opening kaleidscope

(bzr r13708.1.28)

2 files changed, 94 insertions, 5 deletions

diff --git a/src/live_effects/lpe-copy_rotate.cpp b/src/live_effects/lpe-copy_rotate.cpp
index 4fd605b6d..c119ca02e 100644
--- a/src/live_effects/lpe-copy_rotate.cpp
+++ b/src/live_effects/lpe-copy_rotate.cpp
@@ -110,10 +110,10 @@ LPECopyRotate::doBeforeEffect (SPLPEItem const* lpeitem)
 {
     using namespace Geom;
     original_bbox(lpeitem);
-    if(kaleidoscope || copies_to_360 ) {
+    if(copies_to_360 ) {
         rotation_angle.param_set_value(360.0/(double)num_copies);
     }
-    if(kaleidoscope) {
+    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);
@@ -216,8 +216,72 @@ LPECopyRotate::split(std::vector<Geom::Path> &path_on,Geom::Path divider)
 }
 
 void
-LPECopyRotate::setKaleidoscope(std::vector<Geom::Path> &path_on, Geom::Path divider, double size_divider)
+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.at(0));
+            start.appendNew<Geom::LineSegment>(divider_extreme.at(1));
+            if(!are_near(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.at(0));
+        start.appendNew<Geom::LineSegment>(divider_extreme.at(1));
+        if(!are_near(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;
+}
+
+void
+LPECopyRotate::setKaleidoscope(std::vector<Geom::Path> &path_on, Geom::Path divider, Geom::Path divider_extreme, 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);
@@ -282,6 +346,21 @@ LPECopyRotate::setKaleidoscope(std::vector<Geom::Path> &path_on, Geom::Path divi
                 tmp_path_helper[0].append(tmp_append);
                 tmp_path_helper[0] = tmp_path_helper[0].reverse();
             } else {
+                if(rotation_angle * num_copies != 360){
+                    split_start(path_on_start,divider_extreme);
+                    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;
+                        }
+                        std::vector<Geom::Path> tmp_path_helper;
+                        if(tmp_path_helper.size() > 0 && Geom::are_near(append_path.initialPoint(),path_it_start[0].initialPoint())) {
+                            path_it_start.reverse();
+                            path_it_start.append(append_path);
+                            append_path = path_it_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())) {
@@ -317,6 +396,14 @@ LPECopyRotate::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & p
     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) {
@@ -341,7 +428,7 @@ LPECopyRotate::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & p
                 original.close(true);
             }
             tmp_path.push_back(original);
-            setKaleidoscope(tmp_path,divider,size_divider);
+            setKaleidoscope(tmp_path,divider, divider_extreme, size_divider);
             path_out.insert(path_out.end(), tmp_path.begin(), tmp_path.end());
             tmp_path.clear();
         }
diff --git a/src/live_effects/lpe-copy_rotate.h b/src/live_effects/lpe-copy_rotate.h
index 83f4a6984..638f8a413 100644
--- a/src/live_effects/lpe-copy_rotate.h
+++ b/src/live_effects/lpe-copy_rotate.h
@@ -38,7 +38,7 @@ public:
 
     virtual void doBeforeEffect (SPLPEItem const* lpeitem);
 
-    virtual void setKaleidoscope(std::vector<Geom::Path> &path_in, Geom::Path divider, double sizeDivider);
+    virtual void setKaleidoscope(std::vector<Geom::Path> &path_in, Geom::Path divider, Geom::Path extreme, double sizeDivider);
 
     virtual bool pointInTriangle(Geom::Point p, Geom::Point p0, Geom::Point p1, Geom::Point p2);
 
@@ -46,6 +46,8 @@ public:
 
     virtual void split(std::vector<Geom::Path> &path_in,Geom::Path divider);
 
+    virtual void split_extreme(std::vector<Geom::Path> &path_on,Geom::Path divider_extreme);
+
     virtual void resetDefaults(SPItem const* item);
 
     virtual void transform_multiply(Geom::Affine const& postmul, bool set);