mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-05-07 12:00:05 -05:00
Code Issues Packages Projects Releases Wiki Activity

Add the ability to DashboardItemSimulationIncrement and DashboardItemDistance to specify fixed unit

Browse Source
This commit is contained in:
Alexander Bock
2018-02-08 12:18:38 -05:00
parent d9f874472e
commit d5f158ad0b
9 changed files with 588 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/util/distanceconversion.cpp
+151 -15
View File
@@ -27,60 +27,75 @@
#include <openspace/util/distanceconstants.h>
#include <ghoul/glm.h>
#include <ghoul/misc/assert.h>
namespace {
constexpr bool equal(char const* lhs, char const* rhs) {
while (*lhs || *rhs) {
if (*lhs++ != *rhs++) {
return false;
}
}
return true;
}
}
namespace openspace {
std::pair<double, std::string> simplifyDistance(double meters) {
std::pair<double, std::string> simplifyDistance(double meters, bool forceSingularForm) {
double metersVal = glm::abs(meters);
if (metersVal == 0.0) {
return { 0.0, "meters"};
return { 0.0, forceSingularForm ? "meter" : "meters"};
}
else if (metersVal > 1e-3 && metersVal < 1e3) {
return { meters, meters == 1.0 ? "meter" : "meters" };
return { meters, (meters == 1.0 || forceSingularForm) ? "meter" : "meters" };
}
if (metersVal < 1e-9) {
return { meters / 1e-9, (meters / 1e-9) == 1.0 ? "nanometer" : "nanometers" };
double val = meters / 1e-9;
return { val, (val == 1.0 || forceSingularForm) ? "nanometer" : "nanometers" };
}
else if (metersVal < 1e-6) {
return { meters / 1e-6, (meters / 1e-6) == 1.0 ? "micrometer" : "micrometers" };
double val = meters / 1e-6;
return { val, (val == 1.0 || forceSingularForm) ? "micrometer" : "micrometers" };
}
else if (metersVal < 1e-3) {
return { meters / 1e-3, (meters / 1e-3) == 1.0 ? "millimeter" : "millimeters" };
double val = meters / 1e-3;
return { val, (val == 1.0 || forceSingularForm) ? "millimeter" : "millimeters" };
}
if (metersVal > (1e9 * distanceconstants::Parsec)) {
double val = meters / (1e9 * distanceconstants::Parsec);
return { val, val == 1.0 ? "Gigaparsec" : "Gigaparsecs" };
return { val, (val == 1.0 || forceSingularForm) ? "Gigaparsec" : "Gigaparsecs" };
}
else if (metersVal > (1e6 * distanceconstants::Parsec)) {
double val = meters / (1e6 * distanceconstants::Parsec);
return { val, val == 1.0 ? "Megaparsec" : "Megaparsecs" };
return { val, (val == 1.0 || forceSingularForm) ? "Megaparsec" : "Megaparsecs" };
}
else if (metersVal > (1e3 * distanceconstants::Parsec)) {
double val = meters / (1e3 * distanceconstants::Parsec);
return { val, val == 1.0 ? "Kiloparsec" : "Kiloparsecs" };
return { val, (val == 1.0 || forceSingularForm) ? "Kiloparsec" : "Kiloparsecs" };
}
else if (metersVal > distanceconstants::Parsec) {
double val = meters / distanceconstants::Parsec;
return { val, val == 1.0 ? "Parsec" : "Parsecs" };
return { val, (val == 1.0 || forceSingularForm) ? "Parsec" : "Parsecs" };
}
else if (metersVal > distanceconstants::LightYear) {
double val = meters / distanceconstants::LightYear;
return { val, val == 1.0 ? "Lightyear" : "Lightyears" };
return { val, (val == 1.0 || forceSingularForm) ? "Lightyear" : "Lightyears" };
}
else if (metersVal > distanceconstants::LightMonth) {
double val = meters / distanceconstants::LightMonth;
return { val, val == 1.0 ? "Lightmonth" : "Lightmonths" };
return { val, (val == 1.0 || forceSingularForm) ? "Lightmonth" : "Lightmonths" };
}
else if (metersVal > distanceconstants::LightDay) {
double val = meters / distanceconstants::LightDay;
return { val, val == 1.0 ? "Lightday" : "Lightdays" };
return { val, (val == 1.0 || forceSingularForm) ? "Lightday" : "Lightdays" };
}
else if (metersVal > distanceconstants::LightHour) {
double val = meters / distanceconstants::LightDay;
return { val, val == 1.0 ? "Lighthour" : "Lighthours" };
double val = meters / distanceconstants::LightHour;
return { val, (val == 1.0 || forceSingularForm) ? "Lighthour" : "Lighthours" };
}
else if (metersVal > distanceconstants::AstronomicalUnit) {
return { meters / distanceconstants::AstronomicalUnit, "AU" };
@@ -90,4 +105,125 @@ std::pair<double, std::string> simplifyDistance(double meters) {
}
}
double convertDistance(double meters, DistanceUnit requestedUnit) {
switch (requestedUnit) {
case DistanceUnit::Nanometer:
return meters / 1e-9;
case DistanceUnit::Micrometer:
return meters / 1e-6;
case DistanceUnit::Millimeter:
return meters / 1e-3;
case DistanceUnit::Meter:
return meters;
case DistanceUnit::Kilometer:
return meters / 1000.0;
case DistanceUnit::AU:
return meters / distanceconstants::AstronomicalUnit;
case DistanceUnit::Lighthour:
return meters / distanceconstants::LightHour;
case DistanceUnit::Lightday:
return meters / distanceconstants::LightDay;
case DistanceUnit::Lightmonth:
return meters / distanceconstants::LightMonth;
case DistanceUnit::Lightyear:
return meters / distanceconstants::LightYear;
case DistanceUnit::Parsec:
return meters / distanceconstants::Parsec;
case DistanceUnit::Kiloparsec:
return meters / (1e3 * distanceconstants::Parsec);
case DistanceUnit::Megaparsec:
return meters / (1e6 * distanceconstants::Parsec);
case DistanceUnit::Gigaparsec:
return meters / (1e9 * distanceconstants::Parsec);
default:
throw ghoul::MissingCaseException();
}
}
std::string nameForDistanceUnit(DistanceUnit unit, bool pluralForm) {
switch (unit) {
case DistanceUnit::Nanometer:
return pluralForm ? "nanometers" : "nanometer";
case DistanceUnit::Micrometer:
return pluralForm ? "micrometers" : "micrometer";
case DistanceUnit::Millimeter:
return pluralForm ? "millimeters" : "millimeter";
case DistanceUnit::Meter:
return pluralForm ? "meters" : "meter";
case DistanceUnit::Kilometer:
return "km";
case DistanceUnit::AU:
return "AU";
case DistanceUnit::Lighthour:
return pluralForm ? "lighthours" : "lighthour";
case DistanceUnit::Lightday:
return pluralForm ? "lightdays" : "lightday";
case DistanceUnit::Lightmonth:
return pluralForm ? "lightmonths" : "lightmonth";
case DistanceUnit::Lightyear:
return pluralForm ? "lightyears" : "lightyear";
case DistanceUnit::Parsec:
return pluralForm ? "parsecs" : "parsec";
case DistanceUnit::Kiloparsec:
return pluralForm ? "kiloparsecs" : "kiloparsec";
case DistanceUnit::Megaparsec:
return pluralForm ? "megaparsecs" : "megaparsec";
case DistanceUnit::Gigaparsec:
return pluralForm ? "gigaparsecs" : "gigaparsec";
default:
throw ghoul::MissingCaseException();
}
}
DistanceUnit distanceUnitFromString(const std::string& unit) {
if (unit == "nanometer" || unit == "nanometers") {
return DistanceUnit::Nanometer;
}
else if (unit == "micrometer" || unit == "micrometers") {
return DistanceUnit::Micrometer;
}
else if (unit == "millimeter" || unit == "millimeters") {
return DistanceUnit::Millimeter;
}
else if (unit == "meter" || unit == "meters") {
return DistanceUnit::Meter;
}
else if (unit == "km") {
return DistanceUnit::Kilometer;
}
else if (unit == "AU") {
return DistanceUnit::AU;
}
else if (unit == "lighthour" || unit == "lighthours") {
return DistanceUnit::Lighthour;
}
else if (unit == "lightday" || unit == "lightdays") {
return DistanceUnit::Lightday;
}
else if (unit == "lightmonth" || unit == "lightmonths") {
return DistanceUnit::Lightmonth;
}
else if (unit == "lightyear" || unit == "lightyears") {
return DistanceUnit::Lightyear;
}
else if (unit == "parsec" || unit == "parsecs") {
return DistanceUnit::Parsec;
}
else if (unit == "kiloparsec" || unit == "kiloparsecs") {
return DistanceUnit::Kiloparsec;
}
else if (unit == "megaparsec" || unit == "megaparsecs") {
return DistanceUnit::Megaparsec;
}
else if (unit == "gigaparsec" || unit == "gigaparsecs") {
return DistanceUnit::Gigaparsec;
}
else {
throw ghoul::MissingCaseException();
}
}
} // namespace openspace
src/util/timeconversion.cpp
+105 -11
View File
@@ -25,6 +25,7 @@
#include <openspace/util/timeconversion.h>
#include <ghoul/glm.h>
#include <ghoul/misc/assert.h>
#include <chrono>
@@ -44,46 +45,139 @@ namespace {
namespace openspace {
std::pair<double, std::string> simplifyTime(double seconds) {
std::pair<double, std::string> simplifyTime(double seconds, bool forceSingularForm) {
double secondsVal = glm::abs(seconds);
if (secondsVal > 1e-3 && secondsVal < SecondsPerMinute) {
return { seconds, seconds == 1.0 ? "second" : "seconds" };
if (secondsVal == 0.0) {
return { 0.0, forceSingularForm ? "second" : "seconds" };
}
else if (secondsVal > 1e-3 && secondsVal < SecondsPerMinute) {
return { seconds, (seconds == 1.0 || forceSingularForm) ? "second" : "seconds" };
}
if (secondsVal <= 1e-9) {
double val = seconds / 1e-9;
return { val, val == 1.0 ? "nanosecond" : "nanoseconds" };
return { val, (val == 1.0 || forceSingularForm) ? "nanosecond" : "nanoseconds" };
}
else if (secondsVal <= 1e-6) {
double val = seconds / 1e-6;
return { val, val == 1.0 ? "microsecond" : "microseconds" };
return {
val,
(val == 1.0 || forceSingularForm) ? "microsecond" : "microseconds"
};
}
else if (secondsVal <= 1e-3) {
double val = seconds / 1e-3;
return { val, val == 1.0 ? "millisecond" : "milliseconds" };
return {
val,
(val == 1.0 || forceSingularForm) ? "millisecond" : "milliseconds"
};
}
if (secondsVal >= SecondsPerYear) {
double val = seconds / SecondsPerYear;
return { val, val == 1.0 ? "year" : "years" };
return { val, (val == 1.0 || forceSingularForm) ? "year" : "years" };
}
else if (secondsVal >= SecondsPerMonth) {
double val = seconds / SecondsPerMonth;
return { val, val == 1.0 ? "month" : "months" };
return { val, (val == 1.0 || forceSingularForm) ? "month" : "months" };
}
else if (secondsVal >= SecondsPerDay) {
double val = seconds / SecondsPerDay;
return { val, val == 1.0 ? "day" : "days" };
return { val, (val == 1.0 || forceSingularForm) ? "day" : "days" };
}
else if (secondsVal >= SecondsPerHour) {
double val = seconds / SecondsPerHour;
return { val, val == 1.0 ? "hour" : "hours" };
return { val, (val == 1.0 || forceSingularForm) ? "hour" : "hours" };
}
else {
double val = seconds / SecondsPerMinute;
return { val, val == 1.0 ? "minute" : "minutes" };
return { val, (val == 1.0 || forceSingularForm) ? "minute" : "minutes" };
}
}
double convertTime(double seconds, TimeUnit requestedUnit) {
switch (requestedUnit) {
case TimeUnit::Nanosecond:
return seconds / 1e-9;
case TimeUnit::Microsecond:
return seconds / 1e-6;
case TimeUnit::Millisecond:
return seconds / 1e-3;
case TimeUnit::Second:
return seconds;
case TimeUnit::Minute:
return seconds / SecondsPerMinute;
case TimeUnit::Hour:
return seconds / SecondsPerHour;
case TimeUnit::Day:
return seconds / SecondsPerDay;
case TimeUnit::Month:
return seconds / SecondsPerMonth;
case TimeUnit::Year:
return seconds / SecondsPerYear;
default:
throw ghoul::MissingCaseException();
}
}
std::string nameForTimeUnit(TimeUnit unit, bool pluralForm) {
switch (unit) {
case TimeUnit::Nanosecond:
return pluralForm ? "nanoseconds" : "nanosecond";
case TimeUnit::Microsecond:
return pluralForm ? "microseconds" : "microsecond";
case TimeUnit::Millisecond:
return pluralForm ? "milliseconds" : "millisecond";
case TimeUnit::Second:
return pluralForm ? "seconds" : "second";
case TimeUnit::Minute:
return pluralForm ? "minutes" : "minute";
case TimeUnit::Hour:
return pluralForm ? "hours" : "hour";
case TimeUnit::Day:
return pluralForm ? "days" : "day";
case TimeUnit::Month:
return pluralForm ? "months" : "month";
case TimeUnit::Year:
return pluralForm ? "years" : "year";
default:
throw ghoul::MissingCaseException();
}
}
TimeUnit timeUnitFromString(const std::string& unit) {
if (unit == "nanosecond" || unit == "nanoseconds") {
return TimeUnit::Nanosecond;
}
else if (unit == "microsecond" || unit == "microseconds") {
return TimeUnit::Microsecond;
}
else if (unit == "millisecond" || unit == "milliseconds") {
return TimeUnit::Millisecond;
}
else if (unit == "second" || unit == "seconds") {
return TimeUnit::Second;
}
else if (unit == "minute" || unit == "minutes") {
return TimeUnit::Minute;
}
else if (unit == "hour" || unit == "hours") {
return TimeUnit::Hour;
}
else if (unit == "day" || unit == "days") {
return TimeUnit::Day;
}
else if (unit == "month" || unit == "months") {
return TimeUnit::Month;
}
else if (unit == "year" || unit == "years") {
return TimeUnit::Year;
}
else {
throw ghoul::MissingCaseException();
}
}
} // namespace openspace