diff --git a/doc/release_notes.qbk b/doc/release_notes.qbk
index 3d68894b5..df3a5fe49 100644
--- a/doc/release_notes.qbk
+++ b/doc/release_notes.qbk
@@ -28,6 +28,8 @@
 * The support for C++11 `std::initializer_list` in geometries models.
 * Disjoint and intersects support the following geometry combinations: multipoint/linestring, multipoint/multilinestring.
 * Added relate() and relation() algorithms.
+* Intersection has been implemented for combinations of pointlike and linear geometries
+* Added implementation for difference(pointlike, linear)
 
 [*Improvements]
 
diff --git a/extensions/test/gis/projections/Jamfile.v2 b/extensions/test/gis/projections/Jamfile.v2
index b57c8ebf5..8e68c39a3 100644
--- a/extensions/test/gis/projections/Jamfile.v2
+++ b/extensions/test/gis/projections/Jamfile.v2
@@ -12,5 +12,7 @@ test-suite boost-geometry-extensions-gis-projections
     :
     [ run projection.cpp ]
     [ run projections.cpp ]
+    [ run projections_combined.cpp ]
+    [ run projections_static.cpp ]
     [ run projection_epsg.cpp ]
     ;
diff --git a/extensions/test/gis/projections/projections.cpp b/extensions/test/gis/projections/projections.cpp
index 180acc3eb..6b7e2f6fc 100644
--- a/extensions/test/gis/projections/projections.cpp
+++ b/extensions/test/gis/projections/projections.cpp
@@ -132,6 +132,7 @@ void test_all()
     test_forward<P>("eck6", 4.897000, 52.371000, 342737.885307, 6363364.830847, "+proj=eck6 +ellps=WGS84 +units=m");
     test_forward<P>("eqc", 4.897000, 52.371000, 545131.546415, 5829913.052335, "+proj=eqc +ellps=WGS84 +units=m");
     test_forward<P>("eqdc", 4.897000, 52.371000, 307874.536263, 5810915.646438, "+proj=eqdc +ellps=WGS84 +units=m +lat_1=60 +lat_2=0");
+    test_forward<P>("etmerc", 4.897000, 52.371000, 333425.492123, 5815921.814393, "+proj=etmerc +ellps=WGS84 +units=m");
     test_forward<P>("euler", 4.897000, 52.371000, 338753.024859, 5836825.984893, "+proj=euler +ellps=WGS84 +units=m +lat_1=60 +lat_2=0");
     test_forward<P>("fahey", 4.897000, 52.371000, 388824.354103, 5705638.873094, "+proj=fahey +ellps=WGS84 +units=m");
     test_forward<P>("fouc", 4.897000, 52.371000, 268017.369817, 6272855.564674, "+proj=fouc +ellps=WGS84 +units=m");
@@ -149,6 +150,7 @@ void test_all()
     test_forward<P>("hammer", 4.897000, 52.371000, 370843.923425, 5630047.232233, "+proj=hammer +ellps=WGS84 +units=m");
     test_forward<P>("hatano", 4.897000, 52.371000, 383644.128560, 6290117.704632, "+proj=hatano +ellps=WGS84 +units=m");
     test_forward<P>("imw_p", 4.897000, 52.371000, 318784.808056, 3594184.939568, "+proj=imw_p +ellps=WGS84 +units=m +lat_1=20n +lat_2=60n +lon_1=5");
+    test_forward<P>("isea", 4.897000, 52.371000, -413613.639976, 9218173.701546, "+proj=isea +ellps=WGS84 +units=m");
     test_forward<P>("kav5", 4.897000, 52.371000, 383646.088858, 5997047.888175, "+proj=kav5 +ellps=WGS84 +units=m");
     test_forward<P>("kav7", 4.897000, 52.371000, 407769.043907, 5829913.052335, "+proj=kav7 +ellps=WGS84 +units=m");
     test_forward<P>("krovak", 14.416667, 50.083333, -743286.779768, -1043498.912060, "+proj=krovak +ellps=WGS84 +units=m");
@@ -256,6 +258,7 @@ void test_all()
     test_inverse<P>("eck6", 342737.885307, 6363364.830847, 4.897000, 52.371000, "+proj=eck6 +ellps=WGS84 +units=m");
     test_inverse<P>("eqc", 545131.546415, 5829913.052335, 4.897000, 52.371000, "+proj=eqc +ellps=WGS84 +units=m");
     test_inverse<P>("eqdc", 307874.536263, 5810915.646438, 4.897000, 52.371000, "+proj=eqdc +ellps=WGS84 +units=m +lat_1=60 +lat_2=0");
+    test_inverse<P>("etmerc", 333425.492123, 5815921.814393, 4.897000, 52.371000, "+proj=etmerc +ellps=WGS84 +units=m");
     test_inverse<P>("euler", 338753.024859, 5836825.984893, 4.897000, 52.371000, "+proj=euler +ellps=WGS84 +units=m +lat_1=60 +lat_2=0");
     test_inverse<P>("fahey", 388824.354103, 5705638.873094, 4.897000, 52.371000, "+proj=fahey +ellps=WGS84 +units=m");
     test_inverse<P>("fouc", 268017.369817, 6272855.564674, 4.897000, 52.371000, "+proj=fouc +ellps=WGS84 +units=m");
diff --git a/extensions/test/gis/projections/projections_combined.cpp b/extensions/test/gis/projections/projections_combined.cpp
new file mode 100644
index 000000000..9cec9b905
--- /dev/null
+++ b/extensions/test/gis/projections/projections_combined.cpp
@@ -0,0 +1,134 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+// Unit Test
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+
+#if defined(_MSC_VER)
+#pragma warning( disable : 4305 ) // truncation double -> float
+#endif // defined(_MSC_VER)
+
+#include <geometry_test_common.hpp>
+
+#include <boost/geometry/extensions/gis/projections/parameters.hpp>
+#include <boost/geometry/extensions/gis/projections/projection.hpp>
+
+#include <boost/geometry/extensions/gis/projections/factory.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/igh.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/ob_tran.hpp>
+
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/algorithms/make.hpp>
+
+#include <boost/geometry.hpp>
+#include <boost/geometry/geometries/geometries.hpp>
+#include <boost/geometry/geometries/point_xy.hpp>
+#include <boost/geometry/extensions/gis/latlong/point_ll.hpp>
+
+
+template <template <typename, typename, typename> class Projection, typename GeoPoint>
+void test_forward(GeoPoint const& geo_point1, GeoPoint const& geo_point2,
+        std::string const& parameters, int deviation = 1)
+{
+    typedef typename bg::coordinate_type<GeoPoint>::type coordinate_type;
+    typedef bg::model::d2::point_xy<coordinate_type> cartesian_point_type;
+    typedef Projection<GeoPoint, cartesian_point_type, bg::projections::parameters> projection_type;
+
+    // TEMPORARY (will replaced by the internal name of the projection - this is ugly and does not work for Windows or many other compilers)
+    std::string name = typeid(projection_type).name();
+    boost::replace_all(name, "N5boost8geometry11projections", "");
+    boost::replace_all(name, "INS0_5model2ll5pointINS0_6degreeEdNS0_2cs10geographicELm2EEENS3_2d28point_xyIdNS7_9cartesianEEENS1_10parametersEEE", "");
+    boost::replace_all(name, "11", "");
+    boost::replace_all(name, "12", "");
+    boost::replace_all(name, "13", "");
+    boost::replace_all(name, "14", "");
+    boost::replace_all(name, "15", "");
+    boost::replace_all(name, "16", "");
+    boost::replace_all(name, "17", "");
+    boost::replace_all(name, "18", "");
+
+    try
+    {
+        bg::projections::parameters par = bg::projections::detail::pj_init_plus(parameters);
+
+        projection_type prj(par);
+
+        cartesian_point_type xy1, xy2;
+        prj.forward(geo_point1, xy1);
+        prj.forward(geo_point2, xy2);
+
+        // Calculate distances in KM
+        int const distance_expected = static_cast<int>(bg::distance(geo_point1, geo_point2) / 1000.0);
+        int const distance_found = static_cast<int>(bg::distance(xy1, xy2) / 1000.0);
+
+        int const difference = std::abs(distance_expected - distance_found);
+        BOOST_CHECK_MESSAGE(difference <= 1 || difference == deviation,
+                " projection: " << name
+                << " distance found: " << distance_found
+                << " expected: " << distance_expected);
+
+// For debug:
+//        std::cout << name << " " << distance_expected
+//            << " " << distance_found
+//            << " " << (difference > 1 && difference != deviation ? " *** WRONG ***" : "")
+//            << " " << difference
+//            << std::endl;
+    }
+    catch(bg::projections::proj_exception const& e)
+    {
+        std::cout << "Exception in " << name << " : " << e.code() << std::endl;
+    }
+    catch(...)
+    {
+        std::cout << "Exception (unknown) in " << name << std::endl;
+    }
+}
+
+template <typename T>
+void test_all()
+{
+    typedef bg::model::ll::point<bg::degree, T> geo_point_type;
+
+    geo_point_type amsterdam = bg::make<geo_point_type>(4.8925, 52.3731);
+    geo_point_type utrecht   = bg::make<geo_point_type>(5.1213, 52.0907);
+
+    geo_point_type anchorage = bg::make<geo_point_type>(-149.90, 61.22);
+    geo_point_type juneau    = bg::make<geo_point_type>(-134.42, 58.30);
+
+    geo_point_type auckland   = bg::make<geo_point_type>(174.74, -36.84);
+    geo_point_type wellington = bg::make<geo_point_type>(177.78, -41.29);
+
+    geo_point_type aspen  = bg::make<geo_point_type>(-106.84, 39.19);
+    geo_point_type denver = bg::make<geo_point_type>(-104.88, 39.76);
+
+    // IGH (internally using moll/sinu)
+    test_forward<bg::projections::igh_spheroid>(amsterdam, utrecht, "+ellps=sphere +units=m", 5);
+    test_forward<bg::projections::igh_spheroid>(aspen, denver, "+ellps=sphere +units=m", 3);
+    test_forward<bg::projections::igh_spheroid>(auckland, wellington, "+ellps=sphere +units=m", 152);
+    test_forward<bg::projections::igh_spheroid>(anchorage, juneau, "+ellps=sphere +units=m", 28);
+
+    // Using moll
+    test_forward<bg::projections::ob_tran_oblique>(amsterdam, utrecht, "+ellps=WGS84 +units=m +o_proj=moll +o_lat_p=10 +o_lon_p=90 +o_lon_o=11.50", 4);
+    test_forward<bg::projections::ob_tran_transverse>(amsterdam, utrecht, "+ellps=WGS84 +units=m +o_proj=moll +o_lat_p=10 +o_lon_p=90 +o_lon_o=11.50", 5);
+    test_forward<bg::projections::ob_tran_oblique>(aspen, denver, "+ellps=WGS84 +units=m +o_proj=moll +o_lat_p=10 +o_lon_p=90 +o_lon_o=11.50", 19);
+    test_forward<bg::projections::ob_tran_transverse>(aspen, denver, "+ellps=WGS84 +units=m +o_proj=moll +o_lat_p=10 +o_lon_p=90 +o_lon_o=11.50", 19);
+
+    // Using sinu
+    test_forward<bg::projections::ob_tran_oblique>(amsterdam, utrecht, "+ellps=WGS84 +units=m +o_proj=sinu +o_lat_p=10 +o_lon_p=90 +o_lon_o=11.50", 5);
+    test_forward<bg::projections::ob_tran_transverse>(amsterdam, utrecht, "+ellps=WGS84 +units=m +o_proj=sinu +o_lat_p=10 +o_lon_p=90 +o_lon_o=11.50", 4);
+    test_forward<bg::projections::ob_tran_oblique>(aspen, denver, "+ellps=WGS84 +units=m +o_proj=sinu +o_lat_p=10 +o_lon_p=90 +o_lon_o=11.50", 14);
+    test_forward<bg::projections::ob_tran_transverse>(aspen, denver, "+ellps=WGS84 +units=m +o_proj=sinu +o_lat_p=10 +o_lon_p=90 +o_lon_o=11.50", 6);
+
+}
+
+int test_main(int, char* [])
+{
+    test_all<double>();
+
+    return 0;
+}
diff --git a/extensions/test/gis/projections/projections_static.cpp b/extensions/test/gis/projections/projections_static.cpp
new file mode 100644
index 000000000..1f7432eb0
--- /dev/null
+++ b/extensions/test/gis/projections/projections_static.cpp
@@ -0,0 +1,385 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+// Unit Test
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+
+#if defined(_MSC_VER)
+#pragma warning( disable : 4305 ) // truncation double -> float
+#endif // defined(_MSC_VER)
+
+#include <geometry_test_common.hpp>
+
+#include <boost/geometry/extensions/gis/projections/parameters.hpp>
+#include <boost/geometry/extensions/gis/projections/projection.hpp>
+
+#include <boost/geometry/extensions/gis/projections/proj/aea.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/aeqd.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/airy.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/aitoff.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/august.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/bacon.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/bipc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/boggs.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/bonne.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/cass.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/cc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/cea.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/chamb.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/collg.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/crast.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/denoy.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/eck1.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/eck2.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/eck3.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/eck4.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/eck5.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/eqc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/eqdc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/etmerc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/fahey.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/fouc_s.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/gall.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/geocent.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/geos.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/gins8.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/gn_sinu.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/gnom.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/goode.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/gstmerc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/hammer.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/hatano.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/krovak.hpp>
+//#include <boost/geometry/extensions/gis/projections/proj/igh.hpp> -> in combined
+#include <boost/geometry/extensions/gis/projections/proj/imw_p.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/isea.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/laea.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/labrd.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/lagrng.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/larr.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/lask.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/latlong.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/lcc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/lcca.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/loxim.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/lsat.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/mbtfpp.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/mbtfpq.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/mbt_fps.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/merc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/mill.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/mod_ster.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/moll.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/natearth.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/nell.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/nell_h.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/nocol.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/nsper.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/nzmg.hpp>
+//#include <boost/geometry/extensions/gis/projections/proj/ob_tran.hpp> -> in combined
+#include <boost/geometry/extensions/gis/projections/proj/ocea.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/oea.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/omerc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/ortho.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/qsc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/poly.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/putp2.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/putp3.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/putp4p.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/putp5.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/putp6.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/robin.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/rouss.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/rpoly.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/sconics.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/somerc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/stere.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/sterea.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/sts.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/tcc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/tcea.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/tmerc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/tpeqd.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/urm5.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/urmfps.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/vandg.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/vandg2.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/vandg4.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/wag2.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/wag3.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/wag7.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/wink1.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/wink2.hpp>
+
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/algorithms/make.hpp>
+
+#include <boost/geometry.hpp>
+#include <boost/geometry/geometries/geometries.hpp>
+#include <boost/geometry/geometries/point_xy.hpp>
+#include <boost/geometry/extensions/gis/latlong/point_ll.hpp>
+
+
+template <template <typename, typename, typename> class Projection, typename GeoPoint>
+void test_forward(GeoPoint const& geo_point1, GeoPoint const& geo_point2,
+        std::string const& parameters, int deviation = 1)
+{
+    typedef typename bg::coordinate_type<GeoPoint>::type coordinate_type;
+    typedef bg::model::d2::point_xy<coordinate_type> cartesian_point_type;
+    typedef Projection<GeoPoint, cartesian_point_type, bg::projections::parameters> projection_type;
+
+    // TEMPORARY (will replaced by the internal name of the projection - this is ugly and does not work for Windows or many other compilers)
+    std::string name = typeid(projection_type).name();
+    boost::replace_all(name, "N5boost8geometry11projections", "");
+    boost::replace_all(name, "INS0_5model2ll5pointINS0_6degreeEdNS0_2cs10geographicELm2EEENS3_2d28point_xyIdNS7_9cartesianEEENS1_10parametersEEE", "");
+    boost::replace_all(name, "11", "");
+    boost::replace_all(name, "12", "");
+    boost::replace_all(name, "13", "");
+    boost::replace_all(name, "14", "");
+    boost::replace_all(name, "15", "");
+    boost::replace_all(name, "16", "");
+    boost::replace_all(name, "17", "");
+    boost::replace_all(name, "18", "");
+
+    try
+    {
+        bg::projections::parameters par = bg::projections::detail::pj_init_plus(parameters);
+
+        projection_type prj(par);
+
+        cartesian_point_type xy1, xy2;
+        prj.forward(geo_point1, xy1);
+        prj.forward(geo_point2, xy2);
+
+        // Calculate distances in KM
+        int const distance_expected = static_cast<int>(bg::distance(geo_point1, geo_point2) / 1000.0);
+        int const distance_found = static_cast<int>(bg::distance(xy1, xy2) / 1000.0);
+
+        int const difference = std::abs(distance_expected - distance_found);
+        BOOST_CHECK_MESSAGE(difference <= 1 || difference == deviation,
+                " projection: " << name
+                << " distance found: " << distance_found
+                << " expected: " << distance_expected);
+
+// For debug:
+//        std::cout << name << " " << distance_expected
+//            << " " << distance_found
+//            << " " << (difference > 1 && difference != deviation ? " *** WRONG ***" : "")
+//            << " " << difference
+//            << std::endl;
+    }
+    catch(bg::projections::proj_exception const& e)
+    {
+        std::cout << "Exception in " << name << " : " << e.code() << std::endl;
+    }
+    catch(...)
+    {
+        std::cout << "Exception (unknown) in " << name << std::endl;
+    }
+}
+
+template <typename T>
+void test_all()
+{
+    typedef bg::model::ll::point<bg::degree, T> geo_point_type;
+
+    geo_point_type amsterdam = bg::make<geo_point_type>(4.8925, 52.3731);
+    geo_point_type utrecht   = bg::make<geo_point_type>(5.1213, 52.0907);
+
+    test_forward<bg::projections::aea_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=55 +lat_2=65");
+    test_forward<bg::projections::aeqd_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::aeqd_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+
+    test_forward<bg::projections::airy_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 4);
+    test_forward<bg::projections::aitoff_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::apian_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lon_0=11d32'00E");
+    test_forward<bg::projections::august_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 14);
+
+    test_forward<bg::projections::bacon_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lon_0=11d32'00E", 5);
+    test_forward<bg::projections::bipc_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 7);
+    test_forward<bg::projections::boggs_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lon_0=11d32'00E", 2);
+
+    test_forward<bg::projections::bonne_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=50");
+    test_forward<bg::projections::bonne_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=50", 33);
+
+    test_forward<bg::projections::cass_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::cass_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::cc_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 52);
+
+    test_forward<bg::projections::cea_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lon_0=11d32'00E", 4);
+    test_forward<bg::projections::cea_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lon_0=11d32'00E", 4);
+
+    test_forward<bg::projections::chamb_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=52 +lon_1=5 +lat_2=30 +lon_2=80 +lat_3=20 +lon_3=-50", 2);
+    test_forward<bg::projections::collg_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 5);
+    test_forward<bg::projections::crast_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::denoy_spheroid>(amsterdam, utrecht,  "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::eck1_spheroid>(amsterdam, utrecht,  "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::eck2_spheroid>(amsterdam, utrecht,  "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::eck3_spheroid>(amsterdam, utrecht,  "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::eck4_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::eck5_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+
+    test_forward<bg::projections::eck6_spheroid>(amsterdam, utrecht,  "+ellps=WGS84 +units=m");
+
+    test_forward<bg::projections::eqc_spheroid>(amsterdam, utrecht,  "+ellps=WGS84 +units=m", 5);
+    test_forward<bg::projections::eqdc_ellipsoid>(amsterdam, utrecht,  "+ellps=WGS84 +units=m +lat_1=60 +lat_2=0");
+    test_forward<bg::projections::etmerc_ellipsoid>(amsterdam, utrecht,  "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::euler_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=60 +lat_2=0");
+
+    test_forward<bg::projections::fahey_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 5);
+    test_forward<bg::projections::fouc_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 6);
+    test_forward<bg::projections::fouc_s_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 4);
+    test_forward<bg::projections::gall_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::geocent_other>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 5);
+    test_forward<bg::projections::geos_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +h=40000000", 13);
+    test_forward<bg::projections::gins8_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 7);
+
+    test_forward<bg::projections::gn_sinu_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +m=0.5 +n=1.785");
+
+    test_forward<bg::projections::gnom_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 50);
+    test_forward<bg::projections::goode_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::gstmerc_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::hammer_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::hatano_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::imw_p_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n +lon_1=5");
+    test_forward<bg::projections::isea_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::kav5_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::kav7_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::krovak_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::laea_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::lagrng_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +W=1", 8);
+    test_forward<bg::projections::larr_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 13);
+    test_forward<bg::projections::lask_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 5);
+    test_forward<bg::projections::lcc_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n", 2);
+    test_forward<bg::projections::lcca_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_0=30n +lat_1=55n +lat_2=60n", 2);
+    test_forward<bg::projections::leac_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 8);
+    test_forward<bg::projections::loxim_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 3);
+    test_forward<bg::projections::lsat_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lsat=1 +path=1", 3);
+    test_forward<bg::projections::mbt_fps_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::mbt_s_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::mbtfpp_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::mbtfpq_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+
+    test_forward<bg::projections::mbtfps_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+
+    test_forward<bg::projections::merc_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 22);
+    test_forward<bg::projections::merc_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 22);
+
+    test_forward<bg::projections::mil_os_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::mill_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 14);
+    test_forward<bg::projections::moll_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::murd1_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n");
+    test_forward<bg::projections::murd2_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n");
+    test_forward<bg::projections::murd3_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n");
+    test_forward<bg::projections::natearth_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::nell_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 4);
+    test_forward<bg::projections::nell_h_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 3);
+    test_forward<bg::projections::nicol_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+
+    test_forward<bg::projections::oea_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n +lon_1=1e +lon_2=30e +m=1 +n=1", 4);
+    test_forward<bg::projections::omerc_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n  +lon_1=1e +lon_2=30e");
+    test_forward<bg::projections::ortel_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::ortho_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 9);
+    test_forward<bg::projections::pconic_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n +lon_0=10E");
+    test_forward<bg::projections::qsc_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 10);
+    test_forward<bg::projections::poly_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::putp1_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::putp2_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::putp3_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 6);
+    test_forward<bg::projections::putp3p_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 5);
+    test_forward<bg::projections::putp4p_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::putp5_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::putp5p_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 3);
+    test_forward<bg::projections::putp6_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::putp6p_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::qua_aut_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::robin_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::rouss_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 8);
+    test_forward<bg::projections::rpoly_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+
+    test_forward<bg::projections::sinu_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::sinu_spheroid>(amsterdam, utrecht, "+ellps=sphere +units=m");
+
+    test_forward<bg::projections::somerc_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 22);
+    test_forward<bg::projections::stere_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_ts=50n", 8);
+    test_forward<bg::projections::sterea_ellipsoid>(amsterdam, utrecht, "+lat_0=52.15616055555555 +lon_0=5.38763888888889 +k=0.9999079 +x_0=155000 +y_0=463000 +ellps=bessel +units=m");
+    test_forward<bg::projections::tcc_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::tcea_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::tissot_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n", 2);
+
+    test_forward<bg::projections::tmerc_spheroid>(amsterdam, utrecht, "+ellps=sphere +units=m");
+    test_forward<bg::projections::tmerc_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+
+    test_forward<bg::projections::tpeqd_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n  +lon_1=0 +lon_2=30e");
+    test_forward<bg::projections::tpers_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +tilt=50 +azi=20 +h=40000000", 14);
+
+    test_forward<bg::projections::ups_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 3);
+    test_forward<bg::projections::ups_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 3);
+
+    test_forward<bg::projections::urm5_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +n=.3 +q=.3 +alpha=10", 4);
+    test_forward<bg::projections::urmfps_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +n=0.50", 4);
+
+    test_forward<bg::projections::utm_spheroid>(amsterdam, utrecht, "+ellps=sphere +units=m +lon_0=11d32'00E");
+    test_forward<bg::projections::utm_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lon_0=11d32'00E");
+
+    test_forward<bg::projections::vandg_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 13);
+    test_forward<bg::projections::vandg2_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 13);
+    test_forward<bg::projections::vandg3_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 13);
+    test_forward<bg::projections::vandg4_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::vitk1_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +lat_1=20n +lat_2=60n");
+    test_forward<bg::projections::wag1_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::wag2_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::wag3_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 3);
+    test_forward<bg::projections::wag4_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::wag5_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::wag6_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+    test_forward<bg::projections::wag7_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 2);
+    test_forward<bg::projections::weren_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 4);
+    test_forward<bg::projections::wink1_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 3);
+    test_forward<bg::projections::wink2_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m", 4);
+    test_forward<bg::projections::wintri_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m");
+
+    //    We SKIP ob_tran because it internally requires the factory and is, in that sense, not a static test
+    //    test_forward<bg::projections::ob_tran_oblique>(amsterdam, utrecht, "+ellps=WGS84 +units=m +o_proj=moll +o_lat_p=10 +o_lon_p=90 +o_lon_o=11.50");
+    //    test_forward<bg::projections::ob_tran_transverse>(amsterdam, utrecht, "+ellps=WGS84 +units=m +o_proj=moll +o_lat_p=10 +o_lon_p=90 +o_lon_o=11.50");
+
+    // TODO: wrong projections or parameters or input points
+//    test_forward<bg::projections::ocea_spheroid>(auckland, wellington, "+ellps=sphere +units=m +lat_1=20s +lat_2=60s  +lon_1=165e +lon_2=175e"); => distance is very large
+//    test_forward<bg::projections::nsper_spheroid>(amsterdam, utrecht, "+ellps=WGS84 +units=m +a=10 +h=40000000"); => distance is 0
+//    test_forward<bg::projections::lee_os_ellipsoid>(amsterdam, utrecht, "+ellps=WGS84 +units=m"); => distance is 407
+
+
+    // Alaska
+    {
+        geo_point_type anchorage = bg::make<geo_point_type>(-149.90, 61.22);
+        geo_point_type juneau    = bg::make<geo_point_type>(-134.42, 58.30);
+        test_forward<bg::projections::alsk_ellipsoid>(anchorage, juneau, "+ellps=WGS84 +units=m +lon_0=-150W", 1);
+    }
+    // New Zealand
+    {
+        geo_point_type auckland   = bg::make<geo_point_type>(174.74, -36.84);
+        geo_point_type wellington = bg::make<geo_point_type>(177.78, -41.29);
+        test_forward<bg::projections::nzmg_ellipsoid>(auckland, wellington, "+ellps=WGS84 +units=m", 0);
+    }
+
+    // US
+    {
+        geo_point_type aspen  = bg::make<geo_point_type>(-106.84, 39.19);
+        geo_point_type denver = bg::make<geo_point_type>(-104.88, 39.76);
+        // TODO: test_forward<bg::projections::gs48_ellipsoid>(aspen, denver, "+ellps=WGS84 +units=m +lon1=-48");=> distance is > 1000
+        test_forward<bg::projections::gs50_ellipsoid>(aspen, denver, "+ellps=WGS84 +units=m +lon1=-50", 2);
+    }
+
+}
+
+int test_main(int, char* [])
+{
+    test_all<double>();
+
+    return 0;
+}
diff --git a/include/boost/geometry/algorithms/detail/buffer/buffer_inserter.hpp b/include/boost/geometry/algorithms/detail/buffer/buffer_inserter.hpp
index 127e4c3fb..0419533e1 100644
--- a/include/boost/geometry/algorithms/detail/buffer/buffer_inserter.hpp
+++ b/include/boost/geometry/algorithms/detail/buffer/buffer_inserter.hpp
@@ -383,6 +383,7 @@ inline void buffer_point(Point const& point, Collection& collection,
     std::vector<OutputPointType> range_out;
     point_strategy.apply(point, distance_strategy, range_out);
     collection.add_piece(strategy::buffer::buffered_point, range_out, false);
+    collection.set_piece_center(point);
     collection.finish_ring();
 }
 
@@ -613,15 +614,18 @@ struct buffer_inserter<linestring_tag, Linestring, Polygon>
 
         output_point_type first_p2, last_p1, last_p2;
 
-        detail::buffer::buffer_range<output_ring_type>::iterate(collection,
+        bool result = detail::buffer::buffer_range<output_ring_type>::iterate(collection,
                 begin, end, side,
                 distance_strategy, side_strategy, join_strategy, end_strategy, robust_policy,
                 first_p1, first_p2, last_p1, last_p2);
 
-        std::vector<output_point_type> range_out;
-        end_strategy.apply(penultimate_point, last_p2, ultimate_point, reverse_p1, side, distance_strategy, range_out);
-        collection.add_endcap(end_strategy, range_out, ultimate_point);
-        return true;
+        if (result)
+        {
+            std::vector<output_point_type> range_out;
+            end_strategy.apply(penultimate_point, last_p2, ultimate_point, reverse_p1, side, distance_strategy, range_out);
+            collection.add_endcap(end_strategy, range_out, ultimate_point);
+        }
+        return result;
     }
 
     template
@@ -910,7 +914,7 @@ inline void buffer_inserter(GeometryInput const& geometry_input, OutputIterator
         collection.reverse();
     }
 
-    if (distance_strategy.negative() && areal)
+    if (BOOST_GEOMETRY_CONDITION(distance_strategy.negative() && areal))
     {
         collection.discard_nonintersecting_deflated_rings();
     }
diff --git a/include/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp b/include/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp
index c5bb8acc0..8def4d5f4 100644
--- a/include/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp
+++ b/include/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp
@@ -9,6 +9,7 @@
 #ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFER_POLICIES_HPP
 #define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFER_POLICIES_HPP
 
+#define BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION
 
 #include <cstddef>
 
@@ -122,6 +123,10 @@ struct buffer_turn_info
 
     intersection_location_type location;
 
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    robust_point_type rob_pi, rob_pj, rob_qi, rob_qj;
+#endif
+
     int count_within;
 
     bool within_original;
@@ -130,7 +135,9 @@ struct buffer_turn_info
 
     int count_on_offsetted;
     int count_on_helper;
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
     int count_within_near_offsetted;
+#endif
 
     bool remove_on_multi;
 
@@ -147,7 +154,9 @@ struct buffer_turn_info
         , count_in_original(0)
         , count_on_offsetted(0)
         , count_on_helper(0)
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
         , count_within_near_offsetted(0)
+#endif
         , remove_on_multi(false)
         , count_on_occupied(0)
         , count_on_multi(0)
diff --git a/include/boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp b/include/boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp
index c13e12449..c25eeae2b 100644
--- a/include/boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp
+++ b/include/boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp
@@ -19,8 +19,10 @@
 #include <boost/geometry/core/coordinate_type.hpp>
 #include <boost/geometry/core/point_type.hpp>
 
+#include <boost/geometry/algorithms/comparable_distance.hpp>
 #include <boost/geometry/algorithms/covered_by.hpp>
 #include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/is_convex.hpp>
 
 #include <boost/geometry/strategies/buffer.hpp>
 
@@ -126,6 +128,11 @@ struct buffered_piece_collection
     typedef geometry::model::ring<robust_point_type> robust_ring_type;
     typedef geometry::model::box<robust_point_type> robust_box_type;
 
+    typedef typename default_comparable_distance_result
+        <
+            robust_point_type
+        >::type robust_comparable_radius_type;
+
     typedef typename strategy::side::services::default_strategy
         <
             typename cs_tag<point_type>::type
@@ -191,13 +198,13 @@ struct buffered_piece_collection
         std::vector<point_type> helper_points; // 4 points for side, 3 points for join - 0 points for flat-end
 #endif
 
+        bool is_convex;
         bool is_monotonic_increasing[2]; // 0=x, 1=y
         bool is_monotonic_decreasing[2]; // 0=x, 1=y
 
         // Monotonic sections of pieces around points
         std::vector<section_type> sections;
 
-
         // Robust representations
         // 3: complete ring
         robust_ring_type robust_ring;
@@ -206,6 +213,27 @@ struct buffered_piece_collection
         robust_box_type robust_offsetted_envelope;
 
         std::vector<robust_turn> robust_turns; // Used only in insert_rescaled_piece_turns - we might use a map instead
+
+        robust_point_type robust_center;
+        robust_comparable_radius_type robust_min_comparable_radius;
+        robust_comparable_radius_type robust_max_comparable_radius;
+
+        piece()
+            : type(strategy::buffer::piece_type_unknown)
+            , index(-1)
+            , left_index(-1)
+            , right_index(-1)
+            , last_segment_index(-1)
+            , offsetted_count(-1)
+            , is_convex(false)
+            , robust_min_comparable_radius(0)
+            , robust_max_comparable_radius(0)
+        {
+            is_monotonic_increasing[0] = false;
+            is_monotonic_increasing[1] = false;
+            is_monotonic_decreasing[0] = false;
+            is_monotonic_decreasing[1] = false;
+        }
     };
 
     struct robust_original
@@ -444,6 +472,7 @@ struct buffered_piece_collection
             {
                 it->location = inside_buffer;
             }
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
             if (it->count_within_near_offsetted > 0)
             {
                 // Within can have in rare cases a rounding issue. We don't discard this
@@ -451,6 +480,7 @@ struct buffered_piece_collection
                 // will never start a new ring from this type of points.
                 it->selectable_start = false;
             }
+#endif
         }
     }
 
@@ -544,6 +574,7 @@ struct buffered_piece_collection
             }
         }
 
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
         // Insert all rescaled turn-points into these rings, to form a
         // reliable integer-based ring. All turns can be compared (inside) to this
         // rings to see if they are inside.
@@ -582,6 +613,7 @@ struct buffered_piece_collection
         }
 
         BOOST_ASSERT(assert_indices_in_robust_rings());
+#endif
     }
 
     template <std::size_t Dimension>
@@ -606,6 +638,8 @@ struct buffered_piece_collection
         pc.is_monotonic_decreasing[0] = true;
         pc.is_monotonic_decreasing[1] = true;
 
+        pc.is_convex = geometry::is_convex(pc.robust_ring);
+
         if (pc.offsetted_count < 2)
         {
             return;
@@ -621,7 +655,6 @@ struct buffered_piece_collection
             current = next;
             ++next;
         }
-
     }
 
     void determine_properties()
@@ -658,7 +691,31 @@ struct buffered_piece_collection
         geometry::sectionalize<false, dimensions>(pc.robust_ring,
                 detail::no_rescale_policy(), pc.sections);
 
-        // TODO (next phase) determine min/max radius
+        // Determine min/max radius
+        typedef geometry::model::referring_segment<robust_point_type const>
+            robust_segment_type;
+
+        typename robust_ring_type::const_iterator current = pc.robust_ring.begin();
+        typename robust_ring_type::const_iterator next = current + 1;
+
+        for (int i = 1; i < pc.offsetted_count; i++)
+        {
+            robust_segment_type s(*current, *next);
+            robust_comparable_radius_type const d
+                = geometry::comparable_distance(pc.robust_center, s);
+
+            if (i == 1 || d < pc.robust_min_comparable_radius)
+            {
+                pc.robust_min_comparable_radius = d;
+            }
+            if (i == 1 || d > pc.robust_max_comparable_radius)
+            {
+                pc.robust_max_comparable_radius = d;
+            }
+
+            current = next;
+            ++next;
+        }
     }
 
     inline void prepare_buffered_point_pieces()
@@ -772,6 +829,13 @@ struct buffered_piece_collection
         }
     }
 
+    inline void set_piece_center(point_type const& center)
+    {
+        BOOST_ASSERT(! m_pieces.empty());
+        geometry::recalculate(m_pieces.back().robust_center, center,
+                m_robust_policy);
+    }
+
     inline void finish_ring(bool is_interior = false, bool has_interiors = false)
     {
         if (m_first_piece_index == -1)
@@ -1286,8 +1350,12 @@ struct buffered_piece_collection
             if (! it->has_intersections()
                 && ! it->is_untouched_outside_original)
             {
-                ring_identifier id(0, index, -1);
-                selected[id] = properties(*it);
+                properties p = properties(*it);
+                if (p.valid)
+                {
+                    ring_identifier id(0, index, -1);
+                    selected[id] = p;
+                }
             }
         }
 
@@ -1298,8 +1366,12 @@ struct buffered_piece_collection
                 it != boost::end(traversed_rings);
                 ++it, ++index)
         {
-            ring_identifier id(2, index, -1);
-            selected[id] = properties(*it);
+            properties p = properties(*it);
+            if (p.valid)
+            {
+                ring_identifier id(2, index, -1);
+                selected[id] = p;
+            }
         }
 
         detail::overlay::assign_parents(offsetted_rings, traversed_rings, selected, true);
diff --git a/include/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp b/include/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp
index 6a3daa282..6885c5ac0 100644
--- a/include/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp
+++ b/include/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp
@@ -17,6 +17,7 @@
 #include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
 #include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
 #include <boost/geometry/algorithms/detail/sections/section_functions.hpp>
+#include <boost/geometry/algorithms/detail/buffer/buffer_policies.hpp>
 
 
 namespace boost { namespace geometry
@@ -28,6 +29,34 @@ namespace detail { namespace buffer
 {
 
 
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+struct buffer_assign_turn
+{
+    static bool const include_no_turn = false;
+    static bool const include_degenerate = false;
+    static bool const include_opposite = false;
+
+    template
+    <
+        typename Info,
+        typename Point1,
+        typename Point2,
+        typename IntersectionInfo
+    >
+    static inline void apply(Info& info,
+                             Point1 const& /*p1*/,
+                             Point2 const& /*p2*/,
+                             IntersectionInfo const& iinfo)
+    {
+        info.rob_pi = iinfo.rpi();
+        info.rob_pj = iinfo.rpj();
+        info.rob_qi = iinfo.rqi();
+        info.rob_qj = iinfo.rqj();
+    }
+
+};
+#endif
+
 template
 <
     typename Pieces,
@@ -204,7 +233,11 @@ class piece_turn_visitor
                 // and iterating in sync with them...
                 typedef detail::overlay::get_turn_info
                     <
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+                        buffer_assign_turn
+#else
                         detail::overlay::assign_null_policy
+#endif
                     > turn_policy;
 
                 turn_policy::apply(*prev1, *it1, *next1,
diff --git a/include/boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp b/include/boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp
index 8803efdec..99bca8f36 100644
--- a/include/boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp
+++ b/include/boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp
@@ -25,6 +25,11 @@
 #include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
 #include <boost/geometry/policies/compare.hpp>
 #include <boost/geometry/strategies/buffer.hpp>
+#include <boost/geometry/algorithms/detail/buffer/buffer_policies.hpp>
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+#include <boost/geometry/strategies/cartesian/side_of_intersection.hpp>
+#endif
 
 
 namespace boost { namespace geometry
@@ -89,8 +94,10 @@ enum analyse_result
     analyse_disjoint,
     analyse_within,
     analyse_on_original_boundary,
-    analyse_on_offsetted,
-    analyse_near_offsetted
+    analyse_on_offsetted
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    , analyse_near_offsetted
+#endif
 };
 
 template <typename Point>
@@ -112,6 +119,31 @@ inline analyse_result check_segment(Point const& previous,
         Point const& current, Turn const& turn,
         bool from_monotonic)
 {
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    typedef geometry::model::referring_segment<Point const> segment_type;
+    segment_type const p(turn.rob_pi, turn.rob_pj);
+    segment_type const q(turn.rob_qi, turn.rob_qj);
+    segment_type const r(previous, current);
+    int const side = strategy::side::side_of_intersection::apply(p, q, r,
+                turn.robust_point);
+
+    if (side == 0)
+    {
+        return analyse_on_offsetted;
+    }
+    if (side == -1 && from_monotonic)
+    {
+        return analyse_within;
+    }
+    if (side == 1 && from_monotonic)
+    {
+        return analyse_disjoint;
+    }
+    return analyse_continue;
+
+#else
+
     typedef typename strategy::side::services::default_strategy
         <
             typename cs_tag<Point>::type
@@ -156,6 +188,7 @@ inline analyse_result check_segment(Point const& previous,
 
     // Not monotonic, on left or right side: continue analysing
     return analyse_continue;
+#endif
 }
 
 
@@ -169,14 +202,22 @@ public :
         typedef typename Turn::robust_point_type point_type;
         typedef typename geometry::coordinate_type<point_type>::type coordinate_type;
 
-        coordinate_type const point_y = geometry::get<1>(turn.robust_point);
-
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+        typedef geometry::model::referring_segment<point_type const> segment_type;
+        segment_type const p(turn.rob_pi, turn.rob_pj);
+        segment_type const q(turn.rob_qi, turn.rob_qj);
+#else
         typedef strategy::within::winding<point_type> strategy_type;
 
         typename strategy_type::state_type state;
         strategy_type strategy;
         boost::ignore_unused(strategy);
-        
+#endif
+
+        BOOST_ASSERT(! piece.sections.empty());
+
+        coordinate_type const point_y = geometry::get<1>(turn.robust_point);
+
         for (std::size_t s = 0; s < piece.sections.size(); s++)
         {
             section_type const& section = piece.sections[s];
@@ -191,6 +232,38 @@ public :
                     point_type const& previous = piece.robust_ring[i - 1];
                     point_type const& current = piece.robust_ring[i];
 
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+
+                    // First check if it is in range - if it is not, the
+                    // expensive side_of_intersection does not need to be
+                    // applied
+                    coordinate_type y1 = geometry::get<1>(previous);
+                    coordinate_type y2 = geometry::get<1>(current);
+
+                    if (y1 > y2)
+                    {
+                        std::swap(y1, y2);
+                    }
+
+                    if (point_y >= y1 - 1 && point_y <= y2 + 1)
+                    {
+                        segment_type const r(previous, current);
+                        int const side = strategy::side::side_of_intersection::apply(p, q, r,
+                                    turn.robust_point);
+
+                        // Sections are monotonic in y-dimension
+                        if (side == 1)
+                        {
+                            // Left on segment
+                            return analyse_disjoint;
+                        }
+                        else if (side == 0)
+                        {
+                            // Collinear - TODO: check if really on segment
+                            return analyse_on_offsetted;
+                        }
+                    }
+#else
                     analyse_result code = check_segment(previous, current, turn, false);
                     if (code != analyse_continue)
                     {
@@ -200,10 +273,15 @@ public :
                     // Get the state (to determine it is within), we don't have
                     // to cover the on-segment case (covered above)
                     strategy.apply(turn.robust_point, previous, current, state);
+#endif
                 }
             }
         }
 
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+        // It is nowhere outside, and not on segment, so it is within
+        return analyse_within;
+#else
         int const code = strategy.result(state);
         if (code == 1)
         {
@@ -216,6 +294,7 @@ public :
 
         // Should normally not occur - on-segment is covered
         return analyse_unknown;
+#endif
     }
 
 };
@@ -228,6 +307,49 @@ class analyse_turn_wrt_piece
                 bool is_original,
                 Point const& offsetted)
     {
+        boost::ignore_unused(offsetted);
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+        typedef geometry::model::referring_segment<Point const> segment_type;
+        segment_type const p(turn.rob_pi, turn.rob_pj);
+        segment_type const q(turn.rob_qi, turn.rob_qj);
+        segment_type const r(s1, s2);
+        int const side = strategy::side::side_of_intersection::apply(p, q, r,
+                    turn.robust_point);
+
+        if (side == 1)
+        {
+            // left of segment
+            return analyse_disjoint;
+        }
+        else if (side == 0)
+        {
+            // If is collinear, either on segment or before/after
+            typedef geometry::model::box<Point> box_type;
+
+            box_type box;
+            geometry::assign_inverse(box);
+            geometry::expand(box, s1);
+            geometry::expand(box, s2);
+
+            if (geometry::covered_by(turn.robust_point, box))
+            {
+                // Points on helper-segments are considered as within
+                // Points on original boundary are processed differently
+                return is_original
+                    ? analyse_on_original_boundary
+                    : analyse_within;
+            }
+
+            // It is collinear but not on the segment. Because these
+            // segments are convex, it is outside
+            // Unless the offsetted ring is collinear or concave w.r.t.
+            // helper-segment but that scenario is not yet supported
+            return analyse_disjoint;
+        }
+
+        // right of segment
+        return analyse_continue;
+#else
         typedef typename strategy::side::services::default_strategy
             <
                 typename cs_tag<Point>::type
@@ -276,6 +398,7 @@ class analyse_turn_wrt_piece
 
         // right of segment
         return analyse_continue;
+#endif
     }
 
     template <typename Turn, typename Piece>
@@ -492,6 +615,60 @@ class turn_in_piece_visitor
         return false;
     }
 
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    template <typename Turn, typename Piece>
+    static inline int turn_in_convex_piece(Turn const& turn,
+            Piece const& piece)
+    {
+        typedef typename Turn::robust_point_type point_type;
+        typedef typename Piece::piece_robust_ring_type ring_type;
+        typedef geometry::model::referring_segment<point_type const> segment;
+
+        segment const p(turn.rob_pi, turn.rob_pj);
+        segment const q(turn.rob_qi, turn.rob_qj);
+
+        typedef typename boost::range_iterator<ring_type const>::type iterator_type;
+        iterator_type it = boost::begin(piece.robust_ring);
+        iterator_type end = boost::end(piece.robust_ring);
+
+        // A robust ring is always closed, and always clockwise
+        for (iterator_type previous = it++; it != end; ++previous, ++it)
+        {
+            geometry::equal_to<point_type> comparator;
+            if (comparator(*previous, *it))
+            {
+                // Points are the same
+                continue;
+            }
+
+            segment r(*previous, *it);
+
+            int const side = strategy::side::side_of_intersection::apply(p, q, r,
+                        turn.robust_point);
+
+            if (side == 1)
+            {
+                // IP is left of segment, so it is outside
+                return -1; // outside
+            }
+            else if (side == 0)
+            {
+                // IP is collinear with segment. TODO: we should analyze this further
+                // For now we use the fallback point
+                if (in_box(*previous, *it, turn.robust_point))
+                {
+                    return 0;
+                }
+                else
+                {
+                    return -1; // outside
+                }
+            }
+        }
+        return 1; // inside
+    }
+#endif
+
 
 public:
 
@@ -530,12 +707,37 @@ public:
         }
 
         // TODO: mutable_piece to make some on-demand preparations in analyse
+        Turn& mutable_turn = m_turns[turn.turn_index];
+
+        if (piece.type == geometry::strategy::buffer::buffered_point)
+        {
+            // Optimization for buffer around points: if distance from center
+            // is not between min/max radius, the result is clear
+            typedef typename default_comparable_distance_result
+                <
+                    typename Turn::robust_point_type
+                >::type distance_type;
+
+            distance_type const cd
+                = geometry::comparable_distance(piece.robust_center,
+                        turn.robust_point);
+
+            if (cd < piece.robust_min_comparable_radius)
+            {
+                mutable_turn.count_within++;
+                return;
+            }
+            if (cd > piece.robust_max_comparable_radius)
+            {
+                return;
+            }
+        }
+
         analyse_result analyse_code =
             piece.type == geometry::strategy::buffer::buffered_point
                 ? analyse_turn_wrt_point_piece::apply(turn, piece)
                 : analyse_turn_wrt_piece::apply(turn, piece);
 
-        Turn& mutable_turn = m_turns[turn.turn_index];
         switch(analyse_code)
         {
             case analyse_disjoint :
@@ -549,16 +751,32 @@ public:
             case analyse_within :
                 mutable_turn.count_within++;
                 return;
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
             case analyse_near_offsetted :
                 mutable_turn.count_within_near_offsetted++;
                 return;
+#endif
             default :
                 break;
         }
 
-        // TODO: this point_in_geometry is a performance-bottleneck here and
-        // will be replaced completely by extending analyse_piece functionality
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+        // We don't know (yet)
+        int geometry_code = 0;
+        if (piece.is_convex)
+        {
+            geometry_code = turn_in_convex_piece(turn, piece);
+        }
+        else
+        {
+
+            // TODO: this point_in_geometry is a performance-bottleneck here and
+            // will be replaced completely by extending analyse_piece functionality
+            geometry_code = detail::within::point_in_geometry(turn.robust_point, piece.robust_ring);
+        }
+#else
         int geometry_code = detail::within::point_in_geometry(turn.robust_point, piece.robust_ring);
+#endif
 
         if (geometry_code == 1)
         {
diff --git a/include/boost/geometry/algorithms/detail/disjoint/point_point.hpp b/include/boost/geometry/algorithms/detail/disjoint/point_point.hpp
index b1d32bf95..2261efd3a 100644
--- a/include/boost/geometry/algorithms/detail/disjoint/point_point.hpp
+++ b/include/boost/geometry/algorithms/detail/disjoint/point_point.hpp
@@ -1,12 +1,12 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
-// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
-// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
-// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland
 
-// This file was modified by Oracle on 2013-2014.
-// Modifications copyright (c) 2013-2014, Oracle and/or its affiliates.
+// This file was modified by Oracle on 2013, 2014, 2015.
+// Modifications copyright (c) 2013-2015, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
@@ -23,11 +23,19 @@
 
 #include <cstddef>
 
+#include <boost/type_traits/is_same.hpp>
+
 #include <boost/geometry/core/access.hpp>
-#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/cs.hpp>
 #include <boost/geometry/core/tags.hpp>
 
+#include <boost/geometry/util/condition.hpp>
 #include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/normalize_spheroidal_coordinates.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
 
 #include <boost/geometry/algorithms/dispatch/disjoint.hpp>
 
@@ -40,12 +48,103 @@ namespace boost { namespace geometry
 namespace detail { namespace disjoint
 {
 
+
+class point_point_on_spheroid
+{
+private:
+    template
+    <
+        typename Units,
+        typename CoordinateType1,
+        typename CoordinateType2
+    >
+    static inline bool apply_same_units(CoordinateType1& lon1,
+                                        CoordinateType1& lat1,
+                                        CoordinateType2& lon2,
+                                        CoordinateType2& lat2)
+    {
+        math::normalize_spheroidal_coordinates<Units>(lon1, lat1);
+        math::normalize_spheroidal_coordinates<Units>(lon2, lat2);
+
+        return ! math::equals(lat1, lat2) || ! math::equals(lon1, lon2);
+    }
+
+public:
+    template <typename Point1, typename Point2>
+    static inline bool apply(Point1 const& p1, Point2 const& p2)
+    {
+        typedef typename coordinate_type<Point1>::type coordinate_type1;
+        typedef typename coordinate_type<Point2>::type coordinate_type2;
+
+        typedef typename coordinate_system<Point1>::type::units units1;
+        typedef typename coordinate_system<Point2>::type::units units2;
+
+        if (BOOST_GEOMETRY_CONDITION((boost::is_same<units1, units2>::value)))
+        {
+            coordinate_type1 lon1 = geometry::get<0>(p1);
+            coordinate_type1 lat1 = geometry::get<1>(p1);
+            coordinate_type2 lon2 = geometry::get<0>(p2);
+            coordinate_type2 lat2 = geometry::get<1>(p2);
+
+            return apply_same_units<units1>(lon1, lat1, lon2, lat2);
+        }
+
+        typedef typename geometry::select_most_precise
+            <
+                typename fp_coordinate_type<Point1>::type,
+                typename fp_coordinate_type<Point2>::type
+            >::type calculation_type;
+
+        calculation_type lon1 = get_as_radian<0>(p1);
+        calculation_type lat1 = get_as_radian<1>(p1);
+
+        calculation_type lon2 = get_as_radian<0>(p2);
+        calculation_type lat2 = get_as_radian<1>(p2);
+
+        return apply_same_units<radian>(lon1, lat1, lon2, lat2);
+    }
+};
+
+
+template
+<
+    typename Point1, typename Point2,
+    std::size_t Dimension, std::size_t DimensionCount,
+    typename CSTag1 = typename cs_tag<Point1>::type,
+    typename CSTag2 = CSTag1
+>
+struct point_point
+    : point_point<Point1, Point2, Dimension, DimensionCount, cartesian_tag>
+{};
+
 template
 <
     typename Point1, typename Point2,
     std::size_t Dimension, std::size_t DimensionCount
 >
 struct point_point
+    <
+        Point1, Point2, Dimension, DimensionCount, spherical_equatorial_tag
+    > : point_point_on_spheroid
+{};
+
+template
+<
+    typename Point1, typename Point2,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct point_point
+    <
+        Point1, Point2, Dimension, DimensionCount, geographic_tag
+    > : point_point_on_spheroid
+{};
+
+template
+<
+    typename Point1, typename Point2,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct point_point<Point1, Point2, Dimension, DimensionCount, cartesian_tag>
 {
     static inline bool apply(Point1 const& p1, Point2 const& p2)
     {
@@ -61,9 +160,11 @@ struct point_point
     }
 };
 
-
 template <typename Point1, typename Point2, std::size_t DimensionCount>
-struct point_point<Point1, Point2, DimensionCount, DimensionCount>
+struct point_point
+    <
+        Point1, Point2, DimensionCount, DimensionCount, cartesian_tag
+    >
 {
     static inline bool apply(Point1 const& , Point2 const& )
     {
diff --git a/include/boost/geometry/algorithms/detail/overlay/clip_linestring.hpp b/include/boost/geometry/algorithms/detail/overlay/clip_linestring.hpp
index fc4f65732..b1a25c9f5 100644
--- a/include/boost/geometry/algorithms/detail/overlay/clip_linestring.hpp
+++ b/include/boost/geometry/algorithms/detail/overlay/clip_linestring.hpp
@@ -1,6 +1,11 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -160,10 +165,12 @@ template
     typename OutputLinestring,
     typename OutputIterator,
     typename Range,
+    typename RobustPolicy,
     typename Box,
     typename Strategy
 >
 OutputIterator clip_range_with_box(Box const& b, Range const& range,
+            RobustPolicy const&,
             OutputIterator out, Strategy const& strategy)
 {
     if (boost::begin(range) == boost::end(range))
diff --git a/include/boost/geometry/algorithms/detail/overlay/intersection_insert.hpp b/include/boost/geometry/algorithms/detail/overlay/intersection_insert.hpp
index 3101de8c3..5b9562674 100644
--- a/include/boost/geometry/algorithms/detail/overlay/intersection_insert.hpp
+++ b/include/boost/geometry/algorithms/detail/overlay/intersection_insert.hpp
@@ -1,9 +1,9 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
 
-// This file was modified by Oracle on 2014.
-// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+// This file was modified by Oracle on 2014, 2015.
+// Modifications copyright (c) 2014-2015 Oracle and/or its affiliates.
 
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 
@@ -42,6 +42,7 @@
 
 #include <boost/geometry/algorithms/detail/overlay/linear_linear.hpp>
 #include <boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp>
+#include <boost/geometry/algorithms/detail/overlay/pointlike_linear.hpp>
 
 #if defined(BOOST_GEOMETRY_DEBUG_FOLLOW)
 #include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
@@ -409,13 +410,13 @@ struct intersection_insert
     template <typename RobustPolicy, typename OutputIterator, typename Strategy>
     static inline OutputIterator apply(Linestring const& linestring,
             Box const& box,
-            RobustPolicy const& ,
+            RobustPolicy const& robust_policy,
             OutputIterator out, Strategy const& )
     {
         typedef typename point_type<GeometryOut>::type point_type;
         strategy::intersection::liang_barsky<Box, point_type> lb_strategy;
         return detail::intersection::clip_range_with_box
-            <GeometryOut>(box, linestring, out, lb_strategy);
+            <GeometryOut>(box, linestring, robust_policy, out, lb_strategy);
     }
 };
 
@@ -487,7 +488,7 @@ struct intersection_insert
     template <typename RobustPolicy, typename OutputIterator, typename Strategy>
     static inline OutputIterator apply(Segment const& segment,
             Box const& box,
-            RobustPolicy const& ,// TODO: propagate to clip_range_with_box
+            RobustPolicy const& robust_policy,
             OutputIterator out, Strategy const& )
     {
         geometry::segment_view<Segment> range(segment);
@@ -495,7 +496,7 @@ struct intersection_insert
         typedef typename point_type<GeometryOut>::type point_type;
         strategy::intersection::liang_barsky<Box, point_type> lb_strategy;
         return detail::intersection::clip_range_with_box
-            <GeometryOut>(box, range, out, lb_strategy);
+            <GeometryOut>(box, range, robust_policy, out, lb_strategy);
     }
 };
 
@@ -700,6 +701,79 @@ struct intersection_insert
 {};
 
 
+// dispatch for difference/intersection of pointlike-linear geometries
+template
+<
+    typename Point, typename Linear, typename PointOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut,
+    typename Tag
+>
+struct intersection_insert
+    <
+        Point, Linear, PointOut, OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        point_tag, Tag, point_tag,
+        false, false, false
+    > : detail_dispatch::overlay::pointlike_linear_point
+        <
+            Point, Linear, PointOut, OverlayType,
+            point_tag, typename tag_cast<Tag, segment_tag, linear_tag>::type
+        >
+{};
+
+
+template
+<
+    typename MultiPoint, typename Linear, typename PointOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut,
+    typename Tag
+>
+struct intersection_insert
+    <
+        MultiPoint, Linear, PointOut, OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        multi_point_tag, Tag, point_tag,
+        false, false, false
+    > : detail_dispatch::overlay::pointlike_linear_point
+        <
+            MultiPoint, Linear, PointOut, OverlayType,
+            multi_point_tag,
+            typename tag_cast<Tag, segment_tag, linear_tag>::type
+        >
+{};
+
+
+template
+<
+    typename Linestring, typename MultiPoint, typename PointOut,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Linestring, MultiPoint, PointOut, overlay_intersection,
+        Reverse1, Reverse2, ReverseOut,
+        linestring_tag, multi_point_tag, point_tag,
+        false, false, false
+    >
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Linestring const& linestring,
+                                       MultiPoint const& multipoint,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator out,
+                                       Strategy const& strategy)
+    {
+        return detail_dispatch::overlay::pointlike_linear_point
+            <
+                MultiPoint, Linestring, PointOut, overlay_intersection,
+                multi_point_tag, linear_tag
+            >::apply(multipoint, linestring, robust_policy, out, strategy);
+    }
+};
+
+
 } // namespace dispatch
 #endif // DOXYGEN_NO_DISPATCH
 
diff --git a/include/boost/geometry/algorithms/detail/overlay/pointlike_linear.hpp b/include/boost/geometry/algorithms/detail/overlay/pointlike_linear.hpp
new file mode 100644
index 000000000..bb42b4232
--- /dev/null
+++ b/include/boost/geometry/algorithms/detail/overlay/pointlike_linear.hpp
@@ -0,0 +1,344 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_LINEAR_HPP
+
+#include <iterator>
+#include <vector>
+
+#include <boost/assert.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+#include <boost/geometry/algorithms/disjoint.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/algorithms/detail/not.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+#include <boost/geometry/algorithms/detail/relate/less.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_geometry.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+// action struct for pointlike-linear difference/intersection
+// it works the same as its pointlike-pointlike counterpart, hence the
+// derivation
+template <typename PointOut, overlay_type OverlayType>
+struct action_selector_pl_l
+    : action_selector_pl_pl<PointOut, OverlayType>
+{};
+
+// difference/intersection of point-linear
+template
+<
+    typename Point,
+    typename Linear,
+    typename PointOut,
+    overlay_type OverlayType,
+    typename Policy
+>
+struct point_linear_point
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Point const& point,
+                                       Linear const& linear,
+                                       RobustPolicy const&,
+                                       OutputIterator oit,
+                                       Strategy const&)
+    {
+        action_selector_pl_l
+            <
+                PointOut, OverlayType
+            >::apply(point, Policy::apply(point, linear), oit);
+        return oit;
+    }
+};
+
+// difference/intersection of multipoint-segment
+template
+<
+    typename MultiPoint,
+    typename Segment,
+    typename PointOut,
+    overlay_type OverlayType,
+    typename Policy
+>
+struct multipoint_segment_point
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(MultiPoint const& multipoint,
+                                       Segment const& segment,
+                                       RobustPolicy const&,
+                                       OutputIterator oit,
+                                       Strategy const&)
+    {
+        for (typename boost::range_iterator<MultiPoint const>::type
+                 it = boost::begin(multipoint);
+             it != boost::end(multipoint);
+             ++it)
+        {
+            action_selector_pl_l
+                <
+                    PointOut, OverlayType
+                >::apply(*it, Policy::apply(*it, segment), oit);
+        }
+
+        return oit;
+    }
+};
+
+
+// difference/intersection of multipoint-linear
+template
+<
+    typename MultiPoint,
+    typename Linear,
+    typename PointOut,
+    overlay_type OverlayType,
+    typename Policy
+>
+class multipoint_linear_point
+{
+private:
+    // structs for partition -- start
+    struct expand_box
+    {
+        template <typename Box, typename Geometry>
+        static inline void apply(Box& total, Geometry const& geometry)
+        {
+            geometry::expand(total, geometry::return_envelope<Box>(geometry));
+        }
+
+    };
+
+    struct overlaps_box
+    {
+        template <typename Box, typename Geometry>
+        static inline bool apply(Box const& box, Geometry const& geometry)
+        {
+            return ! geometry::disjoint(geometry, box);
+        }
+    };
+
+    template <typename OutputIterator>
+    class item_visitor_type
+    {
+    public:
+        item_visitor_type(OutputIterator& oit) : m_oit(oit) {}
+
+        template <typename Item1, typename Item2>
+        inline void apply(Item1 const& item1, Item2 const& item2)
+        {
+            action_selector_pl_l
+                <
+                    PointOut, overlay_intersection
+                >::apply(item1, Policy::apply(item1, item2), m_oit);
+        }
+
+    private:
+        OutputIterator& m_oit;
+    };
+    // structs for partition -- end
+
+    class segment_range
+    {
+    public:
+        typedef geometry::segment_iterator<Linear const> const_iterator;
+        typedef const_iterator iterator;
+
+        segment_range(Linear const& linear)
+            : m_linear(linear)
+        {}
+
+        const_iterator begin() const
+        {
+            return geometry::segments_begin(m_linear);
+        }
+
+        const_iterator end() const
+        {
+            return geometry::segments_end(m_linear);
+        }
+
+    private:
+        Linear const& m_linear;
+    };
+
+    template <typename OutputIterator>
+    static inline OutputIterator get_common_points(MultiPoint const& multipoint,
+                                                   Linear const& linear,
+                                                   OutputIterator oit)
+    {
+        item_visitor_type<OutputIterator> item_visitor(oit);
+
+        segment_range rng(linear);
+
+        geometry::partition
+            <
+                geometry::model::box
+                    <
+                        typename boost::range_value<MultiPoint>::type
+                    >,
+                expand_box,
+                overlaps_box
+            >::apply(multipoint, rng, item_visitor);
+
+        return oit;
+    }
+
+public:
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(MultiPoint const& multipoint,
+                                       Linear const& linear,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator oit,
+                                       Strategy const& strategy)
+    {
+        typedef std::vector
+            <
+                typename boost::range_value<MultiPoint>::type
+            > point_vector_type;
+
+        point_vector_type common_points;
+
+        // compute the common points
+        get_common_points(multipoint, linear,
+                          std::back_inserter(common_points));
+
+        return multipoint_multipoint_point
+            <
+                MultiPoint, point_vector_type, PointOut, OverlayType
+            >::apply(multipoint, common_points, robust_policy, oit, strategy);
+    }
+};
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace detail_dispatch { namespace overlay
+{
+
+// dispatch struct for pointlike-linear difference/intersection computation
+template
+<
+    typename PointLike,
+    typename Linear,
+    typename PointOut,
+    overlay_type OverlayType,
+    typename Tag1,
+    typename Tag2
+>
+struct pointlike_linear_point
+    : not_implemented<PointLike, Linear, PointOut>
+{};
+
+
+template
+<
+    typename Point,
+    typename Linear,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_linear_point
+    <
+        Point, Linear, PointOut, OverlayType, point_tag, linear_tag
+    > : detail::overlay::point_linear_point
+        <
+            Point, Linear, PointOut, OverlayType,
+            detail::not_<detail::disjoint::reverse_covered_by>
+        >
+{};
+
+
+template
+<
+    typename Point,
+    typename Segment,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_linear_point
+    <
+        Point, Segment, PointOut, OverlayType, point_tag, segment_tag
+    > : detail::overlay::point_linear_point
+        <
+            Point, Segment, PointOut, OverlayType,
+            detail::not_<detail::disjoint::reverse_covered_by>
+        >
+{};
+
+
+template
+<
+    typename MultiPoint,
+    typename Linear,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_linear_point
+    <
+        MultiPoint, Linear, PointOut, OverlayType, multi_point_tag, linear_tag
+    > : detail::overlay::multipoint_linear_point
+        <
+            MultiPoint, Linear, PointOut, OverlayType,
+            detail::not_<detail::disjoint::reverse_covered_by>
+        >
+{};
+
+
+template
+<
+    typename MultiPoint,
+    typename Segment,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_linear_point
+    <
+        MultiPoint, Segment, PointOut, OverlayType, multi_point_tag, segment_tag
+    > : detail::overlay::multipoint_segment_point
+        <
+            MultiPoint, Segment, PointOut, OverlayType,
+            detail::not_<detail::disjoint::reverse_covered_by>
+        >
+{};
+
+
+}} // namespace detail_dispatch::overlay
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_LINEAR_HPP
diff --git a/include/boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp b/include/boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp
index 0af062d27..3e0641329 100644
--- a/include/boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp
+++ b/include/boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp
@@ -1,6 +1,6 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014, Oracle and/or its affiliates.
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
 
 // Licensed under the Boost Software License version 1.0.
 // http://www.boost.org/users/license.html
@@ -264,7 +264,7 @@ struct multipoint_multipoint_point
                 >::apply(multipoint2, multipoint1, robust_policy, oit, strategy);
         }
 
-        std::vector<typename point_type<MultiPoint2>::type>
+        std::vector<typename boost::range_value<MultiPoint2>::type>
             points2(boost::begin(multipoint2), boost::end(multipoint2));
 
         std::sort(points2.begin(), points2.end(), detail::relate::less());
diff --git a/include/boost/geometry/algorithms/detail/overlay/ring_properties.hpp b/include/boost/geometry/algorithms/detail/overlay/ring_properties.hpp
index b469052c8..0f2da67b6 100644
--- a/include/boost/geometry/algorithms/detail/overlay/ring_properties.hpp
+++ b/include/boost/geometry/algorithms/detail/overlay/ring_properties.hpp
@@ -29,6 +29,8 @@ struct ring_properties
     typedef Point point_type;
     typedef typename default_area_result<Point>::type area_type;
 
+    bool valid;
+
     // Filled by "select_rings"
     Point point;
     area_type area;
@@ -43,7 +45,8 @@ struct ring_properties
     std::vector<ring_identifier> children;
 
     inline ring_properties()
-        : area(area_type())
+        : valid(false)
+        , area(area_type())
         , reversed(false)
         , discarded(false)
         , parent_area(-1)
@@ -59,7 +62,7 @@ struct ring_properties
         // We should take a point somewhere in the middle of the ring,
         // to avoid taking a point on a (self)tangency,
         // in cases where multiple points come together
-        geometry::point_on_border(this->point, ring_or_box, true);
+        valid = geometry::point_on_border(this->point, ring_or_box, true);
     }
 
     inline area_type get_area() const
diff --git a/include/boost/geometry/algorithms/detail/relate/less.hpp b/include/boost/geometry/algorithms/detail/relate/less.hpp
index 3f11d4e87..462fcc35f 100644
--- a/include/boost/geometry/algorithms/detail/relate/less.hpp
+++ b/include/boost/geometry/algorithms/detail/relate/less.hpp
@@ -14,6 +14,10 @@
 #ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LESS_HPP
 #define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LESS_HPP
 
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/util/math.hpp>
+
 namespace boost { namespace geometry
 {
 
diff --git a/include/boost/geometry/algorithms/is_convex.hpp b/include/boost/geometry/algorithms/is_convex.hpp
new file mode 100644
index 000000000..8feb48db6
--- /dev/null
+++ b/include/boost/geometry/algorithms/is_convex.hpp
@@ -0,0 +1,160 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_IS_CONVEX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_IS_CONVEX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/iterators/ever_circling_iterator.hpp>
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/strategies/cartesian/side_by_triangle.hpp>
+#include <boost/geometry/views/detail/normalized_view.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_convex
+{
+
+struct ring_is_convex
+{
+    template <typename Ring>
+    static inline bool apply(Ring const& ring)
+    {
+        typedef typename geometry::point_type<Ring>::type point_type;
+        typedef typename strategy::side::services::default_strategy
+        <
+            typename cs_tag<point_type>::type
+        >::type side_strategy_type;
+
+        std::size_t n = boost::size(ring);
+        if (boost::size(ring) < core_detail::closure::minimum_ring_size
+                                    <
+                                        geometry::closure<Ring>::value
+                                    >::value)
+        {
+            // (Too) small rings are considered as non-concave, is convex
+            return true;
+        }
+
+        // Walk in clockwise direction, consider ring as closed
+        // (though closure is not important in this algorithm - any dupped
+        //  point is skipped)
+        typedef detail::normalized_view<Ring const> view_type;
+        view_type view(ring);
+
+        typedef geometry::ever_circling_range_iterator<view_type const> it_type;
+        it_type previous(view);
+        it_type current(view);
+        current++;
+
+        std::size_t index = 1;
+        while (equals::equals_point_point(*current, *previous) && index < n)
+        {
+            current++;
+            index++;
+        }
+
+        if (index == n)
+        {
+            // All points are apparently equal
+            return true;
+        }
+
+        it_type next = current;
+        next++;
+        while (equals::equals_point_point(*current, *next))
+        {
+            next++;
+        }
+
+        // We have now three different points on the ring
+        // Walk through all points, use a counter because of the ever-circling
+        // iterator
+        for (std::size_t i = 0; i < n; i++)
+        {
+            int const side = side_strategy_type::apply(*previous, *current, *next);
+            if (side == 1)
+            {
+                // Next is on the left side of clockwise ring:
+                // the piece is not convex
+                return false;
+            }
+
+            previous = current;
+            current = next;
+
+            // Advance next to next different point
+            // (because there are non-equal points, this loop is not infinite)
+            next++;
+            while (equals::equals_point_point(*current, *next))
+            {
+                next++;
+            }
+        }
+        return true;
+    }
+};
+
+
+}} // namespace detail::is_convex
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type
+>
+struct is_convex : not_implemented<Tag>
+{};
+
+template <typename Box>
+struct is_convex<Box, box_tag>
+{
+    static inline bool apply(Box const& )
+    {
+        // Any box is convex (TODO: consider spherical boxes)
+        return true;
+    }
+};
+
+template <typename Box>
+struct is_convex<Box, ring_tag> : detail::is_convex::ring_is_convex
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+// TODO: variants
+
+// TODO: documentation / qbk
+template<typename Geometry>
+inline bool is_convex(Geometry const& geometry)
+{
+    return dispatch::is_convex<Geometry>::apply(geometry);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_IS_CONVEX_HPP
diff --git a/include/boost/geometry/core/radian_access.hpp b/include/boost/geometry/core/radian_access.hpp
index bac77d7bc..374c2954a 100644
--- a/include/boost/geometry/core/radian_access.hpp
+++ b/include/boost/geometry/core/radian_access.hpp
@@ -1,8 +1,13 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
-// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
-// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 
 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
@@ -47,7 +52,8 @@ struct degree_radian_converter
         return boost::numeric_cast
             <
                 coordinate_type
-            >(geometry::get<Dimension>(geometry) * geometry::math::d2r);
+            >(geometry::get<Dimension>(geometry)
+              * math::d2r<coordinate_type>());
     }
 
     static inline void set(Geometry& geometry, coordinate_type const& radians)
@@ -55,7 +61,7 @@ struct degree_radian_converter
         geometry::set<Dimension>(geometry, boost::numeric_cast
             <
                 coordinate_type
-            >(radians * geometry::math::r2d));
+            >(radians * math::r2d<coordinate_type>()));
     }
 
 };
diff --git a/include/boost/geometry/extensions/gis/geographic/strategies/dms_parser.hpp b/include/boost/geometry/extensions/gis/geographic/strategies/dms_parser.hpp
index 884b4b072..5fb829c52 100644
--- a/include/boost/geometry/extensions/gis/geographic/strategies/dms_parser.hpp
+++ b/include/boost/geometry/extensions/gis/geographic/strategies/dms_parser.hpp
@@ -237,13 +237,16 @@ namespace strategy
             // Assign last one, if any
             process(dms, value, has_value);
 
+            double const d2r = math::d2r<double>();
+            double const r2d = math::r2d<double>();
+
             return dms_result(factor *
                 (in_radian && as_radian
                         ? dms.dms[0]
                 : in_radian && ! as_radian
-                        ? dms.dms[0] * math::r2d
+                        ? dms.dms[0] * r2d
                 : ! in_radian && as_radian
-                        ? dms.dms[0] * math::d2r + dms.dms[1] * math::d2r / 60.0 + dms.dms[2] * math::d2r / 3600.0
+                        ? dms.dms[0] * d2r + dms.dms[1] * d2r / 60.0 + dms.dms[2] * d2r / 3600.0
                         : dms.dms[0] + dms.dms[1] / 60.0 + dms.dms[2] / 3600.0)
                 , axis);
         }
diff --git a/include/boost/geometry/extensions/gis/projections/factory.hpp b/include/boost/geometry/extensions/gis/projections/factory.hpp
index b95aed82f..7ee221751 100644
--- a/include/boost/geometry/extensions/gis/projections/factory.hpp
+++ b/include/boost/geometry/extensions/gis/projections/factory.hpp
@@ -28,7 +28,7 @@
 #include <boost/geometry/extensions/gis/projections/proj/cass.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/cc.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/cea.hpp>
-#include <boost/geometry/extensions/gis/projections/proj/chamb.hpp>  // control points XY
+#include <boost/geometry/extensions/gis/projections/proj/chamb.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/collg.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/crast.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/denoy.hpp>
@@ -39,6 +39,7 @@
 #include <boost/geometry/extensions/gis/projections/proj/eck5.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/eqc.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/eqdc.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/etmerc.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/fahey.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/fouc_s.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/gall.hpp>
@@ -47,12 +48,14 @@
 #include <boost/geometry/extensions/gis/projections/proj/gins8.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/gn_sinu.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/gnom.hpp>
-#include <boost/geometry/extensions/gis/projections/proj/goode.hpp> // includes two other projections
+#include <boost/geometry/extensions/gis/projections/proj/goode.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/gstmerc.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/hammer.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/hatano.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/krovak.hpp>
-#include <boost/geometry/extensions/gis/projections/proj/imw_p.hpp> // xy functions after inverse
+#include <boost/geometry/extensions/gis/projections/proj/igh.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/imw_p.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/isea.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/laea.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/labrd.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/lagrng.hpp>
@@ -76,7 +79,7 @@
 #include <boost/geometry/extensions/gis/projections/proj/nocol.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/nsper.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/nzmg.hpp>
-#include <boost/geometry/extensions/gis/projections/proj/ob_tran.hpp> // includes other projection
+#include <boost/geometry/extensions/gis/projections/proj/ob_tran.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/ocea.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/oea.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/omerc.hpp>
@@ -161,6 +164,7 @@ public:
         detail::eck5_init(*this);
         detail::eqc_init(*this);
         detail::eqdc_init(*this);
+        detail::etmerc_init(*this);
         detail::fahey_init(*this);
         detail::fouc_s_init(*this);
         detail::gall_init(*this);
@@ -174,7 +178,9 @@ public:
         detail::hammer_init(*this);
         detail::hatano_init(*this);
         detail::krovak_init(*this);
+        detail::igh_init(*this);
         detail::imw_p_init(*this);
+        detail::isea_init(*this);
         detail::labrd_init(*this);
         detail::laea_init(*this);
         detail::lagrng_init(*this);
diff --git a/include/boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp b/include/boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp
index ff7eb5263..8ee12119a 100644
--- a/include/boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp
+++ b/include/boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp
@@ -11,7 +11,6 @@
 
 #include <string>
 
-#include <boost/concept_check.hpp>
 
 #include <boost/geometry/extensions/gis/projections/projection.hpp>
 
@@ -35,7 +34,9 @@ public:
 
     base_v_f(P const& params) : m_proj(params) {}
 
-    virtual P params() const {return m_proj.params();}
+    virtual P const& params() const { return m_proj.params(); }
+
+    virtual P& mutable_params() { return m_proj.mutable_params(); }
 
     virtual bool forward(LL const& ll, XY& xy) const
     {
@@ -47,20 +48,13 @@ public:
         m_proj.fwd(lp_lon, lp_lat, xy_x, xy_y);
     }
 
-    virtual bool inverse(XY const& xy, LL& ll) const
+    virtual bool inverse(XY const& , LL& ) const
     {
-        boost::ignore_unused_variable_warning(xy);
-        boost::ignore_unused_variable_warning(ll);
-
         // exception?
         return false;
     }
-    virtual void inv(XY_T& xy_x, XY_T& xy_y, LL_T& lp_lon, LL_T& lp_lat) const
+    virtual void inv(XY_T& , XY_T& , LL_T& , LL_T& ) const
     {
-        boost::ignore_unused_variable_warning(xy_x);
-        boost::ignore_unused_variable_warning(xy_y);
-        boost::ignore_unused_variable_warning(lp_lon);
-        boost::ignore_unused_variable_warning(lp_lat);
         // exception?
     }
 
diff --git a/include/boost/geometry/extensions/gis/projections/impl/base_static.hpp b/include/boost/geometry/extensions/gis/projections/impl/base_static.hpp
index 07d47382e..15e86aab3 100644
--- a/include/boost/geometry/extensions/gis/projections/impl/base_static.hpp
+++ b/include/boost/geometry/extensions/gis/projections/impl/base_static.hpp
@@ -41,7 +41,9 @@ public:
         : m_par(params), m_prj(prj)
     {}
 
-    inline P params() const {return m_par;}
+    inline P const& params() const { return m_par; }
+
+    inline P& mutable_params() { return m_par; }
 
     inline bool forward(LL const& lp, XY& xy) const
     {
diff --git a/include/boost/geometry/extensions/gis/projections/impl/pj_auth.hpp b/include/boost/geometry/extensions/gis/projections/impl/pj_auth.hpp
index f198cc51a..adcd3a16b 100644
--- a/include/boost/geometry/extensions/gis/projections/impl/pj_auth.hpp
+++ b/include/boost/geometry/extensions/gis/projections/impl/pj_auth.hpp
@@ -53,7 +53,7 @@ static const double P20 = .01641501294219154443;
 static const int APA_SIZE = 3;
 
 /* determine latitude from authalic latitude */
-inline void pj_authset(double es, double* APA)
+inline bool pj_authset(double es, double* APA)
 {
     BOOST_ASSERT(0 != APA);
 
@@ -70,6 +70,7 @@ inline void pj_authset(double es, double* APA)
         APA[1] += t * P11;
         APA[2] = t * P20;
     }
+    return true;
 }
 
 inline double pj_authlat(double beta, const double* APA)
diff --git a/include/boost/geometry/extensions/gis/projections/impl/pj_init.hpp b/include/boost/geometry/extensions/gis/projections/impl/pj_init.hpp
index 54e4b6c46..9234a6efa 100644
--- a/include/boost/geometry/extensions/gis/projections/impl/pj_init.hpp
+++ b/include/boost/geometry/extensions/gis/projections/impl/pj_init.hpp
@@ -71,7 +71,7 @@ namespace detail
 /*      large enough to hold projection specific parameters.            */
 /************************************************************************/
 template <typename R>
-parameters pj_init(R const& arguments, bool use_defaults = true)
+inline parameters pj_init(R const& arguments, bool use_defaults = true)
 {
     parameters pin;
     for (std::vector<std::string>::const_iterator it = boost::begin(arguments);
diff --git a/include/boost/geometry/extensions/gis/projections/impl/pj_inv.hpp b/include/boost/geometry/extensions/gis/projections/impl/pj_inv.hpp
index 2b4f0c147..d59bc2121 100644
--- a/include/boost/geometry/extensions/gis/projections/impl/pj_inv.hpp
+++ b/include/boost/geometry/extensions/gis/projections/impl/pj_inv.hpp
@@ -56,7 +56,7 @@ namespace inv
 
  /* inverse projection entry */
 template <typename PRJ, typename LL, typename XY, typename PAR>
-void pj_inv(PRJ const& prj, PAR const& par, XY const& xy, LL& ll)
+inline void pj_inv(PRJ const& prj, PAR const& par, XY const& xy, LL& ll)
 {
     /* can't do as much preliminary checking as with forward */
     /* descale and de-offset */
diff --git a/include/boost/geometry/extensions/gis/projections/impl/pj_mlfn.hpp b/include/boost/geometry/extensions/gis/projections/impl/pj_mlfn.hpp
index b5db34988..c4bbf266e 100644
--- a/include/boost/geometry/extensions/gis/projections/impl/pj_mlfn.hpp
+++ b/include/boost/geometry/extensions/gis/projections/impl/pj_mlfn.hpp
@@ -65,7 +65,7 @@ static const double EPS = 1e-11;
 static const int MAX_ITER = 10;
 static const int EN_SIZE = 5;
 
-inline void pj_enfn(double es, double* en)
+inline bool pj_enfn(double es, double* en)
 {
     double t; //, *en;
 
@@ -78,6 +78,7 @@ inline void pj_enfn(double es, double* en)
         en[4] = t * es * C88;
     }
     // return en;
+    return true;
 }
 
 inline double pj_mlfn(double phi, double sphi, double cphi, const double *en)
diff --git a/include/boost/geometry/extensions/gis/projections/impl/proj_mdist.hpp b/include/boost/geometry/extensions/gis/projections/impl/proj_mdist.hpp
index 562e513ce..9069b47b4 100644
--- a/include/boost/geometry/extensions/gis/projections/impl/proj_mdist.hpp
+++ b/include/boost/geometry/extensions/gis/projections/impl/proj_mdist.hpp
@@ -53,7 +53,7 @@ namespace detail
         double b[MDIST_MAX_ITER];
     };
 
-    inline void proj_mdist_ini(double es, MDIST& b)
+    inline bool proj_mdist_ini(double es, MDIST& b)
     {
         double numf, numfi, twon1, denf, denfi, ens, T, twon;
         double den, El, Es;
@@ -97,6 +97,7 @@ namespace detail
             numfi += 2.;
             denfi += 2.;
         }
+        return true;
     }
     inline double proj_mdist(double phi, double sphi, double cphi, const MDIST& b)
     {
diff --git a/include/boost/geometry/extensions/gis/projections/impl/projects.hpp b/include/boost/geometry/extensions/gis/projections/impl/projects.hpp
index eab7eba94..053594d1b 100644
--- a/include/boost/geometry/extensions/gis/projections/impl/projects.hpp
+++ b/include/boost/geometry/extensions/gis/projections/impl/projects.hpp
@@ -39,7 +39,6 @@
 #include <string>
 #include <vector>
 
-#include <boost/concept_check.hpp>
 #include <boost/math/constants/constants.hpp>
 
 namespace boost { namespace geometry { namespace projections
@@ -176,9 +175,12 @@ class proj_exception
 public:
 
     proj_exception(int code = 0)
+        : m_code(code)
     {
-        boost::ignore_unused_variable_warning(code);
     }
+    int code() const { return m_code; }
+private :
+    int m_code;
 };
 
 }}} // namespace boost::geometry::projections
diff --git a/include/boost/geometry/extensions/gis/projections/proj/aea.hpp b/include/boost/geometry/extensions/gis/projections/proj/aea.hpp
index 6aa65ccd2..0323fc217 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/aea.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/aea.hpp
@@ -38,23 +38,24 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/core/ignore_unused.hpp>
 #include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/pj_mlfn.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_msfn.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_qsfn.hpp>
-#include <boost/geometry/extensions/gis/projections/impl/pj_mlfn.hpp>
 
 #include <boost/geometry/extensions/gis/projections/epsg_traits.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace aea{
+    namespace detail { namespace aea
+    {
+
             static const double EPS10 = 1.e-10;
             static const double TOL7 = 1.e-7;
             static const int N_ITER = 15;
@@ -69,19 +70,14 @@ namespace boost { namespace geometry { namespace projections
                 double    dd;
                 double    n2;
                 double    rho0;
-                double    rho;
                 double    phi1;
                 double    phi2;
                 double    en[EN_SIZE];
                 int        ellips;
             };
 
-
-
-
-
             /* determine latitude angle phi-1 */
-                inline double
+                static double
             phi1_(double qs, double Te, double Tone_es) {
                 int i;
                 double Phi, sinpi, cospi, con, com, dphi;
@@ -112,7 +108,7 @@ namespace boost { namespace geometry { namespace projections
                  typedef double geographic_type;
                  typedef double cartesian_type;
 
-                mutable par_aea m_proj_parm;
+                par_aea m_proj_parm;
 
                 inline base_aea_ellipsoid(const Parameters& par)
                     : base_t_fi<base_aea_ellipsoid<Geographic, Cartesian, Parameters>,
@@ -120,22 +116,24 @@ namespace boost { namespace geometry { namespace projections
 
                 inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
                 {
-                    if ((this->m_proj_parm.rho = this->m_proj_parm.c - (this->m_proj_parm.ellips ? this->m_proj_parm.n * pj_qsfn(sin(lp_lat),
+                    double rho = 0.0;
+                    if ((rho = this->m_proj_parm.c - (this->m_proj_parm.ellips ? this->m_proj_parm.n * pj_qsfn(sin(lp_lat),
                         this->m_par.e, this->m_par.one_es) : this->m_proj_parm.n2 * sin(lp_lat))) < 0.) throw proj_exception();
-                    this->m_proj_parm.rho = this->m_proj_parm.dd * sqrt(this->m_proj_parm.rho);
-                    xy_x = this->m_proj_parm.rho * sin( lp_lon *= this->m_proj_parm.n );
-                    xy_y = this->m_proj_parm.rho0 - this->m_proj_parm.rho * cos(lp_lon);
+                    rho = this->m_proj_parm.dd * sqrt(rho);
+                    xy_x = rho * sin( lp_lon *= this->m_proj_parm.n );
+                    xy_y = this->m_proj_parm.rho0 - rho * cos(lp_lon);
                 }
 
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
                 {
-                    if( (this->m_proj_parm.rho = boost::math::hypot(xy_x, xy_y = this->m_proj_parm.rho0 - xy_y)) != 0.0 ) {
+                    double rho = 0.0;
+                    if( (rho = boost::math::hypot(xy_x, xy_y = this->m_proj_parm.rho0 - xy_y)) != 0.0 ) {
                         if (this->m_proj_parm.n < 0.) {
-                            this->m_proj_parm.rho = -this->m_proj_parm.rho;
+                            rho = -rho;
                             xy_x = -xy_x;
                             xy_y = -xy_y;
                         }
-                        lp_lat =  this->m_proj_parm.rho / this->m_proj_parm.dd;
+                        lp_lat =  rho / this->m_proj_parm.dd;
                         if (this->m_proj_parm.ellips) {
                             lp_lat = (this->m_proj_parm.c - lp_lat * lp_lat) / this->m_proj_parm.n;
                             if (fabs(this->m_proj_parm.ec - fabs(lp_lat)) > TOL7) {
@@ -153,26 +151,33 @@ namespace boost { namespace geometry { namespace projections
                         lp_lat = this->m_proj_parm.n > 0. ? HALFPI : - HALFPI;
                     }
                 }
+
+            private :
+                inline void ignore_unused()
+                {
+                    boost::ignore_unused(phi1_);
+                }
             };
 
             template <typename Parameters>
             void setup(Parameters& par, par_aea& proj_parm) 
             {
-                boost::ignore_unused(par);
-                boost::ignore_unused(proj_parm);
                 double cosphi, sinphi;
                 int secant;
+
                 if (fabs(proj_parm.phi1 + proj_parm.phi2) < EPS10) throw proj_exception(-21);
                 proj_parm.n = sinphi = sin(proj_parm.phi1);
                 cosphi = cos(proj_parm.phi1);
                 secant = fabs(proj_parm.phi1 - proj_parm.phi2) >= EPS10;
                 if( (proj_parm.ellips = (par.es > 0.))) {
                     double ml1, m1;
-                    pj_enfn(par.es, proj_parm.en);
+
+                    if (!pj_enfn(par.es, proj_parm.en)) throw proj_exception(0);
                     m1 = pj_msfn(sinphi, cosphi, par.es);
                     ml1 = pj_qsfn(sinphi, par.e, par.one_es);
                     if (secant) { /* secant cone */
                         double ml2, m2;
+
                         sinphi = sin(proj_parm.phi2);
                         cosphi = cos(proj_parm.phi2);
                         m2 = pj_msfn(sinphi, cosphi, par.es);
@@ -192,8 +197,6 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.dd = 1. / proj_parm.n;
                     proj_parm.rho0 = proj_parm.dd * sqrt(proj_parm.c - proj_parm.n2 * sin(par.phi0));
                 }
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
             }
 
 
@@ -228,7 +231,9 @@ namespace boost { namespace geometry { namespace projections
          - Conic
          - Spheroid
          - Ellipsoid
-         - lat_1= lat_2=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel (degrees)
+         - lat_2: Latitude of second standard parallel (degrees)
         \par Example
         \image html ex_aea.gif
     */
@@ -251,7 +256,9 @@ namespace boost { namespace geometry { namespace projections
          - Conic
          - Spheroid
          - Ellipsoid
-         - lat_1= south
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel (degrees)
+         - south: Denotes southern hemisphere UTM zone (boolean)
         \par Example
         \image html ex_leac.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/aeqd.hpp b/include/boost/geometry/extensions/gis/projections/proj/aeqd.hpp
index c8cbeb067..dbfa2d2f8 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/aeqd.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/aeqd.hpp
@@ -46,12 +46,13 @@
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_mlfn.hpp>
-#include <boost/geometry/extensions/gis/projections/impl/proj_mdist.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace aeqd{
+    namespace detail { namespace aeqd
+    {
+
             static const double EPS10 = 1.e-10;
             static const double TOL = 1.e-14;
             static const int N_POLE = 0;
@@ -72,11 +73,6 @@ namespace boost { namespace geometry { namespace projections
                 int        mode;
             };
 
-
-
-
-
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_aeqd_ellipsoid : public base_t_fi<base_aeqd_ellipsoid<Geographic, Cartesian, Parameters>,
@@ -319,14 +315,10 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.cosph0 = cos(par.phi0);
                 }
                 if (! par.es) {
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 } else {
-                    pj_enfn(par.es, proj_parm.en);
+                    if (!pj_enfn(par.es, proj_parm.en)) throw proj_exception(0);
                     if (pj_param(par.params, "bguam").i) {
                         proj_parm.M1 = pj_mlfn(par.phi0, proj_parm.sinph0, proj_parm.cosph0, proj_parm.en);
-                // par.inv = e_guam_inv;
-                // par.fwd = e_guam_fwd;
                     } else {
                         switch (proj_parm.mode) {
                         case N_POLE:
@@ -337,15 +329,11 @@ namespace boost { namespace geometry { namespace projections
                             break;
                         case EQUIT:
                         case OBLIQ:
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                             proj_parm.N1 = 1. / sqrt(1. - par.es * proj_parm.sinph0 * proj_parm.sinph0);
                             proj_parm.G = proj_parm.sinph0 * (proj_parm.He = par.e / sqrt(par.one_es));
                             proj_parm.He *= proj_parm.cosph0;
                             break;
                         }
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                     }
                 }
             }
@@ -363,7 +351,9 @@ namespace boost { namespace geometry { namespace projections
          - Azimuthal
          - Spheroid
          - Ellipsoid
-         - lat_0 guam
+        \par Projection parameters
+         - lat_0: Latitude of origin (degrees)
+         - guam (boolean)
         \par Example
         \image html ex_aeqd.gif
     */
@@ -386,7 +376,9 @@ namespace boost { namespace geometry { namespace projections
          - Azimuthal
          - Spheroid
          - Ellipsoid
-         - lat_0 guam
+        \par Projection parameters
+         - lat_0: Latitude of origin (degrees)
+         - guam (boolean)
         \par Example
         \image html ex_aeqd.gif
     */
@@ -409,7 +401,9 @@ namespace boost { namespace geometry { namespace projections
          - Azimuthal
          - Spheroid
          - Ellipsoid
-         - lat_0 guam
+        \par Projection parameters
+         - lat_0: Latitude of origin (degrees)
+         - guam (boolean)
         \par Example
         \image html ex_aeqd.gif
     */
@@ -433,12 +427,14 @@ namespace boost { namespace geometry { namespace projections
             public :
                 virtual projection<Geographic, Cartesian>* create_new(const Parameters& par) const
                 {
-                    if (! par.es)
-                        return new base_v_fi<aeqd_spheroid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
-                    else if (pj_param(par.params, "bguam").i)
+                    bool const guam = pj_param(par.params, "bguam").i;
+
+                    if (par.es && ! guam)
+                        return new base_v_fi<aeqd_ellipsoid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
+                    else if (par.es && guam)
                         return new base_v_fi<aeqd_guam<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
                     else
-                        return new base_v_fi<aeqd_ellipsoid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
+                        return new base_v_fi<aeqd_spheroid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
                 }
         };
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/airy.hpp b/include/boost/geometry/extensions/gis/projections/proj/airy.hpp
index c8c383599..0a144667b 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/airy.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/airy.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace airy{
+    namespace detail { namespace airy
+    {
+
             static const double EPS = 1.e-10;
             static const int N_POLE = 0;
             static const int S_POLE = 1;
@@ -65,10 +65,6 @@ namespace boost { namespace geometry { namespace projections
                 int        no_cut;    /* do not cut at hemisphere limit */
             };
 
-
-
-
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_airy_spheroid : public base_t_f<base_airy_spheroid<Geographic, Cartesian, Parameters>,
@@ -135,6 +131,7 @@ namespace boost { namespace geometry { namespace projections
             void setup_airy(Parameters& par, par_airy& proj_parm)
             {
                 double beta;
+
                 proj_parm.no_cut = pj_param(par.params, "bno_cut").i;
                 beta = 0.5 * (HALFPI - pj_param(par.params, "rlat_b").f);
                 if (fabs(beta) < EPS)
@@ -160,7 +157,6 @@ namespace boost { namespace geometry { namespace projections
                         proj_parm.cosph0 = cos(par.phi0);
                     }
                 }
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
@@ -177,7 +173,9 @@ namespace boost { namespace geometry { namespace projections
          - Miscellaneous
          - Spheroid
          - no inverse
-         - no_cut lat_b=
+        \par Projection parameters
+         - no_cut: Do not cut at hemisphere limit (boolean)
+         - lat_b (degrees)
         \par Example
         \image html ex_airy.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/aitoff.hpp b/include/boost/geometry/extensions/gis/projections/proj/aitoff.hpp
index 966c0e6f4..c3d205d1b 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/aitoff.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/aitoff.hpp
@@ -39,7 +39,6 @@
 
 
 #include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
@@ -49,7 +48,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace aitoff{
+    namespace detail { namespace aitoff
+    {
 
             struct par_aitoff
             {
@@ -57,11 +57,6 @@ namespace boost { namespace geometry { namespace projections
                 int        mode;
             };
 
-
-
-
-
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_aitoff_spheroid : public base_t_fi<base_aitoff_spheroid<Geographic, Cartesian, Parameters>,
@@ -90,9 +85,7 @@ namespace boost { namespace geometry { namespace projections
                         xy_x = (xy_x + lp_lon * this->m_proj_parm.cosphi1) * 0.5;
                         xy_y = (xy_y + lp_lat) * 0.5;
                     }
-                            return;
                 }
-
                 /***********************************************************************************
                 *
                 * Inverse functions added by Drazen Tutic and Lovro Gradiser based on paper:
@@ -114,7 +107,6 @@ namespace boost { namespace geometry { namespace projections
                 *
                 ************************************************************************************/
 
-
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
                 {
                         int iter, MAXITER = 10, round = 0, MAXROUND = 20;
@@ -171,19 +163,13 @@ namespace boost { namespace geometry { namespace projections
                     } while (((fabs(xy_x-x) > EPSILON) || (fabs(xy_y-y) > EPSILON)) && (round++ < MAXROUND));
 
                     if (iter == MAXITER && round == MAXROUND) fprintf(stderr, "Warning: Accuracy of 1e-12 not reached. Last increments: dlat=%e and dlon=%e\n", dp, dl);
-
-                            return;
                 }
-
             };
 
             template <typename Parameters>
             void setup(Parameters& par, par_aitoff& proj_parm) 
             {
-                boost::ignore_unused(par);
                 boost::ignore_unused(proj_parm);
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
@@ -244,7 +230,8 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Miscellaneous
          - Spheroid
-         - lat_1
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel (degrees)
         \par Example
         \image html ex_wintri.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/august.hpp b/include/boost/geometry/extensions/gis/projections/proj/august.hpp
index 6a88a2e3f..bfe2aad3a 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/august.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/august.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,9 +46,10 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace august{
-            static const double M = 1.333333333333333;
+    namespace detail { namespace august
+    {
 
+            static const double M = 1.333333333333333;
 
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
@@ -84,8 +83,6 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup_august(Parameters& par)
             {
-                // par.inv = 0;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/bacon.hpp b/include/boost/geometry/extensions/gis/projections/proj/bacon.hpp
index 402a22796..2723d5369 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/bacon.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/bacon.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace bacon{
+    namespace detail { namespace bacon
+    {
+
             static const double HLFPI2 = 2.46740110027233965467;
             static const double EPS = 1e-10;
 
@@ -97,7 +97,6 @@ namespace boost { namespace geometry { namespace projections
             {
                 proj_parm.bacn = proj_parm.ortl = 0;
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
             // Ortelius Oval
@@ -107,7 +106,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.bacn = 0;
                 proj_parm.ortl = 1;
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
             // Bacon Globular
@@ -117,7 +115,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.bacn = 1;
                 proj_parm.ortl = 0;
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::bacon
diff --git a/include/boost/geometry/extensions/gis/projections/proj/bipc.hpp b/include/boost/geometry/extensions/gis/projections/proj/bipc.hpp
index 048ef007b..04e760b9e 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/bipc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/bipc.hpp
@@ -48,7 +48,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace bipc{
+    namespace detail { namespace bipc
+    {
+
             static const double EPS = 1e-10;
             static const double EPS10 = 1e-10;
             static const double ONEEPS = 1.000000001;
@@ -197,8 +199,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_bipc(Parameters& par, par_bipc& proj_parm)
             {
                 proj_parm.noskew = pj_param(par.params, "bns").i;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
@@ -214,6 +214,8 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Conic
          - Spheroid
+        \par Projection parameters
+         - ns (boolean)
         \par Example
         \image html ex_bipc.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/boggs.hpp b/include/boost/geometry/extensions/gis/projections/proj/boggs.hpp
index 8ba33ab21..c9cf13b20 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/boggs.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/boggs.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace boggs{
+    namespace detail { namespace boggs
+    {
+
             static const int NITER = 20;
             static const double EPS = 1e-7;
             static const double ONETOL = 1.000001;
@@ -57,7 +57,6 @@ namespace boost { namespace geometry { namespace projections
             static const double FYC = 0.49931;
             static const double FYC2 = 1.41421356237309504880;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_boggs_spheroid : public base_t_f<base_boggs_spheroid<Geographic, Cartesian, Parameters>,
@@ -99,7 +98,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_boggs(Parameters& par)
             {
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::boggs
diff --git a/include/boost/geometry/extensions/gis/projections/proj/bonne.hpp b/include/boost/geometry/extensions/gis/projections/proj/bonne.hpp
index 40e0ae9d7..0d42a9ece 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/bonne.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/bonne.hpp
@@ -49,7 +49,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace bonne{
+    namespace detail { namespace bonne
+    {
+
             static const double EPS10 = 1e-10;
 
             struct par_bonne
@@ -148,6 +150,7 @@ namespace boost { namespace geometry { namespace projections
             void setup_bonne(Parameters& par, par_bonne& proj_parm)
             {
                 double c;
+
                 proj_parm.phi1 = pj_param(par.params, "rlat_1").f;
                 if (fabs(proj_parm.phi1) < EPS10) throw proj_exception(-23);
                 if (par.es) {
@@ -155,15 +158,11 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.m1 = pj_mlfn(proj_parm.phi1, proj_parm.am1 = sin(proj_parm.phi1),
                         c = cos(proj_parm.phi1), proj_parm.en);
                     proj_parm.am1 = c / (sqrt(1. - par.es * proj_parm.am1 * proj_parm.am1) * proj_parm.am1);
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                 } else {
                     if (fabs(proj_parm.phi1) + EPS10 >= HALFPI)
                         proj_parm.cphi1 = 0.;
                     else
                         proj_parm.cphi1 = 1. / tan(proj_parm.phi1);
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 }
             }
 
@@ -180,7 +179,8 @@ namespace boost { namespace geometry { namespace projections
          - Conic
          - Spheroid
          - Ellipsoid
-         - lat_1=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel (degrees)
         \par Example
         \image html ex_bonne.gif
     */
@@ -203,7 +203,8 @@ namespace boost { namespace geometry { namespace projections
          - Conic
          - Spheroid
          - Ellipsoid
-         - lat_1=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel (degrees)
         \par Example
         \image html ex_bonne.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/cass.hpp b/include/boost/geometry/extensions/gis/projections/proj/cass.hpp
index 037476abf..bb4a43394 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/cass.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/cass.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -51,7 +49,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace cass{
+    namespace detail { namespace cass
+    {
+
             static const double EPS10 = 1e-10;
             static const double C1 = .16666666666666666666;
             static const double C2 = .00833333333333333333;
@@ -62,15 +62,6 @@ namespace boost { namespace geometry { namespace projections
             struct par_cass
             {
                 double m0;
-                double n;
-                double t;
-                double a1;
-                double c;
-                double r;
-                double dd;
-                double d2;
-                double a2;
-                double tn;
                 double en[EN_SIZE];
             };
 
@@ -83,7 +74,7 @@ namespace boost { namespace geometry { namespace projections
                  typedef double geographic_type;
                  typedef double cartesian_type;
 
-                mutable par_cass m_proj_parm;
+                par_cass m_proj_parm;
 
                 inline base_cass_ellipsoid(const Parameters& par)
                     : base_t_fi<base_cass_ellipsoid<Geographic, Cartesian, Parameters>,
@@ -91,16 +82,18 @@ namespace boost { namespace geometry { namespace projections
 
                 inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
                 {
-                    xy_y = pj_mlfn(lp_lat, this->m_proj_parm.n = sin(lp_lat), this->m_proj_parm.c = cos(lp_lat), this->m_proj_parm.en);
-                    this->m_proj_parm.n = 1./sqrt(1. - this->m_par.es * this->m_proj_parm.n * this->m_proj_parm.n);
-                    this->m_proj_parm.tn = tan(lp_lat); this->m_proj_parm.t = this->m_proj_parm.tn * this->m_proj_parm.tn;
-                    this->m_proj_parm.a1 = lp_lon * this->m_proj_parm.c;
-                    this->m_proj_parm.c *= this->m_par.es * this->m_proj_parm.c / (1 - this->m_par.es);
-                    this->m_proj_parm.a2 = this->m_proj_parm.a1 * this->m_proj_parm.a1;
-                    xy_x = this->m_proj_parm.n * this->m_proj_parm.a1 * (1. - this->m_proj_parm.a2 * this->m_proj_parm.t *
-                        (C1 - (8. - this->m_proj_parm.t + 8. * this->m_proj_parm.c) * this->m_proj_parm.a2 * C2));
-                    xy_y -= this->m_proj_parm.m0 - this->m_proj_parm.n * this->m_proj_parm.tn * this->m_proj_parm.a2 *
-                        (.5 + (5. - this->m_proj_parm.t + 6. * this->m_proj_parm.c) * this->m_proj_parm.a2 * C3);
+                    double n = sin(lp_lat);
+                    double c = cos(lp_lat);
+                    xy_y = pj_mlfn(lp_lat, n, c, this->m_proj_parm.en);
+                    n = 1./sqrt(1. - this->m_par.es * n * n);
+                    double tn = tan(lp_lat); double t = tn * tn;
+                    double a1 = lp_lon * c;
+                    c *= this->m_par.es * c / (1 - this->m_par.es);
+                    double a2 = a1 * a1;
+                    xy_x = n * a1 * (1. - a2 * t *
+                        (C1 - (8. - t + 8. * c) * a2 * C2));
+                    xy_y -= this->m_proj_parm.m0 - n * tn * a2 *
+                        (.5 + (5. - t + 6. * c) * a2 * C3);
                 }
 
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
@@ -108,17 +101,17 @@ namespace boost { namespace geometry { namespace projections
                     double ph1;
 
                     ph1 = pj_inv_mlfn(this->m_proj_parm.m0 + xy_y, this->m_par.es, this->m_proj_parm.en);
-                    this->m_proj_parm.tn = tan(ph1); this->m_proj_parm.t = this->m_proj_parm.tn * this->m_proj_parm.tn;
-                    this->m_proj_parm.n = sin(ph1);
-                    this->m_proj_parm.r = 1. / (1. - this->m_par.es * this->m_proj_parm.n * this->m_proj_parm.n);
-                    this->m_proj_parm.n = sqrt(this->m_proj_parm.r);
-                    this->m_proj_parm.r *= (1. - this->m_par.es) * this->m_proj_parm.n;
-                    this->m_proj_parm.dd = xy_x / this->m_proj_parm.n;
-                    this->m_proj_parm.d2 = this->m_proj_parm.dd * this->m_proj_parm.dd;
-                    lp_lat = ph1 - (this->m_proj_parm.n * this->m_proj_parm.tn / this->m_proj_parm.r) * this->m_proj_parm.d2 *
-                        (.5 - (1. + 3. * this->m_proj_parm.t) * this->m_proj_parm.d2 * C3);
-                    lp_lon = this->m_proj_parm.dd * (1. + this->m_proj_parm.t * this->m_proj_parm.d2 *
-                        (-C4 + (1. + 3. * this->m_proj_parm.t) * this->m_proj_parm.d2 * C5)) / cos(ph1);
+                    double tn = tan(ph1); double t = tn * tn;
+                    double n = sin(ph1);
+                    double r = 1. / (1. - this->m_par.es * n * n);
+                    n = sqrt(r);
+                    r *= (1. - this->m_par.es) * n;
+                    double dd = xy_x / n;
+                    double d2 = dd * dd;
+                    lp_lat = ph1 - (n * tn / r) * d2 *
+                        (.5 - (1. + 3. * t) * d2 * C3);
+                    lp_lon = dd * (1. + t * d2 *
+                        (-C4 + (1. + 3. * t) * d2 * C5)) / cos(ph1);
                 }
             };
 
@@ -131,7 +124,7 @@ namespace boost { namespace geometry { namespace projections
                  typedef double geographic_type;
                  typedef double cartesian_type;
 
-                mutable par_cass m_proj_parm;
+                par_cass m_proj_parm;
 
                 inline base_cass_spheroid(const Parameters& par)
                     : base_t_fi<base_cass_spheroid<Geographic, Cartesian, Parameters>,
@@ -145,8 +138,9 @@ namespace boost { namespace geometry { namespace projections
 
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
                 {
-                    lp_lat = asin(sin(this->m_proj_parm.dd = xy_y + this->m_par.phi0) * cos(xy_x));
-                    lp_lon = atan2(tan(xy_x), cos(this->m_proj_parm.dd));
+                    double dd = xy_y + this->m_par.phi0;
+                    lp_lat = asin(sin(dd) * cos(xy_x));
+                    lp_lon = atan2(tan(xy_x), cos(dd));
                 }
             };
 
@@ -155,13 +149,9 @@ namespace boost { namespace geometry { namespace projections
             void setup_cass(Parameters& par, par_cass& proj_parm)
             {
                 if (par.es) {
-                    pj_enfn(par.es, proj_parm.en);
+                    if (!pj_enfn(par.es, proj_parm.en)) throw proj_exception(0);
                     proj_parm.m0 = pj_mlfn(par.phi0, sin(par.phi0), cos(par.phi0), proj_parm.en);
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                 } else {
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 }
             }
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/cc.hpp b/include/boost/geometry/extensions/gis/projections/proj/cc.hpp
index 0b491abe2..bd8b20593 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/cc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/cc.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace cc{
+    namespace detail { namespace cc
+    {
+
             static const double EPS10 = 1.e-10;
 
             struct par_cc
@@ -90,8 +90,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_cc(Parameters& par, par_cc& proj_parm)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::cc
diff --git a/include/boost/geometry/extensions/gis/projections/proj/cea.hpp b/include/boost/geometry/extensions/gis/projections/proj/cea.hpp
index 741ad4426..20b5459a5 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/cea.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/cea.hpp
@@ -38,19 +38,19 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
-#include <boost/geometry/extensions/gis/projections/impl/pj_qsfn.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_auth.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/pj_qsfn.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace cea{
+    namespace detail { namespace cea
+    {
+
             static const double EPS = 1e-10;
 
             struct par_cea
@@ -127,6 +127,7 @@ namespace boost { namespace geometry { namespace projections
             void setup_cea(Parameters& par, par_cea& proj_parm)
             {
                 double t = 0;
+
                 if (pj_param(par.params, "tlat_ts").i &&
                     (par.k0 = cos(t = pj_param(par.params, "rlat_ts").f)) < 0.)
                   throw proj_exception(-24);
@@ -134,13 +135,9 @@ namespace boost { namespace geometry { namespace projections
                     t = sin(t);
                     par.k0 /= sqrt(1. - par.es * t * t);
                     par.e = sqrt(par.es);
-                    pj_authset(par.es, proj_parm.apa);
+                    if (!pj_authset(par.es, proj_parm.apa)) throw proj_exception(0);
                     proj_parm.qp = pj_qsfn(1., par.e, par.one_es);
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                 } else {
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 }
             }
 
@@ -157,7 +154,8 @@ namespace boost { namespace geometry { namespace projections
          - Cylindrical
          - Spheroid
          - Ellipsoid
-         - lat_ts=
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
         \par Example
         \image html ex_cea.gif
     */
@@ -180,7 +178,8 @@ namespace boost { namespace geometry { namespace projections
          - Cylindrical
          - Spheroid
          - Ellipsoid
-         - lat_ts=
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
         \par Example
         \image html ex_cea.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/chamb.hpp b/include/boost/geometry/extensions/gis/projections/proj/chamb.hpp
index 5f7949637..3675f5759 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/chamb.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/chamb.hpp
@@ -40,8 +40,6 @@
 
 #include <cstdio>
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -51,12 +49,15 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace chamb{
+    namespace detail { namespace chamb
+    {
+
             static const double THIRD = 0.333333333333333333;
             static const double TOL = 1e-9;
 
+            // specific for 'chamb'
             struct VECT { double r, Az; };
-            struct CXY { double x, y; }; // x/y for chamb
+            struct XY { double x, y; };
 
             struct par_chamb
             {
@@ -64,13 +65,14 @@ namespace boost { namespace geometry { namespace projections
                 double phi, lam;
                 double cosphi, sinphi;
                 VECT v;
-                CXY    p;
+                XY    p;
                 double Az;
                 } c[3];
-                CXY p;
+                XY p;
                 double beta_0, beta_1, beta_2;
             };
-                inline VECT /* distance and azimuth from point 1 to point 2 */
+
+                static VECT /* distance and azimuth from point 1 to point 2 */
             vect(double dphi, double c1, double s1, double c2, double s2, double dlam) {
                 VECT v;
                 double cdl, dp, dl;
@@ -89,7 +91,7 @@ namespace boost { namespace geometry { namespace projections
                     v.r = v.Az = 0.;
                 return v;
             }
-                inline double /* law of cosines */
+                static double /* law of cosines */
             lc(double b,double c,double a) {
                 return aacos(.5 * (b * b + c * c - a * a) / (b * c));
             }
@@ -158,9 +160,8 @@ namespace boost { namespace geometry { namespace projections
             {
                 int i, j;
                 char line[10];
-                for (i = 0;
-             i < 3;
-             ++i) { /* get control point locations */
+
+                for (i = 0; i < 3; ++i) { /* get control point locations */
                     (void)sprintf(line, "rlat_%d", i+1);
                     proj_parm.c[i].phi = pj_param(par.params, line).f;
                     (void)sprintf(line, "rlon_%d", i+1);
@@ -169,9 +170,7 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.c[i].cosphi = cos(proj_parm.c[i].phi);
                     proj_parm.c[i].sinphi = sin(proj_parm.c[i].phi);
                 }
-                for (i = 0;
-             i < 3;
-             ++i) { /* inter ctl pt. distances and azimuths */
+                for (i = 0; i < 3; ++i) { /* inter ctl pt. distances and azimuths */
                     j = i == 2 ? 0 : i + 1;
                     proj_parm.c[i].v = vect(proj_parm.c[j].phi - proj_parm.c[i].phi, proj_parm.c[i].cosphi, proj_parm.c[i].sinphi,
                         proj_parm.c[j].cosphi, proj_parm.c[j].sinphi, proj_parm.c[j].lam - proj_parm.c[i].lam);
@@ -186,7 +185,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.c[0].p.x = - (proj_parm.c[1].p.x = 0.5 * proj_parm.c[0].v.r);
                 proj_parm.p.x = proj_parm.c[2].p.x = proj_parm.c[0].p.x + proj_parm.c[2].v.r * cos(proj_parm.beta_0);
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::chamb
@@ -202,7 +200,13 @@ namespace boost { namespace geometry { namespace projections
          - Miscellaneous
          - Spheroid
          - no inverse
-         - lat_1= lon_1= lat_2= lon_2= lat_3= lon_3=
+        \par Projection parameters
+         - lat_1: Latitude of control point 1 (degrees)
+         - lon_1: Longitude of control point 1 (degrees)
+         - lat_2: Latitude of control point 2 (degrees)
+         - lon_2: Longitude of control point 2 (degrees)
+         - lat_3: Latitude of control point 3 (degrees)
+         - lon_3: Longitude of control point 3 (degrees)
         \par Example
         \image html ex_chamb.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/collg.hpp b/include/boost/geometry/extensions/gis/projections/proj/collg.hpp
index 0358e0648..3988b6ad1 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/collg.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/collg.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,12 +46,13 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace collg{
+    namespace detail { namespace collg
+    {
+
             static const double FXC = 1.12837916709551257390;
             static const double FYC = 1.77245385090551602729;
             static const double ONEEPS = 1.0000001;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_collg_spheroid : public base_t_fi<base_collg_spheroid<Geographic, Cartesian, Parameters>,
@@ -97,8 +96,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_collg(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::collg
diff --git a/include/boost/geometry/extensions/gis/projections/proj/crast.hpp b/include/boost/geometry/extensions/gis/projections/proj/crast.hpp
index ba1a581f8..a2602460b 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/crast.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/crast.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,14 +46,15 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace crast{
+    namespace detail { namespace crast
+    {
+
             static const double XM = 0.97720502380583984317;
             static const double RXM = 1.02332670794648848847;
             static const double YM = 3.06998012383946546542;
             static const double RYM = 0.32573500793527994772;
             static const double THIRD = 0.333333333333333333;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_crast_spheroid : public base_t_fi<base_crast_spheroid<Geographic, Cartesian, Parameters>,
@@ -89,8 +88,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_crast(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::crast
diff --git a/include/boost/geometry/extensions/gis/projections/proj/denoy.hpp b/include/boost/geometry/extensions/gis/projections/proj/denoy.hpp
index 11c1d97a3..d96e505c3 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/denoy.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/denoy.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,14 +46,15 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace denoy{
+    namespace detail { namespace denoy
+    {
+
             static const double C0 = 0.95;
             static const double C1 = -.08333333333333333333;
             static const double C3 = .00166666666666666666;
             static const double D1 = 0.9;
             static const double D5 = 0.03;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_denoy_spheroid : public base_t_f<base_denoy_spheroid<Geographic, Cartesian, Parameters>,
@@ -85,7 +84,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_denoy(Parameters& par)
             {
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::denoy
diff --git a/include/boost/geometry/extensions/gis/projections/proj/eck1.hpp b/include/boost/geometry/extensions/gis/projections/proj/eck1.hpp
index 1acb1e6d5..5654addbf 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/eck1.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/eck1.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,11 +46,12 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace eck1{
+    namespace detail { namespace eck1
+    {
+
             static const double FC = .92131773192356127802;
             static const double RP = .31830988618379067154;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_eck1_spheroid : public base_t_fi<base_eck1_spheroid<Geographic, Cartesian, Parameters>,
@@ -85,8 +84,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_eck1(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::eck1
diff --git a/include/boost/geometry/extensions/gis/projections/proj/eck2.hpp b/include/boost/geometry/extensions/gis/projections/proj/eck2.hpp
index 22f56a403..6caa30254 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/eck2.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/eck2.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,13 +46,14 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace eck2{
+    namespace detail { namespace eck2
+    {
+
             static const double FXC = 0.46065886596178063902;
             static const double FYC = 1.44720250911653531871;
             static const double C13 = 0.33333333333333333333;
             static const double ONEEPS = 1.0000001;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_eck2_spheroid : public base_t_fi<base_eck2_spheroid<Geographic, Cartesian, Parameters>,
@@ -96,8 +95,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_eck2(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::eck2
diff --git a/include/boost/geometry/extensions/gis/projections/proj/eck3.hpp b/include/boost/geometry/extensions/gis/projections/proj/eck3.hpp
index e9d9caf0e..cae3d8c9d 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/eck3.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/eck3.hpp
@@ -39,7 +39,6 @@
 
 
 #include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
@@ -49,7 +48,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace eck3{
+    namespace detail { namespace eck3
+    {
 
             struct par_eck3
             {
@@ -87,11 +87,8 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_eck3& proj_parm) 
             {
-                boost::ignore_unused(par);
                 boost::ignore_unused(proj_parm);
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/eck4.hpp b/include/boost/geometry/extensions/gis/projections/proj/eck4.hpp
index f118e3347..120d8a48e 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/eck4.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/eck4.hpp
@@ -38,17 +38,18 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace eck4{
+    namespace detail { namespace eck4
+    {
+
             static const double C_x = .42223820031577120149;
             static const double C_y = 1.32650042817700232218;
             static const double RC_y = .75386330736002178205;
@@ -57,7 +58,6 @@ namespace boost { namespace geometry { namespace projections
             static const double EPS = 1e-7;
             static const int NITER = 6;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_eck4_spheroid : public base_t_fi<base_eck4_spheroid<Geographic, Cartesian, Parameters>,
@@ -112,8 +112,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_eck4(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::eck4
diff --git a/include/boost/geometry/extensions/gis/projections/proj/eck5.hpp b/include/boost/geometry/extensions/gis/projections/proj/eck5.hpp
index e9b12f7bc..a52c22b75 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/eck5.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/eck5.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,13 +46,14 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace eck5{
+    namespace detail { namespace eck5
+    {
+
             static const double XF = 0.44101277172455148219;
             static const double RXF = 2.26750802723822639137;
             static const double YF = 0.88202554344910296438;
             static const double RYF = 1.13375401361911319568;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_eck5_spheroid : public base_t_fi<base_eck5_spheroid<Geographic, Cartesian, Parameters>,
@@ -86,8 +85,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_eck5(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::eck5
diff --git a/include/boost/geometry/extensions/gis/projections/proj/eqc.hpp b/include/boost/geometry/extensions/gis/projections/proj/eqc.hpp
index f7c831468..762622b04 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/eqc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/eqc.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace eqc{
+    namespace detail { namespace eqc
+    {
 
             struct par_eqc
             {
@@ -88,8 +87,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_eqc(Parameters& par, par_eqc& proj_parm)
             {
                 if ((proj_parm.rc = cos(pj_param(par.params, "rlat_ts").f)) <= 0.) throw proj_exception(-24);
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
@@ -105,8 +102,9 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Cylindrical
          - Spheroid
-         - lat_ts=[
-         - lat_0=0]
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
+         - lat_0: Latitude of origin
         \par Example
         \image html ex_eqc.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/eqdc.hpp b/include/boost/geometry/extensions/gis/projections/proj/eqdc.hpp
index 70dec1580..05a4db36b 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/eqdc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/eqdc.hpp
@@ -44,13 +44,15 @@
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
-#include <boost/geometry/extensions/gis/projections/impl/pj_msfn.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_mlfn.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/pj_msfn.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace eqdc{
+    namespace detail { namespace eqdc
+    {
+
             static const double EPS10 = 1.e-10;
 
             struct par_eqdc
@@ -58,7 +60,6 @@ namespace boost { namespace geometry { namespace projections
                 double phi1;
                 double phi2;
                 double n;
-                double rho;
                 double rho0;
                 double c;
                 double en[EN_SIZE];
@@ -74,7 +75,7 @@ namespace boost { namespace geometry { namespace projections
                  typedef double geographic_type;
                  typedef double cartesian_type;
 
-                mutable par_eqdc m_proj_parm;
+                par_eqdc m_proj_parm;
 
                 inline base_eqdc_ellipsoid(const Parameters& par)
                     : base_t_fi<base_eqdc_ellipsoid<Geographic, Cartesian, Parameters>,
@@ -82,21 +83,23 @@ namespace boost { namespace geometry { namespace projections
 
                 inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
                 {
-                    this->m_proj_parm.rho = this->m_proj_parm.c - (this->m_proj_parm.ellips ? pj_mlfn(lp_lat, sin(lp_lat),
+                    double rho = 0.0;
+                    rho = this->m_proj_parm.c - (this->m_proj_parm.ellips ? pj_mlfn(lp_lat, sin(lp_lat),
                         cos(lp_lat), this->m_proj_parm.en) : lp_lat);
-                    xy_x = this->m_proj_parm.rho * sin( lp_lon *= this->m_proj_parm.n );
-                    xy_y = this->m_proj_parm.rho0 - this->m_proj_parm.rho * cos(lp_lon);
+                    xy_x = rho * sin( lp_lon *= this->m_proj_parm.n );
+                    xy_y = this->m_proj_parm.rho0 - rho * cos(lp_lon);
                 }
 
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
                 {
-                    if ((this->m_proj_parm.rho = boost::math::hypot(xy_x, xy_y = this->m_proj_parm.rho0 - xy_y)) != 0.0 ) {
+                    double rho = 0.0;
+                    if ((rho = boost::math::hypot(xy_x, xy_y = this->m_proj_parm.rho0 - xy_y)) != 0.0 ) {
                         if (this->m_proj_parm.n < 0.) {
-                            this->m_proj_parm.rho = -this->m_proj_parm.rho;
+                            rho = -rho;
                             xy_x = -xy_x;
                             xy_y = -xy_y;
                         }
-                        lp_lat = this->m_proj_parm.c - this->m_proj_parm.rho;
+                        lp_lat = this->m_proj_parm.c - rho;
                         if (this->m_proj_parm.ellips)
                             lp_lat = pj_inv_mlfn(lp_lat, this->m_par.es, this->m_proj_parm.en);
                         lp_lon = atan2(xy_x, xy_y) / this->m_proj_parm.n;
@@ -127,16 +130,18 @@ namespace boost { namespace geometry { namespace projections
             {
                 double cosphi, sinphi;
                 int secant;
+
                 proj_parm.phi1 = pj_param(par.params, "rlat_1").f;
                 proj_parm.phi2 = pj_param(par.params, "rlat_2").f;
                 if (fabs(proj_parm.phi1 + proj_parm.phi2) < EPS10) throw proj_exception(-21);
-                    pj_enfn(par.es, proj_parm.en);
-
+                if (!pj_enfn(par.es, proj_parm.en))
+                    throw proj_exception(0);
                 proj_parm.n = sinphi = sin(proj_parm.phi1);
                 cosphi = cos(proj_parm.phi1);
                 secant = fabs(proj_parm.phi1 - proj_parm.phi2) >= EPS10;
                 if( (proj_parm.ellips = (par.es > 0.)) ) {
                     double ml1, m1;
+
                     m1 = pj_msfn(sinphi, cosphi, par.es);
                     ml1 = pj_mlfn(proj_parm.phi1, sinphi, cosphi, proj_parm.en);
                     if (secant) { /* secant cone */
@@ -154,9 +159,6 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.c = proj_parm.phi1 + cos(proj_parm.phi1) / proj_parm.n;
                     proj_parm.rho0 = proj_parm.c - par.phi0;
                 }
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
-                // par.spc = fac;
             }
 
         }} // namespace detail::eqdc
@@ -172,7 +174,9 @@ namespace boost { namespace geometry { namespace projections
          - Conic
          - Spheroid
          - Ellipsoid
-         - lat_1= lat_2=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel (degrees)
+         - lat_2: Latitude of second standard parallel (degrees)
         \par Example
         \image html ex_eqdc.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/etmerc.hpp b/include/boost/geometry/extensions/gis/projections/proj/etmerc.hpp
new file mode 100644
index 000000000..6c16627da
--- /dev/null
+++ b/include/boost/geometry/extensions/gis/projections/proj/etmerc.hpp
@@ -0,0 +1,359 @@
+#ifndef BOOST_GEOMETRY_PROJECTIONS_ETMERC_HPP
+#define BOOST_GEOMETRY_PROJECTIONS_ETMERC_HPP
+
+// Boost.Geometry - extensions-gis-projections (based on PROJ4)
+// This file is automatically generated. DO NOT EDIT.
+
+// Copyright (c) 2008-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// This file is converted from PROJ4, http://trac.osgeo.org/proj
+// PROJ4 is originally written by Gerald Evenden (then of the USGS)
+// PROJ4 is maintained by Frank Warmerdam
+// PROJ4 is converted to Boost.Geometry by Barend Gehrels
+
+// Last updated version of proj: 4.9.1
+
+// Original copyright notice:
+ 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+
+#include <boost/math/special_functions/hypot.hpp>
+
+#include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+
+namespace boost { namespace geometry { namespace projections
+{
+    #ifndef DOXYGEN_NO_DETAIL
+    namespace detail { namespace etmerc
+    {
+
+            static const int PROJ_ETMERC_ORDER = 6;
+
+            struct par_etmerc
+            {
+                double    Qn;    /* Merid. quad., scaled to the projection */
+                double    Zb;    /* Radius vector in polar coord. systems  */
+                double    cgb[6]; /* Constants for Gauss -> Geo lat */
+                double    cbg[6]; /* Constants for Geo lat -> Gauss */
+                double    utg[6]; /* Constants for transv. merc. -> geo */
+                double    gtu[6]; /* Constants for geo -> transv. merc. */
+            };
+
+            /* The code in this file is largly based upon procedures:
+             *
+             * Written by: Knud Poder and Karsten Engsager
+             *
+             * Based on math from: R.Koenig and K.H. Weise, "Mathematische
+             * Grundlagen der hoeheren Geodaesie und Kartographie,
+             * Springer-Verlag, Berlin/Goettingen" Heidelberg, 1951.
+             *
+             * Modified and used here by permission of Reference Networks
+             * Division, Kort og Matrikelstyrelsen (KMS), Copenhagen, Denmark
+            */
+
+
+
+
+
+
+                static double
+            log1py(double x) {              /* Compute log(1+x) accurately */
+                volatile double
+                  y = 1 + x,
+                  z = y - 1;
+                /* Here's the explanation for this magic: y = 1 + z, exactly, and z
+                 * approx x, thus log(y)/z (which is nearly constant near z = 0) returns
+                 * a good approximation to the true log(1 + x)/x.  The multiplication x *
+                 * (log(y)/z) introduces little additional error. */
+                return z == 0 ? x : x * log(y) / z;
+            }
+
+                static double
+            asinhy(double x) {              /* Compute asinh(x) accurately */
+                double y = fabs(x);         /* Enforce odd parity */
+                y = log1py(y * (1 + y/(boost::math::hypot(1.0, y) + 1)));
+                return x < 0 ? -y : y;
+            }
+
+                static double
+            gatg(const double *p1, int len_p1, double B) {
+                const double *p;
+                double h = 0, h1, h2 = 0, cos_2B;
+
+                cos_2B = 2*cos(2*B);
+                for (p = p1 + len_p1, h1 = *--p; p - p1; h2 = h1, h1 = h)
+                    h = -h2 + cos_2B*h1 + *--p;
+                return (B + h*sin(2*B));
+            }
+
+                static double
+            clenS(const double *a, int size, double arg_r, double arg_i, double *R, double *I) {
+                double      r, i, hr, hr1, hr2, hi, hi1, hi2;
+                double      sin_arg_r, cos_arg_r, sinh_arg_i, cosh_arg_i;
+
+                /* arguments */
+                const double* p = a + size;
+                sin_arg_r  = sin(arg_r);
+                cos_arg_r  = cos(arg_r);
+                sinh_arg_i = sinh(arg_i);
+                cosh_arg_i = cosh(arg_i);
+                r          =  2*cos_arg_r*cosh_arg_i;
+                i          = -2*sin_arg_r*sinh_arg_i;
+                /* summation loop */
+                for (hi1 = hr1 = hi = 0, hr = *--p; a - p;) {
+                    hr2 = hr1;
+                    hi2 = hi1;
+                    hr1 = hr;
+                    hi1 = hi;
+                    hr  = -hr2 + r*hr1 - i*hi1 + *--p;
+                    hi  = -hi2 + i*hr1 + r*hi1;
+                }
+                r   = sin_arg_r*cosh_arg_i;
+                i   = cos_arg_r*sinh_arg_i;
+                *R  = r*hr - i*hi;
+                *I  = r*hi + i*hr;
+                return(*R);
+            }
+                static double
+            clens(const double *a, int size, double arg_r) {
+                double      r, hr, hr1, hr2, cos_arg_r;
+
+                const double* p = a + size;
+                cos_arg_r  = cos(arg_r);
+                r          =  2*cos_arg_r;
+                /* summation loop */
+                for (hr1 = 0, hr = *--p; a - p;) {
+                    hr2 = hr1;
+                    hr1 = hr;
+                    hr  = -hr2 + r*hr1 + *--p;
+                }
+                return(sin(arg_r)*hr);
+            }
+
+            // template class, using CRTP to implement forward/inverse
+            template <typename Geographic, typename Cartesian, typename Parameters>
+            struct base_etmerc_ellipsoid : public base_t_fi<base_etmerc_ellipsoid<Geographic, Cartesian, Parameters>,
+                     Geographic, Cartesian, Parameters>
+            {
+
+                 typedef double geographic_type;
+                 typedef double cartesian_type;
+
+                par_etmerc m_proj_parm;
+
+                inline base_etmerc_ellipsoid(const Parameters& par)
+                    : base_t_fi<base_etmerc_ellipsoid<Geographic, Cartesian, Parameters>,
+                     Geographic, Cartesian, Parameters>(*this, par) {}
+
+                inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
+                {
+                    double sin_Cn, cos_Cn, cos_Ce, sin_Ce, dCn, dCe;
+                    double Cn = lp_lat, Ce = lp_lon;
+
+                    /* ell. LAT, LNG -> Gaussian LAT, LNG */
+                    Cn  = gatg(this->m_proj_parm.cbg, PROJ_ETMERC_ORDER, Cn);
+                    /* Gaussian LAT, LNG -> compl. sph. LAT */
+                    sin_Cn = sin(Cn);
+                    cos_Cn = cos(Cn);
+                    sin_Ce = sin(Ce);
+                    cos_Ce = cos(Ce);
+
+                    Cn     = atan2(sin_Cn, cos_Ce*cos_Cn);
+                    Ce     = atan2(sin_Ce*cos_Cn, boost::math::hypot(sin_Cn, cos_Cn*cos_Ce));
+                    /* compl. sph. N, E -> ell. norm. N, E */
+                    Ce  = asinhy(tan(Ce));     /* Replaces: Ce  = log(tan(FORTPI + Ce*0.5)); */
+                    Cn += clenS(this->m_proj_parm.gtu, PROJ_ETMERC_ORDER, 2*Cn, 2*Ce, &dCn, &dCe);
+                    Ce += dCe;
+                    if (fabs(Ce) <= 2.623395162778) {
+                        xy_y  = this->m_proj_parm.Qn * Cn + this->m_proj_parm.Zb;  /* Northing */
+                        xy_x  = this->m_proj_parm.Qn * Ce;  /* Easting  */
+                    } else
+                        xy_x = xy_y = HUGE_VAL;
+                }
+
+                inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
+                {
+                    double sin_Cn, cos_Cn, cos_Ce, sin_Ce, dCn, dCe;
+                    double Cn = xy_y, Ce = xy_x;
+
+                    /* normalize N, E */
+                    Cn = (Cn - this->m_proj_parm.Zb)/this->m_proj_parm.Qn;
+                    Ce = Ce/this->m_proj_parm.Qn;
+                    if (fabs(Ce) <= 2.623395162778) { /* 150 degrees */
+                    /* norm. N, E -> compl. sph. LAT, LNG */
+                        Cn += clenS(this->m_proj_parm.utg, PROJ_ETMERC_ORDER, 2*Cn, 2*Ce, &dCn, &dCe);
+                        Ce += dCe;
+                        Ce = atan(sinh(Ce)); /* Replaces: Ce = 2*(atan(exp(Ce)) - FORTPI); */
+                        /* compl. sph. LAT -> Gaussian LAT, LNG */
+                        sin_Cn = sin(Cn);
+                        cos_Cn = cos(Cn);
+                        sin_Ce = sin(Ce);
+                        cos_Ce = cos(Ce);
+                        Ce     = atan2(sin_Ce, cos_Ce*cos_Cn);
+                        Cn     = atan2(sin_Cn*cos_Ce, boost::math::hypot(sin_Ce, cos_Ce*cos_Cn));
+                        /* Gaussian LAT, LNG -> ell. LAT, LNG */
+                        lp_lat = gatg(this->m_proj_parm.cgb,  PROJ_ETMERC_ORDER, Cn);
+                        lp_lon = Ce;
+                    }
+                    else
+                        lp_lat = lp_lon = HUGE_VAL;
+                }
+            };
+
+            // Extended Transverse Mercator
+            template <typename Parameters>
+            void setup_etmerc(Parameters& par, par_etmerc& proj_parm)
+            {
+                double f, n, np, Z;
+
+                if (par.es <= 0) throw proj_exception(-34);
+                f = par.es / (1 + sqrt(1 -  par.es)); /* Replaces: f = 1 - sqrt(1-par.es); */
+                /* third flattening */
+                np = n = f/(2 - f);
+
+                /* COEF. OF TRIG SERIES GEO <-> GAUSS */
+                /* cgb := Gaussian -> Geodetic, KW p190 - 191 (61) - (62) */
+                /* cbg := Geodetic -> Gaussian, KW p186 - 187 (51) - (52) */
+                /* PROJ_ETMERC_ORDER = 6th degree : Engsager and Poder: ICC2007 */
+                proj_parm.cgb[0] = n*( 2 + n*(-2/3.0  + n*(-2      + n*(116/45.0 + n*(26/45.0 +
+                            n*(-2854/675.0 ))))));
+                proj_parm.cbg[0] = n*(-2 + n*( 2/3.0  + n*( 4/3.0  + n*(-82/45.0 + n*(32/45.0 +
+                            n*( 4642/4725.0))))));
+                np     *= n;
+                proj_parm.cgb[1] = np*(7/3.0 + n*( -8/5.0  + n*(-227/45.0 + n*(2704/315.0 +
+                            n*( 2323/945.0)))));
+                proj_parm.cbg[1] = np*(5/3.0 + n*(-16/15.0 + n*( -13/9.0  + n*( 904/315.0 +
+                            n*(-1522/945.0)))));
+                np     *= n;
+                /* n^5 coeff corrected from 1262/105 -> -1262/105 */
+                proj_parm.cgb[2] = np*( 56/15.0  + n*(-136/35.0 + n*(-1262/105.0 +
+                            n*( 73814/2835.0))));
+                proj_parm.cbg[2] = np*(-26/15.0  + n*(  34/21.0 + n*(    8/5.0   +
+                            n*(-12686/2835.0))));
+                np     *= n;
+                /* n^5 coeff corrected from 322/35 -> 332/35 */
+                proj_parm.cgb[3] = np*(4279/630.0 + n*(-332/35.0 + n*(-399572/14175.0)));
+                proj_parm.cbg[3] = np*(1237/630.0 + n*( -12/5.0  + n*( -24832/14175.0)));
+                np     *= n;
+                proj_parm.cgb[4] = np*(4174/315.0 + n*(-144838/6237.0 ));
+                proj_parm.cbg[4] = np*(-734/315.0 + n*( 109598/31185.0));
+                np     *= n;
+                proj_parm.cgb[5] = np*(601676/22275.0 );
+                proj_parm.cbg[5] = np*(444337/155925.0);
+
+                /* Constants of the projections */
+                /* Transverse Mercator (UTM, ITM, etc) */
+                np = n*n;
+                /* Norm. mer. quad, K&W p.50 (96), p.19 (38b), p.5 (2) */
+                proj_parm.Qn = par.k0/(1 + n) * (1 + np*(1/4.0 + np*(1/64.0 + np/256.0)));
+                /* coef of trig series */
+                /* utg := ell. N, E -> sph. N, E,  KW p194 (65) */
+                /* gtu := sph. N, E -> ell. N, E,  KW p196 (69) */
+                proj_parm.utg[0] = n*(-0.5  + n*( 2/3.0 + n*(-37/96.0 + n*( 1/360.0 +
+                            n*(  81/512.0 + n*(-96199/604800.0))))));
+                proj_parm.gtu[0] = n*( 0.5  + n*(-2/3.0 + n*(  5/16.0 + n*(41/180.0 +
+                            n*(-127/288.0 + n*(  7891/37800.0 ))))));
+                proj_parm.utg[1] = np*(-1/48.0 + n*(-1/15.0 + n*(437/1440.0 + n*(-46/105.0 +
+                            n*( 1118711/3870720.0)))));
+                proj_parm.gtu[1] = np*(13/48.0 + n*(-3/5.0  + n*(557/1440.0 + n*(281/630.0 +
+                            n*(-1983433/1935360.0)))));
+                np      *= n;
+                proj_parm.utg[2] = np*(-17/480.0 + n*(  37/840.0 + n*(  209/4480.0  +
+                            n*( -5569/90720.0 ))));
+                proj_parm.gtu[2] = np*( 61/240.0 + n*(-103/140.0 + n*(15061/26880.0 +
+                            n*(167603/181440.0))));
+                np      *= n;
+                proj_parm.utg[3] = np*(-4397/161280.0 + n*(  11/504.0 + n*( 830251/7257600.0)));
+                proj_parm.gtu[3] = np*(49561/161280.0 + n*(-179/168.0 + n*(6601661/7257600.0)));
+                np     *= n;
+                proj_parm.utg[4] = np*(-4583/161280.0 + n*(  108847/3991680.0));
+                proj_parm.gtu[4] = np*(34729/80640.0  + n*(-3418889/1995840.0));
+                np     *= n;
+                proj_parm.utg[5] = np*(-20648693/638668800.0);
+                proj_parm.gtu[5] = np*(212378941/319334400.0);
+                /* Gaussian latitude value of the origin latitude */
+                Z = gatg(proj_parm.cbg, PROJ_ETMERC_ORDER, par.phi0);
+                /* Origin northing minus true northing at the origin latitude */
+                /* i.e. true northing = N - proj_parm.Zb                         */
+                proj_parm.Zb  = - proj_parm.Qn*(Z + clens(proj_parm.gtu, PROJ_ETMERC_ORDER, 2*Z));
+            }
+
+        }} // namespace detail::etmerc
+    #endif // doxygen
+
+    /*!
+        \brief Extended Transverse Mercator projection
+        \ingroup projections
+        \tparam Geographic latlong point type
+        \tparam Cartesian xy point type
+        \tparam Parameters parameter type
+        \par Projection characteristics
+         - Cylindrical
+         - Spheroid
+        \par Projection parameters
+         - lat_ts: Latitude of true scale
+         - lat_0: Latitude of origin
+        \par Example
+        \image html ex_etmerc.gif
+    */
+    template <typename Geographic, typename Cartesian, typename Parameters = parameters>
+    struct etmerc_ellipsoid : public detail::etmerc::base_etmerc_ellipsoid<Geographic, Cartesian, Parameters>
+    {
+        inline etmerc_ellipsoid(const Parameters& par) : detail::etmerc::base_etmerc_ellipsoid<Geographic, Cartesian, Parameters>(par)
+        {
+            detail::etmerc::setup_etmerc(this->m_par, this->m_proj_parm);
+        }
+    };
+
+    #ifndef DOXYGEN_NO_DETAIL
+    namespace detail
+    {
+
+        // Factory entry(s)
+        template <typename Geographic, typename Cartesian, typename Parameters>
+        class etmerc_entry : public detail::factory_entry<Geographic, Cartesian, Parameters>
+        {
+            public :
+                virtual projection<Geographic, Cartesian>* create_new(const Parameters& par) const
+                {
+                    return new base_v_fi<etmerc_ellipsoid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
+                }
+        };
+
+        template <typename Geographic, typename Cartesian, typename Parameters>
+        inline void etmerc_init(detail::base_factory<Geographic, Cartesian, Parameters>& factory)
+        {
+            factory.add_to_factory("etmerc", new etmerc_entry<Geographic, Cartesian, Parameters>);
+        }
+
+    } // namespace detail
+    #endif // doxygen
+
+}}} // namespace boost::geometry::projections
+
+#endif // BOOST_GEOMETRY_PROJECTIONS_ETMERC_HPP
+
diff --git a/include/boost/geometry/extensions/gis/projections/proj/fahey.hpp b/include/boost/geometry/extensions/gis/projections/proj/fahey.hpp
index ac444c8ef..fd4f4b049 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/fahey.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/fahey.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,9 +46,10 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace fahey{
-            static const double TOL = 1e-6;
+    namespace detail { namespace fahey
+    {
 
+            static const double TOL = 1e-6;
 
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
@@ -85,8 +84,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_fahey(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::fahey
diff --git a/include/boost/geometry/extensions/gis/projections/proj/fouc_s.hpp b/include/boost/geometry/extensions/gis/projections/proj/fouc_s.hpp
index da057e0f0..086e56986 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/fouc_s.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/fouc_s.hpp
@@ -38,17 +38,18 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace fouc_s{
+    namespace detail { namespace fouc_s
+    {
+
             static const int MAX_ITER = 10;
             static const double LOOP_TOL = 1e-7;
 
@@ -112,8 +113,6 @@ namespace boost { namespace geometry { namespace projections
                     throw proj_exception(-99);
                 proj_parm.n1 = 1. - proj_parm.n;
                 par.es = 0;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::fouc_s
@@ -128,6 +127,8 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Pseudocylindrical
          - Spheroid
+        \par Projection parameters
+         - n (real)
         \par Example
         \image html ex_fouc_s.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/gall.hpp b/include/boost/geometry/extensions/gis/projections/proj/gall.hpp
index 21ba02354..13d8a4a2f 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/gall.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/gall.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,13 +46,14 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace gall{
+    namespace detail { namespace gall
+    {
+
             static const double YF = 1.70710678118654752440;
             static const double XF = 0.70710678118654752440;
             static const double RYF = 0.58578643762690495119;
             static const double RXF = 1.41421356237309504880;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_gall_spheroid : public base_t_fi<base_gall_spheroid<Geographic, Cartesian, Parameters>,
@@ -87,8 +86,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_gall(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::gall
diff --git a/include/boost/geometry/extensions/gis/projections/proj/geocent.hpp b/include/boost/geometry/extensions/gis/projections/proj/geocent.hpp
index 4df4b4d2f..68031d5b1 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/geocent.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/geocent.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,12 +46,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace geocent{
-
-
-
-
-
+    namespace detail { namespace geocent
+    {
 
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
@@ -89,8 +83,6 @@ namespace boost { namespace geometry { namespace projections
                 par.is_geocent = 1;
                 par.x0 = 0.0;
                 par.y0 = 0.0;
-                // par.inv = inverse;
-                // par.fwd = forward;
             }
 
         }} // namespace detail::geocent
@@ -102,7 +94,6 @@ namespace boost { namespace geometry { namespace projections
         \tparam Geographic latlong point type
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
-        \par Projection characteristics
         \par Example
         \image html ex_geocent.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/geos.hpp b/include/boost/geometry/extensions/gis/projections/proj/geos.hpp
index e2fe57c44..e72d01151 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/geos.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/geos.hpp
@@ -48,7 +48,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace geos{
+    namespace detail { namespace geos
+    {
 
             struct par_geos
             {
@@ -63,8 +64,6 @@ namespace boost { namespace geometry { namespace projections
                 int     flip_axis;
             };
 
-
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_geos_ellipsoid : public base_t_fi<base_geos_ellipsoid<Geographic, Cartesian, Parameters>,
@@ -241,12 +240,8 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.radius_p      = sqrt (par.one_es);
                     proj_parm.radius_p2     = par.one_es;
                     proj_parm.radius_p_inv2 = par.rone_es;
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                 } else {
                     proj_parm.radius_p = proj_parm.radius_p2 = proj_parm.radius_p_inv2 = 1.0;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 }
             }
 
@@ -263,7 +258,9 @@ namespace boost { namespace geometry { namespace projections
          - Azimuthal
          - Spheroid
          - Ellipsoid
-         - h=
+        \par Projection parameters
+         - h: Height (real)
+         - sweep: Sweep axis ('x' or 'y') (string)
         \par Example
         \image html ex_geos.gif
     */
@@ -286,7 +283,9 @@ namespace boost { namespace geometry { namespace projections
          - Azimuthal
          - Spheroid
          - Ellipsoid
-         - h=
+        \par Projection parameters
+         - h: Height (real)
+         - sweep: Sweep axis ('x' or 'y') (string)
         \par Example
         \image html ex_geos.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/gins8.hpp b/include/boost/geometry/extensions/gis/projections/proj/gins8.hpp
index 4fe4d33f2..8164a7cf8 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/gins8.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/gins8.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,12 +46,13 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace gins8{
+    namespace detail { namespace gins8
+    {
+
             static const double Cl = 0.000952426;
             static const double Cp = 0.162388;
             static const double C12 = 0.08333333333333333;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_gins8_spheroid : public base_t_f<base_gins8_spheroid<Geographic, Cartesian, Parameters>,
@@ -84,8 +83,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_gins8(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = 0;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::gins8
diff --git a/include/boost/geometry/extensions/gis/projections/proj/gn_sinu.hpp b/include/boost/geometry/extensions/gis/projections/proj/gn_sinu.hpp
index bd2bc33f9..5cdf90805 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/gn_sinu.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/gn_sinu.hpp
@@ -38,19 +38,19 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_mlfn.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace gn_sinu{
+    namespace detail { namespace gn_sinu
+    {
+
             static const double EPS10 = 1e-10;
             static const int MAX_ITER = 8;
             static const double LOOP_TOL = 1e-7;
@@ -60,6 +60,7 @@ namespace boost { namespace geometry { namespace projections
                 double    en[EN_SIZE];
                 double    m, n, C_x, C_y;
             };
+
             /* Ellipsoidal Sinusoidal only */
 
             // template class, using CRTP to implement forward/inverse
@@ -95,7 +96,6 @@ namespace boost { namespace geometry { namespace projections
                     } else if ((s - EPS10) < HALFPI)
                         lp_lon = 0.;
                     else throw proj_exception();;
-                            return;
                 }
                 /* General spherical sinusoidals */
             };
@@ -149,12 +149,8 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_gn_sinu& proj_parm) 
             {
-                boost::ignore_unused(par);
-                boost::ignore_unused(proj_parm);
                 par.es = 0;
                 proj_parm.C_x = (proj_parm.C_y = sqrt((proj_parm.m + 1.) / proj_parm.n))/(proj_parm.m + 1.);
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
 
@@ -174,11 +170,9 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup_sinu(Parameters& par, par_gn_sinu& proj_parm)
             {
-                    pj_enfn(par.es, proj_parm.en);
-
+                if (!pj_enfn(par.es, proj_parm.en))
+                    throw proj_exception(0);
                 if (par.es) {
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                 } else {
                     proj_parm.n = 1.;
                     proj_parm.m = 0.;
@@ -207,6 +201,30 @@ namespace boost { namespace geometry { namespace projections
         }} // namespace detail::gn_sinu
     #endif // doxygen
 
+    /*!
+        \brief General Sinusoidal Series projection
+        \ingroup projections
+        \tparam Geographic latlong point type
+        \tparam Cartesian xy point type
+        \tparam Parameters parameter type
+        \par Projection characteristics
+         - Pseudocylindrical
+         - Spheroid
+        \par Projection parameters
+         - m (real)
+         - n (real)
+        \par Example
+        \image html ex_gn_sinu.gif
+    */
+    template <typename Geographic, typename Cartesian, typename Parameters = parameters>
+    struct gn_sinu_spheroid : public detail::gn_sinu::base_gn_sinu_spheroid<Geographic, Cartesian, Parameters>
+    {
+        inline gn_sinu_spheroid(const Parameters& par) : detail::gn_sinu::base_gn_sinu_spheroid<Geographic, Cartesian, Parameters>(par)
+        {
+            detail::gn_sinu::setup_gn_sinu(this->m_par, this->m_proj_parm);
+        }
+    };
+
     /*!
         \brief Sinusoidal (Sanson-Flamsteed) projection
         \ingroup projections
@@ -229,28 +247,6 @@ namespace boost { namespace geometry { namespace projections
         }
     };
 
-    /*!
-        \brief General Sinusoidal Series projection
-        \ingroup projections
-        \tparam Geographic latlong point type
-        \tparam Cartesian xy point type
-        \tparam Parameters parameter type
-        \par Projection characteristics
-         - Pseudocylindrical
-         - Spheroid
-         - m= n=
-        \par Example
-        \image html ex_gn_sinu.gif
-    */
-    template <typename Geographic, typename Cartesian, typename Parameters = parameters>
-    struct gn_sinu_spheroid : public detail::gn_sinu::base_gn_sinu_spheroid<Geographic, Cartesian, Parameters>
-    {
-        inline gn_sinu_spheroid(const Parameters& par) : detail::gn_sinu::base_gn_sinu_spheroid<Geographic, Cartesian, Parameters>(par)
-        {
-            detail::gn_sinu::setup_gn_sinu(this->m_par, this->m_proj_parm);
-        }
-    };
-
     /*!
         \brief Sinusoidal (Sanson-Flamsteed) projection
         \ingroup projections
diff --git a/include/boost/geometry/extensions/gis/projections/proj/gnom.hpp b/include/boost/geometry/extensions/gis/projections/proj/gnom.hpp
index f60d7db82..da4edc5d4 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/gnom.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/gnom.hpp
@@ -48,7 +48,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace gnom{
+    namespace detail { namespace gnom
+    {
+
             static const double EPS10 = 1.e-10;
             static const int N_POLE = 0;
             static const int S_POLE = 1;
@@ -171,8 +173,6 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.sinph0 = sin(par.phi0);
                     proj_parm.cosph0 = cos(par.phi0);
                 }
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/goode.hpp b/include/boost/geometry/extensions/gis/projections/proj/goode.hpp
index 2873f93fd..dbe894a91 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/goode.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/goode.hpp
@@ -38,19 +38,19 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
-#include <boost/geometry/extensions/gis/projections/proj/moll.hpp>
 #include <boost/geometry/extensions/gis/projections/proj/gn_sinu.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/moll.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace goode{
+    namespace detail { namespace goode
+    {
+
             static const double Y_COR = 0.05280;
             static const double PHI_LIM = .71093078197902358062;
 
@@ -104,8 +104,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_goode(Parameters& par, par_goode<Geographic, Cartesian, Parameters>& proj_parm)
             {
                 par.es = 0.;
-                // par.fwd = s_forward;
-                // par.inv = s_inverse;
             }
 
         }} // namespace detail::goode
diff --git a/include/boost/geometry/extensions/gis/projections/proj/gstmerc.hpp b/include/boost/geometry/extensions/gis/projections/proj/gstmerc.hpp
index ccff62891..d532d40ca 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/gstmerc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/gstmerc.hpp
@@ -38,19 +38,18 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
-#include <boost/geometry/extensions/gis/projections/impl/pj_tsfn.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_phi2.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/pj_tsfn.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace gstmerc{
+    namespace detail { namespace gstmerc
+    {
 
             struct par_gstmerc
             {
@@ -63,7 +62,6 @@ namespace boost { namespace geometry { namespace projections
                 double YS;
             };
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_gstmerc_spheroid : public base_t_fi<base_gstmerc_spheroid<Geographic, Cartesian, Parameters>,
@@ -113,14 +111,9 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.c=       log(pj_tsfn(-1.0*proj_parm.phic,0.0,0.0))
                      -proj_parm.n1*log(pj_tsfn(-1.0*par.phi0,-1.0*sin(par.phi0),par.e));
                 proj_parm.n2= par.k0*par.a*sqrt(1.0-par.es)/(1.0-par.es*sin(par.phi0)*sin(par.phi0));
-                proj_parm.XS= 0;
-            /* -par.x0 */
-                proj_parm.YS= -1.0*proj_parm.n2*proj_parm.phic;
-            /* -par.y0 */
-                // par.inv= s_inverse;
-                // par.fwd= s_forward;
-                /*fprintf(stderr,"a  (m) =%16.4f\ne      =%16.13f\nl0(rad)=%16.13f\np0(rad)=%16.13f\nk0     =%16.4f\nX0  (m)=%16.4f\nY0  (m)=%16.4f\n\nlC(rad)=%16.13f\npC(rad)=%16.13f\nc      =%16.13f\nn1     =%16.13f\nn2 (m) =%16.4f\nXS (m) =%16.4f\nYS (m) =%16.4f\n", par.a, par.e, par.lam0, par.phi0, par.k0, par.x0, par.y0, proj_parm.lamc, proj_parm.phic, proj_parm.c, proj_parm.n1, proj_parm.n2, proj_parm.XS +par.x0, proj_parm.YS + par.y0);
-            */
+                proj_parm.XS= 0;/* -par.x0 */
+                proj_parm.YS= -1.0*proj_parm.n2*proj_parm.phic;/* -par.y0 */
+                /*fprintf(stderr,"a  (m) =%16.4f\ne      =%16.13f\nl0(rad)=%16.13f\np0(rad)=%16.13f\nk0     =%16.4f\nX0  (m)=%16.4f\nY0  (m)=%16.4f\n\nlC(rad)=%16.13f\npC(rad)=%16.13f\nc      =%16.13f\nn1     =%16.13f\nn2 (m) =%16.4f\nXS (m) =%16.4f\nYS (m) =%16.4f\n", par.a, par.e, par.lam0, par.phi0, par.k0, par.x0, par.y0, proj_parm.lamc, proj_parm.phic, proj_parm.c, proj_parm.n1, proj_parm.n2, proj_parm.XS +par.x0, proj_parm.YS + par.y0);*/
             }
 
         }} // namespace detail::gstmerc
@@ -136,7 +129,10 @@ namespace boost { namespace geometry { namespace projections
          - Cylindrical
          - Spheroid
          - Ellipsoid
-         - lat_0= lon_0= k_0=
+        \par Projection parameters
+         - lat_0: Latitude of origin
+         - lon_0: Central meridian
+         - k_0: Scale factor
         \par Example
         \image html ex_gstmerc.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/hammer.hpp b/include/boost/geometry/extensions/gis/projections/proj/hammer.hpp
index 42755171e..395164cb3 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/hammer.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/hammer.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace hammer{
+    namespace detail { namespace hammer
+    {
 
             struct par_hammer
             {
@@ -96,7 +95,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.rm = 1. / proj_parm.m;
                 proj_parm.m /= proj_parm.w;
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::hammer
@@ -112,7 +110,9 @@ namespace boost { namespace geometry { namespace projections
          - Miscellaneous
          - Spheroid
          - no inverse
-         - W= M=
+        \par Projection parameters
+         - W (real)
+         - M (real)
         \par Example
         \image html ex_hammer.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/hatano.hpp b/include/boost/geometry/extensions/gis/projections/proj/hatano.hpp
index bf8c06a8d..c2ac39d82 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/hatano.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/hatano.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace hatano{
+    namespace detail { namespace hatano
+    {
+
             static const int NITER = 20;
             static const double EPS = 1e-7;
             static const double ONETOL = 1.000001;
@@ -63,7 +63,6 @@ namespace boost { namespace geometry { namespace projections
             static const double FXC = 0.85;
             static const double RXC = 1.17647058823529411764;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_hatano_spheroid : public base_t_fi<base_hatano_spheroid<Geographic, Cartesian, Parameters>,
@@ -118,8 +117,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_hatano(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::hatano
diff --git a/include/boost/geometry/extensions/gis/projections/proj/igh.hpp b/include/boost/geometry/extensions/gis/projections/proj/igh.hpp
new file mode 100644
index 000000000..1d3842ce9
--- /dev/null
+++ b/include/boost/geometry/extensions/gis/projections/proj/igh.hpp
@@ -0,0 +1,305 @@
+#ifndef BOOST_GEOMETRY_PROJECTIONS_IGH_HPP
+#define BOOST_GEOMETRY_PROJECTIONS_IGH_HPP
+
+// Boost.Geometry - extensions-gis-projections (based on PROJ4)
+// This file is automatically generated. DO NOT EDIT.
+
+// Copyright (c) 2008-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// This file is converted from PROJ4, http://trac.osgeo.org/proj
+// PROJ4 is originally written by Gerald Evenden (then of the USGS)
+// PROJ4 is maintained by Frank Warmerdam
+// PROJ4 is converted to Boost.Geometry by Barend Gehrels
+
+// Last updated version of proj: 4.9.1
+
+// Original copyright notice:
+ 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+
+#include <boost/shared_ptr.hpp>
+
+#include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/gn_sinu.hpp>
+#include <boost/geometry/extensions/gis/projections/proj/moll.hpp>
+
+namespace boost { namespace geometry { namespace projections
+{
+    #ifndef DOXYGEN_NO_DETAIL
+    namespace detail { namespace igh
+    {
+
+            template <typename Geographic, typename Cartesian>
+            struct par_igh
+            {
+                boost::shared_ptr<projection<Geographic, Cartesian> > pj[12];
+                double dy0;
+            };
+
+            static const double d4044118 = (40 + 44/60. + 11.8/3600.) * DEG_TO_RAD; // 40d 44' 11.8" [degrees]
+
+            static const double d10  =  10 * DEG_TO_RAD;
+            static const double d20  =  20 * DEG_TO_RAD;
+            static const double d30  =  30 * DEG_TO_RAD;
+            static const double d40  =  40 * DEG_TO_RAD;
+            static const double d50  =  50 * DEG_TO_RAD;
+            static const double d60  =  60 * DEG_TO_RAD;
+            static const double d80  =  80 * DEG_TO_RAD;
+            static const double d90  =  90 * DEG_TO_RAD;
+            static const double d100 = 100 * DEG_TO_RAD;
+            static const double d140 = 140 * DEG_TO_RAD;
+            static const double d160 = 160 * DEG_TO_RAD;
+            static const double d180 = 180 * DEG_TO_RAD;
+
+            static const double EPSLN = 1.e-10; // allow a little 'slack' on zone edge positions
+
+            // Converted from #define SETUP(n, proj, x_0, y_0, lon_0)
+            template <template <typename, typename, typename> class Entry, typename Parameters, typename Geographic, typename Cartesian>
+            inline void do_setup(int n, Parameters const& par, par_igh<Geographic, Cartesian>& proj_parm, double x_0, double y_0, double lon_0)
+            {
+                Entry<Geographic, Cartesian, Parameters> entry;
+                proj_parm.pj[n-1].reset(entry.create_new(par));
+                proj_parm.pj[n-1]->mutable_params().x0 = x_0;
+                proj_parm.pj[n-1]->mutable_params().y0 = y_0;
+                proj_parm.pj[n-1]->mutable_params().lam0 = lon_0;
+            }
+
+            // template class, using CRTP to implement forward/inverse
+            template <typename Geographic, typename Cartesian, typename Parameters>
+            struct base_igh_spheroid : public base_t_fi<base_igh_spheroid<Geographic, Cartesian, Parameters>,
+                     Geographic, Cartesian, Parameters>
+            {
+
+                 typedef double geographic_type;
+                 typedef double cartesian_type;
+
+                par_igh<Geographic, Cartesian> m_proj_parm;
+
+                inline base_igh_spheroid(const Parameters& par)
+                    : base_t_fi<base_igh_spheroid<Geographic, Cartesian, Parameters>,
+                     Geographic, Cartesian, Parameters>(*this, par) {}
+
+                inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
+                {
+                        int z;
+                        if (lp_lat >=  d4044118) {          // 1|2
+                          z = (lp_lon <= -d40 ? 1: 2);
+                        }
+                        else if (lp_lat >=  0) {            // 3|4
+                          z = (lp_lon <= -d40 ? 3: 4);
+                        }
+                        else if (lp_lat >= -d4044118) {     // 5|6|7|8
+                               if (lp_lon <= -d100) z =  5; // 5
+                          else if (lp_lon <=  -d20) z =  6; // 6
+                          else if (lp_lon <=   d80) z =  7; // 7
+                          else z = 8;                       // 8
+                        }
+                        else {                              // 9|10|11|12
+                               if (lp_lon <= -d100) z =  9; // 9
+                          else if (lp_lon <=  -d20) z = 10; // 10
+                          else if (lp_lon <=   d80) z = 11; // 11
+                          else z = 12;                      // 12
+                        }
+
+                        lp_lon -= this->m_proj_parm.pj[z-1]->params().lam0;
+                        this->m_proj_parm.pj[z-1]->fwd(lp_lon, lp_lat, xy_x, xy_y);
+                        xy_x += this->m_proj_parm.pj[z-1]->params().x0;
+                        xy_y += this->m_proj_parm.pj[z-1]->params().y0;
+                }
+
+                inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
+                {
+                        const double y90 = this->m_proj_parm.dy0 + sqrt(2); // lt=90 corresponds to y=y0+sqrt(2)
+
+                        int z = 0;
+                        if (xy_y > y90+EPSLN || xy_y < -y90+EPSLN) // 0
+                          z = 0;
+                        else if (xy_y >=  d4044118)       // 1|2
+                          z = (xy_x <= -d40? 1: 2);
+                        else if (xy_y >=  0)              // 3|4
+                          z = (xy_x <= -d40? 3: 4);
+                        else if (xy_y >= -d4044118) {     // 5|6|7|8
+                               if (xy_x <= -d100) z =  5; // 5
+                          else if (xy_x <=  -d20) z =  6; // 6
+                          else if (xy_x <=   d80) z =  7; // 7
+                          else z = 8;                     // 8
+                        }
+                        else {                            // 9|10|11|12
+                               if (xy_x <= -d100) z =  9; // 9
+                          else if (xy_x <=  -d20) z = 10; // 10
+                          else if (xy_x <=   d80) z = 11; // 11
+                          else z = 12;                    // 12
+                        }
+
+                        if (z)
+                        {
+                          int ok = 0;
+
+                          xy_x -= this->m_proj_parm.pj[z-1]->params().x0;
+                          xy_y -= this->m_proj_parm.pj[z-1]->params().y0;
+                          this->m_proj_parm.pj[z-1]->inv(xy_x, xy_y, lp_lon, lp_lat);
+                          lp_lon += this->m_proj_parm.pj[z-1]->params().lam0;
+
+                          switch (z) {
+                            case  1: ok = (lp_lon >= -d180-EPSLN && lp_lon <=  -d40+EPSLN) ||
+                                         ((lp_lon >=  -d40-EPSLN && lp_lon <=  -d10+EPSLN) &&
+                                          (lp_lat >=   d60-EPSLN && lp_lat <=   d90+EPSLN)); break;
+                            case  2: ok = (lp_lon >=  -d40-EPSLN && lp_lon <=  d180+EPSLN) ||
+                                         ((lp_lon >= -d180-EPSLN && lp_lon <= -d160+EPSLN) &&
+                                          (lp_lat >=   d50-EPSLN && lp_lat <=   d90+EPSLN)) ||
+                                         ((lp_lon >=  -d50-EPSLN && lp_lon <=  -d40+EPSLN) &&
+                                          (lp_lat >=   d60-EPSLN && lp_lat <=   d90+EPSLN)); break;
+                            case  3: ok = (lp_lon >= -d180-EPSLN && lp_lon <=  -d40+EPSLN); break;
+                            case  4: ok = (lp_lon >=  -d40-EPSLN && lp_lon <=  d180+EPSLN); break;
+                            case  5: ok = (lp_lon >= -d180-EPSLN && lp_lon <= -d100+EPSLN); break;
+                            case  6: ok = (lp_lon >= -d100-EPSLN && lp_lon <=  -d20+EPSLN); break;
+                            case  7: ok = (lp_lon >=  -d20-EPSLN && lp_lon <=   d80+EPSLN); break;
+                            case  8: ok = (lp_lon >=   d80-EPSLN && lp_lon <=  d180+EPSLN); break;
+                            case  9: ok = (lp_lon >= -d180-EPSLN && lp_lon <= -d100+EPSLN); break;
+                            case 10: ok = (lp_lon >= -d100-EPSLN && lp_lon <=  -d20+EPSLN); break;
+                            case 11: ok = (lp_lon >=  -d20-EPSLN && lp_lon <=   d80+EPSLN); break;
+                            case 12: ok = (lp_lon >=   d80-EPSLN && lp_lon <=  d180+EPSLN); break;
+                          }
+
+                          z = (!ok? 0: z); // projectable?
+                        }
+                     // if (!z) pj_errno = -15; // invalid x or y
+                        if (!z) lp_lon = HUGE_VAL;
+                        if (!z) lp_lat = HUGE_VAL;
+                }
+            };
+
+            // Interrupted Goode Homolosine
+            template <typename Geographic, typename Cartesian, typename Parameters>
+            void setup_igh(Parameters& par, par_igh<Geographic, Cartesian>& proj_parm)
+            {
+            /*
+              Zones:
+
+                -180            -40                       180
+                  +--------------+-------------------------+    Zones 1,2,9,10,11 & 12:
+                  |1             |2                        |      Mollweide projection
+                  |              |                         |
+                  +--------------+-------------------------+    Zones 3,4,5,6,7 & 8:
+                  |3             |4                        |      Sinusoidal projection
+                  |              |                         |
+                0 +-------+------+-+-----------+-----------+
+                  |5      |6       |7          |8          |
+                  |       |        |           |           |
+                  +-------+--------+-----------+-----------+
+                  |9      |10      |11         |12         |
+                  |       |        |           |           |
+                  +-------+--------+-----------+-----------+
+                -180    -100      -20         80          180
+            */
+
+
+                    double lp_lam = 0, lp_phi = d4044118;
+                    double xy1_x, xy1_y;
+                    double xy3_x, xy3_y;
+
+                    // sinusoidal zones
+                    do_setup<sinu_entry>(3, par, proj_parm, -d100, 0, -d100);
+                    do_setup<sinu_entry>(4, par, proj_parm,   d30, 0,   d30);
+                    do_setup<sinu_entry>(5, par, proj_parm, -d160, 0, -d160);
+                    do_setup<sinu_entry>(6, par, proj_parm,  -d60, 0,  -d60);
+                    do_setup<sinu_entry>(7, par, proj_parm,   d20, 0,   d20);
+                    do_setup<sinu_entry>(8, par, proj_parm,  d140, 0,  d140);
+
+                    // mollweide zones
+                    do_setup<moll_entry>(1, par, proj_parm, -d100, 0, -d100);
+
+                    // y0 ?
+                     proj_parm.pj[0]->fwd(lp_lam, lp_phi, xy1_x, xy1_y); // zone 1
+                     proj_parm.pj[2]->fwd(lp_lam, lp_phi, xy3_x, xy3_y); // zone 3
+                    // y0 + xy1_y = xy3_y for lt = 40d44'11.8"
+                    proj_parm.dy0 = xy3_y - xy1_y;
+
+                    proj_parm.pj[0]->mutable_params().y0 = proj_parm.dy0;
+
+                    // mollweide zones (cont'd)
+                    do_setup<moll_entry>( 2, par, proj_parm,   d30,  proj_parm.dy0,   d30);
+                    do_setup<moll_entry>( 9, par, proj_parm, -d160, -proj_parm.dy0, -d160);
+                    do_setup<moll_entry>(10, par, proj_parm,  -d60, -proj_parm.dy0,  -d60);
+                    do_setup<moll_entry>(11, par, proj_parm,   d20, -proj_parm.dy0,   d20);
+                    do_setup<moll_entry>(12, par, proj_parm,  d140, -proj_parm.dy0,  d140);
+
+                    par.es = 0.;
+            }
+
+        }} // namespace detail::igh
+    #endif // doxygen
+
+    /*!
+        \brief Interrupted Goode Homolosine projection
+        \ingroup projections
+        \tparam Geographic latlong point type
+        \tparam Cartesian xy point type
+        \tparam Parameters parameter type
+        \par Projection characteristics
+         - Pseudocylindrical
+         - Spheroid
+        \par Example
+        \image html ex_igh.gif
+    */
+    template <typename Geographic, typename Cartesian, typename Parameters = parameters>
+    struct igh_spheroid : public detail::igh::base_igh_spheroid<Geographic, Cartesian, Parameters>
+    {
+        inline igh_spheroid(const Parameters& par) : detail::igh::base_igh_spheroid<Geographic, Cartesian, Parameters>(par)
+        {
+            detail::igh::setup_igh(this->m_par, this->m_proj_parm);
+        }
+    };
+
+    #ifndef DOXYGEN_NO_DETAIL
+    namespace detail
+    {
+
+        // Factory entry(s)
+        template <typename Geographic, typename Cartesian, typename Parameters>
+        class igh_entry : public detail::factory_entry<Geographic, Cartesian, Parameters>
+        {
+            public :
+                virtual projection<Geographic, Cartesian>* create_new(const Parameters& par) const
+                {
+                    return new base_v_fi<igh_spheroid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
+                }
+        };
+
+        template <typename Geographic, typename Cartesian, typename Parameters>
+        inline void igh_init(detail::base_factory<Geographic, Cartesian, Parameters>& factory)
+        {
+            factory.add_to_factory("igh", new igh_entry<Geographic, Cartesian, Parameters>);
+        }
+
+    } // namespace detail
+    #endif // doxygen
+
+}}} // namespace boost::geometry::projections
+
+#endif // BOOST_GEOMETRY_PROJECTIONS_IGH_HPP
+
diff --git a/include/boost/geometry/extensions/gis/projections/proj/imw_p.hpp b/include/boost/geometry/extensions/gis/projections/proj/imw_p.hpp
index db9b88850..e3bd67545 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/imw_p.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/imw_p.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -49,11 +47,13 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace imw_p{
+    namespace detail { namespace imw_p
+    {
+
             static const double TOL = 1e-10;
             static const double EPS = 1e-10;
 
-            struct PXY { double x, y; }; // x/y projection specific
+            struct XY { double x, y; }; // specific for IMW_P
 
             struct par_imw_p
             {
@@ -62,8 +62,9 @@ namespace boost { namespace geometry { namespace projections
                 double    en[EN_SIZE];
                 int    mode; /* = 0, phi_1 and phi_2 != 0, = 1, phi_1 = 0, = -1 phi_2 = 0 */
             };
+
             template <typename Parameters>
-                inline int
+                static int
             phi12(Parameters& par, par_imw_p& proj_parm, double *del, double *sig) {
                 int err = 0;
 
@@ -80,9 +81,9 @@ namespace boost { namespace geometry { namespace projections
                 return err;
             }
             template <typename Parameters>
-                inline PXY
-            loc_for(double const& lp_lam, double const& lp_phi, const Parameters& par, par_imw_p const& proj_parm, double *yc) {
-                PXY xy;
+                static XY
+            loc_for(double const& lp_lam, double const& lp_phi, Parameters const& par, par_imw_p const& proj_parm, double *yc) {
+                XY xy;
 
                 if (! lp_phi) {
                     xy.x = lp_lam;
@@ -127,10 +128,9 @@ namespace boost { namespace geometry { namespace projections
                 }
                 return (xy);
             }
-
             template <typename Parameters>
-            inline void
-            xy(Parameters& par, par_imw_p& proj_parm, double phi, double *x, double *y, double *sp, double *R) {
+                static void
+            xy(Parameters const& par, par_imw_p const& proj_parm, double phi, double *x, double *y, double *sp, double *R) {
                 double F;
 
                 *sp = sin(phi);
@@ -140,7 +140,6 @@ namespace boost { namespace geometry { namespace projections
                 *x = *R * sin(F);
             }
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_imw_p_ellipsoid : public base_t_fi<base_imw_p_ellipsoid<Geographic, Cartesian, Parameters>,
@@ -159,13 +158,13 @@ namespace boost { namespace geometry { namespace projections
                 inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
                 {
                     double yc = 0;
-                    PXY xy = loc_for(lp_lon, lp_lat, this->m_par, m_proj_parm, &yc);
+                    XY xy = loc_for(lp_lon, lp_lat, this->m_par, m_proj_parm, &yc);
                     xy_x = xy.x; xy_y = xy.y;
                 }
 
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
                 {
-                    PXY t;
+                    XY t;
                     double yc = 0;
 
                     lp_lat = this->m_proj_parm.phi_2;
@@ -184,7 +183,8 @@ namespace boost { namespace geometry { namespace projections
             {
                 double del, sig, s, t, x1, x2, T2, y1, m1, m2, y2;
                 int i;
-                    pj_enfn(par.es, proj_parm.en);
+
+                if (!pj_enfn(par.es, proj_parm.en)) throw proj_exception(0);
                 if( (i = phi12(par, proj_parm, &del, &sig)) != 0)
                     throw proj_exception(i);
                 if (proj_parm.phi_2 < proj_parm.phi_1) { /* make sure proj_parm.phi_1 most southerly */
@@ -225,8 +225,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.Q = (y2 - y1) * t;
                 proj_parm.Pp = (m2 * x1 - m1 * x2) * t;
                 proj_parm.Qp = (x2 - x1) * t;
-                // par.fwd = e_forward;
-                // par.inv = e_inverse;
             }
 
         }} // namespace detail::imw_p
@@ -239,9 +237,12 @@ namespace boost { namespace geometry { namespace projections
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
         \par Projection characteristics
-         - Mod Polyconic
+         - Mod. Polyconic
          - Ellipsoid
-         - lat_1= and lat_2= [lon_1=]
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel
+         - lat_2: Latitude of second standard parallel
+         - lon_1 (degrees)
         \par Example
         \image html ex_imw_p.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/isea.hpp b/include/boost/geometry/extensions/gis/projections/proj/isea.hpp
new file mode 100644
index 000000000..dde5bdaf7
--- /dev/null
+++ b/include/boost/geometry/extensions/gis/projections/proj/isea.hpp
@@ -0,0 +1,1169 @@
+#ifndef BOOST_GEOMETRY_PROJECTIONS_ISEA_HPP
+#define BOOST_GEOMETRY_PROJECTIONS_ISEA_HPP
+
+// Boost.Geometry - extensions-gis-projections (based on PROJ4)
+// This file is automatically generated. DO NOT EDIT.
+
+// Copyright (c) 2008-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// This file is converted from PROJ4, http://trac.osgeo.org/proj
+// PROJ4 is originally written by Gerald Evenden (then of the USGS)
+// PROJ4 is maintained by Frank Warmerdam
+// PROJ4 is converted to Boost.Geometry by Barend Gehrels
+
+// Last updated version of proj: 4.9.1
+
+// Original copyright notice:
+ 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+
+#include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+
+namespace boost { namespace geometry { namespace projections
+{
+    #ifndef DOXYGEN_NO_DETAIL
+    namespace detail { namespace isea
+    {
+
+            static const double E = 52.62263186;
+            static const double F = 10.81231696;
+            static const double DEG60 = 1.04719755119659774614;
+            static const double DEG120 = 2.09439510239319549229;
+            static const double DEG72 = 1.25663706143591729537;
+            static const double DEG90 = 1.57079632679489661922;
+            static const double DEG144 = 2.51327412287183459075;
+            static const double DEG36 = 0.62831853071795864768;
+            static const double DEG108 = 1.88495559215387594306;
+            static const double DEG180 = boost::math::constants::pi<double>();
+            static const double ISEA_SCALE = 0.8301572857837594396028083;
+            static const double V_LAT = 0.46364760899944494524;
+            static const double RAD2DEG = (180.0/boost::math::constants::pi<double>());
+            static const double DEG2RAD = (boost::math::constants::pi<double>()/180.0);
+            static const double E_RAD = 0.91843818702186776133;
+            static const double F_RAD = 0.18871053072122403508;
+            static const double TABLE_G = 0.6615845383;
+            static const double TABLE_H = 0.1909830056;
+            static const double RPRIME = 0.91038328153090290025;
+            static const double PRECISION = 0.0000000000005;
+            static const double ISEA_STD_LAT = 1.01722196792335072101;
+            static const double ISEA_STD_LON = .19634954084936207740;
+
+            #define DOWNTRI(tri) (((tri - 1) / 5) % 2 == 1)
+
+            struct hex {
+                    int iso;
+                    int x, y, z;
+            };
+
+            /* y *must* be positive down as the xy /iso conversion assumes this */
+            static
+            int hex_xy(struct hex *h) {
+                if (!h->iso) return 1;
+                if (h->x >= 0) {
+                    h->y = -h->y - (h->x+1)/2;
+                } else {
+                    /* need to round toward -inf, not toward zero, so x-1 */
+                    h->y = -h->y - h->x/2;
+                }
+                h->iso = 0;
+
+                return 1;
+            }
+
+            static
+            int hex_iso(struct hex *h) {
+                if (h->iso) return 1;
+
+                if (h->x >= 0) {
+                    h->y = (-h->y - (h->x+1)/2);
+                } else {
+                    /* need to round toward -inf, not toward zero, so x-1 */
+                    h->y = (-h->y - (h->x)/2);
+                }
+
+                h->z = -h->x - h->y;
+                h->iso = 1;
+                return 1;
+            }
+
+            static
+            int hexbin2(int horizontal, double width, double x, double y,
+                            int *i, int *j) {
+                double z, rx, ry, rz;
+                double abs_dx, abs_dy, abs_dz;
+                int ix, iy, iz, s;
+                struct hex h;
+
+                x = x / cos(30 * boost::math::constants::pi<double>() / 180.0); /* rotated X coord */
+                y = y - x / 2.0; /* adjustment for rotated X */
+
+                /* adjust for actual hexwidth */
+                x /= width;
+                y /= width;
+
+                z = -x - y;
+
+                ix = rx = floor(x + 0.5);
+                iy = ry = floor(y + 0.5);
+                iz = rz = floor(z + 0.5);
+
+                s = ix + iy + iz;
+
+                if (s) {
+                    abs_dx = fabs(rx - x);
+                    abs_dy = fabs(ry - y);
+                    abs_dz = fabs(rz - z);
+
+                    if (abs_dx >= abs_dy && abs_dx >= abs_dz) {
+                        ix -= s;
+                    } else if (abs_dy >= abs_dx && abs_dy >= abs_dz) {
+                        iy -= s;
+                    } else {
+                        iz -= s;
+                    }
+                }
+                h.x = ix;
+                h.y = iy;
+                h.z = iz;
+                h.iso = 1;
+
+                hex_xy(&h);
+                *i = h.x;
+                *j = h.y;
+                    return ix * 100 + iy;
+            }
+
+            enum isea_poly { ISEA_NONE, ISEA_ICOSAHEDRON = 20 };
+            enum isea_topology { ISEA_HEXAGON=6, ISEA_TRIANGLE=3, ISEA_DIAMOND=4 };
+            enum isea_address_form { ISEA_GEO, ISEA_Q2DI, ISEA_SEQNUM, ISEA_INTERLEAVE,
+                ISEA_PLANE, ISEA_Q2DD, ISEA_PROJTRI, ISEA_VERTEX2DD, ISEA_HEX
+            };
+
+            struct isea_dgg {
+                int    polyhedron; /* ignored, icosahedron */
+                double    o_lat, o_lon, o_az; /* orientation, radians */
+                int    pole; /* true if standard snyder */
+                int    topology; /* ignored, hexagon */
+                int    aperture; /* valid values depend on partitioning method */
+                int    resolution;
+                double    radius; /* radius of the earth in meters, ignored 1.0 */
+                int    output; /* an isea_address_form */
+                int    triangle; /* triangle of last transformed point */
+                int    quad; /* quad of last transformed point */
+                unsigned long serial;
+            };
+
+            struct isea_pt {
+                double x, y;
+            };
+
+            struct isea_geo {
+                double lon, lat;
+            };
+
+            struct isea_address {
+                int    type; /* enum isea_address_form */
+                int    number;
+                double    x,y; /* or i,j or lon,lat depending on type */
+            };
+
+            /* ENDINC */
+
+            enum snyder_polyhedron {
+                SNYDER_POLY_HEXAGON, SNYDER_POLY_PENTAGON,
+                SNYDER_POLY_TETRAHEDRON, SNYDER_POLY_CUBE,
+                SNYDER_POLY_OCTAHEDRON, SNYDER_POLY_DODECAHEDRON,
+                SNYDER_POLY_ICOSAHEDRON
+            };
+
+            struct snyder_constants {
+                double          g, G, theta, ea_w, ea_a, ea_b, g_w, g_a, g_b;
+            };
+
+            /* TODO put these in radians to avoid a later conversion */
+            static
+            struct snyder_constants constants[] = {
+                {23.80018260, 62.15458023, 60.0, 3.75, 1.033, 0.968, 5.09, 1.195, 1.0},
+                {20.07675127, 55.69063953, 54.0, 2.65, 1.030, 0.983, 3.59, 1.141, 1.027},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                {37.37736814, 36.0, 30.0, 17.27, 1.163, 0.860, 13.14, 1.584, 1.0},
+            };
+
+
+            /* sqrt(5)/boost::math::constants::pi<double>() */
+
+            /* 26.565051177 degrees */
+
+
+            static
+            struct isea_geo vertex[] = {
+                {0.0, DEG90},
+                {DEG180, V_LAT},
+                {-DEG108, V_LAT},
+                {-DEG36, V_LAT},
+                {DEG36, V_LAT},
+                {DEG108, V_LAT},
+                {-DEG144, -V_LAT},
+                {-DEG72, -V_LAT},
+                {0.0, -V_LAT},
+                {DEG72, -V_LAT},
+                {DEG144, -V_LAT},
+                {0.0, -DEG90}
+            };
+
+            /* TODO make an isea_pt array of the vertices as well */
+
+            static int      tri_v1[] = {0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 2, 3, 4, 5, 1, 11, 11, 11, 11, 11};
+
+            /* 52.62263186 */
+
+            /* 10.81231696 */
+
+            /* triangle Centers */
+            struct isea_geo icostriangles[] = {
+                {0.0, 0.0},
+                {-DEG144, E_RAD},
+                {-DEG72, E_RAD},
+                {0.0, E_RAD},
+                {DEG72, E_RAD},
+                {DEG144, E_RAD},
+                {-DEG144, F_RAD},
+                {-DEG72, F_RAD},
+                {0.0, F_RAD},
+                {DEG72, F_RAD},
+                {DEG144, F_RAD},
+                {-DEG108, -F_RAD},
+                {-DEG36, -F_RAD},
+                {DEG36, -F_RAD},
+                {DEG108, -F_RAD},
+                {DEG180, -F_RAD},
+                {-DEG108, -E_RAD},
+                {-DEG36, -E_RAD},
+                {DEG36, -E_RAD},
+                {DEG108, -E_RAD},
+                {DEG180, -E_RAD},
+            };
+
+            static double
+            az_adjustment(int triangle)
+            {
+                double          adj;
+
+                struct isea_geo v;
+                struct isea_geo c;
+
+                v = vertex[tri_v1[triangle]];
+                c = icostriangles[triangle];
+
+                /* TODO looks like the adjustment is always either 0 or 180 */
+                /* at least if you pick your vertex carefully */
+                adj = atan2(cos(v.lat) * sin(v.lon - c.lon),
+                        cos(c.lat) * sin(v.lat)
+                        - sin(c.lat) * cos(v.lat) * cos(v.lon - c.lon));
+                return adj;
+            }
+
+            /* R tan(g) sin(60) */
+
+            /* H = 0.25 R tan g = */
+
+
+            static
+            struct isea_pt
+            isea_triangle_xy(int triangle)
+            {
+                struct isea_pt  c;
+                double Rprime = 0.91038328153090290025;
+
+                triangle = (triangle - 1) % 20;
+
+                c.x = TABLE_G * ((triangle % 5) - 2) * 2.0;
+                if (triangle > 9) {
+                    c.x += TABLE_G;
+                }
+                switch (triangle / 5) {
+                case 0:
+                    c.y = 5.0 * TABLE_H;
+                    break;
+                case 1:
+                    c.y = TABLE_H;
+                    break;
+                case 2:
+                    c.y = -TABLE_H;
+                    break;
+                case 3:
+                    c.y = -5.0 * TABLE_H;
+                    break;
+                default:
+                    /* should be impossible */
+                    throw proj_exception();
+                };
+                c.x *= Rprime;
+                c.y *= Rprime;
+
+                return c;
+            }
+
+            /* snyder eq 14 */
+            static double
+            sph_azimuth(double f_lon, double f_lat, double t_lon, double t_lat)
+            {
+                double          az;
+
+                az = atan2(cos(t_lat) * sin(t_lon - f_lon),
+                       cos(f_lat) * sin(t_lat)
+                       - sin(f_lat) * cos(t_lat) * cos(t_lon - f_lon)
+                    );
+                return az;
+            }
+
+            /* coord needs to be in radians */
+            static
+            int
+            isea_snyder_forward(struct isea_geo * ll, struct isea_pt * out)
+            {
+                int             i;
+
+                double          g;
+
+                double          G;
+
+                double          theta;
+
+                /* additional variables from snyder */
+                double          q, Rprime, H, Ag, Azprime, Az, dprime, f, rho,
+                                x, y;
+
+                /* variables used to store intermediate results */
+                double          cot_theta, tan_g, az_offset;
+
+                /* how many multiples of 60 degrees we adjust the azimuth */
+                int             Az_adjust_multiples;
+
+                struct snyder_constants c;
+
+
+                /* TODO put these constants in as radians to begin with */
+                c = constants[SNYDER_POLY_ICOSAHEDRON];
+                theta = c.theta * DEG2RAD;
+                g = c.g * DEG2RAD;
+                G = c.G * DEG2RAD;
+
+                for (i = 1; i <= 20; i++) {
+                    double          z;
+                    struct isea_geo center;
+
+                    center = icostriangles[i];
+
+                    /* step 1 */
+            #if 0
+                    z = sph_distance(center.lon, center.lat, ll->lon, ll->lat);
+            #else
+                    z = acos(sin(center.lat) * sin(ll->lat)
+                         + cos(center.lat) * cos(ll->lat) * cos(ll->lon - center.lon));
+            #endif
+
+                    /* not on this triangle */
+                    if (z > g + 0.000005) { /* TODO DBL_EPSILON */
+                        continue;
+                    }
+                    Az = sph_azimuth(ll->lon, ll->lat, center.lon, center.lat);
+
+                    Az = atan2(cos(ll->lat) * sin(ll->lon - center.lon),
+                           cos(center.lat) * sin(ll->lat)
+                    - sin(center.lat) * cos(ll->lat) * cos(ll->lon - center.lon)
+                        );
+
+                    /* step 2 */
+
+                    /* This calculates "some" vertex coordinate */
+                    az_offset = az_adjustment(i);
+
+                    Az -= az_offset;
+
+                    /* TODO I don't know why we do this.  It's not in snyder */
+                    /* maybe because we should have picked a better vertex */
+                    if (Az < 0.0) {
+                        Az += 2.0 * boost::math::constants::pi<double>();
+                    }
+
+                    Az_adjust_multiples = 0;
+                    while (Az < 0.0) {
+                        Az += DEG120;
+                        Az_adjust_multiples--;
+                    }
+                    while (Az > DEG120 + DBL_EPSILON) {
+                        Az -= DEG120;
+                        Az_adjust_multiples++;
+                    }
+
+                    /* step 3 */
+                    cot_theta = 1.0 / tan(theta);
+                    tan_g = tan(g);    /* TODO this is a constant */
+
+                    /* Calculate q from eq 9. */
+                    /* TODO cot_theta is cot(30) */
+                    q = atan2(tan_g, cos(Az) + sin(Az) * cot_theta);
+
+                    /* not in this triangle */
+                    if (z > q + 0.000005) {
+                        continue;
+                    }
+                    /* step 4 */
+
+                    /* Apply equations 5-8 and 10-12 in order */
+
+                    /* eq 5 */
+                    /* Rprime = 0.9449322893 * R; */
+                    /* R' in the paper is for the truncated */
+                    Rprime = 0.91038328153090290025;
+
+                    /* eq 6 */
+                    H = acos(sin(Az) * sin(G) * cos(g) - cos(Az) * cos(G));
+
+                    /* eq 7 */
+                    /* Ag = (Az + G + H - DEG180) * boost::math::constants::pi<double>() * R * R / DEG180; */
+                    Ag = Az + G + H - DEG180;
+
+                    /* eq 8 */
+                    Azprime = atan2(2.0 * Ag, Rprime * Rprime * tan_g * tan_g - 2.0 * Ag * cot_theta);
+
+                    /* eq 10 */
+                    /* cot(theta) = 1.73205080756887729355 */
+                    dprime = Rprime * tan_g / (cos(Azprime) + sin(Azprime) * cot_theta);
+
+                    /* eq 11 */
+                    f = dprime / (2.0 * Rprime * sin(q / 2.0));
+
+                    /* eq 12 */
+                    rho = 2.0 * Rprime * f * sin(z / 2.0);
+
+
+                    Azprime += DEG120 * Az_adjust_multiples;
+
+                    /* calculate rectangular coordinates */
+
+                    x = rho * sin(Azprime);
+                    y = rho * cos(Azprime);
+
+
+                    out->x = x;
+                    out->y = y;
+
+                    return i;
+                }
+
+
+                fprintf(stderr, "impossible transform: %f %f is not on any triangle\n",
+                    ll->lon * RAD2DEG, ll->lat * RAD2DEG);
+
+                throw proj_exception();
+
+                /* not reached */
+                return 0;        /* supresses a warning */
+            }
+
+
+
+            /* formula from Snyder, Map Projections: A working manual, p31 */
+            static
+            struct isea_geo
+            snyder_ctran(struct isea_geo * np, struct isea_geo * pt)
+            {
+                struct isea_geo npt;
+                double          alpha, phi, lambda, lambda0, beta, lambdap, phip;
+                double          sin_phip;
+                double          lp_b;    /* lambda prime minus beta */
+                double          cos_p, sin_a;
+
+                phi = pt->lat;
+                lambda = pt->lon;
+                alpha = np->lat;
+                beta = np->lon;
+                lambda0 = beta;
+
+                cos_p = cos(phi);
+                sin_a = sin(alpha);
+
+                /* mpawm 5-7 */
+                sin_phip = sin_a * sin(phi) - cos(alpha) * cos_p * cos(lambda - lambda0);
+
+                /* mpawm 5-8b */
+
+                /* use the two argument form so we end up in the right quadrant */
+                lp_b = atan2(cos_p * sin(lambda - lambda0),
+                   (sin_a * cos_p * cos(lambda - lambda0) + cos(alpha) * sin(phi)));
+
+                lambdap = lp_b + beta;
+
+                /* normalize longitude */
+                /* TODO can we just do a modulus ? */
+                lambdap = fmod(lambdap, 2 * boost::math::constants::pi<double>());
+                while (lambdap > boost::math::constants::pi<double>())
+                    lambdap -= 2 * boost::math::constants::pi<double>();
+                while (lambdap < -boost::math::constants::pi<double>())
+                    lambdap += 2 * boost::math::constants::pi<double>();
+
+                phip = asin(sin_phip);
+
+                npt.lat = phip;
+                npt.lon = lambdap;
+
+                return npt;
+            }
+
+            static
+            struct isea_geo
+            isea_ctran(struct isea_geo * np, struct isea_geo * pt, double lon0)
+            {
+                struct isea_geo npt;
+
+                np->lon += boost::math::constants::pi<double>();
+                npt = snyder_ctran(np, pt);
+                np->lon -= boost::math::constants::pi<double>();
+
+                npt.lon -= (boost::math::constants::pi<double>() - lon0 + np->lon);
+
+                npt.lon += boost::math::constants::pi<double>();
+                /* normalize longitude */
+                npt.lon = fmod(npt.lon, 2 * boost::math::constants::pi<double>());
+                while (npt.lon > boost::math::constants::pi<double>())
+                    npt.lon -= 2 * boost::math::constants::pi<double>();
+                while (npt.lon < -boost::math::constants::pi<double>())
+                    npt.lon += 2 * boost::math::constants::pi<double>();
+
+                return npt;
+            }
+
+            /* in radians */
+
+            /* fuller's at 5.2454 west, 2.3009 N, adjacent at 7.46658 deg */
+
+            static
+            int
+            isea_grid_init(struct isea_dgg * g)
+            {
+                if (!g)
+                    return 0;
+
+                g->polyhedron = 20;
+                g->o_lat = ISEA_STD_LAT;
+                g->o_lon = ISEA_STD_LON;
+                g->o_az = 0.0;
+                g->aperture = 4;
+                g->resolution = 6;
+                g->radius = 1.0;
+                g->topology = 6;
+
+                return 1;
+            }
+
+            static
+            int
+            isea_orient_isea(struct isea_dgg * g)
+            {
+                if (!g)
+                    return 0;
+                g->o_lat = ISEA_STD_LAT;
+                g->o_lon = ISEA_STD_LON;
+                g->o_az = 0.0;
+                return 1;
+            }
+
+            static
+            int
+            isea_orient_pole(struct isea_dgg * g)
+            {
+                if (!g)
+                    return 0;
+                g->o_lat = boost::math::constants::pi<double>() / 2.0;
+                g->o_lon = 0.0;
+                g->o_az = 0;
+                return 1;
+            }
+
+            static
+            int
+            isea_transform(struct isea_dgg * g, struct isea_geo * in,
+                       struct isea_pt * out)
+            {
+                struct isea_geo i, pole;
+                int             tri;
+
+                pole.lat = g->o_lat;
+                pole.lon = g->o_lon;
+
+                i = isea_ctran(&pole, in, g->o_az);
+
+                tri = isea_snyder_forward(&i, out);
+                out->x *= g->radius;
+                out->y *= g->radius;
+                g->triangle = tri;
+
+                return tri;
+            }
+
+
+            static
+            void
+            isea_rotate(struct isea_pt * pt, double degrees)
+            {
+                double          rad;
+
+                double          x, y;
+
+                rad = -degrees * boost::math::constants::pi<double>() / 180.0;
+                while (rad >= 2.0 * boost::math::constants::pi<double>()) rad -= 2.0 * boost::math::constants::pi<double>();
+                while (rad <= -2.0 * boost::math::constants::pi<double>()) rad += 2.0 * boost::math::constants::pi<double>();
+
+                x = pt->x * cos(rad) + pt->y * sin(rad);
+                y = -pt->x * sin(rad) + pt->y * cos(rad);
+
+                pt->x = x;
+                pt->y = y;
+            }
+
+            static
+            int isea_tri_plane(int tri, struct isea_pt *pt, double radius) {
+                struct isea_pt tc; /* center of triangle */
+
+                if (DOWNTRI(tri)) {
+                    isea_rotate(pt, 180.0);
+                }
+                tc = isea_triangle_xy(tri);
+                tc.x *= radius;
+                tc.y *= radius;
+                pt->x += tc.x;
+                pt->y += tc.y;
+
+                return tri;
+            }
+
+            /* convert projected triangle coords to quad xy coords, return quad number */
+            static
+            int
+            isea_ptdd(int tri, struct isea_pt *pt) {
+                int             downtri, quad;
+
+                downtri = (((tri - 1) / 5) % 2 == 1);
+                quad = ((tri - 1) % 5) + ((tri - 1) / 10) * 5 + 1;
+
+                isea_rotate(pt, downtri ? 240.0 : 60.0);
+                if (downtri) {
+                    pt->x += 0.5;
+                    /* pt->y += cos(30.0 * boost::math::constants::pi<double>() / 180.0); */
+                    pt->y += .86602540378443864672;
+                }
+                return quad;
+            }
+
+            static
+            int
+            isea_dddi_ap3odd(struct isea_dgg *g, int quad, struct isea_pt *pt, struct isea_pt *di)
+            {
+                struct isea_pt  v;
+                double          hexwidth;
+                double          sidelength;    /* in hexes */
+                int             d, i;
+                int             maxcoord;
+                struct hex      h;
+
+                /* This is the number of hexes from apex to base of a triangle */
+                sidelength = (pow(2.0, g->resolution) + 1.0) / 2.0;
+
+                /* apex to base is cos(30deg) */
+                hexwidth = cos(boost::math::constants::pi<double>() / 6.0) / sidelength;
+
+                /* TODO I think sidelength is always x.5, so
+                 * (int)sidelength * 2 + 1 might be just as good
+                 */
+                maxcoord = (int) (sidelength * 2.0 + 0.5);
+
+                v = *pt;
+                hexbin2(0, hexwidth, v.x, v.y, &h.x, &h.y);
+                h.iso = 0;
+                hex_iso(&h);
+
+                d = h.x - h.z;
+                i = h.x + h.y + h.y;
+
+                if (quad <= 5) {
+                    if (d == 0 && i == maxcoord) {
+                        /* north pole */
+                        quad = 0;
+                        d = 0;
+                        i = 0;
+                    } else if (i == maxcoord) {
+                        /* upper right in next quad */
+                        quad += 1;
+                        if (quad == 6)
+                            quad = 1;
+                        i = maxcoord - d;
+                        d = 0;
+                    } else if (d == maxcoord) {
+                        /* lower right in quad to lower right */
+                        quad += 5;
+                        d = 0;
+                    }
+                } else if (quad >= 6) {
+                    if (i == 0 && d == maxcoord) {
+                        /* south pole */
+                        quad = 11;
+                        d = 0;
+                        i = 0;
+                    } else if (d == maxcoord) {
+                        /* lower right in next quad */
+                        quad += 1;
+                        if (quad == 11)
+                            quad = 6;
+                        d = maxcoord - i;
+                        i = 0;
+                    } else if (i == maxcoord) {
+                        /* upper right in quad to upper right */
+                        quad = (quad - 4) % 5;
+                        i = 0;
+                    }
+                }
+
+                di->x = d;
+                di->y = i;
+
+                g->quad = quad;
+                return quad;
+            }
+
+            static
+            int
+            isea_dddi(struct isea_dgg *g, int quad, struct isea_pt *pt, struct isea_pt *di) {
+                struct isea_pt  v;
+                double          hexwidth;
+                int             sidelength;    /* in hexes */
+                struct hex      h;
+
+                if (g->aperture == 3 && g->resolution % 2 != 0) {
+                    return isea_dddi_ap3odd(g, quad, pt, di);
+                }
+                /* todo might want to do this as an iterated loop */
+                if (g->aperture >0) {
+                    sidelength = (int) (pow(g->aperture, g->resolution / 2.0) + 0.5);
+                } else {
+                    sidelength = g->resolution;
+                }
+
+                hexwidth = 1.0 / sidelength;
+
+                v = *pt;
+                isea_rotate(&v, -30.0);
+                hexbin2(0, hexwidth, v.x, v.y, &h.x, &h.y);
+                h.iso = 0;
+                hex_iso(&h);
+
+                /* we may actually be on another quad */
+                if (quad <= 5) {
+                    if (h.x == 0 && h.z == -sidelength) {
+                        /* north pole */
+                        quad = 0;
+                        h.z = 0;
+                        h.y = 0;
+                        h.x = 0;
+                    } else if (h.z == -sidelength) {
+                        quad = quad + 1;
+                        if (quad == 6)
+                            quad = 1;
+                        h.y = sidelength - h.x;
+                        h.z = h.x - sidelength;
+                        h.x = 0;
+                    } else if (h.x == sidelength) {
+                        quad += 5;
+                        h.y = -h.z;
+                        h.x = 0;
+                    }
+                } else if (quad >= 6) {
+                    if (h.z == 0 && h.x == sidelength) {
+                        /* south pole */
+                        quad = 11;
+                        h.x = 0;
+                        h.y = 0;
+                        h.z = 0;
+                    } else if (h.x == sidelength) {
+                        quad = quad + 1;
+                        if (quad == 11)
+                            quad = 6;
+                        h.x = h.y + sidelength;
+                        h.y = 0;
+                        h.z = -h.x;
+                    } else if (h.y == -sidelength) {
+                        quad -= 4;
+                        h.y = 0;
+                        h.z = -h.x;
+                    }
+                }
+                di->x = h.x;
+                di->y = -h.z;
+
+                g->quad = quad;
+                return quad;
+            }
+
+            static
+            int isea_ptdi(struct isea_dgg *g, int tri, struct isea_pt *pt,
+                           struct isea_pt *di) {
+                struct isea_pt  v;
+                int             quad;
+
+                v = *pt;
+                quad = isea_ptdd(tri, &v);
+                quad = isea_dddi(g, quad, &v, di);
+                return quad;
+            }
+
+            /* q2di to seqnum */
+            static
+            int isea_disn(struct isea_dgg *g, int quad, struct isea_pt *di) {
+                int             sidelength;
+                int             sn, height;
+                int             hexes;
+
+                if (quad == 0) {
+                    g->serial = 1;
+                    return g->serial;
+                }
+                /* hexes in a quad */
+                hexes = (int) (pow(g->aperture, g->resolution) + 0.5);
+                if (quad == 11) {
+                    g->serial = 1 + 10 * hexes + 1;
+                    return g->serial;
+                }
+                if (g->aperture == 3 && g->resolution % 2 == 1) {
+                    height = (int) (pow(g->aperture, (g->resolution - 1) / 2.0));
+                    sn = ((int) di->x) * height;
+                    sn += ((int) di->y) / height;
+                    sn += (quad - 1) * hexes;
+                    sn += 2;
+                } else {
+                    sidelength = (int) (pow(g->aperture, g->resolution / 2.0) + 0.5);
+                    sn = (quad - 1) * hexes + sidelength * di->x + di->y + 2;
+                }
+
+                g->serial = sn;
+                return sn;
+            }
+
+            /* TODO just encode the quad in the d or i coordinate
+             * quad is 0-11, which can be four bits.
+             * d' = d << 4 + q, d = d' >> 4, q = d' & 0xf
+             */
+            /* convert a q2di to global hex coord */
+            static
+            int isea_hex(struct isea_dgg *g, int tri,
+                    struct isea_pt *pt, struct isea_pt *hex) {
+                struct isea_pt v;
+                int sidelength;
+                int d, i, x, y, quad;
+
+                quad = isea_ptdi(g, tri, pt, &v);
+
+                hex->x = ((int)v.x << 4) + quad;
+                hex->y = v.y;
+
+                return 1;
+
+                d = v.x;
+                i = v.y;
+
+                /* Aperture 3 odd resolutions */
+                if (g->aperture == 3 && g->resolution % 2 != 0) {
+                    int offset = (int)(pow(3.0, g->resolution - 1) + 0.5);
+
+                    d += offset * ((g->quad-1) % 5);
+                    i += offset * ((g->quad-1) % 5);
+
+                    if (quad == 0) {
+                        d = 0;
+                        i = offset;
+                    } else if (quad == 11) {
+                        d = 2 * offset;
+                        i = 0;
+                    } else if (quad > 5) {
+                        d += offset;
+                    }
+
+                    x = (2*d - i) /3;
+                    y = (2*i - d) /3;
+
+                    hex->x = x + offset / 3;
+                    hex->y = y + 2 * offset / 3;
+                    return 1;
+                }
+
+                /* aperture 3 even resolutions and aperture 4 */
+                sidelength = (int) (pow(g->aperture, g->resolution / 2.0) + 0.5);
+                if (g->quad == 0) {
+                    hex->x = 0;
+                    hex->y = sidelength;
+                } else if (g->quad == 11) {
+                    hex->x = sidelength * 2;
+                    hex->y = 0;
+                } else {
+                    hex->x = d + sidelength * ((g->quad-1) % 5);
+                    if (g->quad > 5) hex->x += sidelength;
+                    hex->y = i + sidelength * ((g->quad-1) % 5);
+                }
+
+                return 1;
+            }
+
+            static
+            struct isea_pt
+            isea_forward(struct isea_dgg *g, struct isea_geo *in)
+            {
+                int             tri, downtri;
+                struct isea_pt  out, coord;
+
+                tri = isea_transform(g, in, &out);
+
+                downtri = (((tri - 1) / 5) % 2 == 1);
+
+                if (g->output == ISEA_PLANE) {
+                    isea_tri_plane(tri, &out, g->radius);
+                    return out;
+                }
+
+                /* convert to isea standard triangle size */
+                out.x = out.x / g->radius * ISEA_SCALE;
+                out.y = out.y / g->radius * ISEA_SCALE;
+                out.x += 0.5;
+                out.y += 2.0 * .14433756729740644112;
+
+                switch (g->output) {
+                case ISEA_PROJTRI:
+                    /* nothing to do, already in projected triangle */
+                    break;
+                case ISEA_VERTEX2DD:
+                    g->quad = isea_ptdd(tri, &out);
+                    break;
+                case ISEA_Q2DD:
+                    /* Same as above, we just don't print as much */
+                    g->quad = isea_ptdd(tri, &out);
+                    break;
+                case ISEA_Q2DI:
+                    g->quad = isea_ptdi(g, tri, &out, &coord);
+                    return coord;
+                    break;
+                case ISEA_SEQNUM:
+                    isea_ptdi(g, tri, &out, &coord);
+                    /* disn will set g->serial */
+                    isea_disn(g, g->quad, &coord);
+                    return coord;
+                    break;
+                case ISEA_HEX:
+                    isea_hex(g, tri, &out, &coord);
+                    return coord;
+                    break;
+                }
+
+                return out;
+            }
+
+            struct par_isea
+            {
+                struct isea_dgg dgg;
+            };
+
+            // template class, using CRTP to implement forward/inverse
+            template <typename Geographic, typename Cartesian, typename Parameters>
+            struct base_isea_spheroid : public base_t_f<base_isea_spheroid<Geographic, Cartesian, Parameters>,
+                     Geographic, Cartesian, Parameters>
+            {
+
+                 typedef double geographic_type;
+                 typedef double cartesian_type;
+
+                par_isea m_proj_parm;
+
+                inline base_isea_spheroid(const Parameters& par)
+                    : base_t_f<base_isea_spheroid<Geographic, Cartesian, Parameters>,
+                     Geographic, Cartesian, Parameters>(*this, par) {}
+
+                inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
+                {
+                    struct isea_pt out;
+                    struct isea_geo in;
+
+                    in.lon = lp_lon;
+                    in.lat = lp_lat;
+
+                    isea_dgg copy = this->m_proj_parm.dgg;
+                    out = isea_forward(&copy, &in);
+
+                    xy_x = out.x;
+                    xy_y = out.y;
+                }
+            };
+
+            // Icosahedral Snyder Equal Area
+            template <typename Parameters>
+            void setup_isea(Parameters& par, par_isea& proj_parm)
+            {
+                std::string opt;
+
+                    isea_grid_init(&proj_parm.dgg);
+
+                    proj_parm.dgg.output = ISEA_PLANE;
+            /*        proj_parm.dgg.radius = par.a; / * otherwise defaults to 1 */
+                /* calling library will scale, I think */
+
+                opt = pj_param(par.params, "sorient").s;
+                if (! opt.empty()) {
+                    if (opt == std::string("isea")) {
+                        isea_orient_isea(&proj_parm.dgg);
+                    } else if (opt == std::string("pole")) {
+                        isea_orient_pole(&proj_parm.dgg);
+                    } else {
+                        throw proj_exception(-34);
+                    }
+                }
+
+                if (pj_param(par.params, "tazi").i) {
+                    proj_parm.dgg.o_az = pj_param(par.params, "razi").f;
+                }
+
+                if (pj_param(par.params, "tlon_0").i) {
+                    proj_parm.dgg.o_lon = pj_param(par.params, "rlon_0").f;
+                }
+
+                if (pj_param(par.params, "tlat_0").i) {
+                    proj_parm.dgg.o_lat = pj_param(par.params, "rlat_0").f;
+                }
+
+                if (pj_param(par.params, "taperture").i) {
+                    proj_parm.dgg.aperture = pj_param(par.params, "iaperture").i;
+                }
+
+                if (pj_param(par.params, "tresolution").i) {
+                    proj_parm.dgg.resolution = pj_param(par.params, "iresolution").i;
+                }
+
+                opt = pj_param(par.params, "smode").s;
+                if (! opt.empty()) {
+                    if (opt == std::string("plane")) {
+                        proj_parm.dgg.output = ISEA_PLANE;
+                    } else if (opt == std::string("di")) {
+                        proj_parm.dgg.output = ISEA_Q2DI;
+                    }
+                    else if (opt == std::string("dd")) {
+                        proj_parm.dgg.output = ISEA_Q2DD;
+                    }
+                    else if (opt == std::string("hex")) {
+                        proj_parm.dgg.output = ISEA_HEX;
+                    }
+                    else {
+                        /* TODO verify error code.  Possibly eliminate magic */
+                        throw proj_exception(-34);
+                    }
+                }
+
+                if (pj_param(par.params, "trescale").i) {
+                    proj_parm.dgg.radius = ISEA_SCALE;
+                }
+
+                if (pj_param(par.params, "tresolution").i) {
+                    proj_parm.dgg.resolution = pj_param(par.params, "iresolution").i;
+                } else {
+                    proj_parm.dgg.resolution = 4;
+                }
+
+                if (pj_param(par.params, "taperture").i) {
+                    proj_parm.dgg.aperture = pj_param(par.params, "iaperture").i;
+                } else {
+                    proj_parm.dgg.aperture = 3;
+                }
+            }
+
+        }} // namespace detail::isea
+    #endif // doxygen
+
+    /*!
+        \brief Icosahedral Snyder Equal Area projection
+        \ingroup projections
+        \tparam Geographic latlong point type
+        \tparam Cartesian xy point type
+        \tparam Parameters parameter type
+        \par Projection characteristics
+         - Spheroid
+        \par Projection parameters
+         - orient (string)
+         - azi: Azimuth (or Gamma) (degrees)
+         - lon_0: Central meridian (degrees)
+         - lat_0: Latitude of origin (degrees)
+         - aperture (integer)
+         - resolution (integer)
+         - mode (string)
+         - rescale
+        \par Example
+        \image html ex_isea.gif
+    */
+    template <typename Geographic, typename Cartesian, typename Parameters = parameters>
+    struct isea_spheroid : public detail::isea::base_isea_spheroid<Geographic, Cartesian, Parameters>
+    {
+        inline isea_spheroid(const Parameters& par) : detail::isea::base_isea_spheroid<Geographic, Cartesian, Parameters>(par)
+        {
+            detail::isea::setup_isea(this->m_par, this->m_proj_parm);
+        }
+    };
+
+    #ifndef DOXYGEN_NO_DETAIL
+    namespace detail
+    {
+
+        // Factory entry(s)
+        template <typename Geographic, typename Cartesian, typename Parameters>
+        class isea_entry : public detail::factory_entry<Geographic, Cartesian, Parameters>
+        {
+            public :
+                virtual projection<Geographic, Cartesian>* create_new(const Parameters& par) const
+                {
+                    return new base_v_f<isea_spheroid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
+                }
+        };
+
+        template <typename Geographic, typename Cartesian, typename Parameters>
+        inline void isea_init(detail::base_factory<Geographic, Cartesian, Parameters>& factory)
+        {
+            factory.add_to_factory("isea", new isea_entry<Geographic, Cartesian, Parameters>);
+        }
+
+    } // namespace detail
+    #endif // doxygen
+
+}}} // namespace boost::geometry::projections
+
+#endif // BOOST_GEOMETRY_PROJECTIONS_ISEA_HPP
+
diff --git a/include/boost/geometry/extensions/gis/projections/proj/krovak.hpp b/include/boost/geometry/extensions/gis/projections/proj/krovak.hpp
index 49bd7d885..4fb912e5a 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/krovak.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/krovak.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,17 +46,14 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace krovak{
+    namespace detail { namespace krovak
+    {
 
             struct par_krovak
             {
                 double    C_x;
             };
 
-
-
-
-
             /**
                NOTES: According to EPSG the full Krovak projection method should have
                       the following parameters.  Within PROJ.4 the azimuth, and pseudo
@@ -82,9 +77,6 @@ namespace boost { namespace geometry { namespace projections
 
              **/
 
-
-
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_krovak_ellipsoid : public base_t_fi<base_krovak_ellipsoid<Geographic, Cartesian, Parameters>,
@@ -161,13 +153,8 @@ namespace boost { namespace geometry { namespace projections
                         xy_y *= -1.0;
                         xy_x *= -1.0;
                       }
-
-                            return;
                 }
 
-
-
-
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
                 {
                     /* calculate lat/lon from xy */
@@ -247,10 +234,7 @@ namespace boost { namespace geometry { namespace projections
                    while (ok==0);
 
                    lp_lon -= this->m_par.lam0;
-
-                            return;
                 }
-
             };
 
             // Krovak
@@ -260,25 +244,29 @@ namespace boost { namespace geometry { namespace projections
                 double ts;
                 /* read some Parameters,
                  * here Latitude Truescale */
+
                 ts = pj_param(par.params, "rlat_ts").f;
                 proj_parm.C_x = ts;
+
                 /* we want Bessel as fixed ellipsoid */
                 par.a = 6377397.155;
                 par.e = sqrt(par.es = 0.006674372230614);
+
                     /* if latitude of projection center is not set, use 49d30'N */
                 if (!pj_param(par.params, "tlat_0").i)
                         par.phi0 = 0.863937979737193;
+
                     /* if center long is not set use 42d30'E of Ferro - 17d40' for Ferro */
                     /* that will correspond to using longitudes relative to greenwich    */
                     /* as input and output, instead of lat/long relative to Ferro */
                 if (!pj_param(par.params, "tlon_0").i)
                         par.lam0 = 0.7417649320975901 - 0.308341501185665;
+
                     /* if scale not set default to 0.9999 */
                 if (!pj_param(par.params, "tk").i)
                         par.k0 = 0.9999;
+
                 /* always the same */
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
             }
 
         }} // namespace detail::krovak
@@ -292,7 +280,12 @@ namespace boost { namespace geometry { namespace projections
         \tparam Parameters parameter type
         \par Projection characteristics
          - Pseudocylindrical
-         - Ellps
+         - Ellipsoid
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
+         - lat_0: Latitude of origin
+         - lon_0: Central meridian
+         - k: Scale factor on the pseudo standard parallel
         \par Example
         \image html ex_krovak.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/labrd.hpp b/include/boost/geometry/extensions/gis/projections/proj/labrd.hpp
index 3a46dd486..31d70121a 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/labrd.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/labrd.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace labrd{
+    namespace detail { namespace labrd
+    {
+
             static const double EPS = 1.e-10;
 
             struct par_labrd
@@ -157,6 +157,7 @@ namespace boost { namespace geometry { namespace projections
             void setup_labrd(Parameters& par, par_labrd& proj_parm)
             {
                 double Az, sinp, R, N, t;
+
                 proj_parm.rot    = pj_param(par.params, "bno_rot").i == 0;
                 Az = pj_param(par.params, "razi").f;
                 sinp = sin(par.phi0);
@@ -175,8 +176,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.Cb *= sin(t);
                 proj_parm.Cc = 3. * (proj_parm.Ca * proj_parm.Ca - proj_parm.Cb * proj_parm.Cb);
                 proj_parm.Cd = 6. * proj_parm.Ca * proj_parm.Cb;
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
             }
 
         }} // namespace detail::labrd
@@ -192,6 +191,9 @@ namespace boost { namespace geometry { namespace projections
          - Cylindrical
          - Spheroid
          - Special for Madagascar
+        \par Projection parameters
+         - no_rot: No rotation (boolean)
+         - azi: Azimuth (or Gamma) (degrees)
         \par Example
         \image html ex_labrd.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/laea.hpp b/include/boost/geometry/extensions/gis/projections/proj/laea.hpp
index e07b4af4d..882fec716 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/laea.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/laea.hpp
@@ -44,13 +44,15 @@
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
-#include <boost/geometry/extensions/gis/projections/impl/pj_qsfn.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_auth.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/pj_qsfn.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace laea{
+    namespace detail { namespace laea
+    {
+
             static const double EPS10 = 1.e-10;
             static const int NITER = 20;
             static const double CONV = 1.e-10;
@@ -269,6 +271,7 @@ namespace boost { namespace geometry { namespace projections
             void setup_laea(Parameters& par, par_laea& proj_parm)
             {
                 double t;
+
                 if (fabs((t = fabs(par.phi0)) - HALFPI) < EPS10)
                     proj_parm.mode = par.phi0 < 0. ? S_POLE : N_POLE;
                 else if (fabs(t) < EPS10)
@@ -277,6 +280,7 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.mode = OBLIQ;
                 if (par.es) {
                     double sinphi;
+
                     par.e = sqrt(par.es);
                     proj_parm.qp = pj_qsfn(1., par.e, par.one_es);
                     proj_parm.mmf = .5 / (1. - par.es);
@@ -302,15 +306,11 @@ namespace boost { namespace geometry { namespace projections
                         proj_parm.xmf *= proj_parm.dd;
                         break;
                     }
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                 } else {
                     if (proj_parm.mode == OBLIQ) {
                         proj_parm.sinb1 = sin(par.phi0);
                         proj_parm.cosb1 = cos(par.phi0);
                     }
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 }
             }
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/lagrng.hpp b/include/boost/geometry/extensions/gis/projections/proj/lagrng.hpp
index 71c2a4016..705939f30 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/lagrng.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/lagrng.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace lagrng{
+    namespace detail { namespace lagrng
+    {
+
             static const double TOL = 1e-10;
 
             struct par_lagrng
@@ -96,13 +96,13 @@ namespace boost { namespace geometry { namespace projections
             void setup_lagrng(Parameters& par, par_lagrng& proj_parm)
             {
                 double phi1;
+
                 if ((proj_parm.rw = pj_param(par.params, "dW").f) <= 0) throw proj_exception(-27);
                 proj_parm.hrw = 0.5 * (proj_parm.rw = 1. / proj_parm.rw);
                 phi1 = pj_param(par.params, "rlat_1").f;
                 if (fabs(fabs(phi1 = sin(phi1)) - 1.) < TOL) throw proj_exception(-22);
                 proj_parm.a1 = pow((1. - phi1)/(1. + phi1), proj_parm.hrw);
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::lagrng
@@ -118,7 +118,9 @@ namespace boost { namespace geometry { namespace projections
          - Miscellaneous
          - Spheroid
          - no inverse
-         - W=
+        \par Projection parameters
+         - W (real)
+         - lat_1: Latitude of first standard parallel (degrees)
         \par Example
         \image html ex_lagrng.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/larr.hpp b/include/boost/geometry/extensions/gis/projections/proj/larr.hpp
index 45cff26f8..7a512b4eb 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/larr.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/larr.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,9 +46,10 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace larr{
-            static const double SIXTH = .16666666666666666;
+    namespace detail { namespace larr
+    {
 
+            static const double SIXTH = .16666666666666666;
 
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
@@ -77,8 +76,6 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup_larr(Parameters& par)
             {
-                // par.fwd = s_forward;
-                // par.inv = 0;
                 par.es = 0.;
             }
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/lask.hpp b/include/boost/geometry/extensions/gis/projections/proj/lask.hpp
index 2111b5791..f8f576a22 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/lask.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/lask.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace lask{
+    namespace detail { namespace lask
+    {
+
             static const double a10 = 0.975534;
             static const double a12 = -0.119161;
             static const double a32 = -0.0143059;
@@ -60,7 +60,6 @@ namespace boost { namespace geometry { namespace projections
             static const double b23 = -0.0285500;
             static const double b05 = -0.0491032;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_lask_spheroid : public base_t_f<base_lask_spheroid<Geographic, Cartesian, Parameters>,
@@ -91,8 +90,6 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup_lask(Parameters& par)
             {
-                // par.fwd = s_forward;
-                // par.inv = 0;
                 par.es = 0.;
             }
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/latlong.hpp b/include/boost/geometry/extensions/gis/projections/proj/latlong.hpp
index 75e6ab90f..637c9931a 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/latlong.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/latlong.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -50,12 +48,11 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace latlong{
-
+    namespace detail { namespace latlong
+    {
 
             /* very loosely based upon DMA code by Bradford W. Drew */
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_latlong_other : public base_t_fi<base_latlong_other<Geographic, Cartesian, Parameters>,
@@ -72,14 +69,12 @@ namespace boost { namespace geometry { namespace projections
 
                 inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
                 {
-
                         xy_x = lp_lon / this->m_par.a;
                         xy_y = lp_lat / this->m_par.a;
                 }
 
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
                 {
-
                         lp_lat = xy_y * this->m_par.a;
                         lp_lon = xy_x * this->m_par.a;
                 }
@@ -92,8 +87,6 @@ namespace boost { namespace geometry { namespace projections
                     par.is_latlong = 1;
                     par.x0 = 0.0;
                     par.y0 = 0.0;
-                // par.inv = inverse;
-                // par.fwd = forward;
             }
 
             // Lat/long (Geodetic alias)
@@ -103,8 +96,6 @@ namespace boost { namespace geometry { namespace projections
                     par.is_latlong = 1;
                     par.x0 = 0.0;
                     par.y0 = 0.0;
-                // par.inv = inverse;
-                // par.fwd = forward;
             }
 
             // Lat/long (Geodetic alias)
@@ -114,8 +105,6 @@ namespace boost { namespace geometry { namespace projections
                     par.is_latlong = 1;
                     par.x0 = 0.0;
                     par.y0 = 0.0;
-                // par.inv = inverse;
-                // par.fwd = forward;
             }
 
             // Lat/long (Geodetic alias)
@@ -125,8 +114,6 @@ namespace boost { namespace geometry { namespace projections
                     par.is_latlong = 1;
                     par.x0 = 0.0;
                     par.y0 = 0.0;
-                // par.inv = inverse;
-                // par.fwd = forward;
             }
 
         }} // namespace detail::latlong
@@ -138,7 +125,6 @@ namespace boost { namespace geometry { namespace projections
         \tparam Geographic latlong point type
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
-        \par Projection characteristics
         \par Example
         \image html ex_lonlat.gif
     */
@@ -157,7 +143,6 @@ namespace boost { namespace geometry { namespace projections
         \tparam Geographic latlong point type
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
-        \par Projection characteristics
         \par Example
         \image html ex_latlon.gif
     */
@@ -176,7 +161,6 @@ namespace boost { namespace geometry { namespace projections
         \tparam Geographic latlong point type
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
-        \par Projection characteristics
         \par Example
         \image html ex_latlong.gif
     */
@@ -195,7 +179,6 @@ namespace boost { namespace geometry { namespace projections
         \tparam Geographic latlong point type
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
-        \par Projection characteristics
         \par Example
         \image html ex_longlat.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/lcc.hpp b/include/boost/geometry/extensions/gis/projections/proj/lcc.hpp
index 088a0cbe5..b75533d21 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/lcc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/lcc.hpp
@@ -45,15 +45,17 @@
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_msfn.hpp>
-#include <boost/geometry/extensions/gis/projections/impl/pj_tsfn.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_phi2.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/pj_tsfn.hpp>
 
 #include <boost/geometry/extensions/gis/projections/epsg_traits.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace lcc{
+    namespace detail { namespace lcc
+    {
+
             static const double EPS10 = 1.e-10;
 
             struct par_lcc
@@ -75,7 +77,7 @@ namespace boost { namespace geometry { namespace projections
                  typedef double geographic_type;
                  typedef double cartesian_type;
 
-                mutable par_lcc m_proj_parm;
+                par_lcc m_proj_parm;
 
                 inline base_lcc_ellipsoid(const Parameters& par)
                     : base_t_fi<base_lcc_ellipsoid<Geographic, Cartesian, Parameters>,
@@ -143,6 +145,7 @@ namespace boost { namespace geometry { namespace projections
             {
                 double cosphi, sinphi;
                 int secant;
+
                 proj_parm.phi1 = pj_param(par.params, "rlat_1").f;
                 if (pj_param(par.params, "tlat_2").i)
                     proj_parm.phi2 = pj_param(par.params, "rlat_2").f;
@@ -157,6 +160,7 @@ namespace boost { namespace geometry { namespace projections
                 secant = fabs(proj_parm.phi1 - proj_parm.phi2) >= EPS10;
                 if( (proj_parm.ellips = (par.es != 0.)) ) {
                     double ml1, m1;
+
                     par.e = sqrt(par.es);
                     m1 = pj_msfn(sinphi, cosphi, par.es);
                     ml1 = pj_tsfn(proj_parm.phi1, sinphi, par.e);
@@ -177,9 +181,6 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.rho0 = (fabs(fabs(par.phi0) - HALFPI) < EPS10) ? 0. :
                         proj_parm.c * pow(tan(FORTPI + .5 * par.phi0), -proj_parm.n);
                 }
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
-                // par.spc = fac;
             }
 
         }} // namespace detail::lcc
@@ -195,7 +196,10 @@ namespace boost { namespace geometry { namespace projections
          - Conic
          - Spheroid
          - Ellipsoid
-         - lat_1= and lat_2= or lat_0
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel (degrees)
+         - lat_2: Latitude of second standard parallel (degrees)
+         - lat_0: Latitude of origin
         \par Example
         \image html ex_lcc.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/lcca.hpp b/include/boost/geometry/extensions/gis/projections/proj/lcca.hpp
index 37737793b..dab07c140 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/lcca.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/lcca.hpp
@@ -38,7 +38,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
+#include <boost/core/ignore_unused.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
@@ -49,7 +49,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace lcca{
+    namespace detail { namespace lcca
+    {
+
             static const int MAX_ITER = 10;
             static const double DEL_TOL = 1e-12;
 
@@ -60,12 +62,11 @@ namespace boost { namespace geometry { namespace projections
                 double    C;
             };
 
-
-                inline double /* func to compute dr */
+                static double /* func to compute dr */
             fS(double S, double C) {
                     return(S * ( 1. + S * S * C));
             }
-                inline double /* deriv of fs */
+                static double /* deriv of fs */
             fSp(double S, double C) {
                 return(1. + 3.* S * S * C);
             }
@@ -114,6 +115,13 @@ namespace boost { namespace geometry { namespace projections
                     if (!i) throw proj_exception();
                     lp_lat = pj_inv_mlfn(S + this->m_proj_parm.M0, this->m_par.es, this->m_proj_parm.en);
                 }
+
+            private :
+                inline void ignore_unused()
+                {
+                    boost::ignore_unused(fSp);
+                }
+
             };
 
             // Lambert Conformal Conic Alternative
@@ -121,8 +129,8 @@ namespace boost { namespace geometry { namespace projections
             void setup_lcca(Parameters& par, par_lcca& proj_parm)
             {
                 double s2p0, N0, R0, tan0, tan20;
-                boost::ignore_unused(tan20);
-                    pj_enfn(par.es, proj_parm.en);
+
+                if (!pj_enfn(par.es, proj_parm.en)) throw proj_exception(0);
                 if (!pj_param(par.params, "tlat_0").i) throw proj_exception(50);
                 if (par.phi0 == 0.) throw proj_exception(51);
                 proj_parm.l = sin(par.phi0);
@@ -135,8 +143,7 @@ namespace boost { namespace geometry { namespace projections
                 tan20 = tan0 * tan0;
                 proj_parm.r0 = N0 / tan0;
                 proj_parm.C = 1. / (6. * R0 * N0);
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
+                boost::ignore_unused(tan20);
             }
 
         }} // namespace detail::lcca
@@ -152,7 +159,8 @@ namespace boost { namespace geometry { namespace projections
          - Conic
          - Spheroid
          - Ellipsoid
-         - lat_0=
+        \par Projection parameters
+         - lat_0: Latitude of origin
         \par Example
         \image html ex_lcca.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/loxim.hpp b/include/boost/geometry/extensions/gis/projections/proj/loxim.hpp
index 7eba713b0..a46e15fb2 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/loxim.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/loxim.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace loxim{
+    namespace detail { namespace loxim
+    {
+
             static const double EPS = 1e-8;
 
             struct par_loxim
@@ -108,8 +108,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.phi1 = pj_param(par.params, "rlat_1").f;
                 if ((proj_parm.cosphi1 = cos(proj_parm.phi1)) < EPS) throw proj_exception(-22);
                 proj_parm.tanphi1 = tan(FORTPI + 0.5 * proj_parm.phi1);
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
@@ -125,6 +123,8 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Pseudocylindrical
          - Spheroid
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel (degrees)
         \par Example
         \image html ex_loxim.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/lsat.hpp b/include/boost/geometry/extensions/gis/projections/proj/lsat.hpp
index 2061750ca..70308b292 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/lsat.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/lsat.hpp
@@ -38,17 +38,18 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace lsat{
+    namespace detail { namespace lsat
+    {
+
             static const double TOL = 1e-7;
             static const double PI_HALFPI = 4.71238898038468985766;
             static const double TWOPI_HALFPI = 7.85398163397448309610;
@@ -58,9 +59,10 @@ namespace boost { namespace geometry { namespace projections
                 double a2, a4, b, c1, c3;
                 double q, t, u, w, p22, sa, ca, xj, rlm, rlm2;
             };
+
             /* based upon Snyder and Linck, USGS-NMD */
             template <typename Parameters>
-                inline void
+                static void
             seraz0(double lam, double mult, Parameters& par, par_lsat& proj_parm) {
                 double sdsq, h, s, fc, sd, sq, d__1;
 
@@ -198,6 +200,7 @@ namespace boost { namespace geometry { namespace projections
             {
                 int land, path;
                 double lam, alf, esc, ess;
+
                 land = pj_param(par.params, "ilsat").i;
                 if (land <= 0 || land > 5) throw proj_exception(-28);
                 path = pj_param(par.params, "ipath").i;
@@ -228,13 +231,9 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.rlm2 = proj_parm.rlm + TWOPI;
                 proj_parm.a2 = proj_parm.a4 = proj_parm.b = proj_parm.c1 = proj_parm.c3 = 0.;
                 seraz0(0., 1., par, proj_parm);
-                for (lam = 9.;
-             lam <= 81.0001;
-             lam += 18.)
+                for (lam = 9.; lam <= 81.0001; lam += 18.)
                     seraz0(lam, 4., par, proj_parm);
-                for (lam = 18;
-             lam <= 72.0001;
-             lam += 18.)
+                for (lam = 18; lam <= 72.0001; lam += 18.)
                     seraz0(lam, 2., par, proj_parm);
                 seraz0(90., 1., par, proj_parm);
                 proj_parm.a2 /= 30.;
@@ -242,8 +241,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.b /= 30.;
                 proj_parm.c1 /= 15.;
                 proj_parm.c3 /= 45.;
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
             }
 
         }} // namespace detail::lsat
@@ -259,7 +256,9 @@ namespace boost { namespace geometry { namespace projections
          - Cylindrical
          - Spheroid
          - Ellipsoid
-         - lsat= path=
+        \par Projection parameters
+         - lsat (integer)
+         - path (integer)
         \par Example
         \image html ex_lsat.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/mbt_fps.hpp b/include/boost/geometry/extensions/gis/projections/proj/mbt_fps.hpp
index 0abb4ee4f..db592c1b5 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/mbt_fps.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/mbt_fps.hpp
@@ -38,17 +38,18 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace mbt_fps{
+    namespace detail { namespace mbt_fps
+    {
+
             static const int MAX_ITER = 10;
             static const double LOOP_TOL = 1e-7;
             static const double C1 = 0.45503;
@@ -58,7 +59,6 @@ namespace boost { namespace geometry { namespace projections
             static const double C_y = 1.44492;
             static const double C1_2 = 0.33333333333333333333333333;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_mbt_fps_spheroid : public base_t_fi<base_mbt_fps_spheroid<Geographic, Cartesian, Parameters>,
@@ -106,8 +106,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_mbt_fps(Parameters& par)
             {
                 par.es = 0;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::mbt_fps
diff --git a/include/boost/geometry/extensions/gis/projections/proj/mbtfpp.hpp b/include/boost/geometry/extensions/gis/projections/proj/mbtfpp.hpp
index b552f82aa..a53e6ef83 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/mbtfpp.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/mbtfpp.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace mbtfpp{
+    namespace detail { namespace mbtfpp
+    {
+
             static const double CS_ = .95257934441568037152;
             static const double FXC = .92582009977255146156;
             static const double FYC = 3.40168025708304504493;
@@ -56,7 +56,6 @@ namespace boost { namespace geometry { namespace projections
             static const double C13 = .33333333333333333333;
             static const double ONEEPS = 1.0000001;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_mbtfpp_spheroid : public base_t_fi<base_mbtfpp_spheroid<Geographic, Cartesian, Parameters>,
@@ -100,8 +99,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_mbtfpp(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::mbtfpp
diff --git a/include/boost/geometry/extensions/gis/projections/proj/mbtfpq.hpp b/include/boost/geometry/extensions/gis/projections/proj/mbtfpq.hpp
index 66544aa5b..8e9652dff 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/mbtfpq.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/mbtfpq.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace mbtfpq{
+    namespace detail { namespace mbtfpq
+    {
+
             static const int NITER = 20;
             static const double EPS = 1e-7;
             static const double ONETOL = 1.000001;
@@ -59,7 +59,6 @@ namespace boost { namespace geometry { namespace projections
             static const double FXC = 0.31245971410378249250;
             static const double RXC = 3.20041258076506210122;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_mbtfpq_spheroid : public base_t_fi<base_mbtfpq_spheroid<Geographic, Cartesian, Parameters>,
@@ -115,8 +114,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_mbtfpq(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::mbtfpq
diff --git a/include/boost/geometry/extensions/gis/projections/proj/merc.hpp b/include/boost/geometry/extensions/gis/projections/proj/merc.hpp
index 8b6c29daf..e5357d093 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/merc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/merc.hpp
@@ -38,22 +38,21 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_msfn.hpp>
-#include <boost/geometry/extensions/gis/projections/impl/pj_tsfn.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_phi2.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/pj_tsfn.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace merc{
-            static const double EPS10 = 1.e-10;
+    namespace detail { namespace merc
+    {
 
+            static const double EPS10 = 1.e-10;
 
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
@@ -117,6 +116,7 @@ namespace boost { namespace geometry { namespace projections
             {
                 double phits=0.0;
                 int is_phits;
+
                 if( (is_phits = pj_param(par.params, "tlat_ts").i) ) {
                     phits = fabs(pj_param(par.params, "rlat_ts").f);
                     if (phits >= HALFPI) throw proj_exception(-24);
@@ -124,13 +124,9 @@ namespace boost { namespace geometry { namespace projections
                 if (par.es) { /* ellipsoid */
                     if (is_phits)
                         par.k0 = pj_msfn(sin(phits), cos(phits), par.es);
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                 } else { /* sphere */
                     if (is_phits)
                         par.k0 = cos(phits);
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 }
             }
 
@@ -147,7 +143,8 @@ namespace boost { namespace geometry { namespace projections
          - Cylindrical
          - Spheroid
          - Ellipsoid
-         - lat_ts=
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
         \par Example
         \image html ex_merc.gif
     */
@@ -170,7 +167,8 @@ namespace boost { namespace geometry { namespace projections
          - Cylindrical
          - Spheroid
          - Ellipsoid
-         - lat_ts=
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
         \par Example
         \image html ex_merc.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/mill.hpp b/include/boost/geometry/extensions/gis/projections/proj/mill.hpp
index be21405ca..81d404b1e 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/mill.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/mill.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,8 +46,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace mill{
-
+    namespace detail { namespace mill
+    {
 
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
@@ -83,8 +81,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_mill(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::mill
diff --git a/include/boost/geometry/extensions/gis/projections/proj/mod_ster.hpp b/include/boost/geometry/extensions/gis/projections/proj/mod_ster.hpp
index f772392e0..7fa74ea37 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/mod_ster.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/mod_ster.hpp
@@ -38,19 +38,21 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/core/ignore_unused.hpp>
 #include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_zpoly1.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace mod_ster{
+    namespace detail { namespace mod_ster
+    {
+
             static const double EPSLN = 1e-10;
 
             struct par_mod_ster
@@ -59,8 +61,8 @@ namespace boost { namespace geometry { namespace projections
                 double    cchio, schio;
                 int        n;
             };
-            /* based upon Snyder and Linck, USGS-NMD */
 
+            /* based upon Snyder and Linck, USGS-NMD */
 
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
@@ -150,9 +152,8 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_mod_ster& proj_parm)  /* general initialization */
             {
-                boost::ignore_unused(par);
-                boost::ignore_unused(proj_parm);
                 double esphi, chio;
+
                 if (par.es) {
                     esphi = par.e * sin(par.phi0);
                     chio = 2. * atan(tan((HALFPI + par.phi0) * .5) *
@@ -161,8 +162,6 @@ namespace boost { namespace geometry { namespace projections
                     chio = par.phi0;
                 proj_parm.schio = sin(chio);
                 proj_parm.cchio = cos(chio);
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
             }
 
 
@@ -176,6 +175,7 @@ namespace boost { namespace geometry { namespace projections
                 {0.,            0.},
                 {0.019430,    0.}
             };
+
                 proj_parm.n = 2;
                 par.lam0 = DEG_TO_RAD * 20.;
                 par.phi0 = DEG_TO_RAD * 18.;
@@ -194,6 +194,7 @@ namespace boost { namespace geometry { namespace projections
                 {0.,            0.},
                     {-0.0088162,     -0.00617325}
             };
+
                 proj_parm.n = 2;
                 par.lam0 = DEG_TO_RAD * -165.;
                 par.phi0 = DEG_TO_RAD * -10.;
@@ -214,6 +215,7 @@ namespace boost { namespace geometry { namespace projections
                 {0.,        0.},
                     {0.075528,    0.}
             };
+
                 proj_parm.n = 4;
                 par.lam0 = DEG_TO_RAD * -96.;
                 par.phi0 = DEG_TO_RAD * -39.;
@@ -243,6 +245,7 @@ namespace boost { namespace geometry { namespace projections
                 {.0636871,    -.1408027},
                     {.3660976,    -.2937382}
             };
+
                 proj_parm.n = 5;
                 par.lam0 = DEG_TO_RAD * -152.;
                 par.phi0 = DEG_TO_RAD * 64.;
@@ -286,6 +289,7 @@ namespace boost { namespace geometry { namespace projections
                 {-.0216473,    .0776645},
                     {-.0225161,    .0853673}
             };
+
                 proj_parm.n = 9;
                 par.lam0 = DEG_TO_RAD * -120.;
                 par.phi0 = DEG_TO_RAD * 45.;
@@ -310,7 +314,7 @@ namespace boost { namespace geometry { namespace projections
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
         \par Projection characteristics
-         - Azi(mod)
+         - Azimuthal (mod)
         \par Example
         \image html ex_mil_os.gif
     */
@@ -330,7 +334,7 @@ namespace boost { namespace geometry { namespace projections
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
         \par Projection characteristics
-         - Azi(mod)
+         - Azimuthal (mod)
         \par Example
         \image html ex_lee_os.gif
     */
@@ -350,7 +354,7 @@ namespace boost { namespace geometry { namespace projections
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
         \par Projection characteristics
-         - Azi(mod)
+         - Azimuthal (mod)
         \par Example
         \image html ex_gs48.gif
     */
@@ -370,7 +374,7 @@ namespace boost { namespace geometry { namespace projections
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
         \par Projection characteristics
-         - Azi(mod)
+         - Azimuthal (mod)
         \par Example
         \image html ex_alsk.gif
     */
@@ -390,7 +394,7 @@ namespace boost { namespace geometry { namespace projections
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
         \par Projection characteristics
-         - Azi(mod)
+         - Azimuthal (mod)
         \par Example
         \image html ex_gs50.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/moll.hpp b/include/boost/geometry/extensions/gis/projections/proj/moll.hpp
index 0afb9bd4e..be6e1e997 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/moll.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/moll.hpp
@@ -38,9 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -50,7 +47,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace moll{
+    namespace detail { namespace moll
+    {
+
             static const int MAX_ITER = 10;
             static const double LOOP_TOL = 1e-7;
 
@@ -106,17 +105,14 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_moll& proj_parm, double p) 
             {
-                boost::ignore_unused(par);
-                boost::ignore_unused(proj_parm);
                 double r, sp, p2 = p + p;
+
                 par.es = 0;
                 sp = sin(p);
                 r = sqrt(TWOPI * sp / (p2 + sin(p2)));
                 proj_parm.C_x = 2. * r / PI;
                 proj_parm.C_y = r / sp;
                 proj_parm.C_p = p2 + sin(p2);
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
 
@@ -142,8 +138,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.C_x = 0.90977;
                 proj_parm.C_y = 1.65014;
                 proj_parm.C_p = 3.00896;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::moll
diff --git a/include/boost/geometry/extensions/gis/projections/proj/natearth.hpp b/include/boost/geometry/extensions/gis/projections/proj/natearth.hpp
index 8acfe6a98..d8c66fcfb 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/natearth.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/natearth.hpp
@@ -4,7 +4,7 @@
 // Boost.Geometry - extensions-gis-projections (based on PROJ4)
 // This file is automatically generated. DO NOT EDIT.
 
-// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Barend Gehrels, Amsterdam, the Netherlands.
 
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -15,6 +15,8 @@
 // PROJ4 is maintained by Frank Warmerdam
 // PROJ4 is converted to Boost.Geometry by Barend Gehrels
 
+// Last updated version of proj: 4.9.1
+
 // Original copyright notice:
  
 // Permission is hereby granted, free of charge, to any person obtaining a
@@ -35,7 +37,6 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-#include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
@@ -45,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace natearth{ 
+    namespace detail { namespace natearth
+    {
+
             static const double A0 = 0.8707;
             static const double A1 = -0.131979;
             static const double A2 = -0.013791;
@@ -64,9 +67,6 @@ namespace boost { namespace geometry { namespace projections
             static const double EPS = 1e-11;
             static const double MAX_Y = (0.8707 * 0.52 * PI);
 
-            
-            
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_natearth_spheroid : public base_t_fi<base_natearth_spheroid<Geographic, Cartesian, Parameters>,
@@ -84,7 +84,7 @@ namespace boost { namespace geometry { namespace projections
                 inline void fwd(geographic_type& lp_lon, geographic_type& lp_lat, cartesian_type& xy_x, cartesian_type& xy_y) const
                 {
                     double phi2, phi4;
-                
+
                     phi2 = lp_lat * lp_lat;
                     phi4 = phi2 * phi2;
                     xy_x = lp_lon * (A0 + phi2 * (A1 + phi2 * (A2 + phi4 * phi2 * (A3 + phi2 * A4))));
@@ -94,14 +94,14 @@ namespace boost { namespace geometry { namespace projections
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
                 {
                     double yc, tol, y2, y4, f, fder;
-                
+
                         /* make sure y is inside valid range */
                     if (xy_y > MAX_Y) {
                         xy_y = MAX_Y;
                     } else if (xy_y < -MAX_Y) {
                         xy_y = -MAX_Y;
                     }
-                
+
                         /* latitude */
                     yc = xy_y;
                         for (;;) { /* Newton-Raphson */
@@ -115,11 +115,10 @@ namespace boost { namespace geometry { namespace projections
                         }
                     }
                     lp_lat = yc;
-                
+
                         /* longitude */
                     y2 = yc * yc;
                     lp_lon = xy_x / (A0 + y2 * (A1 + y2 * (A2 + y2 * y2 * y2 * (A3 + y2 * A4))));
-                
                 }
             };
 
@@ -128,12 +127,10 @@ namespace boost { namespace geometry { namespace projections
             void setup_natearth(Parameters& par)
             {
                 par.es = 0;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::natearth
-    #endif // doxygen 
+    #endif // doxygen
 
     /*!
         \brief Natural Earth projection
@@ -177,7 +174,7 @@ namespace boost { namespace geometry { namespace projections
             factory.add_to_factory("natearth", new natearth_entry<Geographic, Cartesian, Parameters>);
         }
 
-    } // namespace detail 
+    } // namespace detail
     #endif // doxygen
 
 }}} // namespace boost::geometry::projections
diff --git a/include/boost/geometry/extensions/gis/projections/proj/nell.hpp b/include/boost/geometry/extensions/gis/projections/proj/nell.hpp
index 125f66313..60bf59131 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/nell.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/nell.hpp
@@ -38,21 +38,21 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace nell{
+    namespace detail { namespace nell
+    {
+
             static const int MAX_ITER = 10;
             static const double LOOP_TOL = 1e-7;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_nell_spheroid : public base_t_fi<base_nell_spheroid<Geographic, Cartesian, Parameters>,
@@ -97,8 +97,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_nell(Parameters& par)
             {
                 par.es = 0;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::nell
diff --git a/include/boost/geometry/extensions/gis/projections/proj/nell_h.hpp b/include/boost/geometry/extensions/gis/projections/proj/nell_h.hpp
index a9d0ec33d..c4fe0819a 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/nell_h.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/nell_h.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,11 +46,12 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace nell_h{
+    namespace detail { namespace nell_h
+    {
+
             static const int NITER = 9;
             static const double EPS = 1e-7;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_nell_h_spheroid : public base_t_fi<base_nell_h_spheroid<Geographic, Cartesian, Parameters>,
@@ -98,8 +97,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_nell_h(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::nell_h
diff --git a/include/boost/geometry/extensions/gis/projections/proj/nocol.hpp b/include/boost/geometry/extensions/gis/projections/proj/nocol.hpp
index 4276b02fc..80b72e817 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/nocol.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/nocol.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,9 +46,10 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace nocol{
-            static const double EPS = 1e-10;
+    namespace detail { namespace nocol
+    {
 
+            static const double EPS = 1e-10;
 
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
@@ -105,7 +104,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_nicol(Parameters& par)
             {
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::nocol
diff --git a/include/boost/geometry/extensions/gis/projections/proj/nsper.hpp b/include/boost/geometry/extensions/gis/projections/proj/nsper.hpp
index 66dcf71bc..6ec8e3b10 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/nsper.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/nsper.hpp
@@ -38,7 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/core/ignore_unused.hpp>
 #include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
@@ -49,7 +48,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace nsper{
+    namespace detail { namespace nsper
+    {
+
             static const double EPS10 = 1.e-10;
             static const int N_POLE = 0;
             static const int S_POLE = 1;
@@ -185,8 +186,6 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_nsper& proj_parm) 
             {
-                boost::ignore_unused(par);
-                boost::ignore_unused(proj_parm);
                 if ((proj_parm.height = pj_param(par.params, "dh").f) <= 0.) throw proj_exception(-30);
                 if (fabs(fabs(par.phi0) - HALFPI) < EPS10)
                     proj_parm.mode = par.phi0 < 0. ? S_POLE : N_POLE;
@@ -197,14 +196,11 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.sinph0 = sin(par.phi0);
                     proj_parm.cosph0 = cos(par.phi0);
                 }
-                proj_parm.pn1 = proj_parm.height / par.a;
-             /* normalize by radius */
+                proj_parm.pn1 = proj_parm.height / par.a; /* normalize by radius */
                 proj_parm.p = 1. + proj_parm.pn1;
                 proj_parm.rp = 1. / proj_parm.p;
                 proj_parm.h = 1. / proj_parm.pn1;
                 proj_parm.pfact = (proj_parm.p + 1.) * proj_parm.h;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
@@ -222,13 +218,12 @@ namespace boost { namespace geometry { namespace projections
             void setup_tpers(Parameters& par, par_nsper& proj_parm)
             {
                 double omega, gamma;
+
                 omega = pj_param(par.params, "dtilt").f * DEG_TO_RAD;
                 gamma = pj_param(par.params, "dazi").f * DEG_TO_RAD;
                 proj_parm.tilt = 1;
-                proj_parm.cg = cos(gamma);
-             proj_parm.sg = sin(gamma);
-                proj_parm.cw = cos(omega);
-             proj_parm.sw = sin(omega);
+                proj_parm.cg = cos(gamma); proj_parm.sg = sin(gamma);
+                proj_parm.cw = cos(omega); proj_parm.sw = sin(omega);
                 setup(par, proj_parm);
             }
 
@@ -244,7 +239,8 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Azimuthal
          - Spheroid
-         - h=
+        \par Projection parameters
+         - h: Height
         \par Example
         \image html ex_nsper.gif
     */
@@ -266,7 +262,10 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Azimuthal
          - Spheroid
-         - tilt= azi= h=
+        \par Projection parameters
+         - tilt: Tilt, or Omega (real)
+         - azi: Azimuth (or Gamma) (real)
+         - h: Height
         \par Example
         \image html ex_tpers.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/nzmg.hpp b/include/boost/geometry/extensions/gis/projections/proj/nzmg.hpp
index 9da524997..a321bd344 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/nzmg.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/nzmg.hpp
@@ -38,17 +38,18 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/pj_zpoly1.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace nzmg{
+    namespace detail { namespace nzmg
+    {
+
             static const double EPSLN = 1e-10;
             static const double SEC5_TO_RAD = 0.4848136811095359935899141023;
             static const double RAD_TO_SEC5 = 2.062648062470963551564733573;
@@ -56,10 +57,6 @@ namespace boost { namespace geometry { namespace projections
             static const int Ntpsi = 9;
             static const int Ntphi = 8;
 
-
-
-
-
                 static COMPLEX
             bf[] = {
                 {.7557853228,    0.0},
@@ -142,8 +139,6 @@ namespace boost { namespace geometry { namespace projections
                 par.phi0 = DEG_TO_RAD * -41.;
                 par.x0 = 2510000.;
                 par.y0 = 6023150.;
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
             }
 
         }} // namespace detail::nzmg
@@ -156,7 +151,7 @@ namespace boost { namespace geometry { namespace projections
         \tparam Cartesian xy point type
         \tparam Parameters parameter type
         \par Projection characteristics
-         - fixed Earth
+         - Fixed Earth
         \par Example
         \image html ex_nzmg.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/ob_tran.hpp b/include/boost/geometry/extensions/gis/projections/proj/ob_tran.hpp
index f38ae8a0e..1695de3a9 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/ob_tran.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/ob_tran.hpp
@@ -39,12 +39,12 @@
 
 
 #include <boost/shared_ptr.hpp>
-#include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
@@ -52,7 +52,9 @@ namespace boost { namespace geometry { namespace projections
     template <typename Geographic, typename Cartesian, typename Parameters> class factory;
 
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace ob_tran{
+    namespace detail { namespace ob_tran
+    {
+
             static const double TOL = 1e-10;
 
             template <typename Geographic, typename Cartesian>
@@ -83,7 +85,6 @@ namespace boost { namespace geometry { namespace projections
                     double coslam, sinphi, cosphi;
 
 
-
                     coslam = cos(lp_lon);
                     sinphi = sin(lp_lat);
                     cosphi = cos(lp_lat);
@@ -129,7 +130,6 @@ namespace boost { namespace geometry { namespace projections
                     double cosphi, coslam;
 
 
-
                     cosphi = cos(lp_lat);
                     coslam = cos(lp_lon);
                     lp_lon = adjlon(aatan2(cosphi * sin(lp_lon), sin(lp_lat)) + this->m_proj_parm.lamp);
@@ -155,14 +155,13 @@ namespace boost { namespace geometry { namespace projections
             template <typename Geographic, typename Cartesian, typename Parameters>
             double setup_ob_tran(Parameters& par, par_ob_tran<Geographic, Cartesian>& proj_parm, bool create = true)
             {
-                int i;
                 double phip;
-
-
                 Parameters pj;
+
+                /* get name of projection to be translated */
+                pj.name = pj_param(par.params, "so_proj").s;
                 /* copy existing header into new */
-                par.es = 0.;
-             /* force to spherical */
+                par.es = 0.; /* force to spherical */
                 pj.params = par.params;
                 pj.over = par.over;
                 pj.geoc = par.geoc;
@@ -177,16 +176,16 @@ namespace boost { namespace geometry { namespace projections
                 /* force spherical earth */
                 pj.one_es = pj.rone_es = 1.;
                 pj.es = pj.e = 0.;
-                pj.name = pj_param(par.params, "so_proj").s;
 
-                factory<Geographic, Cartesian, Parameters> fac;
                 if (create)
                 {
+                    factory<Geographic, Cartesian, Parameters> fac;
                     proj_parm.link.reset(fac.create_new(pj));
                     if (! proj_parm.link.get()) throw proj_exception(-26);
                 }
                 if (pj_param(par.params, "to_alpha").i) {
                     double lamc, phic, alpha;
+
                     lamc    = pj_param(par.params, "ro_lon_c").f;
                     phic    = pj_param(par.params, "ro_lat_c").f;
                     alpha    = pj_param(par.params, "ro_alpha").f;
@@ -204,6 +203,7 @@ namespace boost { namespace geometry { namespace projections
                     phip = pj_param(par.params, "ro_lat_p").f;
                 } else { /* specified new "equator" points */
                     double lam1, lam2, phi1, phi2, con;
+
                     lam1 = pj_param(par.params, "ro_lon_1").f;
                     phi1 = pj_param(par.params, "ro_lat_1").f;
                     lam2 = pj_param(par.params, "ro_lon_2").f;
@@ -221,13 +221,8 @@ namespace boost { namespace geometry { namespace projections
                 if (fabs(phip) > TOL) { /* oblique */
                     proj_parm.cphip = cos(phip);
                     proj_parm.sphip = sin(phip);
-                // par.fwd = o_forward;
-                // par.inv = pj.inv ? o_inverse : 0;
                 } else { /* transverse */
-                // par.fwd = t_forward;
-                // par.inv = pj.inv ? t_inverse : 0;
                 }
-                boost::ignore_unused(i);
                 // return phip to choose model
                 return phip;
             }
@@ -244,10 +239,19 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Miscellaneous
          - Spheroid
-         - o_proj= plus parameters for projection
-         - o_lat_p= o_lon_p= (new pole) or
-         - o_alpha= o_lon_c= o_lat_c= or
-         - o_lon_1= o_lat_1= o_lon_2= o_lat_2=
+        \par Projection parameters
+         - o_proj (string)
+         - Plus projection parameters
+         - o_lat_p (degrees)
+         - o_lon_p (degrees)
+         - New pole
+         - o_alpha: Alpha (degrees)
+         - o_lon_c (degrees)
+         - o_lat_c (degrees)
+         - o_lon_1 (degrees)
+         - o_lat_1: Latitude of first standard parallel (degrees)
+         - o_lon_2 (degrees)
+         - o_lat_2: Latitude of second standard parallel (degrees)
         \par Example
         \image html ex_ob_tran.gif
     */
@@ -269,10 +273,19 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Miscellaneous
          - Spheroid
-         - o_proj= plus parameters for projection
-         - o_lat_p= o_lon_p= (new pole) or
-         - o_alpha= o_lon_c= o_lat_c= or
-         - o_lon_1= o_lat_1= o_lon_2= o_lat_2=
+        \par Projection parameters
+         - o_proj (string)
+         - Plus projection parameters
+         - o_lat_p (degrees)
+         - o_lon_p (degrees)
+         - New pole
+         - o_alpha: Alpha (degrees)
+         - o_lon_c (degrees)
+         - o_lat_c (degrees)
+         - o_lon_1 (degrees)
+         - o_lat_1: Latitude of first standard parallel (degrees)
+         - o_lon_2 (degrees)
+         - o_lat_2: Latitude of second standard parallel (degrees)
         \par Example
         \image html ex_ob_tran.gif
     */
@@ -299,6 +312,7 @@ namespace boost { namespace geometry { namespace projections
                     detail::ob_tran::par_ob_tran<Geographic, Cartesian> proj_parm;
                     Parameters p = par;
                     double phip = setup_ob_tran(p, proj_parm, false);
+
                     if (fabs(phip) > detail::ob_tran::TOL)
                         return new base_v_fi<ob_tran_oblique<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
                     else
diff --git a/include/boost/geometry/extensions/gis/projections/proj/ocea.hpp b/include/boost/geometry/extensions/gis/projections/proj/ocea.hpp
index 41e206ccc..f3d9d84ed 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/ocea.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/ocea.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace ocea{
+    namespace detail { namespace ocea
+    {
 
             struct par_ocea
             {
@@ -109,6 +108,7 @@ namespace boost { namespace geometry { namespace projections
             void setup_ocea(Parameters& par, par_ocea& proj_parm)
             {
                 double phi_0=0.0, phi_1, phi_2, lam_1, lam_2, lonz, alpha;
+
                 proj_parm.rok = par.a / par.k0;
                 proj_parm.rtk = par.a * par.k0;
                 if ( pj_param(par.params, "talpha").i) {
@@ -132,8 +132,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.sinphi = sin(proj_parm.sinphi);
                 proj_parm.cosgam = cos(proj_parm.singam);
                 proj_parm.singam = sin(proj_parm.singam);
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
@@ -148,8 +146,14 @@ namespace boost { namespace geometry { namespace projections
         \tparam Parameters parameter type
         \par Projection characteristics
          - Cylindrical
-         - Sph lonc= alpha= or
-         - lat_1= lat_2= lon_1= lon_2=
+         - Spheroid
+        \par Projection parameters
+         - lonc: Longitude (only used if alpha (or gamma) is specified) (degrees)
+         - alpha: Alpha (degrees)
+         - lat_1: Latitude of first standard parallel (degrees)
+         - lat_2: Latitude of second standard parallel (degrees)
+         - lon_1 (degrees)
+         - lon_2 (degrees)
         \par Example
         \image html ex_ocea.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/oea.hpp b/include/boost/geometry/extensions/gis/projections/proj/oea.hpp
index f1a043317..a29292923 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/oea.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/oea.hpp
@@ -44,11 +44,13 @@
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace oea{
+    namespace detail { namespace oea
+    {
 
             struct par_oea
             {
@@ -123,8 +125,6 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.two_r_m = 2. * proj_parm.rm;
                     proj_parm.hm = 0.5 * proj_parm.m;
                     proj_parm.hn = 0.5 * proj_parm.n;
-                // par.fwd = s_forward;
-                // par.inv = s_inverse;
                     par.es = 0.;
                 }
             }
@@ -141,7 +141,10 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Miscellaneous
          - Spheroid
-         - n= m= theta=
+        \par Projection parameters
+         - n (real)
+         - m (real)
+         - theta: Theta (degrees)
         \par Example
         \image html ex_oea.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/omerc.hpp b/include/boost/geometry/extensions/gis/projections/proj/omerc.hpp
index 37d37eeb1..0cf43379a 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/omerc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/omerc.hpp
@@ -38,26 +38,22 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
-#include <boost/geometry/extensions/gis/projections/impl/pj_tsfn.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_phi2.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/pj_tsfn.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace omerc{
+    namespace detail { namespace omerc
+    {
+
             static const double TOL = 1.e-7;
             static const double EPS = 1.e-10;
 
-                inline double TSFN0(double x)
-                    {return tan(.5 * (HALFPI - (x))); }
-
-
             struct par_omerc
             {
                 double    A, B, E, AB, ArB, BrA, rB, singam, cosgam, sinrot, cosrot;
@@ -65,8 +61,6 @@ namespace boost { namespace geometry { namespace projections
                 int no_rot;
             };
 
-
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_omerc_ellipsoid : public base_t_fi<base_omerc_ellipsoid<Geographic, Cartesian, Parameters>,
@@ -152,6 +146,7 @@ namespace boost { namespace geometry { namespace projections
                 double con, com, cosph0, D, F, H, L, sinph0, p, J, gamma=0,
                     gamma0, lamc=0, lam1=0, lam2=0, phi1=0, phi2=0, alpha_c;
                 int alp, gam, no_off = 0;
+
                 proj_parm.no_rot = pj_param(par.params, "tno_rot").i;
                     if ((alp = pj_param(par.params, "talpha").i) != 0)
                     alpha_c = pj_param(par.params, "ralpha").f;
@@ -250,8 +245,6 @@ namespace boost { namespace geometry { namespace projections
                 F = 0.5 * gamma0;
                 proj_parm.v_pole_n = proj_parm.ArB * log(tan(FORTPI - F));
                 proj_parm.v_pole_s = proj_parm.ArB * log(tan(FORTPI + F));
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
             }
 
         }} // namespace detail::omerc
@@ -266,9 +259,18 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Cylindrical
          - Spheroid
-         - Ell no_rot
-         - alpha= [gamma=] [no_off] lonc= or
-         - lon_1= lat_1= lon_2= lat_2=
+         - Ellipsoid
+        \par Projection parameters
+         - no_rot: No rotation
+         - alpha: Alpha (degrees)
+         - gamma: Gamma (degrees)
+         - no_off: Only for compatibility with libproj, proj4 (string)
+         - lonc: Longitude (only used if alpha (or gamma) is specified) (degrees)
+         - lon_1 (degrees)
+         - lat_1: Latitude of first standard parallel (degrees)
+         - lon_2 (degrees)
+         - lat_2: Latitude of second standard parallel (degrees)
+         - no_uoff (string)
         \par Example
         \image html ex_omerc.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/ortho.hpp b/include/boost/geometry/extensions/gis/projections/proj/ortho.hpp
index 44f5b0d7e..577382c43 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/ortho.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/ortho.hpp
@@ -48,7 +48,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace ortho{
+    namespace detail { namespace ortho
+    {
+
             static const double EPS10 = 1.e-10;
             static const int N_POLE = 0;
             static const int S_POLE = 1;
@@ -101,10 +103,8 @@ namespace boost { namespace geometry { namespace projections
                         break;
                     }
                     xy_x = cosphi * sin(lp_lon);
-                            return;
                 }
 
-
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
                 {
                     double  rh, cosc, sinc;
@@ -146,9 +146,7 @@ namespace boost { namespace geometry { namespace projections
                              ? (xy_x == 0. ? 0. : xy_x < 0. ? -HALFPI : HALFPI)
                                            : atan2(xy_x, xy_y);
                     }
-                            return;
                 }
-
             };
 
             // Orthographic
@@ -163,8 +161,6 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.cosph0 = cos(par.phi0);
                 } else
                     proj_parm.mode = EQUIT;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/poly.hpp b/include/boost/geometry/extensions/gis/projections/proj/poly.hpp
index f9b560ec5..1e8b47f02 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/poly.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/poly.hpp
@@ -38,19 +38,19 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
-#include <boost/geometry/extensions/gis/projections/impl/pj_msfn.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/pj_mlfn.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/pj_msfn.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace poly{
+    namespace detail { namespace poly
+    {
+
             static const double TOL = 1e-10;
             static const double CONV = 1e-10;
             static const int N_ITER = 10;
@@ -178,14 +178,10 @@ namespace boost { namespace geometry { namespace projections
             void setup_poly(Parameters& par, par_poly& proj_parm)
             {
                 if (par.es) {
-                    pj_enfn(par.es, proj_parm.en);
+                    if (!pj_enfn(par.es, proj_parm.en)) throw proj_exception(0);
                     proj_parm.ml0 = pj_mlfn(par.phi0, sin(par.phi0), cos(par.phi0), proj_parm.en);
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                 } else {
                     proj_parm.ml0 = -par.phi0;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 }
             }
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/putp2.hpp b/include/boost/geometry/extensions/gis/projections/proj/putp2.hpp
index 1e05e1099..716b5b3bc 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/putp2.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/putp2.hpp
@@ -38,17 +38,18 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace putp2{
+    namespace detail { namespace putp2
+    {
+
             static const double C_x = 1.89490;
             static const double C_y = 1.71848;
             static const double C_p = 0.6141848493043784;
@@ -56,7 +57,6 @@ namespace boost { namespace geometry { namespace projections
             static const int NITER = 10;
             static const double PI_DIV_3 = 1.0471975511965977;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_putp2_spheroid : public base_t_fi<base_putp2_spheroid<Geographic, Cartesian, Parameters>,
@@ -108,8 +108,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_putp2(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::putp2
diff --git a/include/boost/geometry/extensions/gis/projections/proj/putp3.hpp b/include/boost/geometry/extensions/gis/projections/proj/putp3.hpp
index 5722dd08e..0b1a9f3e0 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/putp3.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/putp3.hpp
@@ -39,7 +39,6 @@
 
 
 #include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
@@ -49,7 +48,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace putp3{
+    namespace detail { namespace putp3
+    {
+
             static const double C = 0.79788456;
             static const double RPISQ = 0.1013211836;
 
@@ -89,11 +90,8 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_putp3& proj_parm) 
             {
-                boost::ignore_unused(par);
                 boost::ignore_unused(proj_parm);
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/putp4p.hpp b/include/boost/geometry/extensions/gis/projections/proj/putp4p.hpp
index 42204f98c..4a66bb444 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/putp4p.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/putp4p.hpp
@@ -39,17 +39,18 @@
 
 
 #include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace putp4p{
+    namespace detail { namespace putp4p
+    {
 
             struct par_putp4p
             {
@@ -92,11 +93,8 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_putp4p& proj_parm) 
             {
-                boost::ignore_unused(par);
                 boost::ignore_unused(proj_parm);
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/putp5.hpp b/include/boost/geometry/extensions/gis/projections/proj/putp5.hpp
index ce3ef9db8..0b75bf3b2 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/putp5.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/putp5.hpp
@@ -39,7 +39,6 @@
 
 
 #include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
@@ -49,7 +48,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace putp5{
+    namespace detail { namespace putp5
+    {
+
             static const double C = 1.01346;
             static const double D = 1.2158542;
 
@@ -89,11 +90,8 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_putp5& proj_parm) 
             {
-                boost::ignore_unused(par);
                 boost::ignore_unused(proj_parm);
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/putp6.hpp b/include/boost/geometry/extensions/gis/projections/proj/putp6.hpp
index 6f8def3a9..949c70e14 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/putp6.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/putp6.hpp
@@ -39,17 +39,19 @@
 
 
 #include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace putp6{
+    namespace detail { namespace putp6
+    {
+
             static const double EPS = 1e-10;
             static const int NITER = 10;
             static const double CON_POLE = 1.732050807568877;
@@ -108,11 +110,8 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_putp6& proj_parm) 
             {
-                boost::ignore_unused(par);
                 boost::ignore_unused(proj_parm);
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/qsc.hpp b/include/boost/geometry/extensions/gis/projections/proj/qsc.hpp
index a9f6bf0db..0a1f47f09 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/qsc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/qsc.hpp
@@ -39,7 +39,6 @@
 
 
 #include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
@@ -49,7 +48,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace qsc{
+    namespace detail { namespace qsc
+    {
+
             static const double EPS10 = 1.e-10;
             static const int FACE_FRONT = 0;
             static const int FACE_RIGHT = 1;
@@ -71,7 +72,6 @@ namespace boost { namespace geometry { namespace projections
                 double one_minus_f_squared;
             };
 
-
             /* The six cube faces. */
 
             /* The four areas on a cube face. AREA_0 is the area of definition,
@@ -79,7 +79,7 @@ namespace boost { namespace geometry { namespace projections
 
             /* Helper function for forward projection: compute the theta angle
              * and determine the area number. */
-            inline double
+            static double
             qsc_fwd_equat_face_theta(double phi, double y, double x, int *area) {
                     double theta;
                     if (phi < EPS10) {
@@ -104,7 +104,7 @@ namespace boost { namespace geometry { namespace projections
             }
 
             /* Helper function: shift the longitude. */
-            inline double
+            static double
             qsc_shift_lon_origin(double lon, double offset) {
                     double slon = lon + offset;
                     if (slon < -PI) {
@@ -238,9 +238,7 @@ namespace boost { namespace geometry { namespace projections
                         xy_x = t * cos(mu);
                         xy_y = t * sin(mu);
                         boost::ignore_unused(nu);
-                            return;
                 }
-
                 /* Inverse projection, ellipsoid */
 
                 inline void inv(cartesian_type& xy_x, cartesian_type& xy_y, geographic_type& lp_lon, geographic_type& lp_lat) const
@@ -386,8 +384,6 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup_qsc(Parameters& par, par_qsc& proj_parm)
             {
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                     /* Determine the cube face from the center of projection. */
                     if (par.phi0 >= HALFPI - FORTPI / 2.0) {
                         proj_parm.face = FACE_TOP;
diff --git a/include/boost/geometry/extensions/gis/projections/proj/robin.hpp b/include/boost/geometry/extensions/gis/projections/proj/robin.hpp
index fae3416a0..4aba44459 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/robin.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/robin.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -49,7 +47,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace robin{
+    namespace detail { namespace robin
+    {
+
             static const double FXC = 0.8487;
             static const double FYC = 1.3523;
             static const double C1 = 11.45915590261646417544;
@@ -58,8 +58,6 @@ namespace boost { namespace geometry { namespace projections
             static const double ONEEPS = 1.000001;
             static const double EPS = 1e-8;
 
-
-
             struct COEFS {
                 double c0, c1, c2, c3;
             };
@@ -182,8 +180,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_robin(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::robin
diff --git a/include/boost/geometry/extensions/gis/projections/proj/rouss.hpp b/include/boost/geometry/extensions/gis/projections/proj/rouss.hpp
index 1429c76e9..f93d34f54 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/rouss.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/rouss.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -49,7 +47,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace rouss{
+    namespace detail { namespace rouss
+    {
 
             struct par_rouss
             {
@@ -115,8 +114,9 @@ namespace boost { namespace geometry { namespace projections
             void setup_rouss(Parameters& par, par_rouss& proj_parm)
             {
                 double N0, es2, t, t2, R_R0_2, R_R0_4;
-                proj_mdist_ini(par.es, proj_parm.en);
 
+                if (!proj_mdist_ini(par.es, proj_parm.en))
+                    throw proj_exception(0);
                 es2 = sin(par.phi0);
                 proj_parm.s0 = proj_mdist(par.phi0, es2, cos(par.phi0), proj_parm.en);
                 t = 1. - (es2 = par.es * es2 * es2);
@@ -156,8 +156,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.D9 = R_R0_4 * t * (-21. + t2 * (178. - t2 * 26.))/720.;
                 proj_parm.D10 = R_R0_4 * t * (29. + t2 * (86. + t2 * 48.))/(96. * N0);
                 proj_parm.D11 = R_R0_4 * t * (37. + t2 * 44.)/(96. * N0);
-                // par.fwd = e_forward;
-                // par.inv = e_inverse;
             }
 
         }} // namespace detail::rouss
@@ -171,7 +169,7 @@ namespace boost { namespace geometry { namespace projections
         \tparam Parameters parameter type
         \par Projection characteristics
          - Azimuthal
-         - Ellps
+         - Ellipsoid
         \par Example
         \image html ex_rouss.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/rpoly.hpp b/include/boost/geometry/extensions/gis/projections/proj/rpoly.hpp
index 7783e5080..31ea6c442 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/rpoly.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/rpoly.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace rpoly{
+    namespace detail { namespace rpoly
+    {
+
             static const double EPS = 1e-9;
 
             struct par_rpoly
@@ -102,7 +102,6 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.fxa = 0.5 / proj_parm.fxb;
                 }
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::rpoly
@@ -118,7 +117,8 @@ namespace boost { namespace geometry { namespace projections
          - Conic
          - Spheroid
          - no inverse
-         - lat_ts=
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
         \par Example
         \image html ex_rpoly.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/sconics.hpp b/include/boost/geometry/extensions/gis/projections/proj/sconics.hpp
index 0206c4918..447709262 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/sconics.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/sconics.hpp
@@ -38,7 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/core/ignore_unused.hpp>
 #include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
@@ -49,7 +48,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace sconics{
+    namespace detail { namespace sconics
+    {
+
             static const int EULER = 0;
             static const int MURD1 = 1;
             static const int MURD2 = 2;
@@ -69,9 +70,10 @@ namespace boost { namespace geometry { namespace projections
                 double    c1, c2;
                 int        type;
             };
+
             /* get common factors for simple conics */
             template <typename Parameters>
-                inline int
+                static int
             phi12(Parameters& par, par_sconics& proj_parm, double *del) {
                 double p1, p2;
                 int err = 0;
@@ -151,10 +153,9 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_sconics& proj_parm) 
             {
-                boost::ignore_unused(par);
-                boost::ignore_unused(proj_parm);
                 double del, cs;
                 int i;
+
                 if( (i = phi12(par, proj_parm, &del)) )
                     throw proj_exception(i);
                 switch (proj_parm.type) {
@@ -199,8 +200,6 @@ namespace boost { namespace geometry { namespace projections
                     proj_parm.rho_0 = proj_parm.rho_c - par.phi0;
                     break;
                 }
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0;
             }
 
@@ -273,7 +272,9 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Conic
          - Spheroid
-         - lat_1= and lat_2=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel
+         - lat_2: Latitude of second standard parallel
         \par Example
         \image html ex_tissot.gif
     */
@@ -295,7 +296,9 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Conic
          - Spheroid
-         - lat_1= and lat_2=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel
+         - lat_2: Latitude of second standard parallel
         \par Example
         \image html ex_murd1.gif
     */
@@ -317,7 +320,9 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Conic
          - Spheroid
-         - lat_1= and lat_2=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel
+         - lat_2: Latitude of second standard parallel
         \par Example
         \image html ex_murd2.gif
     */
@@ -339,7 +344,9 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Conic
          - Spheroid
-         - lat_1= and lat_2=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel
+         - lat_2: Latitude of second standard parallel
         \par Example
         \image html ex_murd3.gif
     */
@@ -361,7 +368,9 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Conic
          - Spheroid
-         - lat_1= and lat_2=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel
+         - lat_2: Latitude of second standard parallel
         \par Example
         \image html ex_euler.gif
     */
@@ -383,7 +392,9 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Conic
          - Spheroid
-         - lat_1= and lat_2=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel
+         - lat_2: Latitude of second standard parallel
         \par Example
         \image html ex_pconic.gif
     */
@@ -405,7 +416,9 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Conic
          - Spheroid
-         - lat_1= and lat_2=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel
+         - lat_2: Latitude of second standard parallel
         \par Example
         \image html ex_vitk1.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/somerc.hpp b/include/boost/geometry/extensions/gis/projections/proj/somerc.hpp
index e5377abeb..b55a092f2 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/somerc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/somerc.hpp
@@ -38,17 +38,18 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace somerc{
+    namespace detail { namespace somerc
+    {
+
             static const double EPS = 1.e-10;
             static const int NITER = 6;
 
@@ -121,6 +122,7 @@ namespace boost { namespace geometry { namespace projections
             void setup_somerc(Parameters& par, par_somerc& proj_parm)
             {
                 double cp, phip0, sp;
+
                 proj_parm.hlf_e = 0.5 * par.e;
                 cp = cos(par.phi0);
                 cp *= cp;
@@ -132,8 +134,6 @@ namespace boost { namespace geometry { namespace projections
                     log(tan(FORTPI + 0.5 * par.phi0)) - proj_parm.hlf_e *
                     log((1. + sp) / (1. - sp)));
                 proj_parm.kR = par.k0 * sqrt(par.one_es) / (1. - sp * sp);
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
             }
 
         }} // namespace detail::somerc
diff --git a/include/boost/geometry/extensions/gis/projections/proj/stere.hpp b/include/boost/geometry/extensions/gis/projections/proj/stere.hpp
index d976ec521..fc6aeba68 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/stere.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/stere.hpp
@@ -38,7 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/core/ignore_unused.hpp>
 #include <boost/math/special_functions/hypot.hpp>
 
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
@@ -50,7 +49,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace stere{
+    namespace detail { namespace stere
+    {
+
             static const double EPS10 = 1.e-10;
             static const double TOL = 1.e-8;
             static const int NITER = 8;
@@ -68,7 +69,8 @@ namespace boost { namespace geometry { namespace projections
                 double akm1;
                 int    mode;
             };
-                inline double
+
+                static double
             ssfn_(double phit, double sinphi, double eccen) {
                 sinphi *= eccen;
                 return (tan (.5 * (HALFPI + phit)) *
@@ -256,9 +258,8 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_stere& proj_parm)  /* general initialization */
             {
-                boost::ignore_unused(par);
-                boost::ignore_unused(proj_parm);
                 double t;
+
                 if (fabs((t = fabs(par.phi0)) - HALFPI) < EPS10)
                     proj_parm.mode = par.phi0 < 0. ? S_POLE : N_POLE;
                 else
@@ -266,6 +267,7 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.phits = fabs(proj_parm.phits);
                 if (par.es) {
                     double X;
+
                     switch (proj_parm.mode) {
                     case N_POLE:
                     case S_POLE:
@@ -291,8 +293,6 @@ namespace boost { namespace geometry { namespace projections
                         proj_parm.cosX1 = cos(X);
                         break;
                     }
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                 } else {
                     switch (proj_parm.mode) {
                     case OBLIQ:
@@ -308,8 +308,6 @@ namespace boost { namespace geometry { namespace projections
                            2. * par.k0 ;
                         break;
                     }
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 }
             }
 
@@ -351,7 +349,8 @@ namespace boost { namespace geometry { namespace projections
          - Azimuthal
          - Spheroid
          - Ellipsoid
-         - lat_ts=
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
         \par Example
         \image html ex_stere.gif
     */
@@ -364,6 +363,30 @@ namespace boost { namespace geometry { namespace projections
         }
     };
 
+    /*!
+        \brief Stereographic projection
+        \ingroup projections
+        \tparam Geographic latlong point type
+        \tparam Cartesian xy point type
+        \tparam Parameters parameter type
+        \par Projection characteristics
+         - Azimuthal
+         - Spheroid
+         - Ellipsoid
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
+        \par Example
+        \image html ex_stere.gif
+    */
+    template <typename Geographic, typename Cartesian, typename Parameters = parameters>
+    struct stere_spheroid : public detail::stere::base_stere_spheroid<Geographic, Cartesian, Parameters>
+    {
+        inline stere_spheroid(const Parameters& par) : detail::stere::base_stere_spheroid<Geographic, Cartesian, Parameters>(par)
+        {
+            detail::stere::setup_stere(this->m_par, this->m_proj_parm);
+        }
+    };
+
     /*!
         \brief Universal Polar Stereographic projection
         \ingroup projections
@@ -374,7 +397,8 @@ namespace boost { namespace geometry { namespace projections
          - Azimuthal
          - Spheroid
          - Ellipsoid
-         - south
+        \par Projection parameters
+         - south: Denotes southern hemisphere UTM zone (boolean)
         \par Example
         \image html ex_ups.gif
     */
@@ -388,7 +412,7 @@ namespace boost { namespace geometry { namespace projections
     };
 
     /*!
-        \brief Stereographic projection
+        \brief Universal Polar Stereographic projection
         \ingroup projections
         \tparam Geographic latlong point type
         \tparam Cartesian xy point type
@@ -397,16 +421,17 @@ namespace boost { namespace geometry { namespace projections
          - Azimuthal
          - Spheroid
          - Ellipsoid
-         - lat_ts=
+        \par Projection parameters
+         - south: Denotes southern hemisphere UTM zone (boolean)
         \par Example
-        \image html ex_stere.gif
+        \image html ex_ups.gif
     */
     template <typename Geographic, typename Cartesian, typename Parameters = parameters>
-    struct stere_spheroid : public detail::stere::base_stere_spheroid<Geographic, Cartesian, Parameters>
+    struct ups_spheroid : public detail::stere::base_stere_spheroid<Geographic, Cartesian, Parameters>
     {
-        inline stere_spheroid(const Parameters& par) : detail::stere::base_stere_spheroid<Geographic, Cartesian, Parameters>(par)
+        inline ups_spheroid(const Parameters& par) : detail::stere::base_stere_spheroid<Geographic, Cartesian, Parameters>(par)
         {
-            detail::stere::setup_stere(this->m_par, this->m_proj_parm);
+            detail::stere::setup_ups(this->m_par, this->m_proj_parm);
         }
     };
 
@@ -434,7 +459,10 @@ namespace boost { namespace geometry { namespace projections
             public :
                 virtual projection<Geographic, Cartesian>* create_new(const Parameters& par) const
                 {
-                    return new base_v_fi<ups_ellipsoid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
+                    if (par.es)
+                        return new base_v_fi<ups_ellipsoid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
+                    else
+                        return new base_v_fi<ups_spheroid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
                 }
         };
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/sterea.hpp b/include/boost/geometry/extensions/gis/projections/proj/sterea.hpp
index 96e89dded..6870426a0 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/sterea.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/sterea.hpp
@@ -51,7 +51,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace sterea{
+    namespace detail { namespace sterea
+    {
+
             static const double DEL_TOL = 1.e-14;
             static const int MAX_ITER = 10;
 
@@ -63,9 +65,6 @@ namespace boost { namespace geometry { namespace projections
                 gauss::GAUSS en;
             };
 
-
-
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_sterea_ellipsoid : public base_t_fi<base_sterea_ellipsoid<Geographic, Cartesian, Parameters>,
@@ -120,12 +119,11 @@ namespace boost { namespace geometry { namespace projections
             void setup_sterea(Parameters& par, par_sterea& proj_parm)
             {
                 double R;
+
                 proj_parm.en = detail::gauss::gauss_ini(par.e, par.phi0, proj_parm.phic0, R);
                 proj_parm.sinc0 = sin(proj_parm.phic0);
                 proj_parm.cosc0 = cos(proj_parm.phic0);
                 proj_parm.R2 = 2. * R;
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
             }
 
         }} // namespace detail::sterea
diff --git a/include/boost/geometry/extensions/gis/projections/proj/sts.hpp b/include/boost/geometry/extensions/gis/projections/proj/sts.hpp
index 1d84cf64f..ab2d307a7 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/sts.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/sts.hpp
@@ -38,18 +38,17 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace sts{
+    namespace detail { namespace sts
+    {
 
             struct par_sts
             {
@@ -107,11 +106,7 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_sts& proj_parm, double p, double q, int mode) 
             {
-                boost::ignore_unused(par);
-                boost::ignore_unused(proj_parm);
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 proj_parm.C_x = q / p;
                 proj_parm.C_y = p;
                 proj_parm.C_p = 1/ q;
diff --git a/include/boost/geometry/extensions/gis/projections/proj/tcc.hpp b/include/boost/geometry/extensions/gis/projections/proj/tcc.hpp
index e7a375d27..d6bfb4345 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/tcc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/tcc.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace tcc{
+    namespace detail { namespace tcc
+    {
+
             static const double EPS10 = 1.e-10;
 
             struct par_tcc
@@ -87,7 +87,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_tcc(Parameters& par, par_tcc& proj_parm)
             {
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::tcc
diff --git a/include/boost/geometry/extensions/gis/projections/proj/tcea.hpp b/include/boost/geometry/extensions/gis/projections/proj/tcea.hpp
index 57d90cf4f..504724204 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/tcea.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/tcea.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace tcea{
+    namespace detail { namespace tcea
+    {
 
             struct par_tcea
             {
@@ -93,8 +92,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_tcea(Parameters& par, par_tcea& proj_parm)
             {
                 proj_parm.rk0 = 1 / par.k0;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/tmerc.hpp b/include/boost/geometry/extensions/gis/projections/proj/tmerc.hpp
index e45cb1d7b..babbe34c6 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/tmerc.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/tmerc.hpp
@@ -38,9 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -53,7 +50,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace tmerc{
+    namespace detail { namespace tmerc
+    {
+
             static const double EPS10 = 1.e-10;
             static const double FC1 = 1.;
             static const double FC2 = .5;
@@ -101,7 +100,7 @@ namespace boost { namespace geometry { namespace projections
                         {
                             xy_x = HUGE_VAL;
                             xy_y = HUGE_VAL;
-                            throw proj_exception(-14 );
+                            throw proj_exception( -14 );
                             return;
                         }
 
@@ -187,7 +186,7 @@ namespace boost { namespace geometry { namespace projections
                         {
                             xy_x = HUGE_VAL;
                             xy_y = HUGE_VAL;
-                            throw proj_exception(-14 );
+                            throw proj_exception( -14 );
                             return;
                         }
 
@@ -219,20 +218,14 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_tmerc& proj_parm)  /* general initialization */
             {
-                boost::ignore_unused(par);
-                boost::ignore_unused(proj_parm);
                 if (par.es) {
-                    pj_enfn(par.es, proj_parm.en);
-            
+                    if (!pj_enfn(par.es, proj_parm.en))
+                        throw proj_exception(0);
                     proj_parm.ml0 = pj_mlfn(par.phi0, sin(par.phi0), cos(par.phi0), proj_parm.en);
                     proj_parm.esp = par.es / (1. - par.es);
-                // par.inv = e_inverse;
-                // par.fwd = e_forward;
                 } else {
                     proj_parm.esp = par.k0;
                     proj_parm.ml0 = .5 * proj_parm.esp;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 }
             }
 
@@ -249,7 +242,7 @@ namespace boost { namespace geometry { namespace projections
             void setup_utm(Parameters& par, par_tmerc& proj_parm)
             {
                 int zone;
-                if (!par.es) throw proj_exception(-34);
+
                 par.y0 = pj_param(par.params, "bsouth").i ? 10000000. : 0.;
                 par.x0 = 500000.;
                 if (pj_param(par.params, "tzone").i) /* zone input ? */
@@ -293,28 +286,6 @@ namespace boost { namespace geometry { namespace projections
         }
     };
 
-    /*!
-        \brief Universal Transverse Mercator (UTM) projection
-        \ingroup projections
-        \tparam Geographic latlong point type
-        \tparam Cartesian xy point type
-        \tparam Parameters parameter type
-        \par Projection characteristics
-         - Cylindrical
-         - Spheroid
-         - zone= south
-        \par Example
-        \image html ex_utm.gif
-    */
-    template <typename Geographic, typename Cartesian, typename Parameters = parameters>
-    struct utm_ellipsoid : public detail::tmerc::base_tmerc_ellipsoid<Geographic, Cartesian, Parameters>
-    {
-        inline utm_ellipsoid(const Parameters& par) : detail::tmerc::base_tmerc_ellipsoid<Geographic, Cartesian, Parameters>(par)
-        {
-            detail::tmerc::setup_utm(this->m_par, this->m_proj_parm);
-        }
-    };
-
     /*!
         \brief Transverse Mercator projection
         \ingroup projections
@@ -337,6 +308,54 @@ namespace boost { namespace geometry { namespace projections
         }
     };
 
+    /*!
+        \brief Universal Transverse Mercator (UTM) projection
+        \ingroup projections
+        \tparam Geographic latlong point type
+        \tparam Cartesian xy point type
+        \tparam Parameters parameter type
+        \par Projection characteristics
+         - Cylindrical
+         - Spheroid
+        \par Projection parameters
+         - zone: UTM Zone (integer)
+         - south: Denotes southern hemisphere UTM zone (boolean)
+        \par Example
+        \image html ex_utm.gif
+    */
+    template <typename Geographic, typename Cartesian, typename Parameters = parameters>
+    struct utm_ellipsoid : public detail::tmerc::base_tmerc_ellipsoid<Geographic, Cartesian, Parameters>
+    {
+        inline utm_ellipsoid(const Parameters& par) : detail::tmerc::base_tmerc_ellipsoid<Geographic, Cartesian, Parameters>(par)
+        {
+            detail::tmerc::setup_utm(this->m_par, this->m_proj_parm);
+        }
+    };
+
+    /*!
+        \brief Universal Transverse Mercator (UTM) projection
+        \ingroup projections
+        \tparam Geographic latlong point type
+        \tparam Cartesian xy point type
+        \tparam Parameters parameter type
+        \par Projection characteristics
+         - Cylindrical
+         - Spheroid
+        \par Projection parameters
+         - zone: UTM Zone (integer)
+         - south: Denotes southern hemisphere UTM zone (boolean)
+        \par Example
+        \image html ex_utm.gif
+    */
+    template <typename Geographic, typename Cartesian, typename Parameters = parameters>
+    struct utm_spheroid : public detail::tmerc::base_tmerc_spheroid<Geographic, Cartesian, Parameters>
+    {
+        inline utm_spheroid(const Parameters& par) : detail::tmerc::base_tmerc_spheroid<Geographic, Cartesian, Parameters>(par)
+        {
+            detail::tmerc::setup_utm(this->m_par, this->m_proj_parm);
+        }
+    };
+
     #ifndef DOXYGEN_NO_DETAIL
     namespace detail
     {
@@ -361,7 +380,10 @@ namespace boost { namespace geometry { namespace projections
             public :
                 virtual projection<Geographic, Cartesian>* create_new(const Parameters& par) const
                 {
-                    return new base_v_fi<utm_ellipsoid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
+                    if (par.es)
+                        return new base_v_fi<utm_ellipsoid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
+                    else
+                        return new base_v_fi<utm_spheroid<Geographic, Cartesian, Parameters>, Geographic, Cartesian, Parameters>(par);
                 }
         };
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/tpeqd.hpp b/include/boost/geometry/extensions/gis/projections/proj/tpeqd.hpp
index bc11a1d13..965d4be29 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/tpeqd.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/tpeqd.hpp
@@ -44,11 +44,13 @@
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace tpeqd{
+    namespace detail { namespace tpeqd
+    {
 
             struct par_tpeqd
             {
@@ -113,6 +115,7 @@ namespace boost { namespace geometry { namespace projections
             void setup_tpeqd(Parameters& par, par_tpeqd& proj_parm)
             {
                 double lam_1, lam_2, phi_1, phi_2, A12, pp;
+
                 /* get control point locations */
                 phi_1 = pj_param(par.params, "rlat_1").f;
                 lam_1 = pj_param(par.params, "rlon_1").f;
@@ -141,8 +144,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.rhshz0 = .5 / sin(proj_parm.hz0);
                 proj_parm.r2z0 = 0.5 / proj_parm.z02;
                 proj_parm.z02 *= proj_parm.z02;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
                 par.es = 0.;
             }
 
@@ -158,7 +159,11 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Miscellaneous
          - Spheroid
-         - lat_1= lon_1= lat_2= lon_2=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel (degrees)
+         - lon_1 (degrees)
+         - lat_2: Latitude of second standard parallel (degrees)
+         - lon_2 (degrees)
         \par Example
         \image html ex_tpeqd.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/urm5.hpp b/include/boost/geometry/extensions/gis/projections/proj/urm5.hpp
index ce6a125b3..577e46c9e 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/urm5.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/urm5.hpp
@@ -38,17 +38,17 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace urm5{
+    namespace detail { namespace urm5
+    {
 
             struct par_urm5
             {
@@ -86,6 +86,7 @@ namespace boost { namespace geometry { namespace projections
             void setup_urm5(Parameters& par, par_urm5& proj_parm)
             {
                 double alpha, t;
+
                 proj_parm.n = pj_param(par.params, "dn").f;
                 proj_parm.q3 = pj_param(par.params, "dq").f / 3.;
                 alpha = pj_param(par.params, "ralpha").f;
@@ -93,8 +94,6 @@ namespace boost { namespace geometry { namespace projections
                 proj_parm.m = cos(alpha) / sqrt(1. - t * t);
                 proj_parm.rmn = 1. / (proj_parm.m * proj_parm.n);
                 par.es = 0.;
-                // par.inv = 0;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::urm5
@@ -110,7 +109,10 @@ namespace boost { namespace geometry { namespace projections
          - Pseudocylindrical
          - Spheroid
          - no inverse
-         - n= q= alpha=
+        \par Projection parameters
+         - n (real)
+         - q (real)
+         - alpha: Alpha (degrees)
         \par Example
         \image html ex_urm5.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/urmfps.hpp b/include/boost/geometry/extensions/gis/projections/proj/urmfps.hpp
index 3a9d14d46..c70b58b67 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/urmfps.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/urmfps.hpp
@@ -38,18 +38,18 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/core/ignore_unused.hpp>
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace urmfps{
+    namespace detail { namespace urmfps
+    {
+
             static const double C_x = 0.8773826753;
             static const double Cy = 1.139753528477;
 
@@ -91,12 +91,8 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup(Parameters& par, par_urmfps& proj_parm) 
             {
-                boost::ignore_unused(par);
-                boost::ignore_unused(proj_parm);
                 proj_parm.C_y = Cy / proj_parm.n;
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
 
@@ -133,7 +129,8 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Pseudocylindrical
          - Spheroid
-         - n=
+        \par Projection parameters
+         - n (real)
         \par Example
         \image html ex_urmfps.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/vandg.hpp b/include/boost/geometry/extensions/gis/projections/proj/vandg.hpp
index 32e5e9d98..703cd2b6a 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/vandg.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/vandg.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace vandg{
+    namespace detail { namespace vandg
+    {
+
             static const double TOL = 1.e-10;
             static const double THIRD = .33333333333333333333;
             static const double TWO_THRD = .66666666666666666666;
@@ -58,7 +58,6 @@ namespace boost { namespace geometry { namespace projections
             static const double TPISQ = 19.73920880217871723738;
             static const double HPISQ = 4.93480220054467930934;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_vandg_spheroid : public base_t_fi<base_vandg_spheroid<Geographic, Cartesian, Parameters>,
@@ -146,8 +145,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_vandg(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::vandg
diff --git a/include/boost/geometry/extensions/gis/projections/proj/vandg2.hpp b/include/boost/geometry/extensions/gis/projections/proj/vandg2.hpp
index 2bb33d513..434fea7ee 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/vandg2.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/vandg2.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace vandg2{
+    namespace detail { namespace vandg2
+    {
+
             static const double TOL = 1e-10;
             static const double TWORPI = 0.63661977236758134308;
 
@@ -107,8 +107,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_vandg2(Parameters& par, par_vandg2& proj_parm)
             {
                 proj_parm.vdg3 = 0;
-                // par.inv = 0;
-                // par.fwd = s_forward;
             }
 
             // van der Grinten III
@@ -117,7 +115,6 @@ namespace boost { namespace geometry { namespace projections
             {
                 proj_parm.vdg3 = 1;
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::vandg2
diff --git a/include/boost/geometry/extensions/gis/projections/proj/vandg4.hpp b/include/boost/geometry/extensions/gis/projections/proj/vandg4.hpp
index 798f3a0a7..970ff820c 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/vandg4.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/vandg4.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,11 +46,12 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace vandg4{
+    namespace detail { namespace vandg4
+    {
+
             static const double TOL = 1e-10;
             static const double TWORPI = 0.63661977236758134308;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_vandg4_spheroid : public base_t_f<base_vandg4_spheroid<Geographic, Cartesian, Parameters>,
@@ -108,7 +107,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_vandg4(Parameters& par)
             {
                 par.es = 0.;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::vandg4
diff --git a/include/boost/geometry/extensions/gis/projections/proj/wag2.hpp b/include/boost/geometry/extensions/gis/projections/proj/wag2.hpp
index 09a743f70..9fa719595 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/wag2.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/wag2.hpp
@@ -38,23 +38,23 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/factory_entry.hpp>
+#include <boost/geometry/extensions/gis/projections/impl/aasincos.hpp>
 
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace wag2{
+    namespace detail { namespace wag2
+    {
+
             static const double C_x = 0.92483;
             static const double C_y = 1.38725;
             static const double C_p1 = 0.88022;
             static const double C_p2 = 0.88550;
 
-
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
             struct base_wag2_spheroid : public base_t_fi<base_wag2_spheroid<Geographic, Cartesian, Parameters>,
@@ -89,8 +89,6 @@ namespace boost { namespace geometry { namespace projections
             void setup_wag2(Parameters& par)
             {
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::wag2
diff --git a/include/boost/geometry/extensions/gis/projections/proj/wag3.hpp b/include/boost/geometry/extensions/gis/projections/proj/wag3.hpp
index b34d39a94..b94f91c5f 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/wag3.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/wag3.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace wag3{
+    namespace detail { namespace wag3
+    {
+
             static const double TWOTHIRD = 0.6666666666666666666667;
 
             struct par_wag3
@@ -89,11 +89,10 @@ namespace boost { namespace geometry { namespace projections
             void setup_wag3(Parameters& par, par_wag3& proj_parm)
             {
                 double ts;
+
                 ts = pj_param(par.params, "rlat_ts").f;
                 proj_parm.C_x = cos(ts) / cos(2.*ts/3.);
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::wag3
@@ -108,7 +107,8 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Pseudocylindrical
          - Spheroid
-         - lat_ts=
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
         \par Example
         \image html ex_wag3.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/wag7.hpp b/include/boost/geometry/extensions/gis/projections/proj/wag7.hpp
index 565c8f022..c757cca6a 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/wag7.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/wag7.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,8 +46,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace wag7{
-
+    namespace detail { namespace wag7
+    {
 
             // template class, using CRTP to implement forward/inverse
             template <typename Geographic, typename Cartesian, typename Parameters>
@@ -80,8 +78,6 @@ namespace boost { namespace geometry { namespace projections
             template <typename Parameters>
             void setup_wag7(Parameters& par)
             {
-                // par.fwd = s_forward;
-                // par.inv = 0;
                 par.es = 0.;
             }
 
diff --git a/include/boost/geometry/extensions/gis/projections/proj/wink1.hpp b/include/boost/geometry/extensions/gis/projections/proj/wink1.hpp
index 731c5e0ea..6e50b077e 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/wink1.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/wink1.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,8 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace wink1{
+    namespace detail { namespace wink1
+    {
 
             struct par_wink1
             {
@@ -89,8 +88,6 @@ namespace boost { namespace geometry { namespace projections
             {
                 proj_parm.cosphi1 = cos(pj_param(par.params, "rlat_ts").f);
                 par.es = 0.;
-                // par.inv = s_inverse;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::wink1
@@ -105,7 +102,8 @@ namespace boost { namespace geometry { namespace projections
         \par Projection characteristics
          - Pseudocylindrical
          - Spheroid
-         - lat_ts=
+        \par Projection parameters
+         - lat_ts: Latitude of true scale (degrees)
         \par Example
         \image html ex_wink1.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/proj/wink2.hpp b/include/boost/geometry/extensions/gis/projections/proj/wink2.hpp
index cfad21270..3ea1aa595 100644
--- a/include/boost/geometry/extensions/gis/projections/proj/wink2.hpp
+++ b/include/boost/geometry/extensions/gis/projections/proj/wink2.hpp
@@ -38,8 +38,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 
-#include <boost/math/special_functions/hypot.hpp>
-
 #include <boost/geometry/extensions/gis/projections/impl/base_static.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/base_dynamic.hpp>
 #include <boost/geometry/extensions/gis/projections/impl/projects.hpp>
@@ -48,7 +46,9 @@
 namespace boost { namespace geometry { namespace projections
 {
     #ifndef DOXYGEN_NO_DETAIL
-    namespace detail { namespace wink2{
+    namespace detail { namespace wink2
+    {
+
             static const int MAX_ITER = 10;
             static const double LOOP_TOL = 1e-7;
             static const double TWO_D_PI = 0.636619772367581343;
@@ -102,8 +102,6 @@ namespace boost { namespace geometry { namespace projections
             {
                 proj_parm.cosphi1 = cos(pj_param(par.params, "rlat_1").f);
                 par.es = 0.;
-                // par.inv = 0;
-                // par.fwd = s_forward;
             }
 
         }} // namespace detail::wink2
@@ -119,7 +117,8 @@ namespace boost { namespace geometry { namespace projections
          - Pseudocylindrical
          - Spheroid
          - no inverse
-         - lat_1=
+        \par Projection parameters
+         - lat_1: Latitude of first standard parallel (degrees)
         \par Example
         \image html ex_wink2.gif
     */
diff --git a/include/boost/geometry/extensions/gis/projections/project_inverse_transformer.hpp b/include/boost/geometry/extensions/gis/projections/project_inverse_transformer.hpp
index 4386c8eea..136d51133 100644
--- a/include/boost/geometry/extensions/gis/projections/project_inverse_transformer.hpp
+++ b/include/boost/geometry/extensions/gis/projections/project_inverse_transformer.hpp
@@ -60,8 +60,8 @@ struct project_inverse_transformer
     {
         // Latlong (LL -> XY) will be projected, rest will be copied.
         // So first copy third or higher dimensions
-        geometry::detail::convert::point_to_point<Cartesian, LatLong, 2,
-                geometry::dimension<Cartesian>::value> ::copy(p1, p2);
+        geometry::detail::conversion::point_to_point<Cartesian, LatLong, 2,
+                geometry::dimension<Cartesian>::value> ::apply(p1, p2);
         return m_prj->inverse(p1, p2);
     }
 
diff --git a/include/boost/geometry/extensions/gis/projections/projection.hpp b/include/boost/geometry/extensions/gis/projections/projection.hpp
index e3c5637d4..f84e140a7 100644
--- a/include/boost/geometry/extensions/gis/projections/projection.hpp
+++ b/include/boost/geometry/extensions/gis/projections/projection.hpp
@@ -55,7 +55,10 @@ class projection
         virtual std::string name() const = 0;
 
         /// Returns parameters of projection
-        virtual parameters params() const = 0;
+        virtual parameters const& params() const = 0;
+
+        /// Returns mutable parameters of projection
+        virtual parameters& mutable_params() = 0;
 
         virtual ~projection() {}
 
diff --git a/include/boost/geometry/strategies/buffer.hpp b/include/boost/geometry/strategies/buffer.hpp
index 7dbe03b4a..be3daefec 100644
--- a/include/boost/geometry/strategies/buffer.hpp
+++ b/include/boost/geometry/strategies/buffer.hpp
@@ -66,7 +66,8 @@ enum piece_type
     buffered_round_end,
     buffered_flat_end,
     buffered_point,
-    buffered_concave   // always on the inside
+    buffered_concave,   // always on the inside
+    piece_type_unknown
 };
 
 
diff --git a/include/boost/geometry/strategies/cartesian/buffer_side_straight.hpp b/include/boost/geometry/strategies/cartesian/buffer_side_straight.hpp
index 24655ab3d..221dbe030 100644
--- a/include/boost/geometry/strategies/cartesian/buffer_side_straight.hpp
+++ b/include/boost/geometry/strategies/cartesian/buffer_side_straight.hpp
@@ -73,6 +73,17 @@ public :
         // For normalization [0,1] (=dot product d.d, sqrt)
         promoted_type const length = geometry::math::sqrt(dx * dx + dy * dy);
 
+        if (! boost::math::isfinite(length))
+        {
+            // In case of coordinates differences of e.g. 1e300, length
+            // will overflow and we should not generate output
+#ifdef BOOST_GEOMETRY_DEBUG_BUFFER_WARN
+            std::cout << "Length not calculated for points " << geometry::wkt(input_p1)
+                << " " << geometry::wkt(input_p2) << " " << length << std::endl;
+#endif
+            return;
+        }
+
         if (geometry::math::equals(length, 0))
         {
             // Coordinates are simplified and therefore most often not equal.
diff --git a/include/boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp b/include/boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp
index 0357f17e7..47763a9f3 100644
--- a/include/boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp
+++ b/include/boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp
@@ -1,8 +1,8 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
-// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
-// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
 
 // This file was modified by Oracle on 2015.
 // Modifications copyright (c) 2015 Oracle and/or its affiliates.
@@ -22,6 +22,7 @@
 
 #include <cstddef>
 
+#include <boost/math/special_functions/fpclassify.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 #include <boost/type_traits.hpp>
@@ -206,11 +207,18 @@ public :
                     Point
                 >::type coordinate_type;
 
-            set<0>(centroid,
-                boost::numeric_cast<coordinate_type>(state.sum_x / a3));
-            set<1>(centroid,
-                boost::numeric_cast<coordinate_type>(state.sum_y / a3));
-            return true;
+            // Prevent NaN centroid coordinates
+            if (boost::math::isfinite(a3))
+            {
+                // NOTE: above calculation_type is checked, not the centroid coordinate_type
+                // which means that the centroid can still be filled with INF
+                // if e.g. calculation_type is double and centroid contains floats
+                set<0>(centroid,
+                    boost::numeric_cast<coordinate_type>(state.sum_x / a3));
+                set<1>(centroid,
+                    boost::numeric_cast<coordinate_type>(state.sum_y / a3));
+                return true;
+            }
         }
 
         return false;
diff --git a/include/boost/geometry/strategies/cartesian/centroid_weighted_length.hpp b/include/boost/geometry/strategies/cartesian/centroid_weighted_length.hpp
index b788738d1..0735e925b 100644
--- a/include/boost/geometry/strategies/cartesian/centroid_weighted_length.hpp
+++ b/include/boost/geometry/strategies/cartesian/centroid_weighted_length.hpp
@@ -1,7 +1,12 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
-// Copyright (c) 2009-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2009-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 
 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
@@ -13,9 +18,13 @@
 #ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_WEIGHTED_LENGTH_HPP
 #define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_WEIGHTED_LENGTH_HPP
 
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+
 #include <boost/geometry/algorithms/detail/distance/interface.hpp>
 #include <boost/geometry/algorithms/detail/distance/point_to_geometry.hpp>
 #include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/util/for_each_coordinate.hpp>
 #include <boost/geometry/util/select_most_precise.hpp>
 #include <boost/geometry/strategies/centroid.hpp>
 #include <boost/geometry/strategies/default_distance_result.hpp>
@@ -91,17 +100,37 @@ public :
     static inline bool result(state_type const& state, Point& centroid)
     {
         distance_type const zero = distance_type();
-        if (! geometry::math::equals(state.length, zero))
+        if (! geometry::math::equals(state.length, zero)
+            && boost::math::isfinite(state.length)) // Prevent NaN centroid coordinates
         {
-            assign_zero(centroid);
-            add_point(centroid, state.average_sum);
-            divide_value(centroid, state.length);
+            // NOTE: above distance_type is checked, not the centroid coordinate_type
+            // which means that the centroid can still be filled with INF
+            // if e.g. distance_type is double and centroid contains floats
+            geometry::for_each_coordinate(centroid, set_sum_div_length(state));
             return true;
         }
 
         return false;
     }
 
+    struct set_sum_div_length
+    {
+        state_type const& m_state;
+        set_sum_div_length(state_type const& state)
+            : m_state(state)
+        {}
+        template <typename Pt, std::size_t Dimension>
+        void apply(Pt & centroid) const
+        {
+            typedef typename geometry::coordinate_type<Pt>::type coordinate_type;
+            geometry::set<Dimension>(
+                centroid,
+                boost::numeric_cast<coordinate_type>(
+                    geometry::get<Dimension>(m_state.average_sum) / m_state.length
+                )
+            );
+        }
+    };
 };
 
 #ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
diff --git a/include/boost/geometry/strategies/cartesian/side_of_intersection.hpp b/include/boost/geometry/strategies/cartesian/side_of_intersection.hpp
index 39487676c..9ed6b6377 100644
--- a/include/boost/geometry/strategies/cartesian/side_of_intersection.hpp
+++ b/include/boost/geometry/strategies/cartesian/side_of_intersection.hpp
@@ -2,6 +2,11 @@
 
 // Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
 
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -10,11 +15,24 @@
 #define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_SIDE_OF_INTERSECTION_HPP
 
 
+#include <limits>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+
 #include <boost/geometry/arithmetic/determinant.hpp>
 #include <boost/geometry/core/access.hpp>
 #include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/strategies/cartesian/side_by_triangle.hpp>
 #include <boost/geometry/util/math.hpp>
 
+#ifdef BOOST_GEOMETRY_SIDE_OF_INTERSECTION_DEBUG
+#include <boost/math/common_factor_ct.hpp>
+#include <boost/math/common_factor_rt.hpp>
+#include <boost/multiprecision/cpp_int.hpp>
+#endif
 
 namespace boost { namespace geometry
 {
@@ -22,6 +40,94 @@ namespace boost { namespace geometry
 namespace strategy { namespace side
 {
 
+namespace detail
+{
+
+// A tool for multiplication of integers avoiding overflow
+// It's a temporary workaround until we can use Multiprecision
+// The algorithm is based on Karatsuba algorithm
+// see: http://en.wikipedia.org/wiki/Karatsuba_algorithm
+template <typename T>
+struct multiplicable_integral
+{
+    // Currently this tool can't be used with non-integral coordinate types.
+    // Also side_of_intersection strategy sign_of_product() and sign_of_compare()
+    // functions would have to be modified to properly support floating-point
+    // types (comparisons and multiplication).
+    BOOST_STATIC_ASSERT(boost::is_integral<T>::value);
+
+    static const std::size_t bits = CHAR_BIT * sizeof(T);
+    static const std::size_t half_bits = bits / 2;
+    typedef typename boost::make_unsigned<T>::type unsigned_type;
+    static const unsigned_type base = unsigned_type(1) << half_bits; // 2^half_bits
+
+    int m_sign;
+    unsigned_type m_ms;
+    unsigned_type m_ls;
+
+    multiplicable_integral(int sign, unsigned_type ms, unsigned_type ls)
+        : m_sign(sign), m_ms(ms), m_ls(ls)
+    {}
+
+    explicit multiplicable_integral(T const& val)
+    {
+        unsigned_type val_u = val > 0 ?
+                                unsigned_type(val)
+                              : val == (std::numeric_limits<T>::min)() ?
+                                  unsigned_type((std::numeric_limits<T>::max)()) + 1
+                                : unsigned_type(-val);
+        // MMLL -> S 00MM 00LL
+        m_sign = math::sign(val);
+        m_ms = val_u >> half_bits; // val_u / base
+        m_ls = val_u - m_ms * base;
+    }
+    
+    friend multiplicable_integral operator*(multiplicable_integral const& a,
+                                            multiplicable_integral const& b)
+    {
+        // (S 00MM 00LL) * (S 00MM 00LL) -> (S Z2MM 00LL)
+        unsigned_type z2 = a.m_ms * b.m_ms;
+        unsigned_type z0 = a.m_ls * b.m_ls;
+        unsigned_type z1 = (a.m_ms + a.m_ls) * (b.m_ms + b.m_ls) - z2 - z0;
+        // z0 may be >= base so it must be normalized to allow comparison
+        unsigned_type z0_ms = z0 >> half_bits; // z0 / base
+        return multiplicable_integral(a.m_sign * b.m_sign,
+                                      z2 * base + z1 + z0_ms,
+                                      z0 - base * z0_ms);
+    }
+
+    friend bool operator<(multiplicable_integral const& a,
+                          multiplicable_integral const& b)
+    {
+        if ( a.m_sign == b.m_sign )
+        {
+            bool u_less = a.m_ms < b.m_ms
+                      || (a.m_ms == b.m_ms && a.m_ls < b.m_ls);
+            return a.m_sign > 0 ? u_less : (! u_less);
+        }
+        else
+        {
+            return a.m_sign < b.m_sign;
+        }
+    }
+
+    friend bool operator>(multiplicable_integral const& a,
+                          multiplicable_integral const& b)
+    {
+        return b < a;
+    }
+
+    template <typename CmpVal>
+    void check_value(CmpVal const& cmp_val) const
+    {
+        unsigned_type b = base; // a workaround for MinGW - undefined reference base
+        CmpVal val = CmpVal(m_sign) * (CmpVal(m_ms) * CmpVal(b) + CmpVal(m_ls));
+        BOOST_ASSERT(cmp_val == val);
+    }
+};
+
+} // namespace detail
+
 // Calculates the side of the intersection-point (if any) of
 // of segment a//b w.r.t. segment c
 // This is calculated without (re)calculating the IP itself again and fully
@@ -29,15 +135,93 @@ namespace strategy { namespace side
 // It can be used for either integer (rescaled) points, and also for FP
 class side_of_intersection
 {
+private :
+    template <typename T, typename U>
+    static inline
+    int sign_of_product(T const& a, U const& b)
+    {
+        return a == 0 || b == 0 ? 0
+            : a > 0 && b > 0 ? 1
+            : a < 0 && b < 0 ? 1
+            : -1;
+    }
+
+    template <typename T>
+    static inline
+    int sign_of_compare(T const& a, T const& b, T const& c, T const& d)
+    {
+        // Both a*b and c*d are positive
+        // We have to judge if a*b > c*d
+
+        using side::detail::multiplicable_integral;
+        multiplicable_integral<T> ab = multiplicable_integral<T>(a)
+                                     * multiplicable_integral<T>(b);
+        multiplicable_integral<T> cd = multiplicable_integral<T>(c)
+                                     * multiplicable_integral<T>(d);
+        
+        int result = ab > cd ? 1
+                   : ab < cd ? -1
+                   : 0
+                   ;
+
+#ifdef BOOST_GEOMETRY_SIDE_OF_INTERSECTION_DEBUG
+        using namespace boost::multiprecision;
+        cpp_int const lab = cpp_int(a) * cpp_int(b);
+        cpp_int const lcd = cpp_int(c) * cpp_int(d);
+
+        ab.check_value(lab);
+        cd.check_value(lcd);
+
+        int result2 = lab > lcd ? 1
+                    : lab < lcd ? -1
+                    : 0
+                    ;
+        BOOST_ASSERT(result == result2);
+#endif
+
+        return result;
+    }
+
+    template <typename T>
+    static inline
+    int sign_of_addition_of_two_products(T const& a, T const& b, T const& c, T const& d)
+    {
+        // sign of a*b+c*d, 1 if positive, -1 if negative, else 0
+        int const ab = sign_of_product(a, b);
+        int const cd = sign_of_product(c, d);
+        if (ab == 0)
+        {
+            return cd;
+        }
+        if (cd == 0)
+        {
+            return ab;
+        }
+
+        if (ab == cd)
+        {
+            // Both positive or both negative
+            return ab;
+        }
+
+        // One is positive, one is negative, both are non zero
+        // If ab is positive, we have to judge if a*b > -c*d (then 1 because sum is positive)
+        // If ab is negative, we have to judge if c*d > -a*b (idem)
+        return ab == 1
+            ? sign_of_compare(a, b, -c, d)
+            : sign_of_compare(c, d, -a, b);
+    }
+
+
 public :
 
     // Calculates the side of the intersection-point (if any) of
     // of segment a//b w.r.t. segment c
     // This is calculated without (re)calculating the IP itself again and fully
     // based on integer mathematics
-    template <typename T, typename Segment>
+    template <typename T, typename Segment, typename Point>
     static inline T side_value(Segment const& a, Segment const& b,
-                Segment const& c)
+                Segment const& c, Point const& fallback_point)
     {
         // The first point of the three segments is reused several times
         T const ax = get<0, 0>(a);
@@ -67,9 +251,15 @@ public :
         if (d == zero)
         {
             // There is no IP of a//b, they are collinear or parallel
-            // We don't have to divide but we can already conclude the side-value
-            // is meaningless and the resulting determinant will be 0
-            return zero;
+            // Assuming they intersect (this method should be called for
+            // segments known to intersect), they are collinear and overlap.
+            // They have one or two intersection points - we don't know and
+            // have to rely on the fallback intersection point
+
+            Point c1, c2;
+            geometry::detail::assign_point_from_index<0>(c, c1);
+            geometry::detail::assign_point_from_index<1>(c, c2);
+            return side_by_triangle<>::apply(c1, c2, fallback_point);
         }
 
         // Cramer's rule: da (see cart_intersect.hpp)
@@ -82,7 +272,9 @@ public :
         // IP is at (ax + (da/d) * dx_a, ay + (da/d) * dy_a)
         // Side of IP is w.r.t. c is: determinant(dx_c, dy_c, ipx-cx, ipy-cy)
         // We replace ipx by expression above and multiply each term by d
-        T const result = geometry::detail::determinant<T>
+
+#ifdef BOOST_GEOMETRY_SIDE_OF_INTERSECTION_DEBUG
+        T const result1 = geometry::detail::determinant<T>
                     (
                         dx_c * d,                   dy_c * d,
                         d * (ax - cx) + dx_a * da,  d * (ay - cy) + dy_a * da
@@ -93,15 +285,52 @@ public :
         // Therefore, the sign is always the same as that result, and the
         // resulting side (left,right,collinear) is the same
 
+        // The first row we divide again by d because of determinant multiply rule
+        T const result2 = d * geometry::detail::determinant<T>
+                    (
+                        dx_c,                   dy_c,
+                        d * (ax - cx) + dx_a * da,  d * (ay - cy) + dy_a * da
+                    );
+        // Write out:
+        T const result3 = d * (dx_c * (d * (ay - cy) + dy_a * da)
+                             - dy_c * (d * (ax - cx) + dx_a * da));
+        // Write out in braces:
+        T const result4 = d * (dx_c * d * (ay - cy) + dx_c * dy_a * da
+                             - dy_c * d * (ax - cx) - dy_c * dx_a * da);
+        // Write in terms of d * XX + da * YY
+        T const result5 = d * (d * (dx_c * (ay - cy) - dy_c * (ax - cx))
+                             + da * (dx_c * dy_a - dy_c * dx_a));
+
+        boost::ignore_unused(result1, result2, result3, result4, result5);
+        //return result;
+#endif
+
+        // We consider the results separately
+        // (in the end we only have to return the side-value 1,0 or -1)
+
+        // To avoid multiplications we judge the product (easy, avoids *d)
+        // and the sign of p*q+r*s (more elaborate)
+        T const result = sign_of_product
+            (
+                d,
+                sign_of_addition_of_two_products
+                    (
+                        d, dx_c * (ay - cy) - dy_c * (ax - cx),
+                        da, dx_c * dy_a - dy_c * dx_a
+                    )
+                );
         return result;
 
+
     }
 
-    template <typename Segment>
-    static inline int apply(Segment const& a, Segment const& b, Segment const& c)
+    template <typename Segment, typename Point>
+    static inline int apply(Segment const& a, Segment const& b,
+            Segment const& c,
+            Point const& fallback_point)
     {
         typedef typename geometry::coordinate_type<Segment>::type coordinate_type;
-        coordinate_type const s = side_value<coordinate_type>(a, b, c);
+        coordinate_type const s = side_value<coordinate_type>(a, b, c, fallback_point);
         coordinate_type const zero = coordinate_type();
         return math::equals(s, zero) ? 0
             : s > zero ? 1
diff --git a/include/boost/geometry/strategies/spherical/distance_cross_track.hpp b/include/boost/geometry/strategies/spherical/distance_cross_track.hpp
index 486c7effb..31993e76c 100644
--- a/include/boost/geometry/strategies/spherical/distance_cross_track.hpp
+++ b/include/boost/geometry/strategies/spherical/distance_cross_track.hpp
@@ -372,11 +372,16 @@ public :
         typedef typename return_type<Point, PointOfSegment>::type return_type;
 
 #ifdef BOOST_GEOMETRY_DEBUG_CROSS_TRACK
-        std::cout << "Course " << dsv(sp1) << " to " << dsv(p) << " " << crs_AD * geometry::math::r2d << std::endl;
-        std::cout << "Course " << dsv(sp1) << " to " << dsv(sp2) << " " << crs_AB * geometry::math::r2d << std::endl;
-        std::cout << "Course " << dsv(sp2) << " to " << dsv(p) << " " << crs_BD * geometry::math::r2d << std::endl;
-        std::cout << "Projection AD-AB " << projection1 << " : " << d_crs1 * geometry::math::r2d << std::endl;
-        std::cout << "Projection BD-BA " << projection2 << " : " << d_crs2 * geometry::math::r2d << std::endl;
+        std::cout << "Course " << dsv(sp1) << " to " << dsv(p) << " "
+                  << crs_AD * geometry::math::r2d<return_type>() << std::endl;
+        std::cout << "Course " << dsv(sp1) << " to " << dsv(sp2) << " "
+                  << crs_AB * geometry::math::r2d<return_type>() << std::endl;
+        std::cout << "Course " << dsv(sp2) << " to " << dsv(p) << " "
+                  << crs_BD * geometry::math::r2d << std::endl;
+        std::cout << "Projection AD-AB " << projection1 << " : "
+                  << d_crs1 * geometry::math::r2d<return_type>() << std::endl;
+        std::cout << "Projection BD-BA " << projection2 << " : "
+                  << d_crs2 * geometry::math::r2d<return_type>() << std::endl;
 #endif
 
         // http://williams.best.vwh.net/avform.htm#XTE
diff --git a/include/boost/geometry/strategies/strategy_transform.hpp b/include/boost/geometry/strategies/strategy_transform.hpp
index 9d3b1d910..99fcb720c 100644
--- a/include/boost/geometry/strategies/strategy_transform.hpp
+++ b/include/boost/geometry/strategies/strategy_transform.hpp
@@ -1,8 +1,13 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
-// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
-// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 
 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
@@ -28,6 +33,7 @@
 #include <boost/geometry/strategies/transform.hpp>
 
 #include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
 #include <boost/geometry/util/select_coordinate_type.hpp>
 
 namespace boost { namespace geometry
@@ -130,7 +136,15 @@ struct degree_radian_vv
         assert_dimension<P1, 2>();
         assert_dimension<P2, 2>();
 
-        detail::transform_coordinates<P1, P2, 0, 2, F>::transform(p1, p2, math::d2r);
+        typedef typename promote_floating_point
+            <
+                typename select_coordinate_type<P1, P2>::type
+            >::type calculation_type;
+
+        detail::transform_coordinates
+            <
+                P1, P2, 0, 2, F
+            >::transform(p1, p2, math::d2r<calculation_type>());
         return true;
     }
 };
@@ -143,7 +157,16 @@ struct degree_radian_vv_3
         assert_dimension<P1, 3>();
         assert_dimension<P2, 3>();
 
-        detail::transform_coordinates<P1, P2, 0, 2, F>::transform(p1, p2, math::d2r);
+        typedef typename promote_floating_point
+            <
+                typename select_coordinate_type<P1, P2>::type
+            >::type calculation_type;
+
+        detail::transform_coordinates
+            <
+                P1, P2, 0, 2, F
+            >::transform(p1, p2, math::d2r<calculation_type>());
+
         // Copy height or other third dimension
         set<2>(p2, get<2>(p1));
         return true;
diff --git a/include/boost/geometry/strategies/transform/matrix_transformers.hpp b/include/boost/geometry/strategies/transform/matrix_transformers.hpp
index 27a3a2ae8..699b91b3a 100644
--- a/include/boost/geometry/strategies/transform/matrix_transformers.hpp
+++ b/include/boost/geometry/strategies/transform/matrix_transformers.hpp
@@ -1,8 +1,13 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
-// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
-// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 
 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
@@ -40,6 +45,7 @@
 #include <boost/geometry/core/coordinate_dimension.hpp>
 #include <boost/geometry/core/cs.hpp>
 #include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
 #include <boost/geometry/util/select_coordinate_type.hpp>
 #include <boost/geometry/util/select_most_precise.hpp>
 
@@ -340,7 +346,8 @@ struct as_radian<degree>
     template <typename T>
     static inline T get(T const& value)
     {
-        return value * math::d2r;
+        typedef typename promote_floating_point<T>::type promoted_type;
+        return value * math::d2r<promoted_type>();
     }
 
 };
diff --git a/include/boost/geometry/util/math.hpp b/include/boost/geometry/util/math.hpp
index 8361ee76f..4adc6a4ed 100644
--- a/include/boost/geometry/util/math.hpp
+++ b/include/boost/geometry/util/math.hpp
@@ -26,9 +26,7 @@
 #include <boost/core/ignore_unused.hpp>
 
 #include <boost/math/constants/constants.hpp>
-#ifdef BOOST_GEOMETRY_SQRT_CHECK_FINITENESS
 #include <boost/math/special_functions/fpclassify.hpp>
-#endif // BOOST_GEOMETRY_SQRT_CHECK_FINITENESS
 #include <boost/math/special_functions/round.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 #include <boost/type_traits/is_fundamental.hpp>
@@ -162,7 +160,17 @@ struct equals<Type, true>
             return true;
         }
 
-        return abs<Type>::apply(a - b) <= std::numeric_limits<Type>::epsilon() * policy.apply(a, b);
+        if (boost::math::isfinite(a) && boost::math::isfinite(b))
+        {
+            // If a is INF and b is e.g. 0, the expression below returns true
+            // but the values are obviously not equal, hence the condition
+            return abs<Type>::apply(a - b)
+                <= std::numeric_limits<Type>::epsilon() * policy.apply(a, b);
+        }
+        else
+        {
+            return a == b;
+        }
     }
 };
 
@@ -493,9 +501,20 @@ inline bool larger(T1 const& a, T2 const& b)
 }
 
 
+template <typename T>
+inline T d2r()
+{
+    static T const conversion_coefficient = geometry::math::pi<T>() / T(180.0);
+    return conversion_coefficient;
+}
+
+template <typename T>
+inline T r2d()
+{
+    static T const conversion_coefficient = T(180.0) / geometry::math::pi<T>();
+    return conversion_coefficient;
+}
 
-double const d2r = geometry::math::pi<double>() / 180.0;
-double const r2d = 1.0 / d2r;
 
 /*!
     \brief Calculates the haversine of an angle
diff --git a/include/boost/geometry/util/normalize_spheroidal_coordinates.hpp b/include/boost/geometry/util/normalize_spheroidal_coordinates.hpp
new file mode 100644
index 000000000..2379b2d22
--- /dev/null
+++ b/include/boost/geometry/util/normalize_spheroidal_coordinates.hpp
@@ -0,0 +1,254 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_UTIL_NORMALIZE_SPHEROIDAL_COORDINATES_HPP
+#define BOOST_GEOMETRY_UTIL_NORMALIZE_SPHEROIDAL_COORDINATES_HPP
+
+#include <boost/assert.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace math 
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+template <typename CoordinateType, typename Units>
+struct constants_on_spheroid
+{
+    static inline CoordinateType period()
+    {
+        return math::two_pi<CoordinateType>();
+    }
+
+    static inline CoordinateType half_period()
+    {
+        return math::pi<CoordinateType>();
+    }
+
+    static inline CoordinateType min_longitude()
+    {
+        static CoordinateType const minus_pi = -math::pi<CoordinateType>();
+        return minus_pi;
+    }
+
+    static inline CoordinateType max_longitude()
+    {
+        return math::pi<CoordinateType>();
+    }
+
+    static inline CoordinateType min_latitude()
+    {
+        static CoordinateType const minus_half_pi
+            = -math::half_pi<CoordinateType>();
+        return minus_half_pi;
+    }
+
+    static inline CoordinateType max_latitude()
+    {
+        return math::half_pi<CoordinateType>();
+    }
+};
+
+template <typename CoordinateType>
+struct constants_on_spheroid<CoordinateType, degree>
+{
+    static inline CoordinateType period()
+    {
+        return CoordinateType(360.0);
+    }
+
+    static inline CoordinateType half_period()
+    {
+        return CoordinateType(180.0);
+    }
+
+    static inline CoordinateType min_longitude()
+    {
+        return CoordinateType(-180.0);
+    }
+
+    static inline CoordinateType max_longitude()
+    {
+        return CoordinateType(180.0);
+    }
+
+    static inline CoordinateType min_latitude()
+    {
+        return CoordinateType(-90.0);
+    }
+
+    static inline CoordinateType max_latitude()
+    {
+        return CoordinateType(90.0);
+    }
+};
+
+
+template <typename Units, typename CoordinateType>
+class normalize_spheroidal_coordinates
+{
+    typedef constants_on_spheroid<CoordinateType, Units> constants;
+
+protected:
+    static inline CoordinateType normalize_up(CoordinateType const& value)
+    {
+        return
+            math::mod(value + constants::half_period(), constants::period())
+            - constants::half_period();            
+    }
+
+    static inline CoordinateType normalize_down(CoordinateType const& value)
+    {
+        return
+            math::mod(value - constants::half_period(), constants::period())
+            + constants::half_period();            
+    }
+
+public:
+    static inline void apply(CoordinateType& longitude,
+                             CoordinateType& latitude,
+                             bool normalize_poles = true)
+    {
+
+        // first normalize latitude
+        if (math::larger(latitude, constants::half_period()))
+        {
+            latitude = normalize_up(latitude);
+        }
+        else if (math::smaller(latitude, -constants::half_period()))
+        {
+            latitude = normalize_down(latitude);
+        }
+
+        // fix latitude range
+        if (latitude < constants::min_latitude())
+        {
+            latitude = -constants::half_period() - latitude;
+            longitude -= constants::half_period();
+        }
+        else if (latitude > constants::max_latitude())
+        {
+            latitude = constants::half_period() - latitude;
+            longitude -= constants::half_period();
+        }
+
+        // now normalize longitude
+        if (math::equals(longitude, -constants::half_period())
+            || math::equals(longitude, constants::half_period()))
+        {
+            longitude = constants::half_period();
+        }
+        else if (longitude > constants::half_period())
+        {
+            longitude = normalize_up(longitude);
+            if (math::equals(longitude, -constants::half_period()))
+            {
+                longitude = constants::half_period();
+            }
+        }
+        else if (longitude < -constants::half_period())
+        {
+            longitude = normalize_down(longitude);
+        }
+
+        // finally normalize poles
+        if (normalize_poles)
+        {
+            if (math::equals(math::abs(latitude), constants::max_latitude()))
+            {
+                // for the north and south pole we set the longitude to 0
+                // (works for both radians and degrees)
+                longitude = CoordinateType(0);
+            }
+        }
+
+        BOOST_ASSERT(! math::larger(constants::min_latitude(), latitude));
+        BOOST_ASSERT(! math::larger(latitude, constants::max_latitude()));
+
+        BOOST_ASSERT(math::smaller(constants::min_longitude(), longitude));
+        BOOST_ASSERT(! math::larger(longitude, constants::max_longitude()));
+    }
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+template <typename Units, typename CoordinateType>
+inline CoordinateType min_longitude()
+{
+    return detail::constants_on_spheroid
+        <
+            CoordinateType, Units
+        >::min_longitude();
+}
+
+template <typename Units, typename CoordinateType>
+inline CoordinateType max_longitude()
+{
+    return detail::constants_on_spheroid
+        <
+            CoordinateType, Units
+        >::max_longitude();
+}
+
+template <typename Units, typename CoordinateType>
+inline CoordinateType min_latitude()
+{
+    return detail::constants_on_spheroid
+        <
+            CoordinateType, Units
+        >::min_latitude();
+}
+
+template <typename Units, typename CoordinateType>
+inline CoordinateType max_latitude()
+{
+    return detail::constants_on_spheroid
+        <
+            CoordinateType, Units
+        >::max_latitude();
+}
+
+
+/*!
+\brief Short utility to normalize the coordinates on a spheroid
+\tparam Units The units of the coordindate system in the spheroid
+\tparam CoordinateType The type of the coordinates
+\param longitude Longitude
+\param latitude Latitude
+\ingroup utility
+*/
+template <typename Units, typename CoordinateType>
+inline void normalize_spheroidal_coordinates(CoordinateType& longitude,
+                                             CoordinateType& latitude)
+{
+    detail::normalize_spheroidal_coordinates
+        <
+            Units, CoordinateType
+        >::apply(longitude, latitude);
+}
+
+
+} // namespace math
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_NORMALIZE_SPHEROIDAL_COORDINATES_HPP
diff --git a/test/algorithms/Jamfile.v2 b/test/algorithms/Jamfile.v2
index 5fd0e3c04..5233e3f61 100644
--- a/test/algorithms/Jamfile.v2
+++ b/test/algorithms/Jamfile.v2
@@ -28,6 +28,7 @@ test-suite boost-geometry-algorithms
     [ run envelope.cpp ]
     [ run expand.cpp ]
     [ run for_each.cpp ]
+    [ run is_convex.cpp ]
     [ run is_simple.cpp ]
     [ run is_valid.cpp ]
     [ run is_valid_failure.cpp ]
diff --git a/test/algorithms/buffer/linestring_buffer.cpp b/test/algorithms/buffer/linestring_buffer.cpp
index 5179eff9b..1b5ed0354 100644
--- a/test/algorithms/buffer/linestring_buffer.cpp
+++ b/test/algorithms/buffer/linestring_buffer.cpp
@@ -65,6 +65,15 @@ static std::string const mysql_report_2015_03_02c = "LINESTRING(0 2,0 5,5 5,5 0,
 
 static std::string const mysql_report_2015_04_01 = "LINESTRING(103 5,107 2,111 4,116 -1,115 0,112 4)";
 
+static std::string const mysql_report_2015_04_10a = "LINESTRING(1.922421e+307 1.520384e+308, 15 42, 89 -93,-89 -22)";
+static std::string const mysql_report_2015_04_10b = "LINESTRING(15 42, 89 -93,-89 -22, 1.922421e+307 1.520384e+308)";
+static std::string const mysql_report_2015_04_10c = "LINESTRING(15 42, 1.922421e+307 1.520384e+308, 89 -93,-89 -22)";
+static std::string const mysql_report_2015_04_10d = "LINESTRING(1.922421e+307 1.520384e+308, 1.923421e+307 1.521384e+308, 15 42, 89 -93,-89 -22)";
+static std::string const mysql_report_2015_04_10e = "LINESTRING(15 42, 89 -93,-89 -22, 1.922421e+307 1.520384e+308, 1.923421e+307 1.521384e+308)";
+static std::string const mysql_report_2015_04_10f = "LINESTRING(15 42, 1.922421e+307 1.520384e+308, 1.923421e+307 1.521384e+308, 89 -93,-89 -22)";
+static std::string const mysql_report_2015_04_10g = "LINESTRING(15 42, 89 -93,-89 -22)";
+
+
 
 template <bool Clockwise, typename P>
 void test_all()
@@ -203,9 +212,10 @@ void test_all()
         double const d15 = 1.5;
         test_one<linestring, polygon>("mysql_report_2015_03_02c_asym1", mysql_report_2015_03_02c, join_round(7), end_round(7), 39.714, d10, d15);
         test_one<linestring, polygon>("mysql_report_2015_03_02c_asym2", mysql_report_2015_03_02c, join_round(7), end_round(7), 46.116, d15, d10);
-#if defined(BOOST_GEOMETRY_BUFFER_INCLUDE_FAILING_TESTS)
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
         double const d100 = 10;
-        test_one<linestring, polygon>("mysql_report_2015_04_01", mysql_report_2015_04_01, join_round(32), end_round(32), 1.0/*NON ZERO*/, d100);
+        test_one<linestring, polygon>("mysql_report_2015_04_01", mysql_report_2015_04_01, join_round(32), end_round(32), 632.234, d100);
 #endif
     }
 
@@ -231,14 +241,38 @@ void test_all()
         test_one<linestring, polygon>("aimes181", aimes181, join_round_by_divide, end_round, 2.57415564419716247e-08, 0.000036, 0.000036, true, tolerance);
     }
 
-    test_one<linestring, polygon>("crossing", crossing, join_round32, end_flat, 1702.119, 20.0);
-    test_one<linestring, polygon>("crossing", crossing, join_round32, end_round32, 2140.450, 20.0);
+    // On one compiler 1702.56530051454502 2140.78725663358819
+    // so we increase tolerance
+    test_one<linestring, polygon>("crossing", crossing, join_round32, end_flat, 1702.1, 20.0, 20.0, true, 0.5);
+    test_one<linestring, polygon>("crossing", crossing, join_round32, end_round32, 2140.4, 20.0, 20.0, true, 0.5);
 
     test_one<linestring, polygon>("mikado1", mikado1, join_round32, end_round32, 5441135039.0979, 41751.0);
 }
 
+template <bool Clockwise, typename P>
+void test_invalid()
+{
+    typedef bg::model::linestring<P> linestring;
+    typedef bg::model::polygon<P, Clockwise> polygon;
+
+    bg::strategy::buffer::end_round end_round32(32);
+    bg::strategy::buffer::join_round join_round32(32);
+
+#if defined(BOOST_GEOMETRY_BUFFER_INCLUDE_FAILING_TESTS)
+    // Though the generated buffer of this linestring, containing extreme differences, is not correct, it resembles
+    // the equivalent (where the coordinates are set to 0). Both SQL Server and POSTGIS do not output anything for this case
+    test_one<linestring, polygon>("mysql_report_2015_04_10a", mysql_report_2015_04_10a, join_round32, end_round32, 86496.5005, 100.0);
+    test_one<linestring, polygon>("mysql_report_2015_04_10b", mysql_report_2015_04_10b, join_round32, end_round32, 86496.5005, 100.0);
+    test_one<linestring, polygon>("mysql_report_2015_04_10c", mysql_report_2015_04_10c, join_round32, end_round32, 86496.5005, 100.0);
+    test_one<linestring, polygon>("mysql_report_2015_04_10d", mysql_report_2015_04_10d, join_round32, end_round32, 86496.5005, 100.0);
+    test_one<linestring, polygon>("mysql_report_2015_04_10e", mysql_report_2015_04_10e, join_round32, end_round32, 86496.5005, 100.0);
+    test_one<linestring, polygon>("mysql_report_2015_04_10f", mysql_report_2015_04_10f, join_round32, end_round32, 86496.5005, 100.0);
+#endif
+
+    // The equivalent, valid, case
+    test_one<linestring, polygon>("mysql_report_2015_04_10g", mysql_report_2015_04_10g, join_round32, end_round32, 86527.871, 100.0);
+}
 
-//#define HAVE_TTMATH
 #ifdef HAVE_TTMATH
 #include <ttmath_stub.hpp>
 #endif
@@ -249,5 +283,8 @@ int test_main(int, char* [])
     test_all<true, bg::model::point<double, 2, bg::cs::cartesian> >();
     test_all<false, bg::model::point<double, 2, bg::cs::cartesian> >();
     //test_all<bg::model::point<tt, 2, bg::cs::cartesian> >();
+
+    test_invalid<true, bg::model::point<double, 2, bg::cs::cartesian> >();
+//    test_invalid<true, bg::model::point<long double, 2, bg::cs::cartesian> >();
     return 0;
 }
diff --git a/test/algorithms/buffer/multi_linestring_buffer.cpp b/test/algorithms/buffer/multi_linestring_buffer.cpp
index 1f09ceeb8..c48127164 100644
--- a/test/algorithms/buffer/multi_linestring_buffer.cpp
+++ b/test/algorithms/buffer/multi_linestring_buffer.cpp
@@ -29,7 +29,7 @@ static std::string const mikado2 = "MULTILINESTRING((-6.117647058823528993798390
 static std::string const mikado3 = "MULTILINESTRING((1 18,4.0559006211180124168436122999992 7.8136645962732922399140989000443),(6.7243816254416959310447055031545 -1.0812720848056533995418249105569,7 -2,7 -8,14 3.6666666666666669627261399000417),(15.297872340425531234586742357351 5.8297872340425538340014099958353,16 7,15.214285714285713524418497399893 5.8445378151260509724806979647838),(13.685863874345550073030608473346 3.5968586387434555717845796607435,-1 -18,-3.7900797165633304253162805252941 -11.117803365810452476125647081062),(-11.540540540540540348501963308081 8,-16 19,8 14),(1 -10,6.5999999999999996447286321199499 -1.200000000000000177635683940025),(11.5 6.5,15 12),(19 10,11.564231738035264385189293534495 6.4886649874055422060337150469422),(-13.438785504407443127661281323526 -5.3183153770812925387190261972137,-17 -7,-12.970074812967581578959652688354 -7.7556109725685784539450651209336),(-2.3532338308457703135445626685396 -9.7462686567164187323442092747428,-1 -10,12.285714285714286475581502600107 3.2857142857142864755815026001073),(14.90000000000000035527136788005 5.9000000000000003552713678800501,15 6,14.893004115226338157640384451952 5.9012345679012341292946075554937),(11.987804878048780921062643756159 3.2195121951219514144781896902714,-11 -18),(-12.210826210826210669324609625619 -11.703703703703702387883822666481,-15 -15,-11.463576158940396609864365018439 -15.589403973509934786534358863719),(-8.9189189189189193029960733838379 -16.013513513513512265262761502527,-3 -17,-7.0297239915074314353660156484693 -14.210191082802548834251865628175),(-12.450511945392491952588898129761 -10.457337883959045399251408525743,-16 -8,-12.923076923076923350208744523115 -8),(-0.52380952380952372493538859998807 -8,18 -8),(2 -19,-2.2961165048543685784920853620861 -9.6917475728155331182733789319173),(6.0463576158940393057150686217938 -1.7284768211920527036795647291001,7 -3,6.4482758620689653028534848999698 -1.3448275862068967967388744000345),(-1.3333333333333339254522798000835 8,4 16,2.9090909090909091716525836091023 8),(0.64705882352941168633719826175366 -6.8823529411764710062016092706472,-3 -16))";
 static std::string const mikado4 = "MULTILINESTRING((-15 2,-15 -17,-6 11,-1.9358288770053475591481628725887 10.572192513368984023713892383967),(2.1545064377682408007785852532834 10.14163090128755406738036981551,6.87603305785123986026974307606 9.6446280991735537924114396446384),(8.4810810810810810522752944962122 9.475675675675674369813350494951,13 9),(-15 0,-8 9,-2.9850746268656713766631582984701 4.4865671641791049495395782287233),(-1.8235294117647056211239942058455 3.4411764705882355031008046353236,-1.1428571428571423496123315999284 2.8285714285714291804652020800859),(1.2307692307692308375521861307789 0.69230769230769229061195346730528,1.2857142857142858094476878250134 0.64285714285714290472384391250671,2 0,1.9459459459459460539676456392044 0.51351351351351348650808859019889),(1.908127208480565384363103476062 0.87279151943462895957281943992712,1.9078014184397162900097555393586 0.87588652482269502286271745106205),(1.4685990338164249813246442499803 5.0483091787439615671928550000302,0.63551401869158885560295857430901 12.962616822429906093816498469096,0 19,2.9565217391304345895264304999728 8.6521739130434784925682834000327),(0 19,3.4942528735632185643567027000245 6.770114942528735468840750399977),(4.75 2.375,5.2427184466019420838733822165523 0.65048543689320226235395239200443),(5.5384615384615383248956277384423 -0.38461538461538458122390693461057,5.7358490566037731994697423942853 -1.0754716981132084185901476303115),(5.9777777777777778567269706400111 -1.9222222222222207221875578397885,6.867052023121386739035187929403 -5.0346820809248553629799971531611,10 -16,-14 -19,-12 -12),(0 10,1.9476439790575916788384347455576 5.4554973821989527493769855936989),(-4 1,-4.2790697674418600726653494348284 0.16279069767441856075862460784265))";
 
-static std::string const mysql_15_04_10 = "MULTILINESTRING((-58 19, 61 88),(1.922421e+307 1.520384e+308, 15 42, 89 -93,-89 -22),(-63 -5, -262141 -536870908, -3 87, 77 -69))";
+static std::string const mysql_2015_04_10 = "MULTILINESTRING((-58 19, 61 88),(1.922421e+307 1.520384e+308, 15 42, 89 -93,-89 -22),(-63 -5, -262141 -536870908, -3 87, 77 -69))";
 
 template <bool Clockwise, typename P>
 void test_all()
@@ -99,8 +99,11 @@ void test_all()
     test_one<multi_linestring_type, polygon>("mikado4_small", mikado4, join_round32, end_round32, 2103.686, 10.0);
     test_one<multi_linestring_type, polygon>("mikado4_small", mikado4, join_round32, end_flat, 1930.785, 10.0);
 
-#ifdef BOOST_GEOMETRY_BUFFER_INCLUDE_FAILING_TESTS
-    test_one<multi_linestring_type, polygon>("mysql_15_04_10", mysql_15_04_10, join_round32, end_round32, 29151950703.779/*something big*/, 0x98);
+#if defined(BOOST_GEOMETRY_BUFFER_INCLUDE_FAILING_TESTS)
+    // Coordinates vary so much that
+    // length = geometry::math::sqrt(dx * dx + dy * dy); returns a value of inf for length
+    // Buffer is still generated though (see also linestring.cpp)
+    test_one<multi_linestring_type, polygon>("mysql_2015_04_10", mysql_2015_04_10, join_round32, end_round32, 15471237017.3871, 0.98);
 #endif
 }
 
diff --git a/test/algorithms/buffer/multi_point_buffer.cpp b/test/algorithms/buffer/multi_point_buffer.cpp
index d5fcf0583..0e7e686c1 100644
--- a/test/algorithms/buffer/multi_point_buffer.cpp
+++ b/test/algorithms/buffer/multi_point_buffer.cpp
@@ -30,7 +30,7 @@ void test_all()
     typedef bg::model::polygon<P, Clockwise> polygon;
     typedef bg::model::multi_point<P> multi_point_type;
 
-    bg::strategy::buffer::join_miter join_miter;
+    bg::strategy::buffer::join_round join;
     bg::strategy::buffer::end_flat end_flat;
     typedef bg::strategy::buffer::distance_symmetric
     <
@@ -40,41 +40,39 @@ void test_all()
 
     double const pi = boost::geometry::math::pi<double>();
 
-    test_one<multi_point_type, polygon>("simplex1", simplex, join_miter, end_flat, 2.0 * pi, 1.0, 1.0);
-    test_one<multi_point_type, polygon>("simplex2", simplex, join_miter, end_flat, 22.8372, 2.0, 2.0);
-    test_one<multi_point_type, polygon>("simplex3", simplex, join_miter, end_flat, 44.5692, 3.0, 3.0);
+    test_one<multi_point_type, polygon>("simplex1", simplex, join, end_flat, 2.0 * pi, 1.0, 1.0);
+    test_one<multi_point_type, polygon>("simplex2", simplex, join, end_flat, 22.8372, 2.0, 2.0);
+    test_one<multi_point_type, polygon>("simplex3", simplex, join, end_flat, 44.5692, 3.0, 3.0);
 
-    test_one<multi_point_type, polygon>("three1", three, join_miter, end_flat, 3.0 * pi, 1.0, 1.0);
-    test_one<multi_point_type, polygon>("three2", three, join_miter, end_flat, 36.7592, 2.0, 2.0);
-    test_one<multi_point_type, polygon>("three19", three, join_miter, end_flat, 33.6914, 1.9, 1.9);
-    test_one<multi_point_type, polygon>("three21", three, join_miter, end_flat, 39.6394, 2.1, 2.1);
-    test_one<multi_point_type, polygon>("three3", three, join_miter, end_flat, 65.533, 3.0, 3.0);
-
-    test_one<multi_point_type, polygon>("multipoint_a", multipoint_a, join_miter, end_flat, 2049.98, 14.0, 14.0);
-    test_one<multi_point_type, polygon>("multipoint_b", multipoint_b, join_miter, end_flat, 7109.88, 15.0, 15.0);
-    test_one<multi_point_type, polygon>("multipoint_b1", multipoint_b, join_miter, end_flat, 6911.89, 14.7, 14.7);
-    test_one<multi_point_type, polygon>("multipoint_b2", multipoint_b, join_miter, end_flat, 7174.79, 15.1, 15.1);
+    test_one<multi_point_type, polygon>("three1", three, join, end_flat, 3.0 * pi, 1.0, 1.0);
+    test_one<multi_point_type, polygon>("three2", three, join, end_flat, 36.7592, 2.0, 2.0);
+    test_one<multi_point_type, polygon>("three19", three, join, end_flat, 33.6914, 1.9, 1.9);
+    test_one<multi_point_type, polygon>("three21", three, join, end_flat, 39.6394, 2.1, 2.1);
+    test_one<multi_point_type, polygon>("three3", three, join, end_flat, 65.533, 3.0, 3.0);
 
+    test_one<multi_point_type, polygon>("multipoint_a", multipoint_a, join, end_flat, 2049.98, 14.0, 14.0);
+    test_one<multi_point_type, polygon>("multipoint_b", multipoint_b, join, end_flat, 7109.88, 15.0, 15.0);
+    test_one<multi_point_type, polygon>("multipoint_b1", multipoint_b, join, end_flat, 6911.89, 14.7, 14.7);
+    test_one<multi_point_type, polygon>("multipoint_b2", multipoint_b, join, end_flat, 7174.79, 15.1, 15.1);
 
     // Grid tests
     {
         bg::strategy::buffer::point_square point_strategy;
 
-
         test_with_custom_strategies<multi_point_type, polygon>("grid_a50",
-                grid_a, join_miter, end_flat,
+                grid_a, join, end_flat,
                 distance_strategy(0.5), side_strategy, point_strategy, 7.0);
 
-#if defined(BOOST_GEOMETRY_BUFFER_INCLUDE_FAILING_TESTS)
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
         test_with_custom_strategies<multi_point_type, polygon>("grid_a54",
-                grid_a, join_miter, end_flat,
-                distance_strategy(0.54), side_strategy, point_strategy, 99);
+                grid_a, join, end_flat,
+                distance_strategy(0.54), side_strategy, point_strategy, 7.819);
 #endif
 
     }
 
     test_with_custom_strategies<multi_point_type, polygon>("mysql_report_2015_02_25_1_800",
-            mysql_report_2015_02_25_1, join_miter, end_flat,
+            mysql_report_2015_02_25_1, join, end_flat,
             distance_strategy(6051788), side_strategy,
             bg::strategy::buffer::point_circle(800), 115057490003226.125, 1.0);
 }
@@ -92,7 +90,7 @@ void test_many_points_per_circle()
     typedef bg::model::polygon<P, false> polygon;
     typedef bg::model::multi_point<P> multi_point_type;
 
-    bg::strategy::buffer::join_miter join_miter;
+    bg::strategy::buffer::join_round join;
     bg::strategy::buffer::end_flat end_flat;
     typedef bg::strategy::buffer::distance_symmetric
     <
@@ -104,41 +102,62 @@ void test_many_points_per_circle()
 
     double const tolerance = 1.0;
 
+    // Area should be somewhat larger (~>) than pi*distance^2
+    // 6051788: area ~> 115058122875258
+
     // Strategies with many points, which are (very) slow in debug mode
     test_with_custom_strategies<multi_point_type, polygon>(
             "mysql_report_2015_02_25_1_8000",
-            mysql_report_2015_02_25_1, join_miter, end_flat,
+            mysql_report_2015_02_25_1, join, end_flat,
             distance_strategy(6051788), side_strategy, point_circle(8000),
             115058661065242.812, tolerance);
 
     test_with_custom_strategies<multi_point_type, polygon>(
             "mysql_report_2015_02_25_1",
-            mysql_report_2015_02_25_1, join_miter, end_flat,
+            mysql_report_2015_02_25_1, join, end_flat,
             distance_strategy(6051788), side_strategy, point_circle(83585),
             115058672785611.219, tolerance);
 
-    // Takes about 20 seconds in release mode
+    // Takes about 7 seconds in release mode
     test_with_custom_strategies<multi_point_type, polygon>(
             "mysql_report_2015_02_25_1_250k",
-            mysql_report_2015_02_25_1, join_miter, end_flat,
+            mysql_report_2015_02_25_1, join, end_flat,
             distance_strategy(6051788), side_strategy, point_circle(250000),
             115058672880671.531, tolerance);
 
-#if defined(BOOST_GEOMETRY_BUFFER_INCLUDE_FAILING_TESTS)
-    // Takes too long, TODO improve turn_in_piece_visitor
+#if defined(BOOST_GEOMETRY_BUFFER_INCLUDE_SLOW_TESTS)
+    // Takes about 110 seconds in release mode
     test_with_custom_strategies<multi_point_type, polygon>(
-            "mysql_report_2015_02_25_1",
-            mysql_report_2015_02_25_1, join_miter, end_flat,
+            "mysql_report_2015_02_25_1_800k",
+            mysql_report_2015_02_25_1, join, end_flat,
             distance_strategy(6051788), side_strategy, point_circle(800000),
-            115058672799999.999, tolerance); // area to be determined
+            115058672871849.219, tolerance);
 #endif
 
+    // 5666962: area ~> 100890546298964
     test_with_custom_strategies<multi_point_type, polygon>(
             "mysql_report_2015_02_25_2",
-            mysql_report_2015_02_25_2, join_miter, end_flat,
+            mysql_report_2015_02_25_2, join, end_flat,
             distance_strategy(5666962), side_strategy, point_circle(46641),
             100891031341757.344, tolerance);
 
+    // Multipoint b with large distances/many points
+    // Area ~> pi * 10x
+    test_with_custom_strategies<multi_point_type, polygon>(
+            "multipoint_b_50k",
+            multipoint_b, join, end_flat,
+            distance_strategy(1000000), side_strategy, point_circle(50000),
+            3141871558215.26465, tolerance);
+
+#if defined(BOOST_GEOMETRY_BUFFER_INCLUDE_SLOW_TESTS)
+    // Tests optimization min/max radius
+    // Takes about 55 seconds in release mode
+    test_with_custom_strategies<multi_point_type, polygon>(
+            "multipoint_b_500k",
+            multipoint_b, join, end_flat,
+            distance_strategy(10000000), side_strategy, point_circle(500000),
+            314162054419515.562, tolerance);
+#endif
 }
 
 int test_main(int, char* [])
diff --git a/test/algorithms/buffer/multi_polygon_buffer.cpp b/test/algorithms/buffer/multi_polygon_buffer.cpp
index eef6d5155..62a47f8da 100644
--- a/test/algorithms/buffer/multi_polygon_buffer.cpp
+++ b/test/algorithms/buffer/multi_polygon_buffer.cpp
@@ -413,7 +413,11 @@ void test_all()
     test_one<multi_polygon_type, polygon_type>("rt_p22", rt_p22, join_miter, end_flat, 26.5711, 1.0);
 
     test_one<multi_polygon_type, polygon_type>("rt_q1", rt_q1, join_miter, end_flat, 27, 1.0);
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    // Fails because all IP's on external borders are now selectable, two are on top of each other
+    // and this should be fixed differently
     test_one<multi_polygon_type, polygon_type>("rt_q2", rt_q2, join_miter, end_flat, 26.4853, 1.0);
+#endif
     test_one<multi_polygon_type, polygon_type>("rt_q2", rt_q2, join_miter, end_flat, 0.9697, -0.25);
 
     test_one<multi_polygon_type, polygon_type>("rt_r", rt_r, join_miter, end_flat, 21.0761, 1.0);
@@ -449,8 +453,8 @@ void test_all()
     test_one<multi_polygon_type, polygon_type>("rt_u11_50", rt_u11, join_miter, end_flat, 0.04289, -0.50);
     test_one<multi_polygon_type, polygon_type>("rt_u11_25", rt_u11, join_miter, end_flat, 10.1449, -0.25);
 
-#if defined(BOOST_GEOMETRY_BUFFER_INCLUDE_FAILING_TESTS)
-    test_one<multi_polygon_type, polygon_type>("rt_u12", rt_u12, join_miter, end_flat, 999, 1.0);
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    test_one<multi_polygon_type, polygon_type>("rt_u12", rt_u12, join_miter, end_flat, 142.1348, 1.0);
     test_one<multi_polygon_type, polygon_type>("rt_u13", rt_u13, join_miter, end_flat, 115.4853, 1.0);
 #endif
 
diff --git a/test/algorithms/buffer/test_buffer.hpp b/test/algorithms/buffer/test_buffer.hpp
index 6b0d91105..e36ac82de 100644
--- a/test/algorithms/buffer/test_buffer.hpp
+++ b/test/algorithms/buffer/test_buffer.hpp
@@ -1,7 +1,7 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
-// Unit Test
+// Unit Test Helper
 
-// Copyright (c) 2010-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2010-2015 Barend Gehrels, Amsterdam, the Netherlands.
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -10,29 +10,18 @@
 #ifndef BOOST_GEOMETRY_TEST_BUFFER_HPP
 #define BOOST_GEOMETRY_TEST_BUFFER_HPP
 
+#if defined(TEST_WITH_SVG)
+    // Define before including any buffer headerfile
+    #define BOOST_GEOMETRY_BUFFER_USE_HELPER_POINTS
+#endif
+
 #include <iostream>
 #include <fstream>
 #include <iomanip>
 
-#if defined(TEST_WITH_SVG)
-#define BOOST_GEOMETRY_BUFFER_USE_HELPER_POINTS
-
-// Uncomment next lines if you want to have a zoomed view
-// #define BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX
-
-// If possible define box before including this unit with the right view
-#ifdef BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX
-#  ifndef BOOST_GEOMETRY_BUFFER_TEST_SVG_ALTERNATE_BOX
-#    define BOOST_GEOMETRY_BUFFER_TEST_SVG_ALTERNATE_BOX "BOX(0 0,100 100)"
-#  endif
-#endif
-
-#endif // TEST_WITH_SVG
-
 #include <boost/foreach.hpp>
 #include <geometry_test_common.hpp>
 
-
 #include <boost/geometry/algorithms/envelope.hpp>
 #include <boost/geometry/algorithms/area.hpp>
 #include <boost/geometry/algorithms/buffer.hpp>
@@ -57,296 +46,8 @@
 
 
 #if defined(TEST_WITH_SVG)
-
-#include <boost/geometry/io/svg/svg_mapper.hpp>
-
-
-inline char piece_type_char(bg::strategy::buffer::piece_type const& type)
-{
-    using namespace bg::strategy::buffer;
-    switch(type)
-    {
-        case buffered_segment : return 's';
-        case buffered_join : return 'j';
-        case buffered_round_end : return 'r';
-        case buffered_flat_end : return 'f';
-        case buffered_point : return 'p';
-        case buffered_concave : return 'c';
-        default : return '?';
-    }
-}
-
-template <typename Geometry, typename Mapper, typename RescalePolicy>
-void post_map(Geometry const& geometry, Mapper& mapper, RescalePolicy const& rescale_policy)
-{
-    typedef typename bg::point_type<Geometry>::type point_type;
-    typedef bg::detail::overlay::turn_info
-    <
-        point_type,
-        typename bg::segment_ratio_type<point_type, RescalePolicy>::type
-    > turn_info;
-
-    std::vector<turn_info> turns;
-
-    bg::detail::self_get_turn_points::no_interrupt_policy policy;
-    bg::self_turns
-        <
-            bg::detail::overlay::assign_null_policy
-        >(geometry, rescale_policy, turns, policy);
-
-    BOOST_FOREACH(turn_info const& turn, turns)
-    {
-        mapper.map(turn.point, "fill:rgb(255,128,0);stroke:rgb(0,0,100);stroke-width:1", 3);
-    }
-}
-
-template <typename SvgMapper, typename Box, typename Tag>
-struct svg_visitor
-{
-#ifdef BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX
-    Box m_alternate_box;
-#endif
-
-    class si
-    {
-    private :
-        bg::segment_identifier m_id;
-
-    public :
-        inline si(bg::segment_identifier const& id)
-            : m_id(id)
-        {}
-
-        template <typename Char, typename Traits>
-        inline friend std::basic_ostream<Char, Traits>& operator<<(
-                std::basic_ostream<Char, Traits>& os,
-                si const& s)
-        {
-            os << s.m_id.multi_index << "." << s.m_id.segment_index;
-            return os;
-        }
-    };
-
-
-    SvgMapper& m_mapper;
-
-    svg_visitor(SvgMapper& mapper)
-        : m_mapper(mapper)
-    {}
-
-    template <typename Turns>
-    inline void map_turns(Turns const& turns, bool label_good_turns, bool label_wrong_turns)
-    {
-        namespace bgdb = boost::geometry::detail::buffer;
-        typedef typename boost::range_value<Turns const>::type turn_type;
-        typedef typename turn_type::point_type point_type;
-        typedef typename turn_type::robust_point_type robust_point_type;
-
-        std::map<robust_point_type, int, bg::less<robust_point_type> > offsets;
-
-        for (typename boost::range_iterator<Turns const>::type it =
-            boost::begin(turns); it != boost::end(turns); ++it)
-        {
-#ifdef BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX
-            if (bg::disjoint(it->point, m_alternate_box))
-            {
-                continue;
-            }
-#endif
-
-            bool is_good = true;
-            char color = 'g';
-            std::string fill = "fill:rgb(0,255,0);";
-            switch(it->location)
-            {
-                case bgdb::inside_buffer :
-                    fill = "fill:rgb(255,0,0);";
-                    color = 'r';
-                    is_good = false;
-                    break;
-                case bgdb::location_discard :
-                    fill = "fill:rgb(0,0,255);";
-                    color = 'b';
-                    is_good = false;
-                    break;
-            }
-            if (!it->selectable_start)
-            {
-                fill = "fill:rgb(255,192,0);";
-                color = 'o'; // orange
-            }
-            if (it->blocked())
-            {
-                fill = "fill:rgb(128,128,128);";
-                color = '-';
-                is_good = false;
-            }
-
-            fill += "fill-opacity:0.7;";
-
-            m_mapper.map(it->point, fill, 4);
-
-            if ((label_good_turns && is_good) || (label_wrong_turns && ! is_good))
-            {
-                std::ostringstream out;
-                out << it->turn_index
-                    << " " << it->operations[0].piece_index << "/" << it->operations[1].piece_index
-                    << " " << si(it->operations[0].seg_id) << "/" << si(it->operations[1].seg_id)
-
-    //              If you want to see travel information
-                    << std::endl
-                    << " nxt " << it->operations[0].enriched.travels_to_ip_index
-                    << "/" << it->operations[1].enriched.travels_to_ip_index
-                    << " or " << it->operations[0].enriched.next_ip_index
-                    << "/" << it->operations[1].enriched.next_ip_index
-                    //<< " frac " << it->operations[0].fraction
-
-    //                If you want to see robust-point coordinates (e.g. to find duplicates)
-    //                << std::endl
-    //                << " " << bg::get<0>(it->robust_point) << " , " << bg::get<1>(it->robust_point)
-
-                    << std::endl;
-                out << " " << bg::method_char(it->method)
-                    << ":" << bg::operation_char(it->operations[0].operation)
-                    << "/" << bg::operation_char(it->operations[1].operation);
-                out << " "
-                    << (it->count_on_offsetted > 0 ? "b" : "") // b: offsetted border
-                    << (it->count_within_near_offsetted > 0 ? "n" : "")
-                    << (it->count_within > 0 ? "w" : "")
-                    << (it->count_on_helper > 0 ? "h" : "")
-                    << (it->count_on_multi > 0 ? "m" : "")
-                    ;
-
-                offsets[it->get_robust_point()] += 10;
-                int offset = offsets[it->get_robust_point()];
-
-                m_mapper.text(it->point, out.str(), "fill:rgb(0,0,0);font-family='Arial';font-size:9px;", 5, offset);
-
-                offsets[it->get_robust_point()] += 25;
-            }
-        }
-    }
-
-    template <typename Pieces, typename OffsettedRings>
-    inline void map_pieces(Pieces const& pieces,
-                OffsettedRings const& offsetted_rings,
-                bool do_pieces, bool do_indices)
-    {
-        typedef typename boost::range_value<Pieces const>::type piece_type;
-        typedef typename boost::range_value<OffsettedRings const>::type ring_type;
-
-        for(typename boost::range_iterator<Pieces const>::type it = boost::begin(pieces);
-            it != boost::end(pieces);
-            ++it)
-        {
-            const piece_type& piece = *it;
-            bg::segment_identifier seg_id = piece.first_seg_id;
-            if (seg_id.segment_index < 0)
-            {
-                continue;
-            }
-
-            ring_type corner;
-
-
-            ring_type const& ring = offsetted_rings[seg_id.multi_index];
-
-            std::copy(boost::begin(ring) + seg_id.segment_index,
-                    boost::begin(ring) + piece.last_segment_index,
-                    std::back_inserter(corner));
-            std::copy(boost::begin(piece.helper_points),
-                    boost::end(piece.helper_points),
-                    std::back_inserter(corner));
-
-            if (corner.empty())
-            {
-                continue;
-            }
-#ifdef BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX
-            if (bg::disjoint(corner, m_alternate_box))
-            {
-                continue;
-            }
-#endif
-
-            if (do_pieces)
-            {
-                std::string style = "opacity:0.3;stroke:rgb(0,0,0);stroke-width:1;";
-                m_mapper.map(corner,
-                    piece.type == bg::strategy::buffer::buffered_segment
-                    ? style + "fill:rgb(255,128,0);"
-                    : style + "fill:rgb(255,0,0);");
-            }
-
-            if (do_indices)
-            {
-                // Label starting piece_index / segment_index
-                typedef typename bg::point_type<ring_type>::type point_type;
-
-                std::ostringstream out;
-                out << piece.index << " (" << piece_type_char(piece.type) << ") " << piece.first_seg_id.segment_index << ".." << piece.last_segment_index - 1;
-                point_type label_point = bg::return_centroid<point_type>(corner);
-
-                if ((piece.type == bg::strategy::buffer::buffered_concave
-                     || piece.type == bg::strategy::buffer::buffered_flat_end)
-                    && corner.size() >= 2u)
-                {
-                    bg::set<0>(label_point, (bg::get<0>(corner[0]) + bg::get<0>(corner[1])) / 2.0);
-                    bg::set<1>(label_point, (bg::get<1>(corner[0]) + bg::get<1>(corner[1])) / 2.0);
-                }
-                m_mapper.text(label_point, out.str(), "fill:rgb(255,0,0);font-family='Arial';font-size:10px;", 5, 5);
-            }
-        }
-    }
-
-    template <typename TraversedRings>
-    inline void map_traversed_rings(TraversedRings const& traversed_rings)
-    {
-        for(typename boost::range_iterator<TraversedRings const>::type it
-                = boost::begin(traversed_rings); it != boost::end(traversed_rings); ++it)
-        {
-            m_mapper.map(*it, "opacity:0.4;fill:none;stroke:rgb(0,255,0);stroke-width:2");
-        }
-    }
-
-    template <typename OffsettedRings>
-    inline void map_offsetted_rings(OffsettedRings const& offsetted_rings)
-    {
-        for(typename boost::range_iterator<OffsettedRings const>::type it
-                = boost::begin(offsetted_rings); it != boost::end(offsetted_rings); ++it)
-        {
-            if (it->discarded())
-            {
-                m_mapper.map(*it, "opacity:0.4;fill:none;stroke:rgb(255,0,0);stroke-width:2");
-            }
-            else
-            {
-                m_mapper.map(*it, "opacity:0.4;fill:none;stroke:rgb(0,0,255);stroke-width:2");
-            }
-        }
-    }
-
-    template <typename PieceCollection>
-    inline void apply(PieceCollection const& collection, int phase)
-    {
-        // Comment next return if you want to see pieces, turns, etc.
-        return;
-
-        if(phase == 0)
-        {
-            map_pieces(collection.m_pieces, collection.offsetted_rings, true, true);
-            map_turns(collection.m_turns, true, false);
-        }
-#if !defined(BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX)
-        if (phase == 1)
-        {
-//        map_traversed_rings(collection.traversed_rings);
-//        map_offsetted_rings(collection.offsetted_rings);
-        }
-#endif
-    }
-};
-
+#  include <test_buffer_svg.hpp>
+#  include <test_buffer_svg_per_turn.hpp>
 #endif
 
 //-----------------------------------------------------------------------------
@@ -472,40 +173,25 @@ void test_buffer(std::string const& caseid, Geometry const& geometry,
 
     //std::cout << complete.str() << std::endl;
 
+#if defined(TEST_WITH_SVG_PER_TURN)
+    save_turns_visitor<point_type> visitor;
+#elif defined(TEST_WITH_SVG)
+
+    buffer_svg_mapper<point_type> buffer_mapper(complete.str());
+
     std::ostringstream filename;
     filename << "buffer_" << complete.str() << ".svg";
-
-#if defined(TEST_WITH_SVG)
     std::ofstream svg(filename.str().c_str());
     typedef bg::svg_mapper<point_type> mapper_type;
-    mapper_type mapper(svg, 1000, 1000);
+    mapper_type mapper(svg, 1000, 800);
 
-    svg_visitor<mapper_type, bg::model::box<point_type>, tag> visitor(mapper);
-
-#ifdef BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX
-    // Create a zoomed-in view
-    bg::model::box<point_type> alternate_box;
-    bg::read_wkt(BOOST_GEOMETRY_BUFFER_TEST_SVG_ALTERNATE_BOX, alternate_box);
-    mapper.add(alternate_box);
-
-    // Take care non-visible elements are skipped
-    visitor.m_alternate_box = alternate_box;
-#else
-
-    {
-        bg::model::box<point_type> box = envelope;
-        if (distance_strategy.negative())
-        {
-            bg::buffer(box, box, 1.0);
-        }
-        else
-        {
-            bg::buffer(box, box, 1.1 * distance_strategy.max_distance(join_strategy, end_strategy));
-        }
-        mapper.add(box);
-    }
-#endif
+    svg_visitor<mapper_type, bg::model::box<point_type> > visitor(mapper);
 
+    buffer_mapper.prepare(mapper, visitor, envelope,
+            distance_strategy.negative()
+            ? 1.0
+            : 1.1 * distance_strategy.max_distance(join_strategy, end_strategy)
+        );
 #else
     bg::detail::buffer::visit_pieces_default_policy visitor;
 #endif
@@ -534,11 +220,10 @@ void test_buffer(std::string const& caseid, Geometry const& geometry,
 
     typename bg::default_area_result<GeometryOut>::type area = bg::area(buffered);
 
-    //std::cout << caseid << " " << distance_left << std::endl;
-    //std::cout << "INPUT: " << bg::wkt(geometry) << std::endl;
-    //std::cout << "OUTPUT: " << area << std::endl;
-    //std::cout << bg::wkt(buffered) << std::endl;
-
+//    std::cout << caseid << std::endl;
+//    std::cout << "INPUT: " << bg::wkt(geometry) << std::endl;
+//    std::cout << "OUTPUT: " << area << std::endl;
+//    std::cout << bg::wkt(buffered) << std::endl;
 
     if (expected_area > -0.1)
     {
@@ -557,14 +242,26 @@ void test_buffer(std::string const& caseid, Geometry const& geometry,
 
         if (check_self_intersections)
         {
-            // Be sure resulting polygon does not contain
-            // self-intersections
-            BOOST_CHECK_MESSAGE
-                (
-                    ! bg::detail::overlay::has_self_intersections(buffered,
-                            rescale_policy, false),
-                    complete.str() << " output is self-intersecting. "
-                );
+            try
+            {
+                bool has_self_ips = bg::detail::overlay::has_self_intersections(
+                                        buffered, rescale_policy, false);
+                // Be sure resulting polygon does not contain
+                // self-intersections
+                BOOST_CHECK_MESSAGE
+                    (
+                        ! has_self_ips,
+                        complete.str() << " output is self-intersecting. "
+                    );
+            }
+            catch(...)
+            {
+                BOOST_CHECK_MESSAGE
+                    (
+                        false,
+                        "Exception in checking self-intersections"
+                    );
+            }
         }
     }
 
@@ -579,48 +276,28 @@ void test_buffer(std::string const& caseid, Geometry const& geometry,
 //    BOOST_CHECK_MESSAGE(bg::intersects(buffered) == false, complete.str() <<  " intersects");
 #endif
 
-#if defined(TEST_WITH_SVG)
-    bool const areal = boost::is_same
-        <
-            typename bg::tag_cast<tag, bg::areal_tag>::type, bg::areal_tag
-        >::type::value;
-
-    // Map input geometry in green
-    if (areal)
+#if defined(TEST_WITH_SVG_PER_TURN)
     {
-#ifdef BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX_FOR_INPUT
-        // Assuming input is areal
-        bg::model::multi_polygon<GeometryOut> clipped;
-        bg::intersection(geometry, alternate_box, clipped);
-        mapper.map(clipped, "opacity:0.5;fill:rgb(0,128,0);stroke:rgb(0,64,0);stroke-width:2");
-#else
-        mapper.map(geometry, "opacity:0.5;fill:rgb(0,128,0);stroke:rgb(0,64,0);stroke-width:2");
+        // Create a per turn visitor to map per turn, and buffer again with it
+        per_turn_visitor<point_type> ptv(complete.str(), visitor.get_points());
+        bg::detail::buffer::buffer_inserter<GeometryOut>(geometry,
+                            std::back_inserter(buffered),
+                            distance_strategy,
+                            side_strategy,
+                            join_strategy,
+                            end_strategy,
+                            point_strategy,
+                            rescale_policy,
+                            ptv);
+        ptv.map_input_output(geometry, buffered, distance_strategy.negative());
+        // self_ips NYI here
+    }
+#elif defined(TEST_WITH_SVG)
+    buffer_mapper.map_input_output(mapper, geometry, buffered, distance_strategy.negative());
+    buffer_mapper.map_self_ips(mapper, buffered, rescale_policy);
 #endif
-    }
-    else
-    {
-        // TODO: clip input points/linestring
-        mapper.map(geometry, "opacity:0.5;stroke:rgb(0,128,0);stroke-width:10");
-    }
-
-    {
-        // Map buffer in yellow (inflate) and with orange-dots (deflate)
-        std::string style = distance_strategy.negative()
-            ? "opacity:0.4;fill:rgb(255,255,192);stroke:rgb(255,128,0);stroke-width:3"
-            : "opacity:0.4;fill:rgb(255,255,128);stroke:rgb(0,0,0);stroke-width:3";
-
-#ifdef BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX
-        // Clip output multi-polygon with box
-        bg::model::multi_polygon<GeometryOut> clipped;
-        bg::intersection(buffered, alternate_box, clipped);
-        mapper.map(clipped, style);
-#else
-        mapper.map(buffered, style);
-#endif
-    }
-    post_map(buffered, mapper, rescale_policy);
-#endif // TEST_WITH_SVG
 
+    // Check for self-intersections
     if (self_ip_count != NULL)
     {
         std::size_t count = 0;
diff --git a/test/algorithms/buffer/test_buffer_svg.hpp b/test/algorithms/buffer/test_buffer_svg.hpp
new file mode 100644
index 000000000..8dd0f4fe9
--- /dev/null
+++ b/test/algorithms/buffer/test_buffer_svg.hpp
@@ -0,0 +1,469 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+// Unit Test Helper
+
+// Copyright (c) 2010-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+
+#ifndef BOOST_GEOMETRY_TEST_BUFFER_SVG_HPP
+#define BOOST_GEOMETRY_TEST_BUFFER_SVG_HPP
+
+#include <fstream>
+#include <sstream>
+
+// Uncomment next lines if you want to have a zoomed view
+//#define BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX
+
+// If possible define box before including this unit with the right view
+#ifdef BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX
+#  ifndef BOOST_GEOMETRY_BUFFER_TEST_SVG_ALTERNATE_BOX
+#    define BOOST_GEOMETRY_BUFFER_TEST_SVG_ALTERNATE_BOX "BOX(0 0,100 100)"
+#  endif
+#endif
+
+#include <boost/foreach.hpp>
+#include <boost/geometry/io/svg/svg_mapper.hpp>
+
+
+inline char piece_type_char(bg::strategy::buffer::piece_type const& type)
+{
+    using namespace bg::strategy::buffer;
+    switch(type)
+    {
+        case buffered_segment : return 's';
+        case buffered_join : return 'j';
+        case buffered_round_end : return 'r';
+        case buffered_flat_end : return 'f';
+        case buffered_point : return 'p';
+        case buffered_concave : return 'c';
+        default : return '?';
+    }
+}
+
+template <typename SvgMapper, typename Box>
+class svg_visitor
+{
+public :
+    svg_visitor(SvgMapper& mapper)
+        : m_mapper(mapper)
+        , m_zoom(false)
+    {}
+
+    void set_alternate_box(Box const& box)
+    {
+        m_alternate_box = box;
+        m_zoom = true;
+    }
+
+    template <typename PieceCollection>
+    inline void apply(PieceCollection const& collection, int phase)
+    {
+        // Comment next return if you want to see pieces, turns, etc.
+        return;
+
+        if(phase == 0)
+        {
+            map_pieces(collection.m_pieces, collection.offsetted_rings, true, true);
+            map_turns(collection.m_turns, true, false);
+        }
+        if (phase == 1 && ! m_zoom)
+        {
+//        map_traversed_rings(collection.traversed_rings);
+//        map_offsetted_rings(collection.offsetted_rings);
+        }
+    }
+
+private :
+    class si
+    {
+    private :
+        bg::segment_identifier m_id;
+
+    public :
+        inline si(bg::segment_identifier const& id)
+            : m_id(id)
+        {}
+
+        template <typename Char, typename Traits>
+        inline friend std::basic_ostream<Char, Traits>& operator<<(
+                std::basic_ostream<Char, Traits>& os,
+                si const& s)
+        {
+            os << s.m_id.multi_index << "." << s.m_id.segment_index;
+            return os;
+        }
+    };
+
+    template <typename Turns>
+    inline void map_turns(Turns const& turns, bool label_good_turns, bool label_wrong_turns)
+    {
+        namespace bgdb = boost::geometry::detail::buffer;
+        typedef typename boost::range_value<Turns const>::type turn_type;
+        typedef typename turn_type::point_type point_type;
+        typedef typename turn_type::robust_point_type robust_point_type;
+
+        std::map<robust_point_type, int, bg::less<robust_point_type> > offsets;
+
+        for (typename boost::range_iterator<Turns const>::type it =
+            boost::begin(turns); it != boost::end(turns); ++it)
+        {
+            if (m_zoom && bg::disjoint(it->point, m_alternate_box))
+            {
+                continue;
+            }
+
+            bool is_good = true;
+            char color = 'g';
+            std::string fill = "fill:rgb(0,255,0);";
+            switch(it->location)
+            {
+                case bgdb::inside_buffer :
+                    fill = "fill:rgb(255,0,0);";
+                    color = 'r';
+                    is_good = false;
+                    break;
+                case bgdb::location_discard :
+                    fill = "fill:rgb(0,0,255);";
+                    color = 'b';
+                    is_good = false;
+                    break;
+            }
+            if (!it->selectable_start)
+            {
+                fill = "fill:rgb(255,192,0);";
+                color = 'o'; // orange
+            }
+            if (it->blocked())
+            {
+                fill = "fill:rgb(128,128,128);";
+                color = '-';
+                is_good = false;
+            }
+
+            fill += "fill-opacity:0.7;";
+
+            m_mapper.map(it->point, fill, 4);
+
+            if ((label_good_turns && is_good) || (label_wrong_turns && ! is_good))
+            {
+                std::ostringstream out;
+                out << it->turn_index
+                    << " " << it->operations[0].piece_index << "/" << it->operations[1].piece_index
+                    << " " << si(it->operations[0].seg_id) << "/" << si(it->operations[1].seg_id)
+
+    //              If you want to see travel information
+                    << std::endl
+                    << " nxt " << it->operations[0].enriched.travels_to_ip_index
+                    << "/" << it->operations[1].enriched.travels_to_ip_index
+                    << " or " << it->operations[0].enriched.next_ip_index
+                    << "/" << it->operations[1].enriched.next_ip_index
+                    //<< " frac " << it->operations[0].fraction
+
+    //                If you want to see robust-point coordinates (e.g. to find duplicates)
+    //                << std::endl
+    //                << " " << bg::get<0>(it->robust_point) << " , " << bg::get<1>(it->robust_point)
+
+                    << std::endl;
+                out << " " << bg::method_char(it->method)
+                    << ":" << bg::operation_char(it->operations[0].operation)
+                    << "/" << bg::operation_char(it->operations[1].operation);
+                out << " "
+                    << (it->count_on_offsetted > 0 ? "b" : "") // b: offsetted border
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+                    << (it->count_within_near_offsetted > 0 ? "n" : "")
+#endif
+                    << (it->count_within > 0 ? "w" : "")
+                    << (it->count_on_helper > 0 ? "h" : "")
+                    << (it->count_on_multi > 0 ? "m" : "")
+                    ;
+
+                offsets[it->get_robust_point()] += 10;
+                int offset = offsets[it->get_robust_point()];
+
+                m_mapper.text(it->point, out.str(), "fill:rgb(0,0,0);font-family='Arial';font-size:9px;", 5, offset);
+
+                offsets[it->get_robust_point()] += 25;
+            }
+        }
+    }
+
+    template <typename Pieces, typename OffsettedRings>
+    inline void map_pieces(Pieces const& pieces,
+                OffsettedRings const& offsetted_rings,
+                bool do_pieces, bool do_indices)
+    {
+        typedef typename boost::range_value<Pieces const>::type piece_type;
+        typedef typename boost::range_value<OffsettedRings const>::type ring_type;
+
+        for(typename boost::range_iterator<Pieces const>::type it = boost::begin(pieces);
+            it != boost::end(pieces);
+            ++it)
+        {
+            const piece_type& piece = *it;
+            bg::segment_identifier seg_id = piece.first_seg_id;
+            if (seg_id.segment_index < 0)
+            {
+                continue;
+            }
+
+            ring_type corner;
+
+
+            ring_type const& ring = offsetted_rings[seg_id.multi_index];
+
+            std::copy(boost::begin(ring) + seg_id.segment_index,
+                    boost::begin(ring) + piece.last_segment_index,
+                    std::back_inserter(corner));
+            std::copy(boost::begin(piece.helper_points),
+                    boost::end(piece.helper_points),
+                    std::back_inserter(corner));
+
+            if (corner.empty())
+            {
+                continue;
+            }
+            if (m_zoom && bg::disjoint(corner, m_alternate_box))
+            {
+                continue;
+            }
+
+            if (m_zoom && do_pieces)
+            {
+                try
+                {
+                    std::string style = "opacity:0.3;stroke:rgb(0,0,0);stroke-width:1;";
+                    typedef typename bg::point_type<Box>::type point_type;
+                    bg::model::multi_polygon<bg::model::polygon<point_type> > clipped;
+                    bg::intersection(ring, m_alternate_box, clipped);
+                    m_mapper.map(clipped,
+                        piece.type == bg::strategy::buffer::buffered_segment
+                        ? style + "fill:rgb(255,128,0);"
+                        : style + "fill:rgb(255,0,0);");
+                }
+                catch (...)
+                {
+                    std::cout << "Error for piece " << piece.index << std::endl;
+                }
+            }
+            else if (do_pieces)
+            {
+                std::string style = "opacity:0.3;stroke:rgb(0,0,0);stroke-width:1;";
+                m_mapper.map(corner,
+                    piece.type == bg::strategy::buffer::buffered_segment
+                    ? style + "fill:rgb(255,128,0);"
+                    : style + "fill:rgb(255,0,0);");
+            }
+
+            if (do_indices)
+            {
+                // Label starting piece_index / segment_index
+                typedef typename bg::point_type<ring_type>::type point_type;
+
+                std::ostringstream out;
+                out << piece.index << " (" << piece_type_char(piece.type) << ") " << piece.first_seg_id.segment_index << ".." << piece.last_segment_index - 1;
+                point_type label_point = bg::return_centroid<point_type>(corner);
+
+                if ((piece.type == bg::strategy::buffer::buffered_concave
+                     || piece.type == bg::strategy::buffer::buffered_flat_end)
+                    && corner.size() >= 2u)
+                {
+                    bg::set<0>(label_point, (bg::get<0>(corner[0]) + bg::get<0>(corner[1])) / 2.0);
+                    bg::set<1>(label_point, (bg::get<1>(corner[0]) + bg::get<1>(corner[1])) / 2.0);
+                }
+                m_mapper.text(label_point, out.str(), "fill:rgb(255,0,0);font-family='Arial';font-size:10px;", 5, 5);
+            }
+        }
+    }
+
+    template <typename TraversedRings>
+    inline void map_traversed_rings(TraversedRings const& traversed_rings)
+    {
+        for(typename boost::range_iterator<TraversedRings const>::type it
+                = boost::begin(traversed_rings); it != boost::end(traversed_rings); ++it)
+        {
+            m_mapper.map(*it, "opacity:0.4;fill:none;stroke:rgb(0,255,0);stroke-width:2");
+        }
+    }
+
+    template <typename OffsettedRings>
+    inline void map_offsetted_rings(OffsettedRings const& offsetted_rings)
+    {
+        for(typename boost::range_iterator<OffsettedRings const>::type it
+                = boost::begin(offsetted_rings); it != boost::end(offsetted_rings); ++it)
+        {
+            if (it->discarded())
+            {
+                m_mapper.map(*it, "opacity:0.4;fill:none;stroke:rgb(255,0,0);stroke-width:2");
+            }
+            else
+            {
+                m_mapper.map(*it, "opacity:0.4;fill:none;stroke:rgb(0,0,255);stroke-width:2");
+            }
+        }
+    }
+
+
+    SvgMapper& m_mapper;
+    Box m_alternate_box;
+    bool m_zoom;
+
+};
+
+template <typename Point>
+class buffer_svg_mapper
+{
+public :
+
+    buffer_svg_mapper(std::string const& casename)
+        : m_casename(casename)
+        , m_zoom(false)
+    {}
+
+    template <typename Mapper, typename Visitor, typename Envelope>
+    void prepare(Mapper& mapper, Visitor& visitor, Envelope const& envelope, double box_buffer_distance)
+    {
+#ifdef BOOST_GEOMETRY_BUFFER_TEST_SVG_USE_ALTERNATE_BOX
+        // Create a zoomed-in view
+        bg::model::box<Point> alternate_box;
+        bg::read_wkt(BOOST_GEOMETRY_BUFFER_TEST_SVG_ALTERNATE_BOX, alternate_box);
+        mapper.add(alternate_box);
+
+        // Take care non-visible elements are skipped
+        visitor.set_alternate_box(alternate_box);
+        m_zoom = true;
+#else
+        bg::model::box<Point> box = envelope;
+        bg::buffer(box, box, box_buffer_distance);
+        mapper.add(box);
+#endif
+
+        boost::ignore_unused(visitor);
+    }
+
+    void set_alternate_box(bg::model::box<Point> const& box)
+    {
+        m_alternate_box = box;
+        m_zoom = true;
+    }
+
+    template <typename Mapper, typename Geometry, typename GeometryBuffer>
+    void map_input_output(Mapper& mapper, Geometry const& geometry,
+            GeometryBuffer const& buffered, bool negative)
+    {
+        bool const areal = boost::is_same
+            <
+                typename bg::tag_cast
+                    <
+                        typename bg::tag<Geometry>::type,
+                        bg::areal_tag
+                    >::type, bg::areal_tag
+            >::type::value;
+
+        if (m_zoom)
+        {
+            map_io_zoomed(mapper, geometry, buffered, negative, areal);
+        }
+        else
+        {
+            map_io(mapper, geometry, buffered, negative, areal);
+        }
+    }
+
+    template <typename Mapper, typename Geometry, typename RescalePolicy>
+    void map_self_ips(Mapper& mapper, Geometry const& geometry, RescalePolicy const& rescale_policy)
+    {
+        typedef bg::detail::overlay::turn_info
+        <
+            Point,
+            typename bg::segment_ratio_type<Point, RescalePolicy>::type
+        > turn_info;
+
+        std::vector<turn_info> turns;
+
+        bg::detail::self_get_turn_points::no_interrupt_policy policy;
+        bg::self_turns
+            <
+                bg::detail::overlay::assign_null_policy
+            >(geometry, rescale_policy, turns, policy);
+
+        BOOST_FOREACH(turn_info const& turn, turns)
+        {
+            mapper.map(turn.point, "fill:rgb(255,128,0);stroke:rgb(0,0,100);stroke-width:1", 3);
+        }
+    }
+
+private :
+
+    template <typename Mapper, typename Geometry, typename GeometryBuffer>
+    void map_io(Mapper& mapper, Geometry const& geometry,
+            GeometryBuffer const& buffered, bool negative, bool areal)
+    {
+        // Map input geometry in green
+        if (areal)
+        {
+            mapper.map(geometry, "opacity:0.5;fill:rgb(0,128,0);stroke:rgb(0,64,0);stroke-width:2");
+        }
+        else
+        {
+            // TODO: clip input points/linestring
+            mapper.map(geometry, "opacity:0.5;stroke:rgb(0,128,0);stroke-width:10");
+        }
+
+        {
+            // Map buffer in yellow (inflate) and with orange-dots (deflate)
+            std::string style = negative
+                ? "opacity:0.4;fill:rgb(255,255,192);stroke:rgb(255,128,0);stroke-width:3"
+                : "opacity:0.4;fill:rgb(255,255,128);stroke:rgb(0,0,0);stroke-width:3";
+
+            mapper.map(buffered, style);
+        }
+    }
+
+    template <typename Mapper, typename Geometry, typename GeometryBuffer>
+    void map_io_zoomed(Mapper& mapper, Geometry const& geometry,
+            GeometryBuffer const& buffered, bool negative, bool areal)
+    {
+        // Map input geometry in green
+        if (areal)
+        {
+            // Assuming input is areal
+            GeometryBuffer clipped;
+// TODO: the next line does NOT compile for multi-point, TODO: implement that line
+//            bg::intersection(geometry, m_alternate_box, clipped);
+            mapper.map(clipped, "opacity:0.5;fill:rgb(0,128,0);stroke:rgb(0,64,0);stroke-width:2");
+        }
+        else
+        {
+            // TODO: clip input (multi)point/linestring
+            mapper.map(geometry, "opacity:0.5;stroke:rgb(0,128,0);stroke-width:10");
+        }
+
+        {
+            // Map buffer in yellow (inflate) and with orange-dots (deflate)
+            std::string style = negative
+                ? "opacity:0.4;fill:rgb(255,255,192);stroke:rgb(255,128,0);stroke-width:3"
+                : "opacity:0.4;fill:rgb(255,255,128);stroke:rgb(0,0,0);stroke-width:3";
+
+            try
+            {
+                // Clip output multi-polygon with box
+                GeometryBuffer clipped;
+                bg::intersection(buffered, m_alternate_box, clipped);
+                mapper.map(clipped, style);
+            }
+            catch (...)
+            {
+                std::cout << "Error for buffered output " << m_casename << std::endl;
+            }
+        }
+    }
+
+    bg::model::box<Point> m_alternate_box;
+    bool m_zoom;
+    std::string m_casename;
+};
+
+
+#endif
diff --git a/test/algorithms/buffer/test_buffer_svg_per_turn.hpp b/test/algorithms/buffer/test_buffer_svg_per_turn.hpp
new file mode 100644
index 000000000..1a06d6fbf
--- /dev/null
+++ b/test/algorithms/buffer/test_buffer_svg_per_turn.hpp
@@ -0,0 +1,164 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+// Unit Test Helper
+
+// Copyright (c) 2010-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+
+#ifndef BOOST_GEOMETRY_TEST_BUFFER_SVG_PER_TURN_HPP
+#define BOOST_GEOMETRY_TEST_BUFFER_SVG_PER_TURN_HPP
+
+#include <fstream>
+#include <vector>
+
+#include <test_buffer_svg.hpp>
+#include <boost/ptr_container/ptr_vector.hpp>
+
+template <typename Point>
+class save_turns_visitor
+{
+public :
+    typedef std::vector<std::pair<Point, int> > vector_type;
+
+    template <typename Turns>
+    inline void get_turns(Turns const& turns)
+    {
+        for (typename boost::range_iterator<Turns const>::type it =
+            boost::begin(turns); it != boost::end(turns); ++it)
+        {
+            m_points.push_back(std::make_pair(it->point, it->turn_index));
+        }
+    }
+
+    template <typename PieceCollection>
+    inline void apply(PieceCollection const& collection, int phase)
+    {
+        if (phase == 0)
+        {
+            get_turns(collection.m_turns);
+        }
+    }
+
+    vector_type const& get_points() { return m_points; }
+
+private :
+    vector_type m_points;
+};
+
+
+
+template <typename Point>
+class mapper_visitor
+{
+public :
+    mapper_visitor(std::string const& complete, int index, Point const& point)
+        : m_filename(get_filename(complete, index))
+        , m_svg(m_filename.c_str())
+        , m_mapper(m_svg, 1000, 800)
+        , m_visitor(m_mapper)
+        , m_buffer_mapper(m_filename)
+    {
+        box_type box;
+        double half_size = 75.0; // specific for multi_point buffer
+        bg::set<bg::min_corner, 0>(box, bg::get<0>(point) - half_size);
+        bg::set<bg::min_corner, 1>(box, bg::get<1>(point) - half_size);
+        bg::set<bg::max_corner, 0>(box, bg::get<0>(point) + half_size);
+        bg::set<bg::max_corner, 1>(box, bg::get<1>(point) + half_size);
+
+        m_mapper.add(box);
+        m_visitor.set_alternate_box(box);
+        m_buffer_mapper.set_alternate_box(box);
+    }
+
+    // It is used in a ptr vector
+    virtual ~mapper_visitor()
+    {
+    }
+
+    template <typename PieceCollection>
+    inline void apply(PieceCollection const& collection, int phase)
+    {
+        m_visitor.apply(collection, phase);
+    }
+
+    template <typename Geometry, typename GeometryBuffer>
+    void map_input_output(Geometry const& geometry,
+            GeometryBuffer const& buffered, bool negative)
+    {
+        m_buffer_mapper.map_input_output(m_mapper, geometry, buffered, negative);
+    }
+
+private :
+    std::string get_filename(std::string const& complete, int index)
+    {
+        std::ostringstream filename;
+        filename << "buffer_per_turn_" << complete << "_" << index << ".svg";
+        return filename.str();
+    }
+
+    typedef bg::svg_mapper<Point> mapper_type;
+    typedef bg::model::box<Point> box_type;
+
+    std::string m_filename;
+    std::ofstream m_svg;
+    mapper_type m_mapper;
+    svg_visitor<mapper_type, box_type> m_visitor;
+    buffer_svg_mapper<Point> m_buffer_mapper;
+};
+
+template <typename Point>
+class per_turn_visitor
+{
+    // Both fstreams and svg mappers are non-copyable,
+    // therefore we need to use dynamic memory
+    typedef boost::ptr_vector<mapper_visitor<Point> > container_type;
+    container_type mappers;
+
+public :
+
+    typedef std::pair<Point, int> pair_type;
+    typedef std::vector<pair_type> vector_type;
+
+    per_turn_visitor(std::string const& complete_caseid,
+            vector_type const& points)
+    {
+        namespace bg = boost::geometry;
+
+        if (points.size() > 100u)
+        {
+            // Defensive check. Too much intersections. Don't create anything
+            return;
+        }
+
+        BOOST_FOREACH(pair_type const& p, points)
+        {
+            mappers.push_back(new mapper_visitor<Point>(complete_caseid, p.second, p.first));
+        }
+    }
+
+    template <typename PieceCollection>
+    inline void apply(PieceCollection const& collection, int phase)
+    {
+        for(typename container_type::iterator it = mappers.begin();
+            it != mappers.end(); ++it)
+        {
+            it->apply(collection, phase);
+        }
+    }
+
+    template <typename Geometry, typename GeometryBuffer>
+    void map_input_output(Geometry const& geometry,
+            GeometryBuffer const& buffered, bool negative)
+    {
+        for(typename container_type::iterator it = mappers.begin();
+            it != mappers.end(); ++it)
+        {
+           it->map_input_output(geometry, buffered, negative);
+        }
+    }
+};
+
+
+#endif // BOOST_GEOMETRY_TEST_BUFFER_SVG_PER_TURN_HPP
diff --git a/test/algorithms/centroid.cpp b/test/algorithms/centroid.cpp
index 59b483f90..4ffeb45f9 100644
--- a/test/algorithms/centroid.cpp
+++ b/test/algorithms/centroid.cpp
@@ -1,9 +1,9 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 // Unit Test
 
-// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
-// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
-// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
 
 // This file was modified by Oracle on 2014, 2015.
 // Modifications copyright (c) 2014-2015 Oracle and/or its affiliates.
@@ -82,6 +82,31 @@ void test_2d()
     test_centroid<bg::model::linestring<P> >("LINESTRING(1 1, 1 1)", 1.0, 1.0);
     test_centroid<bg::model::linestring<P> >("LINESTRING(1 1)", 1.0, 1.0);
 
+    {
+        bg::model::linestring<P> ls;
+        // LINESTRING(1 -1,1e308 -1e308,0.0001 0.000)
+        bg::append(ls, P(1, -1));
+        typedef typename bg::coordinate_type<P>::type coord_type;
+        //double m = 1.0e308;
+        coord_type m = (std::numeric_limits<coord_type>::max)();
+        bg::append(ls, P(coord_type(m), coord_type(-m)));
+        bg::append(ls, P(coord_type(0.0001), coord_type(0.000)));
+        if (BOOST_GEOMETRY_CONDITION((boost::is_same<typename bg::coordinate_type<P>::type, double>::value)))
+        {
+            // for doubles the INF is detected and the calculation stopped
+            // currently for Geometries for which the centroid can't be calculated
+            // the first Point is returned
+            test_centroid<bg::model::linestring<P> >(ls, 1.0, -1.0);
+        }
+        else
+        {
+            // for floats internally the double is used to store intermediate results
+            // this type is capable to store MAX_FLT and "correctly" calculate the centroid
+            // test_centroid<bg::model::linestring<P> >(ls, m/3, -m/3);
+            // the result is around (1.7e38 -1.7e38)
+        }
+    }
+
     test_centroid<bg::model::segment<P> >("LINESTRING(1 1, 3 3)", 2.0, 2.0);
 
     test_centroid<bg::model::ring<P> >(
diff --git a/test/algorithms/distance/distance_se_pl_l.cpp b/test/algorithms/distance/distance_se_pl_l.cpp
index 65c80f8d2..4fcfaee3f 100644
--- a/test/algorithms/distance/distance_se_pl_l.cpp
+++ b/test/algorithms/distance/distance_se_pl_l.cpp
@@ -122,19 +122,19 @@ void test_distance_point_segment(Strategy const& strategy)
 #endif
     typedef test_distance_of_geometries<point_type, segment_type> tester;
 
+    double const d2r = bg::math::d2r<double>();
+
     tester::apply("p-s-01",
                   "POINT(0 0)",
                   "SEGMENT(2 0,3 0)",
-                  2.0 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                2.0 * bg::math::d2r * strategy.radius()),
+                  2.0 * d2r * strategy.radius(),
+                  to_comparable(strategy, 2.0 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-s-02",
                   "POINT(2.5 3)",
                   "SEGMENT(2 0,3 0)",
-                  3.0 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                3.0 * bg::math::d2r * strategy.radius()),
+                  3.0 * d2r * strategy.radius(),
+                  to_comparable(strategy, 3.0 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-s-03",
                   "POINT(2 0)",
@@ -163,44 +163,38 @@ void test_distance_point_segment(Strategy const& strategy)
     tester::apply("p-s-07",
                   "POINT(90 1e-3)",
                   "SEGMENT(0.5 0,175.5 0)",
-                  1e-3 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                1e-3 * bg::math::d2r * strategy.radius()),
+                  1e-3 * d2r * strategy.radius(),
+                  to_comparable(strategy, 1e-3 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-s-08",
                   "POINT(90 1e-4)",
                   "SEGMENT(0.5 0,175.5 0)",
-                  1e-4 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                1e-4 * bg::math::d2r * strategy.radius()),
+                  1e-4 * d2r * strategy.radius(),
+                  to_comparable(strategy, 1e-4 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-s-09",
                   "POINT(90 1e-5)",
                   "SEGMENT(0.5 0,175.5 0)",
-                  1e-5 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                1e-5 * bg::math::d2r * strategy.radius()),
+                  1e-5 * d2r * strategy.radius(),
+                  to_comparable(strategy, 1e-5 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-s-10",
                   "POINT(90 1e-6)",
                   "SEGMENT(0.5 0,175.5 0)",
-                  1e-6 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                1e-6 * bg::math::d2r * strategy.radius()),
+                  1e-6 * d2r * strategy.radius(),
+                  to_comparable(strategy, 1e-6 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-s-11",
                   "POINT(90 1e-7)",
                   "SEGMENT(0.5 0,175.5 0)",
-                  1e-7 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                1e-7 * bg::math::d2r * strategy.radius()),
+                  1e-7 * d2r * strategy.radius(),
+                  to_comparable(strategy, 1e-7 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-s-12",
                   "POINT(90 1e-8)",
                   "SEGMENT(0.5 0,175.5 0)",
-                  1e-8 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                1e-8 * bg::math::d2r * strategy.radius()),
+                  1e-8 * d2r * strategy.radius(),
+                  to_comparable(strategy, 1e-8 * d2r * strategy.radius()),
                   strategy);
 }
 
@@ -215,26 +209,25 @@ void test_distance_point_linestring(Strategy const& strategy)
 #endif
     typedef test_distance_of_geometries<point_type, linestring_type> tester;
 
+    double const d2r = bg::math::d2r<double>();
+
     tester::apply("p-l-01",
                   "POINT(0 0)",
                   "LINESTRING(2 0,2 0)",
-                  2.0 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                2.0 * bg::math::d2r * strategy.radius()),
+                  2.0 * d2r * strategy.radius(),
+                  to_comparable(strategy, 2.0 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-l-02",
                   "POINT(0 0)",
                   "LINESTRING(2 0,3 0)",
-                  2.0 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                2.0 * bg::math::d2r * strategy.radius()),
+                  2.0 * d2r * strategy.radius(),
+                  to_comparable(strategy, 2.0 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-l-03",
                   "POINT(2.5 3)",
                   "LINESTRING(2 0,3 0)",
-                  3.0 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                3.0 * bg::math::d2r * strategy.radius()),
+                  3.0 * d2r * strategy.radius(),
+                  to_comparable(strategy, 3.0 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-l-04",
                   "POINT(2 0)",
@@ -254,9 +247,8 @@ void test_distance_point_linestring(Strategy const& strategy)
     tester::apply("p-l-07",
                   "POINT(7.5 10)",
                   "LINESTRING(1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9 0)",
-                  10.0 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                10.0 * bg::math::d2r * strategy.radius()),
+                  10.0 * d2r * strategy.radius(),
+                  to_comparable(strategy, 10.0 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-l-08",
                   "POINT(7.5 10)",
@@ -282,19 +274,19 @@ void test_distance_point_multilinestring(Strategy const& strategy)
             point_type, multi_linestring_type
         > tester;
 
+    double const d2r = bg::math::d2r<double>();
+
     tester::apply("p-ml-01",
                   "POINT(0 0)",
                   "MULTILINESTRING((-5 0,-3 0),(2 0,3 0))",
-                  2.0 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                2.0 * bg::math::d2r * strategy.radius()),
+                  2.0 * d2r * strategy.radius(),
+                  to_comparable(strategy, 2.0 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-ml-02",
                   "POINT(2.5 3)",
                   "MULTILINESTRING((-5 0,-3 0),(2 0,3 0))",
-                  3.0 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                3.0 * bg::math::d2r * strategy.radius()),
+                  3.0 * d2r * strategy.radius(),
+                  to_comparable(strategy, 3.0 * d2r * strategy.radius()),
                   strategy);
     tester::apply("p-ml-03",
                   "POINT(2 0)",
@@ -431,6 +423,8 @@ void test_distance_multipoint_segment(Strategy const& strategy)
 #endif
     typedef test_distance_of_geometries<multi_point_type, segment_type> tester;
 
+    double d2r = bg::math::d2r<double>();
+
     tester::apply("mp-s-01",
                   "MULTIPOINT(0 0,1 0,0 1,1 1)",
                   "SEGMENT(2 0,0 2)",
@@ -442,9 +436,8 @@ void test_distance_multipoint_segment(Strategy const& strategy)
     tester::apply("mp-s-02",
                   "MULTIPOINT(0 0,1 0,0 1,1 1)",
                   "SEGMENT(0 -3,1 -10)",
-                  3.0 * bg::math::d2r * strategy.radius(),
-                  to_comparable(strategy,
-                                3.0 * bg::math::d2r * strategy.radius()),
+                  3.0 * d2r * strategy.radius(),
+                  to_comparable(strategy, 3.0 * d2r * strategy.radius()),
                   strategy);
     tester::apply("mp-s-03",
                   "MULTIPOINT(0 0,1 0,0 1,1 1)",
diff --git a/test/algorithms/distance/distance_se_pl_pl.cpp b/test/algorithms/distance/distance_se_pl_pl.cpp
index 2e14e8892..c7dfda2a9 100644
--- a/test/algorithms/distance/distance_se_pl_pl.cpp
+++ b/test/algorithms/distance/distance_se_pl_pl.cpp
@@ -89,7 +89,7 @@ void test_distance_point_point(Strategy const& strategy,
                   "POINT(180 -10)",
                   (is_comparable_strategy
                    ? 1.0
-                   : (180.0 * bg::math::d2r * strategy.radius())),
+                   : (bg::math::pi<double>() * strategy.radius())),
                   1.0,
                   strategy);
     tester::apply("p-p-04",
@@ -97,7 +97,7 @@ void test_distance_point_point(Strategy const& strategy,
                   "POINT(180 0)",
                   (is_comparable_strategy
                    ? 1.0
-                   : (180.0 * bg::math::d2r * strategy.radius())),
+                   : (bg::math::pi<double>() * strategy.radius())),
                   1.0,
                   strategy);
 }
diff --git a/test/algorithms/is_convex.cpp b/test/algorithms/is_convex.cpp
new file mode 100644
index 000000000..7fcc8a913
--- /dev/null
+++ b/test/algorithms/is_convex.cpp
@@ -0,0 +1,61 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+// Unit Test
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstddef>
+#include <string>
+
+#include <boost/geometry/algorithms/is_convex.hpp>
+
+#include <geometry_test_common.hpp>
+
+#include <boost/geometry/algorithms/correct.hpp>
+#include <boost/geometry/io/wkt/wkt.hpp>
+#include <boost/geometry/strategies/strategies.hpp>
+#include <boost/geometry/geometries/point_xy.hpp>
+#include <boost/geometry/geometries/ring.hpp>
+
+
+template <typename Geometry>
+void test_one(std::string const& case_id, std::string const& wkt, bool expected)
+{
+    Geometry geometry;
+    bg::read_wkt(wkt, geometry);
+    bg::correct(geometry);
+
+    bool detected = bg::is_convex(geometry);
+    BOOST_CHECK_MESSAGE(detected == expected,
+        "Not as expected, case: " << case_id
+            << " / expected: " << expected
+            << " / detected: " << detected);
+}
+
+
+template <typename P>
+void test_all()
+{
+    // rectangular, with concavity
+    std::string const concave1 = "polygon((1 1, 1 4, 3 4, 3 3, 4 3, 4 4, 5 4, 5 1, 1 1))";
+    std::string const triangle = "polygon((1 1, 1 4, 5 1, 1 1))";
+
+    test_one<bg::model::ring<P> >("triangle", triangle, true);
+    test_one<bg::model::ring<P> >("concave1", concave1, false);
+    test_one<bg::model::ring<P, false, false> >("triangle", triangle, true);
+    test_one<bg::model::ring<P, false, false> >("concave1", concave1, false);
+
+    test_one<bg::model::box<P> >("box", "box(0 0,2 2)", true);
+}
+
+
+int test_main(int, char* [])
+{
+    test_all<bg::model::d2::point_xy<int> >();
+    test_all<bg::model::d2::point_xy<double> >();
+
+    return 0;
+}
diff --git a/test/algorithms/relational_operations/Jamfile.v2 b/test/algorithms/relational_operations/Jamfile.v2
index 2c0c34c9e..39cf1381e 100644
--- a/test/algorithms/relational_operations/Jamfile.v2
+++ b/test/algorithms/relational_operations/Jamfile.v2
@@ -1,11 +1,11 @@
 # Boost.Geometry (aka GGL, Generic Geometry Library)
 #
-# Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
-# Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
-# Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+# Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+# Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+# Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
 #
-# This file was modified by Oracle on 2014.
-# Modifications copyright (c) 2014, Oracle and/or its affiliates.
+# This file was modified by Oracle on 2014, 2015.
+# Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
 #
 # Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 # Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
@@ -19,6 +19,7 @@ test-suite boost-geometry-algorithms-relational
     [ run covered_by.cpp ]
     [ run crosses.cpp ]
     [ run equals.cpp ]
+    [ run equals_on_spheroid.cpp ]
     [ run intersects.cpp ]
     [ run multi_covered_by.cpp ]
     [ run multi_equals.cpp ]
diff --git a/test/algorithms/relational_operations/equals_on_spheroid.cpp b/test/algorithms/relational_operations/equals_on_spheroid.cpp
new file mode 100644
index 000000000..80c8593e8
--- /dev/null
+++ b/test/algorithms/relational_operations/equals_on_spheroid.cpp
@@ -0,0 +1,183 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+// Unit test
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+#ifndef BOOST_TEST_MODULE
+#define BOOST_TEST_MODULE test_equals_on_spheroid
+#endif
+
+#include <iostream>
+
+#include <boost/test/included/unit_test.hpp>
+
+#include "test_equals.hpp"
+
+#include <boost/geometry/geometries/geometries.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+
+namespace bgm = bg::model;
+
+template <typename P1, typename P2 = P1>
+struct test_point_point
+{
+    static inline void apply(std::string const& header)
+    {
+        std::string const str = header + "-";
+
+        test_geometry<P1, P2>(str + "pp_01", "POINT(0 0)", "POINT(0 0)", true);
+        test_geometry<P1, P2>(str + "pp_02", "POINT(0 0)", "POINT(10 0)", false);
+
+        // points whose longitudes differ by 360 degrees
+        test_geometry<P1, P2>(str + "pp_03", "POINT(0 0)", "POINT(360 0)", true);
+        test_geometry<P1, P2>(str + "pp_04", "POINT(10 0)", "POINT(370 0)", true);
+        test_geometry<P1, P2>(str + "pp_05", "POINT(10 0)", "POINT(-350 0)", true);
+        test_geometry<P1, P2>(str + "pp_06", "POINT(180 10)", "POINT(-180 10)", true);
+        test_geometry<P1, P2>(str + "pp_06a", "POINT(540 10)", "POINT(-540 10)", true);
+        test_geometry<P1, P2>(str + "pp_06b", "POINT(540 370)", "POINT(-540 -350)", true);
+        test_geometry<P1, P2>(str + "pp_06c", "POINT(1260 370)", "POINT(-1260 -350)", true);
+        test_geometry<P1, P2>(str + "pp_06d", "POINT(2340 370)", "POINT(-2340 -350)", true);
+        test_geometry<P1, P2>(str + "pp_06e", "POINT(-180 10)", "POINT(-540 10)", true);
+        test_geometry<P1, P2>(str + "pp_06f", "POINT(180 10)", "POINT(-540 10)", true);
+
+        // north & south pole
+        test_geometry<P1, P2>(str + "pp_07", "POINT(0 90)", "POINT(0 90)", true);
+        test_geometry<P1, P2>(str + "pp_07a", "POINT(0 450)", "POINT(10 -270)", true);
+        test_geometry<P1, P2>(str + "pp_07b", "POINT(0 270)", "POINT(10 90)", false);
+        test_geometry<P1, P2>(str + "pp_07c", "POINT(0 -450)", "POINT(10 90)", false);
+        test_geometry<P1, P2>(str + "pp_08", "POINT(0 90)", "POINT(10 90)", true);
+        test_geometry<P1, P2>(str + "pp_09", "POINT(0 90)", "POINT(0 -90)", false);
+        test_geometry<P1, P2>(str + "pp_10", "POINT(0 -90)", "POINT(0 -90)", true);
+        test_geometry<P1, P2>(str + "pp_11", "POINT(0 -90)", "POINT(10 -90)", true);
+        test_geometry<P1, P2>(str + "pp_11a", "POINT(0 -90)", "POINT(10 90)", false);
+        test_geometry<P1, P2>(str + "pp_12", "POINT(0 -90)", "POINT(0 -85)", false);
+        test_geometry<P1, P2>(str + "pp_13", "POINT(0 90)", "POINT(0 85)", false);
+        test_geometry<P1, P2>(str + "pp_14", "POINT(0 90)", "POINT(10 85)", false);
+
+        // symmetric wrt prime meridian
+        test_geometry<P1, P2>(str + "pp_15", "POINT(-10 45)", "POINT(10 45)", false);
+        test_geometry<P1, P2>(str + "pp_16", "POINT(-170 45)", "POINT(170 45)", false);
+
+        // other points
+        test_geometry<P1, P2>(str + "pp_17", "POINT(-10 45)", "POINT(10 -45)", false);
+        test_geometry<P1, P2>(str + "pp_18", "POINT(-10 -45)", "POINT(10 45)", false);
+        test_geometry<P1, P2>(str + "pp_19", "POINT(10 -135)", "POINT(10 45)", false);
+        test_geometry<P1, P2>(str + "pp_20", "POINT(190 135)", "POINT(10 45)", true);
+        test_geometry<P1, P2>(str + "pp_21", "POINT(190 150)", "POINT(10 30)", true);
+        test_geometry<P1, P2>(str + "pp_21a", "POINT(-170 150)", "POINT(10 30)", true);
+        test_geometry<P1, P2>(str + "pp_22", "POINT(190 -135)", "POINT(10 -45)", true);
+        test_geometry<P1, P2>(str + "pp_23", "POINT(190 -150)", "POINT(10 -30)", true);
+        test_geometry<P1, P2>(str + "pp_23a", "POINT(-170 -150)", "POINT(10 -30)", true);
+    }
+};
+
+
+template <typename P>
+void test_segment_segment(std::string const& header)
+{
+    typedef bgm::segment<P> seg;
+
+    std::string const str = header + "-";
+
+    test_geometry<seg, seg>(str + "ss_01",
+                            "SEGMENT(10 0,180 0)",
+                            "SEGMENT(10 0,-180 0)",
+                            true);
+    test_geometry<seg, seg>(str + "ss_02",
+                            "SEGMENT(0 90,180 0)",
+                            "SEGMENT(10 90,-180 0)",
+                            true);
+    test_geometry<seg, seg>(str + "ss_03",
+                            "SEGMENT(0 90,0 -90)",
+                            "SEGMENT(10 90,20 -90)",
+                            true);
+    test_geometry<seg, seg>(str + "ss_04",
+                            "SEGMENT(10 80,10 -80)",
+                            "SEGMENT(10 80,20 -80)",
+                            false);
+    test_geometry<seg, seg>(str + "ss_05",
+                            "SEGMENT(170 10,-170 10)",
+                            "SEGMENT(170 10,350 10)",
+                            false);
+}
+
+
+BOOST_AUTO_TEST_CASE( equals_point_point_se )
+{
+    typedef bg::cs::spherical_equatorial<bg::degree> cs_type;
+
+    test_point_point<bgm::point<int, 2, cs_type> >::apply("se");
+    test_point_point<bgm::point<double, 2, cs_type> >::apply("se");
+    test_point_point<bgm::point<long double, 2, cs_type> >::apply("se");
+
+    // mixed point types
+    test_point_point
+        <
+            bgm::point<double, 2, cs_type>, bgm::point<int, 2, cs_type>
+        >::apply("se");
+
+    test_point_point
+        <
+            bgm::point<double, 2, cs_type>, bgm::point<long double, 2, cs_type>
+        >::apply("se");
+
+#if defined(HAVE_TTMATH)
+    test_point_point<bgm::point<ttmath_big, 2, cs_type> >::apply("se");
+#endif
+}
+
+BOOST_AUTO_TEST_CASE( equals_point_point_geo )
+{
+    typedef bg::cs::geographic<bg::degree> cs_type;
+
+    test_point_point<bgm::point<int, 2, cs_type> >::apply("geo");
+    test_point_point<bgm::point<double, 2, cs_type> >::apply("geo");
+    test_point_point<bgm::point<long double, 2, cs_type> >::apply("geo");
+
+    // mixed point types
+    test_point_point
+        <
+            bgm::point<double, 2, cs_type>, bgm::point<int, 2, cs_type>
+        >::apply("se");
+
+    test_point_point
+        <
+            bgm::point<double, 2, cs_type>, bgm::point<long double, 2, cs_type>
+        >::apply("se");
+
+#if defined(HAVE_TTMATH)
+    test_point_point<bgm::point<ttmath_big, 2, cs_type> >::apply("geo");
+#endif
+}
+
+BOOST_AUTO_TEST_CASE( equals_segment_segment_se )
+{
+    typedef bg::cs::spherical_equatorial<bg::degree> cs_type;
+
+    test_segment_segment<bgm::point<int, 2, cs_type> >("se");
+    test_segment_segment<bgm::point<double, 2, cs_type> >("se");
+    test_segment_segment<bgm::point<long double, 2, cs_type> >("se");
+
+#if defined(HAVE_TTMATH)
+    test_segment_segment<bgm::point<ttmath_big, 2, cs_type> >("se");
+#endif
+}
+
+BOOST_AUTO_TEST_CASE( equals_segment_segment_geo )
+{
+    typedef bg::cs::geographic<bg::degree> cs_type;
+
+    test_segment_segment<bgm::point<int, 2, cs_type> >("geo");
+    test_segment_segment<bgm::point<double, 2, cs_type> >("geo");
+    test_segment_segment<bgm::point<long double, 2, cs_type> >("geo");
+
+#if defined(HAVE_TTMATH)
+    test_segment_segment<bgm::point<ttmath_big, 2, cs_type> >("geo");
+#endif
+}
diff --git a/test/algorithms/set_operations/difference/Jamfile.v2 b/test/algorithms/set_operations/difference/Jamfile.v2
index 8bbbbbdc6..7cbcb8ada 100644
--- a/test/algorithms/set_operations/difference/Jamfile.v2
+++ b/test/algorithms/set_operations/difference/Jamfile.v2
@@ -1,11 +1,11 @@
 # Boost.Geometry (aka GGL, Generic Geometry Library)
 #
-# Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
-# Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
-# Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+# Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+# Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+# Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
 #
-# This file was modified by Oracle on 2014.
-# Modifications copyright (c) 2014, Oracle and/or its affiliates.
+# This file was modified by Oracle on 2014, 2015.
+# Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
 #
 # Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 # Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
@@ -18,6 +18,7 @@ test-suite boost-geometry-algorithms-difference
     :
     [ run difference.cpp : : : <define>BOOST_GEOMETRY_TEST_ONLY_ONE_TYPE ]
     [ run difference_linear_linear.cpp ]
+    [ run difference_pl_l.cpp ]
     [ run difference_pl_pl.cpp ]
     [ run multi_difference.cpp  : : : <define>BOOST_GEOMETRY_TEST_ONLY_ONE_TYPE ]
     [ run multi_difference_spike.cpp : : : <define>BOOST_GEOMETRY_TEST_ONLY_ONE_TYPE ]
diff --git a/test/algorithms/set_operations/difference/difference_pl_l.cpp b/test/algorithms/set_operations/difference/difference_pl_l.cpp
new file mode 100644
index 000000000..9592ec56d
--- /dev/null
+++ b/test/algorithms/set_operations/difference/difference_pl_l.cpp
@@ -0,0 +1,674 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+#ifndef BOOST_TEST_MODULE
+#define BOOST_TEST_MODULE test_difference_pointlike_linear
+#endif
+
+#include <iostream>
+#include <algorithm>
+
+#include <boost/test/included/unit_test.hpp>
+
+#include "../test_set_ops_pointlike.hpp"
+
+#include <boost/geometry/geometries/point.hpp>
+#include <boost/geometry/geometries/linestring.hpp>
+#include <boost/geometry/geometries/segment.hpp>
+#include <boost/geometry/geometries/multi_point.hpp>
+#include <boost/geometry/geometries/multi_linestring.hpp>
+
+typedef bg::model::point<double, 2, bg::cs::cartesian>  point_type;
+typedef bg::model::segment<point_type>  segment_type;
+typedef bg::model::linestring<point_type>  linestring_type;
+typedef bg::model::multi_point<point_type>  multi_point_type;
+typedef bg::model::multi_linestring<linestring_type>  multi_linestring_type;
+
+
+//===========================================================================
+//===========================================================================
+//===========================================================================
+
+
+BOOST_AUTO_TEST_CASE( test_difference_point_segment )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << "size of std::size_t: " << sizeof(std::size_t) << std::endl;
+    std::cout << "size of range_iterator<multipoint>: "
+              << sizeof(boost::range_iterator<multi_point_type>::type)
+              << std::endl;
+    std::cout << "size of range_iterator<multilinestring>: "
+              << sizeof(boost::range_iterator<multi_linestring_type>::type)
+              << std::endl;
+    std::cout << "size of point_iterator<multipoint>: "
+              << sizeof(bg::point_iterator<multi_point_type>) << std::endl;
+    std::cout << "size of point_iterator<linestring>: "
+              << sizeof(bg::point_iterator<linestring_type>) << std::endl;
+    std::cout << "size of point_iterator<multilinestring>: "
+              << sizeof(bg::point_iterator<multi_linestring_type>) << std::endl;
+    std::cout << "size of segment_iterator<linestring>: "
+              << sizeof(bg::segment_iterator<linestring_type>) << std::endl;
+    std::cout << "size of segment_iterator<multilinestring>: "
+              << sizeof(bg::segment_iterator<multi_linestring_type>) << std::endl;
+
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** POINT / SEGMENT DIFFERENCE ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef point_type P;
+    typedef segment_type S;
+    typedef multi_point_type MP;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            P, S, MP, bg::overlay_difference
+        > tester;
+
+    tester::apply
+        ("psdf01",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<S>("SEGMENT(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("psdf02",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<S>("SEGMENT(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("psdf03",
+         from_wkt<P>("POINT(1 1)"),
+         from_wkt<S>("SEGMENT(0 0,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("psdf04",
+         from_wkt<P>("POINT(3 3)"),
+         from_wkt<S>("SEGMENT(0 0,2 2)"),
+         from_wkt<MP>("MULTIPOINT(3 3)")
+         );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_difference_point_linestring )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** POINT / LINESTRING DIFFERENCE ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef point_type P;
+    typedef linestring_type L;
+    typedef multi_point_type MP;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            P, L, MP, bg::overlay_difference
+        > tester;
+
+    tester::apply
+        ("pldf01",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<L>("LINESTRING(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("pldf02",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<L>("LINESTRING(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pldf03",
+         from_wkt<P>("POINT(1 1)"),
+         from_wkt<L>("LINESTRING(0 0,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pldf04",
+         from_wkt<P>("POINT(3 3)"),
+         from_wkt<L>("LINESTRING(0 0,2 2)"),
+         from_wkt<MP>("MULTIPOINT(3 3)")
+         );
+
+    // linestrings with more than two points
+    tester::apply
+        ("pldf05",
+         from_wkt<P>("POINT(1 1)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pldf06",
+         from_wkt<P>("POINT(2 2)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,4 4)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pldf07",
+         from_wkt<P>("POINT(10 10)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,4 4)"),
+         from_wkt<MP>("MULTIPOINT(10 10)")
+         );
+
+    tester::apply
+        ("pldf08",
+         from_wkt<P>("POINT(0 1)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,4 4)"),
+         from_wkt<MP>("MULTIPOINT(0 1)")
+         );
+
+    tester::apply
+        ("pldf09",
+         from_wkt<P>("POINT(4 4)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,4 4)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pldf10",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,4 4)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_difference_point_multilinestring )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** POINT / MULTILINESTRING DIFFERENCE ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef point_type P;
+    typedef multi_linestring_type ML;
+    typedef multi_point_type MP;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            P, ML, MP, bg::overlay_difference
+        > tester;
+
+    tester::apply
+        ("pmldf01",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((1 1,2 2))"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("pmldf02",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmldf03",
+         from_wkt<P>("POINT(1 1)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,2 2))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmldf04",
+         from_wkt<P>("POINT(3 3)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,2 2))"),
+         from_wkt<MP>("MULTIPOINT(3 3)")
+         );
+
+    // linestrings with more than two points
+    tester::apply
+        ("pmldf05",
+         from_wkt<P>("POINT(1 1)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,2 2))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmldf06",
+         from_wkt<P>("POINT(2 2)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmldf07",
+         from_wkt<P>("POINT(10 10)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(10 10)")
+         );
+
+    tester::apply
+        ("pmldf08",
+         from_wkt<P>("POINT(0 1)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(0 1)")
+         );
+
+    tester::apply
+        ("pmldf09",
+         from_wkt<P>("POINT(4 4)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmldf10",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    // multilinestrings with more than one linestring
+    tester::apply
+        ("pmldf11",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((-10,-10),(0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmldf12",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((-10 0,0 0,10 0),(0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmldf13",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((-10 0,10 0),(0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmldf14",
+         from_wkt<P>("POINT(-20 0)"),
+         from_wkt<ML>("MULTILINESTRING((-10 0,10 0),(0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(-20 0)")
+         );
+
+    tester::apply
+        ("pmldf15",
+         from_wkt<P>("POINT(0 1)"),
+         from_wkt<ML>("MULTILINESTRING((-10 0,10 0),(0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(0 1)")
+         );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_difference_multipoint_segment )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** MULTIPOINT / SEGMENT DIFFERENCE ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef multi_point_type MP;
+    typedef segment_type S;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            MP, S, MP, bg::overlay_difference
+        > tester;
+
+    tester::apply
+        ("mpsdf01",
+         from_wkt<MP>("MULTIPOINT(0 0)"),
+         from_wkt<S>("SEGMENT(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("mpsdf02",
+         from_wkt<MP>("MULTIPOINT(0 0)"),
+         from_wkt<S>("SEGMENT(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsdf03",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)"),
+         from_wkt<S>("SEGMENT(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpsdf04",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)"),
+         from_wkt<S>("SEGMENT(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsdf05",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,1 0)"),
+         from_wkt<S>("SEGMENT(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,1 0)")
+         );
+
+    tester::apply
+        ("mpsf06",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,1 0)"),
+         from_wkt<S>("SEGMENT(1 0,2 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpsdf07",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(0 0,1 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0)")
+         );
+
+    tester::apply
+        ("mpsdf08",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<S>("SEGMENT(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsdf09",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(-1 0,1 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0)")
+         );
+
+    tester::apply
+        ("mpsdf10",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(1 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpsdf11",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(-1 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsdf12",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(3 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)")
+         );
+
+    tester::apply
+        ("mpsdf12a",
+         from_wkt<MP>("MULTIPOINT(0 0,2 0,0 0)"),
+         from_wkt<S>("SEGMENT(3 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)")
+         );
+
+    tester::apply
+        ("mpsdf12b",
+         from_wkt<MP>("MULTIPOINT(0 0,2 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(3 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0,2 0)")
+         );
+
+    tester::apply
+        ("mpsdf12c",
+         from_wkt<MP>("MULTIPOINT(0 0,2 0,0 0,2 0,0 0)"),
+         from_wkt<S>("SEGMENT(3 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,0 0,2 0,2 0)")
+         );
+
+    tester::apply
+        ("mpsdf13",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(2 0,2 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpsdf14",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(0 0,0 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0)")
+         );
+
+    tester::apply
+        ("mpsdf15",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<S>("SEGMENT(0 0,1 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_difference_multipoint_linestring )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** MULTIPOINT / LINESTRING DIFFERENCE ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef multi_point_type MP;
+    typedef linestring_type L;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            MP, L, MP, bg::overlay_difference
+        > tester;
+
+    tester::apply
+        ("mpldf01",
+         from_wkt<MP>("MULTIPOINT(0 0)"),
+         from_wkt<L>("LINESTRING(1 1,2 2,3 3,4 4,5 5)"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("mpldf02",
+         from_wkt<MP>("MULTIPOINT(0 0)"),
+         from_wkt<L>("LINESTRING(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpldf03",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)"),
+         from_wkt<L>("LINESTRING(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpldf04",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)"),
+         from_wkt<L>("LINESTRING(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpldf05",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,1 0)"),
+         from_wkt<L>("LINESTRING(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,1 0)")
+         );
+
+    tester::apply
+        ("mplf06",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,1 0)"),
+         from_wkt<L>("LINESTRING(1 0,2 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpldf07",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(0 0,1 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0)")
+         );
+
+    tester::apply
+        ("mpldf08",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<L>("LINESTRING(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpldf09",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(-1 0,1 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0)")
+         );
+
+    tester::apply
+        ("mpldf10",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(1 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpldf11",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(-1 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpldf12",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(3 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)")
+         );
+
+    tester::apply
+        ("mpldf13",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(2 0,2 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpldf14",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(0 0,0 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0)")
+         );
+
+    tester::apply
+        ("mpldf15",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<L>("LINESTRING(0 0,1 0,2 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpldf16",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<L>("LINESTRING()"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_difference_multipoint_multilinestring )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** MULTIPOINT / MULTILINESTRING DIFFERENCE ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef multi_point_type MP;
+    typedef multi_linestring_type ML;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            MP, ML, MP, bg::overlay_difference
+        > tester;
+
+    tester::apply
+        ("mpmldf01",
+         from_wkt<MP>("MULTIPOINT(0 0,1 0,2 0)"),
+         from_wkt<ML>("MULTILINESTRING((1 0,1 1,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(0 0,2 0)")
+         );
+
+    tester::apply
+        ("mpmldf02",
+         from_wkt<MP>("MULTIPOINT(2 2,3 3,0 0,0 0,2 2,1 1,1 1,1 0,1 0)"),
+         from_wkt<ML>("MULTILINESTRING((1 0,1 1,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpmldf03",
+         from_wkt<MP>("MULTIPOINT(5 5,3 3,0 0,0 0,5 5,1 1,1 1,1 0,1 0)"),
+         from_wkt<ML>("MULTILINESTRING((1 0,1 1,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(5 5,5 5,0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpmldf04",
+         from_wkt<MP>("MULTIPOINT(0 0,1 1,1 0,1 1)"),
+         from_wkt<ML>("MULTILINESTRING((1 0,0 0,1 1,0 0))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpmldf05",
+         from_wkt<MP>("MULTIPOINT(0 0,1 0,2 0,5 0)"),
+         from_wkt<ML>("MULTILINESTRING((0 1,0 0,1 2,1 0),\
+                      (0 1,2 0,0 10,2 0,2 10,5 10,5 0,5 10))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpmldf05a",
+         from_wkt<MP>("MULTIPOINT(0 0,1 0,6 0,7 0,2 0,5 0,7 0,8 0)"),
+         from_wkt<ML>("MULTILINESTRING((0 1,0 0,1 2,1 0),\
+                      (0 1,2 0,0 10,2 0,2 10,5 10,5 0,5 10))"),
+         from_wkt<MP>("MULTIPOINT(7 0,7 0,8 0,6 0)")
+         );
+
+    tester::apply
+        ("mpmldf06",
+         from_wkt<MP>("MULTIPOINT(0 0,1 1,1 0,1 1)"),
+         from_wkt<ML>("MULTILINESTRING(())"),
+         from_wkt<MP>("MULTIPOINT(0 0,1 1,1 0,1 1)")
+         );
+
+    tester::apply
+        ("mpmldf07",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<ML>("MULTILINESTRING(())"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpmldf08",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 0),(9 0,10 0))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+}
diff --git a/test/algorithms/set_operations/intersection/Jamfile.v2 b/test/algorithms/set_operations/intersection/Jamfile.v2
index b21302819..1d174881f 100644
--- a/test/algorithms/set_operations/intersection/Jamfile.v2
+++ b/test/algorithms/set_operations/intersection/Jamfile.v2
@@ -1,11 +1,11 @@
 # Boost.Geometry (aka GGL, Generic Geometry Library)
 #
-# Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
-# Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
-# Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+# Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+# Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+# Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
 #
-# This file was modified by Oracle on 2014.
-# Modifications copyright (c) 2014, Oracle and/or its affiliates.
+# This file was modified by Oracle on 2014, 2015.
+# Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
 #
 # Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 # Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
@@ -18,6 +18,7 @@ test-suite boost-geometry-algorithms-intersection
     :
     [ run intersection.cpp : : : <define>BOOST_GEOMETRY_TEST_ONLY_ONE_TYPE ]
     [ run intersection_linear_linear.cpp ]
+    [ run intersection_pl_l.cpp ]
     [ run intersection_pl_pl.cpp ]
     [ run multi_intersection.cpp : : : <define>BOOST_GEOMETRY_TEST_ONLY_ONE_TYPE ]
     ;
diff --git a/test/algorithms/set_operations/intersection/intersection.cpp b/test/algorithms/set_operations/intersection/intersection.cpp
index f89e70fab..2380fe582 100644
--- a/test/algorithms/set_operations/intersection/intersection.cpp
+++ b/test/algorithms/set_operations/intersection/intersection.cpp
@@ -434,6 +434,38 @@ void test_areal_linear()
 
 }
 
+
+template <typename Linestring, typename Box>
+void test_linear_box()
+{
+    typedef bg::model::multi_linestring<Linestring> multi_linestring_type;
+
+    test_one_lp<Linestring, Box, Linestring>
+        ("case-l-b-01",
+         "BOX(-10 -10,10 10)",
+         "LINESTRING(-20 -20, 0 0,20 20)",
+         1, 3, 20 * sqrt(2.0));
+
+    test_one_lp<Linestring, Box, Linestring>
+        ("case-l-b-02",
+         "BOX(-10 -10,10 10)",
+         "LINESTRING(-20 -20, 20 20)",
+         1, 2, 20.0 * sqrt(2.0));
+
+    test_one_lp<Linestring, Box, Linestring>
+        ("case-l-b-02",
+         "BOX(-10 -10,10 10)",
+         "LINESTRING(-20 -20, 20 20,15 0,0 -15)",
+         2, 4, 25.0 * sqrt(2.0));
+
+    test_one_lp<Linestring, Box, multi_linestring_type>
+        ("case-ml-b-01",
+         "BOX(-10 -10,10 10)",
+         "MULTILINESTRING((-20 -20, 20 20),(0 -15,15 0))",
+         2, 4, 25.0 * sqrt(2.0));
+}
+
+
 template <typename P>
 void test_all()
 {
@@ -456,6 +488,8 @@ void test_all()
     test_areal_linear<polygon_ccw_open, linestring>();
 #endif
 
+    test_linear_box<linestring, box>();
+
     // Test polygons clockwise and counter clockwise
     test_areal<polygon>();
 
diff --git a/test/algorithms/set_operations/intersection/intersection_pl_l.cpp b/test/algorithms/set_operations/intersection/intersection_pl_l.cpp
new file mode 100644
index 000000000..fd4575f0b
--- /dev/null
+++ b/test/algorithms/set_operations/intersection/intersection_pl_l.cpp
@@ -0,0 +1,702 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+#ifndef BOOST_TEST_MODULE
+#define BOOST_TEST_MODULE test_intersection_pointlike_linear
+#endif
+
+#include <iostream>
+#include <algorithm>
+
+#include <boost/test/included/unit_test.hpp>
+
+#include "../test_set_ops_pointlike.hpp"
+
+#include <boost/geometry/geometries/point.hpp>
+#include <boost/geometry/geometries/linestring.hpp>
+#include <boost/geometry/geometries/segment.hpp>
+#include <boost/geometry/geometries/multi_point.hpp>
+#include <boost/geometry/geometries/multi_linestring.hpp>
+
+typedef bg::model::point<double, 2, bg::cs::cartesian>  point_type;
+typedef bg::model::segment<point_type>  segment_type;
+typedef bg::model::linestring<point_type>  linestring_type;
+typedef bg::model::multi_point<point_type>  multi_point_type;
+typedef bg::model::multi_linestring<linestring_type>  multi_linestring_type;
+
+
+//===========================================================================
+//===========================================================================
+//===========================================================================
+
+
+BOOST_AUTO_TEST_CASE( test_intersection_point_segment )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** POINT / SEGMENT INTERSECTION ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef point_type P;
+    typedef segment_type S;
+    typedef multi_point_type MP;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            P, S, MP, bg::overlay_intersection
+        > tester;
+
+    tester::apply
+        ("psi01",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<S>("SEGMENT(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("psi02",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<S>("SEGMENT(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("psi03",
+         from_wkt<P>("POINT(1 1)"),
+         from_wkt<S>("SEGMENT(0 0,2 2)"),
+         from_wkt<MP>("MULTIPOINT(1 1)")
+         );
+
+    tester::apply
+        ("psi04",
+         from_wkt<P>("POINT(3 3)"),
+         from_wkt<S>("SEGMENT(0 0,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_intersection_point_linestring )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** POINT / LINESTRING INTERSECTION ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef point_type P;
+    typedef linestring_type L;
+    typedef multi_point_type MP;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            P, L, MP, bg::overlay_intersection
+        > tester;
+
+    tester::apply
+        ("pli01",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<L>("LINESTRING(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pli02",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<L>("LINESTRING(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("pli03",
+         from_wkt<P>("POINT(1 1)"),
+         from_wkt<L>("LINESTRING(0 0,2 2)"),
+         from_wkt<MP>("MULTIPOINT(1 1)")
+         );
+
+    tester::apply
+        ("pli04",
+         from_wkt<P>("POINT(3 3)"),
+         from_wkt<L>("LINESTRING(0 0,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    // linestrings with more than two points
+    tester::apply
+        ("pli05",
+         from_wkt<P>("POINT(1 1)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT(1 1)")
+         );
+
+    tester::apply
+        ("pli06",
+         from_wkt<P>("POINT(2 2)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,4 4)"),
+         from_wkt<MP>("MULTIPOINT(2 2)")
+         );
+
+    tester::apply
+        ("pli07",
+         from_wkt<P>("POINT(10 10)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,4 4)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pli08",
+         from_wkt<P>("POINT(0 1)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,4 4)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pli09",
+         from_wkt<P>("POINT(4 4)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,4 4)"),
+         from_wkt<MP>("MULTIPOINT(4 4)")
+         );
+
+    tester::apply
+        ("pli10",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<L>("LINESTRING(0 0,1 1,4 4)"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_intersection_point_multilinestring )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** POINT / MULTILINESTRING INTERSECTION ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef point_type P;
+    typedef multi_linestring_type ML;
+    typedef multi_point_type MP;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            P, ML, MP, bg::overlay_intersection
+        > tester;
+
+    tester::apply
+        ("pmli01",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((1 1,2 2))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmli02",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1))"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("pmli03",
+         from_wkt<P>("POINT(1 1)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,2 2))"),
+         from_wkt<MP>("MULTIPOINT(1 1)")
+         );
+
+    tester::apply
+        ("pmli04",
+         from_wkt<P>("POINT(3 3)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,2 2))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    // linestrings with more than two points
+    tester::apply
+        ("pmli05",
+         from_wkt<P>("POINT(1 1)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,2 2))"),
+         from_wkt<MP>("MULTIPOINT(1 1)")
+         );
+
+    tester::apply
+        ("pmli06",
+         from_wkt<P>("POINT(2 2)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(2 2)")
+         );
+
+    tester::apply
+        ("pmli07",
+         from_wkt<P>("POINT(10 10)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmli08",
+         from_wkt<P>("POINT(0 1)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmli09",
+         from_wkt<P>("POINT(4 4)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(4 4)")
+         );
+
+    tester::apply
+        ("pmli10",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    // multilinestrings with more than one linestring
+    tester::apply
+        ("pmli11",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((-10,-10),(0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("pmli12",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((-10 0,0 0,10 0),(0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("pmli13",
+         from_wkt<P>("POINT(0 0)"),
+         from_wkt<ML>("MULTILINESTRING((-10 0,10 0),(0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("pmli14",
+         from_wkt<P>("POINT(-20 0)"),
+         from_wkt<ML>("MULTILINESTRING((-10 0,10 0),(0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmli15",
+         from_wkt<P>("POINT(0 1)"),
+         from_wkt<ML>("MULTILINESTRING((-10 0,10 0),(0 0,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("pmli16",
+         from_wkt<P>("POINT(1 0)"),
+         from_wkt<ML>("MULTILINESTRING((-10 0,10 0),(-1 0,2 0,20 0))"),
+         from_wkt<MP>("MULTIPOINT(1 0)")
+         );
+
+    tester::apply
+        ("pmli17",
+         from_wkt<P>("POINT(1 0)"),
+         from_wkt<ML>("MULTILINESTRING((-10 0,10 0),(0 -1,0 2,0 4))"),
+         from_wkt<MP>("MULTIPOINT(1 0)")
+         );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_intersection_multipoint_segment )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** MULTIPOINT / SEGMENT INTERSECTION ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef multi_point_type MP;
+    typedef segment_type S;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            MP, S, MP, bg::overlay_intersection
+        > tester;
+
+    tester::apply
+        ("mpsi01",
+         from_wkt<MP>("MULTIPOINT(0 0)"),
+         from_wkt<S>("SEGMENT(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsi02",
+         from_wkt<MP>("MULTIPOINT(0 0)"),
+         from_wkt<S>("SEGMENT(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("mpsi03",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)"),
+         from_wkt<S>("SEGMENT(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsi04",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)"),
+         from_wkt<S>("SEGMENT(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpsi05",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,1 0)"),
+         from_wkt<S>("SEGMENT(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsf06",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,1 0)"),
+         from_wkt<S>("SEGMENT(1 0,2 0)"),
+         from_wkt<MP>("MULTIPOINT(1 0)")
+         );
+
+    tester::apply
+        ("mpsi07",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(0 0,1 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpsi07a",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(0 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)")
+         );
+
+    tester::apply
+        ("mpsi08",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<S>("SEGMENT(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsi09",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(-1 0,1 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpsi10",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(1 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0)")
+         );
+
+    tester::apply
+        ("mpsi11",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(-1 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)")
+         );
+
+    tester::apply
+        ("mpsi12",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(3 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsi12a",
+         from_wkt<MP>("MULTIPOINT(0 0,2 0,0 0)"),
+         from_wkt<S>("SEGMENT(3 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsi12b",
+         from_wkt<MP>("MULTIPOINT(0 0,2 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(3 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsi12c",
+         from_wkt<MP>("MULTIPOINT(0 0,2 0,0 0,2 0,0 0)"),
+         from_wkt<S>("SEGMENT(3 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsi13",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(2 0,2 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0)")
+         );
+
+    tester::apply
+        ("mpsi14",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<S>("SEGMENT(0 0,0 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpsi15",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<S>("SEGMENT(0 0,1 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpsi16",
+         from_wkt<MP>("MULTIPOINT(0 0,2 0,0 0,2 0,0 0)"),
+         from_wkt<S>("SEGMENT(-1 0,10 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,0 0,2 0,2 0)")
+         );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_intersection_multipoint_linestring )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** MULTIPOINT / LINESTRING INTERSECTION ***" << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef multi_point_type MP;
+    typedef linestring_type L;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            MP, L, MP, bg::overlay_intersection
+        > tester;
+
+    tester::apply
+        ("mpli01",
+         from_wkt<MP>("MULTIPOINT(0 0)"),
+         from_wkt<L>("LINESTRING(1 1,2 2,3 3,4 4,5 5)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpli02",
+         from_wkt<MP>("MULTIPOINT(0 0)"),
+         from_wkt<L>("LINESTRING(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT(0 0)")
+         );
+
+    tester::apply
+        ("mpli03",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)"),
+         from_wkt<L>("LINESTRING(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpli04",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)"),
+         from_wkt<L>("LINESTRING(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpli05",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,1 0)"),
+         from_wkt<L>("LINESTRING(1 1,2 2)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpli06",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,1 0)"),
+         from_wkt<L>("LINESTRING(1 0,2 0)"),
+         from_wkt<MP>("MULTIPOINT(1 0)")
+         );
+
+    tester::apply
+        ("mpli07",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(0 0,1 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpli08",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<L>("LINESTRING(0 0,1 1)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpli09",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(-1 0,1 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpli10",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(1 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0)")
+         );
+
+    tester::apply
+        ("mpli10a",
+         from_wkt<MP>("MULTIPOINT(2 0,0 0,2 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(1 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0,2 0,2 0)")
+         );
+
+    tester::apply
+        ("mpli11",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(-1 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0,0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpli12",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(3 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpli13",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(2 0,2 0)"),
+         from_wkt<MP>("MULTIPOINT(2 0)")
+         );
+
+    tester::apply
+        ("mpli14",
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,2 0)"),
+         from_wkt<L>("LINESTRING(0 0,0 0)"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpli15",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<L>("LINESTRING(0 0,1 0,2 0,3 0)"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpli16",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<L>("LINESTRING()"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_intersection_multipoint_multilinestring )
+{
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+    std::cout << std::endl << std::endl << std::endl;
+    std::cout << "*** MULTIPOINT / MULTILINESTRING INTERSECTION ***"
+              << std::endl;
+    std::cout << std::endl;
+#endif
+
+    typedef multi_point_type MP;
+    typedef multi_linestring_type ML;
+
+    typedef test_set_op_of_pointlike_geometries
+        <
+            MP, ML, MP, bg::overlay_intersection
+        > tester;
+
+    tester::apply
+        ("mpmli01",
+         from_wkt<MP>("MULTIPOINT(0 0,1 0,2 0)"),
+         from_wkt<ML>("MULTILINESTRING((1 0,1 1,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(1 0)")
+         );
+
+    tester::apply
+        ("mpmli02",
+         from_wkt<MP>("MULTIPOINT(2 2,3 3,0 0,0 0,2 2,1 1,1 1,1 0,1 0)"),
+         from_wkt<ML>("MULTILINESTRING((1 0,1 1,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(2 2,2 2,3 3,1 1,1 1,1 0,1 0)")
+         );
+
+    tester::apply
+        ("mpmli03",
+         from_wkt<MP>("MULTIPOINT(5 5,3 3,0 0,0 0,5 5,1 1,1 1,1 0,1 0)"),
+         from_wkt<ML>("MULTILINESTRING((1 0,1 1,1 1,4 4))"),
+         from_wkt<MP>("MULTIPOINT(1 0,1 0,3 3,1 1,1 1)")
+         );
+
+    tester::apply
+        ("mpmli04",
+         from_wkt<MP>("MULTIPOINT(0 0,1 1,1 0,1 1)"),
+         from_wkt<ML>("MULTILINESTRING((1 0,0 0,1 1,0 0))"),
+         from_wkt<MP>("MULTIPOINT(1 0,0 0,1 1,1 1)")
+         );
+
+    tester::apply
+        ("mpmli05",
+         from_wkt<MP>("MULTIPOINT(0 0,1 0,2 0,5 0)"),
+         from_wkt<ML>("MULTILINESTRING((0 1,0 0,1 2,1 0),\
+                      (0 1,2 0,0 10,2 0,2 10,5 10,5 0,5 10))"),
+         from_wkt<MP>("MULTIPOINT(0 0,1 0,2 0,5 0)")
+         );
+
+    tester::apply
+        ("mpmli06",
+         from_wkt<MP>("MULTIPOINT(0 0,1 1,1 0,1 1)"),
+         from_wkt<ML>("MULTILINESTRING(())"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpmli07",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<ML>("MULTILINESTRING(())"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpmli08",
+         from_wkt<MP>("MULTIPOINT()"),
+         from_wkt<ML>("MULTILINESTRING((0 0,1 0),(9 0,10 0))"),
+         from_wkt<MP>("MULTIPOINT()")
+         );
+
+    tester::apply
+        ("mpmli09",
+         from_wkt<MP>("MULTIPOINT(0 0,1 1,0 0,0 0,0 0,0 0,0 0,0 0,\
+                      0 0,0 0,0 0,0 0,0 0)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,0 1),(0 0,2 0),(0 0,0 3),\
+                      (0 0,4 0),(0 0,0 5),(0 0,6 0),(0 0,7 0),(0 0,8 0))"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0,0 0,0 0,0 0,0 0,0 0,\
+                      0 0,0 0,0 0,0 0,0 0)")
+         );
+
+    tester::apply
+        ("mpmli09a",
+         from_wkt<MP>("MULTIPOINT(0 0,1 1,0 0)"),
+         from_wkt<ML>("MULTILINESTRING((0 0,0 1),(0 0,2 0),(0 0,0 3),\
+                      (0 0,4 0),(0 0,0 5),(0 0,6 0),(0 0,7 0),(0 0,8 0))"),
+         from_wkt<MP>("MULTIPOINT(0 0,0 0)")
+         );
+}
diff --git a/test/algorithms/test_centroid.hpp b/test/algorithms/test_centroid.hpp
index 1784f66f4..cfbe01783 100644
--- a/test/algorithms/test_centroid.hpp
+++ b/test/algorithms/test_centroid.hpp
@@ -1,7 +1,13 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 // Unit Test
 
-// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -60,11 +66,8 @@ void test_with_other_calculation_type(Geometry const& geometry, Point& c1)
 }
 
 template <typename Geometry, typename Point, typename T>
-void test_centroid(std::string const& wkt, T const& d1, T const& d2, T const& d3 = T(), T const& d4 = T(), T const& d5 = T())
+void test_centroid(Geometry const& geometry, T const& d1, T const& d2, T const& d3 = T(), T const& d4 = T(), T const& d5 = T())
 {
-    Geometry geometry;
-    bg::read_wkt(wkt, geometry);
-
     Point c1;
 
     bg::centroid(geometry, c1);
@@ -86,6 +89,21 @@ void test_centroid(std::string const& wkt, T const& d1, T const& d2, T const& d3
 #endif
 }
 
+template <typename Geometry, typename Point, typename T>
+void test_centroid(std::string const& wkt, T const& d1, T const& d2, T const& d3 = T(), T const& d4 = T(), T const& d5 = T())
+{
+    Geometry geometry;
+    bg::read_wkt(wkt, geometry);
+
+    test_centroid<Geometry, Point>(geometry, d1, d2, d3, d4, d5);
+}
+
+template <typename Geometry, typename T>
+void test_centroid(Geometry const& geometry, T const& d1, T const& d2, T const& d3 = T(), T const& d4 = T(), T const& d5 = T())
+{
+    test_centroid<Geometry, typename bg::point_type<Geometry>::type>(geometry, d1, d2, d3, d4, d5);
+}
+
 template <typename Geometry, typename T>
 void test_centroid(std::string const& wkt, T const& d1, T const& d2, T const& d3 = T(), T const& d4 = T(), T const& d5 = T())
 {
diff --git a/test/algorithms/transform.cpp b/test/algorithms/transform.cpp
index 1746c7d23..f0414ff51 100644
--- a/test/algorithms/transform.cpp
+++ b/test/algorithms/transform.cpp
@@ -130,24 +130,34 @@ int test_main(int, char* [])
     test_all<bg::model::d2::point_xy<int>, bg::model::d2::point_xy<float> >(1.0);
 
     test_all<bg::model::point<double, 2, bg::cs::spherical<bg::degree> >,
-        bg::model::point<double, 2, bg::cs::spherical<bg::radian> > >(bg::math::d2r);
+        bg::model::point<double, 2, bg::cs::spherical<bg::radian> > >(bg::math::d2r<double>());
     test_all<bg::model::point<double, 2, bg::cs::spherical<bg::radian> >,
-        bg::model::point<double, 2, bg::cs::spherical<bg::degree> > >(bg::math::r2d);
+        bg::model::point<double, 2, bg::cs::spherical<bg::degree> > >(bg::math::r2d<double>());
 
     test_all<bg::model::point<int, 2, bg::cs::spherical<bg::degree> >,
-        bg::model::point<float, 2, bg::cs::spherical<bg::radian> > >(bg::math::d2r);
+        bg::model::point<float, 2, bg::cs::spherical<bg::radian> > >(bg::math::d2r<float>());
 
     test_transformations<float, bg::degree>(4, 52, 1);
     test_transformations<double, bg::degree>(4, 52, 1);
 
-    test_transformations<float, bg::radian>(3 * bg::math::d2r, 51 * bg::math::d2r, 1);
-    test_transformations<double, bg::radian>(3 * bg::math::d2r, 51 * bg::math::d2r, 1);
+    test_transformations
+        <
+            float, bg::radian
+        >(3 * bg::math::d2r<float>(), 51 * bg::math::d2r<float>(), 1);
+
+    test_transformations
+        <
+            double, bg::radian
+        >(3 * bg::math::d2r<double>(), 51 * bg::math::d2r<double>(), 1);
 
 #if defined(HAVE_TTMATH)
     typedef bg::model::d2::point_xy<ttmath_big > PT;
     test_all<PT, PT>();
     test_transformations<ttmath_big, bg::degree>(4, 52, 1);
-    test_transformations<ttmath_big, bg::radian>(3 * bg::math::d2r, 51 * bg::math::d2r, 1);
+    test_transformations
+        <
+            ttmath_big, bg::radian
+        >(3 * bg::math::d2r<ttmath_big>(), 51 * bg::math::d2r<ttmath_big>(), 1);
 #endif
 
     return 0;
diff --git a/test/strategies/side_of_intersection.cpp b/test/strategies/side_of_intersection.cpp
index c5de7e0ea..b42270e3d 100644
--- a/test/strategies/side_of_intersection.cpp
+++ b/test/strategies/side_of_intersection.cpp
@@ -19,9 +19,13 @@ namespace bg = boost::geometry;
 
 int test_main(int, char* [])
 {
-    typedef bg::model::d2::point_xy<int> point;
+    typedef bg::model::d2::point_xy<boost::long_long_type> point;
     typedef bg::model::segment<point> segment;
 
+    typedef bg::strategy::side::side_of_intersection side;
+
+    point no_fb(-99, -99);
+
     segment a(point(20, 10), point(10, 20));
 
     segment b1(point(11, 16), point(20, 14));  // IP with a: (14.857, 15.143)
@@ -31,27 +35,70 @@ int test_main(int, char* [])
     segment c2(point(15, 16), point(14, 8));
     segment c3(point(15, 16), point(15, 8));
 
-    typedef bg::strategy::side::side_of_intersection side;
 
-    BOOST_CHECK_EQUAL( 1, side::apply(a, b1, c1));
-    BOOST_CHECK_EQUAL(-1, side::apply(a, b1, c2));
-    BOOST_CHECK_EQUAL(-1, side::apply(a, b1, c3));
+    BOOST_CHECK_EQUAL( 1, side::apply(a, b1, c1, no_fb));
+    BOOST_CHECK_EQUAL(-1, side::apply(a, b1, c2, no_fb));
+    BOOST_CHECK_EQUAL(-1, side::apply(a, b1, c3, no_fb));
 
-    BOOST_CHECK_EQUAL( 1, side::apply(a, b2, c1));
-    BOOST_CHECK_EQUAL( 1, side::apply(a, b2, c2));
-    BOOST_CHECK_EQUAL( 0, side::apply(a, b2, c3));
+    BOOST_CHECK_EQUAL( 1, side::apply(a, b2, c1, no_fb));
+    BOOST_CHECK_EQUAL( 1, side::apply(a, b2, c2, no_fb));
+    BOOST_CHECK_EQUAL( 0, side::apply(a, b2, c3, no_fb));
 
-    // Check internal calculation-method:
-    BOOST_CHECK_EQUAL(-1400, side::side_value<int>(a, b1, c2));
-    BOOST_CHECK_EQUAL( 2800, side::side_value<int>(a, b1, c1));
+    // Collinear cases
+    // 1: segments intersecting are collinear (with a fallback point):
+    {
+        point fb(5, 5);
+        segment col1(point(0, 5), point(5, 5));
+        segment col2(point(5, 5), point(10, 5)); // One IP with col1 at (5,5)
+        segment col3(point(5, 0), point(5, 5));
+        BOOST_CHECK_EQUAL( 0, side::apply(col1, col2, col3, fb));
+    }
+    // 2: segment of side calculation collinear with one of the segments
+    {
+        point fb(5, 5);
+        segment col1(point(0, 5), point(10, 5));
+        segment col2(point(5, 5), point(5, 12)); // IP with col1 at (5,5)
+        segment col3(point(5, 1), point(5, 5)); // collinear with col2
+        BOOST_CHECK_EQUAL( 0, side::apply(col1, col2, col3, fb));
+    }
+    {
+        point fb(5, 5);
+        segment col1(point(10, 5), point(0, 5));
+        segment col2(point(5, 5), point(5, 12)); // IP with col1 at (5,5)
+        segment col3(point(5, 1), point(5, 5)); // collinear with col2
+        BOOST_CHECK_EQUAL( 0, side::apply(col1, col2, col3, fb));
+    }
+    {
+        point fb(5, 5);
+        segment col1(point(0, 5), point(10, 5));
+        segment col2(point(5, 12), point(5, 5)); // IP with col1 at (5,5)
+        segment col3(point(5, 1), point(5, 5)); // collinear with col2
+        BOOST_CHECK_EQUAL( 0, side::apply(col1, col2, col3, fb));
+    }
 
-    BOOST_CHECK_EQUAL (2800, side::side_value<int>(a, b1, c1));
-    BOOST_CHECK_EQUAL(-1400, side::side_value<int>(a, b1, c2));
-    BOOST_CHECK_EQUAL(-5600, side::side_value<int>(a, b1, c3));
+    {
+        point fb(517248, -517236);
+        segment col1(point(-172408, -517236), point(862076, -517236));
+        segment col2(point(517248, -862064), point(517248, -172408));
+        segment col3(point(517248, -172408), point(517248, -517236));
+        BOOST_CHECK_EQUAL( 0, side::apply(col1, col2, col3, fb));
+    }
+    {
+        point fb(-221647, -830336);
+        segment col1(point(-153817, -837972), point(-222457, -830244));
+        segment col2(point(-221139, -833615), point(-290654, -384388));
+        segment col3(point(-255266, -814663), point(-264389, -811197));
+        BOOST_CHECK_EQUAL(1, side::apply(col1, col2, col3, fb)); // Left of segment...
+    }
 
-    BOOST_CHECK_EQUAL(12800, side::side_value<int>(a, b2, c1));
-    BOOST_CHECK_EQUAL( 6400, side::side_value<int>(a, b2, c2));
-    BOOST_CHECK_EQUAL(    0, side::side_value<int>(a, b2, c3));
+
+    {
+        point fb(27671131, 30809240);
+        segment col1(point(27671116, 30809247), point(27675474, 30807351));
+        segment col2(point(27666779, 30811130), point(27671139, 30809237));
+        segment col3(point(27671122, 30809244), point(27675480, 30807348));
+        BOOST_CHECK_EQUAL(1, side::apply(col1, col2, col3, fb)); // Left of segment...
+    }
 
     // TODO: we might add a check calculating the IP, determining the side
     // with the normal side strategy, and verify the results are equal
diff --git a/test/strategies/vincenty.cpp b/test/strategies/vincenty.cpp
index b80da4bb5..e963a5549 100644
--- a/test/strategies/vincenty.cpp
+++ b/test/strategies/vincenty.cpp
@@ -121,24 +121,27 @@ void test_vincenty(double lon1, double lat1, double lon2, double lat2,
 
     // formula
     {
-        bg::detail::vincenty_inverse<calc_t> vi(lon1 * bg::math::d2r,
-                                                lat1 * bg::math::d2r,
-                                                lon2 * bg::math::d2r,
-                                                lat2 * bg::math::d2r,
+        double const d2r = bg::math::d2r<double>();
+        double const r2d = bg::math::r2d<double>();
+
+        bg::detail::vincenty_inverse<calc_t> vi(lon1 * d2r,
+                                                lat1 * d2r,
+                                                lon2 * d2r,
+                                                lat2 * d2r,
                                                 spheroid);
         calc_t dist = vi.distance();
         calc_t az12 = vi.azimuth12();
         calc_t az21 = vi.azimuth21();
 
-        calc_t az12_deg = az12 * bg::math::r2d;
-        calc_t az21_deg = az21 * bg::math::r2d;
+        calc_t az12_deg = az12 * r2d;
+        calc_t az21_deg = az21 * r2d;
         
         BOOST_CHECK_CLOSE(dist, calc_t(expected_distance), tolerance);
         check_deg("az12_deg", az12_deg, calc_t(expected_azimuth_12), tolerance, error);
         check_deg("az21_deg", az21_deg, calc_t(expected_azimuth_21), tolerance, error);
 
-        bg::detail::vincenty_direct<calc_t> vd(lon1 * bg::math::d2r,
-                                               lat1 * bg::math::d2r,
+        bg::detail::vincenty_direct<calc_t> vd(lon1 * d2r,
+                                               lat1 * d2r,
                                                dist,
                                                az12,
                                                spheroid);
@@ -146,9 +149,9 @@ void test_vincenty(double lon1, double lat1, double lon2, double lat2,
         calc_t direct_lat2 = vd.lat2();
         calc_t direct_az21 = vd.azimuth21();
 
-        calc_t direct_lon2_deg = direct_lon2 * bg::math::r2d;
-        calc_t direct_lat2_deg = direct_lat2 * bg::math::r2d;
-        calc_t direct_az21_deg = direct_az21 * bg::math::r2d;
+        calc_t direct_lon2_deg = direct_lon2 * r2d;
+        calc_t direct_lat2_deg = direct_lat2 * r2d;
+        calc_t direct_az21_deg = direct_az21 * r2d;
         
         check_deg("direct_lon2_deg", direct_lon2_deg, calc_t(lon2), tolerance, error);
         check_deg("direct_lat2_deg", direct_lat2_deg, calc_t(lat2), tolerance, error);
diff --git a/test/util/Jamfile.v2 b/test/util/Jamfile.v2
index 70a463777..1b0ada709 100644
--- a/test/util/Jamfile.v2
+++ b/test/util/Jamfile.v2
@@ -8,6 +8,7 @@
 # Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
 #
 # Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+# Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 #
 # Use, modification and distribution is subject to the Boost Software License,
 # Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -17,6 +18,7 @@ test-suite boost-geometry-util
     :
     [ run calculation_type.cpp ]
     [ run for_each_coordinate.cpp ]
+    [ run math_equals.cpp ]
     [ run math_sqrt.cpp ]
     [ run promote_integral.cpp ]
     [ run range.cpp ]
diff --git a/test/util/math_equals.cpp b/test/util/math_equals.cpp
new file mode 100644
index 000000000..0f26f6951
--- /dev/null
+++ b/test/util/math_equals.cpp
@@ -0,0 +1,79 @@
+// Boost.Geometry
+// Unit Test
+
+// Copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <geometry_test_common.hpp>
+
+#include <limits>
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+namespace bgm = bg::math;
+
+template <typename T>
+void test_all()
+{
+    BOOST_CHECK(bgm::equals(0, 0));
+    BOOST_CHECK(bgm::equals(1, 1));
+    BOOST_CHECK(bgm::equals(123456, 123456));
+    
+    T eps = std::numeric_limits<T>::epsilon();
+    if ( eps > 0 )
+    {
+        BOOST_CHECK(bgm::equals(0, 0+eps));
+        BOOST_CHECK(bgm::equals(0+eps, 0));
+        BOOST_CHECK(bgm::equals(1, 1+eps));
+        BOOST_CHECK(bgm::equals(1+eps, 1));
+        BOOST_CHECK(bgm::equals(12345+eps, 12345));
+    }
+
+    if (BOOST_GEOMETRY_CONDITION(std::numeric_limits<T>::has_infinity))
+    {
+        T inf = std::numeric_limits<T>::infinity();
+        BOOST_CHECK(!bgm::equals(0, inf));
+        BOOST_CHECK(!bgm::equals(0, -inf));
+        BOOST_CHECK(!bgm::equals(1, inf));
+        BOOST_CHECK(!bgm::equals(1, -inf));
+        BOOST_CHECK(!bgm::equals(12345, inf));
+        BOOST_CHECK(!bgm::equals(12345, -inf));
+        BOOST_CHECK(!bgm::equals(inf, 0));
+        BOOST_CHECK(!bgm::equals(-inf, 0));
+        BOOST_CHECK(!bgm::equals(inf, 1));
+        BOOST_CHECK(!bgm::equals(-inf, 1));
+        BOOST_CHECK(!bgm::equals(inf, 12345));
+        BOOST_CHECK(!bgm::equals(-inf, 12345));
+        BOOST_CHECK(bgm::equals(inf, inf));
+        BOOST_CHECK(bgm::equals(-inf, -inf));
+        BOOST_CHECK(!bgm::equals(inf, -inf));
+        BOOST_CHECK(!bgm::equals(-inf, inf));
+    }
+
+    if (BOOST_GEOMETRY_CONDITION(std::numeric_limits<T>::has_quiet_NaN))
+    {
+        T nan = std::numeric_limits<T>::quiet_NaN();
+        BOOST_CHECK(!bgm::equals(0, nan));
+        BOOST_CHECK(!bgm::equals(nan, 0));
+        BOOST_CHECK(!bgm::equals(nan, nan));
+        BOOST_CHECK(!bgm::equals(1, nan));
+        BOOST_CHECK(!bgm::equals(nan, 1));
+        BOOST_CHECK(!bgm::equals(12345, nan));
+        BOOST_CHECK(!bgm::equals(nan, 12345));
+    }
+}
+
+int test_main(int, char* [])
+{
+    test_all<int>();
+    test_all<float>();
+    test_all<double>();
+    
+    return 0;
+}