inline void assign_box_corners_oriented(Box const& box, Range& corners)
{
    if (Reverse)
    {
        // make counterclockwise ll,lr,ur,ul
        assign_box_corners(box, corners[0], corners[1], corners[3], corners[2]);
    }
    else
    {
        // make clockwise ll,ul,ur,lr
        assign_box_corners(box, corners[0], corners[3], corners[1], corners[2]);
    }
}
Beispiel #2
0
    static inline void apply(Box const& box,
                             SegmentIdentifier const& seg_id, int to_index,
                             RangeOut& current_output)
    {
        // Convert again...
        // TODO: avoid that...

        typedef typename point_type<Box>::type point_type;

        point_type ll, lr, ul, ur;
        assign_box_corners(box, ll, lr, ul, ur);

        std::vector<point_type> points;
        points.push_back(ll);
        points.push_back(ul);
        points.push_back(ur);
        points.push_back(lr);
        points.push_back(ll);

        copy_segments_ring
        <
        std::vector<point_type>,
            SegmentIdentifier,
            RangeOut
            >
            ::apply(points, seg_id, to_index, current_output);
    }
inline void assign_box_corners_oriented(Box const& box, Range& corners)
{
    if (Reverse)
    {
        // make counterclockwise ll,lr,ur,ul
        assign_box_corners(box,
                           range::at(corners, 0), range::at(corners, 1),
                           range::at(corners, 3), range::at(corners, 2));
    }
    else
    {
        // make clockwise ll,ul,ur,lr
        assign_box_corners(box,
                           range::at(corners, 0), range::at(corners, 3),
                           range::at(corners, 1), range::at(corners, 2));
    }
}
Beispiel #4
0
    static inline void apply(Collection& collection, Box const& box)
    {
        typename point_type<Box>::type lower_left, lower_right,
                upper_left, upper_right;
        assign_box_corners(box, lower_left, lower_right,
                upper_left, upper_right);

        typedef typename boost::range_value<Collection>::type item;

        collection.push_back(item(get<0>(lower_left), get<1>(lower_left), 0, 1));
        collection.push_back(item(get<0>(upper_left), get<1>(upper_left), 1, 0));
        collection.push_back(item(get<0>(upper_right), get<1>(upper_right), 0, -1));
        collection.push_back(item(get<0>(lower_right), get<1>(lower_right), -1, 0));
    }
    static inline bool apply(Box const& box,
            SegmentIdentifier const& seg_id, bool second,
            PointOut& point)
    {
        int index = seg_id.segment_index;
        if (second)
        {
            index++;
        }

        PointOut ll, lr, ul, ur;
        assign_box_corners(box, ll, lr, ul, ur);
        switch(index)
        {
            case 1 : point = ul; break;
            case 2 : point = ur; break;
            case 3 : point = lr; break;
            default : // 0,4 or 'overflow'
                point = ll; break;
        }
        return true;
    }