libcds-moc-java/0000775000175000017500000000000012710431770013313 5ustar sladensladenlibcds-moc-java/cds/0000755000175000017500000000000012630020762014056 5ustar sladensladenlibcds-moc-java/cds/moc/0000755000175000017500000000000012710430064014633 5ustar sladensladenlibcds-moc-java/cds/moc/Array.java0000644000175000017500000000647712535606610016601 0ustar sladensladen// Copyright 2011 - UDS/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc; import java.util.Iterator; /** * Fast array : see ShortArray, IntArray and LongArray classes * @version 1.0 - oct 2011 * @author P.Fernique [CDS] */ public abstract class Array implements Iterable,Cloneable { static protected final int DEFAULTBLOC = 128; protected int size; // Real array size protected boolean sorted; // true if the array is sorted protected int sizeBloc; // Bloc size for increasing the array /** Return true if the array is ascending sorted */ public boolean isSorted() { return sorted; } /** Size of the array */ public int getSize() { return size; } /** set the size of the array */ public int setSize(int size) { return this.size=size; } public abstract Object clone(); /** Provide the element i */ public abstract long get(int i); /** set the element i */ public abstract void set(int i,long v); /** Add a value, with or without checking unicity */ public abstract boolean add(long v, boolean testUnicity); /** Delete value v from the array */ public abstract boolean delete(long v); /** Delete range of values */ public abstract boolean delete(long v1,long v2); /** Delete 3 others brothers if all present */ public abstract boolean deleteBrothers(long me); /** Sort the array (if required) */ public abstract void sort(); /** Find index of value v, or return negative value (bsearch result) * if it is not present in the array */ public abstract int find(long v); /** Return false if no value in the range [vStart..vEnd] * is present in the array */ public abstract boolean intersectRange(long vStart, long vEnd); /** Size of the array in bytes */ public abstract long getMem(); /** Return the size of the array in compressed mode */ public abstract int getSizeCompressed(); /** Trim the array in order to free the not required memory */ public abstract void trim(); /** Equality test */ public abstract boolean equals(Array a); /** Provide an iterator on the array */ public Iterator iterator() { return new ArrayIterator(); } // Création d'un itérator sur la liste des valeurs private class ArrayIterator implements Iterator { private int indice=0; public boolean hasNext() { return indice consecutive values are memorized as range (2 values) * @return Number of values */ public int getSizeCompressed() { if( array==null ) return 0; int reduce=0; boolean oConsecutif=false; for( int i=1; i=0 ) return false; adjustSize(1); if( testUnicity && sorted ) { pos = -(pos+1); System.arraycopy(array, pos, array, pos+1, size-pos); array[pos]=v; size++; } else { if( sorted ) sorted= size==0 || v>array[size-1]; array[size++]=v; } return true; } /** Delete the first value equals to v * kept the array sorted if required * @param v the value to remove * @return true if the value has been removed */ public boolean delete(long v) { return delete((short)v); } public boolean delete(short v) { int pos = find(v); if( pos<0 ) return false; if( !sorted ) array[pos] = array[size-1]; else System.arraycopy(array, pos+1, array, pos, size-pos-1); size--; return true; } /** Delete the all values between v1 and v2 (inclusive) * kept the array sorted if required * @param v1 the low range value * @param v2 the high range value * @return true if at least one value has been removed */ public boolean delete(long v1,long v2) { return delete((short)v1,(short)v2); } public boolean delete(short v1,short v2) { int i,j; for( i=j=0; iv2 ) array[j++]=array[i]; } size=j; return j!=i; } /** Delete three other brothers only of all of them are already present * (apart me) * @return false if not found */ public boolean deleteBrothers(long me) { return deleteBrothers((short)me); } public boolean deleteBrothers(short me) { int firstBrother = me - me%4; int pos[] = new int[3]; // Search three other brothers for( int j=0,i=0; j<3 && i<4; i++,j++ ) { int v = firstBrother+i; if( v==me ) { j--; continue; } if( j==0 ) pos[j] = find(v); else { if( sorted ) { pos[j] = array[pos[j-1]+1]==v ? pos[j-1]+1 : -1; } else pos[j] = find(v); } if( pos[j]<0 || sorted && size-pos[j]<3-j ) return false; } // Delete three other brothers if( sorted ) { System.arraycopy(array, pos[2]+1, array, pos[0], size-(pos[2]+1)); } else { for( int i=0; i<3; i++ ) array[ pos[i] ] = array[ size-1-i ]; } size-=3; return true; } /** Return the index of the first value v. -1 if not found. * If the arrays is sorted, proceeds by bsearch (see bsearch doc) * @param v Value to find * @return index of the value, otherwise negative index */ public int find(long v) { return find( (short)v ); } public int find(short v) { if( array==null ) return -1; int i=-1; if( sorted ) { if( size==0 || varray[size-1] ) return -(size+1); i= binarySearch(array,0,size, v); } else { for( i=0; iarray[size-1] ? -(size+1) : binarySearch(array,0, size, vStart); if( pos1>=0 ) return true; int pos2 = size==0 || vEndarray[size-1] ? -(size+1) : binarySearch(array,0, size, vEnd); if( pos2>=0 ) return true; return pos1!=pos2; } else { for( int i=0; i>> 1; short midVal = a[mid]; if (midVal < key) low = mid + 1; else if (midVal > key) high = mid - 1; else return mid; } return -(low + 1); } /** Sort the array (only if required) */ public void sort() { if( array==null ) return; if( sorted ) return; Arrays.sort(array,0,size); sorted=true; } /** Remove the reservation room in the array */ public void trim() { if( array==null || size==array.length ) return; short [] nArray = new short[size]; System.arraycopy(array, 0, nArray, 0, size); } // Adjust the size of the array for adding n values. In if it is too small, copy the array // in a larger array. private void adjustSize(int n) { if( n==0 || array!=null && size+n < array.length ) return; short [] nArray = new short[ (1+ (size+n)/sizeBloc) * sizeBloc ]; if( array!=null ) System.arraycopy(array, 0, nArray, 0, size); array=nArray; sizeBloc=sizeBloc+array.length/10; nArray=null; } } libcds-moc-java/cds/moc/HealpixMoc.java0000644000175000017500000015033512710431154017537 0ustar sladensladen// Copyright 2011 - UDS/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc; import healpix.essentials.RangeSet; import java.io.InputStream; import java.io.OutputStream; import java.util.Date; import java.util.HashMap; import java.util.Iterator; import java.util.StringTokenizer; /** HEALPix Multi Order Coverage Map (MOC) * This object provides read, write and process methods to manipulate an HEALPix Multi Order Coverage Map (MOC) * A MOC is used to define a sky region by using HEALPix sky tesselation * * @authors Pierre Fernique [CDS], Martin Reinecke [Max Plank] * @version 4.6 Apr 2016 - MocLint - IVOA 1.0 MOC recommendation compatibility checker * @version 4.5 Nov 2015 - JSON #MOCORDER patch * @version 4.4 Jun 2015 - Empty MOC FITS bug fix * @version 4.2 oct 2014 - setMinLimitOrder() bug fix * @version 4.1 nov 2013 - pixelIterator 4.0 bug fix * @version 4.0 sep 2013 - upgrade for MOC WD 1.0 1 sept 2013 compliance * @version 3.4 oct 2012 - operations by RangeSet * @version 3.3 July 2012 - PixelIterator() addition (low level pixel iterator) * @version 3.2 April 2012 - JSON ASCII support (the previous basic ASCII format is still supported) * @version 3.2 March 2012 - union, intersection,... improvements + refactoring isIntersecting(...) * @version 3.1 Dec 2011 - check() * @version 3.0 Dec 2011 - 1) Use HealpixInterface 2) replace unicityTest by testConsistency 3)code cleaning * @version 2.0 Oct 2011 - use of short, int and long, creation of MocIO class... * @version 1.3 Sept 2011 - Support for delete * @version 1.2 Sept 2011 - COORDSYS support * @version 1.1 Sept 2011 - used sorted MOC (speed improvement) * @version 1.0 June 2011 - first stable version * @version 0.9 May 2011 - creation */ public class HealpixMoc implements Iterable,Cloneable,Comparable { /** Healpix MOC API version number */ static public final String VERSION = "4.6"; /** FITS encoding format (IVOA REC 1.0 compliante) */ static public final int FITS = 0; /** JSON encoding format (IVOA REC 1.0 suggestion) */ static public final int JSON = 1; /** ASCII encoding format (IVOA REC 1.0 suggestion) */ static public final int ASCII = 2; /** JSON obsoleted encoding format (only reading supported for compatibility) */ static public final int JSON0 = 3; /** Maximal HEALPix order supported by the library */ static public final int MAXORDER = 29; static public final int SHORT = 0; static public final int INT = 1; static public final int LONG = 2; /** Provide the integer type for a given order */ static public int getType(int order) { return order<6 ? SHORT : order<14 ? INT : LONG; } private HashMap property; // MOC properties private String coordSys; // Coordinate system (HEALPix convention => G=galactic, C=Equatorial, E=Ecliptic) private int minLimitOrder; // Min order supported (by default 0) private int maxLimitOrder; // Max order supported (by default depending of Healpix library => typically 29) private Array [] level; // pixel list for each HEALPix orders private int nOrder; // The number of orders currently used private boolean testConsistency; // true for checking the consistency during a MOC pixel addition (=> slower) private boolean isConsistant; // true if we are sure that the MOC is consistant private int currentOrder=-1; // last current order for pixel addition /** HEALPix Multi Order Coverage Map (MOC) creation */ public HealpixMoc() { init("C",0,-1); } /** Moc Creation with a specified max limitOrder (by default 29) */ public HealpixMoc(int maxLimitOrder) throws Exception { init("C",0,maxLimitOrder); } /** Moc Creation with a specified min and max limitOrder (by default 0..29) */ public HealpixMoc(int minLimitOrder,int maxLimitOrder) throws Exception { init("C",minLimitOrder,maxLimitOrder); } /** Moc Creation with a specified min and max limitOrder (by default 0..29) * @deprecated Standard MOC must be equatorial */ public HealpixMoc(String coordSys, int minLimitOrder,int maxLimitOrder) throws Exception { init(coordSys,minLimitOrder,maxLimitOrder); } /** HEALPix Multi Order Coverage Map (MOC) creation and initialisation * via a string following ASCII or JSON MOC syntax * ex JSON: { "order1":[npix1,npix2,...], "order2":[npix3...] } * ex basic ASCII: order1/npix1-npix2 npix3 ... order2/npix4 ... * @param s list of MOC pixels */ public HealpixMoc(String s) throws Exception { this(); add(s); } /** HEALPix Multi Order Coverage Map (MOC) creation and initialisation via a stream * @param in input stream */ public HealpixMoc(InputStream in) throws Exception { read(in); } /** HEALPix Multi Order Coverage Map (MOC) creation and initialisation * via a stream, either in ASCII encoded format or in FITS encoded format * @param in input stream * @param mode ASCII - ASCII encoded format, FITS - Fits encoded format * @deprecated see HealpixMoc(InputStream) */ public HealpixMoc(InputStream in, int mode) throws Exception { this(); read(in,mode); } /** Clear the MOC */ public void clear() { init(coordSys,minLimitOrder,maxLimitOrder); } /** Deep copy */ public Object clone() { HealpixMoc moc = new HealpixMoc(); moc.coordSys=coordSys; moc.maxLimitOrder=maxLimitOrder; moc.minLimitOrder=minLimitOrder; moc.nOrder=nOrder; moc.testConsistency=testConsistency; moc.currentOrder=currentOrder; moc.rangeSet= (rangeSet==null) ? null : new RangeSet(rangeSet); for( int order=0; order)property.clone(); return moc; } /** Set the Min limit order supported by the Moc (by default 0) * (and automatically switch on the testConsistency) * Any future addition of pixel with order smallest than minLimitOrder will be automatically replaced by the * addition of its 4 sons. */ public void setMinLimitOrder(int limitOrder) throws Exception { if( limitOrder==minLimitOrder ) return; if( limitOrder>MAXORDER ) throw new Exception("Min limit order exceed HEALPix library possibility ("+MAXORDER+")"); if( limitOrder<0 || maxLimitOrder!=-1 && limitOrder>maxLimitOrder ) throw new Exception("Min limit greater than max limit order"); isConsistant = false; minLimitOrder=limitOrder; setCheckConsistencyFlag(true); } /** Set the limit order supported by the Moc (-1 for Healpix library implementation) * (and automatically switch on the testConsistency) * Any future addition of pixel with order exceeding limitOrder will be automatically replaced by the * addition of the corresponding pixel at the limitOrder. If there is no limitOrder set (-1), an exception * will thrown. */ public void setMocOrder(int order) throws Exception { setMaxLimitOrder(order); } /** Set the limit order supported by the Moc (-1 for Healpix library implementation) * (and automatically switch on the testConsistency) * Any future addition of pixel with order exceeding limitOrder will be automatically replaced by the * addition of the corresponding pixel at the limitOrder. If there is no limitOrder set (-1), an exception * will thrown. * @deprecated see setMocOrder(int) */ public void setMaxLimitOrder(int limitOrder) throws Exception { if( limitOrder==maxLimitOrder ) return; if( limitOrder>MAXORDER ) throw new Exception("Max limit order exceed HEALPix library possibility ("+MAXORDER+")"); if( limitOrder!=-1 && limitOrder redundancy check and hierarchy consistency check during addition (=> slower) * @param flag */ public void setCheckConsistencyFlag(boolean flag) throws Exception { testConsistency=flag; if( testConsistency ) checkAndFix(); } /** return the order of the first descendant, otherwise -1*/ public int getDescendantOrder(int order,long npix) { long pix=npix/4L; for( int o=order-1; o>=0; o--,pix/=4L ) { if( level[o].find(pix)>=0 ) return o; } return -1; } /** Add a list of MOC pixels provided in a string format (JSON format or basic ASCII format) * ex JSON: { "order1":[npix1,npix2,...], "order2":[npix3...] } * ex basic ASCII: order1/npix1-npix2 npix3 ... order2/npix4 ... * Note : The string can be submitted in several times. In this case, the insertion will use the last current order * Note : in JSON, the syntax is not checked ( in fact {, [ and " are ignored) * @see setCheckUnicity(..) */ public void add(String s) throws Exception { StringTokenizer st = new StringTokenizer(s," ;,\n\r\t{}"); while( st.hasMoreTokens() ) { String s1 = st.nextToken(); if( s1.length()==0 ) continue; addHpix(s1); } } /** Add directly a full Moc */ public void add(HealpixMoc moc) throws Exception { setCheckConsistencyFlag(false); for( int order=moc.nOrder-1; order>=0; order-- ) { for( long npix : moc.getArray(order) ) add(order, npix); } setCheckConsistencyFlag(true); } /** Add a Moc pixel * Recursive addition : since with have the 3 brothers, we remove them and add recursively their father * @param cell Moc cell * @return true if the cell (or its father) has been effectively inserted */ public boolean add(MocCell cell) throws Exception { return add(cell.order,cell.npix); } /** Add a Moc pixel (at max order) corresponding to the alpha,delta position * Recursive addition : since with have the 3 brothers, we remove them and add recursively their father * @param alpha, delta position * @return true if the cell (or its father) has been effectively inserted */ public boolean add(HealpixImpl healpix,double alpha, double delta) throws Exception { int order = getMaxOrder(); if( order==-1 ) return false; long npix = healpix.ang2pix(order, alpha, delta); return add(order,npix); } /** Add a MOC pixel * Recursive addition : since with have the 3 brothers, we remove them and add recursively their father * @param order HEALPix order * @param npix Healpix number (-1 if no number => just for memorizing max MocOrder) * @param testHierarchy true if the ascendance and descendance consistance test must be done * @return true if something has been really inserted (npix or ascendant) */ public boolean add(int order, long npix) throws Exception { return add(order,npix,true); } private boolean add(int order, long npix,boolean testHierarchy) throws Exception { rangeSet=null; if( order=0 ) { if( maxLimitOrder!=-1 && order>maxLimitOrder ) return add(order-1, npix>>>2); if( testHierarchy ) { // An ascendant is already inside ? if( order>minLimitOrder && isDescendant(order, npix) ) return false; // remove potential descendants deleteDescendant(order, npix); } if( order>minLimitOrder && deleteBrothers(order,npix) ) { return add(order-1,npix>>>2,testHierarchy); } } return add1(order,npix); } // Delete 3 others brothers if all present private boolean deleteBrothers(int order,long me) { return level[order].deleteBrothers(me); } /** remove a list of MOC pixels provided in a string format * (ex: "order1/npix1-npix2 npix3 ... order2/npix4 ...") */ public void delete(String s) { StringTokenizer st = new StringTokenizer(s," ;,\n\r\t"); while( st.hasMoreTokens() ) deleteHpix(st.nextToken()); } /** Remove a MOC pixel * @param order HEALPix order * @param npix Healpix number * @return true if the deletion has been effectively done */ public boolean delete(int order, long npix) { if( order>=nOrder ) return false; rangeSet=null; return level[order].delete(npix); } /** Remove all descendants of a MOC Pixel * @param order * @param npix * @return true if at least one descendant has been removed */ public boolean deleteDescendant(int order,long npix) { rangeSet=null; long v1 = npix*4; long v2 = (npix+1)*4-1; boolean rep=false; for( int o=order+1 ; o remove cell redundancies * => factorize 4 brothers as 1 father (recursively) * => check and fix descendance consistancy * [REMOVED => Trim the limitOrder if required ] */ public void checkAndFix() throws Exception { if( getMaxOrder()==-1 || isConsistant ) return; rangeSet=null; sort(); HealpixMoc res = new HealpixMoc(coordSys,minLimitOrder,maxLimitOrder); int p[] = new int[getMaxOrder()+1]; for( int npix=0; npix<12; npix++) checkAndFix(res,p,0,npix); // boolean flagTrim=true; for( int order=res.nOrder-1; order>=0; order-- ) { Array a = res.getArray(order); level[order]=a; // On ne change pas le nOrder pour conserver le MocOrder implicite // if( flagTrim && a.getSize()!=0 ) { nOrder=order+1; flagTrim=false; } } nOrder= p.length; // res.nOrder; res=null; isConsistant=true; // System.out.println("checkAndFix: nOrder="+nOrder+" minLimitOrder="+minLimitOrder+" maxLimitOrder="+maxLimitOrder); } // Recursive MOC tree scanning private void checkAndFix(HealpixMoc res, int p[], int order, long pix) throws Exception { Array a; // for( int j=0; j Add + remove possible descendance => return"); return; } // On n'a pas trouvé la cellule, s'il y a une descendance dans l'un ou l'autre // des arbres, on va continuer récursivement sur les 4 fils. boolean found=false; for( int o=order+1; ores.maxLimitOrder ) { // System.out.println(" => rien mais descendance au dela de la limite, Add + remove possible descendance => return"); res.add(order,pix,false); for( int o=order; o rien mais descendance => parcours des fils..."); checkAndFix(res,p,order+1,(pix<<2)+i); } } // else System.out.println(" => aucun descendance => return"); } /** True is the MOC pixel is an ascendant */ public boolean isAscendant(int order, long npix) { long range=4L; for( int o=order+1; o=minLimitOrder; o--,pix/=4L ) { if( level[o].find(pix)>=0 ) return true; } return false; } /** True if the MOC pixel is present at this order */ public boolean isIn(int order, long npix) { return level[order].find(npix)>=0; } /** MOC propertie setter * @param key => MOCORDER, COORDSYS, MOCTOOL, MOCTYPE, MOCID, DATE, ORIGIN, EXTNAME * @param value * @throws Exception */ public void setProperty(String key, String value) throws Exception { // In case of a setProperty() direct call without using setMocOrder(...) if( key.equals("MOCORDER") ) { int mocOrder = Integer.parseInt(value); setMaxLimitOrder(mocOrder); } // In case of a setProperty() direct call without using setCoordSys(...) else if( key.equals("COORDSYS") ) { setCoordSys(value); } // default else property.put(key,value); } /** Provide MOC property value. * Available key properties are: * => MOCORDER, COORDSYS, MOCTOOL, MOCTYPE, MOCID, DATE, ORIGIN, EXTNAME * @param key * @return */ public String getProperty(String key) { return property.get(key); } /** Return the fraction of the sky covered by the Moc [0..1] */ public double getCoverage() { long area = getArea(); long usedArea = getUsedArea(); while( area>(long)Double.MAX_VALUE || usedArea>(long)Double.MAX_VALUE ) { area /= 2L; usedArea /= 2L; } if( area==0 ) return 0.; return (double)getUsedArea() / area; } /** Return the number of low level pixels of the Moc */ public long getUsedArea() { // long n=0; // long sizeCell = 1L; // for( int order=nOrder-1; order>=0; order--, sizeCell*=4L ) n += getSize(order)*sizeCell; // return n; long n=0; long sizeCell = 1L; for( int order=getMocOrder(); order>=0; order--, sizeCell*=4L ) n += getSize(order)*sizeCell; return n; } /** return the area of the Moc computed in pixels at the most low level */ public long getArea() { // if( nOrder==0 ) return 0; // long nside = pow2(nOrder-1); // return 12L*nside*nside; int nOrder = getMocOrder()+1; long nside = pow2(nOrder-1); return 12L*nside*nside; } /** Provide an Iterator on the MOC pixel List. Each Item is a couple of longs, * the first long is the order, the second long is the pixel number */ public Iterator iterator() { return new HpixListIterator(); } /** Provide an Iterator on the low level pixel list covering all the MOC area. * => pixel are provided in ascending order */ public Iterator pixelIterator() { sort(); return new PixelIterator(); } /** Remove all the unused space (allocation reservation) */ public void trim() { for( int order=0; order it = iterator(); for( int i=0; it.hasNext() && i<80; i++ ) { MocCell x = it.next(); if( x.order!=oOrder ) s.append(" "+x.order+"/"); else s.append(","); s.append(x.npix); oOrder=x.order; } if( it.hasNext() ) s.append("...\n"); for( int order=0; orderMAXWORD; boolean first=true; int sizeLine=0; res.append("{"); for( MocCell c : this ) { if( res.length()>0 ) { if( c.order!=order ) { if( !first ) res.append("],"); if( flagNL ) { res.append("\n"); sizeLine=0; } else res.append(" "); } else { int n=(c.npix+"").length(); if( flagNL && n+sizeLine>MAXSIZE ) { res.append(",\n "); sizeLine=3; } else { res.append(','); sizeLine++; } } first=false; } String s = c.order!=order ? "\""+c.order+"\":["+c.npix : c.npix+""; res.append(s); sizeLine+=s.length(); order=c.order; } int n = res.length(); if( first ) res.append("}"); // MOC vide else if( res.charAt(n-1)==',' ) res.replace(n-1, n-1, "]"+(flagNL?"\n":" ")+"}"); else res.append("]"+(flagNL?"\n":" ")+"}"); return res.toString(); } // public static void main(String s[] ) { // try { // HealpixMoc m = new HealpixMoc("1/2-3 2/16-20 3/85-87"); // System.out.println(m); // } catch( Exception e ) { // e.printStackTrace(); // } // } /*************************** Operations on MOCs ************************************************/ public RangeSet rangeSet=null; // Store the MOC as a RangeSet if not yet done public void toRangeSet() { if( rangeSet!=null ) return; // déjà fait sort(); rangeSet = new RangeSet( getSize() ); RangeSet rtmp=new RangeSet(); for (int order=0; order>>shift, b=r2.ivend(iv)>>>shift; r3.append(a<=0 ) return true; if( isDescendant(order,npix) ) return true; return false; } /** * Provide Moc pixels totally or partially inside a circle * @param alpha circle center (in degrees) * @param delta circle center (in degrees) * @param radius circle radius (in degrees) * @return an HealpixMox containing the list of pixels * @throws Exception */ public HealpixMoc queryDisc(HealpixImpl healpix,double alpha, double delta,double radius) throws Exception { int order = getMaxOrder(); long [] list = healpix.queryDisc(order, alpha, delta, radius); HealpixMoc mocA = new HealpixMoc(coordSys,minLimitOrder,maxLimitOrder); mocA.setCheckConsistencyFlag(false); for( int i=0; i13 ) * (Dedicated for fast initialisation) */ public void setPixLevel(int order,long [] val) throws Exception { if( getType(order)!=LONG ) throw new Exception("The order "+order+" requires long[] array"); level[order]=new LongArray(val); if( nOrder { private int currentOrder=0; private int indice=-1; private boolean ready=false; public boolean hasNext() { goNext(); return currentOrder=getSize(currentOrder); currentOrder++, indice=0); ready=true; } } // Création d'un itérator sur la liste des pixels triés et ramenés au max order // Méthode : parcours en parallèle tous les niveaux, en conservant pour chacun d'eux l'indice de sa tête // prends la plus petite "tête", et pour celle-là, itère dans l'intervalle (fonction de la différence par rapport // à l'ordre max => 4 pour order-1, 16 pour order-2 ...). private class PixelIterator implements Iterator { private boolean ready=false; // Le goNext() a été effectué et le pixel courant pas encore lu private long current; // Pixel courant private int order=-1; // L'ordre courant private long indice=0L; // l'indice dans l'intervalle de l'ordre courant private long range=0L; // Nombre d'éléments dans l'intervalle courant private long currentTete; // Valeur de la tete courante private boolean hasNext=true; // false si on a atteind la fin du de tous les ordres private int p[] = new int[getMocOrder()+1];// indice courant pour chaque ordre public boolean hasNext() { goNext(); return hasNext; } public Long next() { if( !hasNext() ) return null; ready=false; return current; } public void remove() { } private void goNext() { if( ready ) return; // recherche de la plus petite tete parmi tous les orders if( indice==range ) { long min = Long.MAX_VALUE; long fct=1L; long tete=-1L; int mocOrder = getMocOrder(); order=-1; for( int o=mocOrder; o>=minLimitOrder; o--, fct*=4 ) { Array a = level[o]; if( a==null ) continue; tete = p[o] array of levels allocation private void init(String coordSys,int minLimitorder,int maxLimitOrder) { this.coordSys=coordSys; this.minLimitOrder=minLimitorder; this.maxLimitOrder=maxLimitOrder; property = new HashMap(); if( maxLimitOrder!=-1 ) property.put("MOCORDER",maxLimitOrder+""); property.put("COORDSYS",coordSys); property.put("MOCTOOL","CDSjavaAPI-"+VERSION); property.put("DATE",String.format("%tFT%MAXORDER ) throw new Exception("Out of MOC order"); if( order>=nOrder ) nOrder=order+1; if( npix<0 ) return false; return level[order].add(npix,testConsistency); } // Low level npixel multi-addition private boolean add2(int orderSrc, long npix, int orderTrg) throws Exception { if( orderTrg>MAXORDER ) throw new Exception("Out of MOC order"); if( orderTrg>=nOrder ) nOrder=orderTrg+1; if( npix<0 ) return false; long fct = pow2(orderTrg-orderSrc); fct *= fct; npix *= fct; boolean rep=false; for( int i=0; i0 ) currentOrder = Integer.parseInt( unQuote( s.substring(0,i) ) ); int j=s.indexOf('-',i+1); if( j<0 ) { String s1 = unBracket( s.substring(i+1) ); // if( s1.length()>0 ) { long npix = s1.trim().length()==0 ? -1 : Long.parseLong( s1 ); add(currentOrder, npix ); // } } else { long startIndex = Long.parseLong(s.substring(i+1,j)); long endIndex = Long.parseLong(s.substring(j+1)); for( long k=startIndex; k<=endIndex; k++ ) add(currentOrder, k); } } private String unQuote(String s) { int n=s.length(); if( n>2 && s.charAt(0)=='"' && s.charAt(n-1)=='"' ) return s.substring(1,n-1); return s; } private String unBracket(String s) { int n=s.length(); if( n<1 ) return s; int o1 = s.charAt(0)=='[' ? 1:0; int o2 = s.charAt(n-1)==']' ? n-1 : n; return s.substring(o1,o2); } // Suppression d'un pixel selon le format "order/npix[-npixn]". // Si l'order n'est pas mentionné, utilise le dernier order utilisé private void deleteHpix(String s) { int i=s.indexOf('/'); if( i>0 ) currentOrder = Integer.parseInt(s.substring(0,i)); int j=s.indexOf('-',i+1); if( j<0 ) delete(currentOrder, Integer.parseInt(s.substring(i+1))); else { int startIndex = Integer.parseInt(s.substring(i+1,j)); int endIndex = Integer.parseInt(s.substring(j+1)); for( int k=startIndex; k<=endIndex; k++ ) delete(currentOrder, k); } } // Sort and check before writting private void check() throws Exception { if( !testConsistency ) checkAndFix(); else sort(); } // Throw an exception if the coordsys of the parameter moc differs of the coordsys private void testCompatibility(HealpixMoc moc) throws Exception { if( getCoordSys().charAt(0)!=moc.getCoordSys().charAt(0) ) throw new Exception("Incompatible MOC coordsys"); } // Determine the best "find" strategie // @return: 0-no object at all // 1-dichotomy - first arg as external loop // 2 dichotomy - second arg as external loop // 3-parallel scanning private int strategie(int size1, int size2) { if( size1==0 || size2==0 ) return 0; double m1 = size1 * (1+Math.log(size2)/Math.log(2)); double m2 = size2 * (1+Math.log(size1)/Math.log(2)); double m3 = size1+size2; if( m1=0 ) return true; return false; case 2: for( long x : a2 ) if( a1.find(x)>=0 ) return true; return false; default : boolean incr1=true; long x1=a1.get(0),x2=a2.get(0); for( int i1=0,i2=0; i1=0 ) return true; onpix=npix; } break; case 2: for( long pix : a2 ) { if( a1.intersectRange(pix*range, (pix+1)*range -1) ) return true; } break; default: boolean incr1=true; long x1=a1.get(0),x2=a2.get(0)*range,x3=(a2.get(0)+1)*range-1; for( int i1=0,i2=0; i1=0; o--,range*=4L ) { Array a1=level[o]; Array a2=a; int size2 = a2.getSize(); int size1 = a1.getSize(); if( !a1.intersectRange( a2.get(0)/range, a2.get(size2-1)/range ) ) continue; switch( strategie(size1,size2) ) { case 0: break; case 1: for( long x : a1 ) { if( a2.intersectRange(x*range, (x+1)*range -1) ) return true; } break; case 2: long onpix=-1L; for( long x : a2 ) { long npix = x/range; if( npix==onpix ) continue; if( a1.find(npix)>=0 ) return true; onpix=npix; } break; default : boolean incr1=true; long x1=a1.get(0),x2=a2.get(0)/range; for( int i1=0,i2=0; i1>>(++i))>0); return --i; } static private final double SKYAREA = 4.*Math.PI*Math.toDegrees(1.0)*Math.toDegrees(1.0); @Override public int compareTo(Object o) { if( o==null ) return 1; return getSize()-((HealpixMoc)o).getSize(); } } libcds-moc-java/cds/moc/MocCell.java0000644000175000017500000000354212535606610017027 0ustar sladensladen// Copyright 2011 - UDS/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc; /** MOC cell object * * @author Pierre Fernique [CDS] * @version 1.0 dec 2011 - creation */ public class MocCell { /** Healpix cell order */ public int order; /** Healpix cell value */ public long npix; /** Create Healpix cell */ public MocCell() {}; /** * Create Healpix cell * @param order cell order (ie log2(Healpix NSIDE) ) * @param npix cell value (ie Healpix value) */ public MocCell(int order,long npix) { this.order=order; this.npix=npix; } /** Order getter */ public int getOrder() { return order; } /** Value getter */ public long getNpix() { return npix; } /** Order setter */ public void setOrder(int order) { this.order = order; } /** Value setter */ public void setNpix(long npix) { this.npix= npix; } /** Couple setter */ public void set(int order,long npix) { this.order=order; this.npix=npix; } public String toString() { return order+"/"+npix; } } libcds-moc-java/cds/moc/LongArray.java0000644000175000017500000002041212535606610017402 0ustar sladensladen// Copyright 2011 - UDS/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc; import java.util.Arrays; /** * Fast array of longs * @version 1.0 - oct 2011 * @author P.Fernique [CDS] */ public final class LongArray extends Array { private long [] array; // Array of longs (real size is given by "size") /** Create a free array of longs */ public LongArray(int bloc) { array=null; size=0; sorted=true; sizeBloc = bloc; } /** Create an array of longs initializing with v[] * @param v initial values of the array */ public LongArray(long[] v) { array = v; size = v.length; sizeBloc=DEFAULTBLOC; sorted=true; } /** Deep copy */ public Array clone() { LongArray a = new LongArray(sizeBloc); if( array==null ) a.array=null; else { a.array = new long[array.length]; System.arraycopy(array, 0, a.array, 0, size); } a.size=size; a.sorted=sorted; return a; } /** Equality test */ public boolean equals(Array a) { if( this==a ) return true; if( size!=a.size ) return false; if( size==0) return true; sort(); a.sort(); for( int i=0; i consecutive values are memorized as range (2 values) * @return Number of values */ public int getSizeCompressed() { if( array==null ) return 0; int reduce=0; boolean oConsecutif=false; for( int i=1; i=0 ) return false; adjustSize(1); if( testUnicity && sorted ) { pos = -(pos+1); System.arraycopy(array, pos, array, pos+1, size-pos); array[pos]=v; size++; } else { if( sorted ) sorted= size==0 || v>array[size-1]; array[size++]=v; } return true; } /** Delete the first value equals to v * kept the array sorted if required * @param v the value to remove * @return true if the value has been removed */ public boolean delete(long v) { int pos = find(v); if( pos<0 ) return false; if( !sorted ) array[pos] = array[size-1]; else System.arraycopy(array, pos+1, array, pos, size-pos-1); size--; return true; } /** Delete the all values between v1 and v2 (inclusive) * kept the array sorted if required * @param v1 the low range value * @param v2 the high range value * @return true if at least one value has been removed */ public boolean delete(long v1,long v2) { int i,j; for( i=j=0; iv2 ) array[j++]=array[i]; } size=j; return j!=i; } /** Delete three other brothers only if all of them are already present * (apart me) * @return false if not found */ public boolean deleteBrothers(long me) { long firstBrother = me - me%4; int pos[] = new int[3]; // Search three other brothers for( int j=0,i=0; i<4; i++,j++ ) { long v = firstBrother+i; if( v==me ) { j--; continue; } if( j==0 ) pos[j] = find(v); else { if( sorted ) { pos[j] = array[pos[j-1]+1]==v ? pos[j-1]+1 : -1; } else pos[j] = find(v); } if( pos[j]<0 || sorted && size-pos[j]<3-j ) return false; } // Delete three other brothers if( sorted ) { System.arraycopy(array, pos[2]+1, array, pos[0], size-(pos[2]+1)); } else { for( int i=0; i<3; i++ ) array[ pos[i] ] = array[ size-1-i ]; } size-=3; return true; } /** Return the index of the first value v. -1 if not found. * If the arrays is sorted, proceeds by bsearch (see bsearch doc) * @param v Value to find * @return index of the value, otherwise negative index */ public int find(long v) { if( array==null ) return -1; int i=-1; if( sorted ) { if( size==0 || varray[size-1] ) return -(size+1); i= binarySearch(array,0,size, v); } else { for( i=0; iarray[size-1] ? -(size+1) : binarySearch(array,0, size, vStart); if( pos1>=0 ) return true; int pos2 = size==0 || vEndarray[size-1] ? -(size+1) : binarySearch(array,0, size, vEnd); if( pos2>=0 ) return true; return pos1!=pos2; } else { for( int i=0; i>> 1; long midVal = a[mid]; if (midVal < key) low = mid + 1; else if (midVal > key) high = mid - 1; else return mid; } return -(low + 1); } /** Sort the array (only if required) */ public void sort() { if( array==null ) return; if( sorted ) return; Arrays.sort(array,0,size); sorted=true; } /** Remove the reservation room in the array */ public void trim() { if( array==null || size==array.length ) return; long [] nArray = new long[ size ]; System.arraycopy(array, 0, nArray, 0, size); } // Adjust the size of the array for adding n values. In if it is too small, copy the array // in a larger array. private void adjustSize(int n) { if( n==0 || array!=null && size+n < array.length ) return; long [] nArray = new long[ (1+ (size+n)/sizeBloc) * sizeBloc ]; if( array!=null ) System.arraycopy(array, 0, nArray, 0, size); array=nArray; sizeBloc=sizeBloc+array.length/10; nArray=null; } } libcds-moc-java/cds/moc/IntArray.java0000644000175000017500000002136612535606610017246 0ustar sladensladen// Copyright 2011 - UDS/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc; import java.util.Arrays; /** * Fast array of integers * @version 1.0 - oct 2011 * @author P.Fernique [CDS] */ public final class IntArray extends Array { private int [] array; // Array of integers (real size is given by "size") /** Create a free array of longs */ public IntArray(int bloc) { array=null; size=0; sorted=true; sizeBloc = bloc; } /** Create an array of integers initializing with v[] * @param v initial values of the array */ public IntArray(int[] v) { array = v; size = v.length; sizeBloc=DEFAULTBLOC; sorted=true; } /** Deep copy */ public Array clone() { IntArray a = new IntArray(sizeBloc); if( array==null ) a.array=null; else { a.array = new int[array.length]; System.arraycopy(array, 0, a.array, 0, size); } a.size=size; a.sorted=sorted; return a; } /** Equality test */ public boolean equals(Array a) { if( this==a ) return true; if( size!=a.size ) return false; if( size==0) return true; sort(); a.sort(); for( int i=0; i consecutive values are memorized as range (2 values) * @return Number of values */ public int getSizeCompressed() { if( array==null ) return 0; int reduce=0; boolean oConsecutif=false; for( int i=1; i=0 ) return false; adjustSize(1); if( testUnicity && sorted ) { pos = -(pos+1); System.arraycopy(array, pos, array, pos+1, size-pos); array[pos]=v; size++; } else { if( sorted ) sorted= size==0 || v>array[size-1]; array[size++]=v; } return true; } /** Delete the first value equals to v * kept the array sorted if required * @param v the value to remove * @return true if the value has been removed */ public boolean delete(long v) { return delete((int)v); } public boolean delete(int v) { int pos = find(v); if( pos<0 ) return false; if( !sorted ) array[pos] = array[size-1]; else System.arraycopy(array, pos+1, array, pos, size-pos-1); size--; return true; } /** Delete the all values between v1 and v2 (inclusive) * kept the array sorted if required * @param v1 the low range value * @param v2 the high range value * @return true if at least one value has been removed */ public boolean delete(long v1,long v2) { return delete((int)v1,(int)v2); } public boolean delete(int v1,int v2) { int i,j; for( i=j=0; iv2 ) array[j++]=array[i]; } size=j; return j!=i; } /** Delete three other brothers only of all of them are already present * (apart me) * @return false if not found */ public boolean deleteBrothers(long me) { return deleteBrothers((int)me); } public boolean deleteBrothers(int me) { int firstBrother = me - me%4; int pos[] = new int[3]; // Search three other brothers for( int j=0,i=0; i<4; i++,j++ ) { int v = firstBrother+i; if( v==me ) { j--; continue; } if( j==0 ) pos[j] = find(v); else { if( sorted ) { pos[j] = array[pos[j-1]+1]==v ? pos[j-1]+1 : -1; } else pos[j] = find(v); } if( pos[j]<0 || sorted && size-pos[j]<3-j ) return false; } // Delete three other brothers if( sorted ) { System.arraycopy(array, pos[2]+1, array, pos[0], size-(pos[2]+1)); } else { for( int i=0; i<3; i++ ) { array[ pos[i] ] = array[ size-1-i ]; } } size-=3; return true; } /** Return the index of the first value v. -1 if not found. * If the arrays is sorted, proceeds by bsearch (see bsearch doc) * @param v Value to find * @return index of the value, otherwise negative index */ public int find(long v) { return find((int)v); } public int find(int v) { if( array==null ) return -1; int i=-1; if( sorted ) { if( size==0 || varray[size-1] ) return -(size+1); i= binarySearch(array,0,size, v); } else { for( i=0; iarray[size-1] ? -(size+1) : binarySearch(array,0, size, vStart); if( pos1>=0 ) return true; int pos2 = size==0 || vEndarray[size-1] ? -(size+1) : binarySearch(array,0, size, vEnd); if( pos2>=0 ) return true; return pos1!=pos2; } else { for( int i=0; i>> 1; int midVal = a[mid]; if (midVal < key) low = mid + 1; else if (midVal > key) high = mid - 1; else return mid; } return -(low + 1); } /** Sort the array (only if required) */ public void sort() { if( array==null ) return; if( sorted ) return; Arrays.sort(array,0,size); sorted=true; } /** Remove the reservation room in the array */ public void trim() { if( array==null || size==array.length ) return; int [] nArray = new int[size]; System.arraycopy(array, 0, nArray, 0, size); } // Adjust the size of the array for adding n values. In if it is too small, copy the array // in a larger array. private void adjustSize(int n) { if( n==0 || array!=null && size+n < array.length ) return; int [] nArray = new int[ (1+ (size+n)/sizeBloc) * sizeBloc ]; if( array!=null ) System.arraycopy(array, 0, nArray, 0, size); array=nArray; sizeBloc=sizeBloc+array.length/10; nArray=null; } } libcds-moc-java/cds/moc/MocIO.java0000644000175000017500000006516612710431050016456 0ustar sladensladen// Copyright 2011 - UDS/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.EOFException; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.util.Hashtable; import java.util.StringTokenizer; /** HEALPix Multi Order Coverage Map (MOC) IO routines * Compliante with IVOA MOC Rec 1.0 June 2014 * * Example : HealpixMoc moc = new HealpixMoc(); * (new IO(moc).read(String filename); * * @author Pierre Fernique [CDS] * @version 1.4 Nov 2015 - JSON #MOCORDER patching * @version 1.3 Sep 2013 - WD 1.0 10/9/2013 compliante * @version 1.2 Avr 2012 - JSON ASCII support * @version 1.1 Mar 2012 - Healpix FITS header adjustements * @version 1.0 Oct 2011 - Dedicated class (removed from HealpixMoc) */ public final class MocIO { static public final int FITS = HealpixMoc.FITS; // Standard format static public final int JSON = HealpixMoc.JSON; // JSON format (suggested in IVOA REC) static public final int ASCII = HealpixMoc.ASCII; // ASCII format (suggested in IVOA REC) static public final int JSON0 = HealpixMoc.JSON0; // JSON obsolete format (only reading supported for compatibility) static private String CR = System.getProperty("line.separator"); /** Standardized MOC FITS keyword list */ private String [][] FITSKEY = { {"COORDSYS","Reference frame"}, {"MOCORDER","MOC resolution (best order)"}, {"MOCTOOL", "Name of the MOC generator"}, {"MOCTYPE", "Source type (IMAGE or CATALOG)"}, {"MOCID", "Identifier of the collection"}, {"ORIGIN", "MOC origin"}, {"DATE", "MOC creation date"}, {"EXTNAME", "MOC name"} }; static final public String OLDSIGNATURE = "HPXMOC"; // FITS keywords used as signature (obsoleted syntax) static final public String SIGNATURE = "MOCORDER"; // FITS keywords used as signature private HealpixMoc moc; private byte firstChar=0; // Use for storing first character (mode detection) public MocIO(HealpixMoc m) { moc=m; } /** Read HEALPix MOC from a file. * Support standard FITS format and ASCII non standard alternatives (JSON, ASCII) * @param filename file name * @throws Exception */ public void read(String filename) throws Exception { File f = new File(filename); FileInputStream fi = null; BufferedInputStream bf = null; try { fi = new FileInputStream(f); bf = new BufferedInputStream(fi); read( bf ); } finally { if( bf!=null ) bf.close(); else if( fi!=null ) fi.close(); } } /** Read HEALPix MOC from a file. * @param filename file name * @param mode MOC format: FITS, JSON, ASCII * @throws Exception * @deprecated see read(String) */ public void read(String filename,int mode) throws Exception { read(filename); } /** Read HEALPix MOC from a stream. * Support standard FITS format and ASCII non standard alternatives (JSON, ASCII) * @param in input stream * @throws Exception */ public void read(InputStream in) throws Exception { // Read the first charactere for deciding FITS or ASCII byte [] b = new byte[1]; in.read(b); firstChar = b[0]; int mode = firstChar=='S' ? FITS : ASCII; read(in,mode); } /** Read HEALPix MOC from a stream. * @param in input stream * @param mode MOC format: FITS, JSON, ASCII * @throws Exception * @deprecated see read(InputStream) */ public void read(InputStream in,int mode) throws Exception { if( mode==FITS ) readFits(in); else readASCII(in); moc.trim(); } /** Read MOC from an ASCII stream * Support simultaneously various ASCII formats (OBSOLETE, ASCII & JSON) * * OBSOLETE * #MOCORDER MAX * ORDER|NSIDE=xxx1 * nn1 * nn2-nn3 nn4 * ... * NSIDE|ORDER=xxx2 * ... * * ASCII (with a first comment for providing the MOCORDER) * #MOCORDER MAX * ORDER1/nn1,nn2-nnX ORDER2/... * * ASCII (with an explicit MAXORDER possibly empty list) * ORDER1/nn1,nn2-nnX ORDER2/... MAXORDER/ * * JSON (with a first comment for providing the MOCORDER => Not well formed JSON) * #MOCORDER MAX * {"ORDER1":[nn1,nn2,...], * "ORDER2":[nn * ... * } * * JSON (with an explicit MAXORDER possibly empty list) * #MOCORDER MAX * {"ORDER1":[nn1,nn2,...], * "ORDER2":[nn...] * ... * "MAXORDER":[] * } * * @param in input stream * @throws Exception */ public void readASCII(InputStream in) throws Exception { BufferedReader dis = new BufferedReader(new InputStreamReader(in)); moc.clear(); moc.setCheckConsistencyFlag(false); // We assume that the input MOC is well formed String s; boolean flagMocOrder=false; for( int line=0; (s=dis.readLine())!=null; line++ ) { if( firstChar!=0 ) { s=(char)firstChar+s; firstChar=0; } if( s.length()==0 ) continue; if( line==0 && s.startsWith("#MOCORDER ") ) { String v = s.substring(10); if( v.length()>0 ) { flagMocOrder=true; moc.setProperty("MOCORDER", v); } } parseASCIILine(s); } // If the MocOrder is found by the containts if( !flagMocOrder ) moc.setProperty("MORORDER", moc.getMaxOrder()+"" ); } /** Read HEALPix MOC from an Binary FITS stream */ public void readFits(InputStream in) throws Exception { moc.clear(); moc.setCheckConsistencyFlag(false); // We assume that the Moc is already consistent HeaderFits header = new HeaderFits(); header.readHeader(in); //For compatibility String v = header.getStringFromHeader("HPXMOC"); if( v!=null ) moc.setProperty("MOCORDER", v); try { header.readHeader(in); //For compatibility v = header.getStringFromHeader("HPXMOC"); if( v!=null ) moc.setProperty("MOCORDER", v); for( int i=0; i=0 ? 8 : tform.indexOf('J')>=0 ? 4 : -1; // entier 64 bits, sinon 32 if( nbyte<=0 ) throw new Exception("HEALPix Multi Order Coverage Map only requieres integers (32bits or 64bits)"); byte [] buf = new byte[naxis1*naxis2]; readFully(in,buf); createUniq((naxis1*naxis2)/nbyte,nbyte,buf); } catch( EOFException e ) { } } /** Write HEALPix MOC to a file * @param filename name of file */ public void write(String filename) throws Exception { write(filename,FITS); } /** Write HEALPix MOC to a file * @param filename name of file * @param mode encoded format (FITS or JSON) */ public void write(String filename,int mode) throws Exception { if( mode!=FITS && mode!=ASCII && mode!=JSON ) throw new Exception("Unknown MOC format !"); File f = new File(filename); if( f.exists() ) f.delete(); FileOutputStream fo = null; BufferedOutputStream fb = null; try { fo = new FileOutputStream(f); fb = new BufferedOutputStream(fo); if( mode==FITS ) writeFits(fb); else if( mode==JSON || mode==ASCII) writeJSON(fb); // else if( mode==ASCII ) writeASCII(fb); } finally { if( fb!=null ) fb.close(); else if( fo!=null ) fo.close(); } } /** Write HEALPix MOC to an output stream * @param out output stream */ public void write(OutputStream out) throws Exception { write(out,FITS); } /** Write HEALPix MOC to an output stream * At the end, the stream is not closed * @param out output stream * @param mode encoded format (FITS or JSON) */ public void write(OutputStream out,int mode) throws Exception { if( mode!=FITS && mode!=ASCII && mode!=JSON ) throw new Exception("Unknown MOC format !"); if( mode==FITS ) writeFits(out); else if( mode==JSON || mode==ASCII ) writeJSON(out); // else if( mode==ASCII ) writeASCII(out); } private void testMocNotNull() throws Exception { if( moc==null ) throw new Exception("No MOC assigned (use setMoc(HealpixMoc))"); } private static final int MAXWORD=20; private static final int MAXSIZE=80; /** Write HEALPix MOC to an output stream IN ASCII encoded format * @param out output stream * @deprecated use FITS format */ public void writeASCII(OutputStream out) throws Exception { testMocNotNull(); out.write(("#"+SIGNATURE+" "+moc.getMocOrder()+CR).getBytes()); StringBuilder res= new StringBuilder(moc.getSize()*8); int order=-1; boolean flagNL = moc.getSize()>MAXWORD; int sizeLine=0; int j=0; for( MocCell c : moc ) { if( res.length()>0 ) { if( c.order!=order ) { if( flagNL ) { res.append("\n"); sizeLine=0; j++; } else res.append(" "); } else { int n=(c.npix+"").length(); if( flagNL && n+sizeLine>MAXSIZE ) { res.append(",\n "); sizeLine=3; j++; } else { res.append(','); sizeLine++; } } if( j>15) { writeASCIIFlush(out,res,false); j=0; } } String s = c.order!=order ? c.order+"/"+c.npix : c.npix+""; res.append(s); sizeLine+=s.length(); order=c.order; } int n = res.length(); if( n>0 && res.charAt(n-1)==',' ) res.replace(n-1, n-1, (flagNL?"\n":" ")); else res.append((flagNL?"\n":" ")); writeASCIIFlush(out,res); } /** Write HEALPix MOC to an output stream IN JSON encoded format * @param out output stream * @deprecated use FITS format */ public void writeJSON(OutputStream out) throws Exception { testMocNotNull(); // Nouvelle version JSON // On remplace tout de même l'ancienne signature non compatible JSON par une ligne vide // pour essayer d'éviter de planter les vieux clients JSON qui saute la première ligne out.write(CR.getBytes()); StringBuilder s = new StringBuilder(2048); int nOrder = moc.getMaxOrder()+1; s.append("{"); boolean first=true; int order; for( order=0; order ignoré } // Parsing de la ligne COORDSYS=G|C private void setCoord(String s) throws Exception { int i = s.indexOf('='); moc.setCoordSys(s.substring(i+1)); } // Parse une ligne d'un flux (reconnait JSON et basic ASCII) private void parseASCIILine(String s) throws Exception { char a = s.charAt(0); if( a=='#' ) return; if( a=='N' ) setCurrentParseOrder(s); else if( a=='C' ) setCoord(s); else if( a=='O' ) setOrder(s); else { StringTokenizer st = new StringTokenizer(s," ;,\n\r\t{}"); while( st.hasMoreTokens() ) { String s1 = st.nextToken(); if( s1.length()==0 ) continue; moc.addHpix(s1); } } } public void createUniq(int nval,int nbyte,byte [] t) throws Exception { int i=0; long [] hpix = null; long oval=-1; for( int k=0; k>shift) ); out.write( buf ); return buf.length; } /****************** Utilitaire Fits **************************/ /** Generate FITS 80 character line => see getFitsLine(String key, String value, String comment) */ private byte [] getFitsLine(String key, String value) { return getFitsLine(key,value,null); } /** * Generate FITS 80 character line. * @param key The FITS key * @param value The associated FITS value (can be numeric, string (quoted or not) * @param comment The commend, or null * @return the 80 character FITS line */ private byte [] getFitsLine(String key, String value, String comment) { int i=0,j; char [] a; byte [] b = new byte[80]; // The keyword a = key.toCharArray(); for( j=0; i<8; j++,i++) b[i]=(byte)( (j right align if( !isFitsString(value) ) { for( j=0; j<20-a.length; j++) b[i++]=(byte)' '; for( j=0; i<80 && j format } else { a = formatFitsString(a); for( j=0; i<80 && j0 ) { if( value!=null ) { b[i++]=(byte)' ';b[i++]=(byte)'/'; b[i++]=(byte)' '; } a = comment.toCharArray(); for( j=0; i<80 && j insert the last END keyword */ private byte [] getEndBourrage(int headSize) { int size = 2880 - headSize%2880; if( size<3 ) size+=2880; byte [] b = new byte[size]; b[0]=(byte)'E'; b[1]=(byte)'N';b[2]=(byte)'D'; for( int i=3; i header; // List of header key/value private int sizeHeader=0; // Header size in bytes /** Pick up FITS value from a 80 character array * @param buffer line buffer * @return Parsed FITS value */ private String getValue(byte [] buffer) { int i; boolean quote = false; boolean blanc=true; int offset = 9; for( i=offset ; i<80; i++ ) { if( !quote ) { if( buffer[i]==(byte)'/' ) break; // on the comment } else { if( buffer[i]==(byte)'\'') break; // on the next quote } if( blanc ) { if( buffer[i]!=(byte)' ' ) blanc=false; if( buffer[i]==(byte)'\'' ) { quote=true; offset=i+1; } } } return (new String(buffer, 0, offset, i-offset)).trim(); } /** Pick up FITS key from a 80 character array * @param buffer line buffer * @return Parsed key value */ private String getKey(byte [] buffer) { return new String(buffer, 0, 0, 8).trim(); } /** Parse FITS header from a stream until next 2880 FITS block after the END key. * Memorize FITS key/value couples * @param dis input stream */ private void readHeader(InputStream dis) throws Exception { int blocksize = 2880; int fieldsize = 80; String key, value; int linesRead = 0; sizeHeader=0; header = new Hashtable(200); byte[] buffer = new byte[fieldsize]; while (true) { if( firstChar==0 ) readFully(dis,buffer); // The first character may be already read to determine the mode else { buffer[0] = firstChar; firstChar=0; readFully(dis,buffer,1,buffer.length-1); } key = getKey(buffer); if( linesRead==0 && !key.equals("SIMPLE") && !key.equals("XTENSION") ) throw new Exception("Not a MOC FITS format"); sizeHeader+=fieldsize; linesRead++; if( key.equals("END" ) ) break; if( buffer[8] != '=' ) continue; value=getValue(buffer); header.put(key, value); } // Skip end of last block int bourrage = blocksize - sizeHeader%blocksize; if( bourrage!=blocksize ) { byte [] tmp = new byte[bourrage]; readFully(dis,tmp); sizeHeader+=bourrage; } } /** * Provide integer value associated to a FITS key * @param key FITs key (with or without trailing blanks) * @return corresponding integer value */ private int getIntFromHeader(String key) throws NumberFormatException,NullPointerException { String s = header.get(key.trim()); return (int)Double.parseDouble(s.trim()); } /** * Provide string value associated to a FITS key * @param key FITs key (with or without trailing blanks) * @return corresponding string value without quotes (') */ private String getStringFromHeader(String key) throws NullPointerException { String s = header.get(key.trim()); if( s==null || s.length()==0 ) return s; if( s.charAt(0)=='\'' ) return s.substring(1,s.length()-1).trim(); return s; } } } libcds-moc-java/cds/moc/examples/0000755000175000017500000000000012710115750016453 5ustar sladensladenlibcds-moc-java/cds/moc/examples/MocTest.java0000644000175000017500000005062112710430576020706 0ustar sladensladen// Copyright 2011 - Unistra/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc.examples; import java.io.ByteArrayInputStream; import java.io.FileInputStream; import java.io.InputStream; import java.util.Iterator; import cds.moc.Healpix; import cds.moc.HealpixMoc; import cds.moc.MocCell; public class MocTest { // Juste pour tester quelques méthodes */ private static boolean testBasic() throws Exception { title("testBasic: Create a Moc manually and check the result..."); String ref = " 3/1 3/3 3/10 4/16 4/17 4/18 4/22"; HealpixMoc moc = new HealpixMoc(); moc.add("3/10 4/12-15 18 22"); moc.add("4/13-18 5/19 20"); moc.add("3/1"); moc.sort(); Iterator it = moc.iterator(); StringBuffer s = new StringBuffer(); while( it.hasNext() ) { MocCell p = it.next(); s.append(" "+p.order+"/"+p.npix); } boolean rep = s.toString().equals(ref); if( !rep ) { System.out.println("MocTest.testBasic ERROR: \n.get ["+s+"]\n.ref ["+ref+"]\n"); } else System.out.println("MocTest.testBasic OK"); return rep; } private static boolean testSetLimitOrder() throws Exception { title("testSetLimitOrder: Test min and max limit order settings..."); HealpixMoc moc = new HealpixMoc("0/0 3/700 8/"); String ref= "{ \"1\":[0,1,2,3], \"2\":[175] }"; int mocOrder=2; System.out.println("MOC before: "+moc); moc.setMinLimitOrder(1); moc.setMocOrder(2); System.out.println("MOC order [1..2]: "+moc); if( !moc.toString().equals(ref) ) { System.out.println("MocTest.testSetLimitOrder ERROR\n"); return false; } if( moc.getMocOrder()!=mocOrder ) { System.out.println("MocTest.testSetLimitOrder ERROR: wrong mocOrder "+moc.getMocOrder()+" waiting "+mocOrder); return false; } System.out.println("testSetLimitOrder OK"); return true; } private static boolean testHierarchy() throws Exception { title("testHierarchy: Create a Moc manually and check isIn(), isAscendant() and isDescendant() methods..."); String ref = "3/10-12 5/128"; HealpixMoc moc = new HealpixMoc(ref); boolean b; boolean rep=true; System.out.println("REF: "+ref); System.out.println("MOC:\n"+moc); System.out.println("- 3/11 [asserting true] isIn()="+(b=moc.isIn(3,11))); rep &= b; System.out.println("- 3/12 [asserting true] isIn()="+(b=moc.isIn(3,11))); rep &= b; System.out.println("- 2/0 [asserting false] isAscendant()="+(b=moc.isAscendant(2,0))); rep &= !b; System.out.println("- 1/0 [asserting true] isAscendant()="+(b=moc.isAscendant(1,0))); rep &= b; System.out.println("- 6/340000 [asserting false] isDescendant()="+(b=moc.isDescendant(6,340000))); rep &=!b; System.out.println("- 6/515 [asserting true] isDescendant()="+(b=moc.isDescendant(6,514))); rep &=b; if( !rep ) System.out.println("MocTest.testContains ERROR:"); else System.out.println("testContains OK"); return rep; } private static boolean testContains() throws Exception { title("testContains: Create a Moc manually and check contains() methods..."); Healpix hpx = new Healpix(); HealpixMoc moc = new HealpixMoc("2/0 3/10 4/35"); System.out.println("MOC: "+moc); boolean rep=true; try { System.out.println("- contains(028.93342,+18.18931) [asserting IN] => "+moc.contains(hpx,028.93342,18.18931)); rep &= moc.contains(hpx,028.93342,18.18931); System.out.println("- contains(057.23564,+15.34922) [asserting OUT] => "+moc.contains(hpx,057.23564,15.34922)); rep &= !moc.contains(hpx,057.23564,15.34922); System.out.println("- contains(031.89266,+17.07820) [asserting IN] => "+moc.contains(hpx,031.89266,17.07820)); rep &= moc.contains(hpx,031.89266,17.07820); } catch( Exception e ) { e.printStackTrace(); rep=false; } if( !rep ) System.out.println("MocTest.testContains ERROR:"); else System.out.println("MocTest.testContains OK"); return rep; } private static boolean testFITS() throws Exception { title("testFITS: Create a MOC manually, write in FITS and re-read it..."); HealpixMoc moc = new HealpixMoc(); moc.add("3/10 4/12-15 18 22"); moc.add("4/13-18 5/19 20"); moc.add("17/222 28/123456789"); String mocS="{ \"3\":[3,10], \"4\":[16,17,18,22], \"5\":[19,20], \"17\":[222], \"28\":[123456789] }"; int mocOrder = 28; String file = "/Users/Pierre/Desktop/__MOC.fits"; System.out.println("- MOC created: "+moc); moc.write(file,HealpixMoc.FITS); System.out.println("- test write (FITS) seems OK"); StringBuilder trace = new StringBuilder(); FileInputStream in = new FileInputStream(file); int rep = MocLint.check(trace,in); in.close(); if( rep==1 ) System.out.println("- test read (FITS) OK and IVOA valid"); else if( rep==-1 ) System.out.println("- test read (FITS) WARNING, MOC ok but IVOA unvalid"); if( rep!=1 ) System.out.println(trace); if( rep==0 ) { System.out.println("MocTest.testFITS ERROR: not IVOA valid"); return false; } moc = new HealpixMoc(); moc.read(file); System.out.println("- MOC re-read: "+moc); if( !moc.toString().equals(mocS) ) { System.out.println("MocTest.testFITS ERROR: waiting=["+mocS+"]"); return false; } if( moc.getMocOrder()!=mocOrder ) { System.out.println("MocTest.testJSON ERROR: wrong mocOrder "+moc.getMocOrder()+" waiting "+mocOrder); return false; } System.out.println("testFITS OK"); return true; } private static boolean testJSON() throws Exception { title("testJSON: Create a MOC manually, write in JSON and re-read it..."); HealpixMoc moc = new HealpixMoc(); moc.add("3/10 4/12-15 18 22"); moc.add("4/13-18 5/19 20"); moc.add("17/222 28/123456789"); String mocS="{ \"3\":[3,10], \"4\":[16,17,18,22], \"5\":[19,20], \"17\":[222], \"28\":[123456789] }"; int mocOrder = 28; String file = "/Users/Pierre/Desktop/__MOC.json"; System.out.println("- MOC created: "+moc); moc.write(file,HealpixMoc.JSON); System.out.println("- test write (JSON) seems OK"); moc = new HealpixMoc(); moc.read(file); System.out.println("- MOC re-read: "+moc); if( !moc.toString().equals(mocS) ) { System.out.println("MocTest.testJSON ERROR: waiting=["+mocS+"]"); return false; } if( moc.getMocOrder()!=mocOrder ) { System.out.println("MocTest.testJSON ERROR: wrong mocOrder "+moc.getMocOrder()+" waiting "+mocOrder); return false; } System.out.println("testJSON OK"); return true; } private static boolean testJSON0() throws Exception { title("testJSON0: read old JSON format (with #MOCORDER commment) for ascending compatibility..."); String s = "#MOCORDER 28\n" + "{\"3\":[3,10],\n" + "\"4\":[16,17,18,22],\n" + "\"5\":[19,20],\n" + "\"17\":[222],\n" + "\"28\":[123456789]}\n"; int mocOrder = 28; InputStream stream = new ByteArrayInputStream(s.getBytes()); String mocS="{ \"3\":[3,10], \"4\":[16,17,18,22], \"5\":[19,20], \"17\":[222], \"28\":[123456789] }"; HealpixMoc moc = new HealpixMoc(); moc.read(stream); System.out.println("- MOC read: "+moc); if( !moc.toString().equals(mocS) ) { System.out.println("MocTest.testJSON0 ERROR: waiting=["+mocS+"]"); return false; } if( moc.getMocOrder()!=mocOrder ) { System.out.println("MocTest.testJSON0 ERROR: wrong mocOrder "+moc.getMocOrder()+" waiting "+mocOrder); return false; } System.out.println("testJSON0 OK"); return true; } private static boolean testASCII() throws Exception { title("testASCII: read ASCII format (with #MOCORDER commment) for ascending compatibility..."); String s = "#MOCORDER 28\n" + "3/3,10 4/16,17,18,22 5/19,20\n" + "17/222 28/123456789\n"; int mocOrder = 28; InputStream stream = new ByteArrayInputStream(s.getBytes()); String mocS="{ \"3\":[3,10], \"4\":[16,17,18,22], \"5\":[19,20], \"17\":[222], \"28\":[123456789] }"; HealpixMoc moc = new HealpixMoc(); moc.read(stream); System.out.println("- MOC read: "+moc); if( !moc.toString().equals(mocS) ) { System.out.println("MocTest.testASCII ERROR: waiting=["+mocS+"]"); return false; } if( moc.getMocOrder()!=mocOrder ) { System.out.println("MocTest.testASCII ERROR: wrong mocOrder "+moc.getMocOrder()+" waiting "+mocOrder); return false; } System.out.println("testASCII OK"); return true; } private static boolean testSTRING() throws Exception { title("testASCII: read STRING format..."); String s = "3/3,10 4/16-18,22 5/19,20 17/222 28/"; int mocOrder = 28; InputStream stream = new ByteArrayInputStream(s.getBytes()); String mocS="{ \"3\":[3,10], \"4\":[16,17,18,22], \"5\":[19,20], \"17\":[222] }"; HealpixMoc moc = new HealpixMoc(); moc.read(stream); System.out.println("- MOC read: "+moc); if( !moc.toString().equals(mocS) ) { System.out.println("MocTest.testSTRING ERROR: waiting=["+mocS+"]"); return false; } if( moc.getMocOrder()!=mocOrder ) { System.out.println("MocTest.testSTRING ERROR: wrong mocOrder "+moc.getMocOrder()+" waiting "+mocOrder); return false; } System.out.println("testSTRING OK"); return true; } private static boolean testOperation() throws Exception { title("testOperation: Create 2 Mocs manually, test intersection(), union(), equals(), clone()..."); HealpixMoc moc1 = new HealpixMoc("3/1,3-4,9 4/30-31"); String moc1S = "{ \"3\":[1,3,4,9], \"4\":[30,31] }"; System.out.println("- Loading moc1: "+moc1); if( !moc1.toString().equals(moc1S) ) { System.out.println("MocTest.testOperation load ERROR: waiting=["+moc1S+"]"); return false; } HealpixMoc moc2 = new HealpixMoc("4/23 3/3 10 4/23-28;4/29 5/65"); String moc2S = "{ \"3\":[3,6,10], \"4\":[23,28,29], \"5\":[65] }"; System.out.println("- Loading moc2: "+moc2); if( !moc2.toString().equals(moc2S) ) { System.out.println("MocTest.testOperation load ERROR: waiting=["+moc2S+"]"); return false; } HealpixMoc moc3 = (HealpixMoc)moc2.clone(); System.out.println("- Cloning moc2->moc3: "+moc3); if( !moc3.toString().equals(moc2S) ) { System.out.println("MocTest.testOperation clone ERROR: waiting=["+moc2S+"]"); return false; } HealpixMoc moc4 = moc2.intersection(moc1); String moc4S = "{ \"3\":[3], \"5\":[65] }"; System.out.println("- Intersection moc2 moc1: "+moc4); if( !moc4.toString().equals(moc4S) ) { System.out.println("MocTest.testOperation intersection ERROR: waiting=["+moc4S+"]"); return false; } if( !moc1.intersection(moc2).toString().equals(moc4S) ) { System.out.println("MocTest.testOperation intersection ERROR: no commutative"); return false; } HealpixMoc moc5 = moc3.union(moc1); String moc5S = "{ \"3\":[1,3,4,6,7,9,10], \"4\":[23] }"; System.out.println("- Union moc3 moc1: "+moc5); if( !moc1.union(moc2).toString().equals(moc5S) ) { System.out.println("MocTest.testOperation union ERROR: no commutative"); return false; } if( !moc5.toString().equals(moc5S) ) { System.out.println("MocTest.testOperation union ERROR: waiting=["+moc5S+"]"); return false; } HealpixMoc moc7 = moc1.subtraction(moc2); String moc7S = "{ \"3\":[1,9], \"4\":[17,18,19,30,31], \"5\":[64,66,67] }"; System.out.println("- Subtraction moc1 - moc2: "+moc7); if( !moc7.toString().equals(moc7S) ) { System.out.println("MocTest.testOperation subtraction ERROR: waiting=["+moc7S+"]"); return false; } String moc6S="{ \"3\":[3,6,10], \"4\":[23,28,29] }"; HealpixMoc moc6 = new HealpixMoc(moc6S); boolean test=moc6.equals(moc2); System.out.println("- Not-equals moc2,["+moc6S+"] : "+test); if( test ) { System.out.println("MocTest.testOperation equals ERROR: waiting=[false]"); return false; } moc6.add("5:65"); test=moc6.equals(moc2); System.out.println("- Equals moc2,["+moc2S+"] : "+test); if( !test ) { System.out.println("MocTest.testOperation equals ERROR: waiting=[true]"); return false; } HealpixMoc moc8 = moc1.difference(moc2); String moc8S = "{ \"3\":[1,6,7,9,10], \"4\":[17,18,19,23], \"5\":[64,66,67] }"; System.out.println("- difference moc1 moc2: "+moc8); if( !moc8.toString().equals(moc8S) ) { System.out.println("MocTest.testOperation difference ERROR: waiting=["+moc8S+"]"); return false; } if( !moc1.difference(moc2).toString().equals(moc8S) ) { System.out.println("MocTest.testOperation difference ERROR: no commutative"); return false; } // HealpixMoc moc10=new HealpixMoc("0/2-11 1/1-3"); // HealpixMoc moc9 = moc10.complement(); // String moc9S = "{ \"0\":[1], \"1\":[0] }"; // System.out.println("- Moc : "+moc10); // System.out.println("- Complement: "+moc9); // if( !moc9.toString().equals(moc9S) ) { // System.out.println("MocTest.testOperation complement ERROR: waiting=["+moc9S+"]"); // return false; // } System.out.println("testOperation OK"); return true; } private static boolean testIsInTree() throws Exception { title("testIsInTree: Create 2 Mocs manually, and test isIntersecting() in both directions..."); HealpixMoc moc1 = new HealpixMoc("0/1"); HealpixMoc moc2 = new HealpixMoc("1/5"); System.out.println("moc1="+moc1); System.out.println("moc2="+moc2); boolean rep1=moc2.isIntersecting(moc1); boolean rep2=moc1.isIntersecting(moc2); System.out.println("moc2 inter moc1 = "+rep1); System.out.println("moc1 inter moc2 = "+rep2); if( !rep1 || !rep2 ) { System.out.println("MocTest.testIsInTree ERROR"); return false; } System.out.println("testIterators OK"); return true; } private static boolean testRange() throws Exception { title("testRange: Create a Mocs manually, and test setMin and Max limitOrder()..."); HealpixMoc moc1 = new HealpixMoc("{ \"1\":[0,1], \"2\":[8,9], \"3\":[40,53] }"); System.out.println("moc1="+moc1); moc1.setCheckConsistencyFlag(false); moc1.add("3/37 53"); System.out.println("moc1 + 3/37,46="+moc1); moc1.checkAndFix(); System.out.println("moc1 after check="+moc1); String s1 = "{ \"1\":[0,1], \"2\":[8,9], \"3\":[40,53] }"; if( !moc1.toString().equals(s1) ) { System.out.println("MocTest.testRange checkAndFix() ERROR: waiting=["+s1+"]"); return false; } HealpixMoc moc2 = (HealpixMoc)moc1.clone(); moc2.setMinLimitOrder(2); System.out.println("moc2="+moc2); String s2 = "{ \"2\":[0,1,2,3,4,5,6,7,8,9], \"3\":[40,53] }"; if( !moc2.toString().equals(s2) ) { System.out.println("MocTest.testRange setMinLimitOrder(2) ERROR: waiting=["+s2+"]"); return false; } HealpixMoc moc3 = (HealpixMoc)moc1.clone(); moc3.setMaxLimitOrder(2); System.out.println("moc3="+moc3); String s3 = "{ \"1\":[0,1], \"2\":[8,9,10,13] }"; if( !moc3.toString().equals(s3) ) { System.out.println("MocTest.testRange setMaxLimitOrder(2) ERROR: waiting=["+s3+"]"); return false; } moc3.setMinLimitOrder(1); boolean in1 = moc3.isIntersecting(0, 1); if( in1 ) { System.out.println("MocTest.testRange isIntersecting(0,1) ERROR: waiting=false]"); return false; } boolean in2 = moc3.isIntersecting(0, 0); if( !in2 ) { System.out.println("MocTest.testRange isIntersecting(0,0) ERROR: waiting=true]"); return false; } boolean in3 = moc3.isIntersecting(3, 33); if( !in3 ) { System.out.println("MocTest.testRange isIntersecting(3,33) ERROR: waiting=true]"); return false; } boolean in5 = moc3.isIntersecting(3, 56); if( in5 ) { System.out.println("MocTest.testRange isIntersecting(3,56) ERROR: waiting=false]"); return false; } System.out.println("testRange OK"); return true; } private static boolean testIterators() throws Exception { title("testIterators: Test on MOC iterators..."); String ref = " 0/2 1/4 1/13"; HealpixMoc moc = new HealpixMoc(); moc.add(ref); // Iterator order per order Iterator it = moc.iterator(); StringBuffer s = new StringBuffer(); while( it.hasNext() ) { MocCell p = it.next(); s.append(" "+p.order+"/"+p.npix); } boolean rep = s.toString().equals(ref); if( !rep ) { System.out.println("MocTest.testIterators [iterator()] ERROR:\n.get ["+s+"]\n.ref ["+ref+"]\n"); return false; } // Iterator on low level pixel String ref1 = " 4 8 9 10 11 13"; Iterator it1 = moc.pixelIterator(); s = new StringBuffer(); while( it1.hasNext() ) { Long p = it1.next(); s.append(" "+p); } rep = s.toString().equals(ref1); if( !rep ) { System.out.println("MocTest.testIterators [pixelIterator()] ERROR:\n.get ["+s+"]\n.ref ["+ref1+"]\n"); return false; } System.out.println("testIterators OK"); return true; } private static void title(String s) { StringBuffer s1 = new StringBuffer(100); s1.append('\n'); for( int i=0; i<20; i++ ) s1.append('-'); s1.append(" "+s+" "); for( int i=0; i<20; i++ ) s1.append('-'); System.out.println(s1); } class Source { double ra,de,rad; Source(double ra,double de,double rad) { this.ra=ra; this.de=de; this.rad=rad; } } // Juste pour tester public static void main(String[] args) { boolean ok=true; try { ok&=testFITS(); ok&=testJSON(); ok&=testJSON0(); ok&=testASCII(); ok&=testSTRING(); ok&=testBasic(); ok&=testIterators(); ok&=testSetLimitOrder(); ok&=testContains(); ok&=testOperation(); ok&=testHierarchy(); ok&=testRange(); ok&=testIsInTree(); if( ok ) System.out.println("-------------- All is fine -----------"); else System.out.println("-------------- There is a problem -----------"); } catch( Exception e ) { e.printStackTrace(); } } } libcds-moc-java/cds/moc/examples/MocLint.java0000644000175000017500000003561712710115750020677 0ustar sladensladen// Copyright 2011 - Unistra/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc.examples; import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.InputStream; import java.net.URL; import cds.moc.HealpixMoc; /** * MOC check - verifying the IVOA 1.0 MOC recommendation compatibility * @author P.Fernique [CDS] * @version 1.0 - April 2016 * */ public class MocLint { static final private int MAXERROR = 20; private static int error(StringBuilder out,String s) { out.append("ERROR "+s+"\n"); return 1; } private static void info(StringBuilder out,String s) { out.append("INFO "+s+"\n"); } private static void status(StringBuilder out,String s) { out.append("STATUS "+s+"\n"); } private static int warning(StringBuilder out,String s) { out.append("WARNING "+s+"\n"); return 1; } private static void tooMany(StringBuilder out) throws Exception { out.append("ERROR Too many errors. Is it really a MOC ?"+"\n"); throw new Exception(); } // Example: 2016-05-09[T10:39[:00]] private static boolean checkDate(String s) { int mode=0; for( int i=0; iMAXERROR ) tooMany(out); } // if( bitpix!=8 ) e+=error(out,"FITS error: BITPIX=8 required in primary HDU"); if( !extend.equals("T") ) { w+=warning(out,"[2.3.2] HDU0: EXTEND=T required"); } // Skipping end of primary HDU int skip = 2880 - size % 2880; if( skip != 2880 ) { size += bis.skip(skip); } // Reading the second HDU line = 0; while( (n = bis.read(buf)) != 0 ) { size += n; line++; if( buf[0] == 'E' && buf[1] == 'N' && buf[2] == 'D' ) break; String key = getKey(buf); if( key.equals("COMMENT") || key.equals("HISTORY") ) continue; String val = getVal(buf); String s = (new String(buf,0,0,n)).trim(); if( ((char) buf[8]) != '=' ) { e+=error(out,"[2.3.2] HDU1 line " + line + ": missing \"=\" character ["+s+"]"); } if( line == 1 && (!key.equals("XTENSION") || key.equals("XTENSION") && !val.equals("BINTABLE")) ) { e+=error(out,"[2.3.2] HDU1 line " + line + ": XTENSION=BINTABLE missing"); } if( key.equals("BITPIX") ) bitpix = getInt(val); else if( key.equals("NAXIS") ) naxis = getInt(val); else if( key.equals("NAXIS1") ) naxis1 = getInt(val); else if( key.equals("NAXIS2") ) naxis2 = getInt(val); else if( key.equals("PCOUNT") ) pcount = getInt(val); else if( key.equals("GCOUNT") ) gcount = getInt(val); else if( key.equals("TFIELDS") ) tfields = getInt(val); else if( key.equals("MOCORDER") ) mocorder = getInt(val); else if( key.equals("TFORM1") ) tform1 = val; else if( key.equals("TTYPE1") ) ttype1 = val; else if( key.equals("PIXTYPE") ) pixtype = val; else if( key.equals("ORDERING") ) ordering = val; else if( key.equals("COORDSYS") ) coordsys = val; else if( key.equals("MOCTOOL") ) moctool = val; else if( key.equals("DATE") ) date = val; else if( key.equals("ORIGIN") ) origin = val; else if( key.equals("EXTNAME") ) extname = val; else if( key.equals("MOCTYPE") ) moctype = val; else if( key.equals("MOCID") ) mocid = val; // out.println("[" + key + "] [" + val + "]"); if( e>MAXERROR ) tooMany(out); } if( moctool.length()>0 ) info(out,"Generated by: "+moctool); if( date.length()>0 ) info(out,"Date: "+date); if( origin.length()>0 ) info(out,"Origin: "+origin); if( mocid.length()>0 ) info(out,"Moc id: "+mocid); if( extname.length()>0 ) info(out,"Extname: "+extname); if( moctype.length()>0 ) info(out,"Moc type: "+moctype); if( mocorder!=-1 ) info(out,"Moc order: "+mocorder); if( naxis2!=-1 ) info(out,"Number of rows: "+naxis2); if( tform1.length()>0 ) info(out,"Coding: " +(tform1.endsWith("J")?"32 bits integer":tform1.endsWith("K")?"64 bits long":tform1)); if( !coordsys.equals("C") ) w+=warning(out,"[2.3.2a]: COORDSYS=C mandatory in HDU1"); if( !pixtype.equals("HEALPIX") ) w+=warning(out,"[2.3.2a]: PIXTYPE=HEALPIX mandatory in HDU1"); if( !ordering.equals("NUNIQ") ) w+=warning(out,"[2.3.2a]: ORDERING=NUNIQ mandatory in HDU1"); if( gcount != 1 ) w+=warning(out,"[2.3.2]: only GCOUNT=1 authorized in HDU1"); if( pcount != 0 ) w+=warning(out,"[2.3.2]: only PCOUNT=0 authorized in HDU1"); if( mocorder ==-1 ) e+=error(out,"[2.3.2b]: MOCORDER is mandatory in HDU1"); else if( mocorder < 0 || mocorder > 29 ) e+=error(out,"[2.3.2b]: MOCORDER=n where n in [0..29] required in HDU1"); if( mocorder==29 ) info(out,"(!) mocOrder 29 is probably a wrong default value rather than a deliberated choice - check it!"); if( tfields != 1 ) e+=error(out,"[2.3.2]: TFIELDS=1 required in HDU1"); if( tform1.length() > 1 && tform1.charAt(0) != '1' ) e+=error(out,"[2.3.2]: TFORM1=1J or 1K required in HDU1"); if( tform1.length() > 1 ) tform1 = tform1.substring(1); if( !tform1.equals("J") && !tform1.equals("K") ) e+=error(out,"[2.3.2]: TFORM1=1J or 1K required in HDU1"); if( tform1.equals("J") && mocorder > 13 ) info(out,"(!) mocOrder>13 may require 64 rather than 32 bits integer coding (TFORM1=1K) - check it!"); if( naxis != 2 ) e+=error(out,"[2.3.2]: only NAXIS=2 authorized in HDU1"); if( tform1.equals("J") && naxis1 != 4 ) e+=error(out,"[2.3.2]: only NAXIS1=4 compatible with TFORM1=J in HDU1"); if( tform1.equals("K") && naxis1 != 8 ) e+=error(out,"[2.3.2]: only NAXIS1=8 compatible with TFORM1=K in HDU1"); if( naxis2 < 0 ) e+=error(out,"[2.3.2]: NAXIS2 error in HDU1"); if( date.length()>0 && !checkDate(date) ) w+=warning(out,"[2.3.2]: DATE syntax error: no FITS convention ["+date+"]"); // Skipping end of secondary HDU skip = 2880 - size % 2880; if( skip != 2880 ) { size += bis.skip(skip); } // Reading binary elements HealpixMoc moc = new HealpixMoc((int)mocorder); moc.setCheckConsistencyFlag(false); long[] hpix = null; int nbyte = tform1.equals("J") ? 4 : 8; byte t[] = new byte[nbyte]; for( long i = 0; i < naxis2; i++ ) { n=0; int m1; while( (m1=bis.read(t,n,t.length-n))!=0 ) { n+=m1; if( n==t.length ) break; } size += n; if( n != t.length ) e+=error(out,"[2.3.2]: truncated FITS table after row " + i); long val = 0; int a = ((t[0]) << 24) | (((t[1]) & 0xFF) << 16) | (((t[2]) & 0xFF) << 8) | (t[3]) & 0xFF; if( nbyte == 4 ) val = a; else { int b = ((t[4]) << 24) | (((t[5]) & 0xFF) << 16) | (((t[6]) & 0xFF) << 8) | (t[7]) & 0xFF; val = (((long) a) << 32) | ((b) & 0xFFFFFFFFL); } hpix = HealpixMoc.uniq2hpix(val, hpix); int order = (int) hpix[0]; long npix = hpix[1]; if( order < 0 || order > 29) e+=error(out,"[2.3.1]: order error in row " + i+ " ["+order+"]"); if( mocorder>=0 && order > mocorder ) w+=warning(out,"[2.3.1]: order greater than mocorder in row " + i+ " ["+order+"]"); long maxnpix = HealpixMoc.pow2(order); maxnpix *= maxnpix; maxnpix *= 12L; if( npix < 0 ) e+=error(out,"[2.3.1]: npix negative error in row " + i+ " ["+npix+"]"); if( npix >= maxnpix ) e+=error(out,"[2.3.1]: npix too high for the current order in row " + i+ " ["+npix+"]"); moc.add(order, npix); if( e>MAXERROR ) tooMany(out); } // Bien formée ? String s = moc.toString(); moc.setCheckConsistencyFlag(true); if( !s.equals(moc.toString()) ) w+=warning(out,"[2.2.3]: not well formed"); // Finishing FITS stream skip = 2880 - size % 2880; if( skip != 2880 ) { n = (int) bis.skip(skip); size+=n; if( n < skip ) w+=warning(out,"[2.3.2]: FITS table not aligned on 2880 byte blocks"); } bis.close(); bis=null; info(out,"FITS size: "+size+" bytes"); } catch( Exception e1 ) { e+=error(out,"Unrecovered exception !"); } finally { if( bis!=null ) try { bis.close(); } catch( Exception e2 ) {} } if( w==0 && e==0 ) { status(out,"OK! MOC compatible with IVOA MOC 1.0 recommendation"); return 1; } else if( e==0 ) { status(out,"WARNING! MOC ok but not fully compatible with IVOA MOC 1.0 recommendation"); return -1; } else { status(out,"ERROR! MOC error, not usable"); return 0; } } /** Check the IVOA 1.0 MOC recommendation compatibility * @param filename name of the file containing the MOC in FITS container * @return true if MOC is compatible */ public static boolean check(String filename) throws Exception { FileInputStream in = new FileInputStream(filename); return check(in); } // Just for test public static void main(String[] args) { try { String u = "http://alasky.unistra.fr/MocServer/query?ivorn=CDS/II/311/wise&get=moc"; URL url = new URL(u); InputStream in = url.openStream(); check(in); // check("/Users/Pierre/Desktop/CDS_II_311_wise.fits"); } catch( Exception e ) { e.printStackTrace(); } } } libcds-moc-java/cds/moc/examples/MocExample.java0000644000175000017500000001443112643426672021370 0ustar sladensladen// Copyright 2011 - UDS/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc.examples; import java.io.BufferedInputStream; import java.io.File; import java.io.FileOutputStream; import java.io.OutputStream; import java.net.URL; import cds.moc.Healpix; import cds.moc.HealpixMoc; import cds.moc.MocCell; public class MocExample { static public void main(String[] args) throws Exception { try { // Creation by Stream String u = "http://alasky.unistra.fr/MocServer/query?ivorn=CDS/II/311/wise&get=moc"; System.out.println("Loading this remote MOC: "+u+"..."); URL url = new URL(u); BufferedInputStream bis = new BufferedInputStream(url.openStream(), 32*1024); HealpixMoc mocA = new HealpixMoc(bis); System.out.println("Moc sky coverage : "+pourcent(mocA.getCoverage())); System.out.println("Moc order : "+mocA.getMocOrder()); System.out.println("Moc resolution : "+mocA.getAngularRes()*3600.+" arcsec"); System.out.println("Number of cells : "+mocA.getSize()); System.out.println("Sorted : "+mocA.isSorted()); System.out.println("In memory : ~"+mocA.getMem()+" bytes"); System.out.println("Information :"+ " MOCTOOL="+mocA.getProperty("MOCTOOL")+ " MOCTYPE="+mocA.getProperty("MOCTYPE")+ " MOCID="+mocA.getProperty("MOCID")+ " DATE="+mocA.getProperty("DATE")+ " ORIGIN="+mocA.getProperty("ORIGIN")+ " EXTNAME="+mocA.getProperty("EXTNAME")); System.out.print("Contents : "); display("MocA",mocA); // for( MocCell item : moc ) System.out.println(" "+item); // Creation by list of cells (JSON format or basic ASCII format), write and reread it. HealpixMoc mocB = new HealpixMoc(); mocB.add("{ \"3\":[2,53,55], \"4\":[20,21,22,25,28,30,50,60], \"5\":[456,567,836], \"9\":[123456] }"); // mocB.add("3/2,53,55 4/20-22,25,28,30,50,60 5/456,567,836 9/123456"); // Addition of some meta data mocB.setProperty("MOCTOOL","MyTool"); // Name of MOC tool generator mocB.setProperty("MOCID","ivo://CDS/0001"); // MOC unique identifier mocB.setProperty("MOCORDER","12"); // MOC resolution (best cell order) mocB.write("/Moc.fits"); mocB.read("/Moc.fits"); System.out.print("\nAnother Moc created by string: "); display("MocB",mocB); // Intersection, union, clone HealpixMoc clone = (HealpixMoc)mocA.clone(); HealpixMoc union = mocA.union(mocB); HealpixMoc inter = mocA.intersection(mocB); System.out.println("\nMocA coverage : "+pourcent(mocA.getCoverage())); System.out.println("MocB coverage : "+pourcent(mocB.getCoverage())); System.out.println("Moc union coverage : "+pourcent(union.getCoverage())); System.out.println("Moc inter coverage : "+pourcent(inter.getCoverage())); // Writing in FITS format File f; f = new File("Moc.fits"); System.out.println("\nWriting MocA in FITS file "+f.getAbsolutePath()); OutputStream outFits = (new FileOutputStream( f )); mocA.writeFits(outFits); outFits.close(); // Writing in JSON format f = new File("Moc.txt"); System.out.println("Writing MocA in JSON file "+f.getAbsolutePath()); OutputStream outJson = (new FileOutputStream( f )); mocA.writeJSON(outJson); outJson.close(); // HEALPix cell queries int order, npix; order=5; npix=849; System.out.println("\nHEALPix cell "+order+"/"+npix+" => inside mocA : "+mocA.isIntersecting(order, npix) ); order=7; npix=14103; System.out.println("HEALPix cell "+order+"/"+npix+" => inside mocA : "+mocA.isIntersecting(order, npix) ); System.out.println("MocA => intersects mocB : "+mocA.isIntersecting(mocB) ); // Coordinate queries Healpix hpx = new Healpix(); double al,del,radius; al = 095.73267; del = 69.55885; System.out.println("Coordinate ("+al+","+del+") => inside MocA : "+mocA.contains(hpx,al,del)); al = 095.60671; del = 69.57092; System.out.println("Coordinate ("+al+","+del+") => inside MocA : "+mocA.contains(hpx,al,del)); // circle queries al = 282.81215; del = -70.20608; radius = 30/60.; HealpixMoc circle = mocA.queryDisc(hpx, al, del, radius); display("MocA intersection with circle("+al+","+del+","+radius+")", circle); circle.setMocOrder(6); display("Same result for limit order 6", circle); } catch( Exception e ) { e.printStackTrace(); } } static String pourcent(double d) { return (int)(1000*d)/100.+"%"; } // Just for displaying a few cells static public void display(String title,HealpixMoc moc) { System.out.print(title+":"); int i=0; int oOrder=-1; for( MocCell item : moc ) { if( oOrder!=item.order ) { System.out.print("\n "+item.order+"/"); oOrder=item.order; i=0; } if( i!=0 && i<20) System.out.print(","); if( i<20 ) System.out.print(item.npix); if( i==21 ) System.out.print("..."); i++; } System.out.println(); } } libcds-moc-java/cds/moc/HealpixImpl.java0000644000175000017500000000434712535606610017731 0ustar sladensladen// Copyright 2011 - UDS/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc; /** HEALPix Interface wrapper for Moc usage * Encapsulate the usage HEALPix * * The HEALPix ordering is always NESTED * * @author Pierre Fernique [CDS] * @version 1.0 dec 2011 - creation */ public interface HealpixImpl { /** Provide the HEALPix number associated to a coord, for a given order * @param order HEALPix order [0..MAXORDER] * @param lon longitude (expressed in the Healpix frame) * @param lat latitude (expressed in the Healpix frame) * @return HEALPix number * @throws Exception */ public long ang2pix(int order,double lon, double lat) throws Exception; /** Provide the galactic coord associated to an HEALPix number, for a given order * @param order HEALPix order [0..MAXORDER] * @param npix HEALPix number * @return spherical coord (lon,lat) (expressed in the Healpix frame) * @throws Exception */ public abstract double [] pix2ang(int order,long npix) throws Exception; /** Provide the list of HEALPix numbers fully covering a circle (for a specified order) * @param order Healpix order * @param lon center longitude (expressed in the Healpix frame) * @param lat center latitude (expressed in the Healpix frame) * @param radius circle radius (in degrees) * @return * @throws Exception */ public long [] queryDisc(int order, double lon, double lat, double radius) throws Exception; } libcds-moc-java/cds/moc/Healpix.java0000644000175000017500000000731012535606610017100 0ustar sladensladen// Copyright 2011 - UDS/CNRS // The MOC API project is distributed under the terms // of the GNU General Public License version 3. // //This file is part of MOC API java project. // // MOC API java project is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, version 3 of the License. // // MOC API java project is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // The GNU General Public License is available in COPYING file // along with MOC API java project. // package cds.moc; import healpix.essentials.*; /** HEALPix CDS wrapper * Encapsulate the usage of the official HEALPix GAIA package * * The HEALPix ordering is always NESTED * * @author Pierre Fernique [CDS] * @version 1.3 May 2014 - NPIX => UNIQ fits keyword * @version 1.2 Jan 2012 - Thread safe implementation * @version 1.1 Oct 2011 - direct HealpixBase use * @version 1.0 May 2011 */ public final class Healpix implements HealpixImpl { /** Provide the HEALPix number associated to a coord, for a given order * @param order HEALPix order [0..MAXORDER] * @param lon longitude (expressed in the Healpix frame) * @param lat latitude (expressed in the Healpix frame) * @return HEALPix number * @throws Exception */ public long ang2pix(int order,double lon, double lat) throws Exception { double theta = Math.PI/2. - lat/180.*Math.PI; double phi = lon/180.*Math.PI; return healpixBase[order].ang2pix(new Pointing(theta,phi)); } /** Provide the spherical coord associated to an HEALPix number, for a given order * @param order HEALPix order [0..MAXORDER] * @param npix HEALPix number * @return coord (lon,lat) (expressed in the Healpix frame) * @throws Exception */ public double [] pix2ang(int order,long npix) throws Exception { Pointing res = healpixBase[order].pix2ang(npix); return new double[]{ res.phi*180./Math.PI, (Math.PI/2. - res.theta)*180./Math.PI}; } /** Provide the list of HEALPix numbers fully covering a circle (for a specified order) * @param order Healpix order * @param lon center longitude (expressed in the Healpix frame) * @param lat center latitude (expressed in the Healpix frame) * @param radius circle radius (in degrees) * @return * @throws Exception */ public long [] queryDisc(int order, double lon, double lat, double radius) throws Exception { double theta = Math.PI/2. - lat/180.*Math.PI; double phi = lon/180.*Math.PI; RangeSet list = healpixBase[order].queryDiscInclusive( new Pointing(theta, phi), Math.toRadians(radius),2); if( list==null ) return new long[0]; return list.toArray(); } /*********************** private stuff ***************************************************/ /** Maximal HEALPix order supported by the library */ static public final int MAXORDER = 29; static private HealpixBase [] healpixBase; static { healpixBase = new HealpixBase[MAXORDER+1]; try { for( int order=0; order>>(++i))>0); return --i; } } libcds-moc-java/META-INF/0000755000175000017500000000000012710431354014447 5ustar sladensladenlibcds-moc-java/META-INF/MANIFEST.MF0000644000175000017500000000014712710431352016101 0ustar sladensladenManifest-Version: 1.0 Ant-Version: Apache Ant 1.9.2 Created-By: 1.7.0_13-b20 (Oracle Corporation)