summaryrefslogtreecommitdiffstats
path: root/src/live_effects/lpe-simplify.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:24:48 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:24:48 +0000
commitcca66b9ec4e494c1d919bff0f71a820d8afab1fa (patch)
tree146f39ded1c938019e1ed42d30923c2ac9e86789 /src/live_effects/lpe-simplify.cpp
parentInitial commit. (diff)
downloadinkscape-cca66b9ec4e494c1d919bff0f71a820d8afab1fa.tar.xz
inkscape-cca66b9ec4e494c1d919bff0f71a820d8afab1fa.zip
Adding upstream version 1.2.2.upstream/1.2.2upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--src/live_effects/lpe-simplify.cpp315
1 files changed, 315 insertions, 0 deletions
diff --git a/src/live_effects/lpe-simplify.cpp b/src/live_effects/lpe-simplify.cpp
new file mode 100644
index 0000000..ccd1b6b
--- /dev/null
+++ b/src/live_effects/lpe-simplify.cpp
@@ -0,0 +1,315 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <gtkmm.h>
+
+#include "live_effects/lpe-simplify.h"
+
+#include "display/curve.h"
+#include "helper/geom.h"
+#include "path/path-util.h"
+#include "svg/svg.h"
+#include "ui/icon-names.h"
+#include "ui/tools/node-tool.h"
+
+#include <2geom/svg-path-parser.h>
+
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+LPESimplify::LPESimplify(LivePathEffectObject *lpeobject)
+ : Effect(lpeobject)
+ , steps(_("Steps:"), _("Change number of simplify steps "), "steps", &wr, this, 1)
+ , threshold(_("Roughly threshold:"), _("Roughly threshold:"), "threshold", &wr, this, 0.002)
+ , smooth_angles(_("Smooth angles:"), _("Max degree difference on handles to perform a smooth"), "smooth_angles",
+ &wr, this, 0.)
+ , helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 5)
+ , simplify_individual_paths(_("Paths separately"), _("Simplifying paths (separately)"), "simplify_individual_paths",
+ &wr, this, false, "", INKSCAPE_ICON("on-outline"), INKSCAPE_ICON("off-outline"))
+ , simplify_just_coalesce(_("Just coalesce"), _("Simplify just coalesce"), "simplify_just_coalesce", &wr, this,
+ false, "", INKSCAPE_ICON("on-outline"), INKSCAPE_ICON("off-outline"))
+{
+ registerParameter(&steps);
+ registerParameter(&threshold);
+ registerParameter(&smooth_angles);
+ registerParameter(&helper_size);
+ registerParameter(&simplify_individual_paths);
+ registerParameter(&simplify_just_coalesce);
+
+ threshold.param_set_range(0.0001, Geom::infinity());
+ threshold.param_set_increments(0.0001, 0.0001);
+ threshold.param_set_digits(6);
+
+ steps.param_set_range(0, 100);
+ steps.param_set_increments(1, 1);
+ steps.param_set_digits(0);
+
+ smooth_angles.param_set_range(0.0, 360.0);
+ smooth_angles.param_set_increments(10, 10);
+ smooth_angles.param_set_digits(2);
+
+ helper_size.param_set_range(0.0, 999.0);
+ helper_size.param_set_increments(5, 5);
+ helper_size.param_set_digits(2);
+
+ radius_helper_nodes = 6.0;
+ apply_to_clippath_and_mask = true;
+}
+
+LPESimplify::~LPESimplify() = default;
+
+void
+LPESimplify::doBeforeEffect (SPLPEItem const* lpeitem)
+{
+ if(!hp.empty()) {
+ hp.clear();
+ }
+ bbox = lpeitem->visualBounds();
+ radius_helper_nodes = helper_size;
+}
+
+Gtk::Widget *
+LPESimplify::newWidget()
+{
+ // use manage here, because after deletion of Effect object, others might still be pointing to this widget.
+ Gtk::Box *vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
+
+ vbox->set_border_width(5);
+ vbox->set_homogeneous(false);
+ vbox->set_spacing(2);
+ std::vector<Parameter *>::iterator it = param_vector.begin();
+ Gtk::Box * buttons = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL,0));
+ while (it != param_vector.end()) {
+ if ((*it)->widget_is_visible) {
+ Parameter * param = *it;
+ Gtk::Widget * widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
+ if (param->param_key == "simplify_individual_paths" ||
+ param->param_key == "simplify_just_coalesce") {
+ Glib::ustring * tip = param->param_getTooltip();
+ if (widg) {
+ buttons->pack_start(*widg, true, true, 2);
+ if (tip) {
+ widg->set_tooltip_text(*tip);
+ } else {
+ widg->set_tooltip_text("");
+ widg->set_has_tooltip(false);
+ }
+ }
+ } else {
+ Glib::ustring * tip = param->param_getTooltip();
+ if (widg) {
+ Gtk::Box * horizontal_box = dynamic_cast<Gtk::Box *>(widg);
+ std::vector< Gtk::Widget* > child_list = horizontal_box->get_children();
+ Gtk::Entry* entry_widg = dynamic_cast<Gtk::Entry *>(child_list[1]);
+ entry_widg->set_width_chars(8);
+ vbox->pack_start(*widg, true, true, 2);
+ if (tip) {
+ widg->set_tooltip_text(*tip);
+ } else {
+ widg->set_tooltip_text("");
+ widg->set_has_tooltip(false);
+ }
+ }
+ }
+ }
+
+ ++it;
+ }
+ vbox->pack_start(*buttons,true, true, 2);
+ if(Gtk::Widget* widg = defaultParamSet()) {
+ vbox->pack_start(*widg, true, true, 2);
+ }
+ return dynamic_cast<Gtk::Widget *>(vbox);
+}
+
+void
+LPESimplify::doEffect(SPCurve *curve)
+{
+ Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(curve->get_pathvector());
+ gdouble size = Geom::L2(bbox->dimensions());
+ //size /= Geom::Affine(0,0,0,0,0,0).descrim();
+ Path* pathliv = Path_for_pathvector(original_pathv);
+ if(simplify_individual_paths) {
+ size = Geom::L2(Geom::bounds_fast(original_pathv)->dimensions());
+ }
+ size /= sp_lpe_item->i2doc_affine().descrim();
+ for (int unsigned i = 0; i < steps; i++) {
+ if ( simplify_just_coalesce ) {
+ pathliv->Coalesce(threshold * size);
+ } else {
+ pathliv->ConvertEvenLines(threshold * size);
+ pathliv->Simplify(threshold * size);
+ }
+ }
+ Geom::PathVector result = Geom::parse_svg_path(pathliv->svg_dump_path());
+ generateHelperPathAndSmooth(result);
+ curve->set_pathvector(result);
+ update_helperpath();
+}
+
+void
+LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result)
+{
+ if(steps < 1) {
+ return;
+ }
+ Geom::PathVector tmp_path;
+ Geom::CubicBezier const *cubic = nullptr;
+ for (auto & path_it : result) {
+ if (path_it.empty()) {
+ continue;
+ }
+
+ Geom::Path::iterator curve_it1 = path_it.begin(); // incoming curve
+ Geom::Path::iterator curve_it2 = ++(path_it.begin());// outgoing curve
+ Geom::Path::iterator curve_endit = path_it.end_default(); // this determines when the loop has to stop
+ SPCurve *nCurve = new SPCurve();
+ if (path_it.closed()) {
+ // if the path is closed, maybe we have to stop a bit earlier because the
+ // closing line segment has zerolength.
+ 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();
+ }
+ }
+ if(helper_size > 0) {
+ drawNode(curve_it1->initialPoint());
+ }
+ nCurve->moveto(curve_it1->initialPoint());
+ Geom::Point start = Geom::Point(0,0);
+ while (curve_it1 != curve_endit) {
+ cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
+ Geom::Point point_at1 = curve_it1->initialPoint();
+ Geom::Point point_at2 = curve_it1->finalPoint();
+ Geom::Point point_at3 = curve_it1->finalPoint();
+ Geom::Point point_at4 = curve_it1->finalPoint();
+
+ if(start == Geom::Point(0,0)) {
+ start = point_at1;
+ }
+
+ if (cubic) {
+ point_at1 = (*cubic)[1];
+ point_at2 = (*cubic)[2];
+ }
+
+ if(path_it.closed() && curve_it2 == curve_endit) {
+ point_at4 = start;
+ }
+ if(curve_it2 != curve_endit) {
+ cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it2);
+ if (cubic) {
+ point_at4 = (*cubic)[1];
+ }
+ }
+ Geom::Ray ray1(point_at2, point_at3);
+ Geom::Ray ray2(point_at3, point_at4);
+ double angle1 = Geom::deg_from_rad(ray1.angle());
+ double angle2 = Geom::deg_from_rad(ray2.angle());
+ if((smooth_angles >= std::abs(angle2 - angle1)) && !are_near(point_at4,point_at3) && !are_near(point_at2,point_at3)) {
+ double dist = Geom::distance(point_at2,point_at3);
+ Geom::Angle angleFixed = ray2.angle();
+ angleFixed -= Geom::Angle::from_degrees(180.0);
+ point_at2 = Geom::Point::polar(angleFixed, dist) + point_at3;
+ }
+ nCurve->curveto(point_at1, point_at2, curve_it1->finalPoint());
+ cubic = dynamic_cast<Geom::CubicBezier const *>(nCurve->last_segment());
+ if (cubic) {
+ point_at1 = (*cubic)[1];
+ point_at2 = (*cubic)[2];
+ if(helper_size > 0) {
+ if(!are_near((*cubic)[0],(*cubic)[1])) {
+ drawHandle((*cubic)[1]);
+ drawHandleLine((*cubic)[0],(*cubic)[1]);
+ }
+ if(!are_near((*cubic)[3],(*cubic)[2])) {
+ drawHandle((*cubic)[2]);
+ drawHandleLine((*cubic)[3],(*cubic)[2]);
+ }
+ }
+ }
+ if(helper_size > 0) {
+ drawNode(curve_it1->finalPoint());
+ }
+ ++curve_it1;
+ ++curve_it2;
+ }
+ if (path_it.closed()) {
+ nCurve->closepath_current();
+ }
+ tmp_path.push_back(nCurve->get_pathvector()[0]);
+ nCurve->reset();
+ delete nCurve;
+ }
+ result = tmp_path;
+}
+
+void
+LPESimplify::drawNode(Geom::Point p)
+{
+ double r = radius_helper_nodes;
+ char const * svgd;
+ svgd = "M 0.55,0.5 A 0.05,0.05 0 0 1 0.5,0.55 0.05,0.05 0 0 1 0.45,0.5 0.05,0.05 0 0 1 0.5,0.45 0.05,0.05 0 0 1 0.55,0.5 Z M 0,0 1,0 1,1 0,1 Z";
+ Geom::PathVector pathv = sp_svg_read_pathv(svgd);
+ pathv *= Geom::Scale(r) * Geom::Translate(p - Geom::Point(0.5*r,0.5*r));
+ hp.push_back(pathv[0]);
+ hp.push_back(pathv[1]);
+}
+
+void
+LPESimplify::drawHandle(Geom::Point p)
+{
+ double r = radius_helper_nodes;
+ 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);
+ pathv *= Geom::Scale(r) * Geom::Translate(p - Geom::Point(0.35*r,0.35*r));
+ hp.push_back(pathv[0]);
+}
+
+
+void
+LPESimplify::drawHandleLine(Geom::Point p,Geom::Point p2)
+{
+ Geom::Path path;
+ path.start( p );
+ double diameter = radius_helper_nodes;
+ if(helper_size > 0 && Geom::distance(p,p2) > (diameter * 0.35)) {
+ Geom::Ray ray2(p, p2);
+ p2 = p2 - Geom::Point::polar(ray2.angle(),(diameter * 0.35));
+ }
+ path.appendNew<Geom::LineSegment>( p2 );
+ hp.push_back(path);
+}
+
+void
+LPESimplify::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
+{
+ hp_vec.push_back(hp);
+}
+
+
+}; //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 :