Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext
for_each_segment

Applies function f to each segment.

Description

Applies a function f (functor, having operator() defined) to each segment making up the geometry

Synopsis

template<typename Geometry, typename Functor>
Functor for_each_segment(Geometry & geometry, Functor f)

Parameters

Type

Concept

Name

Description

Geometry &

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

Functor

Function or class with operator()

f

Unary function, taking a segment as argument

Header

Either

#include <boost/geometry.hpp>

Or

#include <boost/geometry/algorithms/for_each.hpp>

Conformance

The function for_each_segment is not defined by OGC.

The function for_each_segment conforms to the std::for_each function of the C++ std-library.

Example

Sample using for_each_segment, using a functor to get the minimum and maximum length of a segment in a linestring

#include <iostream>

#include <boost/geometry.hpp>
#include <boost/geometry/geometries/linestring.hpp>
#include <boost/geometry/geometries/point_xy.hpp>

#include <boost/assign.hpp>


template <typename Segment>
struct gather_segment_statistics
{
    // Remember that if coordinates are integer, the length might be floating point
    // So use "double" for integers. In other cases, use coordinate type
    typedef typename boost::geometry::select_most_precise
        <
            typename boost::geometry::coordinate_type<Segment>::type,
            double
        >::type type;

    type min_length, max_length;

    // Initialize min and max
    gather_segment_statistics()
        : min_length(1e38)
        , max_length(-1)
    {}

    // This operator is called for each segment
    inline void operator()(Segment const& s)
    {
        type length = boost::geometry::length(s);
        if (length < min_length) min_length = length;
        if (length > max_length) max_length = length;
    }
};

int main()
{
    // Bring "+=" for a vector into scope
    using namespace boost::assign;

    // Define a type
    typedef boost::geometry::model::d2::point_xy<double> point;

    // Declare a linestring
    boost::geometry::model::linestring<point> polyline;

    // Use Boost.Assign to initialize a linestring
    polyline += point(0, 0), point(3, 3), point(5, 1), point(6, 2),
                point(8, 0), point(4, -4), point(1, -1), point(3, 2);


    // Declare the gathering class...
    gather_segment_statistics
        <
            boost::geometry::model::referring_segment<point>
        > functor;

    // ... and use it, the essention.
    // As also in std::for_each it is a const value, so retrieve it as a return value.
    functor = boost::geometry::for_each_segment(polyline, functor);

    // Output the results
    std::cout
        << "Min segment length: " << functor.min_length << std::endl
        << "Max segment length: " << functor.max_length << std::endl;

    return 0;
}

Output:

Min segment length: 1.41421
Max segment length: 5.65685

PrevUpHomeNext