filescan.c

就是将BMP文件转换为DXF格式的文件

            break;
    }
    return (TRUE);

}

/* OK */
static int      remove_polyline(scan_data * p_scd, polyline * p_polyline)
{

    ll_set_list_currpntr(p_scd->p_polylines_list, TG_HEAD);
    do
    {
        polyline       *p_curr_polyline;

        if ((p_curr_polyline = (polyline *) ll_get_list_data(p_scd->p_polylines_list)) == NULL)
            break;
        if (p_curr_polyline == p_polyline)
        {
            ll_empty_free_list(p_curr_polyline->p_poly_list);
            free(ll_delete_list_item(p_scd->p_polylines_list, TG_CURRENT, TG_HEAD));
            return (TRUE);
        }
    } while (ll_set_list_currpntr(p_scd->p_polylines_list, TG_AFTER) == TG_AFTER);
    return (FALSE);

}

/* OK */
static int      transfer_polyline_points(polyline * p_dest_polyline,
                        polyline * p_src_polyline, int insert_location,
                        int direction)
{

    int             points_count = 0;
    img_point       pnt;

    switch (direction)
    {
        case (+1):
            {
                ll_set_list_currpntr(p_src_polyline->p_poly_list, TG_HEAD);
                do
                {
                    if (!ll_get_list_user_data(p_src_polyline->p_poly_list, &pnt))
                        break;
                    if (points_count++ > 0)
                        if (!add_point_in_poly(p_dest_polyline, &pnt, insert_location))
                            return (FALSE);
                } while (ll_set_list_currpntr(p_src_polyline->p_poly_list, TG_AFTER) == TG_AFTER);
            }
            break;

        case (-1):
            {
                ll_set_list_currpntr(p_src_polyline->p_poly_list, TG_TAIL);
                do
                {
                    if (!ll_get_list_user_data(p_src_polyline->p_poly_list, &pnt))
                        break;
                    if (points_count++ > 0)
                        if (!add_point_in_poly(p_dest_polyline, &pnt, insert_location))
                            return (FALSE);
                } while (ll_set_list_currpntr(p_src_polyline->p_poly_list, TG_BEFORE) == TG_BEFORE);
            }
            break;

        default:
            return (FALSE);
    }
    return (TRUE);

}

/* OK */
static int      resync_polyline_lists(scan_data * p_scd)
{

    polyline       *p_polyline;

    ll_set_list_currpntr(p_scd->p_polylines_list, TG_HEAD);
    do
    {
        int             deleted;

        do
        {
            deleted = FALSE;
            if ((p_polyline = (polyline *) ll_get_list_data(p_scd->p_polylines_list)) == NULL)
                break;
            if (same_point(&p_polyline->pnt0, &p_polyline->pnt1) &&
                    (p_scd->current_line > (max(p_polyline->pnt0.y, p_polyline->pnt1.y) + 1)))
            {
                if (opt_flush_polyline(p_scd->fp_poly, p_polyline->p_poly_list,
                                p_scd->pnt_error_tollerance, p_scd->min_polyline_lenght))
                    ++p_scd->number_of_polylines;
                remove_poly_gate(p_scd, p_polyline->pnt0.x, p_polyline);
                remove_poly_gate(p_scd, p_polyline->pnt1.x, p_polyline);
                ll_empty_free_list(p_polyline->p_poly_list);
                free(ll_delete_list_item(p_scd->p_polylines_list, TG_CURRENT, TG_HEAD));
                deleted = TRUE;
            }
        } while (deleted);
    } while (ll_set_list_currpntr(p_scd->p_polylines_list, TG_AFTER) == TG_AFTER);
    return (TRUE);

}

/* OK */
static int      flush_all_polylines(scan_data * p_scd)
{

    polyline       *p_polyline;

    ll_set_list_currpntr(p_scd->p_polylines_list, TG_HEAD);
    while ((p_polyline = (polyline *)
                    ll_delete_list_item(p_scd->p_polylines_list, TG_CURRENT, TG_AFTER)) != NULL)
    {
        if (opt_flush_polyline(p_scd->fp_poly, p_polyline->p_poly_list,
                        p_scd->pnt_error_tollerance, p_scd->min_polyline_lenght))
            ++p_scd->number_of_polylines;
        remove_poly_gate(p_scd, p_polyline->pnt0.x, p_polyline);
        remove_poly_gate(p_scd, p_polyline->pnt1.x, p_polyline);
        ll_empty_free_list(p_polyline->p_poly_list);
        free(p_polyline);
    }
    ll_purge_list(p_scd->p_polylines_list);
    p_scd->p_polylines_list = NULL;
    return (TRUE);

}

/* OK */
static int      next_line(scan_data * p_scd)
{

    BYTE           *p_img_line,
                   *tmp_byte_ptr;

    ++p_scd->current_line;
    tmp_byte_ptr = p_scd->p_line;
    p_scd->p_line = p_scd->p_next_line;
    p_scd->p_next_line = p_scd->p_nnext_line;
    p_scd->p_nnext_line = tmp_byte_ptr;
    if ((p_scd->current_line + 1) < p_scd->y_size)
    {
        p_img_line = get_raw_img_line(p_scd->p_raw_ptr, p_scd->img_line_size,
                p_scd->current_line + 1);
        tx_bits_mem(p_scd->p_next_line, p_scd->x_size, p_img_line, p_scd->back_ground);
    }
    else
        memset(p_scd->p_nnext_line, 0, p_scd->line_size);
    return (TRUE);

}

/* OK */
static int      scan_current_line(scan_data * p_scd)
{

    BYTE            h_open = 0;
    int             xx,
                    curr_bit,
                    right_bit,
                    top_bit,
                    top_right_bit,
                    node = FALSE,
                    prev_node = FALSE;
    img_point       pnt0,
                    pnt1;

    for (xx = 0; xx <= p_scd->x_size; xx++, prev_node = node)
    {
        curr_bit = (int) p_scd->p_line[xx];
        right_bit = (int) p_scd->p_line[xx + 1];
        top_bit = (int) p_scd->p_next_line[xx];
        top_right_bit = (int) p_scd->p_next_line[xx + 1];
        node = ((curr_bit ^ top_bit) && (curr_bit ^ right_bit) &&
                (right_bit ^ top_right_bit)) ? TRUE : FALSE;
        if (curr_bit ^ right_bit)
        {
            h_open = ~h_open;
            if (h_open)
            {
                pnt0.x = xx + 1;
                pnt0.y = p_scd->current_line;
                pnt1.x = xx + 1;
                pnt1.y = p_scd->current_line + 1;
            }
            else
            {
                pnt0.x = xx + 1;
                pnt0.y = p_scd->current_line + 1;
                pnt1.x = xx + 1;
                pnt1.y = p_scd->current_line;
            }
            if (!add_line(p_scd, &pnt0, &pnt1))
                return (FALSE);
        }
        if (curr_bit ^ top_bit)
        {
            p_scd->v_open[xx] = ~p_scd->v_open[xx];
            if (p_scd->v_open[xx])
            {
                pnt0.x = xx + 1;
                pnt0.y = p_scd->current_line + 1;
                pnt1.x = xx;
                pnt1.y = p_scd->current_line + 1;
                if (!prev_node)
                    if (!add_line(p_scd, &pnt0, &pnt1))
                        return (FALSE);
            }
            else
            {
                if (node)
                {
                    pnt0.x = xx + 2;
                    pnt0.y = p_scd->current_line + 1;
                    pnt1.x = xx + 1;
                    pnt1.y = p_scd->current_line + 1;
                    if (!add_line(p_scd, &pnt0, &pnt1))
                        return (FALSE);
                }
                pnt0.x = xx;
                pnt0.y = p_scd->current_line + 1;
                pnt1.x = xx + 1;
                pnt1.y = p_scd->current_line + 1;
                if (!add_line(p_scd, &pnt0, &pnt1))
                    return (FALSE);
            }
        }
    }
    curr_bit = p_scd->p_line[xx];
    top_bit = p_scd->p_next_line[xx];
    if (curr_bit ^ top_bit)
    {
        p_scd->v_open[xx] = ~p_scd->v_open[xx];
        if (p_scd->v_open[xx])
        {
            pnt0.x = xx + 1;
            pnt0.y = p_scd->current_line + 1;
            pnt1.x = xx;
            pnt1.y = p_scd->current_line + 1;
            if (!prev_node)
                if (!add_line(p_scd, &pnt0, &pnt1))
                    return (FALSE);
        }
        else
        {
            pnt0.x = xx;
            pnt0.y = p_scd->current_line + 1;
            pnt1.x = xx + 1;
            pnt1.y = p_scd->current_line + 1;
            if (!add_line(p_scd, &pnt0, &pnt1))
                return (FALSE);
        }
    }
    return (TRUE);

}

/* OK */
int LIB_PROC    dblline_convert_file(char *img_file_name, char *poly_file_name,
                        double pnt_error_tollerance,
                        double poly_lenght_factor)
{

    int             img_line;
    scan_data      *p_scd;

    if ((p_scd = alloc_scan_data(img_file_name, poly_file_name,
                            pnt_error_tollerance, poly_lenght_factor)) == NULL)
        return (FALSE);
    log_printf("- processing image file %s ( %lu bytes )\n", img_file_name,
            (unsigned long) p_scd->y_size * (unsigned long) get_line_size(p_scd->x_size));
    for (img_line = 0; img_line <= p_scd->y_size; img_line++)
    {
        if (!scan_current_line(p_scd))
        {
            free_scan_data(p_scd);
            return (FALSE);
        }
        if (((img_line + 1) % RESYNC_FREQUENCY) == 0)
        {
            if (!resync_polyline_lists(p_scd))
            {
                free_scan_data(p_scd);
                scr_printf("\n");
                return (FALSE);
            }
            scr_printf("\r- %-9d of %d lines processed", img_line, p_scd->y_size);
        }
        next_line(p_scd);
    }
    scr_printf("\r- %-9d of %d lines processed\n", p_scd->y_size, p_scd->y_size);
    if (!resync_polyline_lists(p_scd))
    {
        free_scan_data(p_scd);
        return (FALSE);
    }
    if (!flush_all_polylines(p_scd))
    {
        free_scan_data(p_scd);
        return (FALSE);
    }
    log_printf("- generated %d polyline(s)\n", p_scd->number_of_polylines);
    free_scan_data(p_scd);
    return (TRUE);

}