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

[Jabiertxof]

Add pointwise class to manage "satellite" data in nodes and a add a refactor of fillet-chamfer LPE using it.

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

13704. By Jabiertxof <email address hidden> on 2015-03-31

change pointwise comment

13705. By Jabiertxof <email address hidden> on 2015-03-31

Remove active desktop calls from LPE

13706. By Jabiertxof <email address hidden> on 2015-03-31

fixed hide knots and removed unused headers

13707. By Jabiertxof <email address hidden> on 2015-03-31

removed code comments

[Krzysztof Kosinski (tweenk)]

- 2Geom is a separate library, not part of Inkscape. It should only contain code which is useful outside of Inkscape, and the changes should be submitted to 2Geom.
- 2geom/pointwise.h has a dependency on helper/geom.h, which is unacceptable.
- The Pointwise and Satellite classes are poorly undocumented - I don't understand what they are supposed to do. Are they supposed to some store per-node data? Their interface is rather unintelligible.
- The computational complexity comments are misleading. This code is obviously O(N) in the number of satellites and should either use a map or a simple vector, not a vector of pairs of size_t and Satellite. What is the intended purpose?
- The coding style does not match Inkscape's and is in fact inconsistent even within this patchset (some methods are in snake_case, some local variables are in lowerCamelCase, invalid indent in class definitions, etc.)
- The getters and setters on Satellite are pointless, they could simply be replaced by public fields.
- The way the satellite parameters are stored is very un-XML. I possible, each of the boolean parameters should be a separate attribute.

review: Needs Fixing

[Jabiertxof (jabiertxof)]

Hi Krzysztof thanks for the fast review.
I try to improve all.
Regards.

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

13708. By Jabiertxof <email address hidden> on 2015-04-01

Move 2Geom work to a intermediate positon -helper-
Removed dependency to helper/geom.h
Now use a simple vector, not a vector of pairs of size_t and Satellite
Getters and setters on Satellite removed
Update store parameter to a more friendly string, like powerstroke
Todo:
Documentation and Fix coding style.

13709. By Jabiertxof <email address hidden> on 2015-04-01

More cleanup of code structure.
TODO: Documentation
TODO: Fit code guidelines of Inkscape

13710. By Jabiertxof <email address hidden> on 2015-04-01

add documentation

13711. By Jabiertxof <email address hidden> on 2015-04-01

Added documentation and fix to coding style.

13712. By Jabiertxof <email address hidden> on 2015-04-01

update to trunk

13713. By Jabiertxof <email address hidden> on 2015-04-01

Now open -without conversion- old fillet chamfer objects

13714. By Jabiertxof <email address hidden> on 2015-04-02

add move knots when move nodes pointed by su_v

13715. By Jabiertxof <email address hidden> on 2015-04-02

Adding suport for duplicate nodes
Allow degenrate curves
Show helper path whith original path

13716. By Jabiertxof <email address hidden> on 2015-04-02

update to trunk

13717. By Jabiertxof <email address hidden> on 2015-04-03

Update pathinfo class to allow piecewise and pathvector as input.
Add a method on pointwise to allow update if degenerated curves in new path, not noticed by piecewises

13718. By Jabiertxof <email address hidden> on 2015-04-03

Updated Pathinfo to discrimine degenerate curves optionaly.
Fixed redundant data in are_near from pointwise
Fixed Fillet-Chamfer lpe to allow duplicate nodes

13719. By Jabiertxof <email address hidden> on 2015-04-06

Fix a bug in pathinfo

13720. By Jabiertxof <email address hidden> on 2015-04-06

update to trunk

13721. By Jabiertxof <email address hidden> on 2015-04-06

fixing bug on closed paths

13722. By Jabiertxof <email address hidden> on 2015-04-06

Fixed bug on closed paths, Clenup of pathinfo

[Jabiertxof (jabiertxof)]

Hi Krzysztof, could you review again the branch?
Thanks very much, Jabier.

review: Needs Resubmitting

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

13723. By Jabiertxof <email address hidden> on 2015-04-06

rename pathinfo function

13724. By Jabiertxof <email address hidden> on 2015-04-06

Adding and renaming methofs to pathinfo

13725. By Jabiertxof <email address hidden> on 2015-04-06

added comment

13726. By Jabiertxof <email address hidden> on 2015-04-10

update to trunk

13727. By Jabiertxof <email address hidden> on 2015-04-22

adding suport to full path reverse

13728. By Jabiertxof <email address hidden> on 2015-04-22

update to trunk

13729. By Jabiertxof <email address hidden> on 2015-04-22

prevent overflow index on a pathinfo function

[Krzysztof Kosinski (tweenk)]

There are still a lot of issues that need to be fixed.

I am not sure about the class Pathinfo. I think these functions could be added directly to PathVector, but I'm not sure yet what Pathinfo does.

You should spend some time on writing comments what your code wants to do, it will be easier to review.

review: Needs Fixing

[Jabiertxof (jabiertxof)]

Thanks for the review Krzysztof. I take it soon.

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

13730. By Jabiertxof <email address hidden> on 2015-05-09

update to trunk

13731. By Jabiertxof <email address hidden> on 2015-05-09

fixing review

13732. By Jabiertxof <email address hidden> on 2015-05-09

fixing review

13733. By Jabiertxof <email address hidden> on 2015-05-09

update to trunk

13734. By Jabiertxof <email address hidden> on 2015-05-10

Working on Krzysztof review. Seems to be all fixed.
TODO: double check review and comment

13735. By Jabiertxof <email address hidden> on 2015-05-10

Added some comments

13736. By Jabiertxof <email address hidden> on 2015-05-10

some comments and pointwise related refactor

[Jabiertxof (jabiertxof)]

Hi Krzysztof, could you review again the branch?
Thanks very much, Jabier.

review: Needs Resubmitting

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

13737. By Jabiertxof <email address hidden> on 2015-05-10

fix a minor bug calculating max time

13738. By Jabiertxof <email address hidden> on 2015-05-10

update to trunk

13739. By Jabiertxof <email address hidden> on 2015-06-25

update to trunk

13740. By Jabiertxof <email address hidden> on 2015-06-25

attemp to handle reverse path

13741. By Jabiertxof <email address hidden> on 2015-06-25

update to trunk

13742. By Jabiertxof <email address hidden> on 2015-06-26

removed reverse path, commented why

13743. By Jabiertxof <email address hidden> on 2015-06-26

update to trunk

[Krzysztof Kosinski (tweenk)]

This looks better, but I think I understand what Pathinfo does now, and the whole class is unnecessary. The number of nodes in a Geom::Path is equal to size_closed(), you don't need to reimplement it and you don't need the active attribute in satellites.

I only reviewed a portion of the code - I will try to continue the review during this weekend.

review: Needs Fixing

[Jabiertxof (jabiertxof)]

Thanks Krzysztof for the review. A great new i can use your last work on 2Geom inside Inkscape trunk! Go to fix!

[Jabiertxof (jabiertxof)]

One question Krzysztof, whats the best way to know the first and last subpath curve index on a pathvector?

[Krzysztof Kosinski (tweenk)]

The first subpath is always at index 0. The last one is at size_default() - 1. The number of nodes is always equal to std::max(size_closed(), 1ul): a path that has no segments contains only a naked moveto, and thus has one node. Hope this helps.

[Jabiertxof (jabiertxof)]

> The first subpath is always at index 0. The last one is at size_default() - 1.
> The number of nodes is always equal to std::max(size_closed(), 1ul): a path
> that has no segments contains only a naked moveto, and thus has one node. Hope
> this helps.
Thanks Krzysztof for the quick reply!
Seems I ask bad the question, i want to know the index of start and end index in a intermediate "subpath" not at full pathvector.

Maybe PathVectorTime can also return this value when retrive the value of pathvector index from PathVector->nearestPoint. This solve my problem with start/end of intermediate paths.

Sorry for my bad english.

[Jabiertxof (jabiertxof)]

More, Krzysztof:
I have a new commit with pathinfo class removed. Is working except a small function that need the index of first and last subpath.
Think is better commit it or wait to you to full review current branch?

[Krzysztof Kosinski (tweenk)]

You can commit your new code to this branch and I will try to review both the new code and the parts I didn't review yet.

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

13744. By Jabiertxof <email address hidden> on 2015-07-04

update to trunk

13745. By Jabiertxof <email address hidden> on 2015-07-05

fix to compile on Krzysztof merge previous to fix the improvements in the merge request

13746. By Jabiertxof <email address hidden> on 2015-07-05

Fix a bug displaying arcs

13747. By Jabiertxof <email address hidden> on 2015-07-06

Fixes from branch review

13748. By Jabiertxof <email address hidden> on 2015-07-06

update to trunk

13749. By Jabiertxof <email address hidden> on 2015-07-06

pointwise tweak

13750. By Jabiertxof <email address hidden> on 2015-07-06

astyle

[Jabiertxof (jabiertxof)]

> You can commit your new code to this branch and I will try to review both the
> new code and the parts I didn't review yet.

Commited. Thanks for your time!

review: Needs Resubmitting

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

13751. By Jabiertxof <email address hidden> on 2015-07-24

update to trunk

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

Not sure about this changes :(

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

update to trunk

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

remove couts

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

satellites in curves

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

Cached some functions

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

addes cache and log to a function, result of the test, no diference so remove cache on next commit

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

Removed cache work :(

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

add 'little' comment

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

update to trunk

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

astyle code

13762. By Jabiertxof <email address hidden> on 2015-09-01

update to trunk

13763. By Jabiertxof <email address hidden> on 2015-09-01

Update to limit options to radius = 0, radious > 0 or both

13764. By Jabiertxof <email address hidden> on 2016-03-15

Update to trunk

13765. By Jabiertxof <email address hidden> on 2016-03-15

Fixed bugs post merge

13766. By Jabiertxof <email address hidden> on 2016-03-15

update to trunk

13767. By Jabiertxof <email address hidden> on 2016-03-16

update to trunk

13768. By Jabiertxof <email address hidden> on 2016-03-16

Remove advertaising buttons of old version

13769. By Jabiertxof <email address hidden> on 2016-03-16

update to trunk

13770. By Jabiertxof on 2016-04-08

update to trunk

13771. By Jabiertxof on 2016-04-08

remove a waring on compile

[Krzysztof Kosinski (tweenk)]

This is a little better, but it needs two major changes.

1. Opening a dialog by shift-clicking on a node is completely crazy. There must another way.
2. The doEffect function must be broken down into smaller functions so I can have any hope of understanding what it does.

Moreover, please consider using a vector of vectors for storing satellites. You would not need flat indexing of curves in pathvectors, which is error prone, and your code would be a lot simpler.

review: Needs Fixing

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

13772. By Jabiertxof on 2016-05-08

update to trunk

13773. By Jabiertxof on 2016-05-08

First attempt to make fixed tweenk review

13774. By Jabiertxof on 2016-05-08

update to trunk

13775. By Jabiertxof on 2016-05-10

Working with path updates

13776. By Jabiertxof on 2016-05-10

update to trunk

13777. By Jabiertxof on 2016-05-11

pre-remove of subpath update satellites

13778. By Jabiertxof on 2016-05-13

Fiximg pointwise

13779. By Jabiertxof on 2016-05-14

update to trunk

13780. By Jabiertxof on 2016-05-14

Fixing pointwise

13781. By Jabiertxof on 2016-05-14

update to trunk

13782. By Jabiertxof on 2016-05-15

Fixing pointwise

13783. By Jabiertxof on 2016-05-15

update to trunk

13784. By Jabiertxof on 2016-05-21

Update to refresh knots

13785. By Jabiertxof on 2016-05-21

update to trunk

13786. By Jabiertxof on 2016-05-23

Fixing pointwise

13787. By Jabiertxof on 2016-05-23

update to trunk

13788. By Jabiertxof on 2016-05-26

Fixing pointwise

13789. By Jabiertxof on 2016-05-26

update to trunk

13790. By Jabiertxof on 2016-05-26

Rename branch

13791. By Jabiertxof on 2016-06-11

Fixing satellites bug on erase

13792. By Jabiertxof on 2016-06-11

update to trunk

13793. By Jabiertxof on 2016-06-11

Fix the bug deleting satellites

13794. By Jabiertxof on 2016-06-11

update to trunk

13795. By Jabiertxof on 2016-06-12

Handle path add and remove nodes

13796. By Jabiertxof on 2016-06-12

update to trunk

13797. By Jabiertxof on 2016-06-12

Fix bug consecutive nodes at same position

13798. By Jabiertxof on 2016-06-12

update to trunk

13799. By Jabiertxof on 2016-06-12

Handle both directions on knot reposition

13800. By Jabiertxof on 2016-06-12

Fix 90% of tweenk review

13801. By Jabiertxof on 2016-06-12

update to trunk

13802. By Jabiertxof on 2016-06-14

Add snap to origin in double direction knots

13803. By Jabiertxof on 2016-06-14

update to trunk

13804. By Jabiertxof on 2016-06-18

attemp to simplify doeffect code on fillet chamfer

13805. By Jabiertxof on 2016-06-18

update to trunk

13806. By Jabiertxof on 2016-06-18

Pre fixing selected points

13807. By Jabiertxof on 2016-06-18

fixing bug moving nodes

13808. By Jabiertxof on 2016-06-18

Fixes when moves a path

13809. By Jabiertxof on 2016-06-19

Organize doeffect function

[Jabiertxof (jabiertxof)]

Fix Krzysztof Kosinski review.
Target 0.93

review: Needs Resubmitting

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

13810. By Jabiertxof <jtx@jtx> on 2017-01-21

Update to trunk

13811. By Jabiertxof <jtx@jtx> on 2017-01-22

Update to new code in trunk

13812. By Jabiertxof <jtx@jtx> on 2017-01-22

Update to trunk

13813. By Jabiertxof on 2017-01-25

update to trunk

13814. By Jabiertxof on 2017-01-25

update to trunk

13815. By Jabiertxof <jtx@jtx> on 2017-03-16

Update to trunk

13816. By Jabiertxof <jtx@jtx> on 2017-03-16

Remove some warnings

13817. By Jabiertxof <jtx@jtx> on 2017-03-16

Remove some warnings

13818. By Jabiertxof <jtx@jtx> on 2017-03-16

Update to trunk

[Jabiertxof (jabiertxof)]

Just updated to trunk. Code on trunk about fillet/chamfer need to be replaced by this branch. This is the cause this LPE is not on 0.92.

review: Needs Resubmitting

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

13819. By Jabiertxof on 2017-05-05

Update to trunk

13820. By Jabiertxof <jtx@jtx> on 2017-05-05

Update to trunk

13821. By Jabiertxof <jtx@jtx> on 2017-05-06

Updating code to trunk

13822. By Jabiertxof <jtx@jtx> on 2017-05-06

Pre merge fixing

[Jabiertxof (jabiertxof)]

Merged on r.15666

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2016-12-27 15:49:22 +0000
+++ po/POTFILES.in	2017-05-06 17:46:29 +0000
@@ -153,7 +153,7 @@
 src/live_effects/lpe-vonkoch.cpp
 src/live_effects/parameter/bool.cpp
 src/live_effects/parameter/enum.h
-src/live_effects/parameter/filletchamferpointarray.cpp
+src/live_effects/parameter/satellitearray.cpp
 src/live_effects/parameter/fontbutton.cpp
 src/live_effects/parameter/originalpath.cpp
 src/live_effects/parameter/originalpatharray.cpp

=== modified file 'src/helper/CMakeLists.txt'
--- src/helper/CMakeLists.txt	2015-03-19 01:41:26 +0000
+++ src/helper/CMakeLists.txt	2017-05-06 17:46:29 +0000
@@ -14,6 +14,8 @@
 	geom.cpp
 	geom-nodetype.cpp
 	geom-pathstroke.cpp
+	geom-pathvectorsatellites.cpp
+	geom-satellite.cpp
 	gnome-utils.cpp
 	pixbuf-ops.cpp
 	png-write.cpp
@@ -32,6 +34,8 @@
 	geom-curves.h
 	geom-nodetype.h
 	geom-pathstroke.h
+	geom-pathvectorsatellites.h
+	geom-satellite.h
 	geom.h
 	gnome-utils.h
 	mathfns.h

=== added file 'src/helper/geom-pathvectorsatellites.cpp'
--- src/helper/geom-pathvectorsatellites.cpp	1970-01-01 00:00:00 +0000
+++ src/helper/geom-pathvectorsatellites.cpp	2017-05-06 17:46:29 +0000
@@ -0,0 +1,244 @@
+/**
+ * \file
+ * \brief PathVectorSatellites a class to manage satellites -per node extra data- in a pathvector
+ */ /*
+    * Authors:
+    * Jabiertxof
+    * Nathan Hurst
+    * Johan Engelen
+    * Josh Andler
+    * suv
+    * Mc-
+    * Liam P. White
+    * Krzysztof Kosiński
+    * This code is in public domain
+    */
+
+#include <helper/geom-pathvectorsatellites.h>
+#include "util/units.h"
+
+Geom::PathVector PathVectorSatellites::getPathVector() const
+{
+    return _pathvector;
+}
+
+void PathVectorSatellites::setPathVector(Geom::PathVector pathv)
+{
+    _pathvector = pathv;
+}
+
+Satellites PathVectorSatellites::getSatellites()
+{
+    return _satellites;
+}
+
+void PathVectorSatellites::setSatellites(Satellites satellites)
+{
+    _satellites = satellites;
+}
+
+size_t PathVectorSatellites::getTotalSatellites()
+{
+    size_t counter = 0;
+    for (size_t i = 0; i < _satellites.size(); ++i) {
+        for (size_t j = 0; j < _satellites[i].size(); ++j) {
+            counter++;
+        }
+    }
+    return counter;
+}
+
+std::pair<size_t, size_t> PathVectorSatellites::getIndexData(size_t index)
+{
+    size_t counter = 0;
+    for (size_t i = 0; i < _satellites.size(); ++i) {
+        for (size_t j = 0; j < _satellites[i].size(); ++j) {
+            if (index == counter) {
+                return std::make_pair(i,j);
+            }
+            counter++;
+        }
+    }
+    return std::make_pair(0,0);
+}
+
+void PathVectorSatellites::setSelected(std::vector<size_t> selected)
+{
+    size_t counter = 0;
+    for (size_t i = 0; i < _satellites.size(); ++i) {
+        for (size_t j = 0; j < _satellites[i].size(); ++j) {
+            if (find (selected.begin(), selected.end(), counter) != selected.end()) {
+                _satellites[i][j].setSelected(true);
+            } else {
+                _satellites[i][j].setSelected(false);
+            }
+            counter++;
+        }
+    }
+}
+
+void PathVectorSatellites::updateSteps(size_t steps, bool apply_no_radius, bool apply_with_radius, bool only_selected)
+{
+    for (size_t i = 0; i < _satellites.size(); ++i) {
+        for (size_t j = 0; j < _satellites[i].size(); ++j) {
+            if ((!apply_no_radius && _satellites[i][j].amount == 0) ||
+                (!apply_with_radius && _satellites[i][j].amount != 0)) 
+            {
+                continue;
+            }
+            if (only_selected) {
+                if (_satellites[i][j].selected) {
+                    _satellites[i][j].steps = steps;
+                }
+            } else {
+                _satellites[i][j].steps = steps;
+            }
+        }
+    }
+}
+
+void PathVectorSatellites::updateAmount(double radius, bool apply_no_radius, bool apply_with_radius, bool only_selected, 
+                                         bool use_knot_distance, bool flexible)
+{
+    double power = 0;
+    if (!flexible) {
+        power = radius;
+    } else {
+        power = radius / 100;
+    }
+    for (size_t i = 0; i < _satellites.size(); ++i) {
+        for (size_t j = 0; j < _satellites[i].size(); ++j) {
+            boost::optional<size_t> previous_index = boost::none;
+            if (j == 0 && _pathvector[i].closed()) {
+                previous_index = _pathvector[i].size() - 1;
+            } else if (!_pathvector[i].closed() || j != 0) {
+                previous_index = j - 1;
+            }
+            if (!_pathvector[i].closed() && j == 0) {
+                _satellites[i][j].amount = 0;
+                continue;
+            }
+            if (_pathvector[i].size() == j) {
+                continue;
+            }
+            if ((!apply_no_radius && _satellites[i][j].amount == 0) ||
+                (!apply_with_radius && _satellites[i][j].amount != 0)) 
+            {
+                continue;
+            }
+            
+            Geom::Point satellite_point = _pathvector[i].pointAt(j);
+            if (_satellites[i][j].selected || !only_selected) {
+                if (!use_knot_distance && !flexible) {
+                    if (previous_index) {
+                        _satellites[i][j].amount = _satellites[i][j].radToLen(power, _pathvector[i][*previous_index], _pathvector[i][j]);
+                        if (power && !_satellites[i][j].amount) {
+                            g_warning("Seems a too high radius value");
+                        }
+                    } else {
+                        _satellites[i][j].amount = 0.0;
+                    }
+                } else {
+                    _satellites[i][j].amount = power;
+                }
+            }
+        }
+    }
+}
+
+void PathVectorSatellites::convertUnit(Glib::ustring in, Glib::ustring to, bool apply_no_radius, bool apply_with_radius)
+{
+    for (size_t i = 0; i < _satellites.size(); ++i) {
+        for (size_t j = 0; j < _satellites[i].size(); ++j) {
+            if (!_pathvector[i].closed() && j == 0) {
+                _satellites[i][j].amount = 0;
+                continue;
+            }
+            if (_pathvector[i].size() == j) {
+                continue;
+            }
+            if ((!apply_no_radius && _satellites[i][j].amount == 0) ||
+                (!apply_with_radius && _satellites[i][j].amount != 0)) 
+            {
+                continue;
+            }
+            _satellites[i][j].amount = Inkscape::Util::Quantity::convert(_satellites[i][j].amount, in.c_str(), to.c_str());
+        }
+    }
+}
+
+void PathVectorSatellites::updateSatelliteType(SatelliteType satellitetype, bool apply_no_radius, bool apply_with_radius,
+                                               bool only_selected)
+{
+    for (size_t i = 0; i < _satellites.size(); ++i) {
+        for (size_t j = 0; j < _satellites[i].size(); ++j) {
+            if ((!apply_no_radius && _satellites[i][j].amount == 0) ||
+                (!apply_with_radius && _satellites[i][j].amount != 0)) 
+            {
+                continue;
+            }
+            if (_pathvector[i].size() == j) {
+                if (!only_selected) {
+                    _satellites[i][j].satellite_type = satellitetype;
+                }
+                continue;
+            }
+            if (only_selected) {
+                Geom::Point satellite_point = _pathvector[i].pointAt(j);
+                if (_satellites[i][j].selected) {
+                    _satellites[i][j].satellite_type = satellitetype;
+                }
+            } else {
+                _satellites[i][j].satellite_type = satellitetype;
+            }
+        }
+    }
+}
+
+void PathVectorSatellites::recalculateForNewPathVector(Geom::PathVector const pathv, Satellite const S)
+{
+    Satellites satellites;
+    bool found = false;
+    //TODO evaluate fix on nodes at same position
+    size_t number_nodes = pathv.nodes().size();
+    size_t previous_number_nodes = _pathvector.nodes().size();
+    for (size_t i = 0; i < pathv.size(); i++) {
+        std::vector<Satellite> path_satellites;
+        for (size_t j = 0; j < pathv[i].size_closed(); j++) {
+            found = false;
+            for (size_t k = 0; k < _pathvector.size(); k++) {
+                for (size_t l = 0; l < _pathvector[k].size_closed(); l++) {
+                    if (Geom::are_near(_pathvector[k][l].initialPoint(),  pathv[i][j].initialPoint()))
+                    {
+                        path_satellites.push_back(_satellites[k][l]);
+                        found = true;
+                        break;
+                    }
+                }
+                if (found) {
+                    break;
+                }
+            }
+            
+            if (!found && previous_number_nodes < number_nodes) {
+                path_satellites.push_back(S);
+            }
+        }
+        satellites.push_back(path_satellites);
+    }
+    setPathVector(pathv);
+    setSatellites(satellites);
+}
+
+/*
+  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
+// :

=== added file 'src/helper/geom-pathvectorsatellites.h'
--- src/helper/geom-pathvectorsatellites.h	1970-01-01 00:00:00 +0000
+++ src/helper/geom-pathvectorsatellites.h	2017-05-06 17:46:29 +0000
@@ -0,0 +1,58 @@
+/**
+ * \file
+ * \brief PathVectorSatellites a class to manage satellites -per node extra data- in a pathvector
+ */ /*
+    * Authors:
+    * Jabiertxof
+    * Nathan Hurst
+    * Johan Engelen
+    * Josh Andler
+    * suv
+    * Mc-
+    * Liam P. White
+    * Krzysztof Kosiński
+    * This code is in public domain
+    */
+
+#ifndef SEEN_PATHVECTORSATELLITES_H
+#define SEEN_PATHVECTORSATELLITES_H
+
+#include <helper/geom-satellite.h>
+#include <2geom/path.h>
+#include <2geom/pathvector.h>
+
+typedef std::vector<std::vector<Satellite> > Satellites;
+///@brief PathVectorSatellites a class to manage satellites in a pathvector
+class PathVectorSatellites {
+public:
+    Geom::PathVector getPathVector() const;
+    void setPathVector(Geom::PathVector pathv);
+    Satellites getSatellites();
+    void setSatellites(Satellites satellites);
+    size_t getTotalSatellites();
+    void setSelected(std::vector<size_t> selected);
+    void updateSteps(size_t steps, bool apply_no_radius, bool apply_with_radius, bool only_selected);
+    void updateAmount(double radius, bool apply_no_radius, bool apply_with_radius, bool only_selected, 
+                      bool use_knot_distance, bool flexible);
+    void convertUnit(Glib::ustring in, Glib::ustring to, bool apply_no_radius, bool apply_with_radius);
+    void updateSatelliteType(SatelliteType satellitetype, bool apply_no_radius, bool apply_with_radius, bool only_selected);
+    std::pair<size_t, size_t> getIndexData(size_t index);
+    void recalculateForNewPathVector(Geom::PathVector const pathv, Satellite const S);
+private:
+    Geom::PathVector _pathvector;
+    Satellites _satellites;
+};
+
+#endif //SEEN_PATHVECTORSATELLITES_H
+/*
+  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
+// :

=== added file 'src/helper/geom-satellite.cpp'
--- src/helper/geom-satellite.cpp	1970-01-01 00:00:00 +0000
+++ src/helper/geom-satellite.cpp	2017-05-06 17:46:29 +0000
@@ -0,0 +1,245 @@
+/**
+ * \file
+ * \brief Satellite a per node holder of data.
+ */ /*
+    * Authors:
+    * 2015 Jabier Arraiza Cenoz<[e-mail]>
+    *
+    * This code is in public domain
+    */
+
+#include <helper/geom-satellite.h>
+#include <2geom/curve.h>
+#include <2geom/nearest-time.h>
+#include <2geom/path-intersection.h>
+#include <2geom/sbasis-to-bezier.h>
+#include <2geom/ray.h>
+#include <boost/optional.hpp>
+//log cache
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <sys/time.h>
+#include <ctime>
+#endif
+
+///@brief Satellite a per node holder of data.
+Satellite::Satellite() {}
+
+
+Satellite::Satellite(SatelliteType satellite_type)
+    : satellite_type(satellite_type),
+      is_time(false),
+      selected(false),
+      has_mirror(false),
+      hidden(true),
+      amount(0.0),
+      angle(0.0),
+      steps(0)
+{}
+
+Satellite::~Satellite() {}
+
+///Calculate the time in curve_in with a size of A
+//TODO: find a better place to it
+double timeAtArcLength(double const A, Geom::Curve const &curve_in)
+{
+    if ( A == 0 || curve_in.isDegenerate()) {
+        return 0;
+    }
+
+    Geom::D2<Geom::SBasis> d2_in = curve_in.toSBasis();
+    double t = 0;
+    double length_part = curve_in.length();
+    if (A >= length_part || curve_in.isLineSegment()) {
+        if (length_part != 0) {
+            t = A / length_part;
+        }
+    } else if (!curve_in.isLineSegment()) {
+        std::vector<double> t_roots = roots(Geom::arcLengthSb(d2_in) - A);
+        if (!t_roots.empty()) {
+            t = t_roots[0];
+        }
+    }
+    return t;
+}
+
+///Calculate the size in curve_in with a point at A
+//TODO: find a better place to it
+double arcLengthAt(double const A, Geom::Curve const &curve_in)
+{
+    if ( A == 0 || curve_in.isDegenerate()) {
+        return 0;
+    }
+
+    double s = 0;
+    double length_part = curve_in.length();
+    if (A > length_part || curve_in.isLineSegment()) {
+        s = (A * length_part);
+    } else if (!curve_in.isLineSegment()) {
+        Geom::Curve *curve = curve_in.portion(0.0, A);
+        s = curve->length();
+        delete curve;
+    }
+    return s;
+}
+
+///Convert a arc radius of a fillet/chamfer to his satellite length -point position where fillet/chamfer knot be on original curve
+double Satellite::radToLen(
+    double const A, Geom::Curve const &curve_in,
+    Geom::Curve const &curve_out) const
+{
+    double len = 0;
+    Geom::D2<Geom::SBasis> d2_in = curve_in.toSBasis();
+    Geom::D2<Geom::SBasis> d2_out = curve_out.toSBasis();
+    Geom::Piecewise<Geom::D2<Geom::SBasis> > offset_curve0 = 
+        Geom::Piecewise<Geom::D2<Geom::SBasis> >(d2_in) +
+        rot90(unitVector(derivative(d2_in))) * (A);
+    Geom::Piecewise<Geom::D2<Geom::SBasis> > offset_curve1 =
+        Geom::Piecewise<Geom::D2<Geom::SBasis> >(d2_out) +
+        rot90(unitVector(derivative(d2_out))) * (A);
+    Geom::Path p0 = path_from_piecewise(offset_curve0, 0.1)[0];
+    Geom::Path p1 = path_from_piecewise(offset_curve1, 0.1)[0];
+    Geom::Crossings cs = Geom::crossings(p0, p1);
+    if (cs.size() > 0) {
+        Geom::Point cp = p0(cs[0].ta);
+        double p0pt = nearest_time(cp, curve_out);
+        len = arcLengthAt(p0pt, curve_out);
+    } else {
+        if (A > 0) {
+            len = radToLen(A * -1, curve_in, curve_out);
+        }
+    }
+    return len;
+}
+
+///Convert a satelite length -point position where fillet/chamfer knot be on original curve- to a arc radius of fillet/chamfer
+double Satellite::lenToRad(
+    double const A, Geom::Curve const &curve_in,
+    Geom::Curve const &curve_out,
+    Satellite const previousSatellite) const
+{
+    double time_in = (previousSatellite).time(A, true, curve_in);
+    double time_out = timeAtArcLength(A, curve_out);
+    Geom::Point start_arc_point = curve_in.pointAt(time_in);
+    Geom::Point end_arc_point = curve_out.pointAt(time_out);
+    Geom::Curve *knot_curve1 = curve_in.portion(0, time_in);
+    Geom::Curve *knot_curve2 = curve_out.portion(time_out, 1);
+    Geom::CubicBezier const *cubic1 = dynamic_cast<Geom::CubicBezier const *>(&*knot_curve1);
+    Geom::Ray ray1(start_arc_point, curve_in.pointAt(1));
+    if (cubic1) {
+        ray1.setPoints((*cubic1)[2], start_arc_point);
+    }
+    Geom::CubicBezier const *cubic2 = dynamic_cast<Geom::CubicBezier const *>(&*knot_curve2);
+    Geom::Ray ray2(curve_out.pointAt(0), end_arc_point);
+    if (cubic2) {
+        ray2.setPoints(end_arc_point, (*cubic2)[1]);
+    }
+    bool ccw_toggle = cross(curve_in.pointAt(1) - start_arc_point,
+                           end_arc_point - start_arc_point) < 0;
+    double distance_arc =
+        Geom::distance(start_arc_point, middle_point(start_arc_point, end_arc_point));
+    double angle = angle_between(ray1, ray2, ccw_toggle);
+    double divisor = std::sin(angle / 2.0);
+    if (divisor > 0) {
+        return distance_arc / divisor;
+    }
+    return 0;
+}
+
+///Get the time position of the satellite in curve_in
+double Satellite::time(Geom::Curve const &curve_in, bool inverse) const
+{
+    double t = amount;
+    if (!is_time) {
+        t = time(t, inverse, curve_in);
+    } else if (inverse) {
+        t = 1-t;
+    }
+    if (t > 1) {
+        t = 1;
+    }
+    return t;
+}
+
+///Get the time from a length A in other curve, a bolean inverse gived to reverse time
+double Satellite::time(double A, bool inverse,
+                       Geom::Curve const &curve_in) const
+{
+    if (A == 0 && inverse) {
+        return 1;
+    }
+    if (A == 0 && !inverse) {
+        return 0;
+    }
+    if (!inverse) {
+        return timeAtArcLength(A, curve_in);
+    }
+    double length_part = curve_in.length();
+    A = length_part - A;
+    return timeAtArcLength(A, curve_in);
+}
+
+///Get the length of the satellite in curve_in
+double Satellite::arcDistance(Geom::Curve const &curve_in) const
+{
+    double s = amount;
+    if (is_time) {
+        s = arcLengthAt(s, curve_in);
+    }
+    return s;
+}
+
+///Get the point position of the satellite
+Geom::Point Satellite::getPosition(Geom::Curve const &curve_in, bool inverse) const
+{
+    double t = time(curve_in, inverse);
+    return curve_in.pointAt(t);
+}
+
+///Set the position of the satellite from a gived point P
+void Satellite::setPosition(Geom::Point const p, Geom::Curve const &curve_in, bool inverse)
+{
+    Geom::Curve * curve = const_cast<Geom::Curve *>(&curve_in);
+    if (inverse) {
+        curve = curve->reverse();
+    }
+    double A = Geom::nearest_time(p, *curve);
+    if (!is_time) {
+        A = arcLengthAt(A, *curve);
+    }
+    amount = A;
+}
+
+
+///Map a satellite type with gchar
+void Satellite::setSatelliteType(gchar const *A)
+{
+    std::map<std::string, SatelliteType> gchar_map_to_satellite_type =
+        boost::assign::map_list_of("F", FILLET)("IF", INVERSE_FILLET)("C", CHAMFER)("IC", INVERSE_CHAMFER)("KO", INVALID_SATELLITE);
+    std::map<std::string, SatelliteType>::iterator it = gchar_map_to_satellite_type.find(std::string(A));
+    if (it != gchar_map_to_satellite_type.end()) {
+        satellite_type = it->second;
+    }
+}
+
+///Map a gchar with satelliteType
+gchar const *Satellite::getSatelliteTypeGchar() const
+{
+    std::map<SatelliteType, gchar const *> satellite_type_to_gchar_map =
+        boost::assign::map_list_of(FILLET, "F")(INVERSE_FILLET, "IF")(CHAMFER, "C")(INVERSE_CHAMFER, "IC")(INVALID_SATELLITE, "KO");
+    return satellite_type_to_gchar_map.at(satellite_type);
+}
+
+/*
+  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
+// :

=== added file 'src/helper/geom-satellite.h'
--- src/helper/geom-satellite.h	1970-01-01 00:00:00 +0000
+++ src/helper/geom-satellite.h	2017-05-06 17:46:29 +0000
@@ -0,0 +1,110 @@
+/**
+ * \file
+ * \brief Satellite a per node holder of data.
+ */ /*
+    * Authors:
+    * 2015 Jabier Arraiza Cenoz<[e-mail]>
+    *
+    * This code is in public domain
+    */
+
+#ifndef SEEN_SATELLITE_H
+#define SEEN_SATELLITE_H
+
+#include <map>
+#include <boost/assign.hpp>
+#include <2geom/sbasis-geometric.h>
+#include "util/enums.h"
+
+
+enum SatelliteType {
+    FILLET = 0, //Fillet
+    INVERSE_FILLET,    //Inverse Fillet
+    CHAMFER,     //Chamfer
+    INVERSE_CHAMFER,    //Inverse Chamfer
+    INVALID_SATELLITE     // Invalid Satellite
+};
+/**
+ * @brief Satellite a per node holder of data.
+ */
+
+class Satellite {
+public:
+
+    Satellite();
+    Satellite(SatelliteType satellite_type);
+
+    virtual ~Satellite();
+    void setIsTime(bool set_is_time)
+    {
+        is_time = set_is_time;
+    }
+    void setSelected(bool set_selected)
+    {
+        selected = set_selected;
+    }
+    void setHasMirror(bool set_has_mirror)
+    {
+        has_mirror = set_has_mirror;
+    }
+    void setHidden(bool set_hidden)
+    {
+        hidden = set_hidden;
+    }
+    void setAmount(bool set_amount)
+    {
+        amount = set_amount;
+    }
+    void setAngle(bool set_angle)
+    {
+        angle = set_angle;
+    }
+    void setSteps(bool set_steps)
+    {
+        steps = set_steps;
+    }
+    double lenToRad(double const A, Geom::Curve const &curve_in,
+                    Geom::Curve const &curve_out,
+                    Satellite const previousSatellite) const;
+    double radToLen(double const A, Geom::Curve const &curve_in,
+                    Geom::Curve const &curve_out) const;
+
+    double time(Geom::Curve const &curve_in, bool inverse = false) const;
+    double time(double A, bool inverse, Geom::Curve const &curve_in) const;
+    double arcDistance(Geom::Curve const &curve_in) const;
+
+    void setPosition(Geom::Point const p, Geom::Curve const &curve_in, bool inverse = false);
+    Geom::Point getPosition(Geom::Curve const &curve_in, bool inverse = false) const;
+
+    void setSatelliteType(gchar const *A);
+    gchar const *getSatelliteTypeGchar() const;
+    SatelliteType satellite_type;
+    //The value stored could be a time value of the satellite in the curve or a lenght of distance to the node from the satellite
+    //"is_time" tell is if is a time or lenght value
+    bool is_time;
+    bool selected;
+    bool has_mirror;
+    bool hidden;
+    //in "amount" we store the time or distance used in the satellite
+    double amount;
+    double angle;
+    size_t steps;
+};
+
+double timeAtArcLength(double const A, Geom::Curve const &curve_in);
+double arcLengthAt(double const A, Geom::Curve const &curve_in);
+
+#endif // SEEN_SATELLITE_H
+
+/*
+  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
+// :

=== modified file 'src/knotholder.h'
--- src/knotholder.h	2016-07-30 17:04:34 +0000
+++ src/knotholder.h	2017-05-06 17:46:29 +0000
@@ -30,7 +30,8 @@
 }
 namespace LivePathEffect {
 class PowerStrokePointArrayParamKnotHolderEntity;
-class FilletPointArrayParamKnotHolderEntity;
+class SatellitesArrayParam;
+class FilletChamferKnotHolderEntity;
 }
 }
 
@@ -63,7 +64,7 @@
 
     friend class Inkscape::UI::ShapeEditor; // FIXME why?
     friend class Inkscape::LivePathEffect::PowerStrokePointArrayParamKnotHolderEntity; // why?
-    friend class Inkscape::LivePathEffect::FilletPointArrayParamKnotHolderEntity; // why?
+    friend class Inkscape::LivePathEffect::FilletChamferKnotHolderEntity; // why?
 
 protected:
 

=== modified file 'src/live_effects/CMakeLists.txt'
--- src/live_effects/CMakeLists.txt	2017-01-24 09:44:10 +0000
+++ src/live_effects/CMakeLists.txt	2017-05-06 17:46:29 +0000
@@ -59,7 +59,6 @@
 
 	parameter/array.cpp
 	parameter/bool.cpp
-	parameter/filletchamferpointarray.cpp
 	parameter/item-reference.cpp
 	parameter/item.cpp
 	parameter/originalitem.cpp
@@ -70,6 +69,7 @@
 	parameter/path.cpp
 	parameter/point.cpp
 	parameter/powerstrokepointarray.cpp
+	parameter/satellitesarray.cpp
 	parameter/random.cpp
 	parameter/text.cpp
 	parameter/fontbutton.cpp
@@ -144,7 +144,6 @@
 	parameter/array.h
 	parameter/bool.h
 	parameter/enum.h
-	parameter/filletchamferpointarray.h
 	parameter/item.h
 	parameter/item-reference.h
 	parameter/originalitem.h
@@ -155,6 +154,7 @@
 	parameter/path.h
 	parameter/point.h
 	parameter/powerstrokepointarray.h
+	parameter/satellitesarray.h
 	parameter/random.h
 	parameter/text.h
 	parameter/fontbutton.h

=== modified file 'src/live_effects/effect.cpp'
--- src/live_effects/effect.cpp	2017-05-05 14:45:16 +0000
+++ src/live_effects/effect.cpp	2017-05-06 17:46:29 +0000
@@ -101,7 +101,6 @@
     {RECURSIVE_SKELETON,    N_("Recursive skeleton"),              "recursive_skeleton"},
     {TANGENT_TO_CURVE,      N_("Tangent to curve"),                "tangent_to_curve"},
     {TEXT_LABEL,            N_("Text label"),                      "text_label"},
-    {FILLET_CHAMFER,        N_("Fillet/Chamfer"),                  "fillet_chamfer"},
 #endif
 /* 0.46 */
     {BEND_PATH,             N_("Bend"),                            "bend_path"},
@@ -142,6 +141,7 @@
     {BOUNDING_BOX,          N_("Bounding Box"),                    "bounding_box"},
 /* 9.93 */
     {MEASURE_LINE,          N_("Measure Line"),                    "measure_line"},
+    {FILLET_CHAMFER,        N_("Fillet/Chamfer"),                  "fillet_chamfer"},
 };
 const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
 

=== modified file 'src/live_effects/lpe-fillet-chamfer.cpp'
--- src/live_effects/lpe-fillet-chamfer.cpp	2017-04-28 19:42:36 +0000
+++ src/live_effects/lpe-fillet-chamfer.cpp	2017-05-06 17:46:29 +0000
@@ -4,86 +4,131 @@
  *
  * Copyright (C) 2014 Author(s)
  *
- * Special thanks to Johan Engelen for the base of the effect -powerstroke-
- * Also to ScislaC for point me to the idea
- * Also su_v for his construvtive feedback and time
- * Also to Mc- (IRC nick) for his important contribution to find real time
- * values based on
- * and finaly to Liam P. White for his big help on coding, that save me a lot of hours
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
+
 #include "live_effects/lpe-fillet-chamfer.h"
- 
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/elliptical-arc.h>
-
+#include "helper/geom.h"
 #include "display/curve.h"
-#include "helper/geom-nodetype.h"
 #include "helper/geom-curves.h"
-#include "helper/geom.h"
+#include "helper/geom-satellite.h"
+#include <2geom/elliptical-arc.h>
+#include "knotholder.h"
+#include <boost/optional.hpp>
 
-// for programmatically updating knots
-#include "ui/tools-switch.h"
 // TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
-using namespace Geom;
 namespace Inkscape {
 namespace LivePathEffect {
 
-static const Util::EnumData<FilletMethod> FilletMethodData[FM_END] = {
-    { FM_AUTO, N_("Auto"), "auto" },
+static const Util::EnumData<Filletmethod> FilletmethodData[] = {
+    { FM_AUTO, N_("Auto"), "auto" }, 
     { FM_ARC, N_("Force arc"), "arc" },
     { FM_BEZIER, N_("Force bezier"), "bezier" }
 };
-static const Util::EnumDataConverter<FilletMethod>
-FMConverter(FilletMethodData, FM_END);
-
-const double tolerance = 0.001;
-const double gapHelper = 0.00001;
-
-LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject) :
-    Effect(lpeobject),
-    fillet_chamfer_values(_("Fillet point"), _("Fillet point"), "fillet_chamfer_values", &wr, this),
-    hide_knots(_("Hide knots"), _("Hide knots"), "hide_knots", &wr, this, false),
-    ignore_radius_0(_("Ignore 0 radius knots"), _("Ignore 0 radius knots"), "ignore_radius_0", &wr, this, false),
-    only_selected(_("Change only selected nodes"), _("Change only selected nodes"), "only_selected", &wr, this, false),
-    flexible(_("Flexible radius size (%)"), _("Flexible radius size (%)"), "flexible", &wr, this, false),
-    use_knot_distance(_("Use knots distance instead radius"), _("Use knots distance instead radius"), "use_knot_distance", &wr, this, false),
-    method(_("Method:"), _("Fillets methods"), "method", FMConverter, &wr, this, FM_AUTO),
-    radius(_("Radius (unit or %):"), _("Radius, in unit or %"), "radius", &wr, this, 0.),
-    chamfer_steps(_("Chamfer steps:"), _("Chamfer steps"), "chamfer_steps", &wr, this, 0),
-    
-    helper_size(_("Helper size with direction:"), _("Helper size with direction"), "helper_size", &wr, this, 0)
+static const Util::EnumDataConverter<Filletmethod> FMConverter(FilletmethodData, FM_END);
+
+LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject)
+    : Effect(lpeobject),
+      unit(_("Unit"), _("Unit"), "unit", &wr, this, "px"),
+      satellites_param("Satellites_param", "Satellites_param",
+                       "satellites_param", &wr, this),
+      method(_("Method:"), _("Methods to calculate the fillet or chamfer"),
+             "method", FMConverter, &wr, this, FM_AUTO),
+      radius(_("Radius (unit or %):"), _("Radius, in unit or %"), "radius", &wr,
+             this, 0.0),
+      chamfer_steps(_("Chamfer steps:"), _("Chamfer steps"), "chamfer_steps",
+                    &wr, this, 1),
+      flexible(_("Flexible radius size (%)"), _("Flexible radius size (%)"),
+               "flexible", &wr, this, false),
+      mirror_knots(_("Mirror Knots"), _("Mirror Knots"), "mirror_knots", &wr,
+                   this, true),
+      only_selected(_("Change only selected nodes"),
+                    _("Change only selected nodes"), "only_selected", &wr, this,
+                    false),
+      use_knot_distance(_("Use knots distance instead radius"),
+                        _("Use knots distance instead radius"),
+                        "use_knot_distance", &wr, this, false),
+      hide_knots(_("Hide knots"), _("Hide knots"), "hide_knots", &wr, this,
+                 false),
+      apply_no_radius(_("Apply changes if radius = 0"), _("Apply changes if radius = 0"), "apply_no_radius", &wr, this, true),
+      apply_with_radius(_("Apply changes if radius > 0"), _("Apply changes if radius > 0"), "apply_with_radius", &wr, this, true),
+      helper_size(_("Helper path size with direction to node:"),
+                  _("Helper path size with direction to node"), "helper_size", &wr, this, 0),
+      _pathvector_satellites(NULL),
+      _degenerate_hide(false)
 {
-    registerParameter(&fillet_chamfer_values);
+    registerParameter(&satellites_param);
+    registerParameter(&unit);
     registerParameter(&method);
     registerParameter(&radius);
     registerParameter(&chamfer_steps);
     registerParameter(&helper_size);
     registerParameter(&flexible);
     registerParameter(&use_knot_distance);
-    registerParameter(&ignore_radius_0);
+    registerParameter(&mirror_knots);
+    registerParameter(&apply_no_radius);
+    registerParameter(&apply_with_radius);
     registerParameter(&only_selected);
     registerParameter(&hide_knots);
 
-    radius.param_set_range(0., infinity());
+    radius.param_set_range(0.0, Geom::infinity());
     radius.param_set_increments(1, 1);
     radius.param_set_digits(4);
     radius.param_overwrite_widget(true);
     chamfer_steps.param_set_range(1, 999);
     chamfer_steps.param_set_increments(1, 1);
     chamfer_steps.param_set_digits(0);
-    chamfer_steps.param_overwrite_widget(true);
-    helper_size.param_set_range(0, infinity());
+    helper_size.param_set_range(0, 999);
     helper_size.param_set_increments(5, 5);
     helper_size.param_set_digits(0);
-    helper_size.param_overwrite_widget(true);
-    fillet_chamfer_values.set_chamfer_steps(3);
+    _provides_knotholder_entities = true;
 }
 
-LPEFilletChamfer::~LPEFilletChamfer() {}
+void LPEFilletChamfer::doOnApply(SPLPEItem const *lpeItem)
+{
+    SPLPEItem *splpeitem = const_cast<SPLPEItem *>(lpeItem);
+    SPShape *shape = dynamic_cast<SPShape *>(splpeitem);
+    if (shape) {
+        Geom::PathVector const pathv = pathv_to_linear_and_cubic_beziers(shape->getCurve()->get_pathvector());
+        Satellites satellites;
+        for (Geom::PathVector::const_iterator path_it = pathv.begin(); path_it !=  pathv.end(); ++path_it) {
+            if (path_it->empty()) {
+                continue;
+            }
+            std::vector<Satellite> subpath_satellites;
+            for (Geom::Path::const_iterator curve_it = path_it->begin(); curve_it !=  path_it->end(); ++curve_it) {
+                //Maybe we want this satellites...
+                //if (curve_it->isDegenerate()) {
+                //  continue 
+                //}
+                Satellite satellite(FILLET);
+                satellite.setSteps(chamfer_steps);
+                subpath_satellites.push_back(satellite);
+            }
+            //we add the last satellite on open path because _pathvector_satellites is related to nodes, not curves
+            //so maybe in the future we can need this last satellite in other effects
+            //dont remove for this effect because _pathvector_satellites class has methods when the path is modiffied
+            //and we want one method for all uses
+            if (!path_it->closed()) {
+                Satellite satellite(FILLET);
+                satellite.setSteps(chamfer_steps);
+                subpath_satellites.push_back(satellite);
+            }
+            satellites.push_back(subpath_satellites);
+        }
+        _pathvector_satellites = new PathVectorSatellites();
+        _pathvector_satellites->setPathVector(pathv);
+        _pathvector_satellites->setSatellites(satellites);
+        satellites_param.setPathVectorSatellites(_pathvector_satellites);
+    } else {
+        g_warning("LPE Fillet/Chamfer can only be applied to shapes (not groups).");
+        SPLPEItem *item = const_cast<SPLPEItem *>(lpeItem);
+        item->removeCurrentPathEffect(false);
+    }
+}
 
 Gtk::Widget *LPEFilletChamfer::newWidget()
 {
@@ -94,54 +139,50 @@
     vbox->set_border_width(5);
     vbox->set_homogeneous(false);
     vbox->set_spacing(2);
-    Gtk::HBox *advertaising = Gtk::manage(new Gtk::HBox(true, 0));
-    Gtk::Button *advert = Gtk::manage(new Gtk::Button(Glib::ustring(_("IMPORTANT! New version soon..."))));
-    advertaising->pack_start(*advert, true, true, 2);
-    vbox->pack_start(*advertaising, true, true, 2);
-    Gtk::HBox *advertaising2 = Gtk::manage(new Gtk::HBox(true, 0));
-    Gtk::Button *advert2 = Gtk::manage(new Gtk::Button(Glib::ustring(_("Not compatible. Convert to path after."))));
-    advertaising2->pack_start(*advert2, true, true, 2);
-    vbox->pack_start(*advertaising2, true, true, 2);
     std::vector<Parameter *>::iterator it = param_vector.begin();
     while (it != param_vector.end()) {
         if ((*it)->widget_is_visible) {
             Parameter *param = *it;
             Gtk::Widget *widg = param->param_newWidget();
             if (param->param_key == "radius") {
-                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
-                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::updateFillet));
-                widg = widgRegistered;
+                Inkscape::UI::Widget::Scalar *widg_registered =
+                    Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
+                widg_registered->signal_value_changed().connect(
+                    sigc::mem_fun(*this, &LPEFilletChamfer::updateAmount));
+                widg = widg_registered;
                 if (widg) {
-                    Gtk::HBox *scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
-                    std::vector<Gtk::Widget *> childList = scalarParameter->get_children();
-                    Gtk::Entry *entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
-                    entryWidg->set_width_chars(6);
+                    Gtk::HBox *scalar_parameter = dynamic_cast<Gtk::HBox *>(widg);
+                    std::vector<Gtk::Widget *> childList = scalar_parameter->get_children();
+                    Gtk::Entry *entry_widget = dynamic_cast<Gtk::Entry *>(childList[1]);
+                    entry_widget->set_width_chars(6);
                 }
+//            } else if (param->param_key == "unit") {
+//                Inkscape::UI::Widget::RegisteredUnitMenu* widg_registered = 
+//                    Gtk::manage(dynamic_cast< Inkscape::UI::Widget::RegisteredUnitMenu *>(widg));
+//                widg_registered->setUnit(unit.get_abbreviation());
+//                widg_registered->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change unit parameter"));
+//                widg_registered->getUnitMenu()->signal_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::convertUnit));
+//                widg = widg_registered;
             } else if (param->param_key == "chamfer_steps") {
-                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
-                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::chamferSubdivisions));
-                widg = widgRegistered;
+                Inkscape::UI::Widget::Scalar *widg_registered =
+                    Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
+                widg_registered->signal_value_changed().connect(
+                    sigc::mem_fun(*this, &LPEFilletChamfer::updateChamferSteps));
+                widg = widg_registered;
                 if (widg) {
-                    Gtk::HBox *scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
-                    std::vector<Gtk::Widget *> childList = scalarParameter->get_children();
-                    Gtk::Entry *entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
-                    entryWidg->set_width_chars(3);
+                    Gtk::HBox *scalar_parameter = dynamic_cast<Gtk::HBox *>(widg);
+                    std::vector<Gtk::Widget *> childList = scalar_parameter->get_children();
+                    Gtk::Entry *entry_widget = dynamic_cast<Gtk::Entry *>(childList[1]);
+                    entry_widget->set_width_chars(3);
                 }
-            } else if (param->param_key == "flexible") {
-                Gtk::CheckButton *widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
-                widgRegistered->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleFlexFixed));
             } else if (param->param_key == "helper_size") {
-                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
-                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::refreshKnots));
-            } else if (param->param_key == "hide_knots") {
-                Gtk::CheckButton *widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
-                widgRegistered->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleHide));
+                Inkscape::UI::Widget::Scalar *widg_registered =
+                    Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
+                widg_registered->signal_value_changed().connect(
+                    sigc::mem_fun(*this, &LPEFilletChamfer::refreshKnots));
             } else if (param->param_key == "only_selected") {
                 Gtk::manage(widg);
-            } else if (param->param_key == "ignore_radius_0") {
-                Gtk::manage(widg);
             }
-
             Glib::ustring *tip = param->param_getTooltip();
             if (widg) {
                 vbox->pack_start(*widg, true, true, 2);
@@ -153,504 +194,386 @@
                 }
             }
         }
-
         ++it;
     }
-    Gtk::HBox *filletContainer = Gtk::manage(new Gtk::HBox(true, 0));
-    Gtk::Button *fillet = Gtk::manage(new Gtk::Button(Glib::ustring(_("Fillet"))));
-    fillet->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::fillet));
-
-    filletContainer->pack_start(*fillet, true, true, 2);
-    Gtk::Button *inverseFillet = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse fillet"))));
-    inverseFillet->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::inverseFillet));
-    filletContainer->pack_start(*inverseFillet, true, true, 2);
-    
-    Gtk::HBox *chamferContainer = Gtk::manage(new Gtk::HBox(true, 0));
+
+    Gtk::HBox *fillet_container = Gtk::manage(new Gtk::HBox(true, 0));
+    Gtk::Button *fillet =  Gtk::manage(new Gtk::Button(Glib::ustring(_("Fillet"))));
+    fillet->signal_clicked()
+    .connect(sigc::bind<SatelliteType>(sigc::mem_fun(*this, &LPEFilletChamfer::updateSatelliteType),FILLET));
+
+    fillet_container->pack_start(*fillet, true, true, 2);
+    Gtk::Button *inverse_fillet = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse fillet"))));
+    inverse_fillet->signal_clicked()
+    .connect(sigc::bind<SatelliteType>(sigc::mem_fun(*this, &LPEFilletChamfer::updateSatelliteType),INVERSE_FILLET));
+    fillet_container->pack_start(*inverse_fillet, true, true, 2);
+
+    Gtk::HBox *chamfer_container = Gtk::manage(new Gtk::HBox(true, 0));
     Gtk::Button *chamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Chamfer"))));
-    chamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::chamfer));
-
-    chamferContainer->pack_start(*chamfer, true, true, 2);
-    Gtk::Button *inverseChamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse chamfer"))));
-    inverseChamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::inverseChamfer));
-    chamferContainer->pack_start(*inverseChamfer, true, true, 2);
-
-    vbox->pack_start(*filletContainer, true, true, 2);
-    vbox->pack_start(*chamferContainer, true, true, 2);
+    chamfer->signal_clicked()
+    .connect(sigc::bind<SatelliteType>(sigc::mem_fun(*this, &LPEFilletChamfer::updateSatelliteType),CHAMFER));
+
+    chamfer_container->pack_start(*chamfer, true, true, 2);
+    Gtk::Button *inverse_chamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse chamfer"))));
+    inverse_chamfer->signal_clicked()
+    .connect(sigc::bind<SatelliteType>(sigc::mem_fun(*this, &LPEFilletChamfer::updateSatelliteType),INVERSE_CHAMFER));
+    chamfer_container->pack_start(*inverse_chamfer, true, true, 2);
+
+    vbox->pack_start(*fillet_container, true, true, 2);
+    vbox->pack_start(*chamfer_container, true, true, 2);
 
     return vbox;
 }
 
-void LPEFilletChamfer::toggleHide()
-{
-    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
-    std::vector<Geom::Point> result;
-    for (std::vector<Point>::const_iterator point_it = filletChamferData.begin();
-            point_it != filletChamferData.end(); ++point_it) {
-        if (hide_knots) {
-            result.push_back(Point((*point_it)[X], std::abs((*point_it)[Y]) * -1));
-        } else {
-            result.push_back(Point((*point_it)[X], std::abs((*point_it)[Y])));
-        }
-    }
-    fillet_chamfer_values.param_set_and_write_new_value(result);
-    refreshKnots();
-}
-
-void LPEFilletChamfer::toggleFlexFixed()
-{
-    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
-    std::vector<Geom::Point> result;
-    unsigned int i = 0;
-    for (std::vector<Point>::const_iterator point_it = filletChamferData.begin();
-            point_it != filletChamferData.end(); ++point_it) {
-        if (flexible) {
-            result.push_back(Point(fillet_chamfer_values.to_time(i, (*point_it)[X]),
-                                   (*point_it)[Y]));
-        } else {
-            result.push_back(Point(fillet_chamfer_values.to_len(i, (*point_it)[X]),
-                                   (*point_it)[Y]));
-        }
-        i++;
-    }
-    if (flexible) {
-        radius.param_set_range(0., 100);
-        radius.param_set_value(0);
-    } else {
-        radius.param_set_range(0., infinity());
-        radius.param_set_value(0);
-    }
-    fillet_chamfer_values.param_set_and_write_new_value(result);
-}
-
-void LPEFilletChamfer::updateFillet()
-{
-    double power = 0;
+void LPEFilletChamfer::refreshKnots()
+{
+    if (satellites_param._knoth) {
+        satellites_param._knoth->update_knots();
+    }
+}
+
+void LPEFilletChamfer::updateAmount()
+{
+    setSelected(_pathvector_satellites);
+    double power = radius;
     if (!flexible) {
-        power = radius * -1;
-    } else {
-        power = radius;
-    }
-    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
-    doUpdateFillet(path_from_piecewise(pwd2, tolerance), power);
-    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change scalar parameter"));
-}
-
-void LPEFilletChamfer::fillet()
-{
-    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
-    doChangeType(path_from_piecewise(pwd2, tolerance), 1);
-    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Convert to fillet"));
-}
-
-void LPEFilletChamfer::inverseFillet()
-{
-    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
-    doChangeType(path_from_piecewise(pwd2, tolerance), 2);
-    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Convert to inverse fillet"));
-}
-
-void LPEFilletChamfer::chamferSubdivisions()
-{
-    fillet_chamfer_values.set_chamfer_steps(chamfer_steps);
-    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
-    doChangeType(path_from_piecewise(pwd2, tolerance), chamfer_steps + 5000);
-    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change scalar parameter"));
-}
-
-void LPEFilletChamfer::chamfer()
-{
-    fillet_chamfer_values.set_chamfer_steps(chamfer_steps);
-    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
-    doChangeType(path_from_piecewise(pwd2, tolerance), chamfer_steps + 3000);
-    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Convert to chamfer"));
-}
-
-void LPEFilletChamfer::inverseChamfer()
-{
-    fillet_chamfer_values.set_chamfer_steps(chamfer_steps);
-    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
-    doChangeType(path_from_piecewise(pwd2, tolerance), chamfer_steps + 4000);
-    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Convert to inverse fillet"));
-}
-
-void LPEFilletChamfer::refreshKnots()
-{
-    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
-    fillet_chamfer_values.recalculate_knots(pwd2);
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-    if (tools_isactive(desktop, TOOLS_NODES)) {
-        tools_switch(desktop, TOOLS_SELECT);
-        tools_switch(desktop, TOOLS_NODES);
-    }
-    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Knots and helper paths refreshed"));
-}
-
-void LPEFilletChamfer::doUpdateFillet(Geom::PathVector const &original_pathv, double power)
-{
-    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
-    std::vector<Geom::Point> result;
-    Geom::PathVector original_pathv_processed = pathv_to_linear_and_cubic_beziers(original_pathv);
-    int counter = 0;
-    for (PathVector::const_iterator path_it = original_pathv_processed.begin();
-            path_it != original_pathv_processed.end(); ++path_it) {
-        if (path_it->empty())
-            continue;
-
-        Geom::Path::const_iterator curve_it1 = path_it->begin();
-        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
-        Geom::Path::const_iterator curve_endit = path_it->end_default();
-        if (path_it->closed() && path_it->back_closed().isDegenerate()) {
-            const Curve &closingline = path_it->back_closed();
-            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
-                curve_endit = path_it->end_open();
-            }
-        }
-        double powerend = 0;
-        while (curve_it1 != curve_endit) {
-            powerend = power;
-            if (power < 0 && !use_knot_distance) {
-                powerend = fillet_chamfer_values.rad_to_len(counter,powerend);
-            }
-            if (power > 0) {
-                powerend = counter + (power / 100);
-            }
-            if (ignore_radius_0 && (filletChamferData[counter][X] == 0 ||
-                                    filletChamferData[counter][X] == counter)) {
-                powerend = filletChamferData[counter][X];
-            }
-            if (filletChamferData[counter][Y] == 0) {
-                powerend = filletChamferData[counter][X];
-            }
-            if (only_selected && !isNodePointSelected(curve_it1->initialPoint())) {
-                powerend = filletChamferData[counter][X];
-            }
-            result.push_back(Point(powerend, filletChamferData[counter][Y]));
-            ++curve_it1;
-            ++curve_it2;
-            counter++;
-        }
-    }
-    fillet_chamfer_values.param_set_and_write_new_value(result);
-}
-
-void LPEFilletChamfer::doChangeType(Geom::PathVector const &original_pathv, int type)
-{
-    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
-    std::vector<Geom::Point> result;
-    Geom::PathVector original_pathv_processed = pathv_to_linear_and_cubic_beziers(original_pathv);
-    int counter = 0;
-    for (PathVector::const_iterator path_it = original_pathv_processed.begin(); path_it != original_pathv_processed.end(); ++path_it) {
-        int pathCounter = 0;
-        if (path_it->empty())
-            continue;
-
-        Geom::Path::const_iterator curve_it1 = path_it->begin();
-        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
-        Geom::Path::const_iterator curve_endit = path_it->end_default();
-        if (path_it->closed() && path_it->back_closed().isDegenerate()) {
-            const Curve &closingline = path_it->back_closed();
-            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
-                curve_endit = path_it->end_open();
-            }
-        }
-        while (curve_it1 != curve_endit) {
-            bool toggle = true;
-            if (filletChamferData[counter][Y] == 0 ||
-                    (ignore_radius_0 && (filletChamferData[counter][X] == 0 ||
-                    filletChamferData[counter][X] == counter)) ||
-                    (only_selected && !isNodePointSelected(curve_it1->initialPoint()))) {
-                toggle = false;
-            }
-            if (toggle) {
-                if(type >= 5000){
-                    if(filletChamferData[counter][Y] >= 3000 && filletChamferData[counter][Y] < 4000){
-                        type = type - 2000;
-                    } else if (filletChamferData[counter][Y] >= 4000 && filletChamferData[counter][Y] < 5000){
-                        type = type - 1000;
-                    }
-                }
-                result.push_back(Point(filletChamferData[counter][X], type));
+        SPDocument * document = SP_ACTIVE_DOCUMENT;
+        SPNamedView *nv = sp_document_namedview(document, NULL);
+        Glib::ustring display_unit = nv->display_units->abbr;
+        power = Inkscape::Util::Quantity::convert(power, unit.get_abbreviation(), display_unit.c_str());
+    }
+    _pathvector_satellites->updateAmount(power, apply_no_radius, apply_with_radius, only_selected, 
+                                         use_knot_distance, flexible);
+    satellites_param.setPathVectorSatellites(_pathvector_satellites);
+}
+
+//void LPEFilletChamfer::convertUnit()
+//{
+//    SPDocument * document = SP_ACTIVE_DOCUMENT;
+//    SPNamedView *nv = sp_document_namedview(document, NULL);
+//    Glib::ustring display_unit = nv->display_units->abbr;
+//    _pathvector_satellites->convertUnit(unit.get_abbreviation(), display_unit, apply_no_radius, apply_with_radius);
+//    satellites_param.setPathVectorSatellites(_pathvector_satellites);
+//}
+
+void LPEFilletChamfer::updateChamferSteps()
+{
+    setSelected(_pathvector_satellites);
+    _pathvector_satellites->updateSteps(chamfer_steps, apply_no_radius, apply_with_radius, only_selected);
+    satellites_param.setPathVectorSatellites(_pathvector_satellites);
+}
+
+void LPEFilletChamfer::updateSatelliteType(SatelliteType satellitetype)
+{
+    setSelected(_pathvector_satellites);
+    _pathvector_satellites->updateSatelliteType(satellitetype, apply_no_radius, apply_with_radius, only_selected);
+    satellites_param.setPathVectorSatellites(_pathvector_satellites);
+}
+
+void LPEFilletChamfer::setSelected(PathVectorSatellites *_pathvector_satellites){
+    Geom::PathVector const pathv = _pathvector_satellites->getPathVector();
+    Satellites satellites = _pathvector_satellites->getSatellites();
+    for (size_t i = 0; i < satellites.size(); ++i) {
+        for (size_t j = 0; j < satellites[i].size(); ++j) {
+            Geom::Curve const &curve_in = pathv[i][j];
+            if (only_selected && isNodePointSelected(curve_in.initialPoint()) ){
+                satellites[i][j].setSelected(true);
             } else {
-                result.push_back(filletChamferData[counter]);
-            }
-            ++curve_it1;
-            if (curve_it2 != curve_endit) {
-                ++curve_it2;
-            }
-            counter++;
-            pathCounter++;
-        }
-    }
-    fillet_chamfer_values.param_set_and_write_new_value(result);
-}
-
-void LPEFilletChamfer::doOnApply(SPLPEItem const *lpeItem)
-{
-    if (SP_IS_SHAPE(lpeItem)) {
-        std::vector<Point> point;
-        PathVector const &original_pathv = pathv_to_linear_and_cubic_beziers(SP_SHAPE(lpeItem)->_curve->get_pathvector());
-        Piecewise<D2<SBasis> > pwd2_in = paths_to_pw(original_pathv);
-        for (PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {
-            if (path_it->empty())
-                continue;
-
-            Geom::Path::const_iterator curve_it1 = path_it->begin();
-            Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
-            Geom::Path::const_iterator curve_endit = path_it->end_default();
-            if (path_it->closed()) {
-              const Geom::Curve &closingline = path_it->back_closed(); 
-              // the closing line segment is always of type 
-              // Geom::LineSegment.
-              if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
-                // closingline.isDegenerate() did not work, because it only checks for
-                // *exact* zero length, which goes wrong for relative coordinates and
-                // rounding errors...
-                // the closing line segment has zero-length. So stop before that one!
-                curve_endit = path_it->end_open();
-              }
-            }
-            int counter = 0;
-            while (curve_it1 != curve_endit) {
-                std::pair<std::size_t, std::size_t> positions = fillet_chamfer_values.get_positions(counter, original_pathv);
-                Geom::NodeType nodetype;
-                if (positions.second == 0) {
-                    if (path_it->closed()) {
-                        Piecewise<D2<SBasis> > u;
-                        u.push_cut(0);          
-                        u.push(pwd2_in[fillet_chamfer_values.last_index(counter, original_pathv)], 1);
-                        Geom::Curve const * A = path_from_piecewise(u, 0.1)[0][0].duplicate();
-                        nodetype = get_nodetype(*A, *curve_it1);
-                    } else {
-                        nodetype = NODE_NONE;
-                    }
-                } else {
-                    nodetype = get_nodetype((*path_it)[counter - 1], *curve_it1);
-                }
-                if (nodetype == NODE_CUSP) {
-                    point.push_back(Point(0, 1));
-                } else {
-                    point.push_back(Point(0, 0));
-                }
-                ++curve_it1;
-                if (curve_it2 != curve_endit) {
-                    ++curve_it2;
-                }
-                counter++;
-            }
-        }
-        fillet_chamfer_values.param_set_and_write_new_value(point);
-    } else {
-        g_warning("LPE Fillet can only be applied to shapes (not groups).");
-        SPLPEItem * item = const_cast<SPLPEItem*>(lpeItem);
-        item->removeCurrentPathEffect(false);
-    }
+                satellites[i][j].setSelected(false);
+            }
+        }
+    }
+    _pathvector_satellites->setSatellites(satellites);
 }
 
 void LPEFilletChamfer::doBeforeEffect(SPLPEItem const *lpeItem)
 {
-    if (SP_IS_SHAPE(lpeItem)) {
-        if(hide_knots){
-            fillet_chamfer_values.set_helper_size(0);
-        } else {
-            fillet_chamfer_values.set_helper_size(helper_size);
-        }
-        fillet_chamfer_values.set_use_distance(use_knot_distance);
-        SPCurve *c = SP_IS_PATH(lpeItem) ? static_cast<SPPath const *>(lpeItem)
-                     ->get_original_curve()
-                     : SP_SHAPE(lpeItem)->getCurve();
-        std::vector<Point> filletChamferData = fillet_chamfer_values.data();
-        if (!filletChamferData.empty() && getKnotsNumber(c) != (int)
-                filletChamferData.size()) {
-            PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(c->get_pathvector());
-            Piecewise<D2<SBasis> > pwd2_in = paths_to_pw(original_pathv);
-            fillet_chamfer_values.recalculate_controlpoints_for_new_pwd2(pwd2_in);
-        }
+    if (sp_curve) {
+        //fillet chamfer specific calls
+        satellites_param.setUseDistance(use_knot_distance);
+        satellites_param.setCurrentZoom(current_zoom);
+        //mandatory call
+        satellites_param.setEffectType(effectType());
+        Geom::PathVector const pathv = pathv_to_linear_and_cubic_beziers(sp_curve->get_pathvector());
+        //if are diferent sizes call to recalculate
+        //TODO: Update the satellite data in paths modified,
+        Satellites satellites = satellites_param.data();
+        if (satellites.empty()) {
+            doOnApply(lpeItem);
+            satellites = satellites_param.data();
+        }
+        if (_pathvector_satellites) {
+            size_t number_nodes = pathv.nodes().size();
+            size_t previous_number_nodes = _pathvector_satellites->getTotalSatellites();
+            if (number_nodes != previous_number_nodes) {
+                Satellite satellite(FILLET);
+                satellite.setIsTime(flexible);
+                satellite.setHasMirror(mirror_knots);
+                satellite.setHidden(hide_knots);
+                _pathvector_satellites->recalculateForNewPathVector(pathv, satellite);
+                satellites = _pathvector_satellites->getSatellites();
+            }
+        }
+        if (_degenerate_hide) {
+            satellites_param.setGlobalKnotHide(true);
+        } else {
+            satellites_param.setGlobalKnotHide(false);
+        }
+        if (hide_knots) {
+            satellites_param.setHelperSize(0);
+        } else {
+            satellites_param.setHelperSize(helper_size);
+        }
+        for (size_t i = 0; i < satellites.size(); ++i) {
+            for (size_t j = 0; j < satellites[i].size(); ++j) {
+                Geom::Curve const &curve_in = pathv[i][j];
+                if (satellites[i][j].is_time != flexible) {
+                    satellites[i][j].is_time = flexible;
+                    double amount = satellites[i][j].amount;
+                    if (pathv[i].size() == j) {
+                        continue;
+                    }
+                    if (satellites[i][j].is_time) {
+                        double time = timeAtArcLength(amount, curve_in);
+                        satellites[i][j].amount = time;
+                    } else {
+                        double size = arcLengthAt(amount, curve_in);
+                        satellites[i][j].amount = size;
+                    }
+                }
+                if (satellites[i][j].has_mirror != mirror_knots) {
+                    satellites[i][j].has_mirror = mirror_knots;
+                }
+                satellites[i][j].hidden = hide_knots;
+                if (only_selected && isNodePointSelected(curve_in.initialPoint()) ){
+                    satellites[i][j].setSelected(true);
+                }
+            }
+        }
+        if (!_pathvector_satellites) {
+            _pathvector_satellites = new PathVectorSatellites();
+        }
+        _pathvector_satellites->setPathVector(pathv);
+        _pathvector_satellites->setSatellites(satellites);
+        satellites_param.setPathVectorSatellites(_pathvector_satellites, false);
+        refreshKnots();
     } else {
         g_warning("LPE Fillet can only be applied to shapes (not groups).");
     }
 }
 
-int LPEFilletChamfer::getKnotsNumber(SPCurve const *c)
+void
+LPEFilletChamfer::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
 {
-    int nKnots = c->nodes_in_path();
-    PathVector const pv =    pathv_to_linear_and_cubic_beziers(c->get_pathvector());
-    for (Geom::PathVector::const_iterator path_it = pv.begin();
-            path_it != pv.end(); ++path_it) {
-        if (!(*path_it).closed()) {
-            nKnots--;
-        }
-    }
-    return nKnots;
+    hp_vec.push_back(_hp);
 }
 
 void
-LPEFilletChamfer::adjustForNewPath(Geom::PathVector const &path_in)
+LPEFilletChamfer::addChamferSteps(Geom::Path &tmp_path, Geom::Path path_chamfer, Geom::Point end_arc_point, size_t steps)
 {
-    if (!path_in.empty()) {
-        fillet_chamfer_values.recalculate_controlpoints_for_new_pwd2(pathv_to_linear_and_cubic_beziers(path_in)[0].toPwSb());
+    setSelected(_pathvector_satellites);
+    double path_subdivision = 1.0 / steps;
+    for (size_t i = 1; i < steps; i++) {
+        Geom::Point chamfer_step = path_chamfer.pointAt(path_subdivision * i);
+        tmp_path.appendNew<Geom::LineSegment>(chamfer_step);
     }
+    tmp_path.appendNew<Geom::LineSegment>(end_arc_point);
 }
 
 Geom::PathVector
 LPEFilletChamfer::doEffect_path(Geom::PathVector const &path_in)
 {
-    Geom::PathVector pathvector_out;
-    Piecewise<D2<SBasis> > pwd2_in = paths_to_pw(pathv_to_linear_and_cubic_beziers(path_in));
-    pwd2_in = remove_short_cuts(pwd2_in, .01);
-    Piecewise<D2<SBasis> > der = derivative(pwd2_in);
-    Piecewise<D2<SBasis> > n = rot90(unitVector(der));
-    fillet_chamfer_values.set_pwd2(pwd2_in, n);
-    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
-    unsigned int counter = 0;
+    const double GAP_HELPER = 0.00001;
+    Geom::PathVector path_out;
+    size_t path = 0;
     const double K = (4.0 / 3.0) * (sqrt(2.0) - 1.0);
-    Geom::PathVector path_in_processed = pathv_to_linear_and_cubic_beziers(path_in);
-    for (PathVector::const_iterator path_it = path_in_processed.begin();
-            path_it != path_in_processed.end(); ++path_it) {
-        if (path_it->empty())
-            continue;
-        Geom::Path path_out;
-        Geom::Path::const_iterator curve_it1 = path_it->begin();
-        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
-        Geom::Path::const_iterator curve_endit = path_it->end_default();
+    _degenerate_hide = false;
+    Geom::PathVector const pathv = pathv_to_linear_and_cubic_beziers(path_in);
+    Satellites satellites = _pathvector_satellites->getSatellites();
+    for (Geom::PathVector::const_iterator path_it = pathv.begin(); path_it != pathv.end(); ++path_it) {
+        if (path_it->empty()) {
+            continue;
+        }
+        Geom::Path tmp_path;
+        if (path_it->size() == 1) {
+            path++;
+            tmp_path.start(path_it[0].pointAt(0));
+            tmp_path.append(path_it[0]);
+            path_out.push_back(tmp_path);
+            continue;
+        }
+        double time0 = 0;
+        size_t curve = 0;
+        for (Geom::Path::const_iterator curve_it1 = path_it->begin(); curve_it1 !=  path_it->end(); ++curve_it1) {
+            size_t next_index = curve + 1;
+            if (curve == pathv[path].size() - 1 && pathv[path].closed()) {
+                next_index = 0;
+            }
+            //append last extreme of paths on open paths
+            if (curve == pathv[path].size() -1 && !pathv[path].closed()) { //the path is open and we are at end of path
+                if (time0 != 1) { //Previous satellite not at 100% amount
+                    Geom::Curve *last_curve = curve_it1->portion(time0, 1);
+                    last_curve->setInitial(tmp_path.finalPoint());
+                    tmp_path.append(*last_curve);
+                }
+                continue;
+            }
+            Geom::Curve const &curve_it2 = pathv[path][next_index];
+            Satellite satellite = satellites[path][next_index];
+            if (Geom::are_near((*curve_it1).initialPoint(), (*curve_it1).finalPoint())) {
+                _degenerate_hide = true;
+                g_warning("Knots hidded if consecutive nodes has the same position.");
+                return path_in;
+            }
+            if (!curve) { //curve == 0 
+                if (!path_it->closed()) {
+                    time0 = 0;
+                } else {
+                    time0 = satellites[path][0].time(*curve_it1);
+                }
+            }
+            double s = satellite.arcDistance(curve_it2);
+            double time1 = satellite.time(s, true, (*curve_it1));
+            double time2 = satellite.time(curve_it2);
+            if (time1 <= time0) {
+                time1 = time0;
+            }
+            if (time2 > 1) {
+                time2 = 1;
+            }
+            Geom::Curve *knot_curve_1 = curve_it1->portion(time0, time1);
+            Geom::Curve *knot_curve_2 = curve_it2.portion(time2, 1);
+            if (curve > 0) {
+                knot_curve_1->setInitial(tmp_path.finalPoint());
+            } else {
+                tmp_path.start((*curve_it1).pointAt(time0));
+            }
+
+            Geom::Point start_arc_point = knot_curve_1->finalPoint();
+            Geom::Point end_arc_point = curve_it2.pointAt(time2);
+            //add a gap helper
+            if (time2 == 1) {
+                end_arc_point = curve_it2.pointAt(time2 - GAP_HELPER);
+            }
+            if (time1 == time0) {
+                start_arc_point = curve_it1->pointAt(time1 + GAP_HELPER);
+            }
+
+            double k1 = distance(start_arc_point, curve_it1->finalPoint()) * K;
+            double k2 = distance(curve_it2.initialPoint(), end_arc_point) * K;
+            Geom::CubicBezier const *cubic_1 = dynamic_cast<Geom::CubicBezier const *>(&*knot_curve_1);
+            Geom::CubicBezier const *cubic_2 = dynamic_cast<Geom::CubicBezier const *>(&*knot_curve_2);
+            Geom::Ray ray_1(start_arc_point, curve_it1->finalPoint());
+            Geom::Ray ray_2(curve_it2.initialPoint(), end_arc_point);
+            if (cubic_1) {
+                ray_1.setPoints((*cubic_1)[2], start_arc_point);
+            }
+            if (cubic_2) {
+                ray_2.setPoints(end_arc_point, (*cubic_2)[1]);
+            }
+            bool ccw_toggle = cross(curve_it1->finalPoint() - start_arc_point, end_arc_point - start_arc_point) < 0;
+            double angle = angle_between(ray_1, ray_2, ccw_toggle);
+            double handle_angle_1 = ray_1.angle() - angle;
+            double handle_angle_2 = ray_2.angle() + angle;
+            if (ccw_toggle) {
+                handle_angle_1 = ray_1.angle() + angle;
+                handle_angle_2 = ray_2.angle() - angle;
+            }
+            Geom::Point handle_1 = Geom::Point::polar(ray_1.angle(), k1) + start_arc_point;
+            Geom::Point handle_2 = end_arc_point - Geom::Point::polar(ray_2.angle(), k2);
+            Geom::Point inverse_handle_1 = Geom::Point::polar(handle_angle_1, k1) + start_arc_point;
+            Geom::Point inverse_handle_2 = end_arc_point - Geom::Point::polar(handle_angle_2, k2);
+            if (time0 == 1) {
+                handle_1 = start_arc_point;
+                inverse_handle_1 = start_arc_point;
+            }
+            //remove gap helper
+            if (time2 == 1) {
+                end_arc_point = curve_it2.pointAt(time2);
+            }
+            if (time1 == time0) {
+                start_arc_point = curve_it1->pointAt(time0);
+            }
+            if (time1 != 1) {
+                if (time1 != time0 || (time1 == 1 && time0 == 1)) {
+                    if (!knot_curve_1->isDegenerate()) {
+                        tmp_path.append(*knot_curve_1);
+                    }
+                }
+                SatelliteType type = satellite.satellite_type;
+                size_t steps = satellite.steps;
+                if (!steps) steps = 1;
+                Geom::Line const x_line(Geom::Point(0, 0), Geom::Point(1, 0));
+                Geom::Line const angled_line(start_arc_point, end_arc_point);
+                double arc_angle = Geom::angle_between(x_line, angled_line);
+                double radius = Geom::distance(start_arc_point, middle_point(start_arc_point, end_arc_point)) /
+                                               sin(angle / 2.0);
+                Geom::Coord rx = radius;
+                Geom::Coord ry = rx;
+                bool eliptical = (is_straight_curve(*curve_it1) &&
+                                  is_straight_curve(curve_it2) && method != FM_BEZIER) ||
+                                  method == FM_ARC;
+                switch (type) {
+                case CHAMFER:
+                    {
+                        Geom::Path path_chamfer;
+                        path_chamfer.start(tmp_path.finalPoint());
+                        if (eliptical) {
+                            ccw_toggle = ccw_toggle ? 0 : 1;
+                            path_chamfer.appendNew<Geom::EllipticalArc>(rx, ry, arc_angle, 0, ccw_toggle, end_arc_point);
+                        } else {
+                            path_chamfer.appendNew<Geom::CubicBezier>(handle_1, handle_2, end_arc_point);
+                        }
+                        addChamferSteps(tmp_path, path_chamfer, end_arc_point, steps);
+                    }
+                    break;
+                case INVERSE_CHAMFER:
+                    {
+                        Geom::Path path_chamfer;
+                        path_chamfer.start(tmp_path.finalPoint());
+                        if (eliptical) {
+                            path_chamfer.appendNew<Geom::EllipticalArc>(rx, ry, arc_angle, 0, ccw_toggle, end_arc_point);
+                        } else {
+                            path_chamfer.appendNew<Geom::CubicBezier>(inverse_handle_1, inverse_handle_2, end_arc_point);
+                        }
+                        addChamferSteps(tmp_path, path_chamfer, end_arc_point, steps);
+                    }
+                    break;
+                case INVERSE_FILLET:
+                    {
+                        if (eliptical) {
+                            tmp_path.appendNew<Geom::EllipticalArc>(rx, ry, arc_angle, 0, ccw_toggle, end_arc_point);
+                        } else {
+                            tmp_path.appendNew<Geom::CubicBezier>(inverse_handle_1, inverse_handle_2, end_arc_point);
+                        }
+                    }
+                    break;
+                default: //fillet
+                    {
+                        if (eliptical) {
+                            ccw_toggle = ccw_toggle ? 0 : 1;
+                            tmp_path.appendNew<Geom::EllipticalArc>(rx, ry, arc_angle, 0, ccw_toggle, end_arc_point);
+                        } else {
+                            tmp_path.appendNew<Geom::CubicBezier>(handle_1, handle_2, end_arc_point);
+                        }
+                    }
+                    break;
+                }
+            } else {
+                if (!knot_curve_1->isDegenerate()) {
+                    tmp_path.append(*knot_curve_1);
+                }
+            }
+            curve++;
+            time0 = time2;
+        }
         if (path_it->closed()) {
-          const Geom::Curve &closingline = path_it->back_closed(); 
-          // the closing line segment is always of type 
-          // Geom::LineSegment.
-          if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
-            // closingline.isDegenerate() did not work, because it only checks for
-            // *exact* zero length, which goes wrong for relative coordinates and
-            // rounding errors...
-            // the closing line segment has zero-length. So stop before that one!
-            curve_endit = path_it->end_open();
-          }
-        }
-        unsigned int counterCurves = 0;
-        while (curve_it1 != curve_endit) {
-            Curve *curve_it2Fixed = (*path_it->begin()).duplicate();
-            if(!path_it->closed() || curve_it2 != curve_endit){
-                curve_it2Fixed = (*curve_it2).duplicate();
-            }
-            bool last = curve_it2 == curve_endit;
-            std::vector<double> times = fillet_chamfer_values.get_times(counter, path_in, last);
-            Curve *knotCurve1 = curve_it1->portion(times[0], times[1]);
-            if (counterCurves > 0) {
-                knotCurve1->setInitial(path_out.finalPoint());
-            } else {
-                path_out.start((*curve_it1).pointAt(times[0]));
-            }
-            Curve *knotCurve2 = curve_it2Fixed->portion(times[2], 1);
-            Point startArcPoint = knotCurve1->finalPoint();
-            Point endArcPoint = curve_it2Fixed->pointAt(times[2]);
-            double k1 = distance(startArcPoint, curve_it1->finalPoint()) * K;
-            double k2 = distance(endArcPoint, curve_it1->finalPoint()) * K;
-            Geom::CubicBezier const *cubic1 = dynamic_cast<Geom::CubicBezier const *>(&*knotCurve1);
-            Ray ray1(startArcPoint, curve_it1->finalPoint());
-            if (cubic1) {
-                ray1.setPoints((*cubic1)[2], startArcPoint);
-            }
-            Point handle1 =  Point::polar(ray1.angle(),k1) + startArcPoint;
-            Geom::CubicBezier const *cubic2 =
-                dynamic_cast<Geom::CubicBezier const *>(&*knotCurve2);
-            Ray ray2(curve_it1->finalPoint(), endArcPoint);
-            if (cubic2) {
-                ray2.setPoints(endArcPoint, (*cubic2)[1]);
-            }
-            Point handle2 = endArcPoint - Point::polar(ray2.angle(),k2);
-            bool ccwToggle = cross(curve_it1->finalPoint() - startArcPoint, endArcPoint - startArcPoint) > 0;
-            double angle = angle_between(ray1, ray2, ccwToggle);
-            double handleAngle = ray1.angle() - angle;
-            if (ccwToggle) {
-                handleAngle = ray1.angle() + angle;
-            }
-            Point inverseHandle1 = Point::polar(handleAngle,k1) + startArcPoint;
-            handleAngle = ray2.angle() + angle;
-            if (ccwToggle) {
-                handleAngle = ray2.angle() - angle;
-            }
-            Point inverseHandle2 = endArcPoint - Point::polar(handleAngle,k2);
-            //straigth lines arc based
-            Line const x_line(Geom::Point(0,0),Geom::Point(1,0));
-            Line const angled_line(startArcPoint,endArcPoint);
-            double angleArc = Geom::angle_between( x_line,angled_line);
-            double radius = Geom::distance(startArcPoint,middle_point(startArcPoint,endArcPoint))/sin(angle/2.0);
-            Coord rx = radius;
-            Coord ry = rx;
-            
-            if (times[1] != 1) {
-                if (times[1] != gapHelper && times[1] != times[0] + gapHelper) {
-                    path_out.append(*knotCurve1);
-                }
-                int type = 0;
-                if(path_it->closed() && last){
-                    type = std::abs(filletChamferData[counter - counterCurves][Y]);
-                } else if (!path_it->closed() && last){
-                    //0
-                } else {
-                    type = std::abs(filletChamferData[counter + 1][Y]);
-                }
-                if(are_near(middle_point(startArcPoint,endArcPoint),curve_it1->finalPoint(), 0.0001)){
-                    path_out.appendNew<Geom::LineSegment>(endArcPoint);
-                } else if (type >= 3000 && type < 4000) {
-                    unsigned int chamferSubs = type-3000;
-                    Geom::Path path_chamfer;
-                    path_chamfer.start(path_out.finalPoint());
-                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
-                        path_chamfer.appendNew<EllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
-                    } else {
-                        path_chamfer.appendNew<Geom::CubicBezier>(handle1, handle2, endArcPoint);
-                    }
-                    double chamfer_stepsTime = 1.0/chamferSubs;
-                    for(unsigned int i = 1; i < chamferSubs; i++){
-                        Geom::Point chamferStep = path_chamfer.pointAt(chamfer_stepsTime * i);
-                        path_out.appendNew<Geom::LineSegment>(chamferStep);
-                    }
-                    path_out.appendNew<Geom::LineSegment>(endArcPoint);
-                } else if (type >= 4000 && type < 5000) {
-                    unsigned int chamferSubs = type-4000;
-                    Geom::Path path_chamfer;
-                    path_chamfer.start(path_out.finalPoint());
-                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
-                        ccwToggle = ccwToggle?0:1;
-                        path_chamfer.appendNew<EllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
-                    }else{
-                        path_chamfer.appendNew<Geom::CubicBezier>(inverseHandle1, inverseHandle2, endArcPoint);
-                    }
-                    double chamfer_stepsTime = 1.0/chamferSubs;
-                    for(unsigned int i = 1; i < chamferSubs; i++){
-                        Geom::Point chamferStep = path_chamfer.pointAt(chamfer_stepsTime * i);
-                        path_out.appendNew<Geom::LineSegment>(chamferStep);
-                    }
-                    path_out.appendNew<Geom::LineSegment>(endArcPoint);
-                } else if (type == 2) {
-                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
-                        ccwToggle = ccwToggle?0:1;
-                        path_out.appendNew<EllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
-                    }else{
-                        path_out.appendNew<Geom::CubicBezier>(inverseHandle1, inverseHandle2, endArcPoint);
-                    }
-                } else if (type == 1){
-                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
-                        path_out.appendNew<EllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
-                    } else {
-                        path_out.appendNew<Geom::CubicBezier>(handle1, handle2, endArcPoint);
-                    }
-                }
-            } else {
-                path_out.append(*knotCurve1);
-            }
-            if (path_it->closed() && last) {
-                path_out.close();
-            }
-            ++curve_it1;
-            if (curve_it2 != curve_endit) {
-                ++curve_it2;
-            }
-            counter++;
-            counterCurves++;
-        }
-        pathvector_out.push_back(path_out);
+            tmp_path.close();
+        }
+        path++;
+        path_out.push_back(tmp_path);
     }
-    return pathvector_out;
+    return path_out;
 }
 
 }; //namespace LivePathEffect

=== modified file 'src/live_effects/lpe-fillet-chamfer.h'
--- src/live_effects/lpe-fillet-chamfer.h	2015-07-24 18:50:50 +0000
+++ src/live_effects/lpe-fillet-chamfer.h	2017-05-06 17:46:29 +0000
@@ -7,25 +7,22 @@
  *
  * Copyright (C) 2014 Author(s)
  *
- * Special thanks to Johan Engelen for the base of the effect -powerstroke-
- * Also to ScislaC for point me to the idea
- * Also su_v for his construvtive feedback and time
- * and finaly to Liam P. White for his big help on coding, that save me a lot of hours
+ * Jabiertxof:Thanks to all people help me
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
 #include "live_effects/parameter/enum.h"
-#include "live_effects/parameter/bool.h"
+#include "live_effects/parameter/satellitesarray.h"
+#include "live_effects/effect.h"
 #include "live_effects/parameter/unit.h"
-
-#include "live_effects/parameter/filletchamferpointarray.h"
-#include "live_effects/effect.h"
+#include "helper/geom-pathvectorsatellites.h"
+#include "helper/geom-satellite.h"
 
 namespace Inkscape {
 namespace LivePathEffect {
 
-enum FilletMethod {
+enum Filletmethod {
     FM_AUTO,
     FM_ARC,
     FM_BEZIER,
@@ -35,41 +32,38 @@
 class LPEFilletChamfer : public Effect {
 public:
     LPEFilletChamfer(LivePathEffectObject *lpeobject);
-    virtual ~LPEFilletChamfer();
-
+    virtual void doBeforeEffect(SPLPEItem const *lpeItem);
     virtual Geom::PathVector doEffect_path(Geom::PathVector const &path_in);
-
     virtual void doOnApply(SPLPEItem const *lpeItem);
-    virtual void doBeforeEffect(SPLPEItem const *lpeItem);
-    virtual void adjustForNewPath(Geom::PathVector const &path_in);
-    virtual Gtk::Widget* newWidget();
-
-    int getKnotsNumber(SPCurve const *c);
-    void toggleHide();
-    void toggleFlexFixed();
-    void chamfer();
-    void chamferSubdivisions();
-    void inverseChamfer();
-    void fillet();
-    void inverseFillet();
-    void updateFillet();
-    void doUpdateFillet(Geom::PathVector const& original_pathv, double power);
-    void doChangeType(Geom::PathVector const& original_pathv, int type);
+    virtual Gtk::Widget *newWidget();
+    Geom::Ray getRay(Geom::Point start, Geom::Point end, Geom::Curve *curve, bool reverse);
+    void addChamferSteps(Geom::Path &tmp_path, Geom::Path path_chamfer, Geom::Point end_arc_point, size_t steps);
+    void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
+    void updateSatelliteType(SatelliteType satellitetype);
+    void setSelected(PathVectorSatellites *_pathvector_satellites);
+    //void convertUnit();
+    void updateChamferSteps();
+    void updateAmount();
     void refreshKnots();
 
-    FilletChamferPointArrayParam fillet_chamfer_values;
+    SatellitesArrayParam satellites_param;
 
 private:
-
-    BoolParam hide_knots;
-    BoolParam ignore_radius_0;
+    UnitParam unit;
+    EnumParam<Filletmethod> method;
+    ScalarParam radius;
+    ScalarParam chamfer_steps;
+    BoolParam flexible;
+    BoolParam mirror_knots;
     BoolParam only_selected;
-    BoolParam flexible;
     BoolParam use_knot_distance;
-    EnumParam<FilletMethod> method;
-    ScalarParam radius;
-    ScalarParam chamfer_steps;
+    BoolParam hide_knots;
+    BoolParam apply_no_radius;
+    BoolParam apply_with_radius;
     ScalarParam helper_size;
+    bool _degenerate_hide;
+    PathVectorSatellites *_pathvector_satellites;
+    Geom::PathVector _hp;
 
     LPEFilletChamfer(const LPEFilletChamfer &);
     LPEFilletChamfer &operator=(const LPEFilletChamfer &);

=== modified file 'src/live_effects/parameter/array.cpp'
--- src/live_effects/parameter/array.cpp	2014-03-27 01:33:44 +0000
+++ src/live_effects/parameter/array.cpp	2017-05-06 17:46:29 +0000
@@ -5,10 +5,7 @@
  */
 
 #include "live_effects/parameter/array.h"
-
-#include "svg/svg.h"
-#include "svg/stringstream.h"
-
+#include "helper-fns.h"
 #include <2geom/coord.h>
 #include <2geom/point.h>
 
@@ -49,6 +46,45 @@
     return Geom::Point(Geom::infinity(),Geom::infinity());
 }
 
+
+template <>
+std::vector<Satellite>
+ArrayParam<std::vector<Satellite > >::readsvg(const gchar * str)
+{
+    std::vector<Satellite> subpath_satellites;
+    if (!str) {
+        return subpath_satellites;
+    }
+    gchar ** strarray = g_strsplit(str, "@", 0);
+    gchar ** iter = strarray;
+    while (*iter != NULL) {
+        gchar ** strsubarray = g_strsplit(*iter, ",", 8);
+        if (*strsubarray[7]) {//steps always > 0
+            Satellite *satellite = new Satellite();
+            satellite->setSatelliteType(g_strstrip(strsubarray[0]));
+            satellite->is_time = strncmp(strsubarray[1],"1",1) == 0;
+            satellite->selected = strncmp(strsubarray[2],"1",1) == 0;
+            satellite->has_mirror = strncmp(strsubarray[3],"1",1) == 0;
+            satellite->hidden = strncmp(strsubarray[4],"1",1) == 0;
+            double amount,angle;
+            float stepsTmp;
+            sp_svg_number_read_d(strsubarray[5], &amount);
+            sp_svg_number_read_d(strsubarray[6], &angle);
+            sp_svg_number_read_f(g_strstrip(strsubarray[7]), &stepsTmp);
+            unsigned int steps = (unsigned int)stepsTmp;
+            satellite->amount = amount;
+            satellite->angle = angle;
+            satellite->steps = steps;
+            subpath_satellites.push_back(*satellite);
+        }
+        g_strfreev (strsubarray);
+        iter++;
+    }
+    g_strfreev (strarray);
+    return subpath_satellites;
+}
+
+
 } /* namespace LivePathEffect */
 
 } /* namespace Inkscape */

=== modified file 'src/live_effects/parameter/array.h'
--- src/live_effects/parameter/array.h	2017-04-29 00:01:22 +0000
+++ src/live_effects/parameter/array.h	2017-05-06 17:46:29 +0000
@@ -15,6 +15,7 @@
 
 #include "live_effects/parameter/parameter.h"
 
+#include "helper/geom-satellite.h"
 #include "svg/svg.h"
 #include "svg/stringstream.h"
 
@@ -93,7 +94,43 @@
                 // separate items with pipe symbol
                 str << " | ";
             }
-            str << vector[i];
+            writesvgData(str,vector[i]);
+        }
+    }
+    
+    void writesvgData(SVGOStringStream &str, float const &vector_data) const {
+        str << vector_data;
+    }
+
+    void writesvgData(SVGOStringStream &str, double const &vector_data) const {
+        str << vector_data;
+    }
+
+    void writesvgData(SVGOStringStream &str, Geom::Point const &vector_data) const {
+        str << vector_data;
+    }
+
+    void writesvgData(SVGOStringStream &str, std::vector<Satellite> const &vector_data) const {
+        for (size_t i = 0; i < vector_data.size(); ++i) {
+            if (i != 0) {
+                // separate items with @ symbol ¿Any other?
+                str << " @ ";
+            }
+            str << vector_data[i].getSatelliteTypeGchar();
+            str << ",";
+            str << vector_data[i].is_time;
+            str << ",";
+            str << vector_data[i].selected;
+            str << ",";
+            str << vector_data[i].has_mirror;
+            str << ",";
+            str << vector_data[i].hidden;
+            str << ",";
+            str << vector_data[i].amount;
+            str << ",";
+            str << vector_data[i].angle;
+            str << ",";
+            str << vector_data[i].steps;
         }
     }
 

=== removed file 'src/live_effects/parameter/filletchamferpointarray.cpp'
--- src/live_effects/parameter/filletchamferpointarray.cpp	2016-12-19 20:54:42 +0000
+++ src/live_effects/parameter/filletchamferpointarray.cpp	1970-01-01 00:00:00 +0000
@@ -1,873 +0,0 @@
-/*
- * Copyright (C) Jabiertxo Arraiza Cenoz <[e-mail]>
- * Special thanks to Johan Engelen for the base of the effect -powerstroke-
- * Also to ScislaC for point me to the idea
- * Also su_v for his construvtive feedback and time
- * and finaly to Liam P. White for his big help on coding, that save me a lot of
- * hours
- * Released under GNU GPL, read the file 'COPYING' for more information
- */
-
-#include <2geom/piecewise.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/sbasis-geometric.h>
-#include <2geom/line.h>
-#include <2geom/path-intersection.h>
-
-#include "ui/dialog/lpe-fillet-chamfer-properties.h"
-#include "live_effects/parameter/filletchamferpointarray.h"
-#include "live_effects/effect.h"
-#include "svg/svg.h"
-#include "svg/stringstream.h"
-#include "knotholder.h"
-#include "sp-lpe-item.h"
-#include "selection.h"
-
-// needed for on-canvas editting:
-#include "live_effects/lpeobject.h"
-#include "helper/geom-nodetype.h"
-#include "helper/geom-curves.h"
-#include "ui/tools/node-tool.h"
-
-// TODO due to internal breakage in glibmm headers,
-// this has to be included last.
-#include <glibmm/i18n.h>
-
-
-using namespace Geom;
-
-namespace Inkscape {
-
-namespace LivePathEffect {
-
-FilletChamferPointArrayParam::FilletChamferPointArrayParam(
-    const Glib::ustring &label, const Glib::ustring &tip,
-    const Glib::ustring &key, Inkscape::UI::Widget::Registry *wr,
-    Effect *effect)
-    : ArrayParam<Point>(label, tip, key, wr, effect, 0)
-{
-    knot_shape = SP_KNOT_SHAPE_DIAMOND;
-    knot_mode = SP_KNOT_MODE_XOR;
-    knot_color = 0x00ff0000;
-}
-
-FilletChamferPointArrayParam::~FilletChamferPointArrayParam() {}
-
-Gtk::Widget *FilletChamferPointArrayParam::param_newWidget()
-{
-    return NULL;
-    /*
-          Inkscape::UI::Widget::RegisteredTransformedPoint * pointwdg =
-        Gtk::manage(
-              new Inkscape::UI::Widget::RegisteredTransformedPoint(
-        param_label,
-                                                                    param_tooltip,
-                                                                    param_key,
-                                                                    *param_wr,
-                                                                    param_effect->getRepr(),
-                                                                    param_effect->getSPDoc()
-        ) );
-          // TODO: fix to get correct desktop (don't use SP_ACTIVE_DESKTOP)
-          SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-          Affine transf = desktop->doc2dt();
-          pointwdg->setTransform(transf);
-          pointwdg->setValue( *this );
-          pointwdg->clearProgrammatically();
-          pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT,
-        _("Change point parameter"));
-
-          Gtk::HBox * hbox = Gtk::manage( new Gtk::HBox() );
-          static_cast<Gtk::HBox*>(hbox)->pack_start(*pointwdg, true, true);
-          static_cast<Gtk::HBox*>(hbox)->show_all_children();
-
-          return dynamic_cast<Gtk::Widget *> (hbox);
-      */
-}
-
-void
-FilletChamferPointArrayParam::param_transform_multiply(Affine const &postmul,
-        bool /*set*/)
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
-    if (prefs->getBool("/options/transform/rectcorners", true) &&
-            _vector[1][X] <= 0) {
-        std::vector<Geom::Point> result;
-        for (std::vector<Point>::const_iterator point_it = _vector.begin();
-                point_it != _vector.end(); ++point_it) {
-            Coord A =
-                (*point_it)[X] * ((postmul.expansionX() + postmul.expansionY()) / 2);
-            result.push_back(Point(A, (*point_it)[Y]));
-        }
-        param_set_and_write_new_value(result);
-    }
-
-    //    param_set_and_write_new_value( (*this) * postmul );
-}
-
-/** call this method to recalculate the controlpoints such that they stay at the
- * same location relative to the new path. Useful after adding/deleting nodes to
- * the path.*/
-void FilletChamferPointArrayParam::recalculate_controlpoints_for_new_pwd2(
-    Piecewise<D2<SBasis> > const &pwd2_in)
-{
-    if (!last_pwd2.empty()) {
-        PathVector const pathv =
-            path_from_piecewise(remove_short_cuts(pwd2_in, 0.1), 0.001);
-        PathVector last_pathv =
-            path_from_piecewise(remove_short_cuts(last_pwd2, 0.1), 0.001);
-        std::vector<Point> result;
-        unsigned long counter = 0;
-        unsigned long counterPaths = 0;
-        unsigned long counterCurves = 0;
-        long offset = 0;
-        long offsetPaths = 0;
-        Geom::NodeType nodetype;
-        for (PathVector::const_iterator path_it = pathv.begin();
-                path_it != pathv.end(); ++path_it) {
-            if (path_it->empty()) {
-                counterPaths++;
-                counter++;
-                continue;
-            }
-            Geom::Path::const_iterator curve_it1 = path_it->begin();
-            Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
-            Geom::Path::const_iterator curve_endit = path_it->end_default();
-            if (path_it->closed() && path_it->back_closed().isDegenerate()) {
-                const Curve &closingline = path_it->back_closed();
-                if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
-                    curve_endit = path_it->end_open();
-                }
-            }
-            counterCurves = 0;
-            while (curve_it1 != curve_endit) {
-                //if start a path get node type
-                if (counterCurves == 0) {
-                    if (path_it->closed()) {
-                        if (path_it->back_closed().isDegenerate()) {
-                            nodetype = get_nodetype(path_it->back_open(), *curve_it1);
-                        } else {
-                            nodetype = get_nodetype(path_it->back_closed(), *curve_it1);
-                        }
-                    } else {
-                        nodetype = NODE_NONE;
-                    }
-                } else {
-                    //check node type also whith straight lines because get_nodetype
-                    //return non cusp node in a node inserted inside a straight line
-                    //todo: if the path remove some nodes whith the result of a straight
-                    //line but with handles, the node inserted into dont fire the knot
-                    // because is not handle as cusp node by  get_nodetype function
-                    bool next_is_line = is_straight_curve(*curve_it1);
-                    bool this_is_line = is_straight_curve((*path_it)[counterCurves - 1]);
-                    nodetype = get_nodetype((*path_it)[counterCurves - 1], *curve_it1);
-                    if (this_is_line || next_is_line) {
-                        nodetype = NODE_CUSP;
-                    }
-                }
-                if (last_pathv.size() > pathv.size() ||
-                        (last_pathv.size() > counterPaths && 
-                        last_pathv[counterPaths].size() > counter - offset &&
-                         !are_near(curve_it1->initialPoint(),
-                                   last_pathv[counterPaths][counter - offset].initialPoint(),
-                                   0.1))) {
-                    if ( curve_it2 == curve_endit) {
-                        if (last_pathv[counterPaths].size() != pathv[counterPaths].size()) {
-                            offset = (last_pathv[counterPaths].size() - pathv[counterPaths].size()) * -1;
-                        } else {
-                            offset = 0;
-                        }
-                        offsetPaths += offset;
-                        offset = offsetPaths;
-                    } else if (counterCurves == 0 && last_pathv.size() <= pathv.size() &&
-                            counter - offset <= last_pathv[counterPaths].size() &&
-                            are_near(curve_it1->initialPoint(),
-                                     last_pathv[counterPaths].finalPoint(), 0.1) &&
-                                     !last_pathv[counterPaths].closed()) {
-                        long e = counter - offset + 1;
-                        std::vector<Point> tmp = _vector;
-                        for (unsigned long i =
-                                     last_pathv[counterPaths].size() + counter - offset;
-                                i > counterCurves - offset + 1; i--) {
-
-                            if (tmp[i - 1][X] > 0) {
-                                double fractpart, intpart;
-                                fractpart = modf(tmp[i - 1][X], &intpart);
-                                _vector[e] = Point(e + fractpart, tmp[i - 1][Y]);
-                            } else {
-                                _vector[e] = Point(tmp[i - 1][X], tmp[i - 1][Y]);
-                            }
-                            e++;
-                        }
-                        //delete temp vector
-                        std::vector<Point>().swap(tmp);
-                        if (last_pathv.size() > counterPaths) {
-                            last_pathv[counterPaths] = last_pathv[counterPaths].reversed();
-                        }
-                    } else {
-                        if (last_pathv.size() > counterPaths) {
-                            if (last_pathv[counterPaths].size() <
-                                    pathv[counterPaths].size()) {
-                                offset++;
-                            } else if (last_pathv[counterPaths].size() >
-                                       pathv[counterPaths].size()) {
-                                offset--;
-                                continue;
-                            }
-                        } else {
-                            offset++;
-                        }
-                    }
-                    double xPos = 0;
-                    if (_vector[1][X] > 0) {
-                        xPos = nearest_time(curve_it1->initialPoint(), pwd2_in);
-                    }
-                    if (nodetype == NODE_CUSP) {
-                        result.push_back(Point(xPos, 1));
-                    } else {
-                        result.push_back(Point(xPos, 0));
-                    }
-                } else {
-                    double xPos = _vector[counter - offset][X];
-                    if (_vector.size() <= (unsigned)(counter - offset)) {
-                        if (_vector[1][X] > 0) {
-                            xPos = nearest_time(curve_it1->initialPoint(), pwd2_in);
-                        } else {
-                            xPos = 0;
-                        }
-                    }
-                    if (nodetype == NODE_CUSP) {
-                        double vectorY = _vector[counter - offset][Y];
-                        if (_vector.size() <= (unsigned)(counter - offset) || vectorY == 0) {
-                            vectorY = 1;
-                        }
-                        result.push_back(Point(xPos, vectorY));
-                    } else {
-                        if (_vector[1][X] < 0) {
-                            xPos = 0;
-                        }
-                        result.push_back(Point(floor(xPos), 0));
-                    }
-                }
-                ++curve_it1;
-                if (curve_it2 != curve_endit) {
-                    ++curve_it2;
-                }
-                counter++;
-                counterCurves++;
-            }
-            counterPaths++;
-        }
-        _vector = result;
-        write_to_SVG();
-    }
-}
-
-void FilletChamferPointArrayParam::recalculate_knots(
-    Piecewise<D2<SBasis> > const &pwd2_in)
-{
-    bool change = false;
-    if(_vector.size() == 0){
-        return;
-    }
-    PathVector pathv = path_from_piecewise(pwd2_in, 0.001);
-    if (!pathv.empty()) {
-        std::vector<Point> result;
-        int counter = 0;
-        int counterCurves = 0;
-        Geom::NodeType nodetype;
-        for (PathVector::const_iterator path_it = pathv.begin();
-                path_it != pathv.end(); ++path_it) {
-            if (path_it->empty()) {
-                counter++;
-                continue;
-            }
-            Geom::Path::const_iterator curve_it1 = path_it->begin();
-            Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
-            Geom::Path::const_iterator curve_endit = path_it->end_default();
-            if (path_it->closed() && path_it->back_closed().isDegenerate()) {
-                const Curve &closingline = path_it->back_closed();
-                if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
-                    curve_endit = path_it->end_open();
-                }
-            }
-            counterCurves = 0;
-            while (curve_it1 != curve_endit) {
-                //if start a path get node type
-                if (counterCurves == 0) {
-                    if (path_it->closed()) {
-                        if (path_it->back_closed().isDegenerate()) {
-                            nodetype = get_nodetype(path_it->back_open(), *curve_it1);
-                        } else {
-                            nodetype = get_nodetype(path_it->back_closed(), *curve_it1);
-                        }
-                    } else {
-                        nodetype = NODE_NONE;
-                    }
-                } else {
-                    bool next_is_line = is_straight_curve(*curve_it1);
-                    bool this_is_line = is_straight_curve((*path_it)[counterCurves - 1]);
-                    nodetype = get_nodetype((*path_it)[counterCurves - 1], *curve_it1);
-                    if (this_is_line || next_is_line) {
-                        nodetype = NODE_CUSP;
-                    }
-                }
-                if (nodetype == NODE_CUSP) {
-                    double vectorY = _vector[counter][Y];
-                    if (vectorY == 0) {
-                        vectorY = 1;
-                        change = true;
-                    }
-                    result.push_back(Point(_vector[counter][X], vectorY));
-                } else {
-                    double xPos = floor(_vector[counter][X]);
-                    if (_vector[1][X] < 0) {
-                        xPos = 0;
-                    }
-                    double vectorY = _vector[counter][Y];
-                    if (vectorY != 0) {
-                        change = true;
-                    }
-                    result.push_back(Point(xPos, 0));
-                }
-                ++curve_it1;
-                counter++;
-                if (curve_it2 != curve_endit) {
-                    ++curve_it2;
-                }
-                counterCurves++;
-            }
-        }
-        if (change) {
-            _vector = result;
-            write_to_SVG();
-        }
-    }
-}
-
-void FilletChamferPointArrayParam::set_pwd2(
-    Piecewise<D2<SBasis> > const &pwd2_in,
-    Piecewise<D2<SBasis> > const &pwd2_normal_in)
-{
-    last_pwd2 = pwd2_in;
-    last_pwd2_normal = pwd2_normal_in;
-}
-
-void FilletChamferPointArrayParam::set_helper_size(int hs)
-{
-    helper_size = hs;
-}
-
-void FilletChamferPointArrayParam::set_chamfer_steps(int value_chamfer_steps)
-{
-    chamfer_steps = value_chamfer_steps;
-}
-
-void FilletChamferPointArrayParam::set_use_distance(bool use_knot_distance )
-{
-    use_distance = use_knot_distance;
-}
-
-void FilletChamferPointArrayParam::updateCanvasIndicators()
-{
-    std::vector<Point> ts = data();
-    hp.clear();
-    unsigned int i = 0;
-    for (std::vector<Point>::const_iterator point_it = ts.begin();
-            point_it != ts.end(); ++point_it) {
-        double Xvalue = to_time(i, (*point_it)[X]) -i;
-        if (Xvalue == 0) {
-            i++;
-            continue;
-        }
-        Geom::Point ptA = last_pwd2[i].valueAt(Xvalue);
-        Geom::Point derivA = unit_vector(derivative(last_pwd2[i]).valueAt(Xvalue));
-        Geom::Rotate rot(Geom::Rotate::from_degrees(-90));
-        derivA = derivA * rot;
-        Geom::Point C = ptA - derivA * helper_size;
-        Geom::Point D = ptA + derivA * helper_size;
-        Geom::Ray ray1(C, D);
-        char const * svgd = "M 1,0.25 0.5,0 1,-0.25 M 1,0.5 0,0 1,-0.5";
-        Geom::PathVector pathv = sp_svg_read_pathv(svgd);
-        Geom::Affine aff = Geom::Affine();
-        aff *= Geom::Scale(helper_size);
-        aff *= Geom::Rotate(ray1.angle() - rad_from_deg(270));
-        aff *= Geom::Translate(last_pwd2[i].valueAt(Xvalue));
-        pathv *= aff;
-        hp.push_back(pathv[0]);
-        hp.push_back(pathv[1]);
-        i++;
-    }
-}
-
-void FilletChamferPointArrayParam::addCanvasIndicators(
-    SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
-{
-    hp_vec.push_back(hp);
-}
-
-double FilletChamferPointArrayParam::rad_to_len(int index, double rad)
-{
-    double len = 0;
-    Geom::PathVector subpaths = path_from_piecewise(last_pwd2, 0.1);
-    std::pair<std::size_t, std::size_t> positions = get_positions(index, subpaths);
-    D2<SBasis> A = last_pwd2[last_index(index, subpaths)];
-    if(positions.second != 0){
-        A = last_pwd2[index-1];
-    }else{
-        if(!subpaths[positions.first].closed()){
-            return len;
-        }
-    }
-    D2<SBasis> B = last_pwd2[index];
-    Piecewise<D2<SBasis> > offset_curve0 = Piecewise<D2<SBasis> >(A)+rot90(unitVector(derivative(A)))*(rad);
-    Piecewise<D2<SBasis> > offset_curve1 = Piecewise<D2<SBasis> >(B)+rot90(unitVector(derivative(B)))*(rad);
-    Geom::Path p0 = path_from_piecewise(offset_curve0, 0.1)[0];
-    Geom::Path p1 = path_from_piecewise(offset_curve1, 0.1)[0];
-    Geom::Crossings cs = Geom::crossings(p0, p1);
-    if(cs.size() > 0){
-        Point cp =p0(cs[0].ta);
-        double p0pt = nearest_time(cp, B);
-        len = time_to_len(index,p0pt);
-    } else {
-        if(rad < 0){
-            len = rad_to_len(index, rad * -1);
-        }
-    }
-    return len;
-}
-
-double FilletChamferPointArrayParam::len_to_rad(int index, double len)
-{
-    double rad = 0;
-    double tmp_len = _vector[index][X];
-    _vector[index] = Geom::Point(len,_vector[index][Y]);
-    Geom::PathVector subpaths = path_from_piecewise(last_pwd2, 0.1);
-    std::pair<std::size_t, std::size_t> positions = get_positions(index, subpaths);
-    Piecewise<D2<SBasis> > u;
-    u.push_cut(0);          
-    u.push(last_pwd2[last_index(index, subpaths)], 1);
-    Geom::Curve * A = path_from_piecewise(u, 0.1)[0][0].duplicate();
-    Geom::Curve * B = subpaths[positions.first][positions.second].duplicate();
-    std::vector<double> times;
-    if(positions.second != 0){
-        A = subpaths[positions.first][positions.second-1].duplicate();
-        times = get_times(index-1, subpaths, false);
-    }else{
-        if(!subpaths[positions.first].closed()){
-            return rad;
-        }
-        times = get_times(last_index(index, subpaths), subpaths, true);
-    }
-    _vector[index] = Geom::Point(tmp_len,_vector[index][Y]);
-    Geom::Point startArcPoint = A->toSBasis().valueAt(times[1]);
-    Geom::Point endArcPoint = B->toSBasis().valueAt(times[2]);
-    Curve *knotCurve1 = A->portion(times[0], times[1]);
-    Curve *knotCurve2 = B->portion(times[2], 1);
-    Geom::CubicBezier const *cubic1 = dynamic_cast<Geom::CubicBezier const *>(knotCurve1);
-    Ray ray1(startArcPoint, A->finalPoint());
-    if (cubic1) {
-        ray1.setPoints((*cubic1)[2], startArcPoint);
-    }
-    Geom::CubicBezier const *cubic2 = dynamic_cast<Geom::CubicBezier const *>(knotCurve2);
-    Ray ray2(B->initialPoint(), endArcPoint);
-    if (cubic2) {
-        ray2.setPoints(endArcPoint, (*cubic2)[1]);
-    }
-    bool ccwToggle = cross(A->finalPoint() - startArcPoint, endArcPoint - startArcPoint) > 0;
-    double distanceArc = Geom::distance(startArcPoint,middle_point(startArcPoint,endArcPoint));
-    double angleBetween = angle_between(ray1, ray2, ccwToggle);
-    rad = distanceArc/sin(angleBetween/2.0);
-    return rad * -1;
-}
-
-std::vector<double> FilletChamferPointArrayParam::get_times(int index, Geom::PathVector subpaths, bool last)
-{
-    const double tolerance = 0.001;
-    const double gapHelper = 0.00001;
-    std::pair<std::size_t, std::size_t> positions = get_positions(index, subpaths);
-    Curve *curve_it1;
-    curve_it1 = subpaths[positions.first][positions.second].duplicate();
-    Coord it1_length = (*curve_it1).length(tolerance);
-    double time_it1, time_it2, time_it1_B, intpart;
-    if (static_cast<int>(_vector.size()) <= index){
-        std::vector<double> out;
-        out.push_back(0);
-        out.push_back(1);
-        out.push_back(0);
-        return out;
-    }
-    time_it1 = modf(to_time(index, _vector[index][X]), &intpart);
-    if (_vector[index][Y] == 0) {
-        time_it1 = 0;
-    }
-    double resultLenght = 0;
-    if (subpaths[positions.first].closed() && last) {
-        time_it2 = modf(to_time(index - positions.second , _vector[index - positions.second ][X]), &intpart);
-        resultLenght = it1_length + to_len(index - positions.second, _vector[index - positions.second ][X]);
-    } else if (!subpaths[positions.first].closed() && last){
-        time_it2 = 0;
-        resultLenght = 0;
-    } else {
-        time_it2 = modf(to_time(index + 1, _vector[index + 1][X]), &intpart);
-        resultLenght = it1_length + to_len( index + 1, _vector[index + 1][X]);
-    }
-    if (resultLenght > 0 && time_it2 != 0) {
-        time_it1_B = modf(to_time(index, -resultLenght), &intpart);
-    } else {
-        if (time_it2 == 0) {
-            time_it1_B = 1;
-        } else {
-            time_it1_B = gapHelper;
-        }
-    }
-
-    if ((subpaths[positions.first].closed() && last && _vector[index - positions.second][Y] == 0) || (subpaths[positions.first].size() > positions.second + 1 && _vector[index + 1][Y] == 0)) {
-        time_it1_B = 1;
-        time_it2 = 0;
-    }
-    if (time_it1_B < time_it1) {
-        time_it1_B = time_it1 + gapHelper;
-    }
-    std::vector<double> out;
-    out.push_back(time_it1);
-    out.push_back(time_it1_B);
-    out.push_back(time_it2);
-    return out;
-}
-
-std::pair<std::size_t, std::size_t> FilletChamferPointArrayParam::get_positions(int index, Geom::PathVector subpaths)
-{
-    int counter = -1;
-    std::size_t first = 0;
-    std::size_t second = 0;
-    for (PathVector::const_iterator path_it = subpaths.begin(); path_it != subpaths.end(); ++path_it) {
-        if (path_it->empty())
-            continue;
-        Geom::Path::const_iterator curve_it1 = path_it->begin();
-        Geom::Path::const_iterator curve_endit = path_it->end_default();
-        if (path_it->closed()) {
-          const Geom::Curve &closingline = path_it->back_closed(); 
-          // the closing line segment is always of type 
-          // Geom::LineSegment.
-          if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
-            // closingline.isDegenerate() did not work, because it only checks for
-            // *exact* zero length, which goes wrong for relative coordinates and
-            // rounding errors...
-            // the closing line segment has zero-length. So stop before that one!
-            curve_endit = path_it->end_open();
-          }
-        }
-        first++;
-        second = 0;
-        while (curve_it1 != curve_endit) {
-            counter++;
-            second++;
-            if(counter == index){
-                break;
-            }
-            ++curve_it1;
-        }
-        if(counter == index){
-            break;
-        }
-    }
-    first--;
-    second--;
-    std::pair<std::size_t, std::size_t> out(first, second);
-    return out;
-}
-
-int FilletChamferPointArrayParam::last_index(int index, Geom::PathVector subpaths)
-{
-    int counter = -1;
-    bool inSubpath = false;
-    for (PathVector::const_iterator path_it = subpaths.begin(); path_it != subpaths.end(); ++path_it) {
-        if (path_it->empty())
-            continue;
-        Geom::Path::const_iterator curve_it1 = path_it->begin();
-        Geom::Path::const_iterator curve_endit = path_it->end_default();
-        if (path_it->closed()) {
-          const Geom::Curve &closingline = path_it->back_closed(); 
-          if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
-            curve_endit = path_it->end_open();
-          }
-        }
-        while (curve_it1 != curve_endit) {
-            counter++;
-            if(counter == index){
-                inSubpath = true;
-            }
-            ++curve_it1;
-        }
-        if(inSubpath){
-            break;
-        }
-    }
-    if(!inSubpath){
-        counter = -1;
-    }
-    return counter;
-}
-
-
-double FilletChamferPointArrayParam::len_to_time(int index, double len)
-{
-    double t = 0;
-    if (last_pwd2.size() > (unsigned) index) {
-        if (len != 0) {
-            if (last_pwd2[index][0].degreesOfFreedom() != 2) {
-                Piecewise<D2<SBasis> > u;
-                u.push_cut(0);          
-                u.push(last_pwd2[index], 1);
-                std::vector<double> t_roots = roots(arcLengthSb(u) - std::abs(len));
-                if (t_roots.size() > 0) {
-                    t = t_roots[0];
-                }
-            } else {
-                double lenghtPart = 0;
-                if (last_pwd2.size() > (unsigned) index) {
-                    lenghtPart = length(last_pwd2[index], EPSILON);
-                }
-                if (std::abs(len) < lenghtPart && lenghtPart != 0) {
-                    t = std::abs(len) / lenghtPart;
-                }
-            }
-        }
-        t = double(index) + t;
-    } else {
-        t = double(last_pwd2.size() - 1);
-    }
-
-    return t;
-}
-
-double FilletChamferPointArrayParam::time_to_len(int index, double time)
-{
-    double intpart;
-    double len = 0;
-    time = modf(time, &intpart);
-    double lenghtPart = 0;
-    if (last_pwd2.size() <= (unsigned) index || time == 0) {
-        return len;
-    }
-    if (last_pwd2[index][0].degreesOfFreedom() != 2) {
-        Piecewise<D2<SBasis> > u;
-        u.push_cut(0);
-        u.push(last_pwd2[index], 1);
-        u = portion(u, 0, time);
-        return length(u, 0.001) * -1;
-    }
-    lenghtPart = length(last_pwd2[index], EPSILON);
-    return (time * lenghtPart) * -1;
-}
-
-double FilletChamferPointArrayParam::to_time(int index, double A)
-{
-    if (A > 0) {
-        return A;
-    } else {
-        return len_to_time(index, A);
-    }
-}
-
-double FilletChamferPointArrayParam::to_len(int index, double A)
-{
-    if (A > 0) {
-        return time_to_len(index, A);
-    } else {
-        return A;
-    }
-}
-
-void FilletChamferPointArrayParam::set_oncanvas_looks(SPKnotShapeType shape,
-        SPKnotModeType mode,
-        guint32 color)
-{
-    knot_shape = shape;
-    knot_mode = mode;
-    knot_color = color;
-}
-
-FilletChamferPointArrayParamKnotHolderEntity::
-FilletChamferPointArrayParamKnotHolderEntity(
-    FilletChamferPointArrayParam *p, unsigned int index)
-    : _pparam(p), _index(index) {}
-
-void FilletChamferPointArrayParamKnotHolderEntity::knot_set(Point const &p,
-                                                            Point const &/*origin*/,
-                                                            guint state)
-{
-    using namespace Geom;
-
-    if (!valid_index(_index)) {
-        return;
-    }
-    Piecewise<D2<SBasis> > const &pwd2 = _pparam->get_pwd2();
-    double t = nearest_time(p, pwd2[_index]);
-    Geom::Point const s = snap_knot_position(pwd2[_index].valueAt(t), state);
-    t = nearest_time(s, pwd2[_index]);
-    if (t == 1) {
-        t = 0.9999;
-    }
-    t += _index;
-
-    if (_pparam->_vector.at(_index)[X] <= 0) {
-        _pparam->_vector.at(_index) =
-            Point(_pparam->time_to_len(_index, t), _pparam->_vector.at(_index)[Y]);
-    } else {
-        _pparam->_vector.at(_index) = Point(t, _pparam->_vector.at(_index)[Y]);
-    }
-    sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
-}
-
-Point FilletChamferPointArrayParamKnotHolderEntity::knot_get() const
-{
-    using namespace Geom;
-
-    if (!valid_index(_index)) {
-        return Point(infinity(), infinity());
-    }
-
-    Piecewise<D2<SBasis> > const &pwd2 = _pparam->get_pwd2();
-
-    double time_it = _pparam->to_time(_index, _pparam->_vector.at(_index)[X]);
-    Point canvas_point = pwd2.valueAt(time_it);
-
-    _pparam->updateCanvasIndicators();
-    return canvas_point;
-
-}
-
-void FilletChamferPointArrayParamKnotHolderEntity::knot_click(guint state)
-{
-    if (state & GDK_CONTROL_MASK) {
-        if (state & GDK_MOD1_MASK) {
-            _pparam->_vector.at(_index) = Point(_index, _pparam->_vector.at(_index)[Y]);
-            _pparam->param_set_and_write_new_value(_pparam->_vector);
-            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
-        }else{
-            using namespace Geom;
-            int type = (int)_pparam->_vector.at(_index)[Y];
-            if (type >=3000 && type < 4000){
-                type = 3;
-            }
-            if (type >=4000 && type < 5000){
-                type = 4;
-            }
-            switch(type){
-                case 1:
-                    type = 2;
-                    break;
-                case 2:
-                    type =  _pparam->chamfer_steps + 3000;
-                    break;
-                case 3:
-                    type =  _pparam->chamfer_steps + 4000;
-                    break;
-                default:
-                    type = 1;
-                    break;
-            }
-            _pparam->_vector.at(_index) = Point(_pparam->_vector.at(_index)[X], (double)type);
-            _pparam->param_set_and_write_new_value(_pparam->_vector);
-            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
-            const gchar *tip;
-            if (type >=3000 && type < 4000){
-                 tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
-                        "<b>Shift+Click</b> open dialog, "
-                        "<b>Ctrl+Alt+Click</b> reset");
-            } else if (type >=4000 && type < 5000) {
-                tip = _("<b>Inverse Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
-                        "<b>Shift+Click</b> open dialog, "
-                        "<b>Ctrl+Alt+Click</b> reset");
-            } else if (type == 2) {
-                tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toggle type, "
-                        "<b>Shift+Click</b> open dialog, "
-                        "<b>Ctrl+Alt+Click</b> reset");
-            } else {
-                tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toggle type, "
-                        "<b>Shift+Click</b> open dialog, "
-                        "<b>Ctrl+Alt+Click</b> reset");
-            }
-            this->knot->tip = g_strdup(tip);
-            this->knot->show();
-        }
-    } else if (state & GDK_SHIFT_MASK) {
-        double xModified = _pparam->_vector.at(_index).x(); 
-        if(xModified < 0 && !_pparam->use_distance){
-             xModified = _pparam->len_to_rad(_index, _pparam->_vector.at(_index).x());
-        }
-        Geom::PathVector subpaths = path_from_piecewise(_pparam->last_pwd2, 0.1);
-        std::pair<std::size_t, std::size_t> positions = _pparam->get_positions(_index, subpaths);
-        D2<SBasis> A = _pparam->last_pwd2[_pparam->last_index(_index, subpaths)];
-        if(positions.second != 0){
-            A = _pparam->last_pwd2[_index-1];
-        }
-        D2<SBasis> B = _pparam->last_pwd2[_index];
-        bool aprox = (A[0].degreesOfFreedom() != 2 || B[0].degreesOfFreedom() != 2) && !_pparam->use_distance?true:false;
-        Geom::Point offset = Geom::Point(xModified, _pparam->_vector.at(_index).y());
-        Inkscape::UI::Dialogs::FilletChamferPropertiesDialog::showDialog(
-            this->desktop, offset, this, _pparam->use_distance, aprox);
-    }
-
-}
-
-void FilletChamferPointArrayParamKnotHolderEntity::knot_set_offset(
-    Geom::Point offset)
-{
-    double xModified = offset.x(); 
-    if(xModified < 0 && !_pparam->use_distance){
-         xModified = _pparam->rad_to_len(_index, offset.x());
-    }
-    _pparam->_vector.at(_index) = Geom::Point(xModified, offset.y());
-    this->parent_holder->knot_ungrabbed_handler(this->knot, 0);
-}
-
-void FilletChamferPointArrayParam::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item) {
-    recalculate_knots(get_pwd2());
-    for (unsigned int i = 0; i < _vector.size(); ++i) {
-        if (_vector[i][Y] <= 0) {
-            continue;
-        }
-        const gchar *tip;
-        if (_vector[i][Y] >=3000 && _vector[i][Y] < 4000){
-             tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
-                    "<b>Shift+Click</b> open dialog, "
-                    "<b>Ctrl+Alt+Click</b> reset");
-        } else if (_vector[i][Y] >=4000 && _vector[i][Y] < 5000) {
-            tip = _("<b>Inverse Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
-                    "<b>Shift+Click</b> open dialog, "
-                    "<b>Ctrl+Alt+Click</b> reset");
-        } else if (_vector[i][Y] == 2) {
-            tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toggle type, "
-                    "<b>Shift+Click</b> open dialog, "
-                    "<b>Ctrl+Alt+Click</b> reset");
-        } else {
-            tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toggle type, "
-                    "<b>Shift+Click</b> open dialog, "
-                    "<b>Ctrl+Alt+Click</b> reset");
-        }
-        FilletChamferPointArrayParamKnotHolderEntity *e =
-            new FilletChamferPointArrayParamKnotHolderEntity(this, i);
-        e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _(tip),
-                  knot_shape, knot_mode, knot_color);
-        knotholder->add(e);
-    }
-    updateCanvasIndicators();
-}
-
-} /* 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 :

=== removed file 'src/live_effects/parameter/filletchamferpointarray.h'
--- src/live_effects/parameter/filletchamferpointarray.h	2017-04-29 00:01:22 +0000
+++ src/live_effects/parameter/filletchamferpointarray.h	1970-01-01 00:00:00 +0000
@@ -1,123 +0,0 @@
-#ifndef INKSCAPE_LIVEPATHEFFECT_FILLET_CHAMFER_POINT_ARRAY_H
-#define INKSCAPE_LIVEPATHEFFECT_FILLET_CHAMFER_POINT_ARRAY_H
-
-/*
- * Inkscape::LivePathEffectParameters
- * Copyright (C) Jabiertxo Arraiza Cenoz <[e-mail]>
- * Special thanks to Johan Engelen for the base of the effect -powerstroke-
- * Also to ScislaC for point me to the idea
- * Also su_v for his construvtive feedback and time
- * and finaly to Liam P. White for his big help on coding, that save me a lot of
- * hours
- * Released under GNU GPL, read the file 'COPYING' for more information
- */
-
-#include <glib.h>
-#include <2geom/point.h>
-
-#include "live_effects/parameter/array.h"
-
-#include "knot-holder-entity.h"
-
-namespace Inkscape {
-
-namespace LivePathEffect {
-
-class FilletChamferPointArrayParamKnotHolderEntity;
-
-class FilletChamferPointArrayParam : public ArrayParam<Geom::Point> {
-public:
-    FilletChamferPointArrayParam(const Glib::ustring &label,
-                                 const Glib::ustring &tip,
-                                 const Glib::ustring &key,
-                                 Inkscape::UI::Widget::Registry *wr,
-                                 Effect *effect);
-    virtual ~FilletChamferPointArrayParam();
-
-    virtual Gtk::Widget *param_newWidget();
-
-    virtual void param_transform_multiply(Geom::Affine const &postmul,
-                                          bool /*set*/);
-
-    void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode,
-                            guint32 color);
-    virtual double to_time(int index, double A);
-    virtual double to_len(int index, double A);
-    virtual double rad_to_len(int index, double rad);
-    virtual double len_to_rad(int index, double len);
-    virtual double len_to_time(int index, double len);
-    virtual double time_to_len(int index, double time);
-    virtual std::pair<std::size_t, std::size_t> get_positions(int index, Geom::PathVector subpaths);
-    virtual int last_index(int index, Geom::PathVector subpaths);
-    std::vector<double> get_times(int index, Geom::PathVector subpaths, bool last);
-    virtual void set_helper_size(int hs);
-    virtual void set_use_distance(bool use_knot_distance);
-    virtual void set_chamfer_steps(int value_chamfer_steps);
-    virtual void addCanvasIndicators(SPLPEItem const *lpeitem,
-                                     std::vector<Geom::PathVector> &hp_vec);
-    virtual void param_update_default(const gchar * default_value){};
-    virtual bool providesKnotHolderEntities() const {
-        return true;
-    }
-    virtual void updateCanvasIndicators();
-    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
-
-    void set_pwd2(Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in,
-                  Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_normal_in);
-    Geom::Piecewise<Geom::D2<Geom::SBasis> > const &get_pwd2() const {
-        return last_pwd2;
-    }
-    Geom::Piecewise<Geom::D2<Geom::SBasis> > const &get_pwd2_normal() const {
-        return last_pwd2_normal;
-    }
-
-    void recalculate_controlpoints_for_new_pwd2(
-        Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in);
-    void recalculate_knots(
-        Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in);
-    friend class FilletChamferPointArrayParamKnotHolderEntity;
-
-private:
-    FilletChamferPointArrayParam(const FilletChamferPointArrayParam &);
-    FilletChamferPointArrayParam &operator=(const FilletChamferPointArrayParam &);
-
-    SPKnotShapeType knot_shape;
-    SPKnotModeType knot_mode;
-    guint32 knot_color;
-    int helper_size;
-    int chamfer_steps;
-    bool use_distance;
-    Geom::PathVector hp;
-
-    Geom::Piecewise<Geom::D2<Geom::SBasis> > last_pwd2;
-    Geom::Piecewise<Geom::D2<Geom::SBasis> > last_pwd2_normal;
-};
-
-class FilletChamferPointArrayParamKnotHolderEntity : public KnotHolderEntity {
-public:
-    FilletChamferPointArrayParamKnotHolderEntity(FilletChamferPointArrayParam *p,
-            unsigned int index);
-    virtual ~FilletChamferPointArrayParamKnotHolderEntity() {}
-
-    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin,
-                          guint state);
-    virtual Geom::Point knot_get() const;
-    virtual void knot_click(guint state);
-    virtual void knot_set_offset(Geom::Point offset);
-
-    /*Checks whether the index falls within the size of the parameter's vector*/
-    bool valid_index(unsigned int index) const {
-        return (_pparam->_vector.size() > index);
-    }
-    ;
-
-private:
-    FilletChamferPointArrayParam *_pparam;
-    unsigned int _index;
-};
-
-} //namespace LivePathEffect
-
-} //namespace Inkscape
-
-#endif

=== added file 'src/live_effects/parameter/satellitesarray.cpp'
--- src/live_effects/parameter/satellitesarray.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/satellitesarray.cpp	2017-05-06 17:46:29 +0000
@@ -0,0 +1,583 @@
+/*
+ * Author(s):
+ *   Jabiertxo Arraiza Cenoz <[e-mail]>
+ *
+ * Copyright (C) 2014 Author(s)
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "knotholder.h"
+#include "ui/dialog/lpe-fillet-chamfer-properties.h"
+#include "live_effects/parameter/satellitesarray.h"
+#include "live_effects/effect.h"
+#include "sp-lpe-item.h"
+#include "inkscape.h"
+#include <preferences.h>
+// TODO due to internal breakage in glibmm headers,
+// this has to be included last.
+#include <glibmm/i18n.h>
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+SatellitesArrayParam::SatellitesArrayParam(const Glib::ustring &label,
+        const Glib::ustring &tip,
+        const Glib::ustring &key,
+        Inkscape::UI::Widget::Registry *wr,
+        Effect *effect)
+    : ArrayParam<std::vector<Satellite> >(label, tip, key, wr, effect, 0), _knoth(NULL)
+{
+    _knot_shape = SP_KNOT_SHAPE_DIAMOND;
+    _knot_mode = SP_KNOT_MODE_XOR;
+    _knot_color = 0xAAFF8800;
+    _helper_size = 0;
+    _use_distance = false;
+    _global_knot_hide = false;
+    _current_zoom = 0;
+    _effectType = FILLET_CHAMFER;
+    _last_pathvector_satellites = NULL;
+}
+
+
+void SatellitesArrayParam::set_oncanvas_looks(SPKnotShapeType shape,
+        SPKnotModeType mode,
+        guint32 color)
+{
+    _knot_shape = shape;
+    _knot_mode = mode;
+    _knot_color = color;
+}
+
+void SatellitesArrayParam::setPathVectorSatellites(PathVectorSatellites *pathVectorSatellites, bool write)
+{
+    _last_pathvector_satellites = pathVectorSatellites;
+    if (write) {
+        param_set_and_write_new_value(_last_pathvector_satellites->getSatellites());
+    } else {
+        param_setValue(_last_pathvector_satellites->getSatellites());
+    }
+}
+
+void SatellitesArrayParam::setUseDistance(bool use_knot_distance)
+{
+    _use_distance = use_knot_distance;
+}
+
+void SatellitesArrayParam::setCurrentZoom(double current_zoom)
+{
+    _current_zoom = current_zoom;
+}
+
+void SatellitesArrayParam::setGlobalKnotHide(bool global_knot_hide)
+{
+    _global_knot_hide = global_knot_hide;
+}
+void SatellitesArrayParam::setEffectType(EffectType et)
+{
+    _effectType = et;
+}
+
+void SatellitesArrayParam::setHelperSize(int hs)
+{
+    _helper_size = hs;
+    updateCanvasIndicators();
+}
+
+void SatellitesArrayParam::updateCanvasIndicators(bool mirror)
+{
+    if (!_last_pathvector_satellites) {
+        return;
+    }
+
+    if (!_hp.empty()) {
+        _hp.clear();
+    }
+    Geom::PathVector pathv = _last_pathvector_satellites->getPathVector();
+    if (pathv.empty()) {
+        return;
+    }
+    if (mirror == true) {
+        _hp.clear();
+    }
+    if (_effectType == FILLET_CHAMFER) {
+        for (size_t i = 0; i < _vector.size(); ++i) {
+            for (size_t j = 0; j < _vector[i].size(); ++j) {
+                if (_vector[i][j].hidden || //Ignore if hidden
+                    (!_vector[i][j].has_mirror && mirror == true) || //Ignore if not have mirror and we are in mirror loop
+                    _vector[i][j].amount == 0 || //no helper in 0 value
+                    pathv[i].size() == j || //ignore last satellite in open paths with fillet chamfer effect
+                    (!pathv[i].closed() && j == 0))  //ignore first satellites on open paths
+                {
+                    continue;
+                }
+                Geom::Curve *curve_in = pathv[i][j].duplicate();
+                double pos = 0;
+                bool overflow = false;
+                double size_out = _vector[i][j].arcDistance(*curve_in);
+                double lenght_out = curve_in->length();
+                gint previous_index = j - 1; //Always are previous index because we skip first satellite on open paths
+                if (j == 0 && pathv[i].closed()) {
+                    previous_index = pathv[i].size() - 1;
+                }
+                if ( previous_index < 0 ) {
+                    return;
+                }
+                double lenght_in = pathv.curveAt(previous_index).length();
+                if (mirror) {
+                    curve_in = const_cast<Geom::Curve *>(&pathv.curveAt(previous_index));
+                    pos = _vector[i][j].time(size_out, true, *curve_in);
+                    if (lenght_out < size_out) {
+                        overflow = true;
+                    }
+                } else {
+                    pos = _vector[i][j].time(*curve_in);
+                    if (lenght_in < size_out) {
+                        overflow = true;
+                    }
+                }
+                if (pos <= 0 || pos >= 1) {
+                    continue;
+                }
+                Geom::Point point_a = curve_in->pointAt(pos);
+                Geom::Point deriv_a = unit_vector(derivative(curve_in->toSBasis()).pointAt(pos));
+                Geom::Rotate rot(Geom::Rotate::from_degrees(-90));
+                deriv_a = deriv_a * rot;
+                Geom::Point point_c = point_a - deriv_a * _helper_size;
+                Geom::Point point_d = point_a + deriv_a * _helper_size;
+                Geom::Ray ray_1(point_c, point_d);
+                char const *svgd = "M 1,0.25 0.5,0 1,-0.25 M 1,0.5 0,0 1,-0.5";
+                Geom::PathVector pathv = sp_svg_read_pathv(svgd);
+                Geom::Affine aff = Geom::Affine();
+                aff *= Geom::Scale(_helper_size);
+                if (mirror) {
+                    aff *= Geom::Rotate(ray_1.angle() - Geom::rad_from_deg(90));
+                } else {
+                    aff *= Geom::Rotate(ray_1.angle() - Geom::rad_from_deg(270));
+                }
+                aff *= Geom::Translate(curve_in->pointAt(pos));
+                pathv *= aff;
+                _hp.push_back(pathv[0]);
+                _hp.push_back(pathv[1]);
+                if (overflow) {
+                    double diameter = _helper_size;
+                    if (_helper_size == 0) {
+                        diameter = 15;
+                        char const *svgd;
+                        svgd = "M 0.7,0.35 A 0.35,0.35 0 0 1 0.35,0.7 0.35,0.35 0 0 1 0,0.35 "
+                               "0.35,0.35 0 0 1 0.35,0 0.35,0.35 0 0 1 0.7,0.35 Z";
+                        Geom::PathVector pathv = sp_svg_read_pathv(svgd);
+                        aff = Geom::Affine();
+                        aff *= Geom::Scale(diameter);
+                        aff *= Geom::Translate(point_a - Geom::Point(diameter * 0.35, diameter * 0.35));
+                        pathv *= aff;
+                        _hp.push_back(pathv[0]);
+                    } else {
+                        char const *svgd;
+                        svgd = "M 0 -1.32 A 1.32 1.32 0 0 0 -1.32 0 A 1.32 1.32 0 0 0 0 1.32 A "
+                               "1.32 1.32 0 0 0 1.18 0.59 L 0 0 L 1.18 -0.59 A 1.32 1.32 0 0 0 "
+                               "0 -1.32 z";
+                        Geom::PathVector pathv = sp_svg_read_pathv(svgd);
+                        aff = Geom::Affine();
+                        aff *= Geom::Scale(_helper_size / 2.0);
+                        if (mirror) {
+                            aff *= Geom::Rotate(ray_1.angle() - Geom::rad_from_deg(90));
+                        } else {
+                            aff *= Geom::Rotate(ray_1.angle() - Geom::rad_from_deg(270));
+                        }
+                        aff *= Geom::Translate(curve_in->pointAt(pos));
+                        pathv *= aff;
+                        _hp.push_back(pathv[0]);
+                    }
+                }
+            }
+        }
+    }
+    if (!_knot_reset_helper.empty()) {
+        _hp.insert(_hp.end(), _knot_reset_helper.begin(), _knot_reset_helper.end() );
+    }
+    if (mirror) {
+        updateCanvasIndicators(false);
+    }
+}
+void SatellitesArrayParam::updateCanvasIndicators()
+{
+    updateCanvasIndicators(true);
+}
+
+void SatellitesArrayParam::addCanvasIndicators(
+    SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
+{
+    hp_vec.push_back(_hp);
+}
+
+void SatellitesArrayParam::param_transform_multiply(Geom::Affine const &postmul, bool /*set*/)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    if (prefs->getBool("/options/transform/rectcorners", true)) {
+        for (size_t i = 0; i < _vector.size(); ++i) {
+            for (size_t j = 0; j < _vector[i].size(); ++j) {
+                if (!_vector[i][j].is_time && _vector[i][j].amount > 0) {
+                    _vector[i][j].amount = _vector[i][j].amount * ((postmul.expansionX() + postmul.expansionY()) / 2);
+                }
+            }
+        }
+        param_set_and_write_new_value(_vector);
+    }
+}
+
+void SatellitesArrayParam::addKnotHolderEntities(KnotHolder *knotholder,
+                                                 SPItem *item,
+                                                 bool mirror)
+{
+    if (!_last_pathvector_satellites) {
+        return;
+    }
+    Geom::PathVector pathv = _last_pathvector_satellites->getPathVector();
+    size_t index = 0;
+    for (size_t i = 0; i < _vector.size(); ++i) {
+        for (size_t j = 0; j < _vector[i].size(); ++j) {
+            if (!_vector[i][j].has_mirror && mirror) {
+                continue;
+            }
+            SatelliteType type = _vector[i][j].satellite_type;
+            if (mirror && i == 0 && j == 0) {
+                index = index + _last_pathvector_satellites->getTotalSatellites();
+            }
+            using namespace Geom;
+            //If is for filletChamfer effect...
+            if (_effectType == FILLET_CHAMFER) {
+                const gchar *tip;
+                if (type == CHAMFER) {
+                    tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toggles type, "
+                            "<b>Shift+Click</b> open dialog, "
+                            "<b>Ctrl+Alt+Click</b> reset");
+                } else if (type == INVERSE_CHAMFER) {
+                    tip = _("<b>Inverse Chamfer</b>: <b>Ctrl+Click</b> toggles type, "
+                            "<b>Shift+Click</b> open dialog, "
+                            "<b>Ctrl+Alt+Click</b> reset");
+                } else if (type == INVERSE_FILLET) {
+                    tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toggles type, "
+                            "<b>Shift+Click</b> open dialog, "
+                            "<b>Ctrl+Alt+Click</b> reset");
+                } else {
+                    tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toggles type, "
+                            "<b>Shift+Click</b> open dialog, "
+                            "<b>Ctrl+Alt+Click</b> reset");
+                }
+                FilletChamferKnotHolderEntity *e = new FilletChamferKnotHolderEntity(this, index);
+                e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _(tip),_knot_shape, _knot_mode, _knot_color);
+                knotholder->add(e);
+            }
+            index++;
+        }
+    }
+    if (mirror) {
+        addKnotHolderEntities(knotholder, item, false);
+    }
+}
+
+void SatellitesArrayParam::addKnotHolderEntities(KnotHolder *knotholder,
+        SPItem *item)
+{
+    _knoth = knotholder;
+    addKnotHolderEntities(knotholder, item, true);
+}
+
+FilletChamferKnotHolderEntity::FilletChamferKnotHolderEntity(
+    SatellitesArrayParam *p, size_t index)
+    : _pparam(p), _index(index) {}
+
+void FilletChamferKnotHolderEntity::knot_set(Geom::Point const &p,
+        Geom::Point const &/*origin*/,
+        guint state)
+{
+    if (!_pparam->_last_pathvector_satellites) {
+        return;
+    }
+    size_t total_satellites = _pparam->_last_pathvector_satellites->getTotalSatellites();
+    bool is_mirror = false;
+    size_t index = _index;
+    if (_index >= total_satellites) {
+        index = _index - total_satellites;
+        is_mirror = true;
+    }
+    std::pair<size_t, size_t> index_data = _pparam->_last_pathvector_satellites->getIndexData(index);
+    size_t path_index = index_data.first;
+    size_t curve_index = index_data.second;
+    
+    Geom::Point s = snap_knot_position(p, state);
+    if (!valid_index(path_index, curve_index)) {
+        return;
+    }
+    Satellite satellite = _pparam->_vector[path_index][curve_index];
+    Geom::PathVector pathv = _pparam->_last_pathvector_satellites->getPathVector();
+    if (satellite.hidden ||
+        (!pathv[path_index].closed() && curve_index == 0) ||//ignore first satellites on open paths
+        pathv[path_index].size() == curve_index) //ignore last satellite in open paths with fillet chamfer effect
+    {
+        return;
+    }
+    gint previous_index = curve_index - 1;
+    if (curve_index == 0 && pathv[path_index].closed()) {
+        previous_index = pathv[path_index].size() - 1;
+    }
+    if ( previous_index < 0 ) {
+        return;
+    }
+    Geom::Curve const &curve_in = pathv[path_index][previous_index];
+    double mirror_time = Geom::nearest_time(s, curve_in);
+    Geom::Point mirror = curve_in.pointAt(mirror_time);
+    double normal_time = Geom::nearest_time(s, pathv[path_index][curve_index]);
+    Geom::Point normal = pathv[path_index][curve_index].pointAt(normal_time);
+    double distance_mirror = Geom::distance(mirror,s);
+    double distance_normal = Geom::distance(normal,s);
+    if (Geom::are_near(s, pathv[path_index][curve_index].initialPoint(), 1.5 / _pparam->_current_zoom)) {
+        satellite.amount = 0;
+    } else if (distance_mirror < distance_normal) {
+        double time_start = 0;
+        Satellites satellites = _pparam->_last_pathvector_satellites->getSatellites();
+        time_start = satellites[path_index][previous_index].time(curve_in);
+        if (time_start > mirror_time) {
+            mirror_time = time_start;
+        }
+        double size = arcLengthAt(mirror_time, curve_in);
+        double amount = curve_in.length() - size;
+        if (satellite.is_time) {
+            amount = timeAtArcLength(amount, pathv[path_index][curve_index]);
+        }
+        satellite.amount = amount;
+    } else {
+        satellite.setPosition(s, pathv[path_index][curve_index]);
+    }
+    _pparam->_knot_reset_helper.clear();
+    if (satellite.amount == 0) {
+        char const *svgd;
+        svgd = "M -5.39,8.78 -9.13,5.29 -10.38,10.28 Z M -7.22,7.07 -3.43,3.37 m -1.95,-12.16 -3.74,3.5 -1.26,-5 z "
+               "m -1.83,1.71 3.78,3.7 M 5.24,8.78 8.98,5.29 10.24,10.28 Z "
+               "M 7.07,7.07 3.29,3.37 M 5.24,-8.78 l 3.74,3.5 1.26,-5 z M 7.07,-7.07 3.29,-3.37";
+        _pparam->_knot_reset_helper = sp_svg_read_pathv(svgd);
+        _pparam->_knot_reset_helper *= Geom::Affine(_pparam->_helper_size * 0.1,0,0,_pparam->_helper_size * 0.1,0,0) * Geom::Translate(pathv[path_index][curve_index].initialPoint());
+    }
+    _pparam->_vector[path_index][curve_index] = satellite;
+    sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
+}
+
+Geom::Point FilletChamferKnotHolderEntity::knot_get() const
+{
+    if (!_pparam->_last_pathvector_satellites || _pparam->_global_knot_hide) {
+        return Geom::Point(Geom::infinity(), Geom::infinity());
+    }
+    Geom::Point tmp_point;
+    size_t total_satellites = _pparam->_last_pathvector_satellites->getTotalSatellites();
+    bool is_mirror = false;
+    size_t index = _index;
+    if (_index >= total_satellites) {
+        index = _index - total_satellites;
+        is_mirror = true;
+    }
+    std::pair<size_t, size_t> index_data = _pparam->_last_pathvector_satellites->getIndexData(index);
+    size_t path_index = index_data.first;
+    size_t curve_index = index_data.second;
+    if (!valid_index(path_index, curve_index)) {
+        return Geom::Point(Geom::infinity(), Geom::infinity());
+    }
+    Satellite satellite = _pparam->_vector[path_index][curve_index];
+    Geom::PathVector pathv = _pparam->_last_pathvector_satellites->getPathVector();
+    if (satellite.hidden ||
+        (!pathv[path_index].closed() && curve_index == 0) ||//ignore first satellites on open paths
+        pathv[path_index].size() == curve_index) //ignore last satellite in open paths with fillet chamfer effect
+    {
+        return Geom::Point(Geom::infinity(), Geom::infinity());
+    }
+    this->knot->show();
+    if (is_mirror) {
+        gint previous_index = curve_index - 1;
+        if (curve_index == 0 && pathv[path_index].closed()) {
+            previous_index = pathv[path_index].size() - 1;
+        }
+        if ( previous_index < 0 ) {
+            return Geom::Point(Geom::infinity(), Geom::infinity());
+        }
+        Geom::Curve const &curve_in = pathv[path_index][previous_index];
+        double s = satellite.arcDistance(pathv[path_index][curve_index]);
+        double t = satellite.time(s, true, curve_in);
+        if (t > 1) {
+            t = 1;
+        }
+        if (t < 0) {
+            t = 0;
+        }
+        double time_start = 0;
+        time_start = _pparam->_last_pathvector_satellites->getSatellites()[path_index][previous_index].time(curve_in);
+        if (time_start > t) {
+            t = time_start;
+        }
+        tmp_point = (curve_in).pointAt(t);
+    } else {
+        tmp_point = satellite.getPosition(pathv[path_index][curve_index]);
+    }
+    Geom::Point const canvas_point = tmp_point;
+    _pparam->updateCanvasIndicators();
+    return canvas_point;
+}
+
+void FilletChamferKnotHolderEntity::knot_click(guint state)
+{
+    if (!_pparam->_last_pathvector_satellites) {
+        return;
+    }
+    size_t total_satellites = _pparam->_last_pathvector_satellites->getTotalSatellites();
+    bool is_mirror = false;
+    size_t index = _index;
+    if (_index >= total_satellites) {
+        index = _index - total_satellites;
+        is_mirror = true;
+    }
+    std::pair<size_t, size_t> index_data = _pparam->_last_pathvector_satellites->getIndexData(index);
+    size_t path_index = index_data.first;
+    size_t curve_index = index_data.second;
+    if (!valid_index(path_index, curve_index)) {
+        return;
+    }
+    Geom::PathVector pathv = _pparam->_last_pathvector_satellites->getPathVector();
+    if ((!pathv[path_index].closed() && curve_index == 0) ||//ignore first satellites on open paths
+        pathv[path_index].size() == curve_index) //ignore last satellite in open paths with fillet chamfer effect
+    {
+        return;
+    }
+    if (state & GDK_CONTROL_MASK) {
+        if (state & GDK_MOD1_MASK) {
+            _pparam->_vector[path_index][curve_index].amount = 0.0;
+            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
+        } else {
+            using namespace Geom;
+            SatelliteType type = _pparam->_vector[path_index][curve_index].satellite_type;
+            switch (type) {
+            case FILLET:
+                type = INVERSE_FILLET;
+                break;
+            case INVERSE_FILLET:
+                type = CHAMFER;
+                break;
+            case CHAMFER:
+                type = INVERSE_CHAMFER;
+                break;
+            default:
+                type = FILLET;
+                break;
+            }
+            _pparam->_vector[path_index][curve_index].satellite_type = type;
+            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
+            const gchar *tip;
+            if (type == CHAMFER) {
+                tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toggles type, "
+                        "<b>Shift+Click</b> open dialog, "
+                        "<b>Ctrl+Alt+Click</b> resets");
+            } else if (type == INVERSE_CHAMFER) {
+                tip = _("<b>Inverse Chamfer</b>: <b>Ctrl+Click</b> toggles type, "
+                        "<b>Shift+Click</b> open dialog, "
+                        "<b>Ctrl+Alt+Click</b> resets");
+            } else if (type == INVERSE_FILLET) {
+                tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toggles type, "
+                        "<b>Shift+Click</b> open dialog, "
+                        "<b>Ctrl+Alt+Click</b> resets");
+            } else {
+                tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toggles type, "
+                        "<b>Shift+Click</b> open dialog, "
+                        "<b>Ctrl+Alt+Click</b> resets");
+            }
+            this->knot->tip = g_strdup(tip);
+            this->knot->show();
+        }
+    } else if (state & GDK_SHIFT_MASK) {
+        double amount = _pparam->_vector[path_index][curve_index].amount;
+        gint previous_index =  curve_index - 1;
+        if (curve_index == 0 && pathv[path_index].closed()) {
+            previous_index = pathv[path_index].size() - 1;
+        }
+        if ( previous_index < 0 ) {
+            return;
+        }
+        if (!_pparam->_use_distance && !_pparam->_vector[path_index][curve_index].is_time) {
+            amount = _pparam->_vector[path_index][curve_index].lenToRad(amount, pathv[path_index][previous_index], pathv[path_index][curve_index], _pparam->_vector[path_index][previous_index]);
+        }
+        bool aprox = false;
+        Geom::D2<Geom::SBasis> d2_out = pathv[path_index][curve_index].toSBasis();
+        Geom::D2<Geom::SBasis> d2_in = pathv[path_index][previous_index].toSBasis();
+        aprox = ((d2_in)[0].degreesOfFreedom() != 2 ||
+                 d2_out[0].degreesOfFreedom() != 2) &&
+                !_pparam->_use_distance
+                ? true
+                : false;
+        Inkscape::UI::Dialogs::FilletChamferPropertiesDialog::showDialog(
+            this->desktop, amount, this, _pparam->_use_distance,
+            aprox, _pparam->_vector[path_index][curve_index]);
+
+    }
+}
+
+void FilletChamferKnotHolderEntity::knot_set_offset(Satellite satellite)
+{
+    if (!_pparam->_last_pathvector_satellites) {
+        return;
+    }
+    size_t total_satellites = _pparam->_last_pathvector_satellites->getTotalSatellites();
+    bool is_mirror = false;
+    size_t index = _index;
+    if (_index >= total_satellites) {
+        index = _index - total_satellites;
+        is_mirror = true;
+    }
+    std::pair<size_t, size_t> index_data = _pparam->_last_pathvector_satellites->getIndexData(index);
+    size_t path_index = index_data.first;
+    size_t curve_index = index_data.second;
+    if (!valid_index(path_index, curve_index)) {
+        return;
+    }
+    Geom::PathVector pathv = _pparam->_last_pathvector_satellites->getPathVector();
+    if (satellite.hidden ||
+        (!pathv[path_index].closed() && curve_index == 0) ||//ignore first satellites on open paths
+        pathv[path_index].size() == curve_index) //ignore last satellite in open paths with fillet chamfer effect
+    {
+        return;
+    }
+    double amount = satellite.amount;
+    double max_amount = amount;
+    if (!_pparam->_use_distance && !satellite.is_time) {
+        gint previous_index = curve_index - 1;
+        if (curve_index == 0 && pathv[path_index].closed()) {
+            previous_index = pathv[path_index].size() - 1;
+        }
+        if ( previous_index < 0 ) {
+            return;
+        }
+        amount = _pparam->_vector[path_index][curve_index].radToLen(amount, pathv[path_index][previous_index], pathv[path_index][curve_index]);
+        if (max_amount > 0 && amount == 0) {
+            amount = _pparam->_vector[path_index][curve_index].amount;
+        }
+    }
+    satellite.amount = amount;
+    _pparam->_vector[path_index][curve_index] = satellite;
+    this->parent_holder->knot_ungrabbed_handler(this->knot, 0);
+    SPLPEItem *splpeitem = dynamic_cast<SPLPEItem *>(item);
+    if (splpeitem) {
+        sp_lpe_item_update_patheffect(splpeitem, false, false);
+    }
+}
+
+} /* 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 :

=== added file 'src/live_effects/parameter/satellitesarray.h'
--- src/live_effects/parameter/satellitesarray.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/satellitesarray.h	2017-05-06 17:46:29 +0000
@@ -0,0 +1,114 @@
+#ifndef INKSCAPE_LIVEPATHEFFECT_SATELLITES_ARRAY_H
+#define INKSCAPE_LIVEPATHEFFECT_SATELLITES_ARRAY_H
+
+/*
+ * Inkscape::LivePathEffectParameters
+ * Copyright (C) Jabiertxo Arraiza Cenoz <[e-mail]>
+ * Special thanks to Johan Engelen for the base of the effect -powerstroke-
+ * Also to ScislaC for point me to the idea
+ * Also su_v for his construvtive feedback and time
+ * To Nathan Hurst for his review and help on refactor
+ * and finaly to Liam P. White for his big help on coding, that save me a lot of
+ * hours
+ *
+ *
+ * This parameter act as bridge from pathVectorSatellites class to serialize it as a LPE
+ * parameter
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/parameter/array.h"
+#include "live_effects/effect-enum.h"
+#include "helper/geom-pathvectorsatellites.h"
+#include "knot-holder-entity.h"
+#include <glib.h>
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+class FilletChamferKnotHolderEntity;
+
+class SatellitesArrayParam : public ArrayParam<std::vector<Satellite> > {
+public:
+    SatellitesArrayParam(const Glib::ustring &label, const Glib::ustring &tip,
+                        const Glib::ustring &key,
+                        Inkscape::UI::Widget::Registry *wr, Effect *effect);
+
+    virtual Gtk::Widget *param_newWidget()
+    {
+        return NULL;
+    }
+    virtual void setHelperSize(int hs);
+    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
+    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item, bool mirror);
+    virtual void addCanvasIndicators(SPLPEItem const *lpeitem, std::vector<Geom::PathVector> &hp_vec);
+    virtual void updateCanvasIndicators();
+    virtual void updateCanvasIndicators(bool mirror);
+    virtual bool providesKnotHolderEntities() const
+    {
+        return true;
+    }
+    void param_transform_multiply(Geom::Affine const &postmul, bool /*set*/);
+    void setUseDistance(bool use_knot_distance);
+    void setCurrentZoom(double current_zoom);
+    void setGlobalKnotHide(bool global_knot_hide);
+    void setEffectType(EffectType et);
+    void setPathVectorSatellites(PathVectorSatellites *pathVectorSatellites, bool write = true);
+    void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
+
+    friend class FilletChamferKnotHolderEntity;
+    friend class LPEFilletChamfer;
+
+protected:
+    KnotHolder *_knoth;
+
+private:
+    SatellitesArrayParam(const SatellitesArrayParam &);
+    SatellitesArrayParam &operator=(const SatellitesArrayParam &);
+
+    SPKnotShapeType _knot_shape;
+    SPKnotModeType _knot_mode;
+    guint32 _knot_color;
+    Geom::PathVector _hp;
+    Geom::PathVector _knot_reset_helper;
+    int _helper_size;
+    bool _use_distance;
+    bool _global_knot_hide;
+    double _current_zoom;
+    EffectType _effectType;
+    PathVectorSatellites *_last_pathvector_satellites;
+
+};
+
+class FilletChamferKnotHolderEntity : public KnotHolderEntity {
+public:
+    FilletChamferKnotHolderEntity(SatellitesArrayParam *p, size_t index);
+    virtual ~FilletChamferKnotHolderEntity()
+    {
+        _pparam->_knoth = NULL;
+    }
+
+    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin,
+                          guint state);
+    virtual Geom::Point knot_get() const;
+    virtual void knot_click(guint state);
+    void knot_set_offset(Satellite);
+    /** Checks whether the index falls within the size of the parameter's vector
+     */
+    bool valid_index(size_t index,size_t subindex) const
+    {
+        return (_pparam->_vector.size() > index && _pparam->_vector[index].size() > subindex);
+    };
+
+private:
+    SatellitesArrayParam *_pparam;
+    size_t _index;
+};
+
+} //namespace LivePathEffect
+
+} //namespace Inkscape
+
+#endif

=== modified file 'src/ui/dialog/lpe-fillet-chamfer-properties.cpp'
--- src/ui/dialog/lpe-fillet-chamfer-properties.cpp	2017-03-12 13:45:15 +0000
+++ src/ui/dialog/lpe-fillet-chamfer-properties.cpp	2017-05-06 17:46:29 +0000
@@ -43,7 +43,6 @@
     //todo: get tha max aloable infinity freeze the widget
     _fillet_chamfer_position_numeric.set_range(0., SCALARPARAM_G_MAXDOUBLE);
     _fillet_chamfer_position_numeric.set_hexpand();
-    
     _fillet_chamfer_position_label.set_label(_("Radius (pixels):"));
     _fillet_chamfer_position_label.set_alignment(1.0, 0.5);
 
@@ -54,7 +53,6 @@
     //todo: get tha max aloable infinity freeze the widget
     _fillet_chamfer_chamfer_subdivisions.set_range(0, SCALARPARAM_G_MAXDOUBLE);
     _fillet_chamfer_chamfer_subdivisions.set_hexpand();
-    
     _fillet_chamfer_chamfer_subdivisions_label.set_label(_("Chamfer subdivisions:"));
     _fillet_chamfer_chamfer_subdivisions_label.set_alignment(1.0, 0.5);
 
@@ -104,23 +102,26 @@
 FilletChamferPropertiesDialog::~FilletChamferPropertiesDialog()
 {
 
-    _set_desktop(NULL);
+    _setDesktop(NULL);
 }
 
 void FilletChamferPropertiesDialog::showDialog(
-    SPDesktop *desktop, Geom::Point knotpoint,
+    SPDesktop *desktop, 
+    double _amount,
     const Inkscape::LivePathEffect::
-    FilletChamferPointArrayParamKnotHolderEntity *pt,
-    bool use_distance,
-    bool aprox_radius)
+    FilletChamferKnotHolderEntity *pt,
+    bool _use_distance,
+    bool _aprox_radius,
+    Satellite _satellite)
 {
     FilletChamferPropertiesDialog *dialog = new FilletChamferPropertiesDialog();
 
-    dialog->_set_desktop(desktop);
-    dialog->_set_use_distance(use_distance);
-    dialog->_set_aprox(aprox_radius);
-    dialog->_set_knot_point(knotpoint);
-    dialog->_set_pt(pt);
+    dialog->_setDesktop(desktop);
+    dialog->_setUseDistance(_use_distance);
+    dialog->_setAprox(_aprox_radius);
+    dialog->_setAmount(_amount);
+    dialog->_setSatellite(_satellite);
+    dialog->_setPt(pt);
 
     dialog->set_title(_("Modify Fillet-Chamfer"));
     dialog->_apply_button.set_label(_("_Modify"));
@@ -135,34 +136,38 @@
 
 void FilletChamferPropertiesDialog::_apply()
 {
-    double d_width;
+
     double d_pos =  _fillet_chamfer_position_numeric.get_value();
-    if (d_pos) {
+    if (d_pos >= 0) {
         if (_fillet_chamfer_type_fillet.get_active() == true) {
-            d_width = 1;
+            _satellite.satellite_type = FILLET;
         } else if (_fillet_chamfer_type_inverse_fillet.get_active() == true) {
-            d_width = 2;
+            _satellite.satellite_type = INVERSE_FILLET;
         } else if (_fillet_chamfer_type_inverse_chamfer.get_active() == true) {
-            d_width = _fillet_chamfer_chamfer_subdivisions.get_value() + 4000;
+            _satellite.satellite_type = INVERSE_CHAMFER;
         } else {
-            d_width = _fillet_chamfer_chamfer_subdivisions.get_value() + 3000;
+            _satellite.satellite_type = CHAMFER;
         }
         if (_flexible) {
             if (d_pos > 99.99999 || d_pos < 0) {
                 d_pos = 0;
             }
-            d_pos = _index + (d_pos / 100);
-        } else {
-            d_pos = d_pos * -1;
-        }
-        _knotpoint->knot_set_offset(Geom::Point(d_pos, d_width));
+            d_pos = d_pos / 100;
+        }
+        _satellite.amount = d_pos;
+        size_t steps = (size_t)_fillet_chamfer_chamfer_subdivisions.get_value();
+        if (steps < 1) {
+            steps = 1;
+        }
+        _satellite.steps = steps;
+        _knotpoint->knot_set_offset(_satellite);
     }
     _close();
 }
 
 void FilletChamferPropertiesDialog::_close()
 {
-    _set_desktop(NULL);
+    _setDesktop(NULL);
     destroy_();
     Glib::signal_idle().connect(
         sigc::bind_return(
@@ -184,62 +189,68 @@
     }
 }
 
-void FilletChamferPropertiesDialog::_set_knot_point(Geom::Point knotpoint)
+void FilletChamferPropertiesDialog::_setSatellite(Satellite satellite)
 {
     double position;
     std::string distance_or_radius = std::string(_("Radius"));
-    if(aprox){
+    if (_aprox) {
         distance_or_radius = std::string(_("Radius approximated"));
     }
-    if(use_distance){
+    if (_use_distance) {
         distance_or_radius = std::string(_("Knot distance"));
     }
-    if (knotpoint.x() > 0) {
-        double intpart;
-        position = modf(knotpoint[Geom::X], &intpart) * 100;
+    if (satellite.is_time) {
+        position = _amount * 100;
         _flexible = true;
-        _index = intpart;
         _fillet_chamfer_position_label.set_label(_("Position (%):"));
     } else {
         _flexible = false;
         std::string posConcat = Glib::ustring::compose (_("%1:"), distance_or_radius);
         _fillet_chamfer_position_label.set_label(_(posConcat.c_str()));
-        position = knotpoint[Geom::X] * -1;
+        position = _amount;
     }
     _fillet_chamfer_position_numeric.set_value(position);
-    if (knotpoint.y() == 1) {
+    _fillet_chamfer_chamfer_subdivisions.set_value(satellite.steps);
+    if (satellite.satellite_type == FILLET) {
         _fillet_chamfer_type_fillet.set_active(true);
-    } else if (knotpoint.y() == 2) {
+    } else if (satellite.satellite_type == INVERSE_FILLET) {
         _fillet_chamfer_type_inverse_fillet.set_active(true);
-    } else if (knotpoint.y() >= 3000 && knotpoint.y() < 4000) {
-        _fillet_chamfer_chamfer_subdivisions.set_value(knotpoint.y() - 3000);
+    } else if (satellite.satellite_type == CHAMFER) {
         _fillet_chamfer_type_chamfer.set_active(true);
-    } else if (knotpoint.y() >= 4000 && knotpoint.y() < 5000) {
-        _fillet_chamfer_chamfer_subdivisions.set_value(knotpoint.y() - 4000);
+    } else if (satellite.satellite_type == INVERSE_CHAMFER) {
         _fillet_chamfer_type_inverse_chamfer.set_active(true);
     }
+    _satellite = satellite;
 }
 
-void FilletChamferPropertiesDialog::_set_pt(
+void FilletChamferPropertiesDialog::_setPt(
     const Inkscape::LivePathEffect::
-    FilletChamferPointArrayParamKnotHolderEntity *pt)
+    FilletChamferKnotHolderEntity *pt)
 {
     _knotpoint = const_cast<
-                 Inkscape::LivePathEffect::FilletChamferPointArrayParamKnotHolderEntity *>(
+                 Inkscape::LivePathEffect::FilletChamferKnotHolderEntity *>(
                      pt);
 }
 
-void FilletChamferPropertiesDialog::_set_use_distance(bool use_knot_distance)
-{
-    use_distance = use_knot_distance;
-}
-
-void FilletChamferPropertiesDialog::_set_aprox(bool aprox_radius)
-{
-    aprox = aprox_radius;
-}
-
-void FilletChamferPropertiesDialog::_set_desktop(SPDesktop *desktop)
+
+void FilletChamferPropertiesDialog::_setAmount(double amount)
+{
+    _amount = amount;
+}
+
+
+
+void FilletChamferPropertiesDialog::_setUseDistance(bool use_knot_distance)
+{
+    _use_distance = use_knot_distance;
+}
+
+void FilletChamferPropertiesDialog::_setAprox(bool _aprox_radius)
+{
+    _aprox = _aprox_radius;
+}
+
+void FilletChamferPropertiesDialog::_setDesktop(SPDesktop *desktop)
 {
     if (desktop) {
         Inkscape::GC::anchor(desktop);

=== modified file 'src/ui/dialog/lpe-fillet-chamfer-properties.h'
--- src/ui/dialog/lpe-fillet-chamfer-properties.h	2017-03-12 13:37:33 +0000
+++ src/ui/dialog/lpe-fillet-chamfer-properties.h	2017-05-06 17:46:29 +0000
@@ -10,7 +10,7 @@
 
 #include <2geom/point.h>
 #include <gtkmm.h>
-#include "live_effects/parameter/filletchamferpointarray.h"
+#include "live_effects/parameter/satellitesarray.h"
 
 class SPDesktop;
 
@@ -23,20 +23,22 @@
     FilletChamferPropertiesDialog();
     virtual ~FilletChamferPropertiesDialog();
 
-    Glib::ustring getName() const {
+    Glib::ustring getName() const
+    {
         return "LayerPropertiesDialog";
     }
 
-    static void showDialog(SPDesktop *desktop, Geom::Point knotpoint,
+    static void showDialog(SPDesktop *desktop, double _amount,
                            const Inkscape::LivePathEffect::
-                           FilletChamferPointArrayParamKnotHolderEntity *pt,
-                           bool use_distance,
-                           bool aprox_radius);
+                           FilletChamferKnotHolderEntity *pt,
+                           bool _use_distance,
+                           bool _aprox_radius,
+                           Satellite _satellite);
 
 protected:
 
     SPDesktop *_desktop;
-    Inkscape::LivePathEffect::FilletChamferPointArrayParamKnotHolderEntity *
+    Inkscape::LivePathEffect::FilletChamferKnotHolderEntity *
     _knotpoint;
 
     Gtk::Label _fillet_chamfer_position_label;
@@ -51,36 +53,40 @@
 
     Gtk::Grid _layout_table;
     bool _position_visible;
-    double _index;
 
     Gtk::Button _close_button;
     Gtk::Button _apply_button;
 
     sigc::connection _destroy_connection;
 
-    static FilletChamferPropertiesDialog &_instance() {
+    static FilletChamferPropertiesDialog &_instance()
+    {
         static FilletChamferPropertiesDialog instance;
         return instance;
     }
 
-    void _set_desktop(SPDesktop *desktop);
-    void _set_pt(const Inkscape::LivePathEffect::
-                FilletChamferPointArrayParamKnotHolderEntity *pt);
-    void _set_use_distance(bool use_knot_distance);
-    void _set_aprox(bool aprox_radius);
+    void _setDesktop(SPDesktop *desktop);
+    void _setPt(const Inkscape::LivePathEffect::
+                FilletChamferKnotHolderEntity *pt);
+    void _setUseDistance(bool use_knot_distance);
+    void _setAprox(bool aprox_radius);
+    void _setAmount(double amount);
+    void _setSatellite(Satellite satellite);
+    void _prepareLabelRenderer(Gtk::TreeModel::const_iterator const &row);
+
+    bool _handleKeyEvent(GdkEventKey *event);
+    void _handleButtonEvent(GdkEventButton *event);
+
     void _apply();
     void _close();
     bool _flexible;
-    bool use_distance;
-    bool aprox;
-    void _set_knot_point(Geom::Point knotpoint);
-    void _prepareLabelRenderer(Gtk::TreeModel::const_iterator const &row);
-
-    bool _handleKeyEvent(GdkEventKey *event);
-    void _handleButtonEvent(GdkEventButton *event);
+    Satellite _satellite;
+    bool _use_distance;
+    double _amount;
+    bool _aprox;
 
     friend class Inkscape::LivePathEffect::
-            FilletChamferPointArrayParamKnotHolderEntity;
+        FilletChamferKnotHolderEntity;
 
 private:
     FilletChamferPropertiesDialog(

=== modified file 'src/ui/tool/path-manipulator.cpp'
--- src/ui/tool/path-manipulator.cpp	2016-12-06 21:22:02 +0000
+++ src/ui/tool/path-manipulator.cpp	2017-05-06 17:46:29 +0000
@@ -12,7 +12,6 @@
 
 #include "live_effects/lpe-powerstroke.h"
 #include "live_effects/lpe-bspline.h"
-#include "live_effects/lpe-fillet-chamfer.h"
 #include <2geom/bezier-utils.h>
 #include <2geom/path-sink.h>
 #include "ui/tool/path-manipulator.h"
@@ -1364,13 +1363,6 @@
                     lpe_pwr->adjustForNewPath(pathv);
                 }
             }
-            this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER);
-            if(this_effect){
-                LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast<LivePathEffect::LPEFilletChamfer*>(this_effect->getLPEObj()->get_lpe());
-                if (lpe_fll) {
-                    lpe_fll->adjustForNewPath(pathv);
-                }
-            }
         }
     }