diff options
Diffstat (limited to 'src/live_effects/lpe-sketch.cpp')
| -rw-r--r-- | src/live_effects/lpe-sketch.cpp | 384 |
1 files changed, 384 insertions, 0 deletions
diff --git a/src/live_effects/lpe-sketch.cpp b/src/live_effects/lpe-sketch.cpp new file mode 100644 index 0000000..802f791 --- /dev/null +++ b/src/live_effects/lpe-sketch.cpp @@ -0,0 +1,384 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/** + * @file + * 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 v2+, 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/sbasis-math.h> +#include <2geom/bezier-to-sbasis.h> +#include <2geom/path-intersection.h> + +// TODO due to internal breakage in glibmm headers, this must be last: +#include <glibmm/i18n.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(&testpointA) ); + registerParameter(&nbiter_approxstrokes); + registerParameter(&strokelength); + registerParameter(&strokelength_rdm); + registerParameter(&strokeoverlap); + registerParameter(&strokeoverlap_rdm); + registerParameter(&ends_tolerance); + registerParameter(¶llel_offset); + registerParameter(&tremble_size); + registerParameter(&tremble_frequency); +#ifdef LPE_SKETCH_USE_CONSTRUCTION_LINES + registerParameter(&nbtangents); + registerParameter(&tgt_places_rdmness); + registerParameter(&tgtscale); + registerParameter(&tgtlength); + registerParameter(&tgtlength_rdm); +#ifdef LPE_SKETCH_USE_CURVATURE + registerParameter(&min_curvature); + registerParameter(&max_curvature); +#endif +#endif + + nbiter_approxstrokes.param_make_integer(); + nbiter_approxstrokes.param_set_range(0, std::numeric_limits<gint>::max()); + strokelength.param_set_range(1, std::numeric_limits<double>::max()); + 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, std::numeric_limits<double>::max()); + 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, std::numeric_limits<gint>::max()); + tgtscale.param_set_range(0, std::numeric_limits<double>::max()); + tgtscale.param_set_increments(.1, .5); + tgtlength.param_set_range(0, std::numeric_limits<double>::max()); + 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. + //Note: we could specify a density instead of an absolute number, but this would be scale dependent. + concatenate_before_pwd2 = true; +#endif +} + +LPESketch::~LPESketch() += default; + +/* +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 (auto piece : pieces_in){ + + 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 corresponding [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 original 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.empty()) 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 original 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 = std::pow(v_t.length(), 3) / cross(v_t, a_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 const*/*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 : |