Ticket #180: sharp_spike_fix.patch

include/mapnik/ctrans.hpp

@@ -30 +30 @@
 #include <mapnik/envelope.hpp>
 #include <mapnik/coord_array.hpp>
 #include <mapnik/proj_transform.hpp>
+#include <mapnik/vertex.hpp>
 
+#include <mapnik/vertex.hpp> 
+#ifndef M_PI 
+#define M_PI 3.14159265358979323846 
+#endif 
+
+#ifdef MAPNIK_DEBUG 
+#include <iostream> 
+#endif 
+
 namespace mapnik {
    typedef coord_array<coord2d> CoordinateArray;
     
@@ -123 +133 @@
       int dy_;
    };
    
+   template <typename Transform,typename Geometry> struct MAPNIK_DECL coord_transform4 {
+    
+    /**
+     * Creates a new coord_transform4.
+     */
+    coord_transform4(Transform const& t,  Geometry const& geom,  proj_transform const& prj_trans ) 
+        : t_(t),  
+                geom_(geom),  
+                prj_trans_(prj_trans), 
+                offset_(0.0), 
+                m_status(initial) {} 
+        
+    // Enum representing the status or the tranformation process.
+    enum status 
+    {  
+        initial,  
+        start, 
+        first,  
+        process, 
+        last_vertex, 
+        angle_joint, 
+        end  
+    }; 
+ 
+    double get_offset() const 
+    { 
+        return offset_; 
+    } 
+     
+    void set_offset(double offset) 
+    { 
+        offset_ = offset; 
+    } 
+ 
+    bool is_acute(double x0,double y0,double x1,double y1,double x2,double y2) 
+    { 
+        double dx0 = x0 - x1; 
+        double dy0 = y0 - y1; 
+        double dx1 = x2 - x1; 
+        double dy1 = y2 - y1; 
+        double product = dx0 * dx1 + dy0 * dy1; 
+        return product > 0; 
+    } 
+ 
+        /**
+         * Reads the x and y values of the next vertex and assigns the 
+         * values of the locations of the x and y parameters to them.  
+         * Returns the next command associated with the vertex based
+         * from where in the line the point is read.
+         */
+        /*
+         * Basically copied out of mapservers line offset algorithm
+         * (msOffsetPolyline).
+         */
+    unsigned vertex(double * x , double  * y) 
+    {
+        double z=0; 
+        
+        if (offset_==0.0) 
+        { 
+            unsigned command = geom_.vertex(x,y); 
+            prj_trans_.backward(*x,*y,z); 
+            t_.forward(x,y); 
+            return command; 
+        } 
+        else 
+        { 
+            while(true){
+                switch(m_status) 
+                { 
+                    case end: 
+                        return SEG_END; 
+                        break; 
+                    case initial: 
+                        m_pre_cmd = geom_.vertex(x,y);
+                        prj_trans_.backward(*x,*y,z); 
+                        t_.forward(x,y); 
+                        m_pre_x = *x; 
+                        m_pre_y = *y;
+                    case start: 
+                        m_cur_cmd = geom_.vertex(&m_cur_x, &m_cur_y);
+                        prj_trans_.backward(m_cur_x,m_cur_y,z);
+                        t_.forward(&m_cur_x,&m_cur_y);
+                    case first:
+                        angle_a = atan2((m_pre_y-m_cur_y),(m_pre_x-m_cur_x));
+                        dx_pre = cos(angle_a + M_PI/2);
+                        dy_pre = sin(angle_a + M_PI/2);
+                        #ifdef MAPNIK_DEBUG
+                            std::clog << "offsetting line by: " << offset_ << "\n"; 
+                            std::clog << "initial dx=" << (dx_pre * offset_) << " dy=" << (dy_pre * offset_) << "\n"; 
+                        #endif
+                        *x = m_pre_x + (dx_pre * offset_);
+                        *y = m_pre_y + (dy_pre * offset_);
+                        m_status = process;
+                        return SEG_MOVETO;
+                    case process: 
+                        switch(m_cur_cmd) 
+                        { 
+                            case SEG_LINETO: 
+                                m_next_cmd = geom_.vertex(&m_next_x, &m_next_y); 
+                                prj_trans_.backward(m_next_x,m_next_y,z); 
+                                t_.forward(&m_next_x,&m_next_y); 
+                                switch(m_next_cmd) 
+                                { 
+                                    case SEG_LINETO: 
+                                        m_status = angle_joint; 
+                                        break; 
+                                    default: 
+                                        m_status = last_vertex; 
+                                        break; 
+                                }
+                                break; 
+                            case SEG_END: 
+                                m_status = end; 
+                                return SEG_END; 
+                        } 
+                        break; 
+                    case last_vertex: 
+                        dx_curr = cos(angle_a + M_PI/2); 
+                        dy_curr = sin(angle_a + M_PI/2); 
+                        *x = m_cur_x + (dx_curr * offset_); 
+                        *y = m_cur_y + (dy_curr * offset_); 
+                        m_status = end; 
+                        return m_cur_cmd; 
+                    case angle_joint:
+                        dx_curr = cos(angle_a + M_PI/2); 
+                        dy_curr = sin(angle_a + M_PI/2);
+                        
+                        sin_curve = dx_curr*dy_pre-dy_curr*dx_pre;
+                        cos_curve = -dx_pre*dx_curr-dy_pre*dy_curr;
+                        
+                        #ifdef MAPNIK_DEBUG
+                            std::clog << "sin_curve value: " << sin_curve << "\n";
+                        #endif
+                        if(-0.3 < sin_curve && sin_curve < 0.3) {
+                                                        angle_b = atan2((m_cur_y-m_next_y),(m_cur_x-m_next_x)); 
+                                                        h = tan((angle_b - angle_a)/2.0); 
+                                                        *x = m_cur_x + dx_curr * offset_ - h * dy_curr * offset_; 
+                                                        *y = m_cur_y + dy_curr * offset_ + h * dx_curr * offset_; 
+                                                } else {
+                                                        base_shift = -1.0*(1.0+cos_curve)/sin_curve;
+                                                        *x = m_cur_x + (dx_curr + base_shift*dy_curr)*offset_;
+                                                        *y = m_cur_y + (dy_curr - base_shift*dx_curr)*offset_;
+                                                }
+                        
+                        // Save old shit
+                        m_cur_x = m_next_x; 
+                        m_cur_y = m_next_y; 
+                        angle_a = angle_b; 
+                        m_pre_cmd = m_cur_cmd; 
+                        m_cur_cmd = m_next_cmd; 
+                        m_status = process; 
+                        return m_pre_cmd; 
+             } 
+          } 
+       } 
+    } 
+ 
+    void rewind (unsigned pos) 
+    { 
+        geom_.rewind(pos); 
+        m_status = initial; 
+    }
+    
+    private: 
+        Transform const& t_; 
+        Geometry const& geom_; 
+        proj_transform const& prj_trans_; 
+        int offset_; 
+        double dx_pre; 
+        double dy_pre;
+        double dx_curr; 
+        double dy_curr;
+        double base_shift;
+        double sin_curve;
+        double cos_curve;
+        double angle_a; 
+        double angle_b; 
+        double h; 
+        // processing state 
+        status       m_status; 
+        // source vertex lookahead queue 
+        unsigned       m_pre_cmd; 
+        double         m_pre_x; 
+        double         m_pre_y; 
+        unsigned       m_cur_cmd; 
+        double         m_cur_x; 
+        double         m_cur_y; 
+        unsigned       m_next_cmd; 
+        double         m_next_x; 
+        double         m_next_y;
+        
+        
+ 
+    }; 
+   
    class CoordTransform
    {
       private:
@@ -133 +339 @@
          Envelope<double> extent_;
          double offset_x_;
          double offset_y_;
+         
       public:
          CoordTransform(int width,int height,const Envelope<double>& extent,
                         double offset_x = 0, double offset_y = 0)
-            :width_(width),height_(height),extent_(extent),offset_x_(offset_x),offset_y_(offset_y)
+            : width_(width),
+            height_(height),
+            extent_(extent),
+            offset_x_(offset_x),
+            offset_y_(offset_y)
+            
          {
             sx_ = ((double)width_)/extent_.width();
             sy_ = ((double)height_)/extent_.height();