From 44911fb71708f71feea4c853de856a14af4fbccf Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Date: Thu, 18 Jul 2019 00:57:15 +0200 Subject: Improvements finish pointed by Maren --- src/live_effects/effect.cpp | 7 ++ src/live_effects/effect.h | 1 + src/live_effects/lpe-powerstroke.cpp | 34 ++++++- src/live_effects/lpe-powerstroke.h | 3 + src/live_effects/lpe-simplify.cpp | 2 +- src/live_effects/lpe-simplify.h | 2 +- src/live_effects/parameter/togglebutton.cpp | 38 ++++---- src/live_effects/parameter/togglebutton.h | 4 +- src/object/sp-lpe-item.cpp | 2 +- src/ui/toolbar/pencil-toolbar.cpp | 2 +- src/ui/tools/freehand-base.cpp | 10 +- src/ui/tools/pencil-tool.cpp | 139 ++++++++++++++++------------ src/ui/tools/pencil-tool.h | 7 +- 13 files changed, 157 insertions(+), 94 deletions(-) (limited to 'src') diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp index f5b291635..e547e709d 100644 --- a/src/live_effects/effect.cpp +++ b/src/live_effects/effect.cpp @@ -1250,6 +1250,13 @@ void Effect::doAfterEffect (SPLPEItem const* /*lpeitem*/) is_load = false; } +void Effect::doOnException (SPLPEItem const* /*lpeitem*/) +{ + has_exception = true; + pathvector_after_effect = pathvector_before_effect; +} + + void Effect::doOnRemove (SPLPEItem const* /*lpeitem*/) { } diff --git a/src/live_effects/effect.h b/src/live_effects/effect.h index 725aae6c4..6ef65fe3c 100644 --- a/src/live_effects/effect.h +++ b/src/live_effects/effect.h @@ -75,6 +75,7 @@ public: virtual void doBeforeEffect (SPLPEItem const* lpeitem); virtual void doAfterEffect (SPLPEItem const* lpeitem); + virtual void doOnException (SPLPEItem const* lpeitem); virtual void doOnRemove (SPLPEItem const* lpeitem); virtual void doOnVisibilityToggled(SPLPEItem const* lpeitem); void writeParamsToSVG(); diff --git a/src/live_effects/lpe-powerstroke.cpp b/src/live_effects/lpe-powerstroke.cpp index 0a13e4661..5eb5afc75 100644 --- a/src/live_effects/lpe-powerstroke.cpp +++ b/src/live_effects/lpe-powerstroke.cpp @@ -12,7 +12,9 @@ */ #include "live_effects/lpe-powerstroke.h" +#include "live_effects/lpe-simplify.h" #include "live_effects/lpe-powerstroke-interpolators.h" +#include "live_effects/lpeobject.h" #include "svg/svg-color.h" #include "desktop-style.h" @@ -182,17 +184,25 @@ LPEPowerStroke::LPEPowerStroke(LivePathEffectObject *lpeobject) : scale_width.param_set_range(0.0, Geom::infinity()); scale_width.param_set_increments(0.1, 0.1); scale_width.param_set_digits(4); + recusion_limit = 0; + previous_size = 0; } -LPEPowerStroke::~LPEPowerStroke() -= default; +LPEPowerStroke::~LPEPowerStroke() = default; + void LPEPowerStroke::doBeforeEffect(SPLPEItem const *lpeItem) { offset_points.set_scale_width(scale_width); + size_t psize = pathvector_before_effect.size(); + if (!is_load && previous_size != psize) { + adjustForNewPath(pathvector_before_effect); + } + previous_size = psize; } -void LPEPowerStroke::applyStyle(SPLPEItem *lpeitem) +void +LPEPowerStroke::applyStyle(SPLPEItem *lpeitem) { SPCSSAttr *css = sp_repr_css_attr_new(); if (lpeitem->style) { @@ -755,6 +765,24 @@ LPEPowerStroke::doEffect_path (Geom::PathVector const & path_in) return path_out; } +void +LPEPowerStroke::doAfterEffect (SPLPEItem const* lpeitem){ + is_load = false; + if (pathvector_before_effect[0].size() == pathvector_after_effect[0].size()) { + if (recusion_limit < 6) { + Inkscape::LivePathEffect::Effect* effect = sp_lpe_item->getPathEffectOfType(Inkscape::LivePathEffect::SIMPLIFY); + if(effect){ + LivePathEffect::LPESimplify *simplify = dynamic_cast(effect->getLPEObj()->get_lpe()); + double threshold = simplify->threshold * 1.2; + simplify->threshold.param_set_value(threshold); + simplify->threshold.write_to_SVG(); + } + } + ++recusion_limit; + } else { + recusion_limit = 0; + } +} /* ######################## */ diff --git a/src/live_effects/lpe-powerstroke.h b/src/live_effects/lpe-powerstroke.h index 945a2ffe7..4cb4e5a69 100644 --- a/src/live_effects/lpe-powerstroke.h +++ b/src/live_effects/lpe-powerstroke.h @@ -42,6 +42,7 @@ public: void doBeforeEffect(SPLPEItem const *lpeItem) override; void doOnApply(SPLPEItem const* lpeitem) override; void doOnRemove(SPLPEItem const* lpeitem) override; + void doAfterEffect (SPLPEItem const* lpeitem) override; void applyStyle(SPLPEItem *lpeitem); // methods called by path-manipulator upon edits void adjustForNewPath(Geom::PathVector const & path_in); @@ -57,6 +58,8 @@ private: EnumParam linejoin_type; ScalarParam miter_limit; EnumParam end_linecap_type; + size_t recusion_limit; + size_t previous_size; }; } //namespace LivePathEffect diff --git a/src/live_effects/lpe-simplify.cpp b/src/live_effects/lpe-simplify.cpp index 56647e4e2..da36b184e 100644 --- a/src/live_effects/lpe-simplify.cpp +++ b/src/live_effects/lpe-simplify.cpp @@ -27,7 +27,7 @@ LPESimplify::LPESimplify(LivePathEffectObject *lpeobject) simplify_individual_paths(_("Paths separately"), _("Simplifying paths (separately)"), "simplify_individual_paths", &wr, this, false, "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), simplify_just_coalesce(_("Just coalesce"), _("Simplify just coalesce"), "simplify_just_coalesce", &wr, this, false, - "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")) + "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")) { registerParameter(&steps); registerParameter(&threshold); diff --git a/src/live_effects/lpe-simplify.h b/src/live_effects/lpe-simplify.h index a04fff76c..08561b3e4 100644 --- a/src/live_effects/lpe-simplify.h +++ b/src/live_effects/lpe-simplify.h @@ -35,13 +35,13 @@ public: virtual void drawHandle(Geom::Point p); virtual void drawHandleLine(Geom::Point p,Geom::Point p2); + ScalarParam threshold; protected: void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector &hp_vec) override; private: ScalarParam steps; - ScalarParam threshold; ScalarParam smooth_angles; ScalarParam helper_size; ToggleButtonParam simplify_individual_paths; diff --git a/src/live_effects/parameter/togglebutton.cpp b/src/live_effects/parameter/togglebutton.cpp index bc275e876..555b1222a 100644 --- a/src/live_effects/parameter/togglebutton.cpp +++ b/src/live_effects/parameter/togglebutton.cpp @@ -29,7 +29,7 @@ ToggleButtonParam::ToggleButtonParam( const Glib::ustring& label, const Glib::us const Glib::ustring& key, Inkscape::UI::Widget::Registry* wr, Effect* effect, bool default_value, Glib::ustring inactive_label, char const * _icon_active, char const * _icon_inactive, - GtkIconSize _icon_size) + Gtk::BuiltinIconSize _icon_size) : Parameter(label, tip, key, wr, effect), value(default_value), defvalue(default_value), inactive_label(std::move(inactive_label)), _icon_active(_icon_active), _icon_inactive(_icon_inactive), _icon_size(_icon_size) { @@ -95,38 +95,38 @@ ToggleButtonParam::param_newWidget() false, param_effect->getRepr(), param_effect->getSPDoc()) ); - auto box_button = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); - gtk_box_set_homogeneous(GTK_BOX(box_button), false); - GtkWidget * label_button = gtk_label_new (""); + auto box_button = new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL); + box_button->set_homogeneous(false); + Gtk::Label * label = new Gtk::Label(""); if (!param_label.empty()) { if(value || inactive_label.empty()){ - gtk_label_set_text(GTK_LABEL(label_button), param_label.c_str()); + label->set_text(param_label.c_str()); }else{ - gtk_label_set_text(GTK_LABEL(label_button), inactive_label.c_str()); + label->set_text(inactive_label.c_str()); } } - gtk_widget_show(label_button); + label->show(); if ( _icon_active ) { if(!_icon_inactive){ _icon_inactive = _icon_active; } - gtk_widget_show(box_button); - GtkWidget *icon_button = nullptr; + box_button->show(); + Gtk::Widget *icon_button = nullptr; if (!value) { icon_button = sp_get_icon_image(_icon_inactive, _icon_size); } else { icon_button = sp_get_icon_image(_icon_active, _icon_size); } - gtk_widget_show(icon_button); - gtk_box_pack_start (GTK_BOX(box_button), icon_button, false, false, 1); + icon_button->show(); + box_button->pack_start(*icon_button, false, false, 1); if (!param_label.empty()) { - gtk_box_pack_start (GTK_BOX(box_button), label_button, false, false, 1); + box_button->pack_start (*label, false, false, 1); } }else{ - gtk_box_pack_start (GTK_BOX(box_button), label_button, false, false, 1); + box_button->pack_start(*label, false, false, 1); } - checkwdg->add(*Gtk::manage(Glib::wrap(box_button))); + checkwdg->add(*Gtk::manage(box_button)); checkwdg->setActive(value); checkwdg->setProgrammatically = false; checkwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change togglebutton parameter")); @@ -145,11 +145,11 @@ ToggleButtonParam::refresh_button() if(!checkwdg){ return; } - Gtk::Widget * box_button = checkwdg->get_child(); + Gtk::Container *box_button = dynamic_cast(checkwdg->get_child()); if(!box_button){ return; } - std::vector children = Glib::wrap(GTK_CONTAINER(box_button))->get_children(); + std::vector children = box_button->get_children(); if (!param_label.empty()) { Gtk::Label *lab = dynamic_cast(children[children.size()-1]); if (!lab) return; @@ -160,13 +160,13 @@ ToggleButtonParam::refresh_button() } } if ( _icon_active ) { - GdkPixbuf * icon_pixbuf = nullptr; + Gdk::Pixbuf * icon_pixbuf = nullptr; Gtk::Widget *im = dynamic_cast(children[0]); if (!im) return; if (!value) { - im = Glib::wrap(sp_get_icon_image(_icon_inactive, _icon_size)); + im = sp_get_icon_image(_icon_inactive, _icon_size); } else { - im = Glib::wrap(sp_get_icon_image(_icon_active, _icon_size)); + im = sp_get_icon_image(_icon_active, _icon_size); } } } diff --git a/src/live_effects/parameter/togglebutton.h b/src/live_effects/parameter/togglebutton.h index d1845de5b..d21c9ac37 100644 --- a/src/live_effects/parameter/togglebutton.h +++ b/src/live_effects/parameter/togglebutton.h @@ -34,7 +34,7 @@ public: Glib::ustring inactive_label = "", char const * icon_active = nullptr, char const * icon_inactive = nullptr, - GtkIconSize icon_size = GTK_ICON_SIZE_SMALL_TOOLBAR); + Gtk::BuiltinIconSize icon_size = Gtk::ICON_SIZE_SMALL_TOOLBAR); ~ToggleButtonParam() override; ToggleButtonParam(const ToggleButtonParam&) = delete; ToggleButtonParam& operator=(const ToggleButtonParam&) = delete; @@ -64,7 +64,7 @@ private: const Glib::ustring inactive_label; const char * _icon_active; const char * _icon_inactive; - GtkIconSize _icon_size; + Gtk::BuiltinIconSize _icon_size; Inkscape::UI::Widget::RegisteredToggleButton * checkwdg; sigc::signal _signal_toggled; diff --git a/src/object/sp-lpe-item.cpp b/src/object/sp-lpe-item.cpp index 6be373925..457ce65c1 100755 --- a/src/object/sp-lpe-item.cpp +++ b/src/object/sp-lpe-item.cpp @@ -259,7 +259,7 @@ bool SPLPEItem::performOnePathEffect(SPCurve *curve, SPShape *current, Inkscape: SP_ACTIVE_DESKTOP->messageStack()->flash( Inkscape::WARNING_MESSAGE, _("An exception occurred during execution of the Path Effect.") ); } - lpe->has_exception = true; + lpe->doOnException(this); return false; } diff --git a/src/ui/toolbar/pencil-toolbar.cpp b/src/ui/toolbar/pencil-toolbar.cpp index e32d2c19a..bcc3a3d2d 100644 --- a/src/ui/toolbar/pencil-toolbar.cpp +++ b/src/ui/toolbar/pencil-toolbar.cpp @@ -146,7 +146,7 @@ PencilToolbar::PencilToolbar(SPDesktop *desktop, _("(few nodes, smooth)") }; std::vector values = { 1, 10, 20, 30, 50, 75, 100 }; auto tolerance_val = prefs->getDouble("/tools/freehand/pencil/tolerance", 3.0); - _tolerance_adj = Gtk::Adjustment::create(tolerance_val, 1, 100.0, 0.5, 1.0); + _tolerance_adj = Gtk::Adjustment::create(tolerance_val, 0, 100.0, 0.5, 1.0); auto tolerance_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("pencil-tolerance", _("Smoothing:"), _tolerance_adj, 1, 2)); tolerance_item->set_tooltip_text(_("How much smoothing (simplifying) is applied to the line")); diff --git a/src/ui/tools/freehand-base.cpp b/src/ui/tools/freehand-base.cpp index 961410c6b..52796b25e 100644 --- a/src/ui/tools/freehand-base.cpp +++ b/src/ui/tools/freehand-base.cpp @@ -890,13 +890,11 @@ static void spdc_flush_white(FreehandBase *dc, SPCurve *gc) repr->setAttribute("d", str); g_free(str); - if (SP_IS_PENCIL_CONTEXT(dc)) { - if (dc->tablet_enabled) { - if (!dc->white_item) { - dc->white_item = SP_ITEM(desktop->currentLayer()->appendChildRepr(repr)); - } - spdc_check_for_and_apply_waiting_LPE(dc, dc->white_item, c, false); + if (SP_IS_PENCIL_CONTEXT(dc) && dc->tablet_enabled) { + if (!dc->white_item) { + dc->white_item = SP_ITEM(desktop->currentLayer()->appendChildRepr(repr)); } + spdc_check_for_and_apply_waiting_LPE(dc, dc->white_item, c, false); } if (!dc->white_item) { // Attach repr diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp index dd5ef80fd..bda06ad97 100644 --- a/src/ui/tools/pencil-tool.cpp +++ b/src/ui/tools/pencil-tool.cpp @@ -41,6 +41,8 @@ #include "live_effects/lpe-powerstroke-interpolators.h" #include "live_effects/lpe-powerstroke.h" +#include "live_effects/lpe-simplify.h" +#include "live_effects/lpeobject.h" #include "object/sp-lpe-item.h" #include "object/sp-path.h" @@ -98,6 +100,7 @@ void PencilTool::setup() { this->_is_drawing = false; this->anchor_statusbar = false; + this->size_powerpencil = 0; } @@ -230,7 +233,7 @@ bool PencilTool::_handleButtonPress(GdkEventButton const &bevent) { desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Continuing selected path")); } else { m.setup(desktop, true); - if (tablet_enabled && this->pressure) { + if (tablet_enabled) { // This is the first click of a new curve; deselect item so that // this curve is not combined with it (unless it is drawn from its // anchor, which is handled by the sibling branch above) @@ -351,7 +354,7 @@ bool PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) { // whether we're going into freehand mode or not this->ps.push_back(this->p[0]); if (tablet_enabled) { - this->_wps.push_back(0); + this->_wps.push_back(Geom::Point(0,0)); } } this->_addFreehandPoint(p, mevent.state); @@ -475,10 +478,17 @@ bool PencilTool::_handleButtonRelease(GdkEventButton const &revent) { this->_interpolate(); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); if (tablet_enabled) { - gint prevmode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0); + gint shapetype = prefs->getInt("/tools/freehand/pencil/shape", 0); + gint simplify = prefs->getInt("/tools/freehand/pencil/simplify", 0); + gint mode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0); + prefs->setInt("/tools/freehand/pencil/shape", 0); + prefs->setInt("/tools/freehand/pencil/simplify", 0); prefs->setInt("/tools/freehand/pencil/freehand-mode", 0); spdc_concat_colors_and_flush(this, FALSE); - prefs->setInt("/tools/freehand/pencil/freehand-mode", prevmode); + prefs->setInt("/tools/freehand/pencil/freehand-mode", mode); + prefs->setInt("/tools/freehand/pencil/simplify", simplify); + prefs->setInt("/tools/freehand/pencil/shape", shapetype); + this->addPowerStrokePencil(true); } else { spdc_concat_colors_and_flush(this, FALSE); } @@ -487,6 +497,7 @@ bool PencilTool::_handleButtonRelease(GdkEventButton const &revent) { this->ea = nullptr; this->ps.clear(); this->_wps.clear(); + this->size_powerpencil = 0; if (this->green_anchor) { this->green_anchor = sp_draw_anchor_destroy(this->green_anchor); } @@ -691,16 +702,24 @@ void PencilTool::_finishEndpoint() { static inline double square(double const x) { return x * x; } -void PencilTool::addPowerStrokePencil(bool force, gint tolsimplify) +void PencilTool::addPowerStrokePencil(bool reset) { - - static int pscounter = 16; - if (pscounter > 15 || force) { + gint top = 21; + if (this->size_powerpencil > 50) { + top = 41; + } + static int pscounter = top; + if (reset) { + pscounter = top; + return; + } + if (pscounter > top-1) { pscounter = 0; } else { pscounter++; return; } + using namespace Inkscape::LivePathEffect; if (this->_curve && this->ps.size() > 1) { @@ -734,14 +753,13 @@ void PencilTool::addPowerStrokePencil(bool force, gint tolsimplify) toremove->getRepr()->setAttribute("id", "tmp_power_stroke_preview"); } Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - double tol = prefs->getDoubleLimited("/tools/freehand/pencil/base-simplify", 25.0, 0.0, 100.0) * 0.4; + double tol = (prefs->getDoubleLimited("/tools/freehand/pencil/base-simplify", 25.0, 0.0, 100.0) -10) * 0.4; double tolerance_sq = 0.02 * square(this->desktop->w2d().descrim() * tol) * exp(0.2 * tol - 2); int n_points = this->ps.size(); // worst case gives us a segment per point int max_segs = 4 * n_points; std::vector b(max_segs); SPCurve *curvepressure = new SPCurve(); - int const n_segs = Geom::bezier_fit_cubic_r(b.data(), this->ps.data(), n_points, tolerance_sq, max_segs); if (n_segs > 0) { /* Fit and draw and reset state */ @@ -750,20 +768,15 @@ void PencilTool::addPowerStrokePencil(bool force, gint tolsimplify) curvepressure->curveto(b[4 * c + 1], b[4 * c + 2], b[4 * c + 3]); } } + Geom::Affine transform_coordinate = SP_ITEM(SP_ACTIVE_DESKTOP->currentLayer())->i2dt_affine().inverse(); + curvepressure->transform(transform_coordinate); Geom::Path path = curvepressure->get_pathvector()[0]; int original_size = path.size(); if (!path.empty()) { - Geom::Affine transform_coordinate = SP_ITEM(SP_ACTIVE_DESKTOP->currentLayer())->i2dt_affine().inverse(); - path *= transform_coordinate; // std::vector points_preview = this->points; // points_preview.push_back(Geom::Point(path.size() - 1, points_preview[points_preview.size()-1][Geom::Y])); // future = std::async(std::launch::async, [path, points_preview] { using namespace Inkscape::LivePathEffect; - SPDocument *document = SP_ACTIVE_DOCUMENT; - if (!document) { - return; - // return true; - } Inkscape::XML::Document *xml_doc = document->getReprDoc(); Inkscape::XML::Node *pp = nullptr; pp = xml_doc->createElement("svg:path"); @@ -782,30 +795,37 @@ void PencilTool::addPowerStrokePencil(bool force, gint tolsimplify) return; // return true; } - - tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 0.0, 100.0) + tolsimplify; - tol = tol / (100.0 * (102.0 - tol)); - std::ostringstream threshold; - threshold << tol; - Effect::createAndApply(SIMPLIFY, desktop->doc(), SP_ITEM(lpeitem)); - Effect *lpe = lpeitem->getCurrentLPE(); - if (lpe) { - Glib::ustring pref_path = "/live_effects/simplify/smooth_angles"; - bool valid = prefs->getEntry(pref_path).isValid(); - if (!valid) { - lpe->getRepr()->setAttribute("smooth_angles", "0"); + + tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 0.0, 100.0) + 30; + if (tol > 30) { + tol = tol / (100.0 * (102.0 - tol)); + std::ostringstream threshold; + threshold << tol; + Effect::createAndApply(SIMPLIFY, desktop->doc(), SP_ITEM(lpeitem)); + Effect *lpe = lpeitem->getCurrentLPE(); + Inkscape::LivePathEffect::LPESimplify *simplify = static_cast(lpe); + if (simplify) { + Glib::ustring pref_path = "/live_effects/simplify/smooth_angles"; + bool valid = prefs->getEntry(pref_path).isValid(); + if (!valid) { + lpe->getRepr()->setAttribute("smooth_angles", "360"); + } + lpe->getRepr()->setAttribute("threshold", threshold.str()); + } + sp_lpe_item_update_patheffect(lpeitem, false, true); + curvepressure = powerpreview->getCurve(); + if (curvepressure->is_empty()) { + return; } - lpe->getRepr()->setAttribute("threshold", threshold.str()); + path = curvepressure->get_pathvector()[0]; } - sp_lpe_item_update_patheffect(lpeitem, false, true); - curvepressure = powerpreview->getCurve(); - path = curvepressure->get_pathvector()[0]; + this->size_powerpencil = path.size(); powerStrokeInterpolate(path); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); Glib::ustring pref_path_pp = "/live_effects/powerstroke/powerpencil"; prefs->setBool(pref_path_pp, true); Effect::createAndApply(POWERSTROKE, SP_ACTIVE_DESKTOP->doc(), lpeitem); - lpe = lpeitem->getCurrentLPE(); + Effect *lpe = lpeitem->getCurrentLPE(); Inkscape::LivePathEffect::LPEPowerStroke *pspreview = static_cast(lpe); if (pspreview) { sp_lpe_item_enable_path_effects(lpeitem, false); @@ -814,6 +834,11 @@ void PencilTool::addPowerStrokePencil(bool force, gint tolsimplify) if (!valid) { pspreview->getRepr()->setAttribute("interpolator_type", "CentripetalCatmullRom"); } + pref_path = "/live_effects/powerstroke/linejoin_type"; + valid = prefs->getEntry(pref_path).isValid(); + if (!valid) { + pspreview->getRepr()->setAttribute("linejoin_type", "bevel"); + } gint cap = prefs->getInt("/live_effects/powerstroke/powerpencilcap", 4); pspreview->getRepr()->setAttribute("start_linecap_type", LineCapTypeConverter.get_key(cap)); pspreview->getRepr()->setAttribute("end_linecap_type", LineCapTypeConverter.get_key(cap)); @@ -830,21 +855,20 @@ void PencilTool::addPowerStrokePencil(bool force, gint tolsimplify) SP_OBJECT(lpeobj)->deleteObject(true); lpeobj = nullptr; } - lpe = SP_LPE_ITEM(toremove)->getCurrentLPE(); - SP_LPE_ITEM(toremove)->removeCurrentPathEffect(true); - lpeobj = lpe->getLPEObj(); - if (lpeobj) { - SP_OBJECT(lpeobj)->deleteObject(true); - lpeobj = nullptr; + tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 0.0, 100.0) + 30; + if (tol > 30) { + lpe = SP_LPE_ITEM(toremove)->getCurrentLPE(); + SP_LPE_ITEM(toremove)->removeCurrentPathEffect(true); + lpeobj = lpe->getLPEObj(); + if (lpeobj) { + SP_OBJECT(lpeobj)->deleteObject(true); + lpeobj = nullptr; + } } toremove->deleteObject(true); toremove = nullptr; } - if (!pspreview->has_exception && path.size() != powerpreview->getCurve()->get_pathvector()[0].size()) { - pp->setAttribute("style", "fill:#888888;opacity:1;fill-rule:nonzero;stroke:none;"); - } else if (tolsimplify < 61) { // run 3 times - addPowerStrokePencil(true, tolsimplify + 10); - } + pp->setAttribute("style", "fill:#888888;opacity:1;fill-rule:nonzero;stroke:none;"); } if (curvepressure) { curvepressure->unref(); @@ -870,19 +894,18 @@ void PencilTool::_addFreehandPoint(Geom::Point const &p, guint /*state*/) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); double min = prefs->getIntLimited("/tools/freehand/pencil/minpressure", 10, 0, 100) / 100.0; double max = prefs->getIntLimited("/tools/freehand/pencil/maxpressure", 40, 0, 100) / 100.0; - Geom::Affine transform_coordinate = SP_ITEM(SP_ACTIVE_DESKTOP->currentLayer())->i2dt_affine(); if (min > max) { min = max; } - if (this->pressure < 0.25) { - this->_wps.push_back(0); - return; - } double dezoomify_factor = 0.05 * 1000 / SP_EVENT_CONTEXT(this)->desktop->current_zoom(); double pressure_shrunk = (((this->pressure - 0.25) * 1.25) * (max - min)) + min; double pressure_computed = pressure_shrunk * (dezoomify_factor / 5.0); - this->_wps.push_back(pressure_computed); - this->addPowerStrokePencil(false, 30); + if (this->pressure < 0.25) { + this->_wps.push_back(Geom::Point(this->ps.size(), 0)); + } else { + this->_wps.push_back(Geom::Point(this->ps.size(), pressure_computed)); + } + this->addPowerStrokePencil(false); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), nullptr); for (auto i:this->green_bpaths) { sp_canvas_item_destroy(i); @@ -898,6 +921,7 @@ void PencilTool::powerStrokeInterpolate(Geom::Path path) if ( ps_size <= 1 ) { return; } + using Geom::X; using Geom::Y; Inkscape::Preferences *prefs = Inkscape::Preferences::get(); @@ -907,13 +931,10 @@ void PencilTool::powerStrokeInterpolate(Geom::Path path) std::vector tmp_points; Geom::Point previous = Geom::Point(Geom::infinity(), 0); size_t i = 0; - size_t previ = 0; bool increase = true; - for (auto pressure : this->_wps) { - Geom::Point pp = Geom::Point(); + for (auto pp : this->_wps) { pp[Geom::X] = (path_size / (double)points_size) * i; - pp[Geom::Y] = pressure; - if (pressure == 0 || (path_size > 1 && (pp[Geom::X] < 1 || pp[Geom::X] > path_size - 1))) { + if (pp[Geom::Y] == 0 || (path_size > 1 && (pp[Geom::X] < 1 || pp[Geom::X] > path_size - 2))) { ++i; continue; } @@ -937,6 +958,10 @@ void PencilTool::powerStrokeInterpolate(Geom::Path path) } this->points = tmp_points; tmp_points.clear(); + if (this->points.empty()) { + Geom::Point one(Geom::Coord(path_size/2), this->_wps[this->_wps.size()/2][Geom::Y]); + this->points.push_back(one); + } sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), nullptr); } diff --git a/src/ui/tools/pencil-tool.h b/src/ui/tools/pencil-tool.h index 60edd3f78..e30db8067 100644 --- a/src/ui/tools/pencil-tool.h +++ b/src/ui/tools/pencil-tool.h @@ -48,8 +48,8 @@ public: Geom::Point p[16]; std::vector ps; std::vector points; - void addPowerStrokePencil(bool force, gint tolsimplify); - void powerStrokeInterpolate(Geom::Path); + void addPowerStrokePencil(bool reset); + void powerStrokeInterpolate(Geom::Path const path); Geom::Piecewise > sketch_interpolation; // the current proposal from the sketched paths unsigned sketch_n; // number of sketches done static const std::string prefsPath; @@ -76,12 +76,13 @@ private: void _extinput(GdkEvent *event); void _cancel(); void _endpointSnap(Geom::Point &p, guint const state); - std::vector _wps; + std::vector _wps; SPCurve * _curve; Geom::Point _req_tangent; bool _is_drawing; PencilState _state; gint _npoints; + gint size_powerpencil; // std::future future; }; -- cgit v1.2.3