histogram.c

Go to the documentation of this file.

#include <grass/gis.h>
#include <grass/glocale.h>
#include <stdlib.h>


#define LIST struct Histogram_list

static FILE *fopen_histogram_new(const char *);
static int cmp(const void *, const void *);
static int cmp_count(const void *, const void *);


int G_init_histogram(struct Histogram *histogram)
{
    histogram->num = 0;
    histogram->list = NULL;

    return 0;
}


int G_read_histogram(const char *name, const char *mapset,
                     struct Histogram *histogram)
{
    FILE *fd = NULL;
    long cat;
    long count;
    char buf[200];

    G_init_histogram(histogram);

    if (G_find_file2_misc("cell_misc", "histogram", name, mapset) == NULL) {
        G_warning(_("Histogram for [%s in %s] missing (run r.support)"), name,
                  mapset);

        return 0;
    }

    fd = G_fopen_old_misc("cell_misc", "histogram", name, mapset);
    if (!fd) {
        G_warning(_("Can't read histogram for [%s in %s]"), name, mapset);

        return -1;
    }

    while (fgets(buf, sizeof buf, fd)) {
        if (sscanf(buf, "%ld:%ld", &cat, &count) != 2) {
            G_free_histogram(histogram);
            fclose(fd);
            G_warning(_("Invalid histogram file for [%s in %s]"), name,
                      mapset);

            return -1;
        }
        G_extend_histogram((CELL) cat, count, histogram);
    }
    fclose(fd);

    if (histogram->num == 0) {
        G_warning(_("Invalid histogram file for [%s in %s]"), name, mapset);

        return -1;
    }

    G_sort_histogram(histogram);

    return 1;
}


int G_write_histogram(const char *name, const struct Histogram *histogram)
{
    FILE *fd;
    int n;
    LIST *list;

    fd = fopen_histogram_new(name);
    if (fd == NULL)
        return -1;

    list = histogram->list;
    for (n = 0; n < histogram->num; n++) {
        if (list[n].count)
            fprintf(fd, "%ld:%ld\n", (long)list[n].cat, list[n].count);
    }
    fclose(fd);

    return 1;
}


int G_write_histogram_cs(const char *name, struct Cell_stats *statf)
{
    FILE *fd;
    CELL cat;
    long count;

    fd = fopen_histogram_new(name);
    if (fd == NULL)
        return -1;

    G_rewind_cell_stats(statf);
    while (G_next_cell_stat(&cat, &count, statf)) {
        if (count > 0)
            fprintf(fd, "%ld:%ld\n", (long)cat, count);
    }
    fclose(fd);

    return 1;
}


int G_make_histogram_cs(struct Cell_stats *statf, struct Histogram *histogram)
{
    CELL cat;
    long count;

    G_init_histogram(histogram);
    G_rewind_cell_stats(statf);
    while (G_next_cell_stat(&cat, &count, statf))
        G_add_histogram(cat, count, histogram);

    G_sort_histogram(histogram);

    return 0;
}


int G_get_histogram_num(const struct Histogram *histogram)
{
    return histogram->num;
}


CELL G_get_histogram_cat(int n, const struct Histogram * histogram)
{
    if (n < 0 || n >= histogram->num)
        return 0;

    return histogram->list[n].cat;
}


long G_get_histogram_count(int n, const struct Histogram *histogram)
{
    if (n < 0 || n >= histogram->num)
        return 0;

    return histogram->list[n].count;
}


int G_free_histogram(struct Histogram *histogram)
{
    if (histogram->num > 0)
        G_free(histogram->list);
    histogram->num = 0;
    histogram->list = NULL;

    return 1;
}

int G_sort_histogram(struct Histogram *histogram)
{
    int a, b, n;
    LIST *list;

    /* if histogram only has 1 entry, nothing to do */
    if ((n = histogram->num) <= 1)
        return 1;

    list = histogram->list;

    /* quick check to see if sorting needed */
    for (a = 1; a < n; a++)
        if (list[a - 1].cat >= list[a].cat)
            break;
    if (a >= n)
        return 1;

    /* sort */
    qsort(list, n, sizeof(LIST), &cmp);

    /* sum duplicate entries */
    for (a = 0, b = 1; b < n; b++) {
        if (list[a].cat != list[b].cat) {
            a++;
            list[a].count = list[b].count;
            list[a].cat = list[b].cat;
        }
        else {
            list[a].count += list[b].count;
        }
    }
    histogram->num = a + 1;

    return 0;
}


static int cmp(const void *aa, const void *bb)
{
    const LIST *a = aa, *b = bb;

    if (a->cat < b->cat)
        return -1;

    if (a->cat > b->cat)
        return 1;

    return 0;
}

int G_sort_histogram_by_count(struct Histogram *histogram)
{
    int n;
    LIST *list;

    /* if histogram only has 1 entry, nothing to do */
    if ((n = histogram->num) <= 1)
        return 1;

    list = histogram->list;

    /* sort */
    qsort(list, n, sizeof(LIST), &cmp_count);

    return 0;
}


static int cmp_count(const void *aa, const void *bb)
{
    const LIST *a = aa, *b = bb;

    if (a->count < b->count)
        return -1;

    if (a->count > b->count)
        return 1;

    if (a->cat < b->cat)
        return -1;

    if (a->cat > b->cat)
        return 1;

    return 0;
}

static FILE *fopen_histogram_new(const char *name)
{
    FILE *fd;

    fd = G_fopen_new_misc("cell_misc", "histogram", name);
    if (fd == NULL)
        G_warning(_("can't create histogram for [%s in %s]"), name,
                  G_mapset());

    return fd;
}


int G_remove_histogram(const char *name)
{
    G_remove_misc("cell_misc", "histogram", name);

    return 0;
}


int G_add_histogram(CELL cat, long count, struct Histogram *histogram)
{
    int i;

    for (i = 0; i < histogram->num; i++) {
        if (histogram->list[i].cat == cat) {
            histogram->list[i].count += count;
            return 1;
        }
    }
    G_extend_histogram(cat, count, histogram);

    return 0;
}


int G_set_histogram(CELL cat, long count, struct Histogram *histogram)
{
    int i;

    for (i = 0; i < histogram->num; i++) {
        if (histogram->list[i].cat == cat) {
            histogram->list[i].count = count;
            return 1;
        }
    }
    G_extend_histogram(cat, count, histogram);

    return 0;
}


int G_extend_histogram(CELL cat, long count, struct Histogram *histogram)
{
    histogram->num++;
    histogram->list =
        (LIST *) G_realloc((char *)histogram->list,
                           histogram->num * sizeof(LIST));
    histogram->list[histogram->num - 1].cat = cat;
    histogram->list[histogram->num - 1].count = count;

    return 0;
}


int G_zero_histogram(struct Histogram *histogram)
{
    int i;

    for (i = 0; i < histogram->num; i++)
        histogram->list[i].count = 0;

    return 0;
}