summaryrefslogtreecommitdiffstats
path: root/src/live_effects/lpe-vonkoch.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/live_effects/lpe-vonkoch.cpp')
-rw-r--r--src/live_effects/lpe-vonkoch.cpp334
1 files changed, 334 insertions, 0 deletions
diff --git a/src/live_effects/lpe-vonkoch.cpp b/src/live_effects/lpe-vonkoch.cpp
new file mode 100644
index 0000000..277c5f3
--- /dev/null
+++ b/src/live_effects/lpe-vonkoch.cpp
@@ -0,0 +1,334 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (C) JF Barraud 2007 <jf.barraud@gmail.com>
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <vector>
+#include "live_effects/lpe-vonkoch.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+void
+VonKochPathParam::param_setup_nodepath(Inkscape::NodePath::Path *np)
+{
+ PathParam::param_setup_nodepath(np);
+ //sp_nodepath_make_straight_path(np);
+}
+
+//FIXME: a path is used here instead of 2 points to work around path/point param incompatibility bug.
+void
+VonKochRefPathParam::param_setup_nodepath(Inkscape::NodePath::Path *np)
+{
+ PathParam::param_setup_nodepath(np);
+ //sp_nodepath_make_straight_path(np);
+}
+bool
+VonKochRefPathParam::param_readSVGValue(const gchar * strvalue)
+{
+ Geom::PathVector old = _pathvector;
+ bool res = PathParam::param_readSVGValue(strvalue);
+ if (res && _pathvector.size()==1 && _pathvector.front().size()==1){
+ return true;
+ }else{
+ _pathvector = old;
+ return false;
+ }
+}
+
+LPEVonKoch::LPEVonKoch(LivePathEffectObject *lpeobject) :
+ Effect(lpeobject),
+ nbgenerations(_("N_r of generations:"), _("Depth of the recursion --- keep low!!"), "nbgenerations", &wr, this, 1),
+ generator(_("Generating path:"), _("Path whose segments define the iterated transforms"), "generator", &wr, this, "M0,0 L30,0 M0,10 L10,10 M 20,10 L30,10"),
+ similar_only(_("_Use uniform transforms only"), _("2 consecutive segments are used to reverse/preserve orientation only (otherwise, they define a general transform)."), "similar_only", &wr, this, false),
+ drawall(_("Dra_w all generations"), _("If unchecked, draw only the last generation"), "drawall", &wr, this, true),
+ //,draw_boxes(_("Display boxes"), _("Display boxes instead of paths only"), "draw_boxes", &wr, this, true)
+ ref_path(_("Reference segment:"), _("The reference segment. Defaults to the horizontal midline of the bbox."), "ref_path", &wr, this, "M0,0 L10,0"),
+ //refA(_("Ref Start"), _("Left side middle of the reference box"), "refA", &wr, this),
+ //refB(_("Ref End"), _("Right side middle of the reference box"), "refB", &wr, this),
+ //FIXME: a path is used here instead of 2 points to work around path/point param incompatibility bug.
+ maxComplexity(_("_Max complexity:"), _("Disable effect if the output is too complex"), "maxComplexity", &wr, this, 1000)
+{
+ //FIXME: a path is used here instead of 2 points to work around path/point param incompatibility bug.
+ registerParameter(&ref_path);
+ //registerParameter(&refA) );
+ //registerParameter(&refB) );
+ registerParameter(&generator);
+ registerParameter(&similar_only);
+ registerParameter(&nbgenerations);
+ registerParameter(&drawall);
+ registerParameter(&maxComplexity);
+ //registerParameter(&draw_boxes) );
+ apply_to_clippath_and_mask = true;
+ nbgenerations.param_make_integer();
+ nbgenerations.param_set_range(0, std::numeric_limits<gint>::max());
+ maxComplexity.param_make_integer();
+ maxComplexity.param_set_range(0, std::numeric_limits<gint>::max());
+}
+
+LPEVonKoch::~LPEVonKoch()
+= default;
+
+bool
+LPEVonKoch::doOnOpen(SPLPEItem const *lpeitem)
+{
+ if (!is_load || is_applied) {
+ return false;
+ }
+ generator.reload();
+ ref_path.reload();
+ return false;
+}
+
+
+Geom::PathVector
+LPEVonKoch::doEffect_path (Geom::PathVector const & path_in)
+{
+ using namespace Geom;
+ Geom::Affine affine = generator.get_relative_affine();
+ Geom::PathVector generating_path = generator.get_pathvector() * affine;
+
+ if (generating_path.empty()) {
+ return path_in;
+ }
+ if (is_load) {
+ generator.reload();
+ ref_path.reload();
+ }
+
+ //Collect transform matrices.
+ affine = ref_path.get_relative_affine();
+
+ Affine m0;
+ Geom::Path refpath = ref_path.get_pathvector().front() * affine ;
+ Point A = refpath.pointAt(0);
+ Point B = refpath.pointAt(refpath.size());
+ Point u = B-A;
+ m0 = Affine(u[X], u[Y],-u[Y], u[X], A[X], A[Y]);
+
+ //FIXME: a path is used as ref instead of 2 points to work around path/point param incompatibility bug.
+ //Point u = refB-refA;
+ //m0 = Affine(u[X], u[Y],-u[Y], u[X], refA[X], refA[Y]);
+ m0 = m0.inverse();
+
+ std::vector<Affine> transforms;
+ for (const auto & i : generating_path){
+ Affine m;
+ if(i.size()==1){
+ Point p = i.pointAt(0);
+ Point u = i.pointAt(1)-p;
+ m = Affine(u[X], u[Y],-u[Y], u[X], p[X], p[Y]);
+ m = m0*m;
+ transforms.push_back(m);
+ }else if(i.size()>=2){
+ Point p = i.pointAt(1);
+ Point u = i.pointAt(2)-p;
+ Point v = p-i.pointAt(0);
+ if (similar_only.get_value()){
+ int sign = (u[X]*v[Y]-u[Y]*v[X]>=0?1:-1);
+ v[X] = -u[Y]*sign;
+ v[Y] = u[X]*sign;
+ }
+ m = Affine(u[X], u[Y],v[X], v[Y], p[X], p[Y]);
+ m = m0*m;
+ transforms.push_back(m);
+ }
+ }
+
+ if (transforms.empty()){
+ return path_in;
+ }
+
+ //Do nothing if the output is too complex...
+ int path_in_complexity = 0;
+ for (const auto & k : path_in){
+ path_in_complexity+=k.size();
+ }
+ double complexity = std::pow(transforms.size(), nbgenerations) * path_in_complexity;
+ if (drawall.get_value()){
+ int k = transforms.size();
+ if(k>1){
+ complexity = (std::pow(k,nbgenerations+1)-1)/(k-1)*path_in_complexity;
+ }else{
+ complexity = nbgenerations*k*path_in_complexity;
+ }
+ }
+ if (complexity > double(maxComplexity)){
+ g_warning("VonKoch lpe's output too complex. Effect bypassed.");
+ return path_in;
+ }
+
+ //Generate path:
+ Geom::PathVector pathi = path_in;
+ Geom::PathVector path_out = path_in;
+
+ for (unsigned i = 0; i<nbgenerations; i++){
+ if (drawall.get_value()){
+ path_out = path_in;
+ complexity = path_in_complexity;
+ }else{
+ path_out = Geom::PathVector();
+ complexity = 0;
+ }
+ for (const auto & transform : transforms){
+ for (unsigned k = 0; k<pathi.size() && complexity < maxComplexity; k++){
+ path_out.push_back(pathi[k]*transform);
+ complexity+=pathi[k].size();
+ }
+ }
+ pathi = path_out;
+ }
+ return path_out;
+}
+
+
+//Useful??
+//void
+//LPEVonKoch::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
+/*{
+ using namespace Geom;
+ if (draw_boxes.get_value()){
+ double ratio = .5;
+ if (similar_only.get_value()) ratio = boundingbox_Y.extent()/boundingbox_X.extent()/2;
+
+ Point BB1,BB2,BB3,BB4,v;
+
+ //Draw the reference box (ref_path is supposed to consist in one line segment)
+ //FIXME: a path is used as ref instead of 2 points to work around path/point param incompatibility bug.
+ Geom::Path refpath = ref_path.get_pathvector().front();
+ if (refpath.size()==1){
+ BB1 = BB4 = refpath.front().pointAt(0);
+ BB2 = BB3 = refpath.front().pointAt(1);
+ v = rot90(BB2 - BB1)*ratio;
+ BB1 -= v;
+ BB2 -= v;
+ BB3 += v;
+ BB4 += v;
+ Geom::Path refbox(BB1);
+ refbox.appendNew<LineSegment>(BB2);
+ refbox.appendNew<LineSegment>(BB3);
+ refbox.appendNew<LineSegment>(BB4);
+ refbox.close();
+ PathVector refbox_as_vect;
+ refbox_as_vect.push_back(refbox);
+ hp_vec.push_back(refbox_as_vect);
+ }
+ //Draw the transformed boxes
+ Geom::PathVector generating_path = generator.get_pathvector();
+ for (unsigned i=0;i<generating_path.size(); i++){
+ if (generating_path[i].size()==0){
+ //Ooops! this should not happen.
+ }else if (generating_path[i].size()==1){
+ BB1 = BB4 = generating_path[i].pointAt(0);
+ BB2 = BB3 = generating_path[i].pointAt(1);
+ v = rot90(BB2 - BB1)*ratio;
+ }else{//Only tak the first 2 segments into account.
+ BB1 = BB4 = generating_path[i].pointAt(1);
+ BB2 = BB3 = generating_path[i].pointAt(2);
+ if(similar_only.get_value()){
+ v = rot90(BB2 - BB1)*ratio;
+ }else{
+ v = (generating_path[i].pointAt(0) - BB1)*ratio;
+ }
+ }
+ BB1 -= v;
+ BB2 -= v;
+ BB3 += v;
+ BB4 += v;
+ Geom::Path path(BB1);
+ path.appendNew<LineSegment>(BB2);
+ path.appendNew<LineSegment>(BB3);
+ path.appendNew<LineSegment>(BB4);
+ path.close();
+ PathVector pathv;
+ pathv.push_back(path);
+ hp_vec.push_back(pathv);
+ }
+ }
+}
+*/
+
+void
+LPEVonKoch::doBeforeEffect (SPLPEItem const* lpeitem)
+{
+ using namespace Geom;
+ original_bbox(lpeitem, false, true);
+
+ Geom::PathVector paths = ref_path.get_pathvector();
+ Geom::Point A,B;
+ if (paths.empty()||paths.front().size()==0){
+ //FIXME: a path is used as ref instead of 2 points to work around path/point param incompatibility bug.
+ //refA.param_setValue( Geom::Point(boundingbox_X.min(), boundingbox_Y.middle()) );
+ //refB.param_setValue( Geom::Point(boundingbox_X.max(), boundingbox_Y.middle()) );
+ A = Point(boundingbox_X.min(), boundingbox_Y.middle());
+ B = Point(boundingbox_X.max(), boundingbox_Y.middle());
+ }else{
+ A = paths.front().pointAt(0);
+ B = paths.front().pointAt(paths.front().size());
+ }
+ if (paths.size()!=1||paths.front().size()!=1){
+ Geom::Path tmp_path(A);
+ tmp_path.appendNew<LineSegment>(B);
+ Geom::PathVector tmp_pathv;
+ tmp_pathv.push_back(tmp_path);
+ ref_path.set_new_value(tmp_pathv,true);
+ }
+}
+
+
+void
+LPEVonKoch::resetDefaults(SPItem const* item)
+{
+ Effect::resetDefaults(item);
+
+ using namespace Geom;
+ original_bbox(SP_LPE_ITEM(item), false, true);
+
+ Point A,B;
+ A[Geom::X] = boundingbox_X.min();
+ A[Geom::Y] = boundingbox_Y.middle();
+ B[Geom::X] = boundingbox_X.max();
+ B[Geom::Y] = boundingbox_Y.middle();
+
+ Geom::PathVector paths,refpaths;
+ Geom::Path path = Geom::Path(A);
+ path.appendNew<Geom::LineSegment>(B);
+
+ refpaths.push_back(path);
+ ref_path.set_new_value(refpaths, true);
+
+ paths.push_back(path * Affine(1./3,0,0,1./3, A[X]*2./3, A[Y]*2./3 + boundingbox_Y.extent()/2));
+ paths.push_back(path * Affine(1./3,0,0,1./3, B[X]*2./3, B[Y]*2./3 + boundingbox_Y.extent()/2));
+ generator.set_new_value(paths, true);
+
+ //FIXME: a path is used as ref instead of 2 points to work around path/point param incompatibility bug.
+ //refA[Geom::X] = boundingbox_X.min();
+ //refA[Geom::Y] = boundingbox_Y.middle();
+ //refB[Geom::X] = boundingbox_X.max();
+ //refB[Geom::Y] = boundingbox_Y.middle();
+ //Geom::PathVector paths;
+ //Geom::Path path = Geom::Path( (Point) refA);
+ //path.appendNew<Geom::LineSegment>( (Point) refB );
+ //paths.push_back(path * Affine(1./3,0,0,1./3, refA[X]*2./3, refA[Y]*2./3 + boundingbox_Y.extent()/2));
+ //paths.push_back(path * Affine(1./3,0,0,1./3, refB[X]*2./3, refB[Y]*2./3 + boundingbox_Y.extent()/2));
+ //paths.push_back(path);
+ //generator.set_new_value(paths, true);
+}
+
+} // 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 :