package models;
import models.coordinates.EclipticCoordinates;
import models.coordinates.EquatorialCoordinates;
import models.coordinates.LocalHorizontalCoordinates;
import models.coordinates.UserCoordinates;
/**
* General purpose tools for Coordinates
*
* @author francois
* @version 23 avr. 2013
*/
public class Coordinates {
/**
*
* @param c
* the equatorial coordinates to be converted
* @param uc
* the position of the user
* @return the corresponding LocalHorizontalCoordinates
*/
public static LocalHorizontalCoordinates equatorialToLocalHorizontal(EquatorialCoordinates c, UserCoordinates uc) {
return equatorialToLocalHorizontal(c.getAscention(), c.getDeclinaison(), uc.getTheta(), uc.getLongitude(), uc.getLatitude());
}
private static LocalHorizontalCoordinates equatorialToLocalHorizontal(double ascention, double declinaison, double Theta, double longitude, double latitude) {
/*
* Theta est le temps sidéral à Greenwich à la date et l'heure
* considérée. L est la longitude de l'observateur (positive à l'ouest
* de Greenwich) Phi est la latitude de l'observateur
*/
double H = Math.toRadians(15 * Theta) - longitude - ascention;
double y = Math.sin(H);
double x = Math.cos(H) * Math.sin(latitude) - Math.tan(declinaison) * Math.cos(latitude);
double A = atan(y, x);
double h = Math.asin(Math.sin(latitude) * Math.sin(declinaison) + Math.cos(latitude) * Math.cos(H) * Math.cos(declinaison));
return new LocalHorizontalCoordinates(A, h);
}
/**
* Converts ecliptic Coordinates to equatorial coordinates
*
* @param c
* the set of ecliptic coordinates
* @param uc
* the user position (equatorial Coordinates)
* @return the equivalent equatorial coordinates
*/
public static EquatorialCoordinates eclipticToEquatorial(EclipticCoordinates c, UserCoordinates uc) {
return eclipticToEquatorial(c.getLatitude(), c.getLongitude(), uc.getEpsilon());
}
private static EquatorialCoordinates eclipticToEquatorial(double latitude, double longitude, double epsilon) {
/*
* epsilon obliquité de l'ecliptique.
* longitude ecliptic : lambda
* latitude ecliptic : beta
*/
double y = Math.sin(longitude) * Math.cos(epsilon) - Math.tan(latitude) * Math.sin(epsilon);
double x = Math.cos(longitude);
double alpha = atan(y, x);
double delta = Math.sin(latitude) * Math.cos(epsilon) + Math.cos(latitude) * Math.sin(epsilon) * Math.sin(longitude);
delta = Math.asin(delta);
return new EquatorialCoordinates(alpha, delta);
}
/**
* Converts ecliptic Coordinates to LocalHorizontal coordinates
*
* @param c
* the ecliptic coordinates to be converted
* @param uc
* the users'position
* @return the corresponding local horizontal coordinates
*/
public static LocalHorizontalCoordinates eclipticToLocalHorizontal(EclipticCoordinates c, UserCoordinates uc) {
// TODO : simplify (sin(arcsin ...)etc...)
return equatorialToLocalHorizontal(eclipticToEquatorial(c, uc), uc);
}
/**
* "True" arctan function
*
* @param y
* @param x
* @return the arctan of y/x
*/
private static double atan(double y, double x) {
double alpha;
if (x == 0) {
if (y < 0)
alpha = Math.PI / 2;
else
alpha = 3 * Math.PI / 2;
} else
alpha = Math.atan(y / x);
if (x < 0)
alpha += Math.PI;
else if (y < 0)
alpha += 2 * Math.PI;
return alpha;
}
public static double DegreesMinutesSecondsToRadians(String dms) {
String[] dmsparts = treatSeparator(dms);
double deg = Double.parseDouble(dmsparts[0]);
double min = Double.parseDouble(dmsparts[1]);
double sec = Double.parseDouble(dmsparts[2]);
return Math.toRadians(deg + min/60 + sec/3600);
}
public static double HoursMinutesSecondsToRadians(String hms) {
String[] hmsparts = treatSeparator(hms);
double hour = Double.parseDouble(hmsparts[0]);
double min = Double.parseDouble(hmsparts[1]);
double sec = Double.parseDouble(hmsparts[2]);
return (hour + min/60 + sec/3600)*Math.PI/12;
}
private static String[] treatSeparator(String str) {
String[] dmsparts = str.split(":");
if (dmsparts.length < 3)
return treatSeparator("0:"+str);
return dmsparts;
}
}