8N/A

8N/A#include "ui/widget/scalar.h"

8N/A#include <glibmm/i18n.h>

8N/A#include "live_effects/lpe-rough-hatches.h"

8N/A

8N/A#include "sp-item.h"

8N/A#include "sp-path.h"

1241N/A#include "svg/svg.h"

8N/A#include "xml/repr.h"

8N/A

8N/A#include <2geom/path.h>

95N/A#include <2geom/piecewise.h>

459N/A#include <2geom/sbasis.h>

8N/A#include <2geom/sbasis-math.h>

749N/A#include <2geom/sbasis-geometric.h>

749N/A#include <2geom/bezier-to-sbasis.h>

771N/A#include <2geom/sbasis-to-bezier.h>

771N/A#include <2geom/d2.h>

749N/A#include <2geom/affine.h>

783N/A

1481N/A

1327N/Anamespace Inkscape {

1241N/Anamespace LivePathEffect {

1182N/A

8N/Ausing namespace Geom;

8N/A

8N/Astruct LevelCrossing{

664N/A Point pt;

232N/A double t;

1461N/A bool sign;

1327N/A bool used;

1327N/A std::pair<unsigned,unsigned> next_on_curve;

1241N/A std::pair<unsigned,unsigned> prev_on_curve;

1241N/A};

1241N/Astruct LevelCrossingOrder {

1241N/A bool operator()(LevelCrossing a, LevelCrossing b) {

1241N/A return ( a.pt[Y] < b.pt[Y] );// a.pt[X] == b.pt[X] since we are supposed to be on the same level...

1241N/A //return ( a.pt[X] < b.pt[X] || ( a.pt[X] == b.pt[X] && a.pt[Y] < b.pt[Y] ) );

1241N/A }

1461N/A};

1461N/Astruct LevelCrossingInfo{

1473N/A double t;

1473N/A unsigned level;

1473N/A unsigned idx;

1473N/A};

1461N/Astruct LevelCrossingInfoOrder {

1461N/A bool operator()(LevelCrossingInfo a, LevelCrossingInfo b) {

1461N/A return a.t < b.t;

1473N/A }

765N/A};

765N/A

765N/Atypedef std::vector<LevelCrossing> LevelCrossings;

765N/A

765N/Astatic std::vector<double>

765N/Adiscontinuities(Piecewise<D2<SBasis> > const &f){

765N/A std::vector<double> result;

1473N/A if (f.size()==0) return result;

765N/A result.push_back(f.cuts[0]);

765N/A Point prev_pt = f.segs[0].at1();

1473N/A //double old_t = f.cuts[0];

1473N/A for(unsigned i=1; i<f.size(); i++){

1473N/A if ( f.segs[i].at0()!=prev_pt){

765N/A result.push_back(f.cuts[i]);

765N/A //old_t = f.cuts[i];

1473N/A //assert(f.segs[i-1].at1()==f.valueAt(old_t));

765N/A }

1473N/A prev_pt = f.segs[i].at1();

765N/A }

65N/A result.push_back(f.cuts.back());

1473N/A //assert(f.segs.back().at1()==f.valueAt(old_t));

771N/A return result;

771N/A}

771N/A

771N/Aclass LevelsCrossings: public std::vector<LevelCrossings>{

771N/Apublic:

771N/A LevelsCrossings():std::vector<LevelCrossings>(){};

771N/A LevelsCrossings(std::vector<std::vector<double> > const &times,

771N/A Piecewise<D2<SBasis> > const &f,

771N/A Piecewise<SBasis> const &dx){

771N/A

771N/A for (unsigned i=0; i<times.size(); i++){

1473N/A LevelCrossings lcs;

1473N/A for (unsigned j=0; j<times[i].size(); j++){

771N/A LevelCrossing lc;

771N/A lc.pt = f.valueAt(times[i][j]);

771N/A lc.t = times[i][j];

771N/A lc.sign = ( dx.valueAt(times[i][j])>0 );

1473N/A lc.used = false;

771N/A lcs.push_back(lc);

1473N/A }

1473N/A std::sort(lcs.begin(), lcs.end(), LevelCrossingOrder());

1473N/A push_back(lcs);

783N/A }

783N/A //Now create time ordering.

783N/A std::vector<LevelCrossingInfo>temp;

783N/A for (unsigned i=0; i<size(); i++){

1327N/A for (unsigned j=0; j<(*this)[i].size(); j++){

1327N/A LevelCrossingInfo elem;

1327N/A elem.t = (*this)[i][j].t;

783N/A elem.level = i;

783N/A elem.idx = j;

771N/A temp.push_back(elem);

771N/A }

771N/A }

771N/A std::sort(temp.begin(),temp.end(),LevelCrossingInfoOrder());

771N/A std::vector<double> jumps = discontinuities(f);

771N/A unsigned jump_idx = 0;

771N/A unsigned first_in_comp = 0;

771N/A for (unsigned i=0; i<temp.size(); i++){

967N/A unsigned lvl = temp[i].level, idx = temp[i].idx;

771N/A if ( i == temp.size()-1 || temp[i+1].t > jumps[jump_idx+1]){

967N/A std::pair<unsigned,unsigned>next_data(temp[first_in_comp].level,temp[first_in_comp].idx);

967N/A (*this)[lvl][idx].next_on_curve = next_data;

771N/A first_in_comp = i+1;

771N/A jump_idx += 1;

771N/A }else{

967N/A std::pair<unsigned,unsigned> next_data(temp[i+1].level,temp[i+1].idx);

967N/A (*this)[lvl][idx].next_on_curve = next_data;

967N/A }

967N/A }

967N/A

967N/A for (unsigned i=0; i<size(); i++){

967N/A for (unsigned j=0; j<(*this)[i].size(); j++){

967N/A std::pair<unsigned,unsigned> next = (*this)[i][j].next_on_curve;

967N/A (*this)[next.first][next.second].prev_on_curve = std::pair<unsigned,unsigned>(i,j);

967N/A }

967N/A }

967N/A }

967N/A

967N/A void findFirstUnused(unsigned &level, unsigned &idx){

1461N/A level = size();

1473N/A idx = 0;

1473N/A for (unsigned i=0; i<size(); i++){

1473N/A for (unsigned j=0; j<(*this)[i].size(); j++){

967N/A if (!(*this)[i][j].used){

1473N/A level = i;

967N/A idx = j;

967N/A return;

967N/A }

967N/A }

967N/A }

967N/A }

967N/A //set indexes to point to the next point in the "snake walk"

1473N/A //follow_level's meaning:

1473N/A // 0=yes upward

967N/A // 1=no, last move was upward,

771N/A // 2=yes downward

771N/A // 3=no, last move was downward.

771N/A void step(unsigned &level, unsigned &idx, int &direction){

1473N/A if ( direction % 2 == 0 ){

65N/A if (direction == 0) {

1473N/A if ( idx >= (*this)[level].size()-1 || (*this)[level][idx+1].used ) {

1473N/A level = size();

1473N/A return;

1473N/A }

1467N/A idx += 1;

1467N/A }else{

65N/A if ( idx <= 0 || (*this)[level][idx-1].used ) {

1473N/A level = size();

1473N/A return;

65N/A }

65N/A idx -= 1;

1473N/A }

1473N/A direction += 1;

1473N/A return;

1473N/A }

1473N/A //double t = (*this)[level][idx].t;

176N/A double sign = ((*this)[level][idx].sign ? 1 : -1);

1473N/A //---double next_t = t;

176N/A //level += 1;

176N/A direction = (direction + 1)%4;

95N/A if (level == size()){

95N/A return;

1473N/A }

1182N/A

1182N/A std::pair<unsigned,unsigned> next;

1467N/A if ( sign > 0 ){

1462N/A next = (*this)[level][idx].next_on_curve;

95N/A }else{

1473N/A next = (*this)[level][idx].prev_on_curve;

1473N/A }

95N/A

95N/A if ( level+1 != next.first || (*this)[next.first][next.second].used ) {

65N/A level = size();

766N/A return;

766N/A }

766N/A level = next.first;

232N/A idx = next.second;

771N/A return;

771N/A }

771N/A};

771N/A

771N/A

1473N/Astatic Piecewise<D2<SBasis> > bend(Piecewise<D2<SBasis> > const &f, Piecewise<SBasis> bending){

1473N/A D2<Piecewise<SBasis> > ff = make_cuts_independent(f);

435N/A ff[X] += compose(bending, ff[Y]);

435N/A return sectionize(ff);

435N/A}

238N/A

1461N/ALPERoughHatches::LPERoughHatches(LivePathEffectObject *lpeobject) :

1461N/A Effect(lpeobject),

1461N/A hatch_dist(0),

1461N/A dist_rdm(_("Frequency randomness:"), _("Variation of distance between hatches, in %."), "dist_rdm", &wr, this, 75),

238N/A growth(_("Growth:"), _("Growth of distance between hatches."), "growth", &wr, this, 0.),

238N/A scale_tf(_("Half-turns smoothness: 1st side, in:"), _("Set smoothness/sharpness of path when reaching a 'bottom' half-turn. 0=sharp, 1=default"), "scale_bf", &wr, this, 1.),

232N/A scale_tb(_("1st side, out:"), _("Set smoothness/sharpness of path when leaving a 'bottom' half-turn. 0=sharp, 1=default"), "scale_bb", &wr, this, 1.),

969N/A scale_bf(_("2nd side, in:"), _("Set smoothness/sharpness of path when reaching a 'top' half-turn. 0=sharp, 1=default"), "scale_tf", &wr, this, 1.),

969N/A scale_bb(_("2nd side, out:"), _("Set smoothness/sharpness of path when leaving a 'top' half-turn. 0=sharp, 1=default"), "scale_tb", &wr, this, 1.),

969N/A top_edge_variation(_("Magnitude jitter: 1st side:"), _("Randomly moves 'bottom' half-turns to produce magnitude variations."), "bottom_edge_variation", &wr, this, 0),

969N/A bot_edge_variation(_("2nd side:"), _("Randomly moves 'top' half-turns to produce magnitude variations."), "top_edge_variation", &wr, this, 0),

969N/A top_tgt_variation(_("Parallelism jitter: 1st side:"), _("Add direction randomness by moving 'bottom' half-turns tangentially to the boundary."), "bottom_tgt_variation", &wr, this, 0),

969N/A bot_tgt_variation(_("2nd side:"), _("Add direction randomness by randomly moving 'top' half-turns tangentially to the boundary."), "top_tgt_variation", &wr, this, 0),

969N/A top_smth_variation(_("Variance: 1st side:"), _("Randomness of 'bottom' half-turns smoothness"), "top_smth_variation", &wr, this, 0),

969N/A bot_smth_variation(_("2nd side:"), _("Randomness of 'top' half-turns smoothness"), "bottom_smth_variation", &wr, this, 0),

1182N/A fat_output(_("Generate thick/thin path"), _("Simulate a stroke of varying width"), "fat_output", &wr, this, true),

1182N/A do_bend(_("Bend hatches"), _("Add a global bend to the hatches (slower)"), "do_bend", &wr, this, true),

1182N/A stroke_width_top(_("Thickness: at 1st side:"), _("Width at 'bottom' half-turns"), "stroke_width_top", &wr, this, 1.),

1182N/A stroke_width_bot(_("At 2nd side:"), _("Width at 'top' half-turns"), "stroke_width_bottom", &wr, this, 1.),

1327N/A front_thickness(_("From 2nd to 1st side:"), _("Width from 'top' to 'bottom'"), "front_thickness", &wr, this, 1.),

1481N/A back_thickness(_("From 1st to 2nd side:"), _("Width from 'bottom' to 'top'"), "back_thickness", &wr, this, .25),

1481N/A

1481N/A direction(_("Hatches width and dir"), _("Defines hatches frequency and direction"), "direction", &wr, this, Geom::Point(50,0)),

969N/A bender(_("Global bending"), _("Relative position to a reference point defines global bending direction and amount"), "bender", &wr, this, Geom::Point(-5,0))

969N/A{

969N/A registerParameter( dynamic_cast<Parameter *>(&direction) );

969N/A registerParameter( dynamic_cast<Parameter *>(&dist_rdm) );

969N/A registerParameter( dynamic_cast<Parameter *>(&growth) );

969N/A registerParameter( dynamic_cast<Parameter *>(&do_bend) );

969N/A registerParameter( dynamic_cast<Parameter *>(&bender) );

969N/A registerParameter( dynamic_cast<Parameter *>(&top_edge_variation) );

969N/A registerParameter( dynamic_cast<Parameter *>(&bot_edge_variation) );

771N/A registerParameter( dynamic_cast<Parameter *>(&top_tgt_variation) );

743N/A registerParameter( dynamic_cast<Parameter *>(&bot_tgt_variation) );

743N/A registerParameter( dynamic_cast<Parameter *>(&scale_tf) );

232N/A registerParameter( dynamic_cast<Parameter *>(&scale_tb) );

232N/A registerParameter( dynamic_cast<Parameter *>(&scale_bf) );

1190N/A registerParameter( dynamic_cast<Parameter *>(&scale_bb) );

203N/A registerParameter( dynamic_cast<Parameter *>(&top_smth_variation) );

203N/A registerParameter( dynamic_cast<Parameter *>(&bot_smth_variation) );

203N/A registerParameter( dynamic_cast<Parameter *>(&fat_output) );

203N/A registerParameter( dynamic_cast<Parameter *>(&stroke_width_top) );

203N/A registerParameter( dynamic_cast<Parameter *>(&stroke_width_bot) );

459N/A registerParameter( dynamic_cast<Parameter *>(&front_thickness) );

1190N/A registerParameter( dynamic_cast<Parameter *>(&back_thickness) );

314N/A

314N/A //hatch_dist.param_set_range(0.1, Geom::infinity());

1190N/A growth.param_set_range(0, Geom::infinity());

1473N/A dist_rdm.param_set_range(0, 99.);

1473N/A stroke_width_top.param_set_range(0, Geom::infinity());

1473N/A stroke_width_bot.param_set_range(0, Geom::infinity());

1473N/A front_thickness.param_set_range(0, Geom::infinity());

1473N/A back_thickness.param_set_range(0, Geom::infinity());

314N/A

1473N/A // hide the widgets for direction and bender vectorparams

1190N/A direction.widget_is_visible = false;

314N/A bender.widget_is_visible = false;

1473N/A // give distinguishing colors to direction and bender on-canvas params

1190N/A direction.set_oncanvas_color(0x00ff7d00);

1473N/A bender.set_oncanvas_color(0xffffb500);

314N/A

1461N/A concatenate_before_pwd2 = false;

1473N/A show_orig_path = true;

314N/A}

314N/A

749N/ALPERoughHatches::~LPERoughHatches()

1461N/A{

1461N/A

1461N/A}

1461N/A

1461N/AGeom::Piecewise<Geom::D2<Geom::SBasis> >

1461N/ALPERoughHatches::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in){

749N/A

1182N/A //std::cout<<"doEffect_pwd2:\n";

1182N/A

1190N/A Piecewise<D2<SBasis> > result;

1473N/A

1473N/A Piecewise<D2<SBasis> > transformed_pwd2_in = pwd2_in;

1473N/A Point start = pwd2_in.segs.front().at0();

1473N/A Point end = pwd2_in.segs.back().at1();

1473N/A if (end != start ){

1473N/A transformed_pwd2_in.push_cut( transformed_pwd2_in.cuts.back() + 1 );

1473N/A D2<SBasis> stitch( SBasis( 1, Linear(end[X],start[X]) ), SBasis( 1, Linear(end[Y],start[Y]) ) );

1182N/A transformed_pwd2_in.push_seg( stitch );

1182N/A }

749N/A Point transformed_org = direction.getOrigin();

1241N/A Piecewise<SBasis> tilter;//used to bend the hatches

1241N/A Affine bend_mat;//used to bend the hatches

1241N/A

1241N/A if (do_bend.get_value()){

1241N/A Point bend_dir = -rot90(unit_vector(bender.getVector()));

1241N/A double bend_amount = L2(bender.getVector());

1241N/A bend_mat = Affine(-bend_dir[Y], bend_dir[X], bend_dir[X], bend_dir[Y],0,0);

1241N/A transformed_pwd2_in = transformed_pwd2_in * bend_mat;

1241N/A tilter = Piecewise<SBasis>(shift(Linear(-bend_amount),1));

1241N/A OptRect bbox = bounds_exact( transformed_pwd2_in );

1241N/A if (!(bbox)) return pwd2_in;

1241N/A tilter.setDomain((*bbox)[Y]);

1241N/A transformed_pwd2_in = bend(transformed_pwd2_in, tilter);

1241N/A transformed_pwd2_in = transformed_pwd2_in * bend_mat.inverse();

1241N/A }

1241N/A hatch_dist = Geom::L2(direction.getVector())/5;

1470N/A Point hatches_dir = rot90(unit_vector(direction.getVector()));

1241N/A Affine mat(-hatches_dir[Y], hatches_dir[X], hatches_dir[X], hatches_dir[Y],0,0);

1241N/A transformed_pwd2_in = transformed_pwd2_in * mat;

1241N/A transformed_org *= mat;

1470N/A

1241N/A std::vector<std::vector<Point> > snakePoints;

1241N/A snakePoints = linearSnake(transformed_pwd2_in, transformed_org);

1241N/A if (!snakePoints.empty()){

1241N/A Piecewise<D2<SBasis> >smthSnake = smoothSnake(snakePoints);

8N/A smthSnake = smthSnake*mat.inverse();

if (do_bend.get_value()){

smthSnake = smthSnake*bend_mat;

smthSnake = bend(smthSnake, -tilter);

smthSnake = smthSnake*bend_mat.inverse();

}

return (smthSnake);

}

return pwd2_in;

}

std::vector<double>

LPERoughHatches::generateLevels(Interval const &domain, double x_org){

std::vector<double> result;

int n = int((domain.min()-x_org)/hatch_dist);

double x = x_org + n * hatch_dist;

//double x = domain.min() + double(hatch_dist)/2.;

double step = double(hatch_dist);

double scale = 1+(hatch_dist*growth/domain.extent());

while (x < domain.max()){

result.push_back(x);

double rdm = 1;

if (dist_rdm.get_value() != 0)

rdm = 1.+ double((2*dist_rdm - dist_rdm.get_value()))/100.;

x+= step*rdm;

step*=scale;//(1.+double(growth));

}

return result;

}

std::vector<std::vector<Point> >

LPERoughHatches::linearSnake(Piecewise<D2<SBasis> > const &f, Point const &org){

//std::cout<<"linearSnake:\n";

std::vector<std::vector<Point> > result;

Piecewise<SBasis> x = make_cuts_independent(f)[X];

//Remark: derivative is computed twice in the 2 lines below!!

Piecewise<SBasis> dx = derivative(x);

OptInterval range = bounds_exact(x);

if (!range) return result;

std::vector<double> levels = generateLevels(*range, org[X]);

std::vector<std::vector<double> > times;

times = multi_roots(x,levels);

std::vector<std::vector<double> > cleaned_times(levels.size(),std::vector<double>());

for (unsigned i=0; i<times.size(); i++){

if ( times[i].size()>0 ){

double last_t = times[i][0]-1;//ugly hack!!

for (unsigned j=0; j<times[i].size(); j++){

if (times[i][j]-last_t >0.000001){

last_t = times[i][j];

cleaned_times[i].push_back(last_t);

}

}

}

}

times = cleaned_times;

LevelsCrossings lscs(times,f,dx);

unsigned i,j;

lscs.findFirstUnused(i,j);

std::vector<Point> result_component;

int n = int((range->min()-org[X])/hatch_dist);

while ( i < lscs.size() ){

int dir = 0;

//switch orientation of first segment according to starting point.

if ((static_cast<long long>(i) % 2 == n % 2) && ((j + 1) < lscs[i].size()) && !lscs[i][j].used){

j += 1;

dir = 2;

}

while ( i < lscs.size() ){

result_component.push_back(lscs[i][j].pt);

lscs[i][j].used = true;

lscs.step(i,j, dir);

}

result.push_back(result_component);

result_component = std::vector<Point>();

lscs.findFirstUnused(i,j);

}

return result;

}

Piecewise<D2<SBasis> >

LPERoughHatches::smoothSnake(std::vector<std::vector<Point> > const &linearSnake){

Piecewise<D2<SBasis> > result;

for (unsigned comp=0; comp<linearSnake.size(); comp++){

if (linearSnake[comp].size()>=2){

Point last_pt = linearSnake[comp][0];

//Point last_top = linearSnake[comp][0];

//Point last_bot = linearSnake[comp][0];

Point last_hdle = linearSnake[comp][0];

Point last_top_hdle = linearSnake[comp][0];

Point last_bot_hdle = linearSnake[comp][0];

Geom::Path res_comp(last_pt);

Geom::Path res_comp_top(last_pt);

Geom::Path res_comp_bot(last_pt);

unsigned i=1;

//bool is_top = true;//Inversion here; due to downward y?

bool is_top = ( linearSnake[comp][0][Y] < linearSnake[comp][1][Y] );

while( i+1<linearSnake[comp].size() ){

Point pt0 = linearSnake[comp][i];

Point pt1 = linearSnake[comp][i+1];

Point new_pt = (pt0+pt1)/2;

double scale_in = (is_top ? scale_tf : scale_bf );

double scale_out = (is_top ? scale_tb : scale_bb );

if (is_top){

if (top_edge_variation.get_value() != 0)

new_pt[Y] += double(top_edge_variation)-top_edge_variation.get_value()/2.;

if (top_tgt_variation.get_value() != 0)

new_pt[X] += double(top_tgt_variation)-top_tgt_variation.get_value()/2.;

if (top_smth_variation.get_value() != 0) {

scale_in*=(100.-double(top_smth_variation))/100.;

scale_out*=(100.-double(top_smth_variation))/100.;

}

}else{

if (bot_edge_variation.get_value() != 0)

new_pt[Y] += double(bot_edge_variation)-bot_edge_variation.get_value()/2.;

if (bot_tgt_variation.get_value() != 0)

new_pt[X] += double(bot_tgt_variation)-bot_tgt_variation.get_value()/2.;

if (bot_smth_variation.get_value() != 0) {

scale_in*=(100.-double(bot_smth_variation))/100.;

scale_out*=(100.-double(bot_smth_variation))/100.;

}

}

Point new_hdle_in = new_pt + (pt0-pt1) * (scale_in /2.);

Point new_hdle_out = new_pt - (pt0-pt1) * (scale_out/2.);

if ( fat_output.get_value() ){

//double scaled_width = double((is_top ? stroke_width_top : stroke_width_bot))/(pt1[X]-pt0[X]);

//double scaled_width = 1./(pt1[X]-pt0[X]);

//Point hdle_offset = (pt1-pt0)*scaled_width;

Point inside = new_pt;

Point inside_hdle_in;

Point inside_hdle_out;

inside[Y]+= double((is_top ? -stroke_width_top : stroke_width_bot));

inside_hdle_in = inside + (new_hdle_in -new_pt);// + hdle_offset * double((is_top ? front_thickness : back_thickness));

inside_hdle_out = inside + (new_hdle_out-new_pt);// - hdle_offset * double((is_top ? back_thickness : front_thickness));

inside_hdle_in += (pt1-pt0)/2*( double((is_top ? front_thickness : back_thickness)) / (pt1[X]-pt0[X]) );

inside_hdle_out -= (pt1-pt0)/2*( double((is_top ? back_thickness : front_thickness)) / (pt1[X]-pt0[X]) );

new_hdle_in -= (pt1-pt0)/2*( double((is_top ? front_thickness : back_thickness)) / (pt1[X]-pt0[X]) );

new_hdle_out += (pt1-pt0)/2*( double((is_top ? back_thickness : front_thickness)) / (pt1[X]-pt0[X]) );

//TODO: find a good way to handle limit cases (small smthness, large stroke).

//if (inside_hdle_in[X] > inside[X]) inside_hdle_in = inside;

//if (inside_hdle_out[X] < inside[X]) inside_hdle_out = inside;

if (is_top){

res_comp_top.appendNew<CubicBezier>(last_top_hdle,new_hdle_in,new_pt);

res_comp_bot.appendNew<CubicBezier>(last_bot_hdle,inside_hdle_in,inside);

last_top_hdle = new_hdle_out;

last_bot_hdle = inside_hdle_out;

}else{

res_comp_top.appendNew<CubicBezier>(last_top_hdle,inside_hdle_in,inside);

res_comp_bot.appendNew<CubicBezier>(last_bot_hdle,new_hdle_in,new_pt);

last_top_hdle = inside_hdle_out;

last_bot_hdle = new_hdle_out;

}

}else{

res_comp.appendNew<CubicBezier>(last_hdle,new_hdle_in,new_pt);

}

last_hdle = new_hdle_out;

i+=2;

is_top = !is_top;

}

if ( i<linearSnake[comp].size() ){

if ( fat_output.get_value() ){

res_comp_top.appendNew<CubicBezier>(last_top_hdle,linearSnake[comp][i],linearSnake[comp][i]);

res_comp_bot.appendNew<CubicBezier>(last_bot_hdle,linearSnake[comp][i],linearSnake[comp][i]);

}else{

res_comp.appendNew<CubicBezier>(last_hdle,linearSnake[comp][i],linearSnake[comp][i]);

}

}

if ( fat_output.get_value() ){

res_comp = res_comp_bot;

res_comp.append(res_comp_top.reverse(),Geom::Path::STITCH_DISCONTINUOUS);

}

result.concat(res_comp.toPwSb());

}

}

return result;

}

LPERoughHatches::doBeforeEffect (SPLPEItem const*/*lpeitem*/)

{

using namespace Geom;

top_edge_variation.resetRandomizer();

bot_edge_variation.resetRandomizer();

top_tgt_variation.resetRandomizer();

bot_tgt_variation.resetRandomizer();

top_smth_variation.resetRandomizer();

bot_smth_variation.resetRandomizer();

dist_rdm.resetRandomizer();

//original_bbox(lpeitem);

}

LPERoughHatches::resetDefaults(SPItem const* item)

{

Effect::resetDefaults(item);

Geom::OptRect bbox = item->geometricBounds();

Geom::Point origin(0.,0.);

Geom::Point vector(50.,0.);

if (bbox) {

origin = bbox->midpoint();

vector = Geom::Point((*bbox)[X].extent()/4, 0.);

top_edge_variation.param_set_value( (*bbox)[Y].extent()/10, 0 );

bot_edge_variation.param_set_value( (*bbox)[Y].extent()/10, 0 );

top_edge_variation.write_to_SVG();

bot_edge_variation.write_to_SVG();

}

//direction.set_and_write_new_values(origin, vector);

//bender.param_set_and_write_new_value( origin + Geom::Point(5,0) );

direction.set_and_write_new_values(origin + Geom::Point(0,-5), vector);

bender.set_and_write_new_values( origin, Geom::Point(5,0) );

hatch_dist = Geom::L2(vector)/2;

}

} //namespace LivePathEffect

} /* namespace Inkscape */