refactor angle computation into class/compile unit

CMakeLists.txt

@@ -56,7 +56,7 @@ add_library(IMPORT OBJECT ${ImporterGlob})
 set(ExtractorSources extractor.cpp ${ExtractorGlob})
 add_executable(osrm-extract ${ExtractorSources} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:IMPORT>)
 
-file(GLOB PrepareGlob Contractor/*.cpp DataStructures/HilbertValue.cpp DataStructures/RestrictionMap.cpp)
+file(GLOB PrepareGlob Contractor/*.cpp DataStructures/HilbertValue.cpp DataStructures/RestrictionMap.cpp Util/compute_angle.cpp)
 set(PrepareSources prepare.cpp ${PrepareGlob})
 add_executable(osrm-prepare ${PrepareSources} $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:IMPORT>)
 

Contractor/EdgeBasedGraphFactory.cpp

@@ -29,7 +29,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../Algorithms/BFSComponentExplorer.h"
 #include "../DataStructures/Percent.h"
 #include "../DataStructures/Range.h"
-#include "../Util/ComputeAngle.h"
+#include "../Util/compute_angle.hpp"
 #include "../Util/LuaUtil.h"
 #include "../Util/SimpleLogger.h"
 #include "../Util/TimingUtil.h"
@@ -630,7 +630,7 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(const std::string &original_edg
                 {
                     distance += speed_profile.traffic_signal_penalty;
                 }
-                const double angle = GetAngleBetweenThreeFixedPointCoordinates(
+                const double angle = ComputeAngle::OfThreeFixedPointCoordinates(
                     m_node_info_list[u], m_node_info_list[v], m_node_info_list[w]);
                 const int turn_penalty = GetTurnPenalty(angle, lua_state);
                 TurnInstruction turn_instruction = AnalyzeTurn(u, v, w, angle);

Include/osrm/Coordinate.h

@@ -30,6 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <iosfwd> //for std::ostream
 #include <string>
+#include <type_traits>
 
 constexpr float COORDINATE_PRECISION = 1000000.f;
 
@@ -40,6 +41,14 @@ struct FixedPointCoordinate
 
     FixedPointCoordinate();
     FixedPointCoordinate(int lat, int lon);
+
+    template<class T>
+    FixedPointCoordinate(const T &coordinate) : lat(coordinate.lat), lon(coordinate.lon)
+    {
+        static_assert(std::is_same<decltype(lat), decltype(coordinate.lat)>::value, "coordinate types incompatible");
+        static_assert(std::is_same<decltype(lon), decltype(coordinate.lon)>::value, "coordinate types incompatible");
+    }
+
     void Reset();
     bool isSet() const;
     bool isValid() const;

Util/compute_angle.cpp

@@ -25,21 +25,17 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef COMPUTE_ANGLE_H
-#define COMPUTE_ANGLE_H
+#include "compute_angle.hpp"
 
 #include "TrigonometryTables.h"
 #include "../Util/MercatorUtil.h"
 #include <osrm/Coordinate.h>
 
-#include <boost/assert.hpp>
 #include <cmath>
 
-/* Get angle of line segment (A,C)->(C,B), atan2 magic, formerly cosine theorem*/
-template <class CoordinateT>
-static double GetAngleBetweenThreeFixedPointCoordinates(const CoordinateT &A,
-                                                               const CoordinateT &C,
-                                                               const CoordinateT &B)
+double ComputeAngle::OfThreeFixedPointCoordinates(const FixedPointCoordinate &A,
+                                                  const FixedPointCoordinate &C,
+                                                  const FixedPointCoordinate &B)
 {
     const double v1x = (A.lon - C.lon) / COORDINATE_PRECISION;
     const double v1y = lat2y(A.lat / COORDINATE_PRECISION) - lat2y(C.lat / COORDINATE_PRECISION);
@@ -53,5 +49,3 @@ static double GetAngleBetweenThreeFixedPointCoordinates(const CoordinateT &A,
     }
     return angle;
 }
-
-#endif // COMPUTE_ANGLE_H

Util/compute_angle.hpp

@@ -0,0 +1,41 @@
+/*
+
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef COMPUTE_ANGLE_HPP
+#define COMPUTE_ANGLE_HPP
+
+struct FixedPointCoordinate;
+struct NodeInfo;
+
+struct ComputeAngle
+{
+    /* Get angle of line segment (A,C)->(C,B), atan2 magic, formerly cosine theorem*/
+    static double OfThreeFixedPointCoordinates(const FixedPointCoordinate &A,
+                                               const FixedPointCoordinate &C,
+                                               const FixedPointCoordinate &B);
+};
+#endif // COMPUTE_ANGLE_HPP