eris_nix_wavecal_utils.c

/* $Id$
 *
 * This file is part of the ERIS/NIX Pipeline
 * Copyright (C) 2017 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 /*
 * $Author$
 * $Date$
 * $Rev$
 */
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
/*-----------------------------------------------------------------------------
                                   Includes
 -----------------------------------------------------------------------------*/
 
#include "eris_nix_wavecal_utils.h"
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cpl_matrix * enwu_linepos_2d(const hdrl_image * spectrum2d, 
                             const cpl_size slice_index,
                             const cpl_vector * guess_pos) {
 
    cpl_matrix * line_pos = NULL;
    cpl_vector * next_guess_pos = NULL;
    cpl_vector * spectrum1d = NULL;
 
    if (cpl_error_get_code() != CPL_ERROR_NONE) return NULL;
 
    cpl_ensure(spectrum2d, CPL_ERROR_NULL_INPUT, NULL);
    cpl_ensure(guess_pos, CPL_ERROR_NULL_INPUT, NULL);
    cpl_ensure(cpl_vector_get_size(guess_pos) > 0,
               CPL_ERROR_ILLEGAL_INPUT, NULL);
 
    cpl_size nlines = cpl_vector_get_size(guess_pos);
 
    const cpl_size nx = hdrl_image_get_size_x(spectrum2d);
    line_pos = cpl_matrix_new(nx, nlines);
    cpl_matrix_fill(line_pos, NAN);
 
    /* loop through slices on RH side of image. Remember that cpl_image
       indeces are 1-based, cpl_vector and cpl_matrix 0-based - fab! */
 
    next_guess_pos = cpl_vector_duplicate(guess_pos);
 
    for (cpl_size ix = slice_index; ix < nx; ix++) {
 
        /* fit the lines in this slice to get accurate peak positions */
 
        spectrum1d = cpl_vector_new_from_image_column(
                     hdrl_image_get_image_const(spectrum2d), ix+1);
    
        for (cpl_size line_id=0; line_id < nlines; line_id++) {
            double line_guess_pos = cpl_vector_get(next_guess_pos, line_id);
            double fitted_pos = enwu_linepos_1d(spectrum1d, line_guess_pos);
            if (!isnan(fitted_pos)) {
 
                /* set the fit peak as the measured position of the line,
                   set next_guess_pos to the actual line positions so that
                   it can follow slow variations with ix */
 
                cpl_matrix_set(line_pos, ix, line_id, fitted_pos);
                cpl_vector_set(next_guess_pos, line_id, fitted_pos);
            }
        }
        cpl_vector_delete(spectrum1d);
    }
    cpl_vector_delete(next_guess_pos);
 
    /* now loop through slices on LH side of image */
 
    next_guess_pos = cpl_vector_duplicate(guess_pos);
 
    for (cpl_size ix = slice_index-1; ix >= 0; ix--) { 
        spectrum1d = cpl_vector_new_from_image_column(
                     hdrl_image_get_image_const(spectrum2d), ix+1);
    
        for (cpl_size line_id=0; line_id < nlines; line_id++) {
            double line_guess_pos = cpl_vector_get(next_guess_pos, line_id);
            double fitted_pos = enwu_linepos_1d(spectrum1d, line_guess_pos);
            if (!isnan(fitted_pos)) {
                cpl_matrix_set(line_pos, ix, line_id, fitted_pos);
                cpl_vector_set(next_guess_pos, line_id, fitted_pos);
            }
        }
        cpl_vector_delete(spectrum1d);
    }
    cpl_vector_delete(next_guess_pos);
 
    /* Return NULL on error */
 
    if (cpl_error_get_code() != CPL_ERROR_NONE) {
        cpl_matrix_delete(line_pos);
        line_pos = NULL;
    }
 
    return line_pos;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
double enwu_linepos_1d(const cpl_vector * spectrum1d,
                       const double guess_pos) {
 
    if (cpl_error_get_code() != CPL_ERROR_NONE) return NAN;
    cpl_ensure(spectrum1d, CPL_ERROR_NULL_INPUT, NAN);
 
    cpl_polynomial * line_fit = NULL;
    double result = NAN;
 
    cpl_size half_width = 4;
    cpl_size istart = (cpl_size) guess_pos - half_width;
    cpl_size istop = (cpl_size) guess_pos + half_width;
    cpl_size npos = istop - istart + 1;
 
    /* set up pixel positions of chunk */
 
    cpl_matrix * pos_chunk = cpl_matrix_new(1, npos);
    for (cpl_size i = 0; i < npos; i++) {
        cpl_matrix_set(pos_chunk, 0, i, (double) (i + istart));
    }
 
    /* get spectrum data for chunk, spec_ok goes False if any points 
       bad (=0) or are NaN, the fitting routine can't handle NaNs */
 
    cpl_vector * spectrum_chunk = cpl_vector_extract(spectrum1d,
                                                     istart, istop, 1);
    const double * spectrum_chunk_data = cpl_vector_get_data_const(
                                         spectrum_chunk);
    int spec_ok = 1;
    for (cpl_size i = 0; i < npos; i++) {
        spec_ok = spec_ok &&
                  spectrum_chunk_data[i] != 0.0 &&
                  !isnan(spectrum_chunk_data[i]);
    }
 
    /* fit a parabola to the line peak if the data are good */
 
    if (spec_ok) {
        line_fit = cpl_polynomial_new(1);
        const cpl_size maxdeg1d = 2;
        cpl_polynomial_fit(line_fit, pos_chunk, NULL, spectrum_chunk, NULL,
                           CPL_FALSE, NULL, &maxdeg1d);
 
        /* set the fit peak as the measured position of the line,
           set next_guess_pos to the actual line positions so that
           it can follow slow variations with ix */
 
        cpl_size pow = 1;
        double poly_b = cpl_polynomial_get_coeff(line_fit, &pow);
        pow = 2;
        double poly_c = cpl_polynomial_get_coeff(line_fit, &pow);
        result = -poly_b / (2.0 * poly_c);
 
        /* if the fitted line centre is outside the expected range 
           then something has probably gone wrong - errant pixel or
           something - ignore it */
 
        if (fabs(result - guess_pos) > half_width) {
            result = NAN;
        } 
    }
 
    cpl_matrix_delete(pos_chunk);
    cpl_vector_delete(spectrum_chunk);
    cpl_polynomial_delete(line_fit);
 
    if (cpl_error_get_code() != CPL_ERROR_NONE) {
        result = NAN;
    }
 
    return result;
}