diglib/poly.c

Go to the documentation of this file.

/*
 ****************************************************************************
 *
 * MODULE:       Vector library 
 *              
 * AUTHOR(S):    Original author CERL, probably Dave Gerdes.
 *               Update to GRASS 5.7 Radim Blazek.
 *
 * PURPOSE:      Lower level functions for reading/writing/manipulating vectors.
 *
 * COPYRIGHT:    (C) 2001 by the GRASS Development Team
 *
 *               This program is free software under the GNU General Public
 *              License (>=v2). Read the file COPYING that comes with GRASS
 *              for details.
 *
 *****************************************************************************/
#include <math.h>
#include <grass/Vect.h>


#ifndef HUGE_VAL
#define HUGE_VAL 9999999999999.0
#endif

/*
 **  fills BPoints (must be inited previously) by points from imput
 **  array LPoints. Each imput points must have at least 2 points.
 **   
 **  returns number of points or -1 on error
 */


int dig_get_poly_points(int n_lines, struct line_pnts **LPoints, int *direction,        /* line direction: > 0 or < 0 */
                        struct line_pnts *BPoints)
{
    register int i, j, point, start, end, inc;
    struct line_pnts *Points;
    int n_points;

    BPoints->n_points = 0;

    if (n_lines < 1) {
        return 0;
    }

    /* Calc required space */
    n_points = 0;
    for (i = 0; i < n_lines; i++) {
        Points = LPoints[i];
        n_points += Points->n_points - 1;       /* each line from first to last - 1 */
    }
    n_points++;                 /* last point */

    if (0 > dig_alloc_points(BPoints, n_points))
        return (-1);

    point = 0;
    j = 0;
    for (i = 0; i < n_lines; i++) {
        Points = LPoints[i];
        if (direction[i] > 0) {
            start = 0;
            end = Points->n_points - 1;
            inc = 1;
        }
        else {
            start = Points->n_points - 1;
            end = 0;
            inc = -1;
        }

        for (j = start; j != end; j += inc) {
            BPoints->x[point] = Points->x[j];
            BPoints->y[point] = Points->y[j];
        }
        point++;
    }
    /* last point */
    BPoints->x[point] = Points->x[j];
    BPoints->y[point] = Points->y[j];

    BPoints->n_points = n_points;

    return (BPoints->n_points);
}

/*
 **  Calculate area size for polygon. 
 **
 **  Total area is positive for clockwise and negative for counter clockwise ?
 */
int dig_find_area_poly(struct line_pnts *Points, double *totalarea)
{
    int i;
    double *x, *y;
    double tot_area, sum_area;


    *totalarea = 0.;

    tot_area = 0.0;

    x = Points->x;
    y = Points->y;

    sum_area = 0.0;
    for (i = 1; i < Points->n_points; i++) {
        sum_area += (x[i] - x[i - 1]) * (y[i] + y[i - 1]);
    }
    tot_area += sum_area;

    *totalarea = 0.5 * tot_area;

    return (0);
}