sc/scsl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleaning up and documenting scmp code.

Browse Source
This commit is contained in:
Kyle Isom
2023-10-20 02:59:36 -07:00
parent 4eb4008130
commit b49caa3ec9
12 changed files with 343 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
include/scmp/Math.h
View File

@@ -31,11 +31,10 @@
namespace scmp {
/// MAX_RADIAN is a precomputed 2 * M_PI. and MIN_RADIAN is -2 * M_PI.
/// MAX_RADIAN is a precomputed 2 * M_PI.
constexpr double MAX_RADIAN = 2 * M_PI;
constexpr double MIN_RADIAN = -2 * M_PI;
constexpr double POS_HALF_RADIAN = M_PI / 2;
constexpr double NEG_HALF_RADIAN = -(M_PI / 2);
constexpr double PI_D = 3.141592653589793;
/// Roll m die of n sides, returning a vector of the dice.
@@ -48,50 +47,65 @@ int DieTotal(int m, int n);
int BestDie(int k, int m, int n);
/// Convert radians to degrees.
/// @param rads the angle in radians
/// @return the angle in degrees.
/// \brief Convert radians to degrees.
///
/// \param rads the angle in radians
/// \return the angle in degrees.
float RadiansToDegreesF(float rads);
/// Convert radians to degrees.
/// @param rads the angle in radians
/// @return the angle in degrees.
/// \brief Convert radians to degrees.
///
/// \param rads the angle in radians
/// \return the angle in degrees.
double RadiansToDegreesD(double rads);
/// Convert degrees to radians.
/// @param degrees the angle in degrees
/// @return the angle in radians.
/// \brief Convert degrees to radians.
///
/// \param degrees the angle in degrees
/// \return the angle in radians.
float DegreesToRadiansF(float degrees);
/// Convert degrees to radians.
/// @param degrees the angle in degrees
/// @return the angle in radians.
/// \brief Convert degrees to radians.
///
/// \param degrees the angle in degrees
/// \return the angle in radians.
double DegreesToRadiansD(double degrees);
/// RotateRadians rotates theta0 by theta1 radians, wrapping the result to
/// MIN_RADIAN <= result <= MAX_RADIAN.
/// \brief RotateRadians rotates theta0 by theta1 radians, wrapping
/// the result to MIN_RADIAN <= result <= MAX_RADIAN.
///
/// \param theta0
/// \param theta1
/// \return
double RotateRadians(double theta0, double theta1);
/// Get the default epsilon value.
/// @param epsilon The variable to store the epsilon value in.
/// \brief Get the default epsilon value.
///
/// \param epsilon The variable to store the epsilon value in.
void DefaultEpsilon(double &epsilon);
/// Get the default epsilon value.
/// @param epsilon The variable to store the epsilon value in.
///
/// \param epsilon The variable to store the epsilon value in.
void DefaultEpsilon(float &epsilon);
/// Return whether the two values of type T are equal to within some tolerance.
/// @tparam T The type of value
/// @param a A value of type T used as the left-hand side of an equality check.
/// @param b A value of type T used as the right-hand side of an equality check.
/// @param epsilon The tolerance value.
/// @return Whether the two values are "close enough" to be considered equal.
/// \brief Return whether the two values of type T are equal to within
/// some tolerance.
///
/// \tparam T The type of value
/// \param a A value of type T used as the left-hand side of an
/// equality check.
/// \param b A value of type T used as the right-hand side of an
/// equality check.
/// \param epsilon The tolerance value.
/// \return Whether the two values are "close enough" to be considered
/// equal.
template <typename T>
static T
WithinTolerance(T a, T b, T epsilon)
{
return std::abs(a - b) < epsilon;
return std::abs(a - b) <= epsilon;
}

6
include/scmp/filter/Madgwick.h
View File

@@ -55,7 +55,6 @@ public:
Madgwick() : deltaT(0.0), previousSensorFrame(), sensorFrame()
{};
/// \brief The Madgwick filter is initialised with a sensor frame.
///
/// \param sf A sensor frame; if zero, the sensor frame will be
@@ -67,7 +66,6 @@ public:
}
}
/// \brief Initialise the filter with a sensor frame quaternion.
///
/// \param sf A quaternion representing the current Orientation.
@@ -75,7 +73,6 @@ public:
deltaT(0.0), previousSensorFrame(), sensorFrame(sf)
{};
/// \brief Return the current orientation as measured by the
/// filter.
///
@@ -86,7 +83,6 @@ public:
return this->sensorFrame;
}
/// \brief Return the filter's rate of angular change from a
/// sensor frame.
///
@@ -152,7 +148,6 @@ public:
this->UpdateFrame(this->sensorFrame + q, delta);
}
/// \brief Update the sensor frame with a gyroscope reading.
///
/// If no Δt is provided, the filter's default is used.
@@ -168,7 +163,6 @@ public:
this->UpdateAngularOrientation(gyro, this->deltaT);
}
/// \brief Retrieve a vector of the Euler angles in ZYX Orientation.
///
/// \return A vector of Euler angles as <ψ, θ, ϕ>.

43
include/scmp/geom.h Normal file
View File

@@ -0,0 +1,43 @@
///
/// \file include/scmp/geom.h
/// \author K. Isom <kyle@imap.cc>
/// \date 2023-10-20
/// \brief 2D point and polar coordinate systems.
///
/// Copyright 2023 K. Isom <kyle@imap.cc>
///
/// Permission to use, copy, modify, and/or distribute this software for
/// any purpose with or without fee is hereby granted, provided that
/// the above copyright notice and this permission notice appear in all /// copies.
///
/// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
/// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
/// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
/// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
/// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
/// OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
/// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
/// PERFORMANCE OF THIS SOFTWARE.
///
#ifndef SCSL_GEOM_H
#define SCSL_GEOM_H
#include <scmp/geom/Coord2D.h>
#include <scmp/geom/Orientation.h>
#include <scmp/geom/Quaternion.h>
#include <scmp/geom/Vector.h>
namespace scmp {
/// \brief Geometry-related code.
namespace geom {}
} // namespace scmp
#endif // SCSL_GEOM_H

115
include/scmp/geom/Coord2D.h
View File

@@ -1,29 +1,29 @@
/// coord2d.h defines 2D point and polar coordinate systems.
//
// Project: scccl
// File: include/math/coord2d.h
// Author: Kyle Isom
// Date: 2017-06-05
// Namespace: math::geom
//
// coord2d.h defines 2D coordinate classes and functions.
//
// Copyright 2017 Kyle Isom <kyle@imap.cc>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
///
/// \file include/scmp/geom/Coord2D.h
/// \author K. Isom <kyle@imap.cc>
/// \date 2017-06-05
/// \brief 2D point and polar coordinate systems.
///
/// Copyright 2017 K. Isom <kyle@imap.cc>
///
/// Permission to use, copy, modify, and/or distribute this software for
/// any purpose with or without fee is hereby granted, provided that
/// the above copyright notice and this permission notice appear in all /// copies.
///
/// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
/// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
/// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
/// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
/// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
/// OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
/// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
/// PERFORMANCE OF THIS SOFTWARE.
///
#ifndef SCMATH_GEOM_COORD2D_H
#define SCMATH_GEOM_COORD2D_H
#include <cmath>
#include <ostream>
#include <vector>
@@ -34,72 +34,81 @@ namespace geom {
class Point2D;
class Polar2D;
// Point2D is a logical grouping of a set of 2D cartesian coordinates.
/// \brief Point2D is a logical grouping of a set of 2D cartesian
/// coordinates.
class Point2D {
public:
int x, y;
public:
int x, y;
// A Point2D can be initialised by setting its members to 0, by providing the
// x and y coordiantes, or through translation from a polar coordinate.
Point2D() : x(0), y(0) {}
Point2D(int _x, int _y) : x(_x), y(_y) {}
Point2D(const Polar2D&);
// A Point2D can be initialised by setting its members to 0, by providing the
// x and y coordiantes, or through translation from a polar coordinate.
Point2D();
Point2D(int _x, int _y);
Point2D(const Polar2D &);
std::string ToString(void);
void ToPolar(Polar2D&);
std::string ToString();
void ToPolar(Polar2D &);
// Rotate rotates the point by theta radians. Alternatively, a rotation
// can use this point as the centre, with a polar coordinate and a rotation
// amount (in radians). The latter is used to specify a central point
// of rotation with vertices specified as polar coordinates from the centre.
// Both forms take a reference to a Point2D to store the rotated point.
void Rotate(Point2D& rotated, double theta);
void Rotate(Point2D &rotated, double theta);
std::vector<Point2D> Rotate(std::vector<Polar2D>, double);
// Translate adds this point to the first argument, storing the result in the
// second argument.
void Translate(const Point2D& other, Point2D& translated);
void Translate(const Point2D &other, Point2D &translated);
// Distance returns the distance from this point to another.
int Distance(const Point2D& other);
int Distance(const Point2D &other);
Point2D operator+(const Point2D &rhs) const { return Point2D(x + rhs.x, y + rhs.y); }
Point2D operator-(const Point2D &rhs) const { return Point2D(x - rhs.x, y - rhs.y); }
Point2D operator*(const int k) const { return Point2D(x * k, y * k); }
bool operator==(const Point2D& rhs) const;
bool operator!=(const Point2D& rhs) const { return !(*this == rhs); }
friend std::ostream& operator<<(std::ostream& outs, const Point2D& pt);
Point2D operator+(const Point2D &rhs) const
{ return Point2D(x + rhs.x, y + rhs.y); }
Point2D operator-(const Point2D &rhs) const
{ return Point2D(x - rhs.x, y - rhs.y); }
Point2D operator*(const int k) const
{ return Point2D(x * k, y * k); }
bool operator==(const Point2D &rhs) const;
bool operator!=(const Point2D &rhs) const
{ return !(*this == rhs); }
friend std::ostream &operator<<(std::ostream &outs, const Point2D &pt);
};
// A Polar2D is a 2D polar coordinate, specified in terms of the radius from
// some origin and the angle from the positive X axis of a cartesian coordinate
// system.
class Polar2D {
public:
double r, theta;
public:
double r, theta;
// A Polar2D can be initialised as a zeroised polar coordinate, by specifying
// the radius and angle directly, or via conversion from a Point2D.
Polar2D() : r(0.0), theta(0.0) {}
Polar2D(double _r, double _theta) : r(_r), theta(_theta) {}
Polar2D(const Point2D&);
Polar2D() : r(0.0), theta(0.0)
{}
Polar2D(double _r, double _theta) : r(_r), theta(_theta)
{}
Polar2D(const Point2D &);
std::string ToString();
void ToPoint(Point2D&);
void ToPoint(Point2D &);
// Rotate rotates the polar coordinate by the number of radians, storing the result
// in the Polar2D argument.
void Rotate(Polar2D&, double);
void Rotate(Polar2D &, double);
// RotateAround rotates this point about by theta radians, storing the rotated point
// in result.
void RotateAround(const Point2D& other, Point2D& result, double tjeta);
void RotateAround(const Point2D &other, Point2D &result, double tjeta);
bool operator==(const Polar2D&) const;
bool operator!=(const Polar2D& rhs) const { return !(*this == rhs); }
friend std::ostream& operator<<(std::ostream&, const Polar2D&);
bool operator==(const Polar2D &) const;
bool operator!=(const Polar2D &rhs) const
{ return !(*this == rhs); }
friend std::ostream &operator<<(std::ostream &, const Polar2D &);
};

7
include/scmp/scmp.h
View File

@@ -25,9 +25,10 @@
/// \brief Shimmering Clarity Math & Physics toolkit.
namespace scmp {
} // namespace scmp
///
/// The Shimmering Clarity contains code related to math and physics,
/// particularly as relevant to game programming and robotics.
namespace scmp {}
#endif //SCSL_SCMP_H