247 lines
7.9 KiB
C
247 lines
7.9 KiB
C
/***********************************************************
|
||
|
||
Copyright 1987, 1998 The Open Group
|
||
|
||
Permission to use, copy, modify, distribute, and sell this software and its
|
||
documentation for any purpose is hereby granted without fee, provided that
|
||
the above copyright notice appear in all copies and that both that
|
||
copyright notice and this permission notice appear in supporting
|
||
documentation.
|
||
|
||
The above copyright notice and this permission notice shall be included in
|
||
all copies or substantial portions of the Software.
|
||
|
||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
|
||
Except as contained in this notice, the name of The Open Group shall not be
|
||
used in advertising or otherwise to promote the sale, use or other dealings
|
||
in this Software without prior written authorization from The Open Group.
|
||
|
||
|
||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||
|
||
All Rights Reserved
|
||
|
||
Permission to use, copy, modify, and distribute this software and its
|
||
documentation for any purpose and without fee is hereby granted,
|
||
provided that the above copyright notice appear in all copies and that
|
||
both that copyright notice and this permission notice appear in
|
||
supporting documentation, and that the name of Digital not be
|
||
used in advertising or publicity pertaining to distribution of the
|
||
software without specific, written prior permission.
|
||
|
||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||
SOFTWARE.
|
||
|
||
******************************************************************/
|
||
|
||
#ifdef HAVE_DIX_CONFIG_H
|
||
#include <dix-config.h>
|
||
#endif
|
||
|
||
#include "gcstruct.h"
|
||
#include "pixmap.h"
|
||
#include "mi.h"
|
||
#include "miscanfill.h"
|
||
|
||
static int getPolyYBounds(DDXPointPtr pts, int n, int *by, int *ty);
|
||
|
||
/*
|
||
* convexpoly.c
|
||
*
|
||
* Written by Brian Kelleher; Dec. 1985.
|
||
*
|
||
* Fill a convex polygon. If the given polygon
|
||
* is not convex, then the result is undefined.
|
||
* The algorithm is to order the edges from smallest
|
||
* y to largest by partitioning the array into a left
|
||
* edge list and a right edge list. The algorithm used
|
||
* to traverse each edge is an extension of Bresenham's
|
||
* line algorithm with y as the major axis.
|
||
* For a derivation of the algorithm, see the author of
|
||
* this code.
|
||
*/
|
||
_X_EXPORT Bool
|
||
miFillConvexPoly(dst, pgc, count, ptsIn)
|
||
DrawablePtr dst;
|
||
GCPtr pgc;
|
||
int count; /* number of points */
|
||
DDXPointPtr ptsIn; /* the points */
|
||
{
|
||
int xl = 0, xr = 0; /* x vals of left and right edges */
|
||
int dl = 0, dr = 0; /* decision variables */
|
||
int ml = 0, m1l = 0;/* left edge slope and slope+1 */
|
||
int mr = 0, m1r = 0; /* right edge slope and slope+1 */
|
||
int incr1l = 0, incr2l = 0; /* left edge error increments */
|
||
int incr1r = 0, incr2r = 0; /* right edge error increments */
|
||
int dy; /* delta y */
|
||
int y; /* current scanline */
|
||
int left, right; /* indices to first endpoints */
|
||
int i; /* loop counter */
|
||
int nextleft, nextright; /* indices to second endpoints */
|
||
DDXPointPtr ptsOut, FirstPoint; /* output buffer */
|
||
int *width, *FirstWidth; /* output buffer */
|
||
int imin; /* index of smallest vertex (in y) */
|
||
int ymin; /* y-extents of polygon */
|
||
int ymax;
|
||
|
||
/*
|
||
* find leftx, bottomy, rightx, topy, and the index
|
||
* of bottomy. Also translate the points.
|
||
*/
|
||
imin = getPolyYBounds(ptsIn, count, &ymin, &ymax);
|
||
|
||
dy = ymax - ymin + 1;
|
||
if ((count < 3) || (dy < 0))
|
||
return(TRUE);
|
||
ptsOut = FirstPoint = (DDXPointPtr )ALLOCATE_LOCAL(sizeof(DDXPointRec)*dy);
|
||
width = FirstWidth = (int *)ALLOCATE_LOCAL(sizeof(int) * dy);
|
||
if(!FirstPoint || !FirstWidth)
|
||
{
|
||
if (FirstWidth) DEALLOCATE_LOCAL(FirstWidth);
|
||
if (FirstPoint) DEALLOCATE_LOCAL(FirstPoint);
|
||
return(FALSE);
|
||
}
|
||
|
||
nextleft = nextright = imin;
|
||
y = ptsIn[nextleft].y;
|
||
|
||
/*
|
||
* loop through all edges of the polygon
|
||
*/
|
||
do {
|
||
/*
|
||
* add a left edge if we need to
|
||
*/
|
||
if (ptsIn[nextleft].y == y) {
|
||
left = nextleft;
|
||
|
||
/*
|
||
* find the next edge, considering the end
|
||
* conditions of the array.
|
||
*/
|
||
nextleft++;
|
||
if (nextleft >= count)
|
||
nextleft = 0;
|
||
|
||
/*
|
||
* now compute all of the random information
|
||
* needed to run the iterative algorithm.
|
||
*/
|
||
BRESINITPGON(ptsIn[nextleft].y-ptsIn[left].y,
|
||
ptsIn[left].x,ptsIn[nextleft].x,
|
||
xl, dl, ml, m1l, incr1l, incr2l);
|
||
}
|
||
|
||
/*
|
||
* add a right edge if we need to
|
||
*/
|
||
if (ptsIn[nextright].y == y) {
|
||
right = nextright;
|
||
|
||
/*
|
||
* find the next edge, considering the end
|
||
* conditions of the array.
|
||
*/
|
||
nextright--;
|
||
if (nextright < 0)
|
||
nextright = count-1;
|
||
|
||
/*
|
||
* now compute all of the random information
|
||
* needed to run the iterative algorithm.
|
||
*/
|
||
BRESINITPGON(ptsIn[nextright].y-ptsIn[right].y,
|
||
ptsIn[right].x,ptsIn[nextright].x,
|
||
xr, dr, mr, m1r, incr1r, incr2r);
|
||
}
|
||
|
||
/*
|
||
* generate scans to fill while we still have
|
||
* a right edge as well as a left edge.
|
||
*/
|
||
i = min(ptsIn[nextleft].y, ptsIn[nextright].y) - y;
|
||
/* in case we're called with non-convex polygon */
|
||
if(i < 0)
|
||
{
|
||
DEALLOCATE_LOCAL(FirstWidth);
|
||
DEALLOCATE_LOCAL(FirstPoint);
|
||
return(TRUE);
|
||
}
|
||
while (i-- > 0)
|
||
{
|
||
ptsOut->y = y;
|
||
|
||
/*
|
||
* reverse the edges if necessary
|
||
*/
|
||
if (xl < xr)
|
||
{
|
||
*(width++) = xr - xl;
|
||
(ptsOut++)->x = xl;
|
||
}
|
||
else
|
||
{
|
||
*(width++) = xl - xr;
|
||
(ptsOut++)->x = xr;
|
||
}
|
||
y++;
|
||
|
||
/* increment down the edges */
|
||
BRESINCRPGON(dl, xl, ml, m1l, incr1l, incr2l);
|
||
BRESINCRPGON(dr, xr, mr, m1r, incr1r, incr2r);
|
||
}
|
||
} while (y != ymax);
|
||
|
||
/*
|
||
* Finally, fill the <remaining> spans
|
||
*/
|
||
(*pgc->ops->FillSpans)(dst, pgc,
|
||
ptsOut-FirstPoint,FirstPoint,FirstWidth,
|
||
1);
|
||
DEALLOCATE_LOCAL(FirstWidth);
|
||
DEALLOCATE_LOCAL(FirstPoint);
|
||
return(TRUE);
|
||
}
|
||
|
||
|
||
/*
|
||
* Find the index of the point with the smallest y.
|
||
*/
|
||
static int
|
||
getPolyYBounds(DDXPointPtr pts, int n, int *by, int *ty)
|
||
{
|
||
DDXPointPtr ptMin;
|
||
int ymin, ymax;
|
||
DDXPointPtr ptsStart = pts;
|
||
|
||
ptMin = pts;
|
||
ymin = ymax = (pts++)->y;
|
||
|
||
while (--n > 0) {
|
||
if (pts->y < ymin)
|
||
{
|
||
ptMin = pts;
|
||
ymin = pts->y;
|
||
}
|
||
if(pts->y > ymax)
|
||
ymax = pts->y;
|
||
|
||
pts++;
|
||
}
|
||
|
||
*by = ymin;
|
||
*ty = ymax;
|
||
return(ptMin-ptsStart);
|
||
}
|