{

using namespace boost::geometry;

// Boost.Geometry contains several point types:

// 1: its own generic type

model::point<double, 2, cs::cartesian> pt1;

// 2: its own type targetted to Cartesian (x,y) coordinates

model::d2::point_xy<double> pt2;

// 3: it supports Boost tuple's

boost::tuple<double, double> pt3;

// 4: it supports normal arrays

double pt4[2];

// 5: it supports arrays-as-points from Boost.Array

boost::array<double, 2> pt5;

// 6: it supports points from Boost.Polygon

boost::polygon::point_data<double> pt6;

// 7: in the past there was a typedef point_2d

// But users are now supposted to do that themselves:

typedef model::d2::point_xy<double> point_2d;

point_2d pt7;

// 7: there are more variants, and you can create your own.

// (see therefore the custom_point example)

// All these types are handled the same way. We show here

// assigning them and calculating distances.

assign_values(pt1, 1, 1);

assign_values(pt2, 2, 2);

assign_values(pt3, 3, 3);

assign_values(pt4, 4, 4);

assign_values(pt5, 5, 5);

assign_values(pt6, 6, 6);

assign_values(pt7, 7, 7);

double d1 = distance(pt1, pt2);

double d2 = distance(pt3, pt4);

double d3 = distance(pt5, pt6);

std::cout << "Distances: "

<< d1 << " and " << d2 << " and " << d3 << std::endl;

// (in case you didn't note, distances can be calculated

// from points with different point-types)

// Several ways of construction and setting point values

// 1: default, empty constructor, causing no initialization at all

model::d2::point_xy<double> p1;

// 2: as shown above, assign_values

model::d2::point_xy<double> p2;

assign_values(p2, 1, 1);

// 3: using "set" function

// set uses the concepts behind, such that it can be applied for

// every point-type (like assign_values)

model::d2::point_xy<double> p3;

set<0>(p3, 1);

set<1>(p3, 1);

// set<2>(p3, 1); //will result in compile-error

// 3: for any point type, and other geometry objects:

// there is the "make" object generator

// (this one requires to specify the point-type).

model::d2::point_xy<double> p4 = make<model::d2::point_xy<double> >(1,1);

// 5: for the d2::point_xy<...> type only: constructor with two values

model::d2::point_xy<double> p5(1,1);

// 6: for boost tuples you can of course use make_tuple

// Some ways of getting point values

// 1: using the "get" function following the concepts behind

std::cout << get<0>(p2) << "," << get<1>(p2) << std::endl;

// 2: for point_xy only

std::cout << p2.x() << "," << p2.y() << std::endl;

// 3: using boost-tuples you of course can boost-tuple-methods

std::cout << pt3.get<0>() << "," << pt3.get<1>() << std::endl;

// 4: Boost.Geometry supports various output formats, e.g. DSV

// (delimiter separated values)

std::cout << dsv(pt3) << std::endl;

// 5. or wkt

std::cout << wkt(p4) << (equals(p4, p5) ? " equals " : " don't equals ") << wkt(p5) << std::endl;

// There are 3-dimensional points too

model::point<double, 3, cs::cartesian> d3a, d3b;

assign_values(d3a, 1, 2, 3);

assign_values(d3b, 4, 5, 6);

d3 = distance(d3a, d3b);

// Other examples show other types of points, geometries and more algorithms

return 0;