/** Retourne le stream associé à une URL, d'abord teste le réseau et sinon le cache */
public InputStream getWithBackup(String url) throws Exception {
// Cache non accessible, on retourne directement l'appel distant
if (!isAvailable()) return Util.openStream(url);
Exception eBackup = null;
InputStream is = null;
// Tentative d'accès direct par le réseau
try {
is = Util.openStream(url);
if (is == null) throw new Exception("cache openStream error");
} catch (Exception e) {
is = null;
eBackup = e;
}
String id = codage(url);
File f = new File(dir + Util.FS + id);
// Ca a marché en direct !
if (is != null) {
// Devrais-je tenter de remettre à jour le cache
if (!f.isFile() || outOfDate(f)) add(url);
return is;
}
// Ca n'a pas marché en direct, peut être présent dans le cache ?
if (f.isFile() && f.canRead() && f.length() > 0) {
aladin.trace(3, "[" + url + "] backup from cache !");
return new FileInputStream(f);
}
// Bon, pas d'autre solution
throw eBackup;
}
/** Met dans le cache le résultat de l'url indiquée */
public boolean putInCache(String url) throws Exception {
// Lecture
MyInputStream in = null;
try {
in = Util.openStream(url);
byte buf[] = in.readFully();
// Nettoyage et Ecriture
String id = codage(url);
File g = new File(dir + Util.FS + id);
g.delete();
RandomAccessFile f = null;
try {
f = new RandomAccessFile(dir + Util.FS + id, "rw");
f.write(buf);
} finally {
if (f != null) f.close();
}
aladin.trace(3, "Put in cache [" + url + "]");
return true;
} catch (Exception e) {
if (aladin.levelTrace >= 3) e.printStackTrace();
} finally {
if (in != null) in.close();
}
return false;
}
private synchronized void startThread() {
if (!aladin.NETWORK) return;
if (thread != null) return;
thread = new Thread(this, "Cache updater");
Util.decreasePriority(Thread.currentThread(), thread);
// thread.setPriority( Thread.NORM_PRIORITY -2);
thread.start();
}
private boolean getIsColorByPath(String path, boolean local) {
String ext = inPNG ? ".png" : ".jpg";
MyInputStream in = null;
try {
if (local) return Util.isJPEGColored(path + Util.FS + "Norder3" + Util.FS + "Allsky" + ext);
in = new MyInputStream(Util.openStream(path + "/Norder3/Allsky" + ext));
byte[] buf = in.readFully();
return Util.isColoredImage(buf);
} catch (Exception e) {
aladin.trace(3, "Allsky" + ext + " not found => assume B&W survey");
return false;
} finally {
try {
if (in != null) in.close();
} catch (Exception e1) {
}
}
}
/** Retourne true si le cache est actif */
protected boolean isAvailable() {
while (cacheLock) {
try {
Util.pause(100);
} catch (Exception e) {
}
}
return dir != null;
}
/**
* Codage d'une chaine pour servir en tant que nom de fichier. Remplace tous ce qui n'est ni
* lettre ni chiffre en code hexa préfixé par _
*/
private static String codage(String s) {
StringBuffer r = new StringBuffer();
char a[] = s.toCharArray();
for (int i = 0; i < a.length; i++) {
char c = a[i];
if (!Character.isLetterOrDigit(c)) r.append(PREFIX + Util.hex(c));
else r.append(c);
}
return r.toString();
}
/** Utilisé pour le calcul des statistiques sur un polygone */
protected double statPixel(Graphics g, int x, int y, ViewSimple v, HistItem onMouse) {
// Mise à jour des stats
double pix;
PlanImage pi = (PlanImage) v.pref;
Color col = g.getColor();
if (!(plan instanceof PlanBG)
&& (y < 0
|| y >= pi.naxis2
|| x < 0
|| x >= pi.naxis1
|| (pi.fmt == PlanImage.JPEG || pi.pixelsOrigin == null && !pi.isBigImage()))) {
pix = Double.NaN;
} else {
pix = pi.getPixelInDouble(x, y);
}
double zoom = v.getZoom();
// Coloriage du pixel si concerné
if (g != null && onMouse != null && onMouse.contains(pix)) {
Point p = v.getViewCoord(x + 0.5, y + 0.5);
if (p != null) {
g.setColor(Color.cyan);
int z1 = (int) zoom;
if (z1 < 1) z1 = 2;
g.fillRect(p.x - z1 / 2, p.y - z1 / 2, z1, z1);
}
}
if (zoom > 2) {
Point p = v.getViewCoord(x + 0.5, y + 0.5);
if (Double.isNaN(pix)) g.setColor(Color.orange);
else g.setColor(Color.red);
if (zoom > 4) Util.fillCircle5(g, p.x, p.y);
else Util.fillCircle2(g, p.x, p.y);
}
g.setColor(col);
return statPixel(pix);
}
/** Utilisé pour le calcul des statistiques sur un polygone */
protected double statPixel(
Graphics g, double pix, double ra, double dec, ViewSimple v, HistItem onMouse) {
Coord coo = new Coord(ra, dec);
v.getProj().getXY(coo);
Color col = g.getColor();
// Détermination de la taille d'un pixel Healpix sur la vue.
double pixelSize =
v.rv.height / (v.getTailleDE() / ((PlanBG) v.pref).getPixelResolution()) / Math.sqrt(2);
// Coloriage du pixel si concerné
if (g != null && onMouse != null && onMouse.contains(pix)) {
Point p = v.getViewCoord(coo.x, coo.y);
if (p != null) {
g.setColor(Color.cyan);
int z1 = (int) pixelSize;
if (z1 < 1) z1 = 2;
Polygon pol =
new Polygon(
new int[] {p.x, p.x + z1, p.x, p.x - z1},
new int[] {p.y - z1, p.y, p.y + z1, p.y},
4);
g.fillPolygon(pol);
}
}
if (pixelSize > 4) {
Point p = v.getViewCoord(coo.x, coo.y);
if (Double.isNaN(pix)) g.setColor(Color.orange);
else g.setColor(Color.red);
if (pixelSize > 8) Util.fillCircle5(g, p.x, p.y);
else Util.fillCircle2(g, p.x, p.y);
}
g.setColor(col);
return statPixel(pix);
}
private int getMaxOrderByPath(String urlOrPath, boolean local) {
for (int n = 25; n >= 1; n--) {
if (local && new File(urlOrPath + Util.FS + "Norder" + n).isDirectory()
|| !local && Util.isUrlResponding(urlOrPath + "/Norder" + n)) return n;
}
return -1;
// int maxOrder=-1;
// for( int n=3; n<100; n++ ) {
// if( local && !(new File(urlOrPath+Util.FS+"Norder"+n).isDirectory()) ||
// !local && !Util.isUrlResponding(urlOrPath+"/Norder"+n)) break;
// maxOrder=n;
// }
// return maxOrder;
}
/** Retourne le Stream associé à une URL */
public InputStream get(String url) throws Exception {
// Cache non accessible, on retourne directement l'appel distant
if (!isAvailable()) return Util.openStream(url);
String id = codage(url);
File f = new File(dir + Util.FS + id);
// Présent dans le cache, génial !
if (f.isFile() && f.canRead() && f.length() > 0) {
// Devra être mise à jour ?
if (outOfDate(f)) add(url);
aladin.trace(3, "[" + url + "] read in cache !");
return new FileInputStream(f);
}
// Absent du cache, on va l'y mettre et appeler à nouveau la méthode
if (putInCache(url)) return get(url);
// Bon, je n'y arrive pas
System.err.println("Caching not available for [" + url + "] !!!");
// return (new URL(url)).openStream();
return Util.openStream(url);
}
private String getOnlyInfo(Source s, boolean tab1) {
String ret;
int idx = s.info.indexOf('\t');
if (idx >= 0) ret = s.info.substring(idx + 1);
else ret = s.info;
if (colFilter != null) {
int[] idxColToKeep = tab1 ? idxColToKeep1 : idxColToKeep2;
String[] values = cds.tools.Util.split(ret, "\t", ':', ':');
ret = "";
for (int i = 0; i < idxColToKeep.length; i++) {
ret += values[idxColToKeep[i]];
if (i < idxColToKeep.length - 1) ret += "\t";
}
}
return ret;
}
private Color getColor(SavotResource res) {
ParamSet params = res.getParams();
int nbParams = params.getItemCount();
SavotParam param;
for (int i = 0; i < nbParams; i++) {
param = (SavotParam) params.getItemAt(i);
param = getParam(param);
if (param != null && param.getName().equalsIgnoreCase("color")) {
String val = param.getValue();
int idx = Util.indexInArrayOf(val, Action.COLORNAME);
if (idx >= 0) return Action.MYCOLORS[idx];
else return Action.decodeStaticRGB(val);
}
}
return null;
}
/** Met à jour le cache en fonction de la liste todo */
private void updateCache() {
aladin.trace(2, "Start cache updater...");
Vector v;
synchronized (this) {
v = (Vector) todo.clone();
todo.clear();
}
Enumeration e = v.elements();
while (e.hasMoreElements()) {
String url = (String) e.nextElement();
try {
putInCache(url);
} catch (Exception e1) {
}
Util.pause(1000); // Pose entre deux
}
fin();
}
/**
* Fills the result plane, result from a cross-match, and finalizes it (change its status)
*
* @param pc reference to the plane to fill
* @param result array result of the cross-match
* @param p1
* @param p2
* @param coordTab1
* @param array1
*/
private void fillResultPlane(
PlanCatalog pc,
XMatchResult[] result,
Plan p1,
Plan p2,
int[] coordTab1,
double[][] array,
int xmatchType) {
boolean ellXMatch = (xmatchType == POSXMATCH_ELLIPSES);
Obj[] o1 = p1.pcat.getObj();
Obj[] o2 = p2.pcat.getObj();
int idx1, idx2;
Source s1, s2;
double dist;
String newInfo;
Legende leg = null;
Hashtable<String, Legende> legMemory =
new Hashtable<String, Legende>(); // mémoire des légendes créées
Legende saveLeg1, saveLeg2;
saveLeg1 = saveLeg2 = null;
Hashtable<Legende, ArrayList<Source>> legToSources =
new Hashtable<Legende, ArrayList<Source>>(); // correspondance légende --> sources résultats
ArrayList<Source> tmp;
Source srcResult = null;
for (int i = 0; i < result.length; i++) {
idx1 = result[i].idx1;
idx2 = result[i].idx2;
dist = result[i].dist;
s1 = (Source) o1[idx1];
s2 = (dist == -1.0) ? null : (Source) o2[idx2];
// doit-on créer une nouvelle légende ?
if (saveLeg1 == null
|| saveLeg2 == null
|| s1.leg != saveLeg1
|| (s2 != null && s2.leg != saveLeg2)) {
saveLeg1 = s1.leg;
saveLeg2 = s2 == null ? null : s2.leg;
String id = s1.leg.toString() + (s2 == null ? "null" : s2.leg.toString());
if ((leg = legMemory.get(id)) == null) {
leg = createLeg(xmatchType, ellXMatch, s1, s2, coordTab1);
legMemory.put(id, leg);
}
}
// System.out.println("***"+((Source)o1[idx1]).info+"***");
if (xmatchType == JOIN)
newInfo =
"<&_getReadMe "
+ pc.label
+ " >"
+ "\t"
+ getOnlyInfo((Source) o1[idx1], true)
+ "\t"
+ getOnlyInfo((Source) o2[idx2], false);
// non-match
else if (dist == -1.0)
newInfo =
"<&_getReadMe "
+ pc.label
+ " >"
+ "\t"
+ Util.round(dist, 4)
+ "\t"
+ getOnlyInfo((Source) o1[idx1], true);
else
newInfo =
"<&_getReadMe "
+ pc.label
+ " >"
+ "\t"
+ Util.round(dist, 4)
+ "\t"
+ getOnlyInfo((Source) o1[idx1], true)
+ "\t"
+ getOnlyInfo((Source) o2[idx2], false);
if (array == null) {
Source s = (Source) o1[idx1];
srcResult = new Source(pc, s.raj, s.dej, "", newInfo, leg);
} else {
srcResult = new Source(pc, array[idx1][0], array[idx1][1], "", newInfo, leg);
}
// on trie la source nouvellement créée selon la légende associée
tmp = legToSources.get(leg);
if (tmp == null) legToSources.put(leg, tmp = new ArrayList<Source>());
tmp.add(srcResult);
}
// ajout des sources créées dans le plan catalogue, regroupées par légende (pour plans
// multi-tables)
Enumeration<ArrayList<Source>> enumTables = legToSources.elements();
while (enumTables.hasMoreElements()) {
tmp = enumTables.nextElement();
Iterator<Source> it = tmp.iterator();
while (it.hasNext()) pc.pcat.setObjetFast(it.next());
}
// finalisation de la création du plan
pc.setSourceType(Source.getDefaultType(result.length));
pc.setActivated(true);
pc.flagOk = true;
aladin.calque.select.repaint();
aladin.view.repaintAll();
// maj du popup d'aide pour les filtres
FilterProperties.notifyNewPlan();
}
/**
* Construction d'un TreeNodeAllSky à partir des infos qu'il est possible de glaner à l'endroit
* indiqué, soit par exploration du répertoire, soit par le fichier Properties
*/
public TreeNodeAllsky(Aladin aladin, String pathOrUrl) {
String s;
this.aladin = aladin;
local =
!(pathOrUrl.startsWith("http:")
|| pathOrUrl.startsWith("https:")
|| pathOrUrl.startsWith("ftp:"));
MyProperties prop = new MyProperties();
// Par http ou ftp ?
try {
InputStream in = null;
if (!local) in = (new URL(pathOrUrl + "/" + PlanHealpix.PROPERTIES)).openStream();
else in = new FileInputStream(new File(pathOrUrl + Util.FS + PlanHealpix.PROPERTIES));
if (in != null) {
prop.load(in);
in.close();
}
} catch (Exception e) {
aladin.trace(3, "No properties file found => auto discovery...");
}
// recherche du frame Healpix
String strFrame = prop.getProperty(PlanHealpix.KEY_COORDSYS, "G");
char c1 = strFrame.charAt(0);
if (c1 == 'C' || c1 == 'Q') frame = Localisation.ICRS;
else if (c1 == 'E') frame = Localisation.ECLIPTIC;
else if (c1 == 'G') frame = Localisation.GAL;
url = pathOrUrl;
s = prop.getProperty(PlanHealpix.KEY_LABEL);
if (s != null) label = s;
else {
char c = local ? Util.FS.charAt(0) : '/';
int end = pathOrUrl.length();
int offset = pathOrUrl.lastIndexOf(c);
if (offset == end - 1 && offset > 0) {
end = offset;
offset = pathOrUrl.lastIndexOf(c, end - 1);
}
label = pathOrUrl.substring(offset + 1, end);
}
id = "__" + label;
s = prop.getProperty(PlanHealpix.KEY_VERSION);
if (s != null) version = s;
description = prop.getProperty(PlanHealpix.KEY_DESCRIPTION);
verboseDescr = prop.getProperty(PlanHealpix.KEY_DESCRIPTION_VERBOSE);
copyright = prop.getProperty(PlanHealpix.KEY_COPYRIGHT);
copyrightUrl = prop.getProperty(PlanHealpix.KEY_COPYRIGHT_URL);
useCache = !local && Boolean.parseBoolean(prop.getProperty(PlanHealpix.KEY_USECACHE, "True"));
s = prop.getProperty(PlanHealpix.KEY_TARGET);
if (s == null) target = null;
else {
try {
target = new Coord(s);
} catch (Exception e) {
aladin.trace(3, "target error!");
target = null;
}
}
s = prop.getProperty(PlanHealpix.KEY_TARGETRADIUS);
if (s == null) radius = -1;
else {
try {
radius = Server.getAngle(s, Server.RADIUSd);
} catch (Exception e) {
aladin.trace(3, "radius error!");
radius = -1;
}
}
s = prop.getProperty(PlanHealpix.KEY_NSIDE);
if (s != null)
try {
nside = Integer.parseInt(s);
} catch (Exception e) {
aladin.trace(3, "NSIDE number not parsable !");
nside = -1;
}
try {
maxOrder = new Integer(prop.getProperty(PlanHealpix.KEY_MAXORDER));
} catch (Exception e) {
maxOrder = getMaxOrderByPath(pathOrUrl, local);
if (maxOrder == -1) {
aladin.trace(3, "No maxOrder found (even with scanning dir.) => assuming 11");
maxOrder = 11;
}
}
// Les paramètres liés aux cubes
try {
cube = new Boolean(prop.getProperty(PlanHealpix.KEY_ISCUBE));
} catch (Exception e) {
cube = false;
}
if (cube) {
s = prop.getProperty(PlanHealpix.KEY_CUBEDEPTH);
if (s != null) {
try {
cubeDepth = Integer.parseInt(s);
} catch (Exception e) {
aladin.trace(3, "CubeDepth syntax error [" + s + "] => trying autodetection");
cubeDepth = -1;
}
}
s = prop.getProperty(PlanHealpix.KEY_CUBEFIRSTFRAME);
if (s != null) {
try {
cubeFirstFrame = Integer.parseInt(s);
} catch (Exception e) {
aladin.trace(3, "cubeFirstFrame syntax error [" + s + "] => assuming frame 0");
cubeFirstFrame = -1;
}
}
}
progen = pathOrUrl.endsWith("HpxFinder") || pathOrUrl.endsWith("HpxFinder/");
s = prop.getProperty(PlanHealpix.KEY_ISCAT);
if (s != null) cat = new Boolean(s);
else cat = getFormatByPath(pathOrUrl, local, 2);
// Détermination du format des cellules dans le cas d'un survey pixels
String keyColor = prop.getProperty(PlanHealpix.KEY_ISCOLOR);
if (keyColor != null) color = new Boolean(keyColor);
// if( color ) inJPEG=true;
if (!cat && !progen /* && (keyColor==null || !color)*/) {
String format = prop.getProperty(PlanHealpix.KEY_FORMAT);
if (format != null) {
int a, b;
inFits = (a = Util.indexOfIgnoreCase(format, "fit")) >= 0;
inJPEG =
(b = Util.indexOfIgnoreCase(format, "jpeg")) >= 0
|| (b = Util.indexOfIgnoreCase(format, "jpg")) >= 0;
inPNG = (b = Util.indexOfIgnoreCase(format, "png")) >= 0;
truePixels = inFits && a < b; // On démarre dans le premier format indiqué
} else {
inFits = getFormatByPath(pathOrUrl, local, 0);
inJPEG = getFormatByPath(pathOrUrl, local, 1);
inPNG = getFormatByPath(pathOrUrl, local, 3);
truePixels =
local && inFits
|| !(!local
&& (inJPEG
|| inPNG)); // par défaut on démarre en FITS en local, en Jpeg en distant
}
if (keyColor == null) {
color = getIsColorByPath(pathOrUrl, local);
}
if (color) truePixels = false;
}
aladin.trace(4, toString1());
}
public TreeNodeAllsky(
Aladin aladin,
String actionName,
String id,
String aladinMenuNumber,
String url,
String aladinLabel,
String description,
String verboseDescr,
String ack,
String aladinProfile,
String copyright,
String copyrightUrl,
String path,
String aladinHpxParam) {
super(aladin, actionName, aladinMenuNumber, aladinLabel, path);
this.aladinLabel = aladinLabel;
this.url = url;
this.description = description;
this.verboseDescr = verboseDescr;
this.ack = ack;
this.copyright = copyright;
this.copyrightUrl = copyrightUrl;
this.hpxParam = aladinHpxParam;
this.aladinProfile = aladinProfile;
this.internalId = id;
if (this.url != null) {
char c = this.url.charAt(this.url.length() - 1);
if (c == '/' || c == '\\') this.url = this.url.substring(0, this.url.length() - 1);
}
// Parsing des paramètres Healpix
// ex: 3 8 nocache
boolean first = true;
if (hpxParam != null) {
StringTokenizer st = new StringTokenizer(hpxParam);
try {
String s;
while (st.hasMoreTokens()) {
s = st.nextToken();
// test minOrder maxOrder (si un seul nombre => maxOrder);
try {
int n = Integer.parseInt(s);
if (maxOrder != -1) {
minOrder = maxOrder;
maxOrder = n;
} else maxOrder = n;
} catch (Exception e) {
}
if (Util.indexOfIgnoreCase(s, "nocache") >= 0) useCache = false;
if (Util.indexOfIgnoreCase(s, "color") >= 0) color = true;
if (Util.indexOfIgnoreCase(s, "cube") >= 0) cube = true;
if (Util.indexOfIgnoreCase(s, "fits") >= 0) {
inFits = true;
if (first) {
first = false;
truePixels = true;
}
}
if (Util.indexOfIgnoreCase(s, "jpeg") >= 0) {
inJPEG = true;
if (first) {
first = false;
truePixels = false;
}
}
if (Util.indexOfIgnoreCase(s, "png") >= 0) {
inPNG = true;
if (first) {
first = false;
truePixels = false;
}
}
if (Util.indexOfIgnoreCase(s, "gal") >= 0) frame = Localisation.GAL;
if (Util.indexOfIgnoreCase(s, "ecl") >= 0) frame = Localisation.ECLIPTIC;
if (Util.indexOfIgnoreCase(s, "equ") >= 0) frame = Localisation.ICRS;
if (Util.indexOfIgnoreCase(s, "cat") >= 0) cat = true;
if (Util.indexOfIgnoreCase(s, "progen") >= 0) progen = true;
if (Util.indexOfIgnoreCase(s, "map") >= 0) map = true;
if (Util.indexOfIgnoreCase(s, "moc") >= 0) moc = true;
// Un numéro de version du genre "v1.23" ?
if (s.charAt(0) == 'v') {
try {
double n = Double.parseDouble(s.substring(1));
version = "-" + s;
} catch (Exception e) {
}
}
}
if (minOrder == -1) minOrder = 2;
if (maxOrder == -1) maxOrder = 8;
} catch (Exception e) {
}
}
// dans le cas d'un répertoire local => pas d'utilisateur du cache
if (url != null && !url.startsWith("http") && !url.startsWith("ftp")) useCache = false;
if (copyright != null || copyrightUrl != null) setCopyright(copyright);
// Aladin.trace(3,this.toString1());
}
/** Affichage des statistiques d'un polygone */
protected void statDraw(Graphics g, ViewSimple v, int dx, int dy) {
// Juste pour afficher le débugging des losanges HEALPix couvrant
// if( v.pref instanceof PlanBG && ((PlanBG)v.pref).DEBUGMODE ) { statCompute(g,v);
// return; }
if (!v.flagPhotometry || !v.pref.hasAvailablePixels() || v.pref instanceof PlanImageRGB) return;
if (!statCompute(g, v)) return;
String cnt = Util.myRound(nombre);
String sum = Util.myRound(total);
String avg = Util.myRound(moyenne);
String med = Double.isNaN(mediane) ? "" : Util.myRound(mediane);
String sig = Util.myRound(sigma);
String surf = Coord.getUnit(surface, false, true) + "²";
if (isWithStat() || isWithLabel()) {
Rectangle r = getStatPosition(v);
if (r != null && (isWithLabel() || v.aladin.view.isMultiView())) {
r.x += dx;
r.y += dy;
g.drawLine(r.x, r.y, r.x, r.y + HAUTSTAT);
if (posx == -1) {
posx = (int) (minx + 3 * (maxx - minx) / 4.);
posy = (maxy + miny) / 2;
}
Point c = v.getViewCoord(posx, posy);
if (c != null) {
g.drawLine(r.x, r.y + HAUTSTAT / 2, c.x, c.y);
Util.fillCircle5(g, c.x, c.y);
r.x += 2;
r.y += STATDY - 2;
g.setFont(Aladin.BOLD);
g.drawString("Cnt", r.x, r.y);
g.drawString(cnt, r.x + 43, r.y);
r.y += STATDY;
g.drawString("Sum", r.x, r.y);
g.drawString(sum, r.x + 43, r.y);
r.y += STATDY;
g.drawString("Avg", r.x, r.y);
g.drawString(avg, r.x + 43, r.y);
r.y += STATDY;
g.drawString("Sigma", r.x, r.y);
g.drawString(sig, r.x + 43, r.y);
r.y += STATDY;
if (this instanceof Repere) {
g.drawString("Rad", r.x, r.y);
g.drawString(Coord.getUnit(((Repere) this).getRadius()), r.x + 43, r.y);
r.y += STATDY;
}
g.drawString("Surf", r.x, r.y);
g.drawString(surf, r.x + 43, r.y);
r.y += STATDY;
if (!Double.isNaN(mediane)) {
g.drawString("Med", r.x, r.y);
g.drawString(med, r.x + 43, r.y);
r.y += STATDY;
}
}
}
}
if (v.pref == plan.aladin.calque.getPlanBase()) {
id =
"Cnt "
+ cnt
+ " / Sum "
+ sum
+ " / Avg "
+ avg
+ " / Sigma "
+ sig
+ (this instanceof Repere
? " / Rad " + Coord.getUnit(((Repere) this).getRadius())
: "")
+ " / Surf "
+ surf
+ (Double.isNaN(mediane) ? "" : " / Med " + med);
histOn();
}
// status(plan.aladin);
}
private boolean getFormatByPath(String path, boolean local, int fmt) {
String ext = fmt == 0 ? ".fits" : fmt == 1 ? ".jpg" : fmt == 3 ? ".png" : ".xml";
return local && (new File(path + Util.FS + "Norder3" + Util.FS + "Allsky" + ext)).exists()
|| !local && Util.isUrlResponding(path + "/Norder3/Allsky" + ext);
}
