| 
														
															@@ -25,17 +25,15 @@ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  */ 
														 | 
														
														 | 
														
															  */ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 QTime calc::blocktime(QTime tofb, QTime tonb) 
														 | 
														
														 | 
														
															 QTime calc::blocktime(QTime tofb, QTime tonb) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 { 
														 | 
														
														 | 
														
															 { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    if(tonb > tofb)// landing same day 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        QTime blocktimeout(0,0); // initialise return value at midnight 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    if (tonb > tofb) { // landing same day 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        QTime blocktimeout(0, 0); // initialise return value at midnight 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         int blockseconds = tofb.secsTo(tonb); // returns seconds between 2 time objects 
														 | 
														
														 | 
														
															         int blockseconds = tofb.secsTo(tonb); // returns seconds between 2 time objects 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         blocktimeout = blocktimeout.addSecs(blockseconds); 
														 | 
														
														 | 
														
															         blocktimeout = blocktimeout.addSecs(blockseconds); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         return blocktimeout; 
														 | 
														
														 | 
														
															         return blocktimeout; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    } else // landing next day 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        QTime midnight(0,0); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        QTime blocktimeout(0,0); // initialise return value at midnight 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } else { // landing next day 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        QTime midnight(0, 0); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        QTime blocktimeout(0, 0); // initialise return value at midnight 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         int blockseconds = tofb.secsTo(midnight); // returns seconds passed until midnight 
														 | 
														
														 | 
														
															         int blockseconds = tofb.secsTo(midnight); // returns seconds passed until midnight 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         blocktimeout = blocktimeout.addSecs(blockseconds); 
														 | 
														
														 | 
														
															         blocktimeout = blocktimeout.addSecs(blockseconds); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         blockseconds = midnight.secsTo(tonb); // returns seconds passed after midnight 
														 | 
														
														 | 
														
															         blockseconds = midnight.secsTo(tonb); // returns seconds passed after midnight 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -53,10 +51,14 @@ QTime calc::blocktime(QTime tofb, QTime tonb) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 QString calc::minutes_to_string(QString blockminutes) 
														 | 
														
														 | 
														
															 QString calc::minutes_to_string(QString blockminutes) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 { 
														 | 
														
														 | 
														
															 { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     int minutes = blockminutes.toInt(); 
														 | 
														
														 | 
														
															     int minutes = blockminutes.toInt(); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    QString hour = QString::number(minutes/60); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    if (hour.size() < 2) {hour.prepend("0");} 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    QString hour = QString::number(minutes / 60); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    if (hour.size() < 2) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        hour.prepend("0"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     QString minute = QString::number(minutes % 60); 
														 | 
														
														 | 
														
															     QString minute = QString::number(minutes % 60); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    if (minute.size() < 2) {minute.prepend("0");} 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    if (minute.size() < 2) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        minute.prepend("0"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     QString blocktime = hour + ":" + minute; 
														 | 
														
														 | 
														
															     QString blocktime = hour + ":" + minute; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     return blocktime; 
														 | 
														
														 | 
														
															     return blocktime; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 }; 
														 | 
														
														 | 
														
															 }; 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -165,8 +167,8 @@ double calc::greatCircleDistance(double lat1, double lon1, double lat2, double l 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double deltalat = lat2 - lat1; 
														 | 
														
														 | 
														
															     double deltalat = lat2 - lat1; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double result = pow(sin(deltalat / 2), 2) + 
														 | 
														
														 | 
														
															     double result = pow(sin(deltalat / 2), 2) + 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            cos(lat1) * cos(lat2) * pow(sin(deltalon / 2), 2); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    result = 2 * asin(sqrt(result));   
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                    cos(lat1) * cos(lat2) * pow(sin(deltalon / 2), 2); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    result = 2 * asin(sqrt(result)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     return result; 
														 | 
														
														 | 
														
															     return result; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 } 
														 | 
														
														 | 
														
															 } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -186,12 +188,13 @@ double calc::greatCircleDistanceBetweenAirports(QString dept, QString dest) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     }*/ 
														 | 
														
														 | 
														
															     }*/ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															     QVector<QString> columns = {"lat", "long"}; 
														 | 
														
														 | 
														
															     QVector<QString> columns = {"lat", "long"}; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    QVector<QString> deptCoordinates = db::multiSelect(columns,"airports", "icao", dept, db::exactMatch); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    QVector<QString> destCoordinates = db::multiSelect(columns,"airports", "icao", dest, db::exactMatch); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    QVector<QString> deptCoordinates = db::multiSelect(columns, "airports", "icao", dept, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                                                       db::exactMatch); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    QVector<QString> destCoordinates = db::multiSelect(columns, "airports", "icao", dest, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                                                       db::exactMatch); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    if(deptCoordinates.isEmpty() || destCoordinates.isEmpty() 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-       ) 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    if (deptCoordinates.isEmpty() || destCoordinates.isEmpty() 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+       ) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         qDebug() << "greatCircleDistance - invalid input. aborting."; 
														 | 
														
														 | 
														
															         qDebug() << "greatCircleDistance - invalid input. aborting."; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         return 0; 
														 | 
														
														 | 
														
															         return 0; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     } 
														 | 
														
														 | 
														
															     } 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -206,7 +209,7 @@ double calc::greatCircleDistanceBetweenAirports(QString dept, QString dest) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double deltalat = lat2 - lat1; 
														 | 
														
														 | 
														
															     double deltalat = lat2 - lat1; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double result = pow(sin(deltalat / 2), 2) + 
														 | 
														
														 | 
														
															     double result = pow(sin(deltalat / 2), 2) + 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            cos(lat1) * cos(lat2) * pow(sin(deltalon / 2), 2); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                    cos(lat1) * cos(lat2) * pow(sin(deltalon / 2), 2); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     result = 2 * asin(sqrt(result)); 
														 | 
														
														 | 
														
															     result = 2 * asin(sqrt(result)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     return radToNauticalMiles(result); 
														 | 
														
														 | 
														
															     return radToNauticalMiles(result); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 } 
														 | 
														
														 | 
														
															 } 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -221,7 +224,8 @@ double calc::greatCircleDistanceBetweenAirports(QString dept, QString dest) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  * \param tblk Total Blocktime in minutes 
														 | 
														
														 | 
														
															  * \param tblk Total Blocktime in minutes 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  * \return coordinates {lat,lon} along the Great Circle Track 
														 | 
														
														 | 
														
															  * \return coordinates {lat,lon} along the Great Circle Track 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  */ 
														 | 
														
														 | 
														
															  */ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-QVector<QVector<double>> calc::intermediatePointsOnGreatCircle(double lat1, double lon1, double lat2, double lon2, int tblk) 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+QVector<QVector<double>> calc::intermediatePointsOnGreatCircle(double lat1, double lon1, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                                                               double lat2, double lon2, int tblk) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 { 
														 | 
														
														 | 
														
															 { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double d = greatCircleDistance(lat1, lon1, lat2, lon2); //calculate distance (radians) 
														 | 
														
														 | 
														
															     double d = greatCircleDistance(lat1, lon1, lat2, lon2); //calculate distance (radians) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // Converting Latitude and Longitude to Radians 
														 | 
														
														 | 
														
															     // Converting Latitude and Longitude to Radians 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -233,18 +237,18 @@ QVector<QVector<double>> calc::intermediatePointsOnGreatCircle(double lat1, doub 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     //loop for creating one minute steps along the Great Circle 
														 | 
														
														 | 
														
															     //loop for creating one minute steps along the Great Circle 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // 0 is departure point, 1 is end point 
														 | 
														
														 | 
														
															     // 0 is departure point, 1 is end point 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     QVector<QVector<double>> coordinates; 
														 | 
														
														 | 
														
															     QVector<QVector<double>> coordinates; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double fraction = 1.0/tblk; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    for(int i = 0; i <= tblk; i++) { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double fraction = 1.0 / tblk; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    for (int i = 0; i <= tblk; i++) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         // Calculating intermediate point for fraction of distance 
														 | 
														
														 | 
														
															         // Calculating intermediate point for fraction of distance 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        double A=sin((1-fraction * i) * d)/sin(d); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        double B=sin(fraction * i * d)/sin(d); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        double x = A*cos(lat1) * cos(lon1) + B * cos(lat2) * cos(lon2); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        double y = A*cos(lat1) * sin(lon1) + B * cos(lat2) * sin(lon2); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        double z = A*sin(lat1) + B * sin(lat2); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        double A = sin((1 - fraction * i) * d) / sin(d); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        double B = sin(fraction * i * d) / sin(d); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        double x = A * cos(lat1) * cos(lon1) + B * cos(lat2) * cos(lon2); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        double y = A * cos(lat1) * sin(lon1) + B * cos(lat2) * sin(lon2); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        double z = A * sin(lat1) + B * sin(lat2); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         double lat = atan2(z, sqrt( pow(x, 2) + pow(y, 2) )); 
														 | 
														
														 | 
														
															         double lat = atan2(z, sqrt( pow(x, 2) + pow(y, 2) )); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         double lon = atan2(y, x); 
														 | 
														
														 | 
														
															         double lon = atan2(y, x); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        QVector<double> coordinate = {lat,lon}; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        QVector<double> coordinate = {lat, lon}; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         coordinates.append(coordinate); 
														 | 
														
														 | 
														
															         coordinates.append(coordinate); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     } 
														 | 
														
														 | 
														
															     } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     return coordinates; 
														 | 
														
														 | 
														
															     return coordinates; 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -268,55 +272,60 @@ QVector<QVector<double>> calc::intermediatePointsOnGreatCircle(double lat1, doub 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  */ 
														 | 
														
														 | 
														
															  */ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 double calc::solarElevation(QDateTime utc_time_point, double lat, double lon) 
														 | 
														
														 | 
														
															 double calc::solarElevation(QDateTime utc_time_point, double lat, double lon) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 { 
														 | 
														
														 | 
														
															 { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double Alt = 11; // I am taking 11 kilometers as an average cruising height for a commercial passenger airplane. 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double Alt = 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        11; // I am taking 11 kilometers as an average cruising height for a commercial passenger airplane. 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // convert current DateTime Object to a J2000 value used in the calculation 
														 | 
														
														 | 
														
															     // convert current DateTime Object to a J2000 value used in the calculation 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double d = utc_time_point.date().toJulianDay() - 2451544 + utc_time_point.time().hour()/24.0 + utc_time_point.time().minute()/1440.0; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double d = utc_time_point.date().toJulianDay() - 2451544 + utc_time_point.time().hour() / 24.0 + 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+               utc_time_point.time().minute() / 1440.0; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // Orbital Elements (in degress) 
														 | 
														
														 | 
														
															     // Orbital Elements (in degress) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double w = 282.9404 + 4.70935e-5 * d; // (longitude of perihelion) 
														 | 
														
														 | 
														
															     double w = 282.9404 + 4.70935e-5 * d; // (longitude of perihelion) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double e = 0.016709 - 1.151e-9 * d; // (eccentricity) 
														 | 
														
														 | 
														
															     double e = 0.016709 - 1.151e-9 * d; // (eccentricity) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double M = fmod(356.0470 + 0.9856002585 * d, 360.0); // (mean anomaly, needs to be between 0 and 360 degrees) 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double oblecl = 23.4393 - 3.563e-7*d; // (Sun's obliquity of the ecliptic) 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double M = fmod(356.0470 + 0.9856002585 * d, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                    360.0); // (mean anomaly, needs to be between 0 and 360 degrees) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double oblecl = 23.4393 - 3.563e-7 * d; // (Sun's obliquity of the ecliptic) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double L = w + M; // (Sun's mean longitude) 
														 | 
														
														 | 
														
															     double L = w + M; // (Sun's mean longitude) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // auxiliary angle 
														 | 
														
														 | 
														
															     // auxiliary angle 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double  E = M + (180 / M_PI)*e*sin(M*(M_PI / 180))*(1 + e*cos(M*(M_PI / 180))); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double  E = M + (180 / M_PI) * e * sin(M * (M_PI / 180)) * (1 + e * cos(M * (M_PI / 180))); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // The Sun's rectangular coordinates in the plane of the ecliptic 
														 | 
														
														 | 
														
															     // The Sun's rectangular coordinates in the plane of the ecliptic 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double x = cos(E*(M_PI / 180)) - e; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double y = sin(E*(M_PI / 180))*sqrt(1 - pow(e, 2)); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double x = cos(E * (M_PI / 180)) - e; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double y = sin(E * (M_PI / 180)) * sqrt(1 - pow(e, 2)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // find the distance and true anomaly 
														 | 
														
														 | 
														
															     // find the distance and true anomaly 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double r = sqrt(pow(x,2) + pow(y,2)); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double v = atan2(y, x)*(180 / M_PI); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double r = sqrt(pow(x, 2) + pow(y, 2)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double v = atan2(y, x) * (180 / M_PI); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // find the longitude of the sun 
														 | 
														
														 | 
														
															     // find the longitude of the sun 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double solarlongitude = v + w; 
														 | 
														
														 | 
														
															     double solarlongitude = v + w; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // compute the ecliptic rectangular coordinates 
														 | 
														
														 | 
														
															     // compute the ecliptic rectangular coordinates 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double xeclip = r*cos(solarlongitude*(M_PI / 180)); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double yeclip = r*sin(solarlongitude*(M_PI / 180)); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double xeclip = r * cos(solarlongitude * (M_PI / 180)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double yeclip = r * sin(solarlongitude * (M_PI / 180)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double zeclip = 0.0; 
														 | 
														
														 | 
														
															     double zeclip = 0.0; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     //rotate these coordinates to equitorial rectangular coordinates 
														 | 
														
														 | 
														
															     //rotate these coordinates to equitorial rectangular coordinates 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double xequat = xeclip; 
														 | 
														
														 | 
														
															     double xequat = xeclip; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double yequat = yeclip*cos(oblecl*(M_PI / 180)) + zeclip * sin(oblecl*(M_PI / 180)); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double zequat = yeclip*sin(23.4406*(M_PI / 180)) + zeclip * cos(oblecl*(M_PI / 180)); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double yequat = yeclip * cos(oblecl * (M_PI / 180)) + zeclip * sin(oblecl * (M_PI / 180)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double zequat = yeclip * sin(23.4406 * (M_PI / 180)) + zeclip * cos(oblecl * (M_PI / 180)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // convert equatorial rectangular coordinates to RA and Decl: 
														 | 
														
														 | 
														
															     // convert equatorial rectangular coordinates to RA and Decl: 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    r = sqrt(pow(xequat, 2) + pow(yequat, 2) + pow(zequat, 2)) - (Alt / 149598000); //roll up the altitude correction 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double RA = atan2(yequat, xequat)*(180 / M_PI); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double delta = asin(zequat / r)*(180 / M_PI); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    r = sqrt(pow(xequat, 2) + pow(yequat, 2) + pow(zequat, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                                                   2)) - (Alt / 149598000); //roll up the altitude correction 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double RA = atan2(yequat, xequat) * (180 / M_PI); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double delta = asin(zequat / r) * (180 / M_PI); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // GET UTH time 
														 | 
														
														 | 
														
															     // GET UTH time 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double UTH = utc_time_point.time().hour() + utc_time_point.time().minute()/60.0 + utc_time_point.time().second()/3600.0; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double UTH = utc_time_point.time().hour() + utc_time_point.time().minute() / 60.0 + 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                 utc_time_point.time().second() / 3600.0; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // Calculate local siderial time 
														 | 
														
														 | 
														
															     // Calculate local siderial time 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double GMST0 = fmod(L + 180, 360.0) / 15; 
														 | 
														
														 | 
														
															     double GMST0 = fmod(L + 180, 360.0) / 15; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     double SIDTIME = GMST0 + UTH + lon / 15; 
														 | 
														
														 | 
														
															     double SIDTIME = GMST0 + UTH + lon / 15; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // Replace RA with hour angle HA 
														 | 
														
														 | 
														
															     // Replace RA with hour angle HA 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double HA = (SIDTIME*15 - RA); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double HA = (SIDTIME * 15 - RA); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // convert to rectangular coordinate system 
														 | 
														
														 | 
														
															     // convert to rectangular coordinate system 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    x = cos(HA*(M_PI / 180))*cos(delta*(M_PI / 180)); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    y = sin(HA*(M_PI / 180))*cos(delta*(M_PI / 180)); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double z = sin(delta*(M_PI / 180)); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    x = cos(HA * (M_PI / 180)) * cos(delta * (M_PI / 180)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    y = sin(HA * (M_PI / 180)) * cos(delta * (M_PI / 180)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double z = sin(delta * (M_PI / 180)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // rotate this along an axis going east - west. 
														 | 
														
														 | 
														
															     // rotate this along an axis going east - west. 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double zhor = x*sin((90 - lat)*(M_PI / 180)) + z*cos((90 - lat)*(M_PI / 180)); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double zhor = x * sin((90 - lat) * (M_PI / 180)) + z * cos((90 - lat) * (M_PI / 180)); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															     // Find the Elevation 
														 | 
														
														 | 
														
															     // Find the Elevation 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    double elevation = asin(zhor)*(180 / M_PI); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    double elevation = asin(zhor) * (180 / M_PI); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     return elevation; 
														 | 
														
														 | 
														
															     return elevation; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 } 
														 | 
														
														 | 
														
															 } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -331,12 +340,13 @@ double calc::solarElevation(QDateTime utc_time_point, double lat, double lon) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 int calc::calculateNightTime(QString dept, QString dest, QDateTime departureTime, int tblk) 
														 | 
														
														 | 
														
															 int calc::calculateNightTime(QString dept, QString dest, QDateTime departureTime, int tblk) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 { 
														 | 
														
														 | 
														
															 { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     QVector<QString> columns = {"lat", "long"}; 
														 | 
														
														 | 
														
															     QVector<QString> columns = {"lat", "long"}; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    QVector<QString> deptCoordinates = db::multiSelect(columns,"airports", "icao", dept, db::exactMatch); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    QVector<QString> destCoordinates = db::multiSelect(columns,"airports", "icao", dest, db::exactMatch); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    QVector<QString> deptCoordinates = db::multiSelect(columns, "airports", "icao", dept, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                                                       db::exactMatch); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    QVector<QString> destCoordinates = db::multiSelect(columns, "airports", "icao", dest, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                                                       db::exactMatch); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    if(deptCoordinates.isEmpty() || destCoordinates.isEmpty() 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-       ) 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    if (deptCoordinates.isEmpty() || destCoordinates.isEmpty() 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+       ) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         qDebug() << "calc::calculateNightTime - invalid input. aborting."; 
														 | 
														
														 | 
														
															         qDebug() << "calc::calculateNightTime - invalid input. aborting."; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         return 0; 
														 | 
														
														 | 
														
															         return 0; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     } 
														 | 
														
														 | 
														
															     } 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -351,11 +361,13 @@ int calc::calculateNightTime(QString dept, QString dest, QDateTime departureTime 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     qDebug() << "calc::calculateNightTime destLat = " << destLat; 
														 | 
														
														 | 
														
															     qDebug() << "calc::calculateNightTime destLat = " << destLat; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     qDebug() << "calc::calculateNightTime destLon = " << destLon; 
														 | 
														
														 | 
														
															     qDebug() << "calc::calculateNightTime destLon = " << destLon; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    QVector<QVector<double>> route = intermediatePointsOnGreatCircle(deptLat, deptLon, destLat, destLon, tblk); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    QVector<QVector<double>> route = intermediatePointsOnGreatCircle(deptLat, deptLon, destLat, destLon, 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                                                                     tblk); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															     int nightTime = 0; 
														 | 
														
														 | 
														
															     int nightTime = 0; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-    for(int i = 0; i < tblk ; i++) { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        if(solarElevation(departureTime.addSecs(60*i),radToDeg(route[i][0]),radToDeg(route[i][1])) < -0.6) { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    for (int i = 0; i < tblk ; i++) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        if (solarElevation(departureTime.addSecs(60 * i), radToDeg(route[i][0]), 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+                           radToDeg(route[i][1])) < -0.6) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															             nightTime ++; 
														 | 
														
														 | 
														
															             nightTime ++; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         } 
														 | 
														
														 | 
														
															         } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     } 
														 | 
														
														 | 
														
															     } 
														 | 
													
												
											
										
											
												
													
														 | 
														
															@@ -376,34 +388,27 @@ QString calc::formatTimeInput(QString userinput) 
														 | 
													
												
											
												
													
														| 
														 | 
														
															     QTime temptime; //empty time object is invalid by default 
														 | 
														
														 | 
														
															     QTime temptime; //empty time object is invalid by default 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															     bool containsSeperator = userinput.contains(":"); 
														 | 
														
														 | 
														
															     bool containsSeperator = userinput.contains(":"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        if(userinput.length() == 4 && !containsSeperator) 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            temptime = QTime::fromString(userinput,"hhmm"); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        }else if(userinput.length() == 3 && !containsSeperator) 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            if(userinput.toInt() < 240) //Qtime is invalid if time is between 000 and 240 for this case 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-                QString tempstring = userinput.prepend("0"); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-                temptime = QTime::fromString(tempstring,"hhmm"); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            }else 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-                temptime = QTime::fromString(userinput,"Hmm"); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            } 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        }else if(userinput.length() == 4 && containsSeperator) 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            temptime = QTime::fromString(userinput,"h:mm"); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        }else if(userinput.length() == 5 && containsSeperator) 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            temptime = QTime::fromString(userinput,"hh:mm"); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    if (userinput.length() == 4 && !containsSeperator) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        temptime = QTime::fromString(userinput, "hhmm"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } else if (userinput.length() == 3 && !containsSeperator) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        if (userinput.toInt() < 240) { //Qtime is invalid if time is between 000 and 240 for this case 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            QString tempstring = userinput.prepend("0"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            temptime = QTime::fromString(tempstring, "hhmm"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        } else { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+            temptime = QTime::fromString(userinput, "Hmm"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															         } 
														 | 
														
														 | 
														
															         } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } else if (userinput.length() == 4 && containsSeperator) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        temptime = QTime::fromString(userinput, "h:mm"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } else if (userinput.length() == 5 && containsSeperator) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        temptime = QTime::fromString(userinput, "hh:mm"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															  
														 | 
														
														 | 
														
															  
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        output = temptime.toString("hh:mm"); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        if(output.isEmpty()) 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        { 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            /*QMessageBox timeformat(this); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            timeformat.setText("Please enter a valid time. Any of these formats is valid:\n845 0845 8:45 08:45"); 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            timeformat.exec();*/ 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-            qDebug() << "Time input is invalid."; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        } 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															-        return output; 
														 | 
														
														 | 
														
															 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    output = temptime.toString("hh:mm"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    if (output.isEmpty()) { 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        /*QMessageBox timeformat(this); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        timeformat.setText("Please enter a valid time. Any of these formats is valid:\n845 0845 8:45 08:45"); 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        timeformat.exec();*/ 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+        qDebug() << "Time input is invalid."; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    } 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 
														 | 
														
														 | 
														
															+    return output; 
														 | 
													
												
											
												
													
														| 
														 | 
														
															 } 
														 | 
														
														 | 
														
															 } 
														 |