From 152db6322126c6578de1d122d8fac87522b5b627 Mon Sep 17 00:00:00 2001 From: johanengelen Date: Tue, 30 Oct 2007 22:44:42 +0000 Subject: [PATCH] ok. so NOW the new effect is committed... --- src/live_effects/Makefile_insert | 2 + src/live_effects/lpe-pathalongpath.cpp | 195 +++++++++++++++++++++++++ src/live_effects/lpe-pathalongpath.h | 56 +++++++ 3 files changed, 253 insertions(+) create mode 100644 src/live_effects/lpe-pathalongpath.cpp create mode 100644 src/live_effects/lpe-pathalongpath.h diff --git a/src/live_effects/Makefile_insert b/src/live_effects/Makefile_insert index fcce5721e..2c9192468 100644 --- a/src/live_effects/Makefile_insert +++ b/src/live_effects/Makefile_insert @@ -16,6 +16,8 @@ live_effects_liblive_effects_a_SOURCES = \ live_effects/n-art-bpath-2geom.h \ live_effects/lpe-skeletalstrokes.cpp \ live_effects/lpe-skeletalstrokes.h \ + live_effects/lpe-pathalongpath.cpp \ + live_effects/lpe-pathalongpath.h \ live_effects/lpe-curvestitch.cpp \ live_effects/lpe-curvestitch.h \ live_effects/lpe-gears.cpp \ diff --git a/src/live_effects/lpe-pathalongpath.cpp b/src/live_effects/lpe-pathalongpath.cpp new file mode 100644 index 000000000..0e9be8f16 --- /dev/null +++ b/src/live_effects/lpe-pathalongpath.cpp @@ -0,0 +1,195 @@ +#define INKSCAPE_LPE_PATHALONGPATH_CPP + +/* + * Copyright (C) Johan Engelen 2007 + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include "live_effects/lpe-pathalongpath.h" +#include "sp-shape.h" +#include "sp-item.h" +#include "display/curve.h" +#include +#include +#include "live_effects/n-art-bpath-2geom.h" +#include "svg/svg.h" +#include "ui/widget/scalar.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/piecewise.h> + +#include +using std::vector; + + +/* Theory in e-mail from J.F. Barraud +Let B be the skeleton path, and P the pattern (the path to be deformed). + +P is a map t --> P(t) = ( x(t), y(t) ). +B is a map t --> B(t) = ( a(t), b(t) ). + +The first step is to re-parametrize B by its arc length: this is the parametrization in which a point p on B is located by its distance s from start. One obtains a new map s --> U(s) = (a'(s),b'(s)), that still describes the same path B, but where the distance along B from start to +U(s) is s itself. + +We also need a unit normal to the path. This can be obtained by computing a unit tangent vector, and rotate it by 90°. Call this normal vector N(s). + +The basic deformation associated to B is then given by: + + (x,y) --> U(x)+y*N(x) + +(i.e. we go for distance x along the path, and then for distance y along the normal) + +Of course this formula needs some minor adaptations (as is it depends on the absolute position of P for instance, so a little translation is needed +first) but I think we can first forget about them. +*/ + +namespace Inkscape { +namespace LivePathEffect { + +static const Util::EnumData PAPCopyTypeData[PAPCT_END] = { + {PAPCT_SINGLE, N_("Single"), "single"}, + {PAPCT_SINGLE_STRETCHED, N_("Single, stretched"), "single_stretched"}, + {PAPCT_REPEATED, N_("Repeated"), "repeated"}, + {PAPCT_REPEATED_STRETCHED, N_("Repeated, stretched"), "repeated_stretched"} +}; +static const Util::EnumDataConverter PAPCopyTypeConverter(PAPCopyTypeData, PAPCT_END); + +LPEPathAlongPath::LPEPathAlongPath(LivePathEffectObject *lpeobject) : + Effect(lpeobject), + bend_path(_("Bend path"), _("Path along which to bend the original path"), "bendpath", &wr, this, "M0,0 L1,0"), + copytype(_("Path copies"), _("How many copies to place along the skeleton path"), "copytype", PAPCopyTypeConverter, &wr, this, PAPCT_SINGLE_STRETCHED), + prop_scale(_("Width"), _("Width of the path"), "prop_scale", &wr, this, 1), + scale_y_rel(_("Width in units of length"), _("Scale the width of the path in units of its length"), "scale_y_rel", &wr, this, false), + spacing(_("Spacing"), _("Space between copies of the path"), "spacing", &wr, this, 0), + normal_offset(_("Normal offset"), "", "normal_offset", &wr, this, 0), + tang_offset(_("Tangential offset"), "", "tang_offset", &wr, this, 0), + vertical_pattern(_("Original path is vertical"), "", "vertical", &wr, this, false) +{ + registerParameter( dynamic_cast(&bend_path) ); + registerParameter( dynamic_cast(©type) ); + registerParameter( dynamic_cast(&prop_scale) ); + registerParameter( dynamic_cast(&scale_y_rel) ); +//These parameters have not been implemented yet: +// registerParameter( dynamic_cast(&spacing) ); +// registerParameter( dynamic_cast(&normal_offset) ); +// registerParameter( dynamic_cast(&tang_offset) ); + registerParameter( dynamic_cast(&vertical_pattern) ); + + prop_scale.param_set_digits(3); + prop_scale.param_set_increments(0.01, 0.10); +} + +LPEPathAlongPath::~LPEPathAlongPath() +{ + +} + + +Geom::Piecewise > +LPEPathAlongPath::doEffect (Geom::Piecewise > & pwd2_in) +{ + using namespace Geom; + +/* Much credit should go to jfb and mgsloan of lib2geom development for the code below! */ + + PAPCopyType type = copytype.get_value(); + + Piecewise > uskeleton = arc_length_parametrization(Piecewise >(bend_path),2,.1); + uskeleton = remove_short_cuts(uskeleton,.01); + Piecewise > n = rot90(derivative(uskeleton)); + n = force_continuity(remove_short_cuts(n,.1)); + + D2 > patternd2 = make_cuts_independant(pwd2_in); + Piecewise x = vertical_pattern.get_value() ? Piecewise(patternd2[1]) : Piecewise(patternd2[0]); + Piecewise y = vertical_pattern.get_value() ? Piecewise(patternd2[0]) : Piecewise(patternd2[1]); + Interval pattBnds = bounds_exact(x); + x -= pattBnds.min(); + Interval pattBndsY = bounds_exact(y); + y -= (pattBndsY.max()+pattBndsY.min())/2; + + int nbCopies = int(uskeleton.cuts.back()/pattBnds.extent()); + double scaling = 1; + + switch(type) { + case PAPCT_REPEATED: + break; + + case PAPCT_SINGLE: + nbCopies = (nbCopies > 0) ? 1 : 0; + break; + + case PAPCT_SINGLE_STRETCHED: + nbCopies = 1; + scaling = uskeleton.cuts.back()/pattBnds.extent(); + break; + + case PAPCT_REPEATED_STRETCHED: + scaling = uskeleton.cuts.back()/(((double)nbCopies)*pattBnds.extent()); + break; + + default: + return pwd2_in; + }; + + double pattWidth = pattBnds.extent() * scaling; + + if (scaling != 1.0) { + x*=scaling; + } + if ( scale_y_rel.get_value() ) { + y*=(scaling*prop_scale); + } else { + if (prop_scale != 1.0) y *= prop_scale; + } + + double offs = 0; + Piecewise > output; + for (int i=0; i > pwd2; + std::vector temppath = SVGD_to_2GeomPath( SP_OBJECT_REPR(item)->attribute("inkscape:original-d")); + for (unsigned int i=0; i < temppath.size(); i++) { + pwd2.concat( temppath[i].toPwSb() ); + } + + D2 > d2pw = make_cuts_independant(pwd2); + Interval bndsX = bounds_exact(d2pw[0]); + Interval bndsY = bounds_exact(d2pw[1]); + Point start(bndsX.min(), (bndsY.max()+bndsY.min())/2); + Point end(bndsX.max(), (bndsY.max()+bndsY.min())/2); + + Geom::Path path; + path.start( start ); + path.appendNew( end ); + bend_path.param_set_and_write_new_value( path.toPwSb() ); +} + +} // namespace LivePathEffect +} /* 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 : diff --git a/src/live_effects/lpe-pathalongpath.h b/src/live_effects/lpe-pathalongpath.h new file mode 100644 index 000000000..8cc2251a1 --- /dev/null +++ b/src/live_effects/lpe-pathalongpath.h @@ -0,0 +1,56 @@ +#ifndef INKSCAPE_LPE_PATHALONGPATH_H +#define INKSCAPE_LPE_PATHALONGPATH_H + +/* + * Inkscape::LPEPathAlongPath + * +* Copyright (C) Johan Engelen 2007 + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include "live_effects/effect.h" +#include "live_effects/parameter/path.h" +#include "live_effects/parameter/enum.h" +#include "live_effects/parameter/bool.h" + +namespace Inkscape { +namespace LivePathEffect { + +enum PAPCopyType { + PAPCT_SINGLE = 0, + PAPCT_SINGLE_STRETCHED, + PAPCT_REPEATED, + PAPCT_REPEATED_STRETCHED, + PAPCT_END // This must be last +}; + +class LPEPathAlongPath : public Effect { +public: + LPEPathAlongPath(LivePathEffectObject *lpeobject); + ~LPEPathAlongPath(); + + Geom::Piecewise > doEffect (Geom::Piecewise > & pwd2_in); + + void resetDefaults(SPItem * item); + +private: + PathParam bend_path; + EnumParam copytype; + ScalarParam prop_scale; + BoolParam scale_y_rel; + ScalarParam spacing; + ScalarParam normal_offset; + ScalarParam tang_offset; + BoolParam vertical_pattern; + + void on_pattern_pasted(); + + LPEPathAlongPath(const LPEPathAlongPath&); + LPEPathAlongPath& operator=(const LPEPathAlongPath&); +}; + +}; //namespace LivePathEffect +}; //namespace Inkscape + +#endif -- 2.30.2