tracktable.lib._domain_algorithm_overloads module

Module contents

tracktable.lib._domain_algorithm_overloads.bearing((BasePointTerrestrial)arg1, (BasePointTerrestrial)arg2) → float :

C++ signature :

double bearing(tracktable::domain::terrestrial::TerrestrialPoint,tracktable::domain::terrestrial::TerrestrialPoint)

bearing( (TrajectoryPointTerrestrial)arg1, (TrajectoryPointTerrestrial)arg2) -> float :

C++ signature :

double bearing(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

bearing( (BasePointCartesian2D)arg1, (BasePointCartesian2D)arg2) -> float :

C++ signature :

double bearing(tracktable::domain::cartesian2d::CartesianPoint2D,tracktable::domain::cartesian2d::CartesianPoint2D)

bearing( (TrajectoryPointCartesian2D)arg1, (TrajectoryPointCartesian2D)arg2) -> float :

C++ signature :

double bearing(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

tracktable.lib._domain_algorithm_overloads.convex_hull_area((TrajectoryTerrestrial)arg1) → float :

C++ signature :

double convex_hull_area(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

convex_hull_area( (TrajectoryCartesian2D)arg1) -> float :

C++ signature :

double convex_hull_area(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

tracktable.lib._domain_algorithm_overloads.convex_hull_aspect_ratio((TrajectoryTerrestrial)arg1) → float :

C++ signature :

double convex_hull_aspect_ratio(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

convex_hull_aspect_ratio( (TrajectoryCartesian2D)arg1) -> float :

C++ signature :

double convex_hull_aspect_ratio(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

tracktable.lib._domain_algorithm_overloads.convex_hull_centroid((TrajectoryTerrestrial)arg1) → TrajectoryPointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialTrajectoryPoint convex_hull_centroid(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

convex_hull_centroid( (TrajectoryCartesian2D)arg1) -> TrajectoryPointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D convex_hull_centroid(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

tracktable.lib._domain_algorithm_overloads.convex_hull_perimeter((TrajectoryTerrestrial)arg1) → float :

C++ signature :

double convex_hull_perimeter(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

convex_hull_perimeter( (TrajectoryCartesian2D)arg1) -> float :

C++ signature :

double convex_hull_perimeter(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

tracktable.lib._domain_algorithm_overloads.current_length((TrajectoryPointTerrestrial)arg1) → float :

C++ signature :

double current_length(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

current_length( (TrajectoryPointCartesian2D)arg1) -> float :

C++ signature :

double current_length(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

tracktable.lib._domain_algorithm_overloads.current_length_fraction((TrajectoryPointTerrestrial)arg1) → float :

C++ signature :

double current_length_fraction(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

current_length_fraction( (TrajectoryPointCartesian2D)arg1) -> float :

C++ signature :

double current_length_fraction(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

tracktable.lib._domain_algorithm_overloads.current_time_fraction((TrajectoryPointTerrestrial)arg1) → float :

C++ signature :

double current_time_fraction(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

current_time_fraction( (TrajectoryPointCartesian2D)arg1) -> float :

C++ signature :

double current_time_fraction(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

tracktable.lib._domain_algorithm_overloads.distance((BasePointTerrestrial)arg1, (BasePointTerrestrial)arg2) → float :

C++ signature :

double distance(tracktable::domain::terrestrial::TerrestrialPoint,tracktable::domain::terrestrial::TerrestrialPoint)

distance( (BasePointTerrestrial)arg1, (object)arg2) -> float :

C++ signature :

double distance(tracktable::domain::terrestrial::TerrestrialPoint,std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >)

distance( (object)arg1, (BasePointTerrestrial)arg2) -> float :

C++ signature :

double distance(std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >,tracktable::domain::terrestrial::TerrestrialPoint)

distance( (object)arg1, (object)arg2) -> float :

C++ signature :

double distance(std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >,std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >)

distance( (BasePointTerrestrial)arg1, (TrajectoryPointTerrestrial)arg2) -> float :

C++ signature :

double distance(tracktable::domain::terrestrial::TerrestrialPoint,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

distance( (TrajectoryPointTerrestrial)arg1, (BasePointTerrestrial)arg2) -> float :

C++ signature :

double distance(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::domain::terrestrial::TerrestrialPoint)

distance( (BasePointTerrestrial)arg1, (TrajectoryTerrestrial)arg2) -> float :

C++ signature :

double distance(tracktable::domain::terrestrial::TerrestrialPoint,tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

distance( (TrajectoryTerrestrial)arg1, (BasePointTerrestrial)arg2) -> float :

C++ signature :

double distance(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,tracktable::domain::terrestrial::TerrestrialPoint)

distance( (object)arg1, (TrajectoryPointTerrestrial)arg2) -> float :

C++ signature :

double distance(std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

distance( (TrajectoryPointTerrestrial)arg1, (object)arg2) -> float :

C++ signature :

double distance(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >)

distance( (object)arg1, (TrajectoryTerrestrial)arg2) -> float :

C++ signature :

double distance(std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >,tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

distance( (TrajectoryTerrestrial)arg1, (object)arg2) -> float :

C++ signature :

double distance(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >)

distance( (TrajectoryPointTerrestrial)arg1, (TrajectoryPointTerrestrial)arg2) -> float :

C++ signature :

double distance(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

distance( (TrajectoryPointTerrestrial)arg1, (TrajectoryTerrestrial)arg2) -> float :

C++ signature :

double distance(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

distance( (TrajectoryTerrestrial)arg1, (TrajectoryPointTerrestrial)arg2) -> float :

C++ signature :

double distance(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

distance( (TrajectoryTerrestrial)arg1, (TrajectoryTerrestrial)arg2) -> float :

C++ signature :

double distance(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

distance( (BasePointCartesian2D)arg1, (BasePointCartesian2D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian2d::CartesianPoint2D,tracktable::domain::cartesian2d::CartesianPoint2D)

distance( (BasePointCartesian2D)arg1, (object)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian2d::CartesianPoint2D,std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >)

distance( (object)arg1, (BasePointCartesian2D)arg2) -> float :

C++ signature :

double distance(std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >,tracktable::domain::cartesian2d::CartesianPoint2D)

distance( (object)arg1, (object)arg2) -> float :

C++ signature :

double distance(std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >,std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >)

distance( (BasePointCartesian2D)arg1, (TrajectoryPointCartesian2D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian2d::CartesianPoint2D,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

distance( (TrajectoryPointCartesian2D)arg1, (BasePointCartesian2D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::domain::cartesian2d::CartesianPoint2D)

distance( (BasePointCartesian2D)arg1, (TrajectoryCartesian2D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian2d::CartesianPoint2D,tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

distance( (TrajectoryCartesian2D)arg1, (BasePointCartesian2D)arg2) -> float :

C++ signature :

double distance(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,tracktable::domain::cartesian2d::CartesianPoint2D)

distance( (object)arg1, (TrajectoryPointCartesian2D)arg2) -> float :

C++ signature :

double distance(std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

distance( (TrajectoryPointCartesian2D)arg1, (object)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >)

distance( (object)arg1, (TrajectoryCartesian2D)arg2) -> float :

C++ signature :

double distance(std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >,tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

distance( (TrajectoryCartesian2D)arg1, (object)arg2) -> float :

C++ signature :

double distance(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >)

distance( (TrajectoryPointCartesian2D)arg1, (TrajectoryPointCartesian2D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

distance( (TrajectoryPointCartesian2D)arg1, (TrajectoryCartesian2D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

distance( (TrajectoryCartesian2D)arg1, (TrajectoryPointCartesian2D)arg2) -> float :

C++ signature :

double distance(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

distance( (TrajectoryCartesian2D)arg1, (TrajectoryCartesian2D)arg2) -> float :

C++ signature :

double distance(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

distance( (BasePointCartesian3D)arg1, (BasePointCartesian3D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian3d::CartesianPoint3D,tracktable::domain::cartesian3d::CartesianPoint3D)

distance( (BasePointCartesian3D)arg1, (TrajectoryPointCartesian3D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian3d::CartesianPoint3D,tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D)

distance( (TrajectoryPointCartesian3D)arg1, (BasePointCartesian3D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,tracktable::domain::cartesian3d::CartesianPoint3D)

distance( (TrajectoryPointCartesian3D)arg1, (TrajectoryPointCartesian3D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D)

distance( (BasePointCartesian3D)arg1, (object)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian3d::CartesianPoint3D,std::vector<tracktable::domain::cartesian3d::CartesianPoint3D, std::allocator<tracktable::domain::cartesian3d::CartesianPoint3D> >)

distance( (object)arg1, (BasePointCartesian3D)arg2) -> float :

C++ signature :

double distance(std::vector<tracktable::domain::cartesian3d::CartesianPoint3D, std::allocator<tracktable::domain::cartesian3d::CartesianPoint3D> >,tracktable::domain::cartesian3d::CartesianPoint3D)

distance( (BasePointCartesian3D)arg1, (TrajectoryCartesian3D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian3d::CartesianPoint3D,tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>)

distance( (TrajectoryCartesian3D)arg1, (BasePointCartesian3D)arg2) -> float :

C++ signature :

double distance(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>,tracktable::domain::cartesian3d::CartesianPoint3D)

distance( (TrajectoryPointCartesian3D)arg1, (object)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,std::vector<tracktable::domain::cartesian3d::CartesianPoint3D, std::allocator<tracktable::domain::cartesian3d::CartesianPoint3D> >)

distance( (object)arg1, (TrajectoryPointCartesian3D)arg2) -> float :

C++ signature :

double distance(std::vector<tracktable::domain::cartesian3d::CartesianPoint3D, std::allocator<tracktable::domain::cartesian3d::CartesianPoint3D> >,tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D)

distance( (TrajectoryPointCartesian3D)arg1, (TrajectoryCartesian3D)arg2) -> float :

C++ signature :

double distance(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>)

distance( (TrajectoryCartesian3D)arg1, (TrajectoryPointCartesian3D)arg2) -> float :

C++ signature :

double distance(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>,tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D)

tracktable.lib._domain_algorithm_overloads.end_to_end_distance((TrajectoryTerrestrial)arg1) → float :

C++ signature :

double end_to_end_distance(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

end_to_end_distance( (TrajectoryCartesian2D)arg1) -> float :

C++ signature :

double end_to_end_distance(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

end_to_end_distance( (TrajectoryCartesian3D)arg1) -> float :

C++ signature :

double end_to_end_distance(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>)

tracktable.lib._domain_algorithm_overloads.extrapolate((BasePointTerrestrial)arg1, (BasePointTerrestrial)arg2, (float)arg3) → BasePointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialPoint extrapolate(tracktable::domain::terrestrial::TerrestrialPoint,tracktable::domain::terrestrial::TerrestrialPoint,double)

extrapolate( (TrajectoryPointTerrestrial)arg1, (TrajectoryPointTerrestrial)arg2, (float)arg3) -> TrajectoryPointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialTrajectoryPoint extrapolate(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,double)

extrapolate( (BasePointCartesian2D)arg1, (BasePointCartesian2D)arg2, (float)arg3) -> BasePointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianPoint2D extrapolate(tracktable::domain::cartesian2d::CartesianPoint2D,tracktable::domain::cartesian2d::CartesianPoint2D,double)

extrapolate( (TrajectoryPointCartesian2D)arg1, (TrajectoryPointCartesian2D)arg2, (float)arg3) -> TrajectoryPointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D extrapolate(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,double)

extrapolate( (BasePointCartesian3D)arg1, (BasePointCartesian3D)arg2, (float)arg3) -> BasePointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianPoint3D extrapolate(tracktable::domain::cartesian3d::CartesianPoint3D,tracktable::domain::cartesian3d::CartesianPoint3D,double)

extrapolate( (TrajectoryPointCartesian3D)arg1, (TrajectoryPointCartesian3D)arg2, (float)arg3) -> TrajectoryPointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D extrapolate(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,double)

tracktable.lib._domain_algorithm_overloads.geometric_mean((BasePointTerrestrial)arg1, (object)arg2) → BasePointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialPoint geometric_mean(tracktable::domain::terrestrial::TerrestrialPoint,boost::python::api::object)

geometric_mean( (TrajectoryPointTerrestrial)arg1, (object)arg2) -> TrajectoryPointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialTrajectoryPoint geometric_mean(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,boost::python::api::object)

geometric_mean( (BasePointCartesian2D)arg1, (object)arg2) -> BasePointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianPoint2D geometric_mean(tracktable::domain::cartesian2d::CartesianPoint2D,boost::python::api::object)

geometric_mean( (TrajectoryPointCartesian2D)arg1, (object)arg2) -> TrajectoryPointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D geometric_mean(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,boost::python::api::object)

geometric_mean( (BasePointCartesian3D)arg1, (object)arg2) -> BasePointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianPoint3D geometric_mean(tracktable::domain::cartesian3d::CartesianPoint3D,boost::python::api::object)

geometric_mean( (TrajectoryPointCartesian3D)arg1, (object)arg2) -> TrajectoryPointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D geometric_mean(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,boost::python::api::object)

tracktable.lib._domain_algorithm_overloads.geometric_median((BasePointTerrestrial)arg1, (object)arg2) → BasePointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialPoint geometric_median(tracktable::domain::terrestrial::TerrestrialPoint,boost::python::api::object)

geometric_median( (TrajectoryPointTerrestrial)arg1, (object)arg2) -> TrajectoryPointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialTrajectoryPoint geometric_median(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,boost::python::api::object)

geometric_median( (BasePointCartesian2D)arg1, (object)arg2) -> BasePointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianPoint2D geometric_median(tracktable::domain::cartesian2d::CartesianPoint2D,boost::python::api::object)

geometric_median( (TrajectoryPointCartesian2D)arg1, (object)arg2) -> TrajectoryPointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D geometric_median(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,boost::python::api::object)

geometric_median( (BasePointCartesian3D)arg1, (object)arg2) -> BasePointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianPoint3D geometric_median(tracktable::domain::cartesian3d::CartesianPoint3D,boost::python::api::object)

geometric_median( (TrajectoryPointCartesian3D)arg1, (object)arg2) -> TrajectoryPointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D geometric_median(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,boost::python::api::object)

tracktable.lib._domain_algorithm_overloads.interpolate((BasePointTerrestrial)arg1, (BasePointTerrestrial)arg2, (float)arg3) → BasePointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialPoint interpolate(tracktable::domain::terrestrial::TerrestrialPoint,tracktable::domain::terrestrial::TerrestrialPoint,double)

interpolate( (TrajectoryPointTerrestrial)arg1, (TrajectoryPointTerrestrial)arg2, (float)arg3) -> TrajectoryPointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialTrajectoryPoint interpolate(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,double)

interpolate( (BasePointCartesian2D)arg1, (BasePointCartesian2D)arg2, (float)arg3) -> BasePointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianPoint2D interpolate(tracktable::domain::cartesian2d::CartesianPoint2D,tracktable::domain::cartesian2d::CartesianPoint2D,double)

interpolate( (TrajectoryPointCartesian2D)arg1, (TrajectoryPointCartesian2D)arg2, (float)arg3) -> TrajectoryPointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D interpolate(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,double)

interpolate( (BasePointCartesian3D)arg1, (BasePointCartesian3D)arg2, (float)arg3) -> BasePointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianPoint3D interpolate(tracktable::domain::cartesian3d::CartesianPoint3D,tracktable::domain::cartesian3d::CartesianPoint3D,double)

interpolate( (TrajectoryPointCartesian3D)arg1, (TrajectoryPointCartesian3D)arg2, (float)arg3) -> TrajectoryPointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D interpolate(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,double)

tracktable.lib._domain_algorithm_overloads.intersects((BoundingBoxTerrestrial)arg1, (BoundingBoxTerrestrial)arg2) → bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::terrestrial::TerrestrialPoint>,boost::geometry::model::box<tracktable::domain::terrestrial::TerrestrialPoint>)

intersects( (object)arg1, (object)arg2) -> bool :

C++ signature :

bool intersects(std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >,std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >)

intersects( (TrajectoryTerrestrial)arg1, (TrajectoryTerrestrial)arg2) -> bool :

C++ signature :

bool intersects(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

intersects( (BoundingBoxTerrestrial)arg1, (object)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::terrestrial::TerrestrialPoint>,std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >)

intersects( (object)arg1, (BoundingBoxTerrestrial)arg2) -> bool :

C++ signature :

bool intersects(std::vector<tracktable::domain::terrestrial::TerrestrialPoint, std::allocator<tracktable::domain::terrestrial::TerrestrialPoint> >,boost::geometry::model::box<tracktable::domain::terrestrial::TerrestrialPoint>)

intersects( (BoundingBoxTerrestrial)arg1, (TrajectoryTerrestrial)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::terrestrial::TerrestrialPoint>,tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

intersects( (TrajectoryTerrestrial)arg1, (BoundingBoxTerrestrial)arg2) -> bool :

C++ signature :

bool intersects(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,boost::geometry::model::box<tracktable::domain::terrestrial::TerrestrialPoint>)

intersects( (BoundingBoxTerrestrial)arg1, (BasePointTerrestrial)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::terrestrial::TerrestrialPoint>,tracktable::domain::terrestrial::TerrestrialPoint)

intersects( (BasePointTerrestrial)arg1, (BoundingBoxTerrestrial)arg2) -> bool :

C++ signature :

bool intersects(tracktable::domain::terrestrial::TerrestrialPoint,boost::geometry::model::box<tracktable::domain::terrestrial::TerrestrialPoint>)

intersects( (BoundingBoxTerrestrial)arg1, (TrajectoryPointTerrestrial)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::terrestrial::TerrestrialPoint>,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

intersects( (TrajectoryPointTerrestrial)arg1, (BoundingBoxTerrestrial)arg2) -> bool :

C++ signature :

bool intersects(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,boost::geometry::model::box<tracktable::domain::terrestrial::TerrestrialPoint>)

intersects( (BoundingBoxCartesian2D)arg1, (BoundingBoxCartesian2D)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::cartesian2d::CartesianPoint2D>,boost::geometry::model::box<tracktable::domain::cartesian2d::CartesianPoint2D>)

intersects( (object)arg1, (object)arg2) -> bool :

C++ signature :

bool intersects(std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >,std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >)

intersects( (TrajectoryCartesian2D)arg1, (TrajectoryCartesian2D)arg2) -> bool :

C++ signature :

bool intersects(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

intersects( (BoundingBoxCartesian2D)arg1, (object)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::cartesian2d::CartesianPoint2D>,std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >)

intersects( (object)arg1, (BoundingBoxCartesian2D)arg2) -> bool :

C++ signature :

bool intersects(std::vector<tracktable::domain::cartesian2d::CartesianPoint2D, std::allocator<tracktable::domain::cartesian2d::CartesianPoint2D> >,boost::geometry::model::box<tracktable::domain::cartesian2d::CartesianPoint2D>)

intersects( (BoundingBoxCartesian2D)arg1, (TrajectoryCartesian2D)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::cartesian2d::CartesianPoint2D>,tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

intersects( (TrajectoryCartesian2D)arg1, (BoundingBoxCartesian2D)arg2) -> bool :

C++ signature :

bool intersects(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,boost::geometry::model::box<tracktable::domain::cartesian2d::CartesianPoint2D>)

intersects( (BoundingBoxCartesian2D)arg1, (BasePointCartesian2D)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::cartesian2d::CartesianPoint2D>,tracktable::domain::cartesian2d::CartesianPoint2D)

intersects( (BasePointCartesian2D)arg1, (BoundingBoxCartesian2D)arg2) -> bool :

C++ signature :

bool intersects(tracktable::domain::cartesian2d::CartesianPoint2D,boost::geometry::model::box<tracktable::domain::cartesian2d::CartesianPoint2D>)

intersects( (BoundingBoxCartesian2D)arg1, (TrajectoryPointCartesian2D)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::cartesian2d::CartesianPoint2D>,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

intersects( (TrajectoryPointCartesian2D)arg1, (BoundingBoxCartesian2D)arg2) -> bool :

C++ signature :

bool intersects(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,boost::geometry::model::box<tracktable::domain::cartesian2d::CartesianPoint2D>)

intersects( (BoundingBoxCartesian3D)arg1, (BoundingBoxCartesian3D)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::cartesian3d::CartesianPoint3D>,boost::geometry::model::box<tracktable::domain::cartesian3d::CartesianPoint3D>)

intersects( (BoundingBoxCartesian3D)arg1, (object)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::cartesian3d::CartesianPoint3D>,std::vector<tracktable::domain::cartesian3d::CartesianPoint3D, std::allocator<tracktable::domain::cartesian3d::CartesianPoint3D> >)

intersects( (object)arg1, (BoundingBoxCartesian3D)arg2) -> bool :

C++ signature :

bool intersects(std::vector<tracktable::domain::cartesian3d::CartesianPoint3D, std::allocator<tracktable::domain::cartesian3d::CartesianPoint3D> >,boost::geometry::model::box<tracktable::domain::cartesian3d::CartesianPoint3D>)

intersects( (BoundingBoxCartesian3D)arg1, (TrajectoryCartesian3D)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::cartesian3d::CartesianPoint3D>,tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>)

intersects( (TrajectoryCartesian3D)arg1, (BoundingBoxCartesian3D)arg2) -> bool :

C++ signature :

bool intersects(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>,boost::geometry::model::box<tracktable::domain::cartesian3d::CartesianPoint3D>)

intersects( (BoundingBoxCartesian3D)arg1, (BasePointCartesian3D)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::cartesian3d::CartesianPoint3D>,tracktable::domain::cartesian3d::CartesianPoint3D)

intersects( (BasePointCartesian3D)arg1, (BoundingBoxCartesian3D)arg2) -> bool :

C++ signature :

bool intersects(tracktable::domain::cartesian3d::CartesianPoint3D,boost::geometry::model::box<tracktable::domain::cartesian3d::CartesianPoint3D>)

intersects( (BoundingBoxCartesian3D)arg1, (TrajectoryCartesian3D)arg2) -> bool :

C++ signature :

bool intersects(boost::geometry::model::box<tracktable::domain::cartesian3d::CartesianPoint3D>,tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>)

intersects( (TrajectoryCartesian3D)arg1, (BoundingBoxCartesian3D)arg2) -> bool :

C++ signature :

bool intersects(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>,boost::geometry::model::box<tracktable::domain::cartesian3d::CartesianPoint3D>)

tracktable.lib._domain_algorithm_overloads.length((TrajectoryTerrestrial)arg1) → float :

C++ signature :

double length(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

length( (TrajectoryCartesian2D)arg1) -> float :

C++ signature :

double length(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

length( (TrajectoryCartesian3D)arg1) -> float :

C++ signature :

double length(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>)

tracktable.lib._domain_algorithm_overloads.norm((BasePointCartesian2D)arg1) → float :

C++ signature :

double norm(tracktable::domain::cartesian2d::CartesianPoint2D)

norm( (TrajectoryPointCartesian2D)arg1) -> float :

C++ signature :

double norm(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

norm( (BasePointCartesian3D)arg1) -> float :

C++ signature :

double norm(tracktable::domain::cartesian3d::CartesianPoint3D)

norm( (TrajectoryPointCartesian3D)arg1) -> float :

C++ signature :

double norm(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D)

tracktable.lib._domain_algorithm_overloads.point_at_length_fraction((TrajectoryTerrestrial)arg1, (float)arg2) → TrajectoryPointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialTrajectoryPoint point_at_length_fraction(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,double)

point_at_length_fraction( (TrajectoryCartesian2D)arg1, (float)arg2) -> TrajectoryPointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D point_at_length_fraction(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,double)

point_at_length_fraction( (TrajectoryCartesian3D)arg1, (float)arg2) -> TrajectoryPointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D point_at_length_fraction(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>,double)

tracktable.lib._domain_algorithm_overloads.point_at_time((TrajectoryTerrestrial)arg1, (object)arg2) → TrajectoryPointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialTrajectoryPoint point_at_time(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,boost::posix_time::ptime)

point_at_time( (TrajectoryCartesian2D)arg1, (object)arg2) -> TrajectoryPointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D point_at_time(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,boost::posix_time::ptime)

point_at_time( (TrajectoryCartesian3D)arg1, (object)arg2) -> TrajectoryPointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D point_at_time(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>,boost::posix_time::ptime)

tracktable.lib._domain_algorithm_overloads.point_at_time_fraction((TrajectoryTerrestrial)arg1, (float)arg2) → TrajectoryPointTerrestrial :

C++ signature :

tracktable::domain::terrestrial::TerrestrialTrajectoryPoint point_at_time_fraction(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,double)

point_at_time_fraction( (TrajectoryCartesian2D)arg1, (float)arg2) -> TrajectoryPointCartesian2D :

C++ signature :

tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D point_at_time_fraction(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,double)

point_at_time_fraction( (TrajectoryCartesian3D)arg1, (float)arg2) -> TrajectoryPointCartesian3D :

C++ signature :

tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D point_at_time_fraction(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>,double)

tracktable.lib._domain_algorithm_overloads.radius_of_gyration((TrajectoryTerrestrial)arg1) → float :

C++ signature :

double radius_of_gyration(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>)

radius_of_gyration( (TrajectoryCartesian2D)arg1) -> float :

C++ signature :

double radius_of_gyration(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>)

tracktable.lib._domain_algorithm_overloads.signed_turn_angle((BasePointTerrestrial)arg1, (BasePointTerrestrial)arg2, (BasePointTerrestrial)arg3) → float :

C++ signature :

double signed_turn_angle(tracktable::domain::terrestrial::TerrestrialPoint,tracktable::domain::terrestrial::TerrestrialPoint,tracktable::domain::terrestrial::TerrestrialPoint)

signed_turn_angle( (TrajectoryPointTerrestrial)arg1, (TrajectoryPointTerrestrial)arg2, (TrajectoryPointTerrestrial)arg3) -> float :

C++ signature :

double signed_turn_angle(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

signed_turn_angle( (BasePointCartesian2D)arg1, (BasePointCartesian2D)arg2, (BasePointCartesian2D)arg3) -> float :

C++ signature :

double signed_turn_angle(tracktable::domain::cartesian2d::CartesianPoint2D,tracktable::domain::cartesian2d::CartesianPoint2D,tracktable::domain::cartesian2d::CartesianPoint2D)

signed_turn_angle( (TrajectoryPointCartesian2D)arg1, (TrajectoryPointCartesian2D)arg2, (TrajectoryPointCartesian2D)arg3) -> float :

C++ signature :

double signed_turn_angle(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

tracktable.lib._domain_algorithm_overloads.simplify((TrajectoryTerrestrial)arg1, (float)arg2) → TrajectoryTerrestrial :

C++ signature :

tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint> simplify(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,double)

simplify( (TrajectoryCartesian2D)arg1, (float)arg2) -> TrajectoryCartesian2D :

C++ signature :

tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D> simplify(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,double)

simplify( (TrajectoryCartesian3D)arg1, (float)arg2) -> TrajectoryCartesian3D :

C++ signature :

tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D> simplify(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>,double)

tracktable.lib._domain_algorithm_overloads.speed_between((TrajectoryPointTerrestrial)arg1, (TrajectoryPointTerrestrial)arg2) → float :

C++ signature :

double speed_between(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

speed_between( (TrajectoryPointCartesian2D)arg1, (TrajectoryPointCartesian2D)arg2) -> float :

C++ signature :

double speed_between(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

speed_between( (TrajectoryPointCartesian3D)arg1, (TrajectoryPointCartesian3D)arg2) -> float :

C++ signature :

double speed_between(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D)

tracktable.lib._domain_algorithm_overloads.subset_during_interval((TrajectoryTerrestrial)arg1, (object)arg2, (object)arg3) → TrajectoryTerrestrial :

C++ signature :

tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint> subset_during_interval(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,boost::posix_time::ptime,boost::posix_time::ptime)

subset_during_interval( (TrajectoryCartesian2D)arg1, (object)arg2, (object)arg3) -> TrajectoryCartesian2D :

C++ signature :

tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D> subset_during_interval(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,boost::posix_time::ptime,boost::posix_time::ptime)

subset_during_interval( (TrajectoryCartesian3D)arg1, (object)arg2, (object)arg3) -> TrajectoryCartesian3D :

C++ signature :

tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D> subset_during_interval(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>,boost::posix_time::ptime,boost::posix_time::ptime)

tracktable.lib._domain_algorithm_overloads.time_at_fraction((TrajectoryTerrestrial)arg1, (float)arg2) → object :

C++ signature :

boost::posix_time::ptime time_at_fraction(tracktable::Trajectory<tracktable::domain::terrestrial::TerrestrialTrajectoryPoint>,double)

time_at_fraction( (TrajectoryCartesian2D)arg1, (float)arg2) -> object :

C++ signature :

boost::posix_time::ptime time_at_fraction(tracktable::Trajectory<tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D>,double)

time_at_fraction( (TrajectoryCartesian3D)arg1, (float)arg2) -> object :

C++ signature :

boost::posix_time::ptime time_at_fraction(tracktable::Trajectory<tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D>,double)

tracktable.lib._domain_algorithm_overloads.unsigned_turn_angle((BasePointTerrestrial)arg1, (BasePointTerrestrial)arg2, (BasePointTerrestrial)arg3) → float :

C++ signature :

double unsigned_turn_angle(tracktable::domain::terrestrial::TerrestrialPoint,tracktable::domain::terrestrial::TerrestrialPoint,tracktable::domain::terrestrial::TerrestrialPoint)

unsigned_turn_angle( (TrajectoryPointTerrestrial)arg1, (TrajectoryPointTerrestrial)arg2, (TrajectoryPointTerrestrial)arg3) -> float :

C++ signature :

double unsigned_turn_angle(tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint,tracktable::domain::terrestrial::TerrestrialTrajectoryPoint)

unsigned_turn_angle( (BasePointCartesian2D)arg1, (BasePointCartesian2D)arg2, (BasePointCartesian2D)arg3) -> float :

C++ signature :

double unsigned_turn_angle(tracktable::domain::cartesian2d::CartesianPoint2D,tracktable::domain::cartesian2d::CartesianPoint2D,tracktable::domain::cartesian2d::CartesianPoint2D)

unsigned_turn_angle( (TrajectoryPointCartesian2D)arg1, (TrajectoryPointCartesian2D)arg2, (TrajectoryPointCartesian2D)arg3) -> float :

C++ signature :

double unsigned_turn_angle(tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D,tracktable::domain::cartesian2d::CartesianTrajectoryPoint2D)

unsigned_turn_angle( (BasePointCartesian3D)arg1, (BasePointCartesian3D)arg2, (BasePointCartesian3D)arg3) -> float :

C++ signature :

double unsigned_turn_angle(tracktable::domain::cartesian3d::CartesianPoint3D,tracktable::domain::cartesian3d::CartesianPoint3D,tracktable::domain::cartesian3d::CartesianPoint3D)

unsigned_turn_angle( (TrajectoryPointCartesian3D)arg1, (TrajectoryPointCartesian3D)arg2, (TrajectoryPointCartesian3D)arg3) -> float :

C++ signature :

double unsigned_turn_angle(tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D,tracktable::domain::cartesian3d::CartesianTrajectoryPoint3D)