acalc.h

/*
 *openPilotLog - A FOSS Pilot Logbook Application
 *Copyright (C) 2020-2021 Felix Turowsky
 *
 *This program is free software: you can redistribute it and/or modify
 *it under the terms of the GNU General Public License as published by
 *the Free Software Foundation, either version 3 of the License, or
 *(at your option) any later version.
 *
 *This program is distributed in the hope that it will be useful,
 *but WITHOUT ANY WARRANTY; without even the implied warranty of
 *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *GNU General Public License for more details.
 *
 *You should have received a copy of the GNU General Public License
 *along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
#ifndef ACALC_H
#define ACALC_H
 
#ifdef _MSC_VER
#define _USE_MATH_DEFINES
#endif
#include <cmath>
#include <QDateTime>
#include <QDebug>
#include "src/functions/alog.h"
#include "src/functions/atime.h"
namespace ACalc {
 
QT_DEPRECATED
inline QTime blocktime(QTime tofb, QTime tonb)
{
    QTime blocktime_out(0, 0); // initialise return value at midnight
 
    if (tonb > tofb) { // landing same day
        int blockseconds = tofb.secsTo(tonb);
        blocktime_out = blocktime_out.addSecs(blockseconds);
    } else { // landing next day
        QTime midnight(0, 0);
        int blockseconds = tofb.secsTo(midnight);
        blocktime_out = blocktime_out.addSecs(blockseconds);
        blockseconds = midnight.secsTo(tonb);
        blocktime_out = blocktime_out.addSecs(blockseconds);
    }
    return blocktime_out;
}
QT_DEPRECATED
inline QString minutesToString(QString block_minutes)
{
    int minutes = block_minutes.toInt();
    QString hour = QString::number(minutes / 60);
    if (hour.size() < 2) {
        hour.prepend("0");
    }
    QString minute = QString::number(minutes % 60);
    if (minute.size() < 2) {
        minute.prepend("0");
    }
    QString block_time = hour + ":" + minute;
    return block_time;
};
 
QT_DEPRECATED
inline QString minutesToString(int block_minutes)
{
    QString hour = QString::number(block_minutes / 60);
    if (hour.size() < 2) {
        hour.prepend("0");
    }
    QString minute = QString::number(block_minutes % 60);
    if (minute.size() < 2) {
        minute.prepend("0");
    }
    QString blocktime = hour + ":" + minute;
    return blocktime;
};
 
QT_DEPRECATED
inline int QTimeToMinutes(QTime time)
{
    QString timestring = time.toString("hh:mm");
    int minutes = (timestring.left(2).toInt()) * 60;
    minutes += timestring.right(2).toInt();
    return minutes;
}
 
QT_DEPRECATED
inline int stringToMinutes(QString timestring)
{
    int minutes = (timestring.left(2).toInt()) * 60;
    minutes += timestring.right(2).toInt();
    timestring = QString::number(minutes);
    return minutes;
}
 
inline double radToDeg(double rad)
{
    double deg = rad * (180 / M_PI);
    return deg;
}
 
inline double degToRad(double deg)
{
    double rad = deg * (M_PI / 180);
    return rad;
}
 
inline double radToNauticalMiles(double rad)
{
    double nm = rad * 3440.06479482;
    return nm;
}
 
double greatCircleDistance(double lat1, double lon1, double lat2, double lon2);
 
double greatCircleDistanceBetweenAirports(const QString &dept, const QString &dest);
 
QVector<QVector<double>> intermediatePointsOnGreatCircle(double lat1,
                                                         double lon1,
                                                         double lat2,
                                                         double lon2,
                                                         int tblk);
double solarElevation(QDateTime utc_time_point, double lat, double lon);
 
int calculateNightTime(const QString &dept, const QString &dest, QDateTime departureTime, int tblk, int nightAngle);
 
bool isNight(const QString &icao, QDateTime event_time, int night_angle);
 
QString formatTimeInput(QString user_input);
 
void updateAutoTimes(int acft_id);
 
void updateNightTimes();
 
struct NightTimeValues{
    NightTimeValues() = delete;
    NightTimeValues(const QString& dept, const QString& dest, const QDateTime& departure_time, int block_minutes, int night_angle)
    {
        nightMinutes = calculateNightTime(dept, dest, departure_time, block_minutes, night_angle);
 
        nightTime = ATime::qTimefromMinutes(nightMinutes);
        totalTime = ATime::qTimefromMinutes(block_minutes);
 
        if (nightMinutes == 0) { // all day
            takeOffNight = false;
            landingNight  = false;
        }
        else if (nightMinutes == block_minutes) { // all night
            takeOffNight = true;
            landingNight  = true;
        } else {
            if(isNight(dept, departure_time,  night_angle))
                takeOffNight = true;
            else
                takeOffNight = false;
            if(isNight(dest, departure_time.addSecs(block_minutes * 60), night_angle))
                landingNight = true;
            else
                landingNight = false;
        }
 
    };
    NightTimeValues(bool to_night, bool ldg_night, int night_minutes, QTime night_time, QTime total_time)
        : takeOffNight(to_night), landingNight(ldg_night), nightMinutes(night_minutes), nightTime(night_time), totalTime(total_time){};
    bool takeOffNight;
    bool landingNight;
    int nightMinutes;
    QTime nightTime;
    QTime totalTime;
 
    inline bool isAllDay()      {return (!takeOffNight  && !landingNight);}
    inline bool isAllNight()    {return ( takeOffNight  &&  landingNight);}
    inline bool isDayToNight()  {return (!takeOffNight  &&  landingNight);}
    inline bool isNightToDay()  {return ( takeOffNight  && !landingNight);}
};
 
 
} // namespace ACalc
 
#endif // ACALC_H