found Namespace Reference

Classes
class	Action
class	Attitude
class	Camera
class	DistanceDeterminationAlgorithm
class	EdgeDetectionAlgorithm
class	EllipticalOrbitDerminationAlgorithm
class	EllipticDistanceDeterminationAlgorithm
class	EulerAngles
class	EulerianKinematicProfilingAlgorithm
class	FeatureDetectionVectorGenerationAlgorithm
struct	Image
class	KeplerKinematicProfilingAlgorithm
class	KinematicProfilingAlgorithm
class	LoCEdgeDetectionAlgorithm
class	LOSTVectorGenerationAlgorithm
class	Mat3
class	OrbitDeterminationAlgorithm
struct	OrbitParams
class	Pipeline
class	PrecessionOrbitDeterminationAlgorithm
class	Quaternion
class	SimpleEdgeDetectionAlgorithm
class	SphericalDistanceDeterminationAlgorithm
class	Stage
struct	Vec2
class	Vec3
class	VectorGenerationAlgorithm

Typedefs
typedef std::vector< Vec2 >	Points
typedef decimal	distFromEarth
typedef Vec3	PositionVector
typedef struct OrbitParams	OrbitParams
typedef std::pair< std::function< Vec3(int)>, std::function< Vec3(int)> >	KinematicPrediction

Functions
decimal	strtodecimal (const std::string &str)
EulerAngles	strtoea (const std::string &str)
bool	strtobool (const std::string &str)
int	main (int argc, char **argv)
CalibrationOptions	ParseCalibrationOptions (int argc, char **argv)
DistanceOptions	ParseDistanceOptions (int argc, char **argv)
OrbitOptions	ParseOrbitOptions (int argc, char **argv)
Quaternion	SphericalToQuaternion (decimal ra, decimal dec, decimal roll)
Vec3	SphericalToSpatial (const decimal ra, const decimal de)
void	SpatialToSpherical (const Vec3 &vec, decimal &ra, decimal &de)
decimal	RadToDeg (decimal rad)
decimal	DegToRad (decimal deg)
decimal	RadToArcSec (decimal rad)
decimal	ArcSecToRad (decimal arcSec)
decimal	Angle (const Vec3 &vec1, const Vec3 &vec2)
decimal	AngleUnit (const Vec3 &vec1, const Vec3 &vec2)
decimal	Distance (const Vec2 &v1, const Vec2 &v2)
decimal	Distance (const Vec3 &v1, const Vec3 &v2)
Mat3	QuaternionToDCM (const Quaternion &quat)
Quaternion	DCMToQuaternion (const Mat3 &dcm)
int64_t	SerializeLengthVec3 ()
void	SerializeVec3 (const Vec3 &vec, unsigned char *buffer)
Vec3	DeserializeVec3 (const unsigned char *buffer)
decimal	FovToFocalLength (decimal xFov, decimal xResolution)
decimal	FocalLengthToFov (decimal focalLength, decimal xResolution, decimal pixelSize)

Variables
const char	kNoDefaultArgument = 0
	For macro processing.
const Mat3	kIdentityMat3
	3x3 identity matrix

Detailed Description

This file controls all stylistic-related choices for FOUND (except for decimal)

Typedef Documentation

distFromEarth

typedef decimal found::distFromEarth

The output for Distance Determination Algorithms (distance.hpp/cpp). Currently set to a floating point value that represents the distance from Earth

KinematicPrediction

typedef std::pair<std::function<Vec3(int)>,std::function<Vec3(int)> > found::KinematicPrediction

The output for Kinematic Profile Completion. Currently set to two functions that will tell you the position and velocity of the satellite at any given time

OrbitParams

typedef struct OrbitParams found::OrbitParams

The output for Orbit Trajectory Calculation Algorithms. Currently set to a struct that holds the orbit equations.

Points

typedef std::vector<Vec2> found::Points

The output for Edge Detection Algorithms (edge.hpp/cpp). Currently set to a vector of 2D points on the image, according to image coordinate systems

PositionVector

typedef Vec3 found::PositionVector

The output for Vector Assembly Algorithms (vectorize.hpp). Currently set to a 3D Vector that represents the satellite's position relative to Earth's coordinate system.

Function Documentation

Angle()

decimal found::Angle	(	const Vec3 &	vec1,
		const Vec3 &	vec2
	)

Determines the angle between two different vectors

Parameters

vec1	The first vector
vec2	The second vector

Returns

The angle, in radians, between vec1 and vec2

AngleUnit()

decimal found::AngleUnit	(	const Vec3 &	vec1,
		const Vec3 &	vec2
	)

Determines the angle between two different vectors

Parameters

vec1	The first vector
vec2	The second vector

Returns

The angle, in radians, between vec1 and vec2

Precondition

The magnitude of vec1 and vec2 are 1

Warning

vec1 and vec2 must have a magnitude of 1

ArcSecToRad()

decimal found::ArcSecToRad

(

decimal

arcSec

)

Calculates an angle from an inverse secant value

Parameters

arcSec

The arcsecant value

Returns

A possible angle value, in radians, corresponding to the arcsecant value arcSec

DCMToQuaternion()

Quaternion found::DCMToQuaternion

(

const Mat3 &

dcm

)

Creates a Quaternion based on a Direction Cosine Matrix (rotation matrix)

Parameters

dcm	The matrix holding the direction cosines

Returns

A Quaternion that expresses the rotation defined in dcm

DegToRad()

decimal found::DegToRad

(

decimal

deg

)

Converts an angle in degrees to radians

Parameters

deg	The degrees of the angle

Returns

The radians of the angle

DeserializeVec3()

Vec3 found::DeserializeVec3

(

const unsigned char *

buffer

)

Deserializes a Vec3 from a buffer

Parameters

buffer

The buffer to obtain the vector from. This parameter should point to the location of the Vec3 within the buffer.

Returns

A Vec3 representing the Vec3 stored in the buffer

Precondition

buffer points to a valid location storing a Vec3

Warning

Returns nonsense if buffer does not point to a valid location that stores a Vec3

Distance() [1/2]

decimal found::Distance	(	const Vec2 &	v1,
		const Vec2 &	v2
	)

Determines the distance between two vectors

Parameters

v1	The first vector
v2	The second vector

Returns

The distance between v1 and v2

Distance() [2/2]

decimal found::Distance	(	const Vec3 &	v1,
		const Vec3 &	v2
	)

Determines the distance between two vectors

Parameters

v1	The first vector
v2	The second vector

Returns

The distance between v1 and v2

FocalLengthToFov()

decimal found::FocalLengthToFov	(	decimal	focalLength,
		decimal	xResolution,
		decimal	pixelSize
	)

Provides the FOV of a camera for given parameters

Parameters

focalLength	The focal length
xResolution	The horizontal resolution
pixelSize	The size of a pixel in a Camera

Returns

The FOV of a camera with a given focalLength, xResolution, and pixelSize

FovToFocalLength()

decimal found::FovToFocalLength	(	decimal	xFov,
		decimal	xResolution
	)

Provides the focal length of a camera for given parameters

Parameters

xFov	The horizontal field of view
xResolution	The horizontal resolution

Returns

The focal length of a camera with a given xFov and xResolution

main()

int found::main	(	int	argc,
		char **	argv
	)

This is where the program starts.

Parameters

argc	The number of arguments passed into the command line
argv	The arguments passed into the command line

Returns

An integer indicating success (0) iff the program executes successfully

Note

The method itself uses command line arguments to generate an Options object that represents all the algorithms we want to run and their parameters

ParseCalibrationOptions()

CalibrationOptions found::ParseCalibrationOptions	(	int	argc,
		char **	argv
	)

Parses the calibration options from the command line to run the calibration algorithm

Parameters

argc	The number of command-line arguments
argv	The command line arguments

Returns

CalibrationOptions The options for the calibration algorithm as extracted on the command line

ParseDistanceOptions()

DistanceOptions found::ParseDistanceOptions	(	int	argc,
		char **	argv
	)

Parses the distance options from the command line to run the distance determination algorithm

Parameters

argc	The number of command-line arguments
argv	The command line arguments

Returns

DistanceOptions The options for the distance determination algorithm as extracted on the command line

ParseOrbitOptions()

OrbitOptions found::ParseOrbitOptions	(	int	argc,
		char **	argv
	)

Parses the orbit options from the command line to run the orbit determination algorithm

Parameters

argc	The number of command-line arguments
argv	The command line arguments

Returns

OrbitOptions The options for the orbit determination algorithm as extracted from the command line

QuaternionToDCM()

Mat3 found::QuaternionToDCM

(

const Quaternion &

quat

)

Creates a Direction Cosine Matrix (DCM) off of a Quaternion.

Parameters

quat	The quaternion to base the DCM off of

Returns

A Matrix holding the direction cosines of a particular attitude (orientation)

Note

A DCM is also a rotation matrix. If B is a DCM, multiplying B by Vector v will result in vector u where u is v rotated to the angles that the direction cosines hold.

RadToArcSec()

decimal found::RadToArcSec

(

decimal

rad

)

Calculates the approximate value for the inverse secant of an angle

Parameters

rad	The angle, in radians

Returns

The arcsecant of the angle

Precondition

rad is in radians

Warning

rad must be in radians

RadToDeg()

decimal found::RadToDeg

(

decimal

rad

)

Converts an angle in radians to degrees

Parameters

rad	The rad of the angle

Returns

The degrees of the angle

SerializeLengthVec3()

int64_t found::SerializeLengthVec3

(

)

Computes the size, in bytes, that a Vec3 object will take up

Returns

The number of bytes that a Vec3 occupies

SerializeVec3()

void found::SerializeVec3	(	const Vec3 &	vec,
		unsigned char *	buffer
	)

Serializes a Vec3 into a buffer.

Parameters

vec	The vector to serialize.
buffer	The buffer to insert the vector into

Postcondition

The parameter buffer will hold vec after the operation of this function.

Note

A buffer is a very long character array that holds information that the user defines. Serialization of data means inputting certain data into a buffer.

SpatialToSpherical()

void found::SpatialToSpherical	(	const Vec3 &	vec,
		decimal &	ra,
		decimal &	de
	)

Converts a unit vector on the unit sphere to a spherical direction

Parameters

vec	The vector to convert from
ra	The right ascension that will represent the right ascension of vec
de	The declination that will represent the declination of vec

Postcondition

This function's output are the parameters ra and de, and those parameters are modified after this function runs.

SphericalToQuaternion()

Quaternion found::SphericalToQuaternion	(	decimal	ra,
		decimal	dec,
		decimal	roll
	)

Converts Euler Angles into a quaternion

Parameters

ra	The right ascension of the Euler Angles
dec	The declination of the Euler Angles
roll	The roll of the Euler Angles

Returns

A Quaternion representing this collection of Euler Angles

Note

Returned Quaternion will reorient the coordinate axes so that the x-axis points at the given right ascension and declination, then roll the coordinate axes counterclockwise (i.e., the stars will appear to rotate clockwise). This is an "improper" z-y'-x' Euler rotation.

SphericalToSpatial()

Vec3 found::SphericalToSpatial	(	const decimal	ra,
		const decimal	de
	)

Converts spherical direction to a unit vector on the unit sphere

Parameters

ra	The right ascension of the direction in question
de	The declination of the direction in question

Returns

A 3D unit vector that represents the vector on the unit sphere corresponding to this direction

strtobool()

bool found::strtobool ( const std::string &  str )

inline

Converts the string to a bool

Parameters

str	The string to convert

Returns

true iff the string represents a true value

strtodecimal()

decimal found::strtodecimal ( const std::string &  str )

inline

Converts a string to a decimal

Parameters

str	The string to convert

Returns

The decimal numeber this string represents

Precondition

The str must actually represent a decimal

strtoea()

EulerAngles found::strtoea ( const std::string &  str )

inline

Converts a string to euler angles.

Parameters

str	The string to convert

Returns

An EulerAngle corresponding to the string, if the str is valid

Precondition

The string must have 3 decimal values seperated by commas or spaces

Variable Documentation

kIdentityMat3

const Mat3 found::kIdentityMat3

Initial value:

= {1,0,0,
                            0,1,0,
                            0,0,1}

3x3 identity matrix