Merge lp:~inkscape.dev/inkscape/bend_and_pattern_along_path_width_modified_by_knot into lp:~inkscape.dev/inkscape/trunk

[Jabiertxof]

[lp:~inkscape.dev/inkscape/bend_and_pattern_along_path_width_modified_by_knot]

14274. By Jabiertxof <email address hidden> on 2015-08-05

Fix bug on apply effect from pen/pencil toolbar

14275. By Jabiertxof <email address hidden> on 2015-08-05

update to trunk

14276. By Jabiertxof <email address hidden> on 2015-08-05

update to trunk

14277. By Jabiertxof <email address hidden> on 2015-08-06

fix a bug appliening from patheffect list the LPE

[su_v (suv-lp)]

Testing r14277 (on OS X):

a) Pattern along path LPE: a path with such an LPE applied cannot be moved without unexpected deformation/changes of the LPE width parameter.

Steps to reproduce:
1) launch branch (new default prefs, new default document)
2) switch to the bezier (pen) tool
3) select shape 'Ellipse'
4) draw a simple (straight) line
5) switch to the select tool
6) grab the path and drag it to a new location

--> the width parameter of the path effect changes unexpectedly.

Steps to reproduce:
1) launch branch (new default prefs, new default document)
2) switch to the bezier (pen) tool
3) select shape 'Ellipse'
4) draw a simple (straight) line
5) switch to the node tool
6) select all nodes of the original path (Ctrl+A)
7) grab one of selected nodes and drag the path to a new location

--> AFAIU the width parameter is not (or incorrectly) adjusted, and the path gets badly mangled or disappears completely. If snapping is enabled while dragging the selected nodes, inkscape produces these console messages:
** (inkscape:69451): WARNING **: encountered non finite point when evaluating snapping callback
Dragging the path by its nodes also fails if snapping is disabled globally.

b) The new width parameter added to the Bend LPE is not modified when dragging the path with the select tool, and doesn't act as erratically when node-editing the bend path (Ctrl+A, drag the bend path by grabbing one of the selected nodes): what is somewhat surprising though in initial tests is that the width parameter does not stay fixed relative to the bend path (it does not seem to be fixed relative to the original position either?) when dragging the bend path by its nodes.

review: Needs Fixing

[lp:~inkscape.dev/inkscape/bend_and_pattern_along_path_width_modified_by_knot]

14278. By Jabiertxof <email address hidden> on 2015-08-07

Full refactor of the LPE now too much simple code

14279. By Jabiertxof <email address hidden> on 2015-08-07

update to trunk

14280. By Jabiertxof <email address hidden> on 2015-08-07

update to trunk

14281. By Jabiertxof <email address hidden> on 2015-08-08

update to trunk

[Jabiertxof (jabiertxof)]

Total rewrite the code, now without this bugs and with the code much more simplest.

review: Needs Resubmitting

[lp:~inkscape.dev/inkscape/bend_and_pattern_along_path_width_modified_by_knot]

14282. By Jabiertxof <email address hidden> on 2015-08-08

minor changes

[su_v (suv-lp)]

Both earlier reported issues are fixed with the updated branch (tested with r14282 on OS X 10.7.5).

review: Approve (ui)

[lp:~inkscape.dev/inkscape/bend_and_pattern_along_path_width_modified_by_knot]

14283. By jabiertxof<email address hidden> on 2015-12-08

update to trunk

=== modified file 'src/live_effects/lpe-bendpath.cpp'
--- src/live_effects/lpe-bendpath.cpp	2014-09-29 02:01:20 +0000
+++ src/live_effects/lpe-bendpath.cpp	2015-12-08 11:07:10 +0000
@@ -20,7 +20,13 @@
 #include <2geom/d2.h>
 #include <2geom/piecewise.h>
 
+#include "knot-holder-entity.h"
+#include "knotholder.h"
+
+#include <glibmm/i18n.h>
+
 #include <algorithm>
+
 using std::vector;
 
 
@@ -48,10 +54,21 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
+Geom::PathVector bp_helper_path;
+namespace BeP {
+class KnotHolderEntityWidthBendPath : public LPEKnotHolderEntity {
+    public:
+        KnotHolderEntityWidthBendPath(LPEBendPath * effect) : LPEKnotHolderEntity(effect) {}
+        virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
+        virtual Geom::Point knot_get() const;
+    };
+} // BeP
+
 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),
+    original_height(0.0),
+    prop_scale(_("_Width:"), _("Width of the path"), "prop_scale", &wr, this, 1.0),
     scale_y_rel(_("W_idth 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)
 {
@@ -63,6 +80,7 @@
     prop_scale.param_set_digits(3);
     prop_scale.param_set_increments(0.01, 0.10);
 
+    _provides_knotholder_entities = true;
     concatenate_before_pwd2 = true;
 }
 
@@ -76,7 +94,9 @@
 {
     // get the item bounding box
     original_bbox(lpeitem);
+    original_height = boundingbox_Y.max() - boundingbox_Y.min();
     SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
+    
     item->apply_to_clippath(item);
     item->apply_to_mask(item);
 }
@@ -148,7 +168,61 @@
     bend_path.set_new_value( path.toPwSb(), true );
 }
 
-
+void
+LPEBendPath::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
+{
+    hp_vec.push_back(bp_helper_path);
+}
+
+void 
+LPEBendPath::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+{
+    KnotHolderEntity *e = new BeP::KnotHolderEntityWidthBendPath(this);
+    e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _("Change the width"), SP_KNOT_SHAPE_CIRCLE);
+    knotholder->add(e);
+}
+
+namespace BeP {
+
+void 
+KnotHolderEntityWidthBendPath::knot_set(Geom::Point const &p, Geom::Point const& /*origin*/, guint state)
+{
+    LPEBendPath *lpe = dynamic_cast<LPEBendPath *> (_effect);
+
+    Geom::Point const s = snap_knot_position(p, state);
+    Geom::Path path_in = lpe->bend_path.get_pathvector().pathAt(Geom::PathVectorTime(0, 0, 0.0));
+    Geom::Point ptA = path_in.pointAt(Geom::PathTime(0, 0.0));
+    lpe->prop_scale.param_set_value(Geom::distance(s , ptA)/(lpe->original_height/2.0));
+
+    sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);
+}
+
+Geom::Point 
+KnotHolderEntityWidthBendPath::knot_get() const
+{
+    LPEBendPath *lpe = dynamic_cast<LPEBendPath *> (_effect);
+
+    Geom::Path path_in = lpe->bend_path.get_pathvector().pathAt(Geom::PathVectorTime(0, 0, 0.0));
+    Geom::Point ptA = path_in.pointAt(Geom::PathTime(0, 0.0));
+    Geom::Point B = path_in.pointAt(Geom::PathTime(1, 0.0));
+    Geom::Curve const *first_curve = &path_in.curveAt(Geom::PathTime(0, 0.0));
+    Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*first_curve);
+    Geom::Ray ray(ptA, B);
+    if (cubic) {
+        ray.setPoints(ptA,(*cubic)[1]);
+    }
+    Geom::Angle first_curve_angle = ray.transformed(Geom::Rotate(Geom::deg_to_rad(90))).angle();
+    Geom::Point result_point = Geom::Point::polar(first_curve_angle, (lpe->original_height * lpe->prop_scale)/2.0) + ptA;
+
+    bp_helper_path.clear();
+    Geom::Path hp(result_point);
+    hp.appendNew<Geom::LineSegment>(ptA);
+    bp_helper_path.push_back(hp);
+    hp.clear();
+
+    return result_point;
+}
+} // namespace BeP
 } // namespace LivePathEffect
 } /* namespace Inkscape */
 

=== modified file 'src/live_effects/lpe-bendpath.h'
--- src/live_effects/lpe-bendpath.h	2015-08-05 19:25:52 +0000
+++ src/live_effects/lpe-bendpath.h	2015-12-08 11:07:10 +0000
@@ -27,6 +27,10 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
+namespace BeP {
+class KnotHolderEntityWidthBendPath;
+}
+
 //for Bend path on group : we need information concerning the group Bounding box
 class LPEBendPath : public Effect, GroupBBoxEffect {
 public:
@@ -39,12 +43,19 @@
 
     virtual void resetDefaults(SPItem const* item);
 
-    PathParam  bend_path;
+    void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
+
+    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPDesktop * desktop, SPItem * item);
+
+    PathParam bend_path;
+
+    friend class BeP::KnotHolderEntityWidthBendPath;
+protected:
+    double original_height;
+    ScalarParam prop_scale;
 private:
-    ScalarParam  prop_scale;
     BoolParam scale_y_rel;
-    BoolParam    vertical_pattern;
-
+    BoolParam vertical_pattern;
     Geom::Piecewise<Geom::D2<Geom::SBasis> > uskeleton;
     Geom::Piecewise<Geom::D2<Geom::SBasis> > n;
 

=== modified file 'src/live_effects/lpe-patternalongpath.cpp'
--- src/live_effects/lpe-patternalongpath.cpp	2014-03-27 01:33:44 +0000
+++ src/live_effects/lpe-patternalongpath.cpp	2015-12-08 11:07:10 +0000
@@ -18,6 +18,9 @@
 #include <2geom/d2.h>
 #include <2geom/piecewise.h>
 
+#include "knot-holder-entity.h"
+#include "knotholder.h"
+
 #include <algorithm>
 using std::vector;
 
@@ -45,6 +48,16 @@
 
 namespace Inkscape {
 namespace LivePathEffect {
+Geom::PathVector pap_helper_path;
+
+namespace WPAP {
+    class KnotHolderEntityWidthPatternAlongPath : public LPEKnotHolderEntity {
+    public:
+        KnotHolderEntityWidthPatternAlongPath(LPEPatternAlongPath * effect) : LPEKnotHolderEntity(effect) {}
+        virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
+        virtual Geom::Point knot_get() const;
+    };
+} // WPAP
 
 static const Util::EnumData<PAPCopyType> PAPCopyTypeData[PAPCT_END] = {
     {PAPCT_SINGLE,               N_("Single"),               "single"},
@@ -57,9 +70,10 @@
 LPEPatternAlongPath::LPEPatternAlongPath(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     pattern(_("Pattern source:"), _("Path to put along the skeleton path"), "pattern", &wr, this, "M0,0 L1,0"),
+    original_height(0),
+    prop_scale(_("_Width:"), _("Width of the pattern"), "prop_scale", &wr, this, 1.0),
     copytype(_("Pattern copies:"), _("How many pattern copies to place along the skeleton path"),
         "copytype", PAPCopyTypeConverter, &wr, this, PAPCT_SINGLE_STRETCHED),
-    prop_scale(_("_Width:"), _("Width of the pattern"), "prop_scale", &wr, this, 1),
     scale_y_rel(_("Wid_th in units of length"),
         _("Scale the width of the pattern in units of its length"),
         "scale_y_rel", &wr, this, false),
@@ -87,9 +101,11 @@
     registerParameter( dynamic_cast<Parameter *>(&prop_units) );
     registerParameter( dynamic_cast<Parameter *>(&vertical_pattern) );
     registerParameter( dynamic_cast<Parameter *>(&fuse_tolerance) );
-
     prop_scale.param_set_digits(3);
     prop_scale.param_set_increments(0.01, 0.10);
+
+    _provides_knotholder_entities = true;
+
 }
 
 LPEPatternAlongPath::~LPEPatternAlongPath()
@@ -97,6 +113,16 @@
 
 }
 
+void
+LPEPatternAlongPath::doBeforeEffect (SPLPEItem const* lpeitem)
+{
+    // get the pattern bounding box
+    Geom::OptRect bbox = pattern.get_pathvector().boundsFast();
+    if (bbox) {
+        original_height = (*bbox)[Geom::Y].max() - (*bbox)[Geom::Y].min();
+    }
+}
+
 Geom::Piecewise<Geom::D2<Geom::SBasis> >
 LPEPatternAlongPath::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)
 {
@@ -238,6 +264,68 @@
     }
 }
 
+void
+LPEPatternAlongPath::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
+{
+    hp_vec.push_back(pap_helper_path);
+}
+
+
+void 
+LPEPatternAlongPath::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+{
+    KnotHolderEntity *e = new WPAP::KnotHolderEntityWidthPatternAlongPath(this);
+    e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _("Change the width"), SP_KNOT_SHAPE_CIRCLE);
+    knotholder->add(e);
+}
+
+namespace WPAP {
+
+void 
+KnotHolderEntityWidthPatternAlongPath::knot_set(Geom::Point const &p, Geom::Point const& /*origin*/, guint state)
+{
+    LPEPatternAlongPath *lpe = dynamic_cast<LPEPatternAlongPath *> (_effect);
+    
+    Geom::Point const s = snap_knot_position(p, state);
+    SPShape const *sp_shape = dynamic_cast<SPShape const *>(SP_LPE_ITEM(item));
+    if (sp_shape) {
+        Geom::Path const *path_in = sp_shape->getCurveBeforeLPE()->first_path();
+        Geom::Point ptA = path_in->pointAt(Geom::PathTime(0, 0.0));
+        lpe->prop_scale.param_set_value(Geom::distance(s , ptA)/(lpe->original_height/2.0));
+    }
+    sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);
+}
+
+Geom::Point 
+KnotHolderEntityWidthPatternAlongPath::knot_get() const
+{
+    LPEPatternAlongPath *lpe = dynamic_cast<LPEPatternAlongPath *> (_effect);
+
+    SPShape const *sp_shape = dynamic_cast<SPShape const *>(SP_LPE_ITEM(item));
+    if (sp_shape) {
+        Geom::Path const *path_in = sp_shape->getCurveBeforeLPE()->first_path();
+        Geom::Point ptA = path_in->pointAt(Geom::PathTime(0, 0.0));
+        Geom::Point B = path_in->pointAt(Geom::PathTime(1, 0.0));
+        Geom::Curve const *first_curve = &path_in->curveAt(Geom::PathTime(0, 0.0));
+        Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*first_curve);
+        Geom::Ray ray(ptA, B);
+        if (cubic) {
+            ray.setPoints((*cubic)[1], ptA);
+        }
+        Geom::Angle first_curve_angle = ray.transformed(Geom::Rotate(Geom::deg_to_rad(90))).angle();
+        Geom::Point result_point = Geom::Point::polar(first_curve_angle, (lpe->original_height * lpe->prop_scale)/2.0) + ptA;
+
+        pap_helper_path.clear();
+        Geom::Path hp(result_point);
+        hp.appendNew<Geom::LineSegment>(ptA);
+        pap_helper_path.push_back(hp);
+        hp.clear();
+        
+        return result_point;
+    }
+    return Geom::Point();
+}
+} // namespace WPAP
 } // namespace LivePathEffect
 } /* namespace Inkscape */
 

=== modified file 'src/live_effects/lpe-patternalongpath.h'
--- src/live_effects/lpe-patternalongpath.h	2012-02-12 13:43:17 +0000
+++ src/live_effects/lpe-patternalongpath.h	2015-12-08 11:07:10 +0000
@@ -13,10 +13,15 @@
 #include "live_effects/effect.h"
 #include "live_effects/parameter/path.h"
 #include "live_effects/parameter/bool.h"
+#include "live_effects/parameter/point.h"
 
 namespace Inkscape {
 namespace LivePathEffect {
 
+namespace WPAP {
+class KnotHolderEntityWidthPatternAlongPath;
+}
+
 enum PAPCopyType {
     PAPCT_SINGLE = 0,
     PAPCT_SINGLE_STRETCHED,
@@ -30,14 +35,25 @@
     LPEPatternAlongPath(LivePathEffectObject *lpeobject);
     virtual ~LPEPatternAlongPath();
 
+    virtual void doBeforeEffect (SPLPEItem const* lpeitem);
+
     virtual Geom::Piecewise<Geom::D2<Geom::SBasis> > doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
 
     virtual void transform_multiply(Geom::Affine const& postmul, bool set);
 
+    void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
+
+    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPDesktop * desktop, SPItem * item);
+
     PathParam  pattern;
+
+    friend class WPAP::KnotHolderEntityWidthPatternAlongPath;
+protected:
+    double original_height;
+    ScalarParam prop_scale;
+
 private:
     EnumParam<PAPCopyType> copytype;
-    ScalarParam  prop_scale;
     BoolParam scale_y_rel;
     ScalarParam  spacing;
     ScalarParam  normal_offset;
@@ -45,7 +61,6 @@
     BoolParam    prop_units;
     BoolParam    vertical_pattern;
     ScalarParam  fuse_tolerance;
-
     void on_pattern_pasted();
 
     LPEPatternAlongPath(const LPEPatternAlongPath&);