eris_nix_casu_match.c

/* $Id: casu_match.c,v 1.2 2015/08/07 13:06:54 jim Exp $
 *
 * ------------------------------------------------------------------------
 * This file is a copy of casu_match.c, modified to handle the needs of
 * ERIS/NIX. The changes are to cope with the smaller pixel size and FOV
 * of NIX compared to HAWKI for which the CASU methods were originally
 * developed.
 * ------------------------------------------------------------------------
 *
 * This file is part of the CASU Pipeline utilities
 * Copyright (C) 2015 European Southern Observatory
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
/*
 * $Author: jim $
 * $Date: 2015/08/07 13:06:54 $
 * $Revision: 1.2 $
 * $Name:  $
 */
 
/* Includes */
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include "eris_nix_casu_match.h"
 
#include <math.h>
 
#include <cpl.h>
#include <string.h>
#include <strings.h>
 
#include "casu_mods.h"
#include "casu_stats.h"
#include "catalogue/casu_utils.h"
 
#define NX 2048
#define NY 2048
#define NGRIDMAX_XY 61
#define NGRIDMAX_STD 31
 
static cpl_table *casu_mkmstd_table(cpl_table *objtab, cpl_table *stdstab);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
int eris_nix_casu_matchstds(cpl_table *objtab, cpl_table *stdstab, float srad,
                            float min_errlim, cpl_table **outtab,
                            int *status) {
    const char *fctid = "eris_casu_matchstds";
    char *colname;
    int nobj,nstd,ngrid,ngrid2,ibest,ig,jg,nmatch,k,*matches,jm,l,dont,null,k2;
    float *xstd,*ystd,*xobj,*yobj,aveden,errlim,xoffbest,yoffbest,*xoffs;
    float *yoffs,x,y,xx2,yy2,r2,xx1,yy1,r1,xoffmed,sigx,yoffmed,sigy,xoff,yoff;
    cpl_propertylist *p;
    cpl_table *mstds;
    cpl_array *colnames;
 
    /* Inherited status */
 
    *outtab = NULL;
    if (*status != CASU_OK)
        return(*status);
 
    /* Check the size of each of the tables */
 
    nobj = (int)cpl_table_get_nrow(objtab);
    nstd = (int)cpl_table_get_nrow(stdstab);
    if (nobj == 0) {
        cpl_msg_warning(fctid,"Object table has no rows");
        mstds = casu_mkmstd_table(objtab,stdstab);
        *outtab = cpl_table_extract_selected(mstds);
        cpl_table_delete(mstds);
        WARN_RETURN
    } else if (nstd == 0) {
        cpl_msg_warning(fctid,"Standards RA/DEC table has no rows");
        mstds = casu_mkmstd_table(objtab,stdstab);
        *outtab = cpl_table_extract_selected(mstds);
        cpl_table_delete(mstds);
        WARN_RETURN
    }
 
    /* First, sort the two tables by the Y coordinate */
 
    p = cpl_propertylist_new();
    cpl_propertylist_append_bool(p,"Y_coordinate",0);
    if (cpl_table_sort(objtab,p) != CPL_ERROR_NONE) {
        cpl_propertylist_delete(p);
        FATAL_ERROR
    }
    cpl_propertylist_erase(p,"Y_coordinate");
    cpl_propertylist_append_bool(p,"ypredict",0);
    if (cpl_table_sort(stdstab,p) != CPL_ERROR_NONE) {
        cpl_propertylist_delete(p);
        FATAL_ERROR
    }
    cpl_propertylist_delete(p);
 
    /* Get the x,y coordinates for each table */
 
    xobj = cpl_table_get_data_float(objtab,"X_coordinate");
    yobj = cpl_table_get_data_float(objtab,"Y_coordinate");
    xstd = cpl_table_get_data_float(stdstab,"xpredict");
    ystd = cpl_table_get_data_float(stdstab,"ypredict");
    if (xstd == NULL || ystd == NULL || xobj == NULL || yobj == NULL)
        FATAL_ERROR
 
    /* Calculate the error limit and the number of grid points */
 
    // This is the average density of stars in the image
    // FIXME it is incorrect to assume NX and NY are fixed
    aveden = (float)max(nstd,nobj)/(float)(NX*NY);
    // An initial estimate of a sensible error limit
    errlim = 1.0/sqrt(4.0*CPL_MATH_PI*aveden);
 
    /* Change from casu_matchstds. 
       The second parameter of min is hardwired to 15.0 in the original.
 
       The aim is to set a sensible starting point for the tightness of 
       the initial match.
 
       15.0 corresponds to 1.5 arcsec for the HAWKI pixel size of 0.1 
       arcsec. For NIX the pixels are 0.013 or 0.025 arcsec so this limit 
       should be higher - to match for example the inter-jitter pointing
       error of the telescope.
    */
       
    cpl_msg_info(cpl_func, "min_errlim %4.2f", min_errlim);
    errlim = min(errlim,min_errlim);
    // The grid size to achieve this
    ngrid = (int)(srad/errlim);
    ngrid = (ngrid/2)*2 + 1;
    // Constrain the number of grid points
    ngrid = max(5,min(NGRIDMAX_STD,ngrid));
    ngrid2 = ngrid/2 + 1;
 
    cpl_msg_info(fctid, "Search radius is %f pixels. Using a %d x %d grid, with error limit of %f", srad, ngrid, ngrid, errlim);
 
    /* Now search for the best solution */
 
    ibest = 0;
    xoffbest = 0.0;
    yoffbest = 0.0;
    for (ig = -ngrid2; ig <= ngrid2; ig++) {
        xoff = (float)ig*errlim*CPL_MATH_SQRT2;
        for (jg = -ngrid2; jg <= ngrid2; jg++) {
            yoff = (float)jg*errlim*CPL_MATH_SQRT2;
            nmatch = 0;
            for (k = 0; k < nobj; k++) {
                x = xobj[k] + xoff;
                y = yobj[k] + yoff;
                if (casu_fndmatch(x,y,xstd,ystd,nstd,errlim) > -1) 
                    nmatch++;
            }
            if (nmatch > ibest) {
                ibest = nmatch;
                xoffbest = xoff;
                yoffbest = yoff;
            }
        }
    }
 
    /* Now allocate some workspace so that you can calculate a good median
       coordinate difference */
 
    xoffs = cpl_malloc(nstd*sizeof(*xoffs));
    yoffs = cpl_malloc(nstd*sizeof(*yoffs));
    matches = cpl_malloc(nstd*sizeof(*matches));
    for (k = 0; k < nstd; k++)
        matches[k] = -1;
 
    /* Now get the best matches */
 
    nmatch = 0;
    for (k = 0; k < nstd; k++) {
        x = xstd[k] - xoffbest;
        y = ystd[k] - yoffbest;
        jm = casu_fndmatch(x,y,xobj,yobj,nobj,errlim);
        if (jm > -1) {
            dont = 0;
            xx2 = xobj[jm] - x;
            yy2 = yobj[jm] - y;
            r2 = sqrt(xx2*xx2 + yy2*yy2);
            for (l = 0; l < nstd; l++) {
                if (matches[l] == jm) {
                    xx1 = xobj[jm] - (xstd[l] - xoffbest);
                    yy1 = yobj[jm] - (ystd[l] - yoffbest);
                    r1 = sqrt(xx1*xx1 + yy1*yy1);
                    if (r2 < r1) 
                        matches[l] = -1;
                    else
                        dont = 1;
                    break;
                }
            }
            if (dont == 0)
                matches[k] = jm;
        }
    }
 
    /* Now get the coordinate difference for the best matches */
 
    for (k = 0; k < nstd; k++) {
        jm = matches[k];
        if (jm != -1) {
            xoffs[nmatch] = xobj[jm] - xstd[k];
            yoffs[nmatch] = yobj[jm] - ystd[k];
            nmatch++;
        }
    }
    if (nmatch == 0) {
        xoffmed = 0.0;
        sigx = 1.0;
        yoffmed = 0.0;
        sigy = 1.0;
    } else {
        casu_medmad(xoffs,NULL,nmatch,&xoffmed,&sigx);
        sigx *= 1.48;
        casu_medmad(yoffs,NULL,nmatch,&yoffmed,&sigy);
        sigy *= 1.48;
    }
 
    cpl_msg_info(fctid, "Median offset x=%f y=%f, sigx=%f sigy=%f", xoffmed, yoffmed, sigx, sigy);
 
    /* Now go through one final time with a reduced error box and get
       the final matches */
 
    errlim = 3.0*max(sigx,sigy);
    for (k = 0; k < nstd; k++)
        matches[k] = -1;
    for (k = 0; k < nstd; k++) {
        x = xstd[k] + xoffmed;
        y = ystd[k] + yoffmed;
        jm = casu_fndmatch(x,y,xobj,yobj,nobj,errlim);
        if (jm > -1) {
            dont = 0;
            xx2 = xobj[jm] - x;
            yy2 = yobj[jm] - y;
            r2 = sqrt(xx2*xx2 + yy2*yy2);
            for (l = 0; l < nstd; l++) {
                if (matches[l] == jm) {
                    xx1 = xobj[jm] - (xstd[l] + xoffmed);
                    yy1 = yobj[jm] - (ystd[l] + yoffmed);
                    r1 = sqrt(xx1*xx1 + yy1*yy1);
                    if (r2 < r1) 
                        matches[l] = -1;
                    else
                        dont = 1;
/*                  break; */
                }
            }
            if (dont == 0)
                matches[k] = jm;
        }
    }
    jm = matches[1];
 
    /* Make a copy of the standards table and add all the columns from the
       object catalogue to it. Ignore the RA and DEC columns in the catalogue
       as the standards table will already have these.*/
 
    mstds = cpl_table_duplicate(stdstab);
    colnames = cpl_table_get_column_names(objtab);
    ig = (int)cpl_array_get_size(colnames);
    for (k = 0; k < ig; k++) {
        colname = (char *)cpl_array_get_string(colnames,(cpl_size)k);
        if (strcasecmp(colname,"RA") && strcasecmp(colname,"DEC"))
            cpl_table_new_column(mstds,colname,
                                 cpl_table_get_column_type(objtab,colname));
    }
    cpl_table_unselect_all(mstds);
    cpl_array_delete(colnames);
 
    /* Now go through and find the matches. NB: the columns in objtab
       are created by casu_imcore which only produces integer, float and
       double columns, so we don't need to worry about any other type 
       when copying the columns to the matched standards catalogue. */
 
    colnames = cpl_table_get_column_names(objtab);
    ig = (int)cpl_array_get_size(colnames);
    for (k = 0; k < nstd; k++) {
        jm = matches[k];
        if (jm != -1) {
            for (k2 = 0; k2 < ig; k2++) {
                colname = (char *)cpl_array_get_string(colnames,
                                                             (cpl_size)k2);
                if (!strcasecmp(colname,"RA") || !strcasecmp(colname,"DEC")) 
                    continue;
                null = 0;
                switch (cpl_table_get_column_type(objtab,colname)) {
                case CPL_TYPE_INT:
                    cpl_table_set_int(mstds,colname,(cpl_size)k,
                                      cpl_table_get_int(objtab,colname,
                                                        (cpl_size)jm,&null));
                    break;
                case CPL_TYPE_FLOAT:
                    cpl_table_set_float(mstds,colname,(cpl_size)k,
                                        cpl_table_get_float(objtab,colname,
                                                            (cpl_size)jm,&null));
                    break;
                case CPL_TYPE_DOUBLE:
                    cpl_table_set_double(mstds,colname,(cpl_size)k,
                                         cpl_table_get_double(objtab,colname,
                                                              (cpl_size)jm,&null));
                    break;
                case CPL_TYPE_STRING:
                    cpl_table_set_string(mstds,colname,(cpl_size)k,
                                         cpl_table_get_string(objtab,colname,
                                                              (cpl_size)jm));
                    break;
                default:
                    cpl_msg_info(fctid, "Ignoring column %s of type %d", colname, cpl_table_get_column_type(objtab,colname));
                    break;
                }
            }
            cpl_table_select_row(mstds,(cpl_size)k);
        }
    }
    cpl_array_delete(colnames);
 
    /* Now extract the selected rows into the output table */
 
    *outtab = cpl_table_extract_selected(mstds);
    cpl_table_delete(mstds);
 
    /* Tidy up */
 
    freespace(matches);
    freespace(xoffs);
    freespace(yoffs);
    GOOD_STATUS
}
 
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
    
static cpl_table *casu_mkmstd_table(cpl_table *objtab, cpl_table *stdstab) {
    cpl_table *mstds;
    char *colname;
    cpl_array *colnames;
    cpl_size ncol,i;
 
    /* Copy the input standards table */
 
    mstds = cpl_table_duplicate(stdstab);
 
    /* Loop throught the object table columns and copy all of them over, 
       except for the RA and DEC tables */
 
    colnames = cpl_table_get_column_names((const cpl_table *)objtab);
    ncol = cpl_array_get_size(colnames);
    for (i = 0; i < ncol; i++) {
        colname = (char *)cpl_array_get_string(colnames,i);
        if (strcmp(colname,"RA") && strcmp(colname,"DEC"))
            cpl_table_new_column(mstds,colname,
                                 cpl_table_get_column_type(objtab,colname));
    }
    cpl_array_delete(colnames);
    cpl_table_unselect_all(mstds);
 
    /* Get out of here */
 
    return(mstds);
}