Geom::Path half_outline_old(Geom::Path const& input, double width, double miter, Inkscape::LineJoinType join = Inkscape::JOIN_BEVEL) { Geom::Path res; if (input.size() == 0) return res; Geom::Point tang1 = input[0].unitTangentAt(0); Geom::Point start = input.initialPoint() + tang1 * width; Geom::Path temp; Geom::Point tang[2]; res.setStitching(true); temp.setStitching(true); res.start(start); // Do two curves at a time for efficiency, since the join function needs to know the outgoing curve as well const size_t k = (input.back_closed().isDegenerate() && input.closed()) ?input.size_default()-1:input.size_default(); for (size_t u = 0; u < k; u += 2) { temp.clear(); offset_curve_old(temp, &input[u], width); // on the first run through, there isn't a join if (u == 0) { res.append(temp); } else { tangents_old(tang, input[u-1], input[u]); outline_join(res, temp, tang[0], tang[1], width, miter, join); } // odd number of paths if (u < k - 1) { temp.clear(); offset_curve_old(temp, &input[u+1], width); tangents_old(tang, input[u], input[u+1]); outline_join(res, temp, tang[0], tang[1], width, miter, join); } } if (input.closed()) { Geom::Curve const &c1 = res.back(); Geom::Curve const &c2 = res.front(); temp.clear(); temp.append(c1); Geom::Path temp2; temp2.append(c2); tangents_old(tang, input.back(), input.front()); outline_join(temp, temp2, tang[0], tang[1], width, miter, join); res.erase(res.begin()); res.erase_last(); // res.append(temp); res.close(); } return res; }
std::vector<Geom::Path> LPEVonKoch::doEffect_path (std::vector<Geom::Path> const & path_in) { using namespace Geom; std::vector<Geom::Path> generating_path = generator.get_pathvector(); if (generating_path.size()==0) { return path_in; } //Collect transform matrices. Matrix m0; Geom::Path refpath = ref_path.get_pathvector().front(); Point A = refpath.pointAt(0); Point B = refpath.pointAt(refpath.size()); Point u = B-A; m0 = Matrix(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 = Matrix(u[X], u[Y],-u[Y], u[X], refA[X], refA[Y]); m0 = m0.inverse(); std::vector<Matrix> transforms; for (unsigned i=0; i<generating_path.size(); i++){ Matrix m; if(generating_path[i].size()==1){ Point p = generating_path[i].pointAt(0); Point u = generating_path[i].pointAt(1)-p; m = Matrix(u[X], u[Y],-u[Y], u[X], p[X], p[Y]); m = m0*m; transforms.push_back(m); }else if(generating_path[i].size()>=2){ Point p = generating_path[i].pointAt(1); Point u = generating_path[i].pointAt(2)-p; Point v = p-generating_path[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 = Matrix(u[X], u[Y],v[X], v[Y], p[X], p[Y]); m = m0*m; transforms.push_back(m); } } if (transforms.size()==0){ return path_in; } //Do nothing if the output is too complex... int path_in_complexity = 0; for (unsigned k = 0; k < path_in.size(); k++){ path_in_complexity+=path_in[k].size(); } double complexity = pow(transforms.size(),nbgenerations)*path_in_complexity; if (drawall.get_value()){ int k = transforms.size(); if(k>1){ complexity = (pow(k,nbgenerations+1)-1)/(k-1)*path_in_complexity; }else{ complexity = nbgenerations*k*path_in_complexity; } }else{ complexity = pow(transforms.size(),nbgenerations)*path_in_complexity; } if (complexity > double(maxComplexity)){ g_warning("VonKoch lpe's output too complex. Effect bypassed."); return path_in; } //Generate path: std::vector<Geom::Path> pathi = path_in; std::vector<Geom::Path> 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 = std::vector<Geom::Path>(); complexity = 0; } for (unsigned j = 0; j<transforms.size(); j++){ for (unsigned k = 0; k<pathi.size() && complexity < maxComplexity; k++){ path_out.push_back(pathi[k]*transforms[j]); complexity+=pathi[k].size(); } } pathi = path_out; } return path_out; }