From: johanengelen Date: Tue, 8 Apr 2008 17:50:06 +0000 (+0000) Subject: rename LPEPathAlongPath -> LPEBendPath X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=072916d0ef7dccd696b59381f50bcf776abccefb;p=inkscape.git rename LPEPathAlongPath -> LPEBendPath --- diff --git a/src/live_effects/CMakeLists.txt b/src/live_effects/CMakeLists.txt index 57957b88a..d437e40f9 100644 --- a/src/live_effects/CMakeLists.txt +++ b/src/live_effects/CMakeLists.txt @@ -13,8 +13,8 @@ lpeobject.cpp lpeobject.h lpeobject-reference.cpp lpeobject-reference.h -lpe-pathalongpath.cpp -lpe-pathalongpath.h +lpe-bendpath.cpp +lpe-bendpath.h lpe-skeletalstrokes.cpp lpe-skeletalstrokes.h lpe-skeleton.cpp diff --git a/src/live_effects/Makefile_insert b/src/live_effects/Makefile_insert index 4edc2c19f..7d2121c12 100644 --- a/src/live_effects/Makefile_insert +++ b/src/live_effects/Makefile_insert @@ -18,8 +18,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-bendpath.cpp \ + live_effects/lpe-bendpath.h \ live_effects/lpe-sketch.cpp \ live_effects/lpe-sketch.h \ live_effects/lpe-knot.cpp \ diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp index 73f6e3dec..4b3ee5b0f 100644 --- a/src/live_effects/effect.cpp +++ b/src/live_effects/effect.cpp @@ -33,8 +33,7 @@ // include effects: #include "live_effects/lpe-skeletalstrokes.h" -#include "live_effects/lpe-pathalongpath.h" -//here!! +#include "live_effects/lpe-bendpath.h" #include "live_effects/lpe-sketch.h" #include "live_effects/lpe-vonkoch.h" #include "live_effects/lpe-knot.h" @@ -53,7 +52,7 @@ namespace LivePathEffect { const Util::EnumData LPETypeData[INVALID_LPE] = { // {constant defined in effect.h, N_("name of your effect"), "name of your effect in SVG"} - {PATH_ALONG_PATH, N_("Bend Path"), "bend_path"}, + {BEND_PATH, N_("Bend"), "bend_path"}, {SKELETAL_STROKES, N_("Pattern Along Path"), "skeletal"}, {SKETCH, N_("Sketch"), "sketch"}, {VONKOCH, N_("VonKoch"), "vonkoch"}, @@ -77,8 +76,8 @@ Effect::New(EffectType lpenr, LivePathEffectObject *lpeobj) case SKELETAL_STROKES: neweffect = (Effect*) new LPESkeletalStrokes(lpeobj); break; - case PATH_ALONG_PATH: - neweffect = (Effect*) new LPEPathAlongPath(lpeobj); + case BEND_PATH: + neweffect = (Effect*) new LPEBendPath(lpeobj); break; //here!! case SKETCH: diff --git a/src/live_effects/effect.h b/src/live_effects/effect.h index 4293fd854..2f8014cc6 100644 --- a/src/live_effects/effect.h +++ b/src/live_effects/effect.h @@ -51,7 +51,7 @@ namespace NodePath { namespace LivePathEffect { enum EffectType { - PATH_ALONG_PATH = 0, + BEND_PATH = 0, SKELETAL_STROKES, SKETCH, VONKOCH, diff --git a/src/live_effects/lpe-bendpath.cpp b/src/live_effects/lpe-bendpath.cpp new file mode 100644 index 000000000..026c8fb5f --- /dev/null +++ b/src/live_effects/lpe-bendpath.cpp @@ -0,0 +1,211 @@ +#define INKSCAPE_LPE_BENDPATH_CPP + +/* + * Copyright (C) Johan Engelen 2007 + * Copyright (C) Steren Giannini 2008 + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include "live_effects/lpe-bendpath.h" +#include "sp-shape.h" +#include "sp-item.h" +#include "sp-path.h" +#include "sp-item-group.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 { + +LPEBendPath::LPEBendPath(LivePathEffectObject *lpeobject) : + Effect(lpeobject), + bend_path(_("Bend path"), _("Path along which to bend the original path"), "bendpath", &wr, this, "M0,0 L1,0"), + 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), + vertical_pattern(_("Original path is vertical"), _("Rotates the original 90 degrees, before bending it along the bend path"), "vertical", &wr, this, false) +{ + registerParameter( dynamic_cast(&bend_path) ); + registerParameter( dynamic_cast(&prop_scale) ); + registerParameter( dynamic_cast(&scale_y_rel) ); + registerParameter( dynamic_cast(&vertical_pattern) ); + + prop_scale.param_set_digits(3); + prop_scale.param_set_increments(0.01, 0.10); + + groupSpecialBehavior = false; +} + +LPEBendPath::~LPEBendPath() +{ + +} + +void +LPEBendPath::doBeforeEffect (SPLPEItem *lpeitem) +{ + if(SP_IS_GROUP(lpeitem)) + { + groupSpecialBehavior = true; + + using namespace Geom; + Piecewise > pwd2; + std::vector temppath; + + recursive_original_bbox(SP_GROUP(lpeitem), pwd2, temppath); + + for (unsigned int i=0; i < temppath.size(); i++) { + pwd2.concat( temppath[i].toPwSb() ); + } + + D2 > d2pw = make_cuts_independant(pwd2); + boundingbox_X = bounds_exact(d2pw[0]); + boundingbox_Y = bounds_exact(d2pw[1]); + } + +} + + +Geom::Piecewise > +LPEBendPath::doEffect_pwd2 (Geom::Piecewise > & pwd2_in) +{ + using namespace Geom; + +/* Much credit should go to jfb and mgsloan of lib2geom development for the code below! */ + + Piecewise > uskeleton = arc_length_parametrization(Piecewise >(bend_path.get_pwd2()),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]); + +//We use the group bounding box size or the path bbox size to translate well x and y + if(groupSpecialBehavior == false) + { + boundingbox_X = bounds_exact(x); + boundingbox_Y = bounds_exact(y); + } + x-= boundingbox_X.min(); + y-= boundingbox_Y.middle(); + + double scaling = uskeleton.cuts.back()/boundingbox_X.extent(); + + 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; + } + + + Piecewise > output = compose(uskeleton,x) + y*compose(n,x); + return output; +} + +void +LPEBendPath::resetDefaults(SPItem * item) +{ + if (SP_IS_PATH(item) || SP_IS_GROUP(item)) + { + // set the bend path to run horizontally in the middle of the bounding box of the original path + using namespace Geom; + Piecewise > pwd2; + std::vector temppath; + + if (SP_IS_PATH(item)) + { + //TODO : this won't work well with LPE stacking + temppath = SVGD_to_2GeomPath( SP_OBJECT_REPR(item)->attribute("inkscape:original-d")); + } + else if (SP_IS_GROUP(item)) + { + recursive_original_bbox(SP_GROUP(item), pwd2, temppath); + } + + for (unsigned int i=0; i < temppath.size(); i++) { + pwd2.concat( temppath[i].toPwSb() ); + } + + D2 > d2pw = make_cuts_independant(pwd2); + boundingbox_X = bounds_exact(d2pw[0]); + boundingbox_Y = bounds_exact(d2pw[1]); + + + Point start(boundingbox_X.min(), (boundingbox_Y.max()+boundingbox_Y.min())/2); + Point end(boundingbox_X.max(), (boundingbox_Y.max()+boundingbox_Y.min())/2); + + if ( Geom::are_near(start,end) ) { + end += Point(1.,0.); + } + Geom::Path path; + path.start( start ); + path.appendNew( end ); + bend_path.param_set_and_write_new_value( path.toPwSb() ); + + + } +} + +void +LPEBendPath::transform_multiply(Geom::Matrix const& postmul, bool set) +{ + // TODO: implement correct transformation instead of this default behavior + Effect::transform_multiply(postmul, set); +} + + +} // 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-bendpath.h b/src/live_effects/lpe-bendpath.h new file mode 100644 index 000000000..53e580c3a --- /dev/null +++ b/src/live_effects/lpe-bendpath.h @@ -0,0 +1,61 @@ +#ifndef INKSCAPE_LPE_BENDPATH_H +#define INKSCAPE_LPE_BENDPATH_H + +/* + * Inkscape::LPEPathAlongPath + * + * Copyright (C) Johan Engelen 2007 + * Copyright (C) Steren Giannini 2008 + * + * 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" + +#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 "live_effects/lpegroupbbox.h" + +namespace Inkscape { +namespace LivePathEffect { + +//for Bend path on group : we need information concerning the group Bounding box +class LPEBendPath : public Effect, LivePathEffect_group_bbox { +public: + LPEBendPath(LivePathEffectObject *lpeobject); + virtual ~LPEBendPath(); + + virtual void doBeforeEffect (SPLPEItem *lpeitem); + + virtual Geom::Piecewise > doEffect_pwd2 (Geom::Piecewise > & pwd2_in); + + virtual void resetDefaults(SPItem * item); + + virtual void transform_multiply(Geom::Matrix const& postmul, bool set); + +private: + PathParam bend_path; + ScalarParam prop_scale; + BoolParam scale_y_rel; + BoolParam vertical_pattern; + + bool groupSpecialBehavior; + + void on_pattern_pasted(); + + LPEBendPath(const LPEBendPath&); + LPEBendPath& operator=(const LPEBendPath&); +}; + +}; //namespace LivePathEffect +}; //namespace Inkscape + +#endif diff --git a/src/live_effects/lpe-pathalongpath.cpp b/src/live_effects/lpe-pathalongpath.cpp deleted file mode 100644 index d17a0f84f..000000000 --- a/src/live_effects/lpe-pathalongpath.cpp +++ /dev/null @@ -1,211 +0,0 @@ -#define INKSCAPE_LPE_PATHALONGPATH_CPP - -/* - * Copyright (C) Johan Engelen 2007 - * Copyright (C) Steren Giannini 2008 - * - * 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 "sp-path.h" -#include "sp-item-group.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 { - -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"), - 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), - vertical_pattern(_("Original path is vertical"), _("Rotates the original 90 degrees, before bending it along the bend path"), "vertical", &wr, this, false) -{ - registerParameter( dynamic_cast(&bend_path) ); - registerParameter( dynamic_cast(&prop_scale) ); - registerParameter( dynamic_cast(&scale_y_rel) ); - registerParameter( dynamic_cast(&vertical_pattern) ); - - prop_scale.param_set_digits(3); - prop_scale.param_set_increments(0.01, 0.10); - - groupSpecialBehavior = false; -} - -LPEPathAlongPath::~LPEPathAlongPath() -{ - -} - -void -LPEPathAlongPath::doBeforeEffect (SPLPEItem *lpeitem) -{ - if(SP_IS_GROUP(lpeitem)) - { - groupSpecialBehavior = true; - - using namespace Geom; - Piecewise > pwd2; - std::vector temppath; - - recursive_original_bbox(SP_GROUP(lpeitem), pwd2, temppath); - - for (unsigned int i=0; i < temppath.size(); i++) { - pwd2.concat( temppath[i].toPwSb() ); - } - - D2 > d2pw = make_cuts_independant(pwd2); - boundingbox_X = bounds_exact(d2pw[0]); - boundingbox_Y = bounds_exact(d2pw[1]); - } - -} - - -Geom::Piecewise > -LPEPathAlongPath::doEffect_pwd2 (Geom::Piecewise > & pwd2_in) -{ - using namespace Geom; - -/* Much credit should go to jfb and mgsloan of lib2geom development for the code below! */ - - Piecewise > uskeleton = arc_length_parametrization(Piecewise >(bend_path.get_pwd2()),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]); - -//We use the group bounding box size or the path bbox size to translate well x and y - if(groupSpecialBehavior == false) - { - boundingbox_X = bounds_exact(x); - boundingbox_Y = bounds_exact(y); - } - x-= boundingbox_X.min(); - y-= boundingbox_Y.middle(); - - double scaling = uskeleton.cuts.back()/boundingbox_X.extent(); - - 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; - } - - - Piecewise > output = compose(uskeleton,x) + y*compose(n,x); - return output; -} - -void -LPEPathAlongPath::resetDefaults(SPItem * item) -{ - if (SP_IS_PATH(item) || SP_IS_GROUP(item)) - { - // set the bend path to run horizontally in the middle of the bounding box of the original path - using namespace Geom; - Piecewise > pwd2; - std::vector temppath; - - if (SP_IS_PATH(item)) - { - //TODO : this won't work well with LPE stacking - temppath = SVGD_to_2GeomPath( SP_OBJECT_REPR(item)->attribute("inkscape:original-d")); - } - else if (SP_IS_GROUP(item)) - { - recursive_original_bbox(SP_GROUP(item), pwd2, temppath); - } - - for (unsigned int i=0; i < temppath.size(); i++) { - pwd2.concat( temppath[i].toPwSb() ); - } - - D2 > d2pw = make_cuts_independant(pwd2); - boundingbox_X = bounds_exact(d2pw[0]); - boundingbox_Y = bounds_exact(d2pw[1]); - - - Point start(boundingbox_X.min(), (boundingbox_Y.max()+boundingbox_Y.min())/2); - Point end(boundingbox_X.max(), (boundingbox_Y.max()+boundingbox_Y.min())/2); - - if ( Geom::are_near(start,end) ) { - end += Point(1.,0.); - } - Geom::Path path; - path.start( start ); - path.appendNew( end ); - bend_path.param_set_and_write_new_value( path.toPwSb() ); - - - } -} - -void -LPEPathAlongPath::transform_multiply(Geom::Matrix const& postmul, bool set) -{ - // TODO: implement correct transformation instead of this default behavior - Effect::transform_multiply(postmul, set); -} - - -} // 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 deleted file mode 100644 index f1578d5bf..000000000 --- a/src/live_effects/lpe-pathalongpath.h +++ /dev/null @@ -1,61 +0,0 @@ -#ifndef INKSCAPE_LPE_PATHALONGPATH_H -#define INKSCAPE_LPE_PATHALONGPATH_H - -/* - * Inkscape::LPEPathAlongPath - * - * Copyright (C) Johan Engelen 2007 - * Copyright (C) Steren Giannini 2008 - * - * 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" - -#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 "live_effects/lpegroupbbox.h" - -namespace Inkscape { -namespace LivePathEffect { - -//for Bend path on group : we need information concerning the group Bounding box -class LPEPathAlongPath : public Effect, LivePathEffect_group_bbox { -public: - LPEPathAlongPath(LivePathEffectObject *lpeobject); - virtual ~LPEPathAlongPath(); - - virtual void doBeforeEffect (SPLPEItem *lpeitem); - - virtual Geom::Piecewise > doEffect_pwd2 (Geom::Piecewise > & pwd2_in); - - virtual void resetDefaults(SPItem * item); - - virtual void transform_multiply(Geom::Matrix const& postmul, bool set); - -private: - PathParam bend_path; - ScalarParam prop_scale; - BoolParam scale_y_rel; - BoolParam vertical_pattern; - - bool groupSpecialBehavior; - - void on_pattern_pasted(); - - LPEPathAlongPath(const LPEPathAlongPath&); - LPEPathAlongPath& operator=(const LPEPathAlongPath&); -}; - -}; //namespace LivePathEffect -}; //namespace Inkscape - -#endif