![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
index 9b49122fe3b4b322abd3fcaf87b2e05fc92dd00a..f03bac811ef530278f04e6baf1e716cda3707399 100644 (file)
-#define INKSCAPE_LPE_SKETCH_CPP\r
-/** \file\r
- * LPE <sketch> implementation\r
- */\r
-/*\r
- * Authors:\r
- * Johan Engelen\r
-*\r
-* Copyright (C) Johan Engelen 2007 <j.b.c.engelen@utwente.nl>\r
- *\r
- * Released under GNU GPL, read the file 'COPYING' for more information\r
- */\r
-\r
-#include "live_effects/lpe-sketch.h"\r
-#include "display/curve.h"\r
-#include <libnr/n-art-bpath.h>\r
-\r
-// You might need to include other 2geom files. You can add them here:\r
-#include <2geom/path.h>\r
-#include <2geom/sbasis.h>\r
-#include <2geom/sbasis-geometric.h>\r
-#include <2geom/bezier-to-sbasis.h>\r
-#include <2geom/sbasis-to-bezier.h>\r
-#include <2geom/d2.h>\r
-#include <2geom/sbasis-math.h>\r
-#include <2geom/piecewise.h>\r
-#include <2geom/crossing.h>\r
-#include <2geom/path-intersection.h>\r
-\r
-namespace Inkscape {\r
-namespace LivePathEffect {\r
-\r
-LPESketch::LPESketch(LivePathEffectObject *lpeobject) :\r
- Effect(lpeobject),\r
- // initialise your parameters here:\r
- //testpointA(_("Test Point A"), _("Test A"), "ptA", &wr, this, Geom::Point(100,100)),\r
- nbiter_approxstrokes(_("Nb of iterations"), _("Draw that many approximating strokes sequences."), "nbiter_approxstrokes", &wr, this, 5),\r
- strokelength(_("Max stroke length"), _("Maximal length of approximated strokes."), "strokelength", &wr, this, 100.),\r
- strokelength_rdm(_("Randomness"), _("Random variation of stroke length (relative to max. length)."), "strokelength_rdm", &wr, this, .3),\r
- strokeoverlap(_("Max. overlap"), _("How much successive strokes should overlap (relative to max. length)."), "strokeoverlap", &wr, this, .3),\r
- strokeoverlap_rdm(_("Randomness"), _("Random variation of overlap (relative to max. overlap)"), "strokeoverlap_rdm", &wr, this, .3),\r
- ends_tolerance(_("Max. ends tolerance"), _("Max. distance between original and approximated paths ends (relative to max. length)."), "ends_tolerance", &wr, this, .1),\r
- parallel_offset(_("Average offset"), _("Average distance to original stroke(try 0.)."), "parallel_offset", &wr, this, 5.),\r
- tremble_size(_("Max. tremble"), _("Maximal tremble magnitude."), "tremble_size", &wr, this, 5.),\r
- tremble_frequency(_("Tremble frequency"), _("Typical nb of tremble 'period' in a stroke."), "tremble_frequency", &wr, this, 1.),\r
- nbtangents(_("Nb of construction Lines"), _("How many construction lines (tangents) to draw?"), "nbtangents", &wr, this, 5),\r
- tgtscale(_("Scale"), _("Scale factor relating curvature and length of construction lines(try 5*avarage offset) )"), "tgtscale", &wr, this, 10.0),\r
- tgtlength(_("Max. length"), _("Max. length of construction lines."), "tgtlength", &wr, this, 100.0),\r
- tgtlength_rdm(_("Randomness"), _("Random variation of construction lines length."), "tgtlength_rdm", &wr, this, .3)\r
-{\r
- // register all your parameters here, so Inkscape knows which parameters this effect has:\r
- //Add some comment in the UI: *warning* the precise output of this effect might change in future releases!\r
- //convert to path if you want to keep exact output unchanged in future releases...\r
- //registerParameter( dynamic_cast<Parameter *>(&testpointA) );\r
- registerParameter( dynamic_cast<Parameter *>(&nbiter_approxstrokes) );\r
- registerParameter( dynamic_cast<Parameter *>(&strokelength) );\r
- registerParameter( dynamic_cast<Parameter *>(&strokelength_rdm) );\r
- registerParameter( dynamic_cast<Parameter *>(&strokeoverlap) );\r
- registerParameter( dynamic_cast<Parameter *>(&strokeoverlap_rdm) );\r
- registerParameter( dynamic_cast<Parameter *>(&ends_tolerance) );\r
- registerParameter( dynamic_cast<Parameter *>(¶llel_offset) );\r
- registerParameter( dynamic_cast<Parameter *>(&tremble_size) );\r
- registerParameter( dynamic_cast<Parameter *>(&tremble_frequency) );\r
- registerParameter( dynamic_cast<Parameter *>(&nbtangents) );\r
- registerParameter( dynamic_cast<Parameter *>(&tgtscale) );\r
- registerParameter( dynamic_cast<Parameter *>(&tgtlength) );\r
- registerParameter( dynamic_cast<Parameter *>(&tgtlength_rdm) );\r
-\r
-\r
- nbiter_approxstrokes.param_make_integer();\r
- nbiter_approxstrokes.param_set_range(0, NR_HUGE);\r
- strokelength.param_set_range(1, NR_HUGE);\r
- strokelength.param_set_increments(1., 5.);\r
- strokelength_rdm.param_set_range(0, 1.);\r
- strokeoverlap.param_set_range(0, 1.);\r
- strokeoverlap.param_set_increments(0.1, 0.30);\r
- ends_tolerance.param_set_range(0., 1.);\r
- parallel_offset.param_set_range(0, NR_HUGE);\r
- tremble_frequency.param_set_range(0.01, 100.);\r
- tremble_frequency.param_set_increments(.5, 1.5);\r
- strokeoverlap_rdm.param_set_range(0, 1.);\r
-\r
- nbtangents.param_make_integer();\r
- nbtangents.param_set_range(0, NR_HUGE);\r
- tgtscale.param_set_range(0, NR_HUGE);\r
- tgtscale.param_set_increments(.1, .5);\r
- tgtlength.param_set_range(0, NR_HUGE);\r
- tgtlength.param_set_increments(1., 5.);\r
- tgtlength_rdm.param_set_range(0, 1.);\r
-}\r
-\r
-LPESketch::~LPESketch()\r
-{\r
-\r
-}\r
-\r
-/*\r
-Geom::Piecewise<Geom::D2<Geom::SBasis> >\r
-addLinearEnds (Geom::Piecewise<Geom::D2<Geom::SBasis> > & m){\r
- using namespace Geom;\r
- Piecewise<D2<SBasis> > output;\r
- Piecewise<D2<SBasis> > start;\r
- Piecewise<D2<SBasis> > end;\r
- double x,y,vx,vy;\r
-\r
- x = m.segs.front()[0].at0();\r
- y = m.segs.front()[1].at0();\r
- vx = m.segs.front()[0][1][0]+Tri(m.segs.front()[0][0]);\r
- vy = m.segs.front()[1][1][0]+Tri(m.segs.front()[1][0]);\r
- start = Piecewise<D2<SBasis> >(D2<SBasis>(Linear (x-vx,x),Linear (y-vy,y)));\r
- start.offsetDomain(m.cuts.front()-1.);\r
-\r
- x = m.segs.back()[0].at1();\r
- y = m.segs.back()[1].at1();\r
- vx = -m.segs.back()[0][1][1]+Tri(m.segs.back()[0][0]);;\r
- vy = -m.segs.back()[1][1][1]+Tri(m.segs.back()[1][0]);;\r
- end = Piecewise<D2<SBasis> >(D2<SBasis>(Linear (x,x+vx),Linear (y,y+vy)));\r
- //end.offsetDomain(m.cuts.back());\r
-\r
- output = start;\r
- output.concat(m);\r
- output.concat(end);\r
- return output;\r
-}\r
-*/\r
-\r
-//TODO: does this already exist in 2Geom? if not, move this there...\r
-std::vector<Geom::Piecewise<Geom::D2<Geom::SBasis> > > \r
-split_at_discontinuities (Geom::Piecewise<Geom::D2<Geom::SBasis> > & pwsbin, double tol = .0001)\r
-{\r
- using namespace Geom;\r
- std::vector<Piecewise<D2<SBasis> > > ret;\r
- unsigned piece_start = 0;\r
- for (unsigned i=0; i<pwsbin.segs.size(); i++){\r
- if (i==(pwsbin.segs.size()-1) || L2(pwsbin.segs[i].at1()- pwsbin.segs[i+1].at0()) > tol){\r
- Piecewise<D2<SBasis> > piece;\r
- piece.cuts.push_back(pwsbin.cuts[piece_start]);\r
- for (unsigned j = piece_start; j<i+1; j++){\r
- piece.segs.push_back(pwsbin.segs[j]);\r
- piece.cuts.push_back(pwsbin.cuts[j+1]); \r
- }\r
- ret.push_back(piece);\r
- piece_start = i+1;\r
- }\r
- }\r
- return ret;\r
-}\r
-\r
-//This returns a random perturbation. Notice the domain is [s0,s0+first multiple of period>s1]...\r
-Geom::Piecewise<Geom::D2<Geom::SBasis> > \r
-LPESketch::computePerturbation (double s0, double s1){\r
- using namespace Geom;\r
- Piecewise<D2<SBasis> >res;\r
- \r
- //global offset for this stroke.\r
- double offsetX = parallel_offset-parallel_offset.get_value();\r
- double offsetY = parallel_offset-parallel_offset.get_value();\r
- Point A,dA,B,dB,offset = Point(offsetX,offsetY);\r
- //start point A\r
- for (unsigned dim=0; dim<2; dim++){\r
- A[dim] = offset[dim] + 2*tremble_size-tremble_size.get_value();\r
- dA[dim] = 2*tremble_size-tremble_size.get_value();\r
- }\r
- //compute howmany deg 3 sbasis to concat according to frequency.\r
- unsigned count = unsigned((s1-s0)/strokelength*tremble_frequency)+1; \r
- for (unsigned i=0; i<count; i++){\r
- D2<SBasis> perturb = D2<SBasis>();\r
- for (unsigned dim=0; dim<2; dim++){\r
- B[dim] = offset[dim] + 2*tremble_size-tremble_size.get_value();\r
- perturb[dim].push_back(Linear(A[dim],B[dim]));\r
- dA[dim] = dA[dim]-B[dim]+A[dim];\r
- dB[dim] = 2*tremble_size-tremble_size.get_value();\r
- perturb[dim].push_back(Linear(dA[dim],dB[dim]));\r
- }\r
- A = B;\r
- dA = B-A-dB;\r
- res.concat(Piecewise<D2<SBasis> >(perturb));\r
- }\r
- res.setDomain(Interval(s0,s0+count*strokelength/tremble_frequency));\r
- return res;\r
-}\r
-\r
-\r
-// Main effect body...\r
-Geom::Piecewise<Geom::D2<Geom::SBasis> >\r
-LPESketch::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > & pwd2_in)\r
-{\r
- using namespace Geom;\r
- Piecewise<D2<SBasis> > output;\r
-\r
-\r
- //init random parameters.\r
- parallel_offset.resetRandomizer();\r
- strokelength_rdm.resetRandomizer();\r
- strokeoverlap_rdm.resetRandomizer();\r
- tgtlength_rdm.resetRandomizer();\r
-\r
- // some variables for futur use.\r
- // notations will be : t = path time, s = distance from start along the path.\r
- Piecewise<SBasis> pathlength;\r
- std::vector<double> times; \r
- double total_length;\r
-\r
- //TODO: split Construction Lines/Approximated Strokes into two separate effects?\r
-\r
- //----- Approximated Strokes.\r
- //TODO: choose length & offset according to curvature?\r
- \r
- //TODO: retrieve components from path, dont merge to separate afterward! + know if closed!\r
- std::vector<Piecewise<D2<SBasis> > > pieces_in = split_at_discontinuities (pwd2_in);\r
-\r
- //work separately on each component.\r
- for (unsigned pieceidx = 0; pieceidx < pieces_in.size(); pieceidx++){\r
-\r
- Piecewise<D2<SBasis> > piece = pieces_in[pieceidx];\r
- Piecewise<SBasis> piecelength = arcLengthSb(piece,.1);\r
- pathlength.concat(piecelength);\r
- \r
- total_length = piecelength.segs.back().at1()-piecelength.segs.front().at0();\r
-\r
- //TODO: better check this on the Geom::Path.\r
- bool closed = piece.segs.front().at0() == piece.segs.back().at1(); \r
- if (closed){ \r
- piece.concat(piece);\r
- piecelength.concat(piecelength+total_length);\r
- }\r
-\r
- for (unsigned i = 0; i<nbiter_approxstrokes; i++){\r
- //Basic steps: \r
- //- Choose a rdm seg [s0,s1], find coresponding [t0,t1], \r
- //- Pick a rdm perturbation delta(s), collect 'piece(t)+delta(s(t))' over [t0,t1] into output.\r
-\r
- // pick a point where to start the stroke (s0 = dist from start).\r
- double s1=0.,s0 = ends_tolerance*strokelength+0.0001;//the root finder might miss 0. \r
- double t1, t0;\r
- double s0_initial = s0;\r
- bool done = false;// was the end of the component reached?\r
-\r
- while (!done){\r
- // if the start point is already too far... do nothing. (this should not happen!)\r
- assert (s0>=0);//this should not happen!!\r
- if (!closed && s1>total_length - ends_tolerance.get_value()*strokelength) break;\r
- if ( closed && s0>total_length + s0_initial) break;\r
-\r
- times = roots(piecelength-s0); \r
- if (times.size()==0) break;//we should not be there.\r
- t0 = times[0];\r
- \r
- // pick a new end point (s1 = s0 + strokelength).\r
- s1 = s0 + strokelength*(1-strokelength_rdm);\r
- // don't let it go beyond the end of the orgiginal path.\r
- // TODO/FIXME: this might result in short strokes near the end...\r
- if (!closed && s1>total_length-ends_tolerance.get_value()*strokelength){\r
- done = true;\r
- //!!the root solver might miss s1==total_length...\r
- if (s1>total_length){s1 = total_length - ends_tolerance*strokelength-0.0001;}\r
- }\r
- if (closed && s1>total_length + s0_initial){\r
- done = true;\r
- if (closed && s1>2*total_length){s1 = 2*total_length - strokeoverlap*(1-strokeoverlap_rdm)*strokelength-0.0001;}\r
- }\r
- times = roots(piecelength-s1); \r
- if (times.size()==0) break;//we should not be there.\r
- t1 = times[0];\r
- \r
- //pick a rdm perturbation, and collect the perturbed piece into output.\r
- Piecewise<D2<SBasis> > pwperturb = computePerturbation(s0,s1);\r
- pwperturb = compose(pwperturb,portion(piecelength,t0,t1));\r
- output.concat(portion(piece,t0,t1)+pwperturb);\r
- \r
- //step points: s0 = s1 - overlap.\r
- //TODO: make sure this has to end?\r
- s0 = s1 - strokeoverlap*(1-strokeoverlap_rdm)*strokelength;\r
- }\r
- }\r
- }\r
-\r
-\r
- //----- Construction lines.\r
- //TODO: choose places according to curvature?.\r
-\r
- //at this point we have:\r
- //pathlength = arcLengthSb(pwd2_in,.1);\r
- total_length = pathlength.segs.back().at1();\r
- Piecewise<D2<SBasis> > m = pwd2_in;\r
- Piecewise<D2<SBasis> > v = derivative(pwd2_in);\r
- Piecewise<D2<SBasis> > a = derivative(v);\r
- for (unsigned i=0; i<nbtangents; i++){\r
- // pick a point where to draw a tangent (s = dist from start along path).\r
- double s = total_length * ( i + tgtlength_rdm ) / (nbtangents+1.);\r
- times = roots(pathlength-s);\r
- assert(times.size()>0);//there should be one and only one solution!\r
- double t = times[0];\r
- Point m_t = m(t), v_t = v(t), a_t = a(t);\r
- //Compute tgt length according to curvature (not exceeding tgtlength) so that \r
- // dist to origninal curve ~ 4 * (parallel_offset+tremble_size).\r
- //TODO: put this 4 as a parameter in the UI...\r
- //TODO: what if with v=0?\r
- double l = tgtlength*(1-tgtlength_rdm)/v_t.length();\r
- double r = pow(v_t.length(),3)/cross(a_t,v_t);\r
- r = sqrt((2*fabs(r)-tgtscale)*tgtscale)/v_t.length();\r
- l=(r<l)?r:l;\r
- //collect the tgt segment into output.\r
- D2<SBasis> tgt = D2<SBasis>();\r
- for (unsigned dim=0; dim<2; dim++){\r
- tgt[dim] = SBasis(Linear(m_t[dim]-v_t[dim]*l, m_t[dim]+v_t[dim]*l));\r
- }\r
- output.concat(Piecewise<D2<SBasis> >(tgt));\r
- }\r
-\r
-// // -------- Pleins et delies vs courbure ou direction...\r
-// Piecewise<D2<SBasis> > a = derivative(v);\r
-// Piecewise<SBasis> a_cross_n = cross(a,n);\r
-// Piecewise<SBasis> v_dot_n = dot(v,n);\r
-// //Piecewise<D2<SBasis> > rfrac = sectionize(D2<Piecewise<SBasis> >(a_cross_n,v_dot_n));\r
-// //Piecewise<SBasis> h = atan2(rfrac)*para1;\r
-// Piecewise<SBasis> h = reciprocal(curvature(piece))*para1;\r
-//\r
-// // Piecewise<D2<SBasis> > dir = Piecewise<D2<SBasis> >(D2<SBasis>(Linear(0),Linear(-1)));\r
-// // Piecewise<SBasis> h = dot(n,dir)+1.;\r
-// // h *= h*(para1/4.);\r
-//\r
-// n = rot90(n);\r
-// output = piece+h*n;\r
-// output.concat(piece-h*n);\r
-//\r
-// //-----------\r
-\r
- //output.concat(m);\r
- return output;\r
-}\r
-\r
-/* ######################## */\r
-\r
-} //namespace LivePathEffect (setq default-directory "c:/Documents And Settings/jf/Mes Documents/InkscapeSVN")\r
-} /* namespace Inkscape */\r
-\r
-/*\r
- Local Variables:\r
- mode:c++\r
- c-file-style:"stroustrup"\r
- c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))\r
- indent-tabs-mode:nil\r
- fill-column:99\r
- End:\r
-*/\r
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :\r
+/** @file
+ * @brief LPE sketch effect implementation
+ */
+/* Authors:
+ * Jean-Francois Barraud <jf.barraud@gmail.com>
+ * Johan Engelen <j.b.c.engelen@utwente.nl>
+ *
+ * Copyright (C) 2007 Authors
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/lpe-sketch.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/sbasis-math.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(_("Strokes:"), _("Draw that many approximating strokes"), "nbiter_approxstrokes", &wr, this, 5),
+ strokelength(_("Max stroke length:"),
+ _("Maximum length of approximating strokes"), "strokelength", &wr, this, 100.),
+ strokelength_rdm(_("Stroke length variation:"),
+ _("Random variation of stroke length (relative to maximum length)"), "strokelength_rdm", &wr, this, .3),
+ strokeoverlap(_("Max. overlap:"),
+ _("How much successive strokes should overlap (relative to maximum length)"), "strokeoverlap", &wr, this, .3),
+ strokeoverlap_rdm(_("Overlap variation:"),
+ _("Random variation of overlap (relative to maximum overlap)"), "strokeoverlap_rdm", &wr, this, .3),
+ ends_tolerance(_("Max. end tolerance:"),
+ _("Maximum distance between ends of original and approximating paths (relative to maximum length)"), "ends_tolerance", &wr, this, .1),
+ parallel_offset(_("Average offset:"),
+ _("Average distance each stroke is away from the original path"), "parallel_offset", &wr, this, 5.),
+ tremble_size(_("Max. tremble:"),
+ _("Maximum tremble magnitude"), "tremble_size", &wr, this, 5.),
+ tremble_frequency(_("Tremble frequency:"),
+ _("Average number of tremble periods in a stroke"), "tremble_frequency", &wr, this, 1.)
+#ifdef LPE_SKETCH_USE_CONSTRUCTION_LINES
+ ,nbtangents(_("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*offset)"), "tgtscale", &wr, this, 10.0),
+ tgtlength(_("Max. length:"), _("Maximum length of construction lines"), "tgtlength", &wr, this, 100.0),
+ tgtlength_rdm(_("Length variation:"), _("Random variation of the length of construction lines"), "tgtlength_rdm", &wr, this, .3),
+ tgt_places_rdmness(_("Placement randomness:"), _("0: evenly distributed construction lines, 1: purely random placement"), "tgt_places_rdmness", &wr, this, 1.)
+#ifdef LPE_SKETCH_USE_CURVATURE
+ ,min_curvature(_("k_min:"), _("min curvature"), "k_min", &wr, this, 4.0)
+ ,max_curvature(_("k_max:"), _("max curvature"), "k_max", &wr, this, 1000.0)
+#endif
+#endif
+{
+ // 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 *>(¶llel_offset) );
+ registerParameter( dynamic_cast<Parameter *>(&tremble_size) );
+ registerParameter( dynamic_cast<Parameter *>(&tremble_frequency) );
+#ifdef LPE_SKETCH_USE_CONSTRUCTION_LINES
+ registerParameter( dynamic_cast<Parameter *>(&nbtangents) );
+ registerParameter( dynamic_cast<Parameter *>(&tgt_places_rdmness) );
+ registerParameter( dynamic_cast<Parameter *>(&tgtscale) );
+ registerParameter( dynamic_cast<Parameter *>(&tgtlength) );
+ registerParameter( dynamic_cast<Parameter *>(&tgtlength_rdm) );
+#ifdef LPE_SKETCH_USE_CURVATURE
+ registerParameter( dynamic_cast<Parameter *>(&min_curvature) );
+ registerParameter( dynamic_cast<Parameter *>(&max_curvature) );
+#endif
+#endif
+
+ 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.);
+
+#ifdef LPE_SKETCH_USE_CONSTRUCTION_LINES
+ 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.);
+ tgt_places_rdmness.param_set_range(0, 1.);
+ //this is not very smart, but required to avoid having lot of tangents stacked on short components.
+ //Nota: we could specify a density instead of an absolute number, but this would be scale dependant.
+ concatenate_before_pwd2 = true;
+#endif
+}
+
+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;
+}
+*/
+
+
+
+//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 = 2*parallel_offset-parallel_offset.get_value();
+ double offsetY = 2*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;
+ //unsigned count = unsigned((s1-s0)/tremble_frequency)+1;
+
+ for (unsigned i=0; i<count; i++){
+ D2<SBasis> perturb = D2<SBasis>(SBasis(2, Linear()), SBasis(2, Linear()));
+ for (unsigned dim=0; dim<2; dim++){
+ B[dim] = offset[dim] + 2*tremble_size-tremble_size.get_value();
+ perturb[dim][0] = Linear(A[dim],B[dim]);
+ dA[dim] = dA[dim]-B[dim]+A[dim];
+ //avoid dividing by 0. Very short strokes will have ends parallel to the curve...
+ if ( s1-s0 > 1e-2)
+ dB[dim] = -(2*tremble_size-tremble_size.get_value())/(s0-s1)-B[dim]+A[dim];
+ else
+ dB[dim] = -(2*tremble_size-tremble_size.get_value())-B[dim]+A[dim];
+ perturb[dim][1] = Linear(dA[dim],dB[dim]);
+ }
+ dA = B-A-dB;
+ A = B;
+ //dA = B-A-dB;
+ res.concat(Piecewise<D2<SBasis> >(perturb));
+ }
+ res.setDomain(Interval(s0,s0+count*strokelength/tremble_frequency));
+ //res.setDomain(Interval(s0,s0+count*tremble_frequency));
+ return res;
+}
+
+
+// Main effect body...
+Geom::Piecewise<Geom::D2<Geom::SBasis> >
+LPESketch::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)
+{
+ using namespace Geom;
+ //If the input path is empty, do nothing.
+ //Note: this happens when duplicating a 3d box... dunno why.
+ if (pwd2_in.size()==0) return pwd2_in;
+
+ Piecewise<D2<SBasis> > output;
+
+ // some variables for futur use (for construction lines; compute arclength only once...)
+ // notations will be : t = path time, s = distance from start along the path.
+ Piecewise<SBasis> pathlength;
+ double total_length = 0;
+
+ //TODO: split Construction Lines/Approximated Strokes into two separate effects?
+
+ //----- Approximated Strokes.
+ 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);
+ double piece_total_length = piecelength.segs.back().at1()-piecelength.segs.front().at0();
+ pathlength.concat(piecelength + total_length);
+ total_length += piece_total_length;
+
+
+ //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+piece_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!)
+ if (!closed && s1>piece_total_length - ends_tolerance.get_value()*strokelength) break;
+ if ( closed && s0>piece_total_length + s0_initial) break;
+
+ std::vector<double> times;
+ times = roots(piecelength-s0);
+ t0 = times.at(0);//there should be one and only one solution!!
+
+ // 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>piece_total_length-ends_tolerance.get_value()*strokelength){
+ done = true;
+ //!!the root solver might miss s1==piece_total_length...
+ if (s1>piece_total_length){s1 = piece_total_length - ends_tolerance*strokelength-0.0001;}
+ }
+ if (closed && s1>piece_total_length + s0_initial){
+ done = true;
+ if (closed && s1>2*piece_total_length){
+ s1 = 2*piece_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-0.01,s1+0.01);
+ 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)*(s1-s0);
+ }
+ }
+ }
+
+#ifdef LPE_SKETCH_USE_CONSTRUCTION_LINES
+
+ //----- Construction lines.
+ //TODO: choose places according to curvature?.
+
+ //at this point we should have:
+ //pathlength = arcLengthSb(pwd2_in,.1);
+ //total_length = pathlength.segs.back().at1()-pathlength.segs.front().at0();
+ Piecewise<D2<SBasis> > m = pwd2_in;
+ Piecewise<D2<SBasis> > v = derivative(pwd2_in);
+ Piecewise<D2<SBasis> > a = derivative(v);
+
+#ifdef LPE_SKETCH_USE_CURVATURE
+ //---- curvature experiment...(enable
+ Piecewise<SBasis> k = curvature(pwd2_in);
+ OptInterval k_bnds = bounds_exact(abs(k));
+ double k_min = k_bnds->min() + k_bnds->extent() * min_curvature;
+ double k_max = k_bnds->min() + k_bnds->extent() * max_curvature;
+
+ Piecewise<SBasis> bump;
+ //SBasis bump_seg = SBasis( 2, Linear(0) );
+ //bump_seg[1] = Linear( 4. );
+ SBasis bump_seg = SBasis( 1, Linear(1) );
+ bump.push_cut( k_bnds->min() - 1 );
+ bump.push( Linear(0), k_min );
+ bump.push(bump_seg,k_max);
+ bump.push( Linear(0), k_bnds->max()+1 );
+
+ Piecewise<SBasis> repartition = compose( bump, k );
+ repartition = integral(repartition);
+ //-------------------------------
+#endif
+
+ for (unsigned i=0; i<nbtangents; i++){
+
+ // pick a point where to draw a tangent (s = dist from start along path).
+#ifdef LPE_SKETCH_USE_CURVATURE
+ double proba = repartition.firstValue()+ (rand()%100)/100.*(repartition.lastValue()-repartition.firstValue());
+ std::vector<double> times;
+ times = roots(repartition - proba);
+ double t = times.at(0);//there should be one and only one solution!
+#else
+ //double s = total_length * ( i + tgtlength_rdm ) / (nbtangents+1.);
+ double reg_place = total_length * ( i + .5) / ( nbtangents );
+ double rdm_place = total_length * tgt_places_rdmness;
+ double s = ( 1.- tgt_places_rdmness.get_value() ) * reg_place + rdm_place ;
+ std::vector<double> times;
+ times = roots(pathlength-s);
+ double t = times.at(0);//there should be one and only one solution!
+#endif
+ 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));
+ }
+#endif
+
+ return output;
+}
+
+void
+LPESketch::doBeforeEffect (SPLPEItem */*lpeitem*/)
+{
+ //init random parameters.
+ parallel_offset.resetRandomizer();
+ strokelength_rdm.resetRandomizer();
+ strokeoverlap_rdm.resetRandomizer();
+ ends_tolerance.resetRandomizer();
+ tremble_size.resetRandomizer();
+#ifdef LPE_SKETCH_USE_CONSTRUCTION_LINES
+ tgtlength_rdm.resetRandomizer();
+ tgt_places_rdmness.resetRandomizer();
+#endif
+}
+
+/* ######################## */
+
+} //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:fileencoding=utf-8:textwidth=99 :