| AccessError | Thrown if a function makes a request of the OS that can't be satisfied |
| Adler32 | This class is used to generate an Alder-32 checksum for a sequence of bytes |
| AllanDeviation | Compute the overlapping Allan variance of the phase data provided |
| AlmOrbit | Encapsulation of almanac SV orbital parameters (page 5, subframes 1-24) |
| ANSITime | This class encapsulates the "ANSITime (seconds since Unix epoch)" time representation |
| Antenna | This class encapsulates the data related to GNSS antennas according to IGS standards |
| AntexBase | This level isn't serving any purpose other than to make the class diagram look nice.. |
| AntexData | Antex antenna data record: PCOs and PCVs for one antenna |
| AntexData::antennaPCOandPCVData | Class encapsulating the PCOs and PCVs of the antenna |
| AntexHeader | This class models the header for an ANTEX antenna file |
| AntexReader | This is a class to read and parse antenna data in Antex file format |
| AntexStream | This class reads an Antex files |
| AshtechALB | |
| AshtechData | |
| AshtechEPB | |
| AshtechMBEN | |
| AshtechMBEN::code_block | |
| AshtechPBEN | |
| AshtechStream | This is a stream used to decode data in the Ashtech format |
| AssertionFailure | Thrown when a required condition in a function is not met |
| ATSData | This class contains header information for all data types transmitted by receiver meeting the MDP specification |
| ATSData::ChannelBlock | |
| ATSData::SubChannelBlock | |
| ATSStream | This is a stream used to decode data in the MDP format |
| Axis | This class is used to draw a simple axis |
| AxisStyle | This class is used to describe an Axis's style |
| Bancroft | This class defines an algebraic algorithm to get an initial guess of GPS receiver's position given satellites' positions and pseudoranges |
| Base64Encoder | This is used to encode a string in base64 |
| BaseDistribution | This is a base class for statistical distributions |
| BasicFramework | This is a (very) basic framework for programs in the GPS toolkit |
| BasicModel | This is a class to compute the basic parts of a GNSS model, like geometric distance, relativity correction, satellite position and velocity at transmission time, satellite elevation and azimuth, etc |
| BasicShape | This is an interface for basic shapes to group them together |
| BinexData | This class stores, reads, and writes BINEX records |
| BinexData::MGFZI | A signed integer stored using 1, 2, 3, 4, 5, 6, 7, or 8 bytes to represent integers from about -1.15292e18 to +1.15292e18 using a modified version of a compression scheme developed by GFZ, plus using "special" numbers to flag certain conditions, such as using the 1-byte MFGZI to store "-0" to indicate "no value." |
| BinexData::UBNXI | An unsigned integer stored using 1, 2, 3, or 4 bytes to represent integers from 0 to 536870911; used to represent BINEX record IDs, subrecord IDs, field IDs, and so on |
| BinexDataOperatorEquals | Determine if two BinexData objects are equal |
| BinexStream | This class performs file i/o on a BINEX file for the BinexData classes |
| Bitmap | This class defines a simple rectangle |
| BivarStats | Conventional statistics for two samples |
| BLQDataReader | This is a class to read and parse ocean tides harmonics data in BLQ file format |
| BorderLayout | Assists in arranging a new frame within a given one, with a margin |
| Canvas | This is an abstract class for canvases in which you can draw |
| CheckPRData | This class checks that pseudorange data is between reasonable values |
| Chi2Distribution | This class implements the Chi-square distribution |
| Cholesky | Compute cholesky decomposition (upper triangular square root) of the given matrix, which must be positive definite |
| CholeskyCrout | Compute the Cholesky decomposition using the Cholesky-Crout algorithm, which is very fast; if A is the given matrix we will get L, where A = L*LT |
| Circle | This class defines a simple circle |
| CivilTime | This class encapsulates the representation of time consisting of year, month, day (of month), hour (of day), minute (of hour), and second (of minute) |
| ClockModel | |
| CodeBuffer | P(Y)-code Buffer class |
| CodeKalmanSolver | This class computes the code-based solution using a simple Kalman solver |
| CodeSmoother | This class smoothes a given code observable using the corresponding phase observable |
| Color | This class defines a color |
| ColorMap | This class represents a 2d pixel map of colors |
| Combinations | Class Combinations will compute C(n,k), all the combinations of n things taken k at a time (where k <= n) |
| CommandOption | This class is part of a replacement for getopt |
| CommandOptionAllOf | This is a special "command option" which is really a meta-option to make sure that if one of a set of real options has been used, all of the set are used |
| CommandOptionDependent | This is a special "command option" which is really a meta-option to make sure that a required option is set where the requirement is based on another option (that is, if you specify one, you must have specified another) |
| CommandOptionGroupAnd | This is a special "command option" which is really a meta-option to group other options together for use in other meta-options |
| CommandOptionGroupOr | This is a special "command option" which is really a meta-option to group other options together for use in other meta-options |
| CommandOptionMutex | This is a special "command option" which is really a meta-option to enforce mutual exclusion between a set of real options |
| CommandOptionNoArg | A subclass of CommandOption that has no arguments |
| CommandOptionOneOf | This is a special "command option" which is really a meta-option to make sure at least one of a set of real options has been used |
| CommandOptionParser | This class parses the command line options and modifies the corresponding CommandOptions |
| CommandOptionRest | It only makes sense to have a single one of these set. CommandOption to take the rest of the command line |
| CommandOptionWithAnyArg | A CommandOption that requires a string argument |
| CommandOptionWithArg | A subclass of CommandOption that has an argument |
| CommandOptionWithCommonTimeArg | Command-line option class for processing time strings. This class is allows the programmer to add command-line options to an application that can parse strings containing representations of time. The programmer must specify the format to be accepted. Refer to each TimeTag class' getDefaultFormat() for details on the formatting specifications |
| CommandOptionWithNumberArg | A CommandOption that requires a numeric argument |
| CommandOptionWithPositionArg | Command-line option class for processing position strings. This class allows the programmer to add command-line options to an application that can parse strings containing representations of position. The programmer must specify the format to be accepted. Refer to Position::printf() for details on the formatting specifications |
| CommandOptionWithSimpleTimeArg | |
| CommandOptionWithStringArg | A CommandOption that requires a string argument |
| CommandOptionWithTimeArg | Command-line option class for processing time strings. This class is allows the programmer to add command-line options to an application that can parse strings containing representations of time. The programmer must specify the format to be accepted. Refer to DayTime::printf() for details on the formatting specifications |
| Comment | This class defines a simple comment |
| CommonTime | This is the common time format that all time formats convert to when converting between themselves |
| ComputeCombination | This class eases computing combination of data for GNSS data structures |
| ComputeDOP | This class computes the usual DOP values: GDOP, PDOP, TDOP, HDOP and VDOP |
| ComputeIURAWeights | This class computes satellites weights based on URA Index |
| ComputeLC | This class eases computing LC combination for GNSS data structures |
| ComputeLdelta | This class eases computing Ldelta combination for GNSS data structures |
| ComputeLI | This class eases computing LI combination for GNSS data structures |
| ComputeLinear | This class computes linear combinations of GDS data |
| ComputeMelbourneWubbena | This class eases computing Melbourne-Wubbena combination for GNSS data structures |
| ComputeMOPSWeights | This class computes satellites weights based on the Appendix J of MOPS C |
| ComputePC | This class eases computing PC combination for GNSS data structures |
| ComputePdelta | This class eases computing Pdelta combination for GNSS data structures |
| ComputePI | This class eases computing PI combination for GNSS data structures |
| ComputeSatPCenter | This class computes the satellite antenna phase correction, in meters |
| ComputeTropModel | This is a class to compute the main values related to a given GNSS tropospheric model |
| ComputeWindUp | This class computes the wind-up effect on the phase observables, in radians |
| ConfDataReader | This is a class to parse and manage configuration data files |
| ConfigurationException | Application's configuration is invalid |
| ConfigureLOG | Class ConfigureLOG - inherits class Log with type ConfigureLOGstream |
| ConfigureLOGstream | Class ConfigureLOGstream Configure and write to a log stream; type-safe, thread-safe and very portable |
| ConstMatrixBase | A matrix base class for a non-modifiable matrix |
| ConstMatrixColSlice | Constant slice of a single column from a matrix |
| ConstMatrixRowSlice | Unmodifiable row slice of a matrix |
| ConstMatrixSlice | An unmodifiable matrix slice |
| ConstMatrixSliceBase | Base class for an unmodifiable matrix slice |
| ConstVectorBase | A base class for a vector that does not allow modification of the internal vector |
| ConstVectorSlice | A Vector<T> slice that doesn't allow modification |
| ConstVectorSliceBase | A vector slice base class that doesn't allow modification of the internal elements |
| CorrectedEphemerisRange | Class CorrectedEphemerisRange |
| CorrectObservables | This class corrects observables from effects such as antenna excentricity, difference in phase centers, offsets due to tidal effects, etc |
| CRC32 | This class is used to generate a CRC-32 checksum for a sequence of bytes |
| CRCDataStatus | |
| CRCException | This is thrown when there is an error processing a CRC |
| CRCParam | Encapsulate parameters for CRC computation |
| DataStatus | |
| DayTime | A time representation class for all common time formats, including GPS |
| DayTime::DayTimeException | |
| DayTime::FormatException | |
| DayTimeNotFound | Thrown when attempting to access a value and the corresponding epoch (DayTime) does not exist in the map |
| DDid | |
| Decimate | This class decimates GNSS Data Structures data |
| DecimateEpoch | Thrown when some epoch data must be decimated |
| DecodeBits | DecodeBits |
| DecodeQuant | DecodeQuant contains the information necessary to decode a given quantity for a particular navigation message subframe |
| DeltaOp | This class applies the Delta operator (differences on ground-related data) to GNSS data structures |
| DOP | This class encapsulates the computation of DOP, given the Covariance matrix of an equation system |
| Dumper | This class dumps the values inside a GNSS Data Structure (GDS), and therefore is meant to be used with the GDS objects found in "DataStructures" class |
| EarthOrientation | Earth orientation parameters |
| ECEF | Earth centered, earth fixed geodetic coordinates in meters |
| EclipsedSatFilter | This class filters out satellites that are eclipsed by Earth shadow |
| EllipsoidModel | This abstract class encapsulates ellipsoid models (e.g |
| EndOfFile | This gets thrown if a valid EOF occurs on formattedGetLine |
| EngAlmanac | Almanac information for the GPS constellation |
| EngAlmanac::SVNotPresentException | Exception - requested almanac page that wasn't present |
| EngEphemeris | Ephemeris information for a single satellite |
| EngNav | Base class for ICD-GPS-200 navigation messages |
| ENUUtil | A utility for converting from Cartesian in XZY to East-North-Up (ENU) |
| EOPPrediction | Earth orientation parameter prediction Read data from EOPP###.txt file, available from NGA |
| EOPStore | Earth orientation parameter store |
| EphReader | |
| Epoch | |
| Epoch::EpochException | |
| Epoch::FormatException | |
| EpochClockModel | |
| EPSImage | This class generate a vector image in the Encapsulated Postscript (EPS) file format version 3.0 |
| Equation | GNSS Data Structure to define and handle 'descriptions' of GNSS equations |
| equationHeader | Defines a header containing basic equation data |
| EquationSystem | This class defines and handles complex equation systems for solvers, generating the Vectors and Matrices they will need, including: |
| Exception | Base class from which all exception objects thrown in the library are derived |
| ExceptionLocation | A class for recording locations (in the source code) of exceptions being thrown |
| Expression | |
| ExpressionException | This class provides the ability to resolve general mathematical expressions at run time |
| ExtractC1 | This class eases C1 data extraction from a RinexObsData object |
| ExtractCombinationData | This class eases the extraction of a combination of data from a RinexObsData object |
| ExtractD1 | This class eases D1 data extraction from a RinexObsData object |
| ExtractD2 | This class eases D2 data extraction from a RinexObsData object |
| ExtractData | This is the base class to ease data extraction from a RinexObsData object |
| ExtractL1 | This class eases L1 data extraction from a RinexObsData object |
| ExtractL2 | This class eases L2 data extraction from a RinexObsData object |
| ExtractLC | This class eases LC combination data extraction from a RinexObsData object |
| ExtractP1 | This class eases P1 data extraction from a RinexObsData object |
| ExtractP2 | This class eases P2 data extraction from a RinexObsData object |
| ExtractPC | This class eases PC combination data extraction from a RinexObsData object |
| FFBinaryStream | This is an FFStream that is required to be binary |
| FFData | This is the base class for all Formatted File Data (FFData) |
| FFIdentifier | |
| FFStream | Formatted File Stream (FFStream) |
| FFStreamError | FFStreamError is an exception for when the file read doesn't match the specs for that file type |
| FFTextStream | An FFStream is meant for reading text |
| FICAStream | This is a stream used to obtain data from an ascii FIC File |
| FICBase | This is a base class for all FIC-related classes |
| FICData | This does all the grunt-work in reading/decoding FIC-formatted files (ASCII And Binary) |
| FICData109 | |
| FICData162 | |
| FICData62 | |
| FICData9 | |
| FICDataFilterBlock | Removes all data that doesn't match the given block numbers |
| FICDataFilterPRN | Removes all data that doesn't match the given SVID/PRN numbers |
| FICDataFindBlock | Finds all data that matches the given block numbers |
| FICDataOperatorLessThanBlock109 | Sorting only for block 109 FICData |
| FICDataOperatorLessThanBlock9 | Sorting only for block 9 FICData |
| FICDataOperatorLessThanFull | Useful for FICDiff and others.. |
| FICDataUniqueBlock109 | Uniqueness operator for block 109 FIC data |
| FICDataUniqueBlock162 | Uniqueness operator for block 162 FIC data |
| FICDataUniqueBlock62 | Uniqueness operator for block 62 FIC data |
| FICDataUniqueBlock9 | Uniqueness operator for block 9 FIC data |
| FICHeader | This is the Header for the FIC File Model |
| FICStream | This is a stream used to obtain data from a binary FIC File |
| FICStreamBase | Encapsulates FIC stream data for FIC and FICA files |
| FileFilter | This class is a framework for sorting and filtering file data |
| FileFilter::SortAdapter | SortAdapter is an adapter class that takes any comparison function and instead uses list iterator objects instead of FileData |
| FileFilterFrame | This class is a wrapper for FileHunter and FileFilter, allowing you to easily pick what files you want to process and how to process them |
| FileFilterFrameWithHeader | This is just like FileFilterFrame but it can also handle header data |
| FileHunter | FileHunter is a class designed to find files matching specified criteria |
| FileHunterException | The only exception that class FileHunter throws |
| FileMissingException | Attempted to open a file that doesn't exist |
| FileSpec | A FileSpec is how file names are defined |
| FileSpec::FileSpecElement | This is an internal, private class of FileSpec that holds information for one individual file specification element |
| FileSpec::FileSpecSort | Another private, internal class for doing sorting by substring |
| FileSpecException | This exception is thrown when there is a problem with handling file specifications |
| FileStore | This is an abstract class used to add a list of files and the interface to read files into a datastore |
| Fillable | This is an interface for fillable basic shapes to group them together |
| format | |
| Frame | This class defines a frame that can be drawn in |
| GaussianDistribution | This class implements the Gaussian (or normal) distribution |
| GCATTropModel | Tropospheric model implemented in "GPS Code Analysis Tool" (GCAT) software |
| GDCconfiguration | Class GDCconfiguration encapsulates the configuration for input to the GPSTK Discontinuity Corrector |
| GDCPass | |
| GDCreturn | Class GDCreturn encapsulates the information in the 'message' returned by the GPSTK Discontinuity Corrector |
| GenXSequence | Generate X Sequence for GPS Applied Research Laboratories, The University of Texas at Austin August 2003 |
| Geodetic | Specialization of triple that represents geodetic coordinates (latitude in degrees, longitude in degrees, altitude in m) |
| GeodeticFrames | Class GeodeticFrames encapsulates frame transformations between the conventional terrestrial frame and the conventional inertial frame, as defined by the reference |
| GeoidModel | This abstract class encapsulates geodetic models (e.g |
| GeometryException | Thrown when a gpstk::Triple operation can't be completed |
| GGHeightTropModel | Tropospheric model with heights based on Goad and Goodman(1974), "A Modified Hopfield Tropospheric Refraction Correction Model," Paper presented at the Fall Annual Meeting of the American Geophysical Union, San Francisco, December 1974 |
| GGTropModel | Tropospheric model based on Goad and Goodman(1974), "A Modified Hopfield Tropospheric Refraction Correction Model," Paper presented at the Fall Annual Meeting of the American Geophysical Union, San Francisco, December 1974, as presented in Leick, "GPS Satellite Surveying," Wiley, NY, 1990, Chapter 9 (note particularly Table 9.1) |
| gnssData | Basic gnssData structure |
| gnssDataMap | GNSS data structure consisting in a map with DayTime as keys, and sourceDataMap as elements |
| gnssEquationDefinition | Object defining the structure of a GNSS equation |
| gnssLinearCombination | Object defining the structure of a GNSS linear combination |
| gnssRinex | GNSS data structure with source, epoch and extra Rinex data as header (common indexes) and satTypeValueMap as body |
| gnssSatTypeValue | GNSS data structure with source and epoch as header (common indexes) and satTypeValueMap as body |
| gnssSatValue | GNSS data structure with source, epoch and data type as header (common indexes) and satValueMap as body |
| gnssTypeValue | GNSS data structure with source, epoch and satellite as header (common indexes) and typeValueMap as body |
| GPSAlmanacStore | Store GPS almanac information (i.e |
| GPSEllipsoid | This class represents the ellipsoidal model defined in ICD-GPS-200 |
| GPSEphemerisStore | Store GPS broadcast ephemeris information (i.e |
| GPSGeoid | This class represents the geodetic model defined in ICD-GPS-200 |
| GPSWeek | This class is an abstract base class inherited by other GPS-time-related classes |
| GPSWeekSecond | This class encapsulates the "Full GPS Week and GPS Seconds-of-week" time representation |
| GPSWeekZcount | This class encapsulates the "Full GPS Week and GPS Z-count" time representation |
| GPSZcount | A representation class for GPS Time consisting of a short GPS week, and a long GPS Z-count |
| GravitationalDelay | This class computes the delay in the signal due to changes in the gravity field |
| GridLayout | Assists in arranging frames in a grid with some number of rows and columns |
| GSatID | |
| Helper | This class contains static helper methods for common code related to this library |
| HexDumpDataConfig | Class for configuring the appearance of hexDumpData() output |
| HLayout | Assists in arranging frames in a horizontal stack |
| Householder | The Householder transformation is simply an orthogonal transformation designed to make the elements below the diagonal zero |
| IndexedColorMap | This class represents a 2d pixel map of colors |
| IndexOutOfBoundsException | Attempts to access an "array" or other element that doesn't exist |
| InOutFramework | This is a framework for programs that take a single type of input data and output a single stream of output |
| InterpolatedColorMap | This class represents a 2d pixel map of colors |
| InvalidAntex | Thrown when some problem appeared when reading Antex data |
| InvalidArgumentException | A function was passed an invalid argument |
| InvalidData | Thrown when some problem appeared when extracting data |
| InvalidDOP | Thrown when some problem appeared when computing DOP |
| InvalidEquationSystem | Thrown when attempting to use an invalid EquationSystem |
| InvalidParameter | Thrown when a function is given a parameter value that it invalid |
| InvalidRequest | Thrown if a function can not satisfy a request |
| InvalidSolver | Thrown when some problem appeared when solving a given equation set |
| InvalidValue | |
| InvalidWeights | Thrown when some problem appeared when assigning weights to satellites |
| IonexBase | This class does not served any purpose other than to make readable inheritance diagrams |
| IonexData | This class models a IONEX Data Record |
| IonexData::IonexValType | A structure used to store IONEX Value Types |
| IonexHeader | This class models the header for a IONEX file |
| IonexHeader::DCB | |
| IonexModel | This is a class to compute the main values related to a given GNSS IONEX model, i.e., TEC value, ionospheric mapping function and slant ionospheric delay |
| IonexStore | This class reads and stores Ionosphere maps |
| IonexStream | This class provides access to IONEX files |
| IonoModel | Model of the ionosphere |
| IonoModel::InvalidIonoModel | Thrown when attempting to use a model for which all necessary parameters have not been specified |
| IonoModelStore | This class defines an interface to hide how we determine the ionospheric delay as determined from GPS navigation message based models at some point in time |
| IonoModelStore::NoIonoModelFound | Thrown when attempting to get a model that isn't stored |
| JulianDate | This class encapsulates the "Julian Date" time representation |
| Keeper | This class examines a GNSS Data Structure (GDS) and keeps only specific values according to their TypeIDs |
| LabelledMatrix | Class LabelledMatrix. Pretty print a Matrix using the labels in a Namelist |
| LabelledVector | Class LabelledVector. Pretty print a Vector using the labels in a Namelist |
| Layout | This class is used to create new frames from an existing frame |
| LICSDetector | This is a class to detect cycle slips using LI observables |
| LICSDetector2 | This is a class to detect cycle slips using LI observables and a 2nd order fitting curve |
| Line | This class defines a simple line between a set of points |
| LinearClockModel | |
| LinearCombinations | This class defines handy linear combinations of GDS data |
| LinePlot | |
| ListStats | ListStats (i.e. Statistics on a list of numbers) |
| Log | Template class Log is used by classes ConfigureLOG and ConfigureLOGstream |
| LoopedFramework | This is a basic framework for programs processing in loops in the GPSTK |
| LUDecomp | Performs the lower/upper triangular decomposition of a matrix PA = LU |
| Markable | This is an interface for markable basic shapes |
| Marker | This class defines a marker which will be drawn at every point on a line |
| Matrix | An implementation of a matrix class using Vector<T> as its internal basis |
| MatrixColSlice | Assignable single column slice of a matrix |
| MatrixException | |
| MatrixRowSlice | Assignable single row slice of a matrix |
| MatrixSlice | An assignable slice of a matrix |
| MatrixSliceBase | Base class for defining a slice of a matrix |
| MDPHeader | This class contains header information for all data types transmitted by receiver meeting the MDP specification |
| MDPNavSubframe | This class represents a Navigation Subframe Message |
| MDPObsEpoch | This class represents a set of observations from a single SV at a single point in time |
| MDPObsEpoch::Observation | |
| MDPPVTSolution | This class represents a Position-Velocity-Time Solution |
| MDPSelftestStatus | This class represents a runtime selftest status message |
| MDPStream | This is a stream used to decode data in the MDP format |
| MetReader | |
| MinSfTest | |
| MJD | This class encapsulates the "Modified Julian Date" time representation |
| ModeledPR | This class compute modeled pseudoranges from satellites to a mobile receiver |
| ModeledPseudorangeBase | This abstract class deals with modeled pseudoranges |
| ModeledReferencePR | This class compute modeled pseudoranges from satellites to a reference station |
| ModelObs | This class compute modeled (corrected) observations from satellites to a mobile receiver using GNSS data structures (GDS) |
| ModelObsFixedStation | This class computes modeled (corrected) observations from a reference station (whose position is known), using GNSS data structures (GDS) |
| MoonPosition | This class computes the approximate position of the Moon at the given epoch in the ECEF system |
| MOPSTropModel | Tropospheric model implemented in the RTCA "Minimum Operational Performance Standards" (MOPS), version C |
| MOPSWeight | Class to assign weights to satellites based on the Appendix J of MOPS C |
| MSCBase | This is a base class for all MSC-related classes |
| MSCData | Model for a Monitor Station Coordinates File Data Record |
| MSCHeader | This class does not really do anything |
| MSCStore | Store Monitor Station coordinate information and return either the raw information or the position at a given time based on integration of station velocity information over time since the epoch time |
| MSCStream | Stream used to obtain data from a Monitor Station Coordinates File |
| MWCSDetector | This is a class to detect cycle slips using MW observables |
| NablaOp | This class applies the Nabla operator (differences on satellite-related data) to GNSS data structures |
| Namelist | Class Namelist |
| NBTropModel | Tropospheric model developed by University of New Brunswick and described in "A Tropospheric Delay Model for the User of the Wide Area Augmentation System," J |
| NEDUtil | A utility for converting from Cartesian in XZY to North-East-Down (NED) |
| NeillTropModel | Tropospheric model based in the Neill mapping functions |
| NoGeoidException | Thrown when the internal gpstk::GeoidModel isn't assigned |
| NovatelData | Read Novatel binary records and parse into Rinex |
| NovatelStream | The stream used to obtain data from a binary Novatel File |
| NumberOfSatsMismatch | Thrown when the number of data values and the number of corresponding satellites does not match |
| NumberOfTypesMismatch | Thrown when the number of data values and the number of corresponding types does not match |
| ObjectNotFound | Operation failed because it was unable to locate the requested obj |
| ObsClockModel | |
| ObsEphReaderFramework | |
| ObsEpoch | All the observations collected from a single receiver at a single epoch |
| ObsID | |
| ObsID::Initializer | |
| ObsReader | |
| ObsRngDev | A single (one observation from one sv), Observed Range Deviation (ORD) |
| OceanLoading | This class computes the effect of ocean tides at a given position and epoch |
| OneFreqCSDetector | This is a class to detect cycle slips using observables in just one frequency |
| ORDEpoch | |
| OutOfMemory | Unable to allocate memory |
| OWid | |
| Palette | This class defines a simple interpolated palette of colors |
| Path | This class defines a sequence of points |
| PCSmoother | This class smoothes the PC (ionosphere-free) code observable using the corresponding LC phase observable |
| PendulumIntegrator | |
| PhaseAmbiguityModel | This class compute the elements of Phi and Q matrices corresponding to a phase ambiguity variable: Constant stochastic model within cycle slips and white noise stochastic model when a cycle slip happens |
| PhaseCodeAlignment | This class aligns phase with code measurements |
| Plot | |
| PNG | Used to create PNG Images |
| Point | This class describes a point as an (x,y) coordinate |
| PoleTides | This class computes the effect of pole tides, or more properly called "rotational deformations due to polar motion", at a given position and epoch |
| PolyFit | Compute a polynomial fit of the form sum[X(i)*t**i] = d, that is solve for coefficients X given a set of data pairs (t,d) |
| Polygon | This class defines a simple line between a set of points |
| Position | A position representation class for common 3D geographic position formats, including geodetic (geodetic latitude, longitude, and height above the geoid) geocentric (geocentric latitude, longitude, and radius from Earth's center), cartesian (Earth-centered, Earth-fixed) and spherical (theta,phi,radius) |
| PowerSum | |
| PreciseRange | Class PreciseRange |
| ProcessingClass | This is an abstract base class for objects processing GNSS Data Structures (GDS) |
| ProcessingException | Thrown when there is a problem processing GDS data |
| ProcessingList | This is a class to store ProcessingClass objects in a list |
| ProcessingVector | This is a class to store ProcessingClass objects in a vector |
| PRSolution | This class defines an interface to routines which compute a position and time solution from pseudorange data, with a data editing algorithm based on Receiver Autonomous Integrity Monitoring (RAIM) concepts |
| Pruner | This class examines a GNSS Data Structure (GDS) and prunes specific values according to their TypeIDs |
| PSImage | This class generates vector graphics conformant with Postscript Level 2 |
| PSImageBase | This class implements the functionality common between the EPS and Postscript formats |
| RACRotation | |
| RandomWalkModel | This class compute the elements of Phi and Q matrices corresponding to a random walk stochastic model |
| Rectangle | This class defines a simple rectangle |
| RefMatrixBase | A matrix base class that allows assignment of the internal matrix |
| RefMatrixSliceBase | Base class for a modifiable matrix slice |
| RefVectorBase | A vector base class that allows modification of the internal representation |
| RefVectorBaseHelper | Class to hold the static members of RefVectorBase |
| RefVectorSliceBase | A vector slice base class that does allow modification of the internal elements |
| RegTypeID | This class register TypeIDs by a name string, then you can access it globally |
| RequiredOption | A subclass of CommandOption that is a required command line option |
| RequireObservables | This class filters out satellites that don't have the required observations |
| RinexEphemerisStore | |
| RinexMetBase | This class serves no purpose other than to make readable diagrams |
| RinexMetData | This class stores, reads, and writes RINEX MET records |
| RinexMetDataFilterTime | This filter will remove any data not within the specified time range |
| RinexMetDataOperatorEqualsSimple | Only compares times |
| RinexMetDataOperatorLessThanFull | This compares all elements of the RinexMetData with less than (only for those fields which the two obs data share) |
| RinexMetDataOperatorLessThanSimple | Only compares times |
| RinexMetHeader | This class models the RINEX MET header for a RINEX MET file |
| RinexMetHeader::sensorPosType | Struct for holding info about a sensor position |
| RinexMetHeader::sensorType | Struct for holding information about a sensor |
| RinexMetHeaderTouchHeaderMerge | Combines RinexMetHeaders into a single header, combining comments and adding the appropriate RinexMetTypes |
| RinexMetStream | This class performs file i/o on a RINEX MET file for the RinexMetHeader and RinexMetData classes |
| RinexNavBase | This class serves no purpose other than to make readable diagrams |
| RinexNavData | This class models a RINEX NAV record |
| RinexNavDataFilterPRN | Filter based on PRN ID |
| RinexNavDataOperatorEqualsFull | This compares all elements of the RinexNavData with equals |
| RinexNavDataOperatorLessThanFull | This compares all elements of the RinexNavData with less than |
| RinexNavDataOperatorLessThanSimple | Only compares time. Suitable for sorting a RinexNav file |
| RinexNavHeader | This class models the RINEX NAV header for a RINEX NAV file |
| RinexNavHeaderTouchHeaderMerge | Combines RinexNavHeaders into a single header, combining comments This assumes that all the headers come from the same station for setting the other header fields |
| RinexNavStream | This class performs file i/o on a RINEX NAV file |
| RinexObsBase | This level isn't serving any purpose other than to make the class diagram look nice.. |
| RinexObsData | This class models a RINEX Observation Data Record |
| RinexObsData::RinexDatum | A structure used to store a single RINEX Data point |
| RinexObsDataOperatorEqualsSimple | This simply compares the times of the two records for equality |
| RinexObsDataOperatorLessThanFull | This compares all elements of the RinexObsData with less than (only for those fields which the two obs data share) |
| RinexObsDataOperatorLessThanSimple | This is a much faster less than operator for RinexObsData, only checking time and epochFlag (because it IS valid to have more than one record at the same time if the epochFlag is different) |
| RinexObsHeader | This class models the header for a RINEX Observation File |
| RinexObsHeader::ExtraWaveFact | Holds the data for the extra Wavelength Factor lines |
| RinexObsHeader::RinexObsType | RINEX Observation Types |
| RinexObsHeaderTouchHeaderMerge | Combines RinexObsHeaders into a single header, combining comments and adding the appropriate RinexObsTypes |
| RinexObsID | |
| RinexObsStream | This class reads RINEX files |
| RinexSatID | |
| RTFileFrame | This class supports two iteration semantics |
| RTFileFrameHelper | Specifying internal enums and classes of a template class can be problematic, so these are declared outside RTFileFrame |
| RTFileFrameIterator | An iterator class for the RTFileFrame |
| RungeKutta4 | Collection of integration routines that work on a Matrix of doubles |
| SaasTropModel | Saastamoinen tropospheric model based on Saastamoinen, J., 'Atmospheric Correction for the Troposphere and Stratosphere in Radio Ranging of Satellites,' Geophysical Monograph 15, American Geophysical Union, 1972, and Ch 9 of McCarthy, D and Petit, G, IERS Conventions (2003), IERS Technical Note 32, IERS, 2004 |
| SatArcMarker | This class keeps track of satellite arcs caused by cycle slips |
| SatDataReader | This is a class to read and parse satellite data from PRN_GPS-like files |
| SatID | Satellite identifier consisting of a satellite number (PRN, etc.) and a satellite system |
| SatIDNotFound | Thrown when attempting to access a value and the corresponding SatID does not exist in the map |
| SatPass | Class SatPass holds all range and phase data for a full satellite pass |
| SatPass::SatPassData | |
| SatPassIterator | Iterate over a list (vector) of SatPass using this class |
| satTypeValueMap | Map holding SatID with corresponding typeValueMap |
| satValueMap | Map holding SatID with corresponding numeric value |
| ScatterPlot | |
| SDid | |
| Segment | |
| SEMAlmanacStore | |
| SEMBase | This is a base class for all SEM-related classes |
| SEMData | This class stores, reads, and writes SEM records |
| SEMHeader | This class stores, reads, and writes SEM records |
| SEMStream | This class performs file i/o on a SEM file for the SEMHeader and SEMData classes |
| SeriesList | This class will maintain a list of series including their title and strokestyle |
| SimpleFilter | This class filters out satellites with observations grossly out of bounds |
| SimpleIURAWeight | Class to assign weights to satellites based on their URA Index (IURA) |
| SimpleKalmanFilter | This class computes the solution using a Kalman filter |
| SimpleTropModel | A simple Black model of the troposphere. temp is in Kelvin |
| SingularMatrixException | |
| Slip | |
| SMODFData | Model for a Smoothed Measurement Data File Data Record |
| SMODFStream | This is a stream used to obtain data from a Smoothed Measurement Data File |
| SolarSystem | Class SolarSystem encapsulates the information in the JPL ephemeris file, both header and data, reading and writing of both ASCII and binary files, as well as the computation of position and velocity of the sun, moon and planets, plus nutations and lunar librations and their rates |
| SolidTides | This class computes the effect of solid Earth tides at a given position and epoch |
| SolverBase | Abstract base class for solver algorithms |
| SolverGeneral | This class is an Extended Kalman Filter (EKF) implementation that is run-time programmable, making it extremely flexible |
| SolverLMS | This class computes the Least Mean Squares Solution of a given equations set |
| SolverPPP | This class computes the Precise Point Positioning (PPP) solution using a Kalman solver that combines ionosphere-free code and phase measurements |
| SolverPPPFB | This class computes the Precise Point Positioning (PPP) solution using a Kalman solver that combines ionosphere-free code and phase measurements |
| SolverWMS | This class computes the Weighted Least Mean Squares Solution of a given equations set |
| sourceDataMap | GNSS data structure consisting in a map with SourceID as keys, and satTypeValueMap as elements |
| sourceEpochHeader | Defines a header containing the source and epoch of data |
| sourceEpochRinexHeader | Defines a header containing the source and epoch of data, plus extra data extracted from a Rinex file |
| sourceEpochSatHeader | Defines a header containing the source, satellite ID and epoch of data |
| sourceEpochTypeHeader | Defines a header containing the source, type and epoch of data |
| sourceHeader | Set of several headers to be used with data structures. Defines a header containing just the source of data |
| SourceID | |
| SourceID::Initializer | |
| SourceIDNotFound | Thrown when attempting to access a value and the corresponding source (SourceID) does not exist in the map |
| sourceSatHeader | Defines a header containing the source and satellite ID of data |
| sourceTypeHeader | Defines a header containing the source and type of data |
| SP3Base | This class is here to make readable inheritance diagrams |
| SP3Data | This class models Satellite Position in Three Dimensions |
| SP3EphemerisStore | This adds the interface to read SP3 files into a TabularEphemerisStore |
| SP3Header | This class models the header for a SP3 file |
| SP3SatID | |
| SP3Stream | This class provides access to SP3 files |
| Splitter | This is a helper class that assists with cutting a set of points along a line |
| SRI | Class SRI encapsulates all the information associated with the solution of a set of simultaneous linear equations |
| SRIFilter | Class SRIFilter inherits SRI and implements a square root information filter, which is the square root formulation of the Kalman filter algorithm |
| SRIleastSquares | Class SRIleastSquares inherits SRI and implements a general least squares algorithm using SRI, including weighted, linear or linearized, robust and/or sequential algorithms |
| Stats | Conventional statistics for one sample |
| StochasticModel | This is a base class to define stochastic models |
| StringException | This is thrown instread of a std::exception when a gpstk::StringUtils function fails |
| StrokeStyle | This class defines how a line, path, or edge appears |
| StudentDistribution | This class implements the t-Student distribution |
| SunPosition | This class computes the approximate position of the Sun at the given epoch in the ECEF system |
| SurfacePlot | |
| SVD | Class SVD: A function object for the singular value decomposition of a matrix |
| SVData | |
| SVExclusion | |
| SVExclusionList | |
| SVExclusionList::NoSVExclusionFound | |
| SVExclusionList::SVExclusionFileNotFound | |
| SVGImage | This class generates graphics in Scalable Vector Graphics format |
| SVNumXRef | |
| SVNumXRef::NoNAVSTARNumberFound | |
| SVNumXRef::NoPRNNumberFound | |
| SvObsEpoch | |
| SVPCodeGen | SV P-code Generator |
| Synchronize | This class synchronizes two GNSS Data Structures data streams |
| SynchronizeException | Thrown when synchronization was not possible at a given epoch |
| SystemPipeException | A problem using a system pipe |
| SystemQueueException | A problem using a system queue |
| SystemSemaphoreException | A problem using a system semaphore |
| SystemTime | This class reads the current system time and stores it in a UnixTime |
| TabularEphemerisStore | Store a tabular list of Xvt data (such as a table of precise ephemeris data in an SP3 file) and compute Xvt from this table |
| Test | |
| TestException | |
| TestException::TE | |
| TestFFData | |
| TestOperatorEquals | |
| TestOperatorLessThan | |
| TestRangeFilter | |
| TestValueFilter | |
| Text | This class defines a text object that is to be displayed in an image |
| TextStyle | This class defines a style of text |
| TimeNamedFileStream | |
| TimeTag | This class is an abstract base class inherited by all the classes that provide a specific time representation |
| Triple | Three-dimensional vectors |
| TropModel | Abstract base class for tropospheric models |
| TropModel::InvalidTropModel | Thrown when attempting to use a model for which all necessary parameters have not been specified |
| TropoRandomWalkModel | This class compute the elements of Phi and Q matrices corresponding to zenital tropospheric wet delays, modeled as a random walk stochastic model |
| TwoSampleStats | Conventional statistics for two samples |
| TypeID | This class creates an index able to represent any type of observation, correction, model parameter or other data value of interest for GNSS data processing |
| TypeID::Initializer | |
| TypeIDNotFound | Thrown when attempting to access a value and the corresponding TypeID does not exist in the map |
| typeValueMap | Map holding TypeID with corresponding numeric value |
| UnixTime | This class encapsulates the "Unix Timeval" time representation |
| ValidType | |
| ValueNotFound | Thrown when attempting to access a value and any of the corresponding indexes (SourceID, SatID or TypeID) does not exist in the map |
| Variable | Class to define and handle 'descriptions' of GNSS variables |
| VDrawException | Exception class unique to this library |
| Vector | This class pretty much duplicates std::valarray<T> except it's fully STL container compliant |
| VectorException | An exception thrown when there's a problem with a vector |
| VectorSlice | A slice of Vector<T> that can be modified |
| VectorSliceBase | A base class that represents a subset of a vector |
| VGImage | This is a generic, format- and device-independent interface to vector plotting |
| VGState | This class will simply maintain state about text and line styles, fill colors, and markers |
| ViewerManager | This class provides a convenient and consistent mechanism by which to launch a graphics file viewer |
| VLayout | Assists in arranging frames in a vertical stack |
| WeightBase | Abstract base class for algorithms assigning weights to satellites |
| WGS84Ellipsoid | This class represents the ellipsoid model defined in NIMA TR8350.2, "Department of Defense World Geodetic System 1984" |
| WGS84Geoid | This class represents the geodetic model defined in NIMA TR8350.2, "Department of Defense World Geodetic System 1984" |
| WhiteNoiseModel | This class compute the elements of Phi and Q matrices corresponding to a white noise stochastic model |
| WrongBlockFormat | This gets thrown if we don't have the wrong format block is used |
| WrongBlockNumber | This gets thrown if we don't have the right data for cast operations |
| WxObsData | This is a time history weather data from a single site |
| WxObservation | A Single Weather Observation |
| X1Sequence | GPS X1 Sequencer |
| X2Sequence | GPS X2 Sequencer |
| XRefNode | |
| Xvt | An Earth-Centered, Earth-Fixed position/velocity/clock representation |
| XvtStore | Abstract base class for storing and accessing an objects position, velocity, and clock data |
| XYZ2NED | This class changes the reference base from an Earth-Centered, Earth-Fixed (ECEF) system to a North-East-Down (NED) topocentric system, centered at the provided reference location |
| XYZ2NEU | This class changes the reference base from an Earth-Centered, Earth-Fixed (ECEF) system to a North-East-Up (NEU) topocentric system, centered at the provided reference location |
| YDSTime | This class encapsulates the "year, day-of-year, and seconds-of-day" time format |
| YumaAlmanacStore | |
| YumaBase | This is a base class for all Yuma-related classes |
| YumaData | This class stores, reads, and writes Yuma records |
| YumaHeader | This class does not really do anything |
| YumaStream | This class performs file i/o on a Yuma file for the YumaHeader and YumaData classes |
| ZeroTropModel | The 'zero' trop model, meaning it always returns zero |
