Cleanup of distance and time conversion classes, Modifies GuiSpaceTimeComponent

Changed previous slider into text field + dropbox
Added acceleration slider
Added shuffle slider (closes #479)

include/openspace/util/distanceconversion.h

@@ -25,6 +25,11 @@
 #ifndef __OPENSPACE_CORE___DISTANCECONVERSION___H__
 #define __OPENSPACE_CORE___DISTANCECONVERSION___H__
 
+#include <openspace/util/distanceconstants.h>
+
+#include <ghoul/misc/assert.h>
+#include <ghoul/misc/constexpr.h>
+
 #include <array>
 #include <string>
 #include <utility>
@@ -47,6 +52,39 @@ enum class DistanceUnit {
     Megaparsec,
     Gigaparsec
 };
+
+// Assumption:  Unit names are sequential in memory
+constexpr const char* DistanceUnitNanometer = "nanometer";
+constexpr const char* DistanceUnitMicrometer = "micrometer";
+constexpr const char* DistanceUnitMillimeter = "millimeter";
+constexpr const char* DistanceUnitMeter = "meter";
+constexpr const char* DistanceUnitKilometer = "km";
+constexpr const char* DistanceUnitAU = "AU";
+constexpr const char* DistanceUnitLighthour = "lighthour";
+constexpr const char* DistanceUnitLightday = "lightday";
+constexpr const char* DistanceUnitLightmonth = "lightmonth";
+constexpr const char* DistanceUnitLightyear = "lightyear";
+constexpr const char* DistanceUnitParsec = "parsec";
+constexpr const char* DistanceUnitKiloparsec = "kiloparsec";
+constexpr const char* DistanceUnitMegaparsec = "megaparsec";
+constexpr const char* DistanceUnitGigaparsec = "gigaparsec";
+
+// Assumption:  Unit names are sequential in memory
+constexpr const char* DistanceUnitNanometers = "nanometers";
+constexpr const char* DistanceUnitMicrometers = "micrometers";
+constexpr const char* DistanceUnitMillimeters = "millimeters";
+constexpr const char* DistanceUnitMeters = "meters";
+constexpr const char* DistanceUnitKilometers = "km";
+constexpr const char* DistanceUnitAUs = "AU";
+constexpr const char* DistanceUnitLighthours = "lighthours";
+constexpr const char* DistanceUnitLightdays = "lightdays";
+constexpr const char* DistanceUnitLightmonths = "lightmonths";
+constexpr const char* DistanceUnitLightyears = "lightyears";
+constexpr const char* DistanceUnitParsecs = "parsecs";
+constexpr const char* DistanceUnitKiloparsecs = "kiloparsecs";
+constexpr const char* DistanceUnitMegaparsecs = "megaparsecs";
+constexpr const char* DistanceUnitGigaparsecs = "gigaparsecs";
+
 constexpr std::array<DistanceUnit, static_cast<int>(DistanceUnit::Gigaparsec) + 1>
 DistanceUnits = {
     DistanceUnit::Nanometer, DistanceUnit::Micrometer, DistanceUnit::Millimeter,
@@ -56,13 +94,132 @@ DistanceUnits = {
     DistanceUnit::Megaparsec, DistanceUnit::Gigaparsec
 };
 
+constexpr std::array<const char*, static_cast<int>(DistanceUnit::Gigaparsec) + 1>
+DistanceUnitNamesSingular = {
+    DistanceUnitNanometer, DistanceUnitMicrometer, DistanceUnitMillimeter,
+    DistanceUnitMeter, DistanceUnitKilometer, DistanceUnitAU, DistanceUnitLighthour,
+    DistanceUnitLightday, DistanceUnitLightmonth, DistanceUnitLightyear,
+    DistanceUnitParsec, DistanceUnitKiloparsec, DistanceUnitMegaparsec,
+    DistanceUnitGigaparsec
+};
+
+constexpr std::array<const char*, static_cast<int>(DistanceUnit::Gigaparsec) + 1>
+DistanceUnitNamesPlural = {
+    DistanceUnitNanometers, DistanceUnitMicrometers, DistanceUnitMillimeters,
+    DistanceUnitMeters, DistanceUnitKilometers, DistanceUnitAUs, DistanceUnitLighthours,
+    DistanceUnitLightdays, DistanceUnitLightmonths, DistanceUnitLightyears,
+    DistanceUnitParsecs, DistanceUnitKiloparsecs, DistanceUnitMegaparsecs,
+    DistanceUnitGigaparsecs
+};
+
+constexpr bool isValidDistanceUnitName(const char* name) {
+    int i = 0;
+    for (const char* val : DistanceUnitNamesSingular) {
+        if (ghoul::equal(name, val)) {
+            return true;
+        }
+        ++i;
+    }
+
+    i = 0;
+    for (const char* val : DistanceUnitNamesPlural) {
+        if (ghoul::equal(name, val)) {
+            return true;
+        }
+        ++i;
+    }
+    return false;
+}
+
+constexpr const char* nameForDistanceUnit(DistanceUnit unit, bool pluralForm = false) {
+    switch (unit) {
+    case DistanceUnit::Nanometer:
+    case DistanceUnit::Micrometer:
+    case DistanceUnit::Millimeter:
+    case DistanceUnit::Meter:
+    case DistanceUnit::Kilometer:
+    case DistanceUnit::AU:
+    case DistanceUnit::Lighthour:
+    case DistanceUnit::Lightday:
+    case DistanceUnit::Lightmonth:
+    case DistanceUnit::Lightyear:
+    case DistanceUnit::Parsec:
+    case DistanceUnit::Kiloparsec:
+    case DistanceUnit::Megaparsec:
+    case DistanceUnit::Gigaparsec:
+        if (pluralForm) {
+            return DistanceUnitNamesPlural[static_cast<int>(unit)];
+        }
+        else {
+            return DistanceUnitNamesSingular[static_cast<int>(unit)];
+        }
+    default:
+        throw ghoul::MissingCaseException();
+    }
+}
+
+constexpr DistanceUnit distanceUnitFromString(const char* unitName) {
+    int i = 0;
+    for (const char* val : DistanceUnitNamesSingular) {
+        if (ghoul::equal(unitName, val)) {
+            return static_cast<DistanceUnit>(i);
+        }
+        ++i;
+    }
+
+    i = 0;
+    for (const char* val : DistanceUnitNamesPlural) {
+        if (ghoul::equal(unitName, val)) {
+            return static_cast<DistanceUnit>(i);
+        }
+        ++i;
+    }
+
+    ghoul_assert(false, "Unit name is not a valid name");
+    throw ghoul::MissingCaseException();
+}
+
+
+
+
+
 std::pair<double, std::string> simplifyDistance(double meters,
     bool forceSingularForm = false);
 
-double convertDistance(double meters, DistanceUnit requestedUnit);
-
-std::string nameForDistanceUnit(DistanceUnit unit, bool pluralForm = false);
-DistanceUnit distanceUnitFromString(const std::string& unit);
+constexpr 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();
+    }
+}
 
 } // namespace openspace
 

include/openspace/util/timeconversion.h

@@ -25,12 +25,29 @@
 #ifndef __OPENSPACE_CORE___TIMECONVERSION___H__
 #define __OPENSPACE_CORE___TIMECONVERSION___H__
 
+#include <ghoul/misc/assert.h>
+#include <ghoul/misc/constexpr.h>
+
 #include <array>
+#include <chrono>
 #include <string>
 #include <utility>
 
 namespace openspace {
 
+constexpr double SecondsPerYear = 31556952; // seconds in average Gregorian year
+constexpr double SecondsPerMonth = SecondsPerYear / 12;
+constexpr double SecondsPerDay = static_cast<double>(
+    std::chrono::seconds(std::chrono::hours(24)).count()
+);
+constexpr double SecondsPerHour = static_cast<double>(
+    std::chrono::seconds(std::chrono::hours(1)).count()
+);
+constexpr double SecondsPerMinute = static_cast<double>(
+    std::chrono::seconds(std::chrono::minutes(1)).count()
+);
+
+// Assumption:  static_cast<int>(TimeUnit) == position in the list
 enum class TimeUnit {
     Nanosecond = 0,
     Microsecond,
@@ -42,20 +59,168 @@ enum class TimeUnit {
     Month,
     Year
 };
-constexpr std::array<TimeUnit, static_cast<int>(TimeUnit::Year) + 1>
-TimeUnits = {
+
+// Assumption:  Unit names are sequential in memory
+constexpr const char* TimeUnitNanosecond   = "nanosecond";
+constexpr const char* TimeUnitMicrosecond  = "microsecond";
+constexpr const char* TimeUnitMillisecond  = "millisecond";
+constexpr const char* TimeUnitSecond       = "second";
+constexpr const char* TimeUnitMinute       = "minute";
+constexpr const char* TimeUnitHour         = "hour";
+constexpr const char* TimeUnitDay          = "day";
+constexpr const char* TimeUnitMonth        = "month";
+constexpr const char* TimeUnitYear         = "year";
+
+// Assumption:  Unit names are sequential in memory
+constexpr const char* TimeUnitNanoseconds = "nanoseconds";
+constexpr const char* TimeUnitMicroseconds = "microseconds";
+constexpr const char* TimeUnitMilliseconds = "milliseconds";
+constexpr const char* TimeUnitSeconds = "seconds";
+constexpr const char* TimeUnitMinutes = "minutes";
+constexpr const char* TimeUnitHours = "hours";
+constexpr const char* TimeUnitDays = "days";
+constexpr const char* TimeUnitMonths = "months";
+constexpr const char* TimeUnitYears = "years";
+
+constexpr std::array<TimeUnit, static_cast<int>(TimeUnit::Year) + 1> TimeUnits = {
     TimeUnit::Nanosecond, TimeUnit::Microsecond, TimeUnit::Millisecond,
     TimeUnit::Second, TimeUnit::Minute, TimeUnit::Hour, TimeUnit::Day,
     TimeUnit::Month, TimeUnit::Year
 };
 
+constexpr std::array<const char*, static_cast<int>(TimeUnit::Year) + 1>
+TimeUnitNamesSingular = {
+    TimeUnitNanosecond, TimeUnitMicrosecond, TimeUnitMillisecond, TimeUnitSecond,
+    TimeUnitMinute, TimeUnitHour, TimeUnitDay, TimeUnitMonth, TimeUnitYear
+};
+
+constexpr std::array<const char*, static_cast<int>(TimeUnit::Year) + 1>
+TimeUnitNamesPlural = {
+    TimeUnitNanoseconds, TimeUnitMicroseconds, TimeUnitMilliseconds, TimeUnitSeconds,
+    TimeUnitMinutes, TimeUnitHours, TimeUnitDays, TimeUnitMonths, TimeUnitYears
+};
+
+constexpr bool isValidTimeUnitName(const char* name) {
+    int i = 0;
+    for (const char* val : TimeUnitNamesSingular) {
+        if (ghoul::equal(name, val)) {
+            return true;
+        }
+        ++i;
+    }
+
+    i = 0;
+    for (const char* val : TimeUnitNamesPlural) {
+        if (ghoul::equal(name, val)) {
+            return true;
+        }
+        ++i;
+    }
+    return false;
+}
+
+constexpr const char* nameForTimeUnit(TimeUnit unit, bool pluralForm = false) {
+    switch (unit) {
+    case TimeUnit::Nanosecond:
+    case TimeUnit::Microsecond:
+    case TimeUnit::Millisecond:
+    case TimeUnit::Second:
+    case TimeUnit::Minute:
+    case TimeUnit::Hour:
+    case TimeUnit::Day:
+    case TimeUnit::Month:
+    case TimeUnit::Year:
+        if (pluralForm) {
+            return TimeUnitNamesPlural[static_cast<int>(unit)];
+        }
+        else {
+            return TimeUnitNamesSingular[static_cast<int>(unit)];
+        }
+    default:
+        throw ghoul::MissingCaseException();
+    }
+}
+
+constexpr TimeUnit timeUnitFromString(const char* unitName) {
+    int i = 0;
+    for (const char* val : TimeUnitNamesSingular) {
+        if (ghoul::equal(unitName, val)) {
+            return static_cast<TimeUnit>(i);
+        }
+        ++i;
+    }
+
+    i = 0;
+    for (const char* val : TimeUnitNamesPlural) {
+        if (ghoul::equal(unitName, val)) {
+            return static_cast<TimeUnit>(i);
+        }
+        ++i;
+    }
+
+    ghoul_assert(false, "Unit name is not a valid name");
+    throw ghoul::MissingCaseException();
+}
+
+
+
 std::pair<double, std::string> simplifyTime(double seconds,
     bool forceSingularForm = false);
 
-double convertTime(double seconds, TimeUnit requestedUnit);
+constexpr double convertTime(double t, TimeUnit sourceUnit, TimeUnit destinationUnit) {
+    double seconds = t;
+    switch (sourceUnit) {
+        case TimeUnit::Nanosecond:
+            seconds = t * 1e-9;
+            break;
+        case TimeUnit::Microsecond:
+            seconds = t * 1e-6;
+            break;
+        case TimeUnit::Millisecond:
+            seconds = t * 1e-3;
+            break;
+        case TimeUnit::Minute:
+            seconds = t * SecondsPerMinute;
+            break;
+        case TimeUnit::Hour:
+            seconds  = t * SecondsPerHour;
+            break;
+        case TimeUnit::Day:
+            seconds  = t * SecondsPerDay;
+            break;
+        case TimeUnit::Month:
+            seconds  = t * SecondsPerMonth;
+            break;
+        case TimeUnit::Year:
+            seconds  = t * SecondsPerYear;
+            break;
+        default: ;
+    }
+
+    switch (destinationUnit) {
+        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 = false);
-TimeUnit timeUnitFromString(const std::string& unit);
 
 } // namespace openspace