epr_bitmask.c

Insar图像处理软件

/*
 * $Id: epr_bitmask.c,v 1.1.1.1 2003/03/05 17:36:43 hartmut Exp $
 *
 * Copyright (C) 2002 by Brockmann Consult ([e-mail])
 *
 * 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. This program is distributed in the hope 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.
 */

#include <ctype.h>

#include "epr_api.h"
#include "epr_core.h"
#include "epr_string.h"
#include "epr_ptrarray.h"
#include "epr_swap.h"
#include "epr_field.h"
#include "epr_record.h"
#include "epr_param.h"
#include "epr_dsd.h"
#include "epr_msph.h"
#include "epr_band.h"
#include "epr_bitmask.h"

#include "epr_dddb.h"

void epr_resolve_bm_ref(EPR_SBmEvalContext* context, EPR_SBmTerm* term);



EPR_SBmEvalContext* epr_create_bm_eval_context(EPR_SProductId* product_id, 
                                               int offset_x, 
                                               int offset_y, 
                                               EPR_SRaster* bitmask_raster)
{
    EPR_SBmEvalContext* context;
    
    context = (EPR_SBmEvalContext*) calloc(1, sizeof (EPR_SBmEvalContext));
    if (context == NULL) {
        epr_set_err(e_err_out_of_memory, 
                    "epr_create_bm_eval_context: out of memory");
        return NULL;
    }
    context->product_id = product_id;
    context->offset_x = offset_x;
    context->offset_y = offset_y;
    context->bitmask_raster = bitmask_raster;
    context->flag_band_ids = epr_create_ptr_array(4);
    context->flag_rasters = epr_create_ptr_array(4);
    return context;
}


void epr_free_bm_eval_context(EPR_SBmEvalContext* context) 
{
    EPR_SRaster* flag_raster;
    uint flag_index;

    if (context == NULL) {
        return;
    }
    
    if (context->flag_band_ids != NULL) {
        for (flag_index = 0; flag_index < context->flag_band_ids->length; flag_index++) {
            /* 
             * Note that the release of band ID's is handled by the epr_close_product() function,
             * The rasters need to be released, because they are internally used by this
             * context.
             */
            flag_raster = (EPR_SRaster*)context->flag_rasters->elems[flag_index];
            epr_free_raster(flag_raster);
        }
        epr_free_ptr_array(context->flag_band_ids);
        epr_free_ptr_array(context->flag_rasters);
    }
    free(context);
}

/**
 * Reads bit-mask pixels of the given product for the given bit-mask expression 
 * for the given region offset and raster.
 *
 * @param product_id the product ID
 * @param bm_expr the bit-mask expression
 * @param offset_x X-coordinate in pixel co-ordinates (zero-based) of the upper right raster corner to be searched for
 * @param offset_y Y-coordinate in pixel co-ordinates (zero-based) of the upper right raster corner to be searched for
 * @param raster the instance to the buffer information was used
 *
 * @return zero for success, an error code otherwise
 */
int epr_read_bitmask_raster(EPR_SProductId* product_id, 
                            const char* bm_expr, 
                            int offset_x, 
                            int offset_y, 
                            EPR_SRaster* raster)
{
    EPR_SBmEvalContext* context;
    EPR_SBmTerm* term;
    int x, y, x1, x2, y1, y2, sx, sy;
    uint pos;
    uchar* bm_buffer = NULL;
    EPR_EErrCode errcode;

    epr_clear_err();

    if (raster->data_type != e_tid_uchar && raster->data_type != e_tid_char) {
        epr_set_err(e_err_illegal_data_type, 
            "epr_read_bitmask_raster: illegal raster datatype; must be 'char' or 'uchar'");
        return e_err_illegal_data_type; 
    }

    bm_buffer = (uchar*) raster->buffer;
    if (bm_buffer == NULL) {
         epr_set_err(e_err_out_of_memory, 
             "epr_read_bitmask_raster: false memory allocation for a raster buffer");
        return e_err_out_of_memory; 
    }

    context = epr_create_bm_eval_context(product_id, offset_x, offset_y, raster);
    if (context == NULL) {
         epr_set_err(e_err_illegal_arg, 
             "epr_read_bitmask_raster: the context cannot be created");
        return e_err_illegal_arg; 
    }

    term = epr_parse_bm_expr_str(bm_expr);

    if (term == NULL) {
         epr_set_err(e_err_illegal_arg, 
             "epr_read_bitmask_raster: the term was not build");
        return e_err_illegal_arg; 
    }

    x1 = offset_x;
    y1 = offset_y;
    x2 = x1 + raster->source_width - 1;
    y2 = y1 + raster->source_height - 1;
    sx = raster->source_step_x;
    sy = raster->source_step_y;
    pos = 0;

    epr_clear_err();

    errcode = epr_get_last_err_code();
    for (y = y1; y <= y2; y += sy) {
        for (x = x1; x <= x2; x += sx) {
            bm_buffer[pos] = (uchar) epr_eval_bm_term(context, term, x, y);
            pos++;
            errcode = epr_get_last_err_code();
            if (errcode != 0) {
                break;
            }
        }
        if (errcode != 0) {
            break;
        }
    }

    epr_free_bm_term(term);
    epr_free_bm_eval_context(context);

    return errcode;
}

/**
 * Evaluates the given bitmask expression.
 *
 * @param term the bitmask term
 * @param x the pixel's x co-ordinate
 * @param y the pixel's y co-ordinate
 */
boolean epr_eval_bm_term(EPR_SBmEvalContext* context, EPR_SBmTerm* term, int x, int y) {
    
    if (term == NULL) {
        return FALSE;
    }

    switch (term->op_code) {
    case BMT_REF:
		{
			EPR_SRaster* flag_raster = term->op.ref.flag_raster;
            ulong flag_mask = term->op.ref.flag_mask;

            if (flag_raster == NULL) {
                epr_resolve_bm_ref(context, term);
                flag_raster = term->op.ref.flag_raster;
                flag_mask = term->op.ref.flag_mask;
                if (flag_raster == NULL) {
                    return FALSE;
                }
            }

            assert(flag_raster != NULL);
            assert(flag_mask != FLAG_MASK_NOT_COMPUTED);
            return (epr_get_pixel_as_ulong(flag_raster, x, y) & flag_mask) != 0;
        }
    case BMT_AND:
		{
			if (!epr_eval_bm_term(context, term->op.binary.arg1, x, y)) {
                return FALSE;
			}
            return epr_eval_bm_term(context, term->op.binary.arg2, x, y);
		}
    case BMT_OR:
		{
            if (epr_eval_bm_term(context, term->op.binary.arg1, x, y)) {
                return TRUE;
			}
            return epr_eval_bm_term(context, term->op.binary.arg2, x, y);
        }
    case BMT_NOT:
		{
            return !epr_eval_bm_term(context, term->op.unary.arg, x, y);
        }
    default:
        assert(0);
        return FALSE;
    }
}


void epr_resolve_bm_ref(EPR_SBmEvalContext* context, EPR_SBmTerm* term) {
    const char* band_name = term->op.ref.band_name;
    const char* flag_name = term->op.ref.flag_name;
    EPR_SBandId* flag_band_id = NULL;
    uint flag_band_index = (uint) -1;
    uint band_index = 0;
    uint num_bands = context->flag_band_ids->length;
    EPR_SRaster* flag_raster = NULL;
    ulong flag_mask = FLAG_MASK_NOT_COMPUTED;

    /* Find the corresponding flag_band_id for band_name */
    for (band_index = 0; band_index < num_bands; band_index++) {
        flag_band_id = (EPR_SBandId*) context->flag_band_ids->elems[band_index];
        if (epr_equal_names(band_name, flag_band_id->band_name)) {
            flag_band_index = band_index;
            break;
        }
    }
    /* flag_band_id found? */
    if (flag_band_index != (uint) -1) {
        /* Yes, found: get flag_band_id  and the corresponding raster */
        flag_band_id = (EPR_SBandId*)(context->flag_band_ids->elems[flag_band_index]); 
        flag_raster = (EPR_SRaster*)(context->flag_rasters->elems[flag_band_index]); 
    } else {
        /* Not found: get flag_band_id from product and load the corresponding raster */
        flag_band_id = epr_get_band_id(context->product_id, band_name);
        if (flag_band_id != NULL) {
            flag_raster = epr_create_compatible_raster(flag_band_id, 
                                            context->bitmask_raster->source_width, 
                                            context->bitmask_raster->source_height, 
                                            context->bitmask_raster->source_step_x, 
                                            context->bitmask_raster->source_step_y);
            epr_read_band_raster(flag_band_id, 
                                 context->offset_x, 
                                 context->offset_y, 
                                 flag_raster);
            /* register flag_band_id and flag_raster for later use */
            epr_add_ptr_array_elem(context->flag_band_ids, flag_band_id);
            epr_add_ptr_array_elem(context->flag_rasters, flag_raster);
        } else {
            epr_set_err(e_err_flag_not_found, "flags band not found");
            return;
        }
    }
    
    /* Now, compute flag_mask */

    /* Does the band have a flag coding? */
    if (flag_band_id->flag_coding != NULL) {
        /* Yes, now find flag definition for flag_name */
        EPR_SFlagDef* flag_def = NULL;
        uint flag_def_index;
        for (flag_def_index = 0; flag_def_index < flag_band_id->flag_coding->length; flag_def_index++) {
            flag_def = (EPR_SFlagDef*) flag_band_id->flag_coding->elems[flag_def_index];
            if (epr_equal_names(flag_def->name, flag_name)) {
                int bit_index = flag_def->bit_index;
                flag_mask = 1 << bit_index;
                break;
            }
        }
    }
    if (flag_mask == FLAG_MASK_NOT_COMPUTED) {
        epr_set_err(e_err_flag_not_found, "flag not found");
    }    
    term->op.ref.flag_mask = flag_mask;
    term->op.ref.flag_raster = flag_raster;
}

/**
 * Parses the bit-mask expression given as character string.
 *
 * @param bm_expr the bit-mask expression given as character string
 * @return the bit-mask term tree representing the bit-mask expression
 * @throws BitmaskExpressionParseException if the given code could not be epr_parse'd
 * @throws IOException if an I/O error occurs
 */
EPR_SBmTerm* epr_parse_bm_expr_str(const char* bm_expr) {
    
    EPR_SBmTerm* term;
    EPR_SParseInfo parse_info;
    
    parse_info.bm_expr = bm_expr;
    parse_info.bm_expr_pos = 0;
    parse_info.pushed_back = FALSE;
    parse_info.token = NULL;
    parse_info.err_message = NULL;

    term = epr_parse_bm_expr(&parse_info, FALSE);
    
    epr_free_string(parse_info.token);
    parse_info.token = NULL;

    if (epr_is_bm_expr_error(&parse_info)) {
        char tmp[256] = {"bitmap-expression error: "};
        strcat(tmp, parse_info.err_message);
        epr_set_err(e_err_invalid_value, tmp);
    }

    return term;
}


EPR_SPtrArray* epr_create_flag_coding(EPR_SProductId* product_id, const char* flag_coding_name)
{
	int num_descr;
    int i;
    const struct FlagDescriptorTable* fc_tables;
    int fct_index;
    EPR_SPtrArray* flag_coding = NULL;

	if (product_id == NULL) {    
        epr_set_err(e_err_null_pointer, 
                    "epr_create_flag_coding: product_id must not be NULL");
        return NULL;
    }

    /* @DDDB */

    fc_tables = dddb_flag_coding_tables;
    fct_index = -1;
    for (i = 0; i < EPR_NUM_FLAG_CODING_TABLES; i++) { 
        const char* id = fc_tables[i].name;
        if (epr_equal_names(id, flag_coding_name)) {
            fct_index = i;
            break;
        }
    }
    if (fct_index == -1) {
        epr_set_err(e_err_null_pointer, 
                    "epr_create_flag_coding: unknown flag coding");
        return NULL;
    }

    flag_coding = epr_create_ptr_array(16);
    num_descr = fc_tables[fct_index].num_descriptors;
	for (i = 0; i < num_descr; i++) {
		EPR_SFlagDef* flag_def = (EPR_SFlagDef*) calloc(1, sizeof (EPR_SFlagDef));
		if (flag_def == NULL) {
			epr_set_err(e_err_out_of_memory, 
						"epr_create_flag_coding: out of memory");
			return NULL;
		}
        /* 1: flag_name */
        epr_assign_string(&flag_def->name, fc_tables[fct_index].descriptors[i].id);
        if (flag_def->name == NULL) {
            epr_set_err(e_err_out_of_memory, "epr_get_flag_coding: out of memory");
            epr_free_flag_def(flag_def);
            return NULL;
        }
        /* 2: dataset_name */
        flag_def->bit_index = (uint)fc_tables[fct_index].descriptors[i].bit_index;
         /* 3: sample_offset */
        epr_assign_string(&flag_def->description, fc_tables[fct_index].descriptors[i].description);

		epr_add_ptr_array_elem(flag_coding, flag_def);
	}
    return flag_coding;
}


void epr_free_flag_coding(EPR_SPtrArray* flag_coding)
{
    EPR_SFlagDef* flag_def = NULL;
    uint flag_index;

    if (flag_coding == NULL) {
        return;
    }
    
    for (flag_index = 0; flag_index < flag_coding->length; flag_index++)
    {
        flag_def = (EPR_SFlagDef*) flag_coding->elems[flag_index];
        epr_free_flag_def(flag_def);
        flag_def = NULL;
    }
    epr_free_ptr_array(flag_coding);
}


EPR_SFlagDef* epr_create_flag_def()
{
    EPR_SFlagDef* flag_def = NULL;

    flag_def = (EPR_SFlagDef*) calloc(1, sizeof (EPR_SFlagDef));
    if (flag_def == NULL) {
        epr_set_err(e_err_out_of_memory, 
                    "epr_create_flag_def: out of memory");
        return NULL;
    }
    flag_def->magic = EPR_MAGIC_FLAG_DEF;

    return flag_def;
}


void epr_free_flag_def(EPR_SFlagDef* flag_def)
{
    if (flag_def == NULL) 
        return;

    epr_free_string(flag_def->name);
    flag_def->name = NULL;
    flag_def->bit_index = 0;
    epr_free_string(flag_def->description);
    flag_def->description = NULL;

    free(flag_def);
}


EPR_SBmTerm* epr_parse_bm_expr(EPR_SParseInfo* parse_info, boolean term_required) {
    return epr_parse_bm_OR_expr(parse_info, term_required);
}



EPR_SBmTerm* epr_parse_bm_OR_expr(EPR_SParseInfo* parse_info, boolean term_required) {
    EPR_SBmTerm* term1 = epr_parse_bm_AND_expr(parse_info, term_required);
    if (term1 == NULL) {
        return NULL;
    }

    while (!epr_is_bm_expr_error(parse_info)) {
        epr_next_bm_expr_token(parse_info);
        if (epr_is_bm_OR_keyword(parse_info) || epr_is_bm_OR_operator(parse_info)) {
            EPR_SBmTerm* term2 = epr_parse_bm_OR_expr(parse_info, TRUE);
            term1 = epr_create_bm_OR_term(term1, term2);
        } else {
            epr_push_back_bm_expr_token(parse_info);
            break;
        }
    }

    return term1;
}

EPR_SBmTerm* epr_parse_bm_AND_expr(EPR_SParseInfo* parse_info, boolean term_required) {
    EPR_SBmTerm* term1 = epr_parse_bm_unary_expr(parse_info, term_required);
    if (term1 == NULL) {