C++ Polygon2d::size方法代码示例

        // http://astronomy.swin.edu.au/~pbourke/geometry/polyarea/
        vec2 barycenter(const Polygon2d& P) {
            gx_assert(P.size() > 0) ;

            double A = signed_area(P) ;

            if(::fabs(A) < 1e-30) {
                return P[0] ;
            }

            double x = 0.0 ;
            double y = 0.0 ;
            for(unsigned int i=0; i<P.size(); i++) {
                unsigned int j = (i+1) % P.size() ;
                const vec2& t1 = P[i] ;
                const vec2& t2 = P[j] ;
                double d = (t1.x * t2.y - t2.x * t1.y) ;
                x += (t1.x + t2.x) * d ;
                y += (t1.y + t2.y) * d ;
            }
        
            return vec2(
                x / (6.0 * A),
                y / (6.0 * A)
            ) ;
        }

        void clip_polygon_by_half_plane(
            const Polygon2d& P, 
            const vec2& q1,
            const vec2& q2,
            Polygon2d& result,
            bool invert
        ) {
            result.clear() ;

            if(P.size() == 0) {
                return ;
            }

            if(P.size() == 1) {
                if(point_is_in_half_plane(P[0], q1, q2, invert)) {
                    result.push_back(P[0]) ;
                }
                return ;
            }

            vec2 prev_p = P[P.size() - 1] ;
            Sign prev_status = point_is_in_half_plane(
                prev_p, q1, q2, invert
            ) ;

            for(unsigned int i=0; i<P.size(); i++) {
                vec2 p = P[i] ;
                Sign status = point_is_in_half_plane(
                    p, q1, q2, invert
                ) ;
                if(
                    status != prev_status &&
                    status != ZERO &&
                    prev_status != ZERO
                ) {
                    vec2 intersect ;
                    if(intersect_segments(prev_p, p, q1, q2, intersect)) {
                        result.push_back(intersect) ;
                    } else {
                    }
                }

                switch(status) {
                case NEGATIVE:
                    break ;
                case ZERO:
                    result.push_back(p) ;
                    break ;
                case POSITIVE:
                    result.push_back(p) ;
                    break ;
                }

                prev_p = p ;
                prev_status = status ;
            }
        }

        void convex_clip_segment(
            Segment2d& S, const Polygon2d& window
        ) {
	    gx_parano_assert(polygon_is_convex(window)) ;
            bool invert = (signed_area(window) < 0) ;
            for(unsigned int i=0; i<window.size(); i++) {
                unsigned int j = ((i+1) % window.size()) ;
                clip_segment_by_half_plane(S, window[i], window[j], invert) ;
            }
        }

 // http://astronomy.swin.edu.au/~pbourke/geometry/polyarea/
 double signed_area(const Polygon2d& P) {
     double result = 0 ;
     for(unsigned int i=0; i<P.size(); i++) {
         unsigned int j = (i+1) % P.size() ;
         const vec2& t1 = P[i] ;
         const vec2& t2 = P[j] ;
         result += t1.x * t2.y - t2.x * t1.y ;
     }
     result /= 2.0 ;
     return result ;
 }

 void save_polygon(const Polygon2d& P, const std::string& file_name) {
     std::ofstream out(file_name.c_str()) ;
     {for(unsigned int i=0; i<P.size(); i++) {
         out << "v " << P[i].x << " " << P[i].y << std::endl ;
         out << "vt " << P[i].x << " " << P[i].y << std::endl ;
     }}
     out << "f " ;
     {for(unsigned int i=0; i<P.size(); i++) {
         out << i+1 << "/" << i+1 << " " ;
     }}
     out << std::endl ;
 }

 vec2 vertices_barycenter(const Polygon2d& P) {
     gx_assert(P.size() != 0) ;
     double x = 0 ;
     double y = 0 ;
     for(unsigned int i=0; i<P.size(); i++) {
         x += P[i].x ;
         y += P[i].y ;
     }
     x /= double(P.size()) ;
     y /= double(P.size()) ;
     return vec2(x,y) ;
 }

 bool polygon_is_convex(const Polygon2d& P) {
     Sign s = ZERO ;
     for(unsigned int i=0; i<P.size(); i++) {
         unsigned int j = ((i+1) % P.size()) ;
         unsigned int k = ((j+1) % P.size()) ;
         Sign cur_s = orient(P[i],P[j],P[k]) ;
         if(s != ZERO && cur_s != ZERO && cur_s != s) {
             return false ;
         }
         if(cur_s != ZERO) {
             s = cur_s ;
         }
     }
     return true ;
 }

 // Clipping with convex window using Sutherland-Hogdman reentrant clipping
 void convex_clip_polygon(
     const Polygon2d& P, const Polygon2d& clip, Polygon2d& result
 ) {
     gx_parano_assert(polygon_is_convex(clip)) ;
     Polygon2d tmp1 = P ;
     bool invert = (signed_area(tmp1) != signed_area(clip)) ;
     Polygon2d tmp2 ;
     Polygon2d* src = &tmp1 ;
     Polygon2d* dst = &tmp2 ;
     for(unsigned int i=0; i<clip.size(); i++) {
         unsigned int j = ((i+1) % clip.size()) ;
         const vec2& p1 = clip[i] ;
         const vec2& p2 = clip[j] ;
         clip_polygon_by_half_plane(*src, p1, p2, *dst, invert) ;
         gx_swap(src, dst) ;
     }
     result = *src ;
 }

        bool point_is_in_kernel(const Polygon2d& P, const vec2& p) {
            Sign sign = ZERO ;
            for(unsigned int i=0 ; i<P.size() ; i++) {
                unsigned int j = (i+1) % P.size() ;
                const vec2& p1 = P[i] ;
                const vec2& p2 = P[j] ;

                Sign cur_sign = orient(p, p1, p2) ;
                if(sign == ZERO) {
                    sign = cur_sign ;
                } else {
                    if(cur_sign != ZERO && cur_sign != sign) {
                        return false ;
                    }
                }
            }
            return true ;
        }

        void minimum_area_enclosing_rectangle(
            const Polygon2d& PP, 
            vec2& S, vec2& T
        ) {

            // Note: this implementation has O(n2) complexity :-(
            // (where n is the number of vertices in the convex hull)
            // If this appears to be a bottleneck, use a smarter
            // implementation with better complexity.

            Polygon2d P ;
            convex_hull(PP, P) ;

            int N = P.size() ;
            
            // Add the first vertex at the end of P
            P.push_back(P[0]) ;

            double min_area = Numeric::big_double ;

            for(int i=1; i<=N; i++) {
                vec2 Si = P[i] - P[i-1] ;

                if( ( Si.length2() ) < 1e-20) {
                    continue ;
                }

                vec2 Ti(-Si.y, Si.x) ;
                normalize(Si) ;
                normalize(Ti) ;
                double s0 =  Numeric::big_double ;
                double s1 = -Numeric::big_double ;
                double t0 =  Numeric::big_double ;
                double t1 = -Numeric::big_double ; 
                for(int j=1; j<N; j++) {
                    vec2 D = P[j] - P[0] ;
                    double s = dot(Si, D) ;
                    s0 = gx_min(s0, s) ;
                    s1 = gx_max(s1, s) ;
                    double t = dot(Ti, D) ;
                    t0 = gx_min(t0, t) ;
                    t1 = gx_max(t1, t) ;
                }
                double area = (s1 - s0) * (t1 - t0) ;
                if(area < min_area) {
                    min_area = area ;
                    if((s1 - s0) < (t1 - t0)) {
                        S = Si ;
                        T = Ti ;
                    } else {
                        S = Ti ;
                        T = Si ;
                    }
                }
            }
        }

        // Compute the kernel using Sutherland-Hogdman reentrant clipping
        // The kernel is obtained by clipping the polygon with each 
        // half-plane yielded by its sides.
        void kernel(const Polygon2d& P, Polygon2d& result) {

            Array1d<Sign> sign(P.size()) ;
            for(unsigned int i=0; i<P.size(); i++) {
                unsigned int j = ((i+1) % P.size()) ;
                unsigned int k = ((j+1) % P.size()) ;
                sign(j) = orient(P[i],P[j],P[k]) ;
            }

            bool invert = (signed_area(P) < 0) ;

            Polygon2d tmp1 = P ;
            Polygon2d tmp2 ;
            Polygon2d* src = &tmp1 ;
            Polygon2d* dst = &tmp2 ;
            for(unsigned int i=0; i<P.size(); i++) {
                unsigned int j = ((i+1) % P.size()) ;
                const vec2& p1 = P[i] ;
                const vec2& p2 = P[j] ;

                if((p2-p1).length() == 0) {
                    std::cerr << "null edge in poly" << std::endl ;
                    continue ;
                }

                // Optimization: do not clip by convex-convex edges
                // (Thanks to Rodrigo Toledo for the tip !)

                if(!invert && sign(i) != NEGATIVE && sign(j) != NEGATIVE) {
                    continue ;
                }

                if(invert && sign(i) != POSITIVE && sign(j) != POSITIVE) {
                    continue ;
                }

                clip_polygon_by_half_plane(*src, p1, p2, *dst, invert) ;
                gx_swap(src, dst) ;

            }
            result = *src ;
        }

 void convex_hull(const Polygon2d& PP, Polygon2d& result) {
     result.clear() ;
     int n = PP.size() ;
     vec2* P = new vec2[n+1] ;
     { for(int i=0; i<n; i++) {
         P[i] = PP[i] ;
     }}
     int u = make_chain(P, n, cmpl);  
     P[n] = P[0];
     int ch = u+make_chain(P+u, n-u+1, cmph);  
     {for(int i=0; i<ch; i++) {
         result.push_back(P[i]) ;
     }}
     delete[] P ;
 }