#include <glibmm/i18n.h>

#include <gdk/gdk.h>

#include <2geom/path-intersection.h>

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

#include "live_effects/lpe-copy_rotate.h"

#include <2geom/path.h>

#include <2geom/transforms.h>

#include <2geom/d2-sbasis.h>

#include <2geom/angle.h>

#include "knot-holder-entity.h"

#include "knotholder.h"

namespace Inkscape {

namespace LivePathEffect {

namespace CR {

class KnotHolderEntityStartingAngle : public LPEKnotHolderEntity {

public:

KnotHolderEntityStartingAngle(LPECopyRotate *effect) : LPEKnotHolderEntity(effect) {};

virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);

virtual Geom::Point knot_get() const;

};

class KnotHolderEntityRotationAngle : public LPEKnotHolderEntity {

public:

KnotHolderEntityRotationAngle(LPECopyRotate *effect) : LPEKnotHolderEntity(effect) {};

virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);

virtual Geom::Point knot_get() const;

};

} // namespace CR

LPECopyRotate::LPECopyRotate(LivePathEffectObject *lpeobject) :

Effect(lpeobject),

origin(_("Origin"), _("Origin of the rotation"), "origin", &wr, this, "Adjust the origin of the rotation"),

starting_angle(_("Starting:"), _("Angle of the first copy"), "starting_angle", &wr, this, 0.0),

rotation_angle(_("Rotation angle:"), _("Angle between two successive copies"), "rotation_angle", &wr, this, 30.0),

num_copies(_("Number of copies:"), _("Number of copies of the original path"), "num_copies", &wr, this, 5),

copies_to_360(_("360º Copies"), _("No rotation angle, fixed to 360º"), "copies_to_360", &wr, this, true),

kaleidoscope(_("kaleidoscope"), _("kaleidoscope"), "kaleidoscope", &wr, this, false),

dist_angle_handle(100.0)

{

show_orig_path = true;

_provides_knotholder_entities = true;

// register all your parameters here, so Inkscape knows which parameters this effect has:

registerParameter(&copies_to_360);

registerParameter(&kaleidoscope);

registerParameter(&starting_angle);

registerParameter(&rotation_angle);

registerParameter(&num_copies);

registerParameter(&origin);

num_copies.param_make_integer(true);

num_copies.param_set_range(0, 1000);

}

LPECopyRotate::~LPECopyRotate()

{

}

LPECopyRotate::doOnApply(SPLPEItem const* lpeitem)

{

using namespace Geom;

original_bbox(lpeitem);

A = Point(boundingbox_X.min(), boundingbox_Y.middle());

B = Point(boundingbox_X.middle(), boundingbox_Y.middle());

origin.param_setValue(A);

origin.param_update_default(A);

dist_angle_handle = L2(B - A);

dir = unit_vector(B - A);

}

LPECopyRotate::transform_multiply(Geom::Affine const& postmul, bool set)

{

if(kaleidoscope) {

Geom::Coord angle = Geom::rad_to_deg(atan(-postmul[1]/postmul[0]));

angle += starting_angle;

starting_angle.param_set_value(angle);

}

// cycle through all parameters. Most parameters will not need transformation, but path and point params do.

for (std::vector<Parameter *>::iterator it = param_vector.begin(); it != param_vector.end(); ++it) {

Parameter * param = *it;

param->param_transform_multiply(postmul, set);

}

}

LPECopyRotate::doBeforeEffect (SPLPEItem const* lpeitem)

{

using namespace Geom;

original_bbox(lpeitem);

if(copies_to_360 ) {

rotation_angle.param_set_value(360.0/(double)num_copies);

}

if(kaleidoscope && copies_to_360) {

num_copies.param_set_increments(2,2);

if((int)num_copies%2 !=0) {

num_copies.param_set_value(num_copies+1);

}

} else {

num_copies.param_set_increments(1,1);

}

if(dist_angle_handle < 1.0) {

dist_angle_handle = 1.0;

}

A = Point(boundingbox_X.min(), boundingbox_Y.middle());

B = Point(boundingbox_X.middle(), boundingbox_Y.middle());

dir = unit_vector(B - A);

// I first suspected the minus sign to be a bug in 2geom but it is

// likely due to SVG's choice of coordinate system orientation (max)

start_pos = origin + dir * Rotate(-deg_to_rad(starting_angle)) * dist_angle_handle;

rot_pos = origin + dir * Rotate(-deg_to_rad(rotation_angle+starting_angle)) * dist_angle_handle;

if( kaleidoscope || copies_to_360 ) {

rot_pos = origin;

}

SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);

item->apply_to_clippath(item);

item->apply_to_mask(item);

}

LPECopyRotate::pointSideOfLine(Geom::Point A, Geom::Point B, Geom::Point X)

{

//http://stackoverflow.com/questions/1560492/how-to-tell-whether-a-point-is-to-the-right-or-left-side-of-a-line

double pos = (B[Geom::X]-A[Geom::X])*(X[Geom::Y]-A[Geom::Y]) - (B[Geom::Y]-A[Geom::Y])*(X[Geom::X]-A[Geom::X]);

return (pos < 0) ? -1 : (pos > 0);

}

LPECopyRotate::pointInTriangle(Geom::Point p, Geom::Point p1, Geom::Point p2, Geom::Point p3)

{

//http://totologic.blogspot.com.es/2014/01/accurate-point-in-triangle-test.html

using Geom::X;

using Geom::Y;

double denominator = (p1[X]*(p2[Y] - p3[Y]) + p1[Y]*(p3[X] - p2[X]) + p2[X]*p3[Y] - p2[Y]*p3[X]);

double t1 = (p[X]*(p3[Y] - p1[Y]) + p[Y]*(p1[X] - p3[X]) - p1[X]*p3[Y] + p1[Y]*p3[X]) / denominator;

double t2 = (p[X]*(p2[Y] - p1[Y]) + p[Y]*(p1[X] - p2[X]) - p1[X]*p2[Y] + p1[Y]*p2[X]) / -denominator;

double s = t1 + t2;

return 0 <= t1 && t1 <= 1 && 0 <= t2 && t2 <= 1 && s <= 1;

}

LPECopyRotate::split(std::vector<Geom::Path> &path_on,Geom::Path divider)

{

std::vector<Geom::Path> tmp_path;

double time_start = 0.0;

Geom::Path original = path_on[0];

int position = 0;

Geom::Crossings cs = crossings(original,divider);

std::vector<double> crossed;

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

crossed.push_back(cs[i].ta);

}

std::sort (crossed.begin(), crossed.end());

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

double timeEnd = crossed[i];

Geom::Path portion_original = original.portion(time_start,timeEnd);

Geom::Point side_checker = portion_original.pointAt(0.001);

position = pointSideOfLine(divider[0].finalPoint(), divider[1].finalPoint(), side_checker);

if(num_copies > 2) {

position = pointInTriangle(side_checker, divider.initialPoint(), divider[0].finalPoint(), divider[1].finalPoint());

}

if(position == 1) {

tmp_path.push_back(portion_original);

}

portion_original.clear();

time_start = timeEnd;

}

position = pointSideOfLine(divider[0].finalPoint(), divider[1].finalPoint(), original.finalPoint());

if(num_copies > 2) {

position = pointInTriangle(original.finalPoint(), divider.initialPoint(), divider[0].finalPoint(), divider[1].finalPoint());

}

if(cs.size() > 0 && position == 1) {

Geom::Path portion_original = original.portion(time_start, original.size());

if (!original.closed()) {

tmp_path.push_back(portion_original);

} else {

if(tmp_path.size() > 0 && tmp_path[0].size() > 0 ) {

portion_original.setFinal(tmp_path[0].initialPoint());

portion_original.append(tmp_path[0]);

tmp_path[0] = portion_original;

} else {

tmp_path.push_back(portion_original);

}

//temp_path[0].close();

}

portion_original.clear();

}

if(cs.size()==0 && position == 1) {

tmp_path.push_back(original);

}

path_on = tmp_path;

}

LPECopyRotate::split_extreme(std::vector<Geom::Path> &path_on,Geom::Path divider_extreme)

{

std::vector<Geom::Path> tmp_path;

double time_start = 0.0;

Geom::Path original = path_on[0];

int position = 0;

Geom::Crossings cs = crossings(original,divider_extreme);

std::vector<double> crossed;

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

crossed.push_back(cs[i].ta);

}

std::sort (crossed.begin(), crossed.end());

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

double timeEnd = crossed[i];

Geom::Path portion_original = original.portion(time_start,timeEnd);

Geom::Point side_checker = portion_original.pointAt(0.001);

position = pointSideOfLine(divider_extreme[0].finalPoint(), divider_extreme[1].finalPoint(), side_checker);

if(num_copies > 2) {

position = pointInTriangle(side_checker, divider_extreme.initialPoint(), divider_extreme[0].finalPoint(), divider_extreme[1].finalPoint());

}

if(position == 1) {

Geom::Path start = Geom::Path(divider_extreme.pointAt(0));

start.appendNew<Geom::LineSegment>(divider_extreme.pointAt(1));

if(!are_near(start.pointAt(nearest_point(portion_original.initialPoint(),start)),portion_original.initialPoint())){

portion_original.reverse();

}

tmp_path.push_back(portion_original);

}

portion_original.clear();

time_start = timeEnd;

}

position = pointSideOfLine(divider_extreme[0].finalPoint(), divider_extreme[1].finalPoint(), original.finalPoint());

if(num_copies > 2) {

position = pointInTriangle(original.finalPoint(), divider_extreme.initialPoint(), divider_extreme[0].finalPoint(), divider_extreme[1].finalPoint());

}

if(cs.size() > 0 && position == 1) {

Geom::Path portion_original = original.portion(time_start, original.size());

Geom::Path start = Geom::Path(divider_extreme.pointAt(0));

start.appendNew<Geom::LineSegment>(divider_extreme.pointAt(1));

if(!are_near(start.pointAt(nearest_point(portion_original.initialPoint(),start)),portion_original.initialPoint())){

portion_original.reverse();

}

if (!original.closed()) {

tmp_path.push_back(portion_original);

} else {

if(tmp_path.size() > 0 && tmp_path[0].size() > 0 ) {

portion_original.setFinal(tmp_path[0].initialPoint());

portion_original.append(tmp_path[0]);

tmp_path[0] = portion_original;

} else {

tmp_path.push_back(portion_original);

}

//temp_path[0].close();

}

portion_original.clear();

}

if(cs.size()==0 && position == 1) {

tmp_path.push_back(original);

}

path_on = tmp_path;

}

LPECopyRotate::setKaleidoscope(std::vector<Geom::Path> &path_on, Geom::Path divider, Geom::Path divider_start, Geom::Path divider_end, double size_divider)

{

std::vector<Geom::Path> path_on_start = path_on;

split(path_on,divider);

std::vector<Geom::Path> tmp_path;

Geom::Affine pre = Geom::Translate(-origin);

for (Geom::PathVector::const_iterator path_it = path_on.begin(); path_it != path_on.end(); ++path_it) {

Geom::Path original = *path_it;

if (path_it->empty()) {

continue;

}

std::vector<Geom::Path> tmp_path_helper;

Geom::Path append_path = original;

for (int i = 0; i < num_copies; ++i) {

Geom::Rotate rot(-Geom::deg_to_rad(rotation_angle * (i)));

Geom::Affine m = pre * rot * Geom::Translate(origin);

if(i%2 != 0) {

Geom::Point A = (Geom::Point)origin;

Geom::Point B = origin + dir * Geom::Rotate(-Geom::deg_to_rad((rotation_angle*i)+starting_angle)) * size_divider;

Geom::Affine m1(1.0, 0.0, 0.0, 1.0, A[0], A[1]);

double hyp = Geom::distance(A, B);

double c = (B[0] - A[0]) / hyp; // cos(alpha)

double s = (B[1] - A[1]) / hyp; // sin(alpha)

Geom::Affine m2(c, -s, s, c, 0.0, 0.0);

Geom::Affine sca(1.0, 0.0, 0.0, -1.0, 0.0, 0.0);

Geom::Affine tmpM = m1.inverse() * m2;

m = tmpM;

m = m * sca;

m = m * m2.inverse();

m = m * m1;

} else {

append_path = original;

}

append_path *= m;

if(i != 0 && tmp_path_helper.size() > 0 &&( Geom::are_near(tmp_path_helper[tmp_path_helper.size()-1].finalPoint(),append_path.finalPoint()))) {

Geom::Path tmp_append = append_path.reverse();

tmp_append.setInitial(tmp_path_helper[tmp_path_helper.size()-1].finalPoint());

tmp_path_helper[tmp_path_helper.size()-1].append(tmp_append);

} else if(i != 0 && tmp_path_helper.size() > 0 && Geom::are_near(tmp_path_helper[tmp_path_helper.size()-1].initialPoint(),append_path.initialPoint())) {

Geom::Path tmp_append = append_path;

tmp_path_helper[tmp_path_helper.size()-1] = tmp_path_helper[tmp_path_helper.size()-1].reverse();

tmp_append.setInitial(tmp_path_helper[tmp_path_helper.size()-1].finalPoint());

tmp_path_helper[tmp_path_helper.size()-1].append(tmp_append);

tmp_path_helper[tmp_path_helper.size()-1] = tmp_path_helper[tmp_path_helper.size()-1].reverse();

} else if(i != 0 && tmp_path_helper.size() > 0 && Geom::are_near(tmp_path_helper[tmp_path_helper.size()-1].finalPoint(),append_path.initialPoint())) {

Geom::Path tmp_append = append_path;

tmp_append.setInitial(tmp_path_helper[tmp_path_helper.size()-1].finalPoint());

tmp_path_helper[tmp_path_helper.size()-1].append(tmp_append);

} else if(i != 0 && tmp_path_helper.size() > 0 && Geom::are_near(tmp_path_helper[tmp_path_helper.size()-1].initialPoint(),append_path.finalPoint())) {

Geom::Path tmp_append = append_path.reverse();

tmp_path_helper[tmp_path_helper.size()-1] = tmp_path_helper[tmp_path_helper.size()-1].reverse();

tmp_append.setInitial(tmp_path_helper[tmp_path_helper.size()-1].finalPoint());

tmp_path_helper[tmp_path_helper.size()-1].append(tmp_append);

tmp_path_helper[tmp_path_helper.size()-1] = tmp_path_helper[tmp_path_helper.size()-1].reverse();

} else if(i != 0 && tmp_path_helper.size() > 0 && Geom::are_near(tmp_path_helper[0].finalPoint(),append_path.finalPoint())) {

Geom::Path tmp_append = append_path.reverse();

tmp_append.setInitial(tmp_path_helper[0].finalPoint());

tmp_path_helper[0].append(tmp_append);

} else if(i != 0 && tmp_path_helper.size() > 0 && Geom::are_near(tmp_path_helper[0].initialPoint(),append_path.initialPoint())) {

Geom::Path tmp_append = append_path;

tmp_path_helper[0] = tmp_path_helper[0].reverse();

tmp_append.setInitial(tmp_path_helper[0].finalPoint());

tmp_path_helper[0].append(tmp_append);

tmp_path_helper[0] = tmp_path_helper[0].reverse();

} else {

if(rotation_angle * num_copies != 360){

split_extreme(path_on_start,divider_start);

for (Geom::PathVector::const_iterator path_it_start = path_on_start.begin(); path_it_start != path_on_start.end(); ++path_it_start) {

Geom::Path original_start = *path_it_start;

if (path_it->empty()) {

continue;

}

if(Geom::are_near(append_path.initialPoint(),original_start.initialPoint())) {

original_start.reverse();

}

original_start.append(append_path);

append_path = original_start;

}

}

tmp_path_helper.push_back(append_path);

}

if(tmp_path_helper.size() > 0 && Geom::are_near(tmp_path_helper[tmp_path_helper.size()-1].finalPoint(),tmp_path_helper[tmp_path_helper.size()-1].initialPoint())) {

tmp_path_helper[tmp_path_helper.size()-1].close();

}

}

if(tmp_path_helper.size() > 0 && Geom::are_near(tmp_path_helper[0].finalPoint(),tmp_path_helper[0].initialPoint())) {

tmp_path_helper[0].close();

}

tmp_path.insert(tmp_path.end(), tmp_path_helper.begin(), tmp_path_helper.end());

tmp_path_helper.clear();

}

path_on = tmp_path;

tmp_path.clear();

}

Geom::Piecewise<Geom::D2<Geom::SBasis> >

LPECopyRotate::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)

{

using namespace Geom;

if(num_copies == 1) {

return pwd2_in;

}

double diagonal = Geom::distance(Geom::Point(boundingbox_X.min(),boundingbox_Y.min()),Geom::Point(boundingbox_X.max(),boundingbox_Y.max()));

Geom::Rect bbox(Geom::Point(boundingbox_X.min(),boundingbox_Y.min()),Geom::Point(boundingbox_X.max(),boundingbox_Y.max()));

double size_divider = Geom::distance(origin,bbox) + (diagonal * 2);

Geom::Point line_start = origin + dir * Rotate(-deg_to_rad(starting_angle)) * size_divider;

Geom::Point line_end = origin + dir * Rotate(-deg_to_rad(rotation_angle+starting_angle)) * size_divider;

//Note:: beter way to do this

//Whith AppendNew have problems whith the crossing order

Geom::Path divider = Geom::Path(line_start);

divider.appendNew<Geom::LineSegment>((Geom::Point)origin);

divider.appendNew<Geom::LineSegment>(line_end);

Geom::Point line_oposite = origin + dir * Rotate(-deg_to_rad((rotation_angle/2)+starting_angle)) * size_divider;

Geom::Path divider_start = Geom::Path(line_start);

divider_start.appendNew<Geom::LineSegment>((Geom::Point)origin);

divider_start.appendNew<Geom::LineSegment>(line_oposite);

Geom::Path divider_end = Geom::Path(line_end);

divider_end.appendNew<Geom::LineSegment>((Geom::Point)origin);

divider_end.appendNew<Geom::LineSegment>(line_oposite);

Piecewise<D2<SBasis> > output;

Affine pre = Translate(-origin) * Rotate(-deg_to_rad(starting_angle));

if(kaleidoscope) {

std::vector<Geom::Path> path_out;

std::vector<Geom::Path> tmp_path;

PathVector const original_pathv = path_from_piecewise(remove_short_cuts(pwd2_in, 0.1), 0.001);

for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {

if (path_it->empty()) {

continue;

}

bool end_open = false;

if (path_it->closed()) {

const Geom::Curve &closingline = path_it->back_closed();

if (!are_near(closingline.initialPoint(), closingline.finalPoint())) {

end_open = true;

}

}

Geom::Path original = (Geom::Path)(*path_it);

if(end_open && path_it->closed()) {

original.close(false);

original.appendNew<Geom::LineSegment>( original.initialPoint() );

original.close(true);

}

tmp_path.push_back(original);

setKaleidoscope(tmp_path,divider, divider_start, divider_end, size_divider);

path_out.insert(path_out.end(), tmp_path.begin(), tmp_path.end());

tmp_path.clear();

}

if(path_out.size()>0) {

output = paths_to_pw(path_out);

}

} else {

for (int i = 0; i < num_copies; ++i) {

Rotate rot(-deg_to_rad(rotation_angle * i));

Affine t = pre * rot * Translate(origin);

output.concat(pwd2_in * t);

}

}

return output;

}

LPECopyRotate::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)

{

using namespace Geom;

hp_vec.clear();

Geom::Path hp;

hp.start(start_pos);

hp.appendNew<Geom::LineSegment>((Geom::Point)origin);

hp.appendNew<Geom::LineSegment>(origin + dir * Rotate(-deg_to_rad(rotation_angle+starting_angle)) * dist_angle_handle);

Geom::PathVector pathv;

pathv.push_back(hp);

hp_vec.push_back(pathv);

}

LPECopyRotate::resetDefaults(SPItem const* item)

{

Effect::resetDefaults(item);

original_bbox(SP_LPE_ITEM(item));

}

LPECopyRotate::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)

{

{

KnotHolderEntity *e = new CR::KnotHolderEntityStartingAngle(this);

e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,

_("Adjust the starting angle"));

knotholder->add(e);

}

{

KnotHolderEntity *e = new CR::KnotHolderEntityRotationAngle(this);

e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,

_("Adjust the rotation angle"));

knotholder->add(e);

}

};

namespace CR {

using namespace Geom;

KnotHolderEntityStartingAngle::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)

{

LPECopyRotate* lpe = dynamic_cast<LPECopyRotate *>(_effect);

Geom::Point const s = snap_knot_position(p, state);

// I first suspected the minus sign to be a bug in 2geom but it is

// likely due to SVG's choice of coordinate system orientation (max)

lpe->starting_angle.param_set_value(rad_to_deg(-angle_between(lpe->dir, s - lpe->origin)));

if (state & GDK_SHIFT_MASK) {

lpe->dist_angle_handle = L2(lpe->B - lpe->A);

} else {

lpe->dist_angle_handle = L2(p - lpe->origin);

}

// FIXME: this should not directly ask for updating the item. It should write to SVG, which triggers updating.

sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);

}

KnotHolderEntityRotationAngle::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)

{

LPECopyRotate* lpe = dynamic_cast<LPECopyRotate *>(_effect);

Geom::Point const s = snap_knot_position(p, state);

// I first suspected the minus sign to be a bug in 2geom but it is

// likely due to SVG's choice of coordinate system orientation (max)

lpe->rotation_angle.param_set_value(rad_to_deg(-angle_between(lpe->dir, s - lpe->origin)) - lpe->starting_angle);

if (state & GDK_SHIFT_MASK) {

lpe->dist_angle_handle = L2(lpe->B - lpe->A);

} else {

lpe->dist_angle_handle = L2(p - lpe->origin);

}

// FIXME: this should not directly ask for updating the item. It should write to SVG, which triggers updating.

sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);

}

Geom::Point

KnotHolderEntityStartingAngle::knot_get() const

{

LPECopyRotate const *lpe = dynamic_cast<LPECopyRotate const*>(_effect);

return lpe->start_pos;

}

Geom::Point

KnotHolderEntityRotationAngle::knot_get() const

{

LPECopyRotate const *lpe = dynamic_cast<LPECopyRotate const*>(_effect);

return lpe->rot_pos;

}

} // namespace CR

} //namespace LivePathEffect

} /* namespace Inkscape */