epr_bitmask.c

Insar图像处理软件

        return NULL;
    }

    while (!epr_is_bm_expr_error(parse_info)) {
        epr_next_bm_expr_token(parse_info);
        if (epr_is_bm_AND_keyword(parse_info) || epr_is_bm_AND_operator(parse_info)) {
            EPR_SBmTerm* term2 = epr_parse_bm_AND_expr(parse_info, TRUE);
            term1 = epr_create_bm_AND_term(term1, term2);
        } else {
            epr_push_back_bm_expr_token(parse_info);
            break;
        }
    }

    return term1;
}


EPR_SBmTerm* epr_parse_bm_unary_expr(EPR_SParseInfo* parse_info, boolean term_required)  {

    EPR_SBmTerm* term = NULL;

    epr_next_bm_expr_token(parse_info);
    if (epr_is_bm_NOT_keyword(parse_info) || epr_is_bm_NOT_operator(parse_info)) {
        term = epr_parse_bm_unary_expr(parse_info, TRUE);
        term = epr_create_bm_NOT_term(term);
    } else {
        epr_push_back_bm_expr_token(parse_info);
        term = epr_parse_bm_primary_expr(parse_info, term_required);
    }

    return term;
}

EPR_SBmTerm* epr_parse_bm_primary_expr(EPR_SParseInfo* parse_info, boolean term_required) {

    EPR_SBmTerm* term = NULL;

    epr_next_bm_expr_token(parse_info);
    if (epr_get_token_char(parse_info) == '(') {
        term = epr_parse_bm_expr(parse_info, TRUE);
        epr_next_bm_expr_token(parse_info);
        if (epr_get_token_char(parse_info) != ')') {
            epr_set_bm_expr_error(parse_info, "')' expected");
        }
    } else if (epr_is_bm_name_token(parse_info)) {
        char* ds_name = epr_consume_token(parse_info);
        epr_next_bm_expr_token(parse_info);
        if (epr_get_token_char(parse_info) == '.') {
            epr_next_bm_expr_token(parse_info);
            if (epr_is_bm_name_token(parse_info)) {
                char* flag_name = epr_consume_token(parse_info);
                term = epr_create_bm_REF_term(ds_name, flag_name);
            } else {
                epr_set_bm_expr_error(parse_info, "flag name expected");
            }
        } else {
            epr_set_bm_expr_error(parse_info, "'.' expected");
        }
    } else if (epr_is_bm_EOS_token(parse_info)) {
        if (term_required) {
            epr_set_bm_expr_error(parse_info, "operator or flag name expected");
        }
    } else {
        epr_set_bm_expr_error(parse_info, "operator or flag name expected");
    }

    return term;
}

boolean epr_is_bm_OR_keyword(EPR_SParseInfo* parse_info) {
    return epr_is_bm_name_token(parse_info) && stricmp("or", parse_info->token) == 0;
}

boolean epr_is_bm_AND_keyword(EPR_SParseInfo* parse_info) {
    return epr_is_bm_name_token(parse_info) && stricmp("and", parse_info->token) == 0;
}

boolean epr_is_bm_NOT_keyword(EPR_SParseInfo* parse_info) {
    return epr_is_bm_name_token(parse_info) && stricmp("not", parse_info->token) == 0;
}

boolean epr_is_bm_AND_operator(EPR_SParseInfo* parse_info) {
    return epr_get_token_char(parse_info) == '&';
}

boolean epr_is_bm_OR_operator(EPR_SParseInfo* parse_info) {
    return epr_get_token_char(parse_info) == '|';
}

boolean epr_is_bm_NOT_operator(EPR_SParseInfo* parse_info) {
    return epr_get_token_char(parse_info) == '!';
}

boolean epr_is_bm_name_token(EPR_SParseInfo* parse_info) {
    return parse_info->token_type == BME_NAME && parse_info->token != NULL;
}

boolean epr_is_bm_EOS_token(EPR_SParseInfo* parse_info) {
    return parse_info->token_type == BME_EOS;
}

boolean epr_is_bm_expr_error(EPR_SParseInfo* parse_info) {
    return parse_info->err_message != NULL;
}

int epr_get_token_char(EPR_SParseInfo* parse_info) {
    if (parse_info->token_type == BME_SPECIAL && parse_info->token != NULL) {
        return parse_info->token[0];
    }
    return '\0';
}

char* epr_consume_token(EPR_SParseInfo* parse_info) {
    char* token = parse_info->token;
    /* Prevent from being released by epr_free_string() */
    parse_info->token = NULL;
    parse_info->token_type = BME_UNKNOWN;
    parse_info->pushed_back = FALSE;
    return token;

}

void epr_next_bm_expr_token(EPR_SParseInfo* parse_info) {
    if (parse_info->pushed_back) {
        parse_info->pushed_back = FALSE;
        return;
    }
    epr_free_string(parse_info->token);
    parse_info->token_type = epr_tokenize_bm_expr(parse_info->bm_expr, 
                                                  &(parse_info->bm_expr_pos), 
                                                  &(parse_info->token));
}

void epr_push_back_bm_expr_token(EPR_SParseInfo* parse_info) {
    parse_info->pushed_back = TRUE;
}

void epr_set_bm_expr_error(EPR_SParseInfo* parse_info, const char* message) {
    static char msg_buf[2048];
    
    epr_push_back_bm_expr_token(parse_info);
    
    if (message != NULL) {
        if (!epr_is_bm_EOS_token(parse_info)) {
            sprintf(msg_buf, "%s, but found token '%s'", message, parse_info->token);
        } else {
            sprintf(msg_buf, "%s, but found 'end-of-string'", message);
        }
    } else {
        if (!epr_is_bm_EOS_token(parse_info)) {
            sprintf(msg_buf, "unexpected token '%s' found", parse_info->token);
        } else {
            sprintf(msg_buf, "unexpected 'end-of-string' found");
        }
    }

    parse_info->err_message = epr_clone_string(msg_buf);
}


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

    while (isspace(bm_expr[pos])) {
        pos++;
    }

    if (bm_expr[pos] == '\0') {
        *bm_expr_pos = pos;
        *token = NULL;
        return BME_EOS;
    }
    
    if (isalpha(bm_expr[pos]) || bm_expr[pos] == '_') {
        int pos0 = pos;
        size_t len;
        char* tok;
        
        pos++;
        while (isalnum(bm_expr[pos]) || bm_expr[pos] == '_') {
            pos++;
        }

        len = pos - pos0;
        tok = epr_create_string(len + 1);
        strncpy(tok, bm_expr + pos0, len);
        tok[len] = '\0';

        *token = tok;
        *bm_expr_pos = pos;
        return BME_NAME;
    }

    if (bm_expr[pos] == '(' || 
        bm_expr[pos] == ')' || 
        bm_expr[pos] == '.' || 
        bm_expr[pos] == '&' || 
        bm_expr[pos] == '|' || 
        bm_expr[pos] == '!') {
        char* tok;

        tok = epr_create_string(2);
        tok[0] = bm_expr[pos];
        tok[1] = '\0';

        pos++;

        *token = tok;
        *bm_expr_pos = pos;
        return BME_SPECIAL;
    }

    *token = NULL;
    *bm_expr_pos = pos;
    return BME_UNKNOWN;
}


EPR_SBmTerm* epr_create_bm_term(EPR_EBmOpCode op_code) 
{
    EPR_SBmTerm* term = (EPR_SBmTerm*) malloc(sizeof (EPR_SBmTerm));
    term->op_code = op_code;
    return term;
}

EPR_SBmTerm* epr_create_bm_REF_term(char* band_name, char* flag_name)
{
    EPR_SBmTerm* term = epr_create_bm_term(BMT_REF);
    term->op.ref.band_name = band_name;
    term->op.ref.flag_name = flag_name;
    term->op.ref.flag_mask = FLAG_MASK_NOT_COMPUTED; /* not computed */
    term->op.ref.flag_raster = NULL;
    return term;
}

EPR_SBmTerm* epr_create_bm_NOT_term(EPR_SBmTerm* arg)
{
    EPR_SBmTerm* term = epr_create_bm_term(BMT_NOT);
    term->op.unary.arg = arg;
    return term;
}

EPR_SBmTerm* epr_create_bm_OR_term(EPR_SBmTerm* arg1, EPR_SBmTerm* arg2)
{
    EPR_SBmTerm* term = epr_create_bm_term(BMT_OR);
    term->op.binary.arg1 = arg1;
    term->op.binary.arg2 = arg2;
    return term;
}

EPR_SBmTerm* epr_create_bm_AND_term(EPR_SBmTerm* arg1, EPR_SBmTerm* arg2)
{
    EPR_SBmTerm* term = epr_create_bm_term(BMT_AND);
    term->op.binary.arg1 = arg1;
    term->op.binary.arg2 = arg2;
    return term;
}



ulong epr_get_pixel_as_ulong(const EPR_SRaster* raster, int x, int y) 
{
    epr_clear_err();

    switch (raster->data_type) {
    case (e_tid_uchar) :
          return (ulong) ((uchar*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_char)  :
          return (ulong) ((char*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_ushort):
          return (ulong) ((ushort*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_short) :
          return (ulong) ((short*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_ulong):
          return (ulong) ((ulong*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_long) :
          return (ulong) ((long*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_float) :
          return (ulong) ((float*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_double) :
          return (ulong) ((double*)raster->buffer)[y * raster->raster_width + x];
    default:
          return 0;
    }
}

long epr_get_pixel_as_long(const EPR_SRaster* raster, int x, int y) 
{
    epr_clear_err();

    switch (raster->data_type) {
    case (e_tid_uchar) :
          return (long) ((uchar*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_char)  :
          return (long) ((char*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_ushort):
          return (long) ((ushort*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_short) :
          return (long) ((short*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_ulong):
          return (long) ((ulong*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_long) :
          return (long) ((long*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_float) :
          return (long) ((float*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_double) :
          return (long) ((double*)raster->buffer)[y * raster->raster_width + x];
    default:
          return 0;
    }
}


float epr_get_pixel_as_float(const EPR_SRaster* raster, int x, int y) 
{
    epr_clear_err();

    switch (raster->data_type) {
    case (e_tid_uchar) :
          return (float) ((uchar*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_char)  :
          return (float) ((char*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_ushort):
          return (float) ((ushort*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_short) :
          return (float) ((short*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_ulong):
          return (float) ((ulong*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_long) :
          return (float) ((long*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_float) :
          return (float) ((float*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_double) :
          return (float) ((double*)raster->buffer)[y * raster->raster_width + x];
    default:
          return 0;
    }
}

double epr_get_pixel_as_double(const EPR_SRaster* raster, int x, int y) 
{
    epr_clear_err();

    switch (raster->data_type) {
    case (e_tid_uchar) :
          return (double) ((uchar*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_char)  :
          return (double) ((char*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_ushort):
          return (double) ((ushort*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_short) :
          return (double) ((short*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_ulong):
          return (double) ((ulong*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_long) :
          return (double) ((long*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_float) :
          return (double) ((float*)raster->buffer)[y * raster->raster_width + x];
    case (e_tid_double) :
          return (double) ((double*)raster->buffer)[y * raster->raster_width + x];
    default:
          return 0;
    }
}

/**
 * Releases a new bitmask term instance.
 */
void epr_free_bm_term(EPR_SBmTerm* term) {
    if (term == NULL)
        return;

    switch (term->op_code) {
    case BMT_REF:
        epr_free_string(term->op.ref.band_name);
        epr_free_string(term->op.ref.flag_name);
        term->op.ref.band_name = NULL;
        term->op.ref.flag_name = NULL;
        break;
    case BMT_AND: /* OR */ case BMT_OR:
        epr_free_bm_term(term->op.binary.arg1);
        epr_free_bm_term(term->op.binary.arg2);
        term->op.binary.arg1 = NULL;
        term->op.binary.arg2 = NULL;
        break;
    case BMT_NOT:
        epr_free_bm_term(term->op.unary.arg);
        term->op.unary.arg = NULL;
        break;
    default:
        assert(0);
    }

    free(term);
}


/**
 * Creates a new bitmask expression from the given bitmask term.
 * <p>The expression returned is a valid in the sense that the epr_parse_bm_expr() 
 * applied to the returned string would return an equivalent term.
 *
 * @param term the term to be converted
 */
char* epr_create_bm_expr(EPR_SBmTerm* term) 
{
    if (term == NULL)
        return NULL;

    switch (term->op_code) {
    case BMT_REF: {
            char* s0 = epr_create_string(strlen(term->op.ref.band_name) + strlen(term->op.ref.flag_name) + 16);
            sprintf(s0, "%s.%s", term->op.ref.band_name, term->op.ref.flag_name);
            return s0;
        }
    case BMT_AND: {
            char* s1 = epr_create_bm_expr(term->op.binary.arg1);
            char* s2 = epr_create_bm_expr(term->op.binary.arg2);
            char* s0 = epr_create_string(strlen(s1) + strlen(s2) + 16);
            sprintf(s0, "(%s) AND (%s)", s1, s2);
            epr_free_string(s1);
            epr_free_string(s2);
            return s0;
        }                  
    case BMT_OR: {
            char* s1 = epr_create_bm_expr(term->op.binary.arg1);
            char* s2 = epr_create_bm_expr(term->op.binary.arg2);
            char* s0 = epr_create_string(strlen(s1) + strlen(s2) + 16);
            sprintf(s0, "(%s) OR (%s)", s1, s2);
            epr_free_string(s1);
            epr_free_string(s2);
            return s0;
        }
    case BMT_NOT: {
            char* s1 = epr_create_bm_expr(term->op.unary.arg);
            char* s0 = epr_create_string(strlen(s1) + 16);
            sprintf(s0, "NOT (%s)", s1);
            epr_free_string(s1);
            return s0;
        }
    default:
        assert(FALSE);
        return NULL;
    }
}

/**
 * Prints the given term as an expression to the console.
 */
void epr_print_bm_term(EPR_SBmTerm* term) 
{
    epr_write_bm_term(term, stdout);
}

/**
 * Writes the given term as an expression to the given output stream.
 */
void epr_write_bm_term(EPR_SBmTerm* term, FILE* ostream) 
{
    char* bm_expr = epr_create_bm_expr(term);
    fprintf(ostream, "%s", bm_expr);
    epr_free_string(bm_expr);
}