/home/pascal/depot/filedata/src/epr/epr_bitmask.h

/*
 * $Id: epr__bitmask_8h_source.html,v 1.11 2013/02/14 16:57:53 pascal Exp $
 *
 * Copyright (C) 2002 by Brockmann Consult (info@brockmann-consult.de)
 *
 * 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.
 */

#ifndef EPR_BITMASK_H_INCL
#define EPR_BITMASK_H_INCL

#ifdef __cplusplus
extern "C"
{
#endif


#define FLAG_MASK_NOT_COMPUTED ((ulong) -1)

typedef struct EPR_BmTerm               EPR_SBmTerm;
typedef struct EPR_BmEvalContext        EPR_SBmEvalContext;
typedef struct EPR_BmFlagDataset        EPR_SBmFlagDataset;
typedef enum   EPR_BmOpCode             EPR_EBmOpCode;


/* private implementations */


enum EPR_BmOpCode {
    BMT_UNKNOWN = 0,
    BMT_REF,
    BMT_AND,
    BMT_OR,
    BMT_NOT
};


enum EPR_Tok {
    BME_UNKNOWN = 0,
    BME_EOS,
    BME_SPECIAL,
    BME_NAME
};

struct EPR_BmTerm {
    EPR_EBmOpCode op_code;
    union {
        struct /*BMT_REF*/ {
            char* band_name;
            char* flag_name;
            ulong flag_mask;
            EPR_SRaster* flag_raster;
        } ref;
        struct /*BMT_NOT*/ {
            EPR_SBmTerm* arg;
        } unary;
        struct /*BMT_AND and BMT_OR*/ {
            EPR_SBmTerm* arg1;
            EPR_SBmTerm* arg2;
        } binary;
    } op;
};


struct EPR_BmEvalContext
{
    EPR_SProductId* product_id;

    int offset_x;

    int offset_y;

    EPR_SRaster* bitmask_raster;

    EPR_SPtrArray* flag_band_ids;

    EPR_SPtrArray* flag_rasters;
};


struct EPR_BmFlagDataset {
    /*The name of bitmask dataset*/
    char* name;
    /*The value of bitmask dataset (the number of the relevant bit in bitmask)*/
    uint bit_index;
    /*The description of bitmask dataset*/
    char* description;
};


EPR_SBmEvalContext* epr_create_bm_eval_context(EPR_SProductId* product_id,
                                               int offset_x,
                                               int offset_y,
                                               EPR_SRaster* raster);


void epr_free_bm_eval_context(EPR_SBmEvalContext* context);


int epr_read_bitmask_data(const EPR_SProductId* product_id,
                          const char* bm_expr,
                          int xo,
                          int yo,
                          int raster_width,
                          int raster_height,
                          int s_x,
                          int s_y,
                          void* raster_buffer);



boolean epr_eval_bm_term(EPR_SBmEvalContext* context,
                         EPR_SBmTerm* term,
                         int x,
                         int y);



EPR_SBmTerm* epr_parse_bm_expr_str(const char* bm_expr);


struct EPR_ParseInfo {
    const char* bm_expr;
    int bm_expr_pos;
    boolean pushed_back;
    int token_type;
    char* token;
    char* err_message;
};


typedef struct EPR_ParseInfo EPR_SParseInfo;

EPR_SBmTerm* epr_parse_bm_expr(EPR_SParseInfo* parse_info, boolean term_required);
EPR_SBmTerm* epr_parse_bm_OR_expr(EPR_SParseInfo* parse_info, boolean term_required);
EPR_SBmTerm* epr_parse_bm_AND_expr(EPR_SParseInfo* parse_info, boolean term_required);
EPR_SBmTerm* epr_parse_bm_unary_expr(EPR_SParseInfo* parse_info, boolean term_required);
EPR_SBmTerm* epr_parse_bm_primary_expr(EPR_SParseInfo* parse_info, boolean term_required);
boolean epr_is_bm_OR_keyword(EPR_SParseInfo* parse_info);
boolean epr_is_bm_AND_keyword(EPR_SParseInfo* parse_info);
boolean epr_is_bm_NOT_keyword(EPR_SParseInfo* parse_info);
boolean epr_is_bm_AND_operator(EPR_SParseInfo* parse_info);
boolean epr_is_bm_OR_operator(EPR_SParseInfo* parse_info);
boolean epr_is_bm_NOT_operator(EPR_SParseInfo* parse_info);
boolean epr_is_bm_name_token(EPR_SParseInfo* parse_info);

boolean epr_is_bm_EOS_token(EPR_SParseInfo* parse_info);

boolean epr_is_bm_expr_error(EPR_SParseInfo* parse_info);

int epr_get_token_char(EPR_SParseInfo* parse_info);

char* epr_consume_token(EPR_SParseInfo* parse_info);

void epr_next_bm_expr_token(EPR_SParseInfo* parse_info);

void epr_push_back_bm_expr_token(EPR_SParseInfo* parse_info);

void epr_set_bm_expr_error(EPR_SParseInfo* parse_info, const char* message);

int epr_tokenize_bm_expr(const char* bm_expr, int* bm_expr_pos, char** token);

EPR_SBmTerm* epr_create_bm_term(EPR_EBmOpCode op_code);

EPR_SBmTerm* epr_create_bm_REF_term(char* ds_name, char* flag_name);

EPR_SBmTerm* epr_create_bm_NOT_term(EPR_SBmTerm* arg);

EPR_SBmTerm* epr_create_bm_OR_term(EPR_SBmTerm* arg1, EPR_SBmTerm* arg2);

EPR_SBmTerm* epr_create_bm_AND_term(EPR_SBmTerm* arg1, EPR_SBmTerm* arg2);

void epr_free_bm_term(EPR_SBmTerm* term);


char* epr_create_bm_expr(EPR_SBmTerm* term);
void epr_print_bm_term(EPR_SBmTerm* term);

void epr_write_bm_term(EPR_SBmTerm* term, FILE* ostream);

EPR_SPtrArray* epr_create_flag_coding(EPR_SProductId* product_id, const char* str);
EPR_SFlagDef* epr_create_flag_def();
void epr_free_flag_def(EPR_SFlagDef* flag_def);

void epr_free_flag_coding(EPR_SPtrArray* flag_coding);

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif
/* #ifndef EPR_BITMASK_H_INCL */