// there is no elegance here. only sleep deprivation and regret.

Basically, clipping Béziers now actually works, because De Casteljau is
no longer totally back to front. (In fact, I think I just made it more back to front,
which cancelled the original out?)

Also disabled zoom out in the quadtree and some dodgy disabled debug in the bezier shader.

diff --git a/src/bezier.cpp b/src/bezier.cpp
index 9d24672..99611dc 100644 (file)
--- a/src/bezier.cpp
+++ b/src/bezier.cpp
@@ -97,23 +97,6 @@ vector<Real> SolveCubic(const Real & a, const Real & b, const Real & c, const Re
        tu = max;
        CubicSolveSegment(roots, a, b, c, d, tl, tu,delta);
        return roots;
-       /*
-               Real maxi(100);
-               Real prevRes(d);
-               for(int i = 0; i <= 100; ++i)
-               {
-                       Real x(i);
-                       x /= maxi;
-                       Real y = a*(x*x*x) + b*(x*x) + c*x + d;
-                       if (((y < Real(0)) && (prevRes > Real(0))) || ((y > Real(0)) && (prevRes < Real(0))))
-                       {
-                               //Debug("Found root of %fx^3 + %fx^2 + %fx + %f at %f (%f)", a, b, c, d, x, y);
-                               roots.push_back(x);
-                       }
-                       prevRes = y;
-               }
-               return roots;
-       */
 }
 
 /**

diff --git a/src/bezier.h b/src/bezier.h
index 5a773a7..52a5264 100644 (file)
--- a/src/bezier.h
+++ b/src/bezier.h
@@ -15,7 +15,7 @@ namespace IPDF
        
        extern std::vector<Real> SolveQuadratic(const Real & a, const Real & b, const Real & c, const Real & min = 0, const Real & max = 1);
 
-       extern std::vector<Real> SolveCubic(const Real & a, const Real & b, const Real & c, const Real & d, const Real & min = 0, const Real & max = 1, const Real & delta = 1e-4);
+       extern std::vector<Real> SolveCubic(const Real & a, const Real & b, const Real & c, const Real & d, const Real & min = 0, const Real & max = 1, const Real & delta = 1e-9);
 
        /** A _cubic_ bezier. **/
        struct Bezier
@@ -179,56 +179,56 @@ namespace IPDF
                }
 
                // Performs one round of De Casteljau subdivision and returns the [t,1] part.
-               Bezier DeCasteljauSubdivideRight(const Real& t)
+               Bezier DeCasteljauSubdivideLeft(const Real& t)
                {
                        Real one_minus_t = Real(1) - t;
 
                        // X Coordinates
-                       Real x01 = x0*t + x1*one_minus_t;
-                       Real x12 = x1*t + x2*one_minus_t;
-                       Real x23 = x2*t + x3*one_minus_t;
+                       Real x01 = x1*t + x0*one_minus_t;
+                       Real x12 = x2*t + x1*one_minus_t;
+                       Real x23 = x3*t + x2*one_minus_t;
 
-                       Real x012 = x01*t + x12*one_minus_t;
-                       Real x123 = x12*t + x23*one_minus_t;
+                       Real x012 = x12*t + x01*one_minus_t;
+                       Real x123 = x23*t + x12*one_minus_t;
 
-                       Real x0123 = x012*t + x123*one_minus_t;
+                       Real x0123 = x123*t + x012*one_minus_t;
 
                        // Y Coordinates
-                       Real y01 = y0*t + y1*one_minus_t;
-                       Real y12 = y1*t + y2*one_minus_t;
-                       Real y23 = y2*t + y3*one_minus_t;
+                       Real y01 = y1*t + y0*one_minus_t;
+                       Real y12 = y2*t + y1*one_minus_t;
+                       Real y23 = y3*t + y2*one_minus_t;
 
-                       Real y012 = y01*t + y12*one_minus_t;
-                       Real y123 = y12*t + y23*one_minus_t;
+                       Real y012 = y12*t + y01*one_minus_t;
+                       Real y123 = y23*t + y12*one_minus_t;
 
-                       Real y0123 = y012*t + y123*one_minus_t;
+                       Real y0123 = y123*t + y012*one_minus_t;
 
                        return Bezier(x0, y0, x01, y01, x012, y012, x0123, y0123);
                }
-               // Performs one round of De Casteljau subdivision and returns the [0,t] part.
-               Bezier DeCasteljauSubdivideLeft(const Real& t)
+               // Performs one round of De Casteljau subdivision and returns the [t,1] part.
+               Bezier DeCasteljauSubdivideRight(const Real& t)
                {
                        Real one_minus_t = Real(1) - t;
 
                        // X Coordinates
-                       Real x01 = x0*t + x1*one_minus_t;
-                       Real x12 = x1*t + x2*one_minus_t;
-                       Real x23 = x2*t + x3*one_minus_t;
+                       Real x01 = x1*t + x0*one_minus_t;
+                       Real x12 = x2*t + x1*one_minus_t;
+                       Real x23 = x3*t + x2*one_minus_t;
 
-                       Real x012 = x01*t + x12*one_minus_t;
-                       Real x123 = x12*t + x23*one_minus_t;
+                       Real x012 = x12*t + x01*one_minus_t;
+                       Real x123 = x23*t + x12*one_minus_t;
 
-                       Real x0123 = x012*t + x123*one_minus_t;
+                       Real x0123 = x123*t + x012*one_minus_t;
 
                        // Y Coordinates
-                       Real y01 = y0*t + y1*one_minus_t;
-                       Real y12 = y1*t + y2*one_minus_t;
-                       Real y23 = y2*t + y3*one_minus_t;
+                       Real y01 = y1*t + y0*one_minus_t;
+                       Real y12 = y2*t + y1*one_minus_t;
+                       Real y23 = y3*t + y2*one_minus_t;
 
-                       Real y012 = y01*t + y12*one_minus_t;
-                       Real y123 = y12*t + y23*one_minus_t;
+                       Real y012 = y12*t + y01*one_minus_t;
+                       Real y123 = y23*t + y12*one_minus_t;
 
-                       Real y0123 = y012*t + y123*one_minus_t;
+                       Real y0123 = y123*t + y012*one_minus_t;
 
                        return Bezier(x0123, y0123, x123, y123, x23, y23, x3, y3);
                }
@@ -253,35 +253,19 @@ namespace IPDF
                        // Find points of intersection with the rectangle.
                        Debug("Clipping Bezier to Rect %s", r.Str().c_str());
 
-                       // Convert bezier coefficients -> cubic coefficients
-                       Real xd = x0 - r.x;
-                       Real xc = Real(3)*(x1 - x0);
-                       Real xb = Real(3)*(x2 - x1) - xc;
-                       Real xa = x3 - x0 - xc - xb;
 
                        // Find its roots.
-                       std::vector<Real> x_intersection = SolveCubic(xa, xb, xc, xd);
+                       std::vector<Real> x_intersection = SolveXParam(r.x);
 
                        // And for the other side.
-                       xd = x0 - r.x - r.w;
 
-                       std::vector<Real> x_intersection_pt2 = SolveCubic(xa, xb, xc, xd);
+                       std::vector<Real> x_intersection_pt2 = SolveXParam(r.x + r.w);
                        x_intersection.insert(x_intersection.end(), x_intersection_pt2.begin(), x_intersection_pt2.end());
 
-                       // Similarly for y-coordinates.
-                       // Convert bezier coefficients -> cubic coefficients
-                       Real yd = y0 - r.y;
-                       Real yc = Real(3)*(y1 - y0);
-                       Real yb = Real(3)*(y2 - y1) - yc;
-                       Real ya = y3 - y0 - yc - yb;
-
                        // Find its roots.
-                       std::vector<Real> y_intersection = SolveCubic(ya, yb, yc, yd);
+                       std::vector<Real> y_intersection = SolveYParam(r.y);
 
-                       // And for the other side.
-                       yd = y0 - r.y - r.h;
-
-                       std::vector<Real> y_intersection_pt2 = SolveCubic(ya, yb, yc, yd);
+                       std::vector<Real> y_intersection_pt2 = SolveYParam(r.y+r.h);
                        y_intersection.insert(y_intersection.end(), y_intersection_pt2.begin(), y_intersection_pt2.end());
 
                        // Merge and sort.
@@ -291,6 +275,12 @@ namespace IPDF
                        std::sort(x_intersection.begin(), x_intersection.end());
 
                        Debug("Found %d intersections.\n", x_intersection.size());
+                       for(auto t : x_intersection)
+                       {
+                               Real ptx, pty;
+                               Evaluate(ptx, pty, t);
+                               Debug("Root: t = %f, (%f,%f)", t, ptx, pty);
+                       }
                        
                        std::vector<Bezier> all_beziers;
                        if (x_intersection.size() <= 2)
@@ -306,7 +296,7 @@ namespace IPDF
                                Debug(" -- t0: %f to t1: %f", t0, t1);
                                Real ptx, pty;
                                Evaluate(ptx, pty, ((t1 + t0) / Real(2)));
-                               if (true || r.PointIn(ptx, pty))
+                               if (r.PointIn(ptx, pty))
                                {
                                        all_beziers.push_back(this->ReParametrise(t0, t1));
                                }

diff --git a/src/rect.h b/src/rect.h
index 1373c6f..46aa5fb 100644 (file)
--- a/src/rect.h
+++ b/src/rect.h
@@ -15,7 +15,7 @@ namespace IPDF
                {
                        std::stringstream s;
                        // float conversion needed because it is fucking impossible to get ostreams working with template classes
-                       s << "{" << Float(x) << ", " << Float(y) << ", " << Float(w) << ", " << Float(h) << "}";
+                       s << "{" << Float(x) << ", " << Float(y) << ", " << Float(x + w) << ", " << Float(y + h) << " (w: " << Float(w) <<", h: " << Float(h) <<")}";
                        return s.str();
                }
                inline bool PointIn(Real pt_x, Real pt_y) const

diff --git a/src/shaders/bezier_texbuf_geom.glsl b/src/shaders/bezier_texbuf_geom.glsl
index 281627d..13812ef 100644 (file)
--- a/src/shaders/bezier_texbuf_geom.glsl
+++ b/src/shaders/bezier_texbuf_geom.glsl
@@ -4,7 +4,7 @@ uniform samplerBuffer bezier_buffer_texture;
 uniform isamplerBuffer bezier_id_buffer_texture; 
 
 layout(lines) in;
-layout(line_strip, max_vertices = 101) out;
+layout(line_strip, max_vertices = 105) out;
 
 in int objectid[];
 in vec2 pixsize[];
@@ -40,5 +40,14 @@ void main()
                
        }
        EndPrimitive();
+/*     gl_Position = vec4(coeff0 * boundssize + gl_in[0].gl_Position.xy, 0.0, 1.0);
+       EmitVertex();
+       gl_Position = vec4(coeff1 * boundssize + gl_in[0].gl_Position.xy, 0.0, 1.0);
+       EmitVertex();
+       gl_Position = vec4(coeff2 * boundssize + gl_in[0].gl_Position.xy, 0.0, 1.0);
+       EmitVertex();
+       gl_Position = vec4(coeff3 * boundssize + gl_in[0].gl_Position.xy, 0.0, 1.0);
+       EmitVertex();
+       EndPrimitive();*/
 }
 

diff --git a/src/view.cpp b/src/view.cpp
index 94064ad..925fa47 100644 (file)
--- a/src/view.cpp
+++ b/src/view.cpp
@@ -173,7 +173,7 @@ void View::Render(int width, int height)
 #ifndef QUADTREE_DISABLED
        if (m_bounds_dirty)
        {
-               if (m_bounds.x > 1.0 || m_bounds.x < 0.0 || m_bounds.y > 1.0 || m_bounds.y < 0.0 || m_bounds.w > 1.0 || m_bounds.h > 1.0)
+               if (false && (m_bounds.x > 1.0 || m_bounds.x < 0.0 || m_bounds.y > 1.0 || m_bounds.y < 0.0 || m_bounds.w > 1.0 || m_bounds.h > 1.0))
                {
                        //TODO: Generate a new parent node.
                        if (m_document.GetQuadTree().nodes[m_current_quadtree_node].parent != QUADTREE_EMPTY)