Skip to content

K
kicad-source-mirror
Commit 4ce4631d authored by raburton's avatar raburton
Browse files
Options

set eol-style and mime-type properties for new polygon related files

parent dab0fd9e
Hide whitespace changes
Inline Side-by-side
Showing with 1657 additions and 1657 deletions
polygon/GenericPolygonClipperLibrary.cpp
View file @ 4ce4631d
......@@ -1741,7 +1741,7 @@ void gpc_polygon_clip(gpc_op op, gpc_polygon *subj, gpc_polygon *clip,
npoly= poly->next;
FREE(poly);
}
}
}
/* Tidy up */
reset_it(&it);
......
polygon/GenericPolygonClipperLibraryVERSIONS.TXT
View file @ 4ce4631d
Generic Polygon Clipper (gpc) Revision History
==============================================
v2.32 17th Dec 2004
---------------------
Fixed occasional memory leak occurring when processing some
degenerate polygon arrangements.
Added explicit type casting to memory allocator in support of
increased code portability.
v2.31 4th Jun 1999
---------------------
Separated edge merging measure based on a user-defined GPC_EPSILON
value from general numeric equality testing and ordering, which now
uses direct arithmetic comparison rather an EPSILON based proximity
test.
Fixed problem with numerical equality test during construction of
local minima and scanbeam tables, leading to occasional crash.
Fixed hole array memory leak in gpc_add_contour.
Fixed uninitialised hole field bug in gpc_polygon_clip result.
v2.30 11th Apr 1999
---------------------
Major re-write.
Minor API change: additional 'hole' array field added to gpc_polygon
datatype to indicate which constituent contours are internal holes,
and which form external boundaries.
Minor API change: additional 'hole' argument to gpc_add_contour
to indicate whether the new contour is a hole or external contour.
Minor API change: additional parameter to gpc_read_polygon and
gpc_write_polygon to indicate whether or not to read or write
contour hole flags.
Fixed NULL pointer bug in add/merge left/right operations.
Fixed numerical problem in intersection table generation.
Fixed zero byte malloc problem.
Fixed problem producing occasional 2 vertex contours.
Added bounding box test optimisations.
Simplified edge bundle creation, detection of scanbeam internal
edge intersections and tristrip scanbeam boundary code.
Renamed 'class' variable to be C++ friendly.
v2.22 17th Oct 1998
---------------------
Re-implemented edge interpolation and intersection calculations
to improve numerical robustness.
Simplified setting of GPC_EPSILON.
v2.21 19th Aug 1998
---------------------
Fixed problem causing occasional incorrect output when processing
self-intersecting polygons (bow-ties etc).
Removed bug which may lead to non-generation of uppermost triangle
in tristrip output.
v2.20 26th May 1998
---------------------
Major re-write.
Added exclusive-or polygon set operation.
Replaced table-based processing of edge intersections with
rule-based system.
Replaced two-pass approach to scanbeam interior processing with
single pass method.
v2.10a 14th May 1998
---------------------
Minor bug-fixes to counter some v2.10 reliability problems.
v2.10 11th May 1998
---------------------
Major re-write.
Incorporated edge bundle processing of AET to overcome coincident
edge problems present in previous releases.
Replaced Vatti's method for processing scanbeam interior regions
with an adapted version of the scanbeam boundary processing
algorithm.
v2.02 16th Apr 1998 (unreleased)
----------------------------------
Fixed internal minimum vertex duplication in gpc_polygon_clip
result.
Improved line intersection code discourage superfluous
intersections near line ends.
Removed limited precision number formatting in gpc_write_polygon.
Modification to allow subject or clip polygon to be reused as the
result in gpc_polygon_clip without memory leakage.
v2.01 23rd Feb 1998
---------------------
Removed bug causing duplicated vertices in output polygon.
Fixed scanbeam table index overrun problem.
v2.00 25th Nov 1997
---------------------
Major re-write.
Replaced temporary horizontal edge work-around (using tilting)
with true horizontal edge handling.
Trapezoidal output replaced by tristrips.
gpc_op constants now feature a `GPC_' prefix.
Data structures now passed by reference to gpc functions.
Replaced AET search by proxy addressing in polygon table.
Eliminated most (all?) coincident vertex / edge crashes.
v1.02 18th Oct 1997 (unreleased)
----------------------------------
Significantly reduced number of mallocs in build_lmt.
Scanbeam table now built using heapsort rather than insertion
sort.
v1.01 12th Oct 1997
---------------------
Fixed memory leak during output polygon build in
gpc_clip_polygon.
Removed superfluous logfile debug code.
Commented out malloc counts.
Added missing horizontal edge tilt-correction code in
gpc_clip_polygon.
v1.00 8th Oct 1997
--------------------
First release.
Generic Polygon Clipper (gpc) Revision History
==============================================
v2.32 17th Dec 2004
---------------------
Fixed occasional memory leak occurring when processing some
degenerate polygon arrangements.
Added explicit type casting to memory allocator in support of
increased code portability.
v2.31 4th Jun 1999
---------------------
Separated edge merging measure based on a user-defined GPC_EPSILON
value from general numeric equality testing and ordering, which now
uses direct arithmetic comparison rather an EPSILON based proximity
test.
Fixed problem with numerical equality test during construction of
local minima and scanbeam tables, leading to occasional crash.
Fixed hole array memory leak in gpc_add_contour.
Fixed uninitialised hole field bug in gpc_polygon_clip result.
v2.30 11th Apr 1999
---------------------
Major re-write.
Minor API change: additional 'hole' array field added to gpc_polygon
datatype to indicate which constituent contours are internal holes,
and which form external boundaries.
Minor API change: additional 'hole' argument to gpc_add_contour
to indicate whether the new contour is a hole or external contour.
Minor API change: additional parameter to gpc_read_polygon and
gpc_write_polygon to indicate whether or not to read or write
contour hole flags.
Fixed NULL pointer bug in add/merge left/right operations.
Fixed numerical problem in intersection table generation.
Fixed zero byte malloc problem.
Fixed problem producing occasional 2 vertex contours.
Added bounding box test optimisations.
Simplified edge bundle creation, detection of scanbeam internal
edge intersections and tristrip scanbeam boundary code.
Renamed 'class' variable to be C++ friendly.
v2.22 17th Oct 1998
---------------------
Re-implemented edge interpolation and intersection calculations
to improve numerical robustness.
Simplified setting of GPC_EPSILON.
v2.21 19th Aug 1998
---------------------
Fixed problem causing occasional incorrect output when processing
self-intersecting polygons (bow-ties etc).
Removed bug which may lead to non-generation of uppermost triangle
in tristrip output.
v2.20 26th May 1998
---------------------
Major re-write.
Added exclusive-or polygon set operation.
Replaced table-based processing of edge intersections with
rule-based system.
Replaced two-pass approach to scanbeam interior processing with
single pass method.
v2.10a 14th May 1998
---------------------
Minor bug-fixes to counter some v2.10 reliability problems.
v2.10 11th May 1998
---------------------
Major re-write.
Incorporated edge bundle processing of AET to overcome coincident
edge problems present in previous releases.
Replaced Vatti's method for processing scanbeam interior regions
with an adapted version of the scanbeam boundary processing
algorithm.
v2.02 16th Apr 1998 (unreleased)
----------------------------------
Fixed internal minimum vertex duplication in gpc_polygon_clip
result.
Improved line intersection code discourage superfluous
intersections near line ends.
Removed limited precision number formatting in gpc_write_polygon.
Modification to allow subject or clip polygon to be reused as the
result in gpc_polygon_clip without memory leakage.
v2.01 23rd Feb 1998
---------------------
Removed bug causing duplicated vertices in output polygon.
Fixed scanbeam table index overrun problem.
v2.00 25th Nov 1997
---------------------
Major re-write.
Replaced temporary horizontal edge work-around (using tilting)
with true horizontal edge handling.
Trapezoidal output replaced by tristrips.
gpc_op constants now feature a `GPC_' prefix.
Data structures now passed by reference to gpc functions.
Replaced AET search by proxy addressing in polygon table.
Eliminated most (all?) coincident vertex / edge crashes.
v1.02 18th Oct 1997 (unreleased)
----------------------------------
Significantly reduced number of mallocs in build_lmt.
Scanbeam table now built using heapsort rather than insertion
sort.
v1.01 12th Oct 1997
---------------------
Fixed memory leak during output polygon build in
gpc_clip_polygon.
Removed superfluous logfile debug code.
Commented out malloc counts.
Added missing horizontal edge tilt-correction code in
gpc_clip_polygon.
v1.00 8th Oct 1997
--------------------
First release.
polygon/defs-macros.h
View file @ 4ce4631d
/**********************/
/* Some usual defines */
/**********************/
#ifndef DEFS_MACROS_H
#define DEFS_MACROS_H
#ifndef BOOL
#define BOOL bool
#endif
#ifndef FALSE
#define FALSE false
#endif
#ifndef TRUE
#define TRUE true
#endif
#ifndef NULL
#define NULL 0
#endif
#ifndef abs
#define abs(x) (((x) >=0) ? (x) : (-(x)))
#endif
#define TRACE printf
#define ASSERT(x) // todo : change to DEBUG, under wxWidgets
#endif // ifndef DEFS_MACROS_H
/**********************/
/* Some usual defines */
/**********************/
#ifndef DEFS_MACROS_H
#define DEFS_MACROS_H
#ifndef BOOL
#define BOOL bool
#endif
#ifndef FALSE
#define FALSE false
#endif
#ifndef TRUE
#define TRUE true
#endif
#ifndef NULL
#define NULL 0
#endif
#ifndef abs
#define abs(x) (((x) >=0) ? (x) : (-(x)))
#endif
#define TRACE printf
#define ASSERT(x) // todo : change to DEBUG, under wxWidgets
#endif // ifndef DEFS_MACROS_H
polygon/links.txt
View file @ 4ce4631d
links to software relative to polygons (clipping and and other operations)
used in freePCB (Written by Alan Wright)
gpc (here: GenericPolygonClipperLibrary.cpp)
http://www.cs.man.ac.uk/~toby/alan/software/gpc.html
polygon.php (ported in "C++" by Alan Wright)
the c++ corresponding file is php_polygon.cpp
http://www.phpclasses.org/browse/file/10683.html
used in gpcb:
polygon1.c:
http://www.koders.com/c/
and for this file:
http://www.koders.com/c/fidE26CF2236C2DF7E435D597390A05B982EDFB4C38.aspx
gpcb uses a modified file (integer coordinates)
links to software relative to polygons (clipping and and other operations)
used in freePCB (Written by Alan Wright)
gpc (here: GenericPolygonClipperLibrary.cpp)
http://www.cs.man.ac.uk/~toby/alan/software/gpc.html
polygon.php (ported in "C++" by Alan Wright)
the c++ corresponding file is php_polygon.cpp
http://www.phpclasses.org/browse/file/10683.html
used in gpcb:
polygon1.c:
http://www.koders.com/c/
and for this file:
http://www.koders.com/c/fidE26CF2236C2DF7E435D597390A05B982EDFB4C38.aspx
gpcb uses a modified file (integer coordinates)
polygon/makefile.g95
View file @ 4ce4631d
WXDIR = $(WXWIN)
TARGET = lib_polygon.a
all: $(TARGET)
include ../libs.win
include makefile.include
$(TARGET): $(OBJECTS) ../libs.win makefile.include
ar ruv $@ $(OBJECTS)
ranlib $@
clean:
rm -f *.bak
rm -f *.o
rm -f $(TARGET)
WXDIR = $(WXWIN)
TARGET = lib_polygon.a
all: $(TARGET)
include ../libs.win
include makefile.include
$(TARGET): $(OBJECTS) ../libs.win makefile.include
ar ruv $@ $(OBJECTS)
ranlib $@
clean:
rm -f *.bak
rm -f *.o
rm -f $(TARGET)
polygon/makefile.gtk
View file @ 4ce4631d
## Makefile for common.a
CC = gcc
include ../libs.linux
# Compiler flags.
CPPFLAGS += -I./ -I../include
EDACPPFLAGS = $(CPPFLAGS)
TARGET = lib_polygon.a
all: $(TARGET)
deps:
$(CXX) $(CPPFLAGS) -E -MMD -MG *.cpp >/dev/null
include makefile.include
-include *.d
CPPFLAGS += $(EXTRACPPFLAGS) -fno-strict-aliasing
EDACPPFLAGS = $(CPPFLAGS)
$(TARGET): $(OBJECTS) makefile.gtk makefile.include
rm -f $@
ar -rv $@ $(OBJECTS)
ranlib $@
install:$(TARGET)
clean:
rm -f *.o *~ core *.bak *.obj *.d
rm -f $(TARGET)
## Makefile for common.a
CC = gcc
include ../libs.linux
# Compiler flags.
CPPFLAGS += -I./ -I../include
EDACPPFLAGS = $(CPPFLAGS)
TARGET = lib_polygon.a
all: $(TARGET)
deps:
$(CXX) $(CPPFLAGS) -E -MMD -MG *.cpp >/dev/null
include makefile.include
-include *.d
CPPFLAGS += $(EXTRACPPFLAGS) -fno-strict-aliasing
EDACPPFLAGS = $(CPPFLAGS)
$(TARGET): $(OBJECTS) makefile.gtk makefile.include
rm -f $@
ar -rv $@ $(OBJECTS)
ranlib $@
install:$(TARGET)
clean:
rm -f *.o *~ core *.bak *.obj *.d
rm -f $(TARGET)
polygon/makefile.include
View file @ 4ce4631d
EXTRACPPFLAGS += -I$(SYSINCLUDE) -I./ -Ibitmaps -I../include
COMMON =
OBJECTS= \
GenericPolygonClipperLibrary.o \
php_polygon.o\
php_polygon_vertex.o
GenericPolygonClipperLibrary.o: GenericPolygonClipperLibrary.cpp GenericPolygonClipperLibrary.h
php_polygon.o: php_polygon.cpp php_polygon.h php_polygon_vertex.h defs-macros.h
#polygon1.o: polygon1.cpp polyarea.h vectmatr.h
EXTRACPPFLAGS += -I$(SYSINCLUDE) -I./ -Ibitmaps -I../include
COMMON =
OBJECTS= \
GenericPolygonClipperLibrary.o \
php_polygon.o\
php_polygon_vertex.o
GenericPolygonClipperLibrary.o: GenericPolygonClipperLibrary.cpp GenericPolygonClipperLibrary.h
php_polygon.o: php_polygon.cpp php_polygon.h php_polygon_vertex.h defs-macros.h
#polygon1.o: polygon1.cpp polyarea.h vectmatr.h
polygon/makefile.macosx
View file @ 4ce4631d
## Makefile for common.a
include ../libs.macosx
TARGET = lib_polygon.a
all: $(TARGET)
deps:
$(CXX) $(CPPFLAGS) -E -MMD -MG *.cpp >/dev/null
include makefile.include
-include *.d
CPPFLAGS += $(EXTRACPPFLAGS)
EDACPPFLAGS = $(CPPFLAGS)
$(TARGET): $(OBJECTS) makefile.macosx makefile.include
rm -f $@
ar -rv $@ $(OBJECTS)
ranlib $@
clean:
rm -f *.o; rm -f *~
rm -f $(TARGET)
## Makefile for common.a
include ../libs.macosx
TARGET = lib_polygon.a
all: $(TARGET)
deps:
$(CXX) $(CPPFLAGS) -E -MMD -MG *.cpp >/dev/null
include makefile.include
-include *.d
CPPFLAGS += $(EXTRACPPFLAGS)
EDACPPFLAGS = $(CPPFLAGS)
$(TARGET): $(OBJECTS) makefile.macosx makefile.include
rm -f $@
ar -rv $@ $(OBJECTS)
ranlib $@
clean:
rm -f *.o; rm -f *~
rm -f $(TARGET)
polygon/php_polygon.cpp
View file @ 4ce4631d
// file php_polygon.cpp
// This is a port of a php class written by Brenor Brophy (see below)
/*------------------------------------------------------------------------------
** File: polygon.php
** Description: PHP class for a polygon.
** Version: 1.1
** Author: Brenor Brophy
** Email: brenor at sbcglobal dot net
** Homepage: www.brenorbrophy.com
**------------------------------------------------------------------------------
** COPYRIGHT (c) 2005 BRENOR BROPHY
**
** The source code included in this package is free software; you can
** redistribute it and/or modify it under the terms of the GNU General Public
** License as published by the Free Software Foundation. This license can be
** read at:
**
** http://www.opensource.org/licenses/gpl-license.php
**
** This program is distributed in the hope that it will be useful, but WITHOUT
** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
** FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
**------------------------------------------------------------------------------
**
** Based on the paper "Efficient Clipping of Arbitary Polygons" by Gunther
** Greiner (greiner at informatik dot uni-erlangen dot de) and Kai Hormann
** (hormann at informatik dot tu-clausthal dot de), ACM Transactions on Graphics
** 1998;17(2):71-83.
**
** Available at: www.in.tu-clausthal.de/~hormann/papers/clipping.pdf
**
** Another useful site describing the algorithm and with some example
** C code by Ionel Daniel Stroe is at:
**
** http://davis.wpi.edu/~matt/courses/clipping/
**
** The algorithm is extended by Brenor Brophy to allow polygons with
** arcs between vertices.
**
** Rev History
** -----------------------------------------------------------------------------
** 1.0 08/25/2005 Initial Release
** 1.1 09/04/2005 Added Move(), Rotate(), isPolyInside() and bRect() methods.
** Added software license language to header comments
*/
//#include "stdafx.h"
#include <stdio.h>
#include <math.h>
#include "php_polygon_vertex.h"
#include "php_polygon.h"
const double PT = 0.99999;
//const double eps = (1.0 - PT)/10.0;
const double eps = 0.0;
polygon::polygon( vertex * first )
{
m_first = first;
m_cnt = 0;
}
polygon::~polygon()
{
while( m_cnt > 1 )
{
vertex * v = getFirst();
del( v->m_nextV );
}
if( m_first )
{
delete m_first;
}
}
vertex * polygon::getFirst()
{
return m_first;
}
polygon * polygon::NextPoly()
{
return m_first->NextPoly();
}
/*
** Add a vertex object to the polygon (vertex is added at the "end" of the list)
** Which because polygons are closed lists means it is added just before the first
** vertex.
*/
void polygon::add( vertex * nv )
{
if ( m_cnt == 0 ) // If this is the first vertex in the polygon
{
m_first = nv; // Save a reference to it in the polygon
m_first->setNext(nv); // Set its pointer to point to itself
m_first->setPrev(nv); // because it is the only vertex in the list
segment * ps = m_first->Nseg(); // Get ref to the Next segment object
m_first->setPseg(ps); // and save it as Prev segment as well
}
else // At least one other vertex already exists
{
// p <-> nv <-> n
// ps ns
vertex * n = m_first; // Get a ref to the first vertex in the list
vertex * p = n->Prev(); // Get ref to previous vertex
n->setPrev(nv); // Add at end of list (just before first)
nv->setNext(n); // link the new vertex to it
nv->setPrev(p); // link to the pervious EOL vertex
p->setNext(nv); // And finally link the previous EOL vertex
// Segments
segment * ns = nv->Nseg(); // Get ref to the new next segment
segment * ps = p->Nseg(); // Get ref to the previous segment
n->setPseg(ns); // Set new previous seg for m_first
nv->setPseg(ps); // Set previous seg of the new vertex
}
m_cnt++; // Increment the count of vertices
}
/*
** Create a vertex and then add it to the polygon
*/
void polygon::addv ( double x, double y,
double xc, double yc, int d )
{
vertex * nv = new vertex( x, y, xc, yc, d );
add( nv );
}
/*
** Delete a vertex object from the polygon. This is not used by the main algorithm
** but instead is used to clean-up a polygon so that a second boolean operation can
** be performed.
*/
vertex * polygon::del( vertex * v )
{
// p <-> v <-> n Will delete v and ns
// ps ns
vertex * p = v->Prev(); // Get ref to previous vertex
vertex * n = v->Next(); // Get ref to next vertex
p->setNext(n); // Link previous forward to next
n->setPrev(p); // Link next back to previous
// Segments
segment * ps = p->Nseg(); // Get ref to previous segment
segment * ns = v->Nseg(); // Get ref to next segment
n->setPseg(ps); // Link next back to previous segment
delete ns; //AMW
v->m_nSeg = NULL; // AMW
delete v; //AMW
// ns = NULL;
// v = NULL; // Free the memory
m_cnt--; // One less vertex
return n; // Return a ref to the next valid vertex
}
/*
** Reset Polygon - Deletes all intersection vertices. This is used to
** restore a polygon that has been processed by the boolean method
** so that it can be processed again.
*/
void polygon::res()
{
vertex * v = getFirst(); // Get the first vertex
do
{
v = v->Next(); // Get the next vertex in the polygon
while (v->isIntersect()) // Delete all intersection vertices
v = del(v);
}
while (v->id() != m_first->id());
}
/*
** Copy Polygon - Returns a reference to a new copy of the poly object
** including all its vertices & their segments
*/
polygon * polygon::copy_poly()
{
polygon * n = new polygon; // Create a new instance of this class
vertex * v = getFirst();
do
{
n->addv(v->X(),v->Y(),v->Xc(),v->Yc(),v->d());
v = v->Next();
}
while (v->id() != m_first->id());
return n;
}
/*
** Insert and Sort a vertex between a specified pair of vertices (start and end)
**
** This function inserts a vertex (most likely an intersection point) between two
** other vertices. These other vertices cannot be intersections (that is they must
** be actual vertices of the original polygon). If there are multiple intersection
** points between the two vertices then the new vertex is inserted based on its
** alpha value.
*/
void polygon::insertSort( vertex * nv, vertex * s, vertex * e )
{
vertex * c = s; // Set current to the starting vertex
// Move current past any intersections
// whose alpha is lower but don't go past
// the end vertex
while( c->id() != e->id() && c->Alpha() < nv->Alpha() )
c = c->Next();
// p <-> nv <-> c
nv->setNext(c); // Link new vertex forward to curent one
vertex * p = c->Prev(); // Get a link to the previous vertex
nv->setPrev(p); // Link the new vertex back to the previous one
p->setNext(nv); // Link previous vertex forward to new vertex
c->setPrev(nv); // Link current vertex back to the new vertex
// Segments
segment * ps = p->Nseg();
nv->setPseg(ps);
segment * ns = nv->Nseg();
c->setPseg(ns);
m_cnt++; // Just added a new vertex
}
/*
** return the next non intersecting vertex after the one specified
*/
vertex * polygon::nxt( vertex * v )
{
vertex * c = v; // Initialize current vertex
while (c && c->isIntersect()) // Move until a non-intersection
c = c->Next(); // vertex if found
return c; // return that vertex
}
/*
** Check if any unchecked intersections remain in the polygon. The boolean
** method is complete when all intersections have been checked.
*/
BOOL polygon::unckd_remain()
{
BOOL remain = FALSE;
vertex * v = m_first;
do
{
if (v->isIntersect() && !v->isChecked())
remain = TRUE; // Set if an unchecked intersection is found
v = v->Next();
}
while (v->id() != m_first->id());
return remain;
}
/*
** Return a ref to the first unchecked intersection point in the polygon.
** If none are found then just the first vertex is returned.
*/
vertex * polygon::first_unckd_intersect()
{
vertex * v = m_first;
do // Do-While
{ // Not yet reached end of the polygon
v = v->Next(); // AND the vertex if NOT an intersection
} // OR it IS an intersection, but has been checked already
while(v->id() != m_first->id() && ( !v->isIntersect() || ( v->isIntersect() && v->isChecked() ) ) );
return v;
}
/*
** Return the distance between two points
*/
double polygon::dist( double x1, double y1, double x2, double y2 )
{
return sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
}
/*
** Calculate the angle between 2 points, where Xc,Yc is the center of a circle
** and x,y is a point on its circumference. All angles are relative to
** the 3 O'Clock position. Result returned in radians
*/
double polygon::angle( double xc, double yc, double x1, double y1 )
{
double d = dist(xc, yc, x1, y1); // calc distance between two points
double a1;
if ( asin( (y1-yc)/d ) >= 0 )
a1 = acos( (x1-xc)/d );
else
a1 = 2*PI - acos( (x1-xc)/d );
return a1;
}
/*
** Return Alpha value for an Arc
**
** X1/Y1 & X2/Y2 are the end points of the arc, Xc/Yc is the center & Xi/Yi
** the intersection point on the arc. d is the direction of the arc
*/
double polygon::aAlpha( double x1, double y1, double x2, double y2,
double xc, double yc, double xi, double yi, double d )
{
double sa = angle(xc, yc, x1, y1); // Start Angle
double ea = angle(xc, yc, x2, y2); // End Angle
double ia = angle(xc, yc, xi, yi); // Intersection Angle
double arc, aint;
if (d == 1) // Anti-Clockwise
{
arc = ea - sa;
aint = ia - sa;
}
else // Clockwise
{
arc = sa - ea;
aint = sa - ia;
}
if (arc < 0)
arc += 2*PI;
if (aint < 0)
aint += 2*PI;
double a = aint/arc;
return a;
}
/*
** This function handles the degenerate case where a vertex of one
** polygon lies directly on an edge of the other. This case can
** also occur during the isInside() function, where the search
** line exactly intersects with a vertex. The function works
** by shortening the line by a tiny amount.
*/
void polygon::perturb( vertex * p1, vertex * p2, vertex * q1, vertex * q2,
double aP, double aQ )
{
// if (aP == 0) // Move vertex p1 closer to p2
if( abs(aP) <= eps ) // Move vertex p1 closer to p2
{
p1->setX(p1->X() + (1-PT) * (p2->X() - p1->X()));
p1->setY(p1->Y() + (1-PT) * (p2->Y() - p1->Y()));
}
// else if (aP == 1) // Move vertex p2 closer to p1
else if( abs(1-aP) <= eps ) // Move vertex p2 closer to p1
{
p2->setX(p1->X() + PT * (p2->X() - p1->X()));
p2->setY(p1->Y() + PT * (p2->Y() - p1->Y()));
}
//** else if (aQ == 0) // Move vertex q1 closer to q2
if( abs(aQ) <= eps ) // Move vertex q1 closer to q2
{
q1->setX(q1->X() + (1-PT) * (q2->X() - q1->X()));
q1->setY(q1->Y() + (1-PT) * (q2->Y() - q1->Y()));
}
//** else if (aQ == 1) // Move vertex q2 closer to q1
else if( abs(1-aQ) <= eps ) // Move vertex q2 closer to q1
{
q2->setX(q1->X() + PT * (q2->X() - q1->X()));
q2->setY(q1->Y() + PT * (q2->Y() - q1->Y()));
}
}
/*
** Determine the intersection between two pairs of vertices p1/p2, q1/q2
**
** Either or both of the segments passed to this function could be arcs.
** Thus we must first determine if the intersection is line/line, arc/line
** or arc/arc. Then apply the correct math to calculate the intersection(s).
**
** Line/Line can have 0 (no intersection) or 1 intersection
** Line/Arc and Arc/Arc can have 0, 1 or 2 intersections
**
** The function returns TRUE is any intersections are found
** The number found is returned in n
** The arrays ix[], iy[], alphaP[] & alphaQ[] return the intersection points
** and their associated alpha values.
*/
BOOL polygon::ints( vertex * p1, vertex * p2, vertex * q1, vertex * q2,
int * n, double ix[], double iy[], double alphaP[], double alphaQ[] )
{
BOOL found = FALSE;
*n = 0; // No intersections found yet
int pt = p1->d();
int qt = q1->d(); // Do we have Arcs or Lines?
if (pt == 0 && qt == 0) // Is it line/Line ?
{
/* LINE/LINE
** Algorithm from: http://astronomy.swin.edu.au/~pbourke/geometry/lineline2d/
*/
double x1 = p1->X();
double y1 = p1->Y();
double x2 = p2->X();
double y2 = p2->Y();
double x3 = q1->X();
double y3 = q1->Y();
double x4 = q2->X();
double y4 = q2->Y();
double d = ((y4-y3)*(x2-x1)-(x4-x3)*(y2-y1));
if (d != 0)
{ // The lines intersect at a point somewhere
double ua = ((x4-x3)*(y1-y3)-(y4-y3)*(x1-x3))/d;
double ub = ((x2-x1)*(y1-y3)-(y2-y1)*(x1-x3))/d;
TRACE( " ints: ua = %.17f, ub = %.17f\n", ua, ub );
// The values of $ua and $ub tell us where the intersection occurred.
// A value between 0 and 1 means the intersection occurred within the
// line segment.
// A value less than 0 or greater than 1 means the intersection occurred
// outside the line segment
// A value of exactly 0 or 1 means the intersection occurred right at the
// start or end of the line segment. For our purposes we will consider this
// NOT to be an intersection and we will move the vertex a tiny distance
// away from the intersecting line.
// if( ua == 0 || ua == 1 || ub == 0 || ub == 1 )
if( abs(ua)<=eps || abs(1.0-ua)<=eps || abs(ub)<=eps || abs(1.0-ub)<=eps )
{
// Degenerate case - vertex touches a line
perturb(p1, p2, q1, q2, ua, ub);
//** for testing, see if we have successfully resolved the degeneracy
{
double tx1 = p1->X();
double ty1 = p1->Y();
double tx2 = p2->X();
double ty2 = p2->Y();
double tx3 = q1->X();
double ty3 = q1->Y();
double tx4 = q2->X();
double ty4 = q2->Y();
double td = ((ty4-ty3)*(tx2-tx1)-(tx4-tx3)*(ty2-ty1));
if (td != 0)
{
// The lines intersect at a point somewhere
double tua = ((tx4-tx3)*(ty1-ty3)-(ty4-ty3)*(tx1-tx3))/td;
double tub = ((tx2-tx1)*(ty1-ty3)-(ty2-ty1)*(tx1-tx3))/td;
if( abs(tua)<=eps || abs(1.0-tua)<=eps || abs(tub)<=eps || abs(1.0-tub)<=eps )
ASSERT(0);
else if( (tua > 0 && tua < 1) && (tub > 0 && tub < 1) )
ASSERT(0);
TRACE( " perturb:\n new s = (%f,%f) to (%f,%f)\n new c = (%f,%f) to (%f,%f)\n new ua = %.17f, ub = %.17f\n",
tx1, ty1, tx2, ty2, tx3, ty3, tx4, ty4, tua, tub );
}
}
//** end test
found = FALSE;
}
else if ((ua > 0 && ua < 1) && (ub > 0 && ub < 1))
{
// Intersection occurs on both line segments
double x = x1 + ua*(x2-x1);
double y = y1 + ua*(y2-y1);
iy[0] = y;
ix[0] = x;
alphaP[0] = ua;
alphaQ[0] = ub;
*n = 1;
found = TRUE;
}
else
{
// The lines do not intersect
found = FALSE;
}
}
else
{
// The lines do not intersect (they are parallel)
found = FALSE;
}
} // End of find Line/Line intersection
else if (pt != 0 && qt != 0) // Is it Arc/Arc?
{
/* ARC/ARC
** Algorithm from: http://astronomy.swin.edu.au/~pbourke/geometry/2circle/
*/
double x0 = p1->Xc();
double y0 = p1->Yc(); // Center of first Arc
double r0 = dist(x0,y0,p1->X(),p1->Y()); // Calc the radius
double x1 = q1->Xc();
double y1 = q1->Yc(); // Center of second Arc
double r1 = dist(x1,y1,q1->X(),q1->Y()); // Calc the radius
double dx = x1 - x0; // dx and dy are the vertical and horizontal
double dy = y1 - y0; // distances between the circle centers.
double d = sqrt((dy*dy) + (dx*dx)); // Distance between the centers.
if(d > (r0 + r1)) // Check for solvability.
{ // no solution. circles do not intersect.
found = FALSE;
}
else if(d < abs(r0 - r1) )
{ // no solution. one circle inside the other
found = FALSE;
}
else
{
/*
** 'xy2' is the point where the line through the circle intersection
** points crosses the line between the circle centers.
*/
double a = ((r0*r0)-(r1*r1)+(d*d))/(2.0*d); // Calc the distance from xy0 to xy2.
double x2 = x0 + (dx * a/d); // Determine the coordinates of xy2.
double y2 = y0 + (dy * a/d);
if (d == (r0 + r1)) // Arcs touch at xy2 exactly (unlikely)
{
alphaP[0] = aAlpha(p1->X(), p1->Y(), p2->X(), p2->Y(), x0, y0, x2, y2, pt);
alphaQ[0] = aAlpha(q1->X(), q1->Y(), q2->X(), q2->Y(), x1, y1, x2, y2, qt);
if ((alphaP[0] >0 && alphaP[0] < 1) && (alphaQ[0] >0 && alphaQ[0] < 1))
{
ix[0] = x2;
iy[0] = y2;
*n = 1; found = TRUE;
}
}
else // Arcs intersect at two points
{
double alP[2], alQ[2];
double h = sqrt((r0*r0) - (a*a)); // Calc the distance from xy2 to either
// of the intersection points.
double rx = -dy * (h/d); // Now determine the offsets of the
double ry = dx * (h/d);
// intersection points from xy2
double x[2], y[2];
x[0] = x2 + rx; x[1] = x2 - rx; // Calc the absolute intersection points.
y[0] = y2 + ry; y[1] = y2 - ry;
alP[0] = aAlpha(p1->X(), p1->Y(), p2->X(), p2->Y(), x0, y0, x[0], y[0], pt);
alQ[0] = aAlpha(q1->X(), q1->Y(), q2->X(), q2->Y(), x1, y1, x[0], y[0], qt);
alP[1] = aAlpha(p1->X(), p1->Y(), p2->X(), p2->Y(), x0, y0, x[1], y[1], pt);
alQ[1] = aAlpha(q1->X(), q1->Y(), q2->X(), q2->Y(), x1, y1, x[1], y[1], qt);
for (int i=0; i<=1; i++)
if ((alP[i] >0 && alP[i] < 1) && (alQ[i] >0 && alQ[i] < 1))
{
ix[*n] = x[i];
iy[*n] = y[i];
alphaP[*n] = alP[i];
alphaQ[*n] = alQ[i];
*n++;
found = TRUE;
}
}
}
} // End of find Arc/Arc intersection
else // It must be Arc/Line
{
/* ARC/LINE
** Algorithm from: http://astronomy.swin.edu.au/~pbourke/geometry/sphereline/
*/
double d, x1, x2, xc, xs, xe;
double y1, y2, yc, ys, ye;
if (pt == 0) // Segment p1,p2 is the line
{ // Segment q1,q2 is the arc
x1 = p1->X();
y1 = p1->Y();
x2 = p2->X();
y2 = p2->Y();
xc = q1->Xc();
yc = q1->Yc();
xs = q1->X();
ys = q1->Y();
xe = q2->X();
ye = q2->Y();
d = qt;
}
else // Segment q1,q2 is the line
{ // Segment p1,p2 is the arc
x1 = q1->X(); y1 = q1->Y();
x2 = q2->X(); y2 = q2->Y();
xc = p1->Xc(); yc = p1->Yc();
xs = p1->X(); ys = p1->Y();
xe = p2->X(); ye = p2->Y();
d = pt;
}
double r = dist(xc,yc,xs,ys);
double a = pow((x2 - x1),2)+pow((y2 - y1),2);
double b = 2* ( (x2 - x1)*(x1 - xc)
+ (y2 - y1)*(y1 - yc) );
double c = pow(xc,2) + pow(yc,2) +
pow(x1,2) + pow(y1,2) -
2* ( xc*x1 + yc*y1) - pow(r,2);
double i = b * b - 4 * a * c;
if ( i < 0.0 ) // no intersection
{
found = FALSE;
}
else if ( i == 0.0 ) // one intersection
{
double mu = -b/(2*a);
double x = x1 + mu*(x2-x1);
double y = y1 + mu*(y2-y1);
double al = mu; // Line Alpha
double aa = this->aAlpha(xs, ys, xe, ye, xc, yc, x, y, d); // Arc Alpha
if ((al >0 && al <1)&&(aa >0 && aa <1))
{
ix[0] = x; iy[0] = y;
*n = 1;
found = TRUE;
if (pt == 0)
{
alphaP[0] = al; alphaQ[0] = aa;
}
else
{
alphaP[0] = aa; alphaQ[0] = al;
}
}
}
else if ( i > 0.0 ) // two intersections
{
double mu[2], x[2], y[2], al[2], aa[2];
mu[0] = (-b + sqrt( pow(b,2) - 4*a*c )) / (2*a); // first intersection
x[0] = x1 + mu[0]*(x2-x1);
y[0] = y1 + mu[0]*(y2-y1);
mu[1] = (-b - sqrt(pow(b,2) - 4*a*c )) / (2*a); // second intersection
x[1] = x1 + mu[1]*(x2-x1);
y[1] = y1 + mu[1]*(y2-y1);
al[0] = mu[0];
aa[0] = aAlpha(xs, ys, xe, ye, xc, yc, x[0], y[0], d);
al[1] = mu[1];
aa[1] = aAlpha(xs, ys, xe, ye, xc, yc, x[1], y[1], d);
for (int i=0; i<=1; i++)
if ((al[i] >0 && al[i] < 1) && (aa[i] >0 && aa[i] < 1))
{
ix[*n] = x[i];
iy[*n] = y[i];
if (pt == 0)
{
alphaP[*n] = al[i];
alphaQ[*n] = aa[i];
}
else
{
alphaP[*n] = aa[i];
alphaQ[*n] = al[i];
}
*n++;
found = TRUE;
}
}
} // End of find Arc/Line intersection
return found;
} // end of intersect function
/*
** Test if a vertex lies inside the polygon
**
** This function calculates the "winding" number for the point. This number
** represents the number of times a ray emitted from the point to infinity
** intersects any edge of the polygon. An even winding number means the point
** lies OUTSIDE the polygon, an odd number means it lies INSIDE it.
**
** Right now infinity is set to -10000000, some people might argue that infinity
** actually is a bit bigger. Those people have no lives.
**
** Allan Wright 4/16/2006: I guess I have no life: I had to increase it to -1000000000
*/
BOOL polygon::isInside( vertex * v )
{
//** modified for testing
if( v->isIntersect() )
ASSERT(0);
int winding_number = 0;
int winding_number2 = 0;
int winding_number3 = 0;
int winding_number4 = 0;
//** vertex * point_at_infinity = new vertex(-10000000,v->Y()); // Create point at infinity
vertex * point_at_infinity = new vertex(-1000000000,-50000000); // Create point at infinity
vertex * point_at_infinity2 = new vertex(1000000000,+50000000); // Create point at infinity
vertex * point_at_infinity3 = new vertex(500000000,1000000000); // Create point at infinity
vertex * point_at_infinity4 = new vertex(-500000000,1000000000); // Create point at infinity
vertex * q = m_first; // End vertex of a line segment in polygon
do
{
if (!q->isIntersect())
{
int n;
double x[2], y[2], aP[2], aQ[2];
if( ints( point_at_infinity, v, q, nxt(q->Next()), &n, x, y, aP, aQ ) )
winding_number += n; // Add number of intersections found
if( ints( point_at_infinity2, v, q, nxt(q->Next()), &n, x, y, aP, aQ ) )
winding_number2 += n; // Add number of intersections found
if( ints( point_at_infinity3, v, q, nxt(q->Next()), &n, x, y, aP, aQ ) )
winding_number3 += n; // Add number of intersections found
if( ints( point_at_infinity4, v, q, nxt(q->Next()), &n, x, y, aP, aQ ) )
winding_number4 += n; // Add number of intersections found
}
q = q->Next();
}
while( q->id() != m_first->id() );
delete point_at_infinity;
delete point_at_infinity2;
if( winding_number%2 != winding_number2%2
|| winding_number3%2 != winding_number4%2
|| winding_number%2 != winding_number3%2 )
ASSERT(0);
if( winding_number%2 == 0 ) // Check even or odd
return FALSE; // even == outside
else
return TRUE; // odd == inside
}
/*
** Execute a Boolean operation on a polygon
**
** This is the key method. It allows you to AND/OR this polygon with another one
** (equvalent to a UNION or INTERSECT operation. You may also subtract one from
** the other (same as DIFFERENCE). Given two polygons A, B the following operations
** may be performed:
**
** A|B ... A OR B (Union of A and B)
** A&B ... A AND B (Intersection of A and B)
** A\B ... A - B
** B\A ... B - A
**
** A is the object and B is the polygon passed to the method.
*/
polygon * polygon::boolean( polygon * polyB, int oper )
{
polygon * last = NULL;
vertex * s = m_first; // First vertex of the subject polygon
vertex * c = polyB->getFirst(); // First vertex of the "clip" polygon
/*
** Phase 1 of the algoritm is to find all intersection points between the two
** polygons. A new vertex is created for each intersection and it is added to
** the linked lists for both polygons. The "neighbor" reference in each vertex
** stores the link between the same intersection point in each polygon.
*/
TRACE( "boolean...phase 1\n" );
do
{
TRACE( "s=(%f,%f) to (%f,%f) I=%d\n",
s->m_x, s->m_y, s->m_nextV->m_x, s->m_nextV->m_y, s->m_intersect );
if (!s->isIntersect())
{
do
{
TRACE( " c=(%f,%f) to (%f,%f) I=%d\n",
c->m_x, c->m_y, c->m_nextV->m_x, c->m_nextV->m_y, c->m_intersect );
if (!c->isIntersect())
{
int n;
double ix[2], iy[2], alphaS[2], alphaC[2];
BOOL bInt = ints(s, nxt(s->Next()),c, polyB->nxt(c->Next()), &n, ix, iy, alphaS, alphaC);
if( bInt )
{
TRACE( " int at (%f,%f) aS = %.17f, aC = %.17f\n", ix[0], iy[0], alphaS[0], alphaC[0] );
for (int i=0; i<n; i++)
{
vertex * is = new vertex(ix[i], iy[i], s->Xc(), s->Yc(), s->d(), NULL, NULL, NULL, TRUE, NULL, alphaS[i], FALSE, FALSE);
vertex * ic = new vertex(ix[i], iy[i], c->Xc(), c->Yc(), c->d(), NULL, NULL, NULL, TRUE, NULL, alphaC[i], FALSE, FALSE);
is->setNeighbor(ic);
ic->setNeighbor(is);
insertSort(is, s, this->nxt(s->Next()));
polyB->insertSort(ic, c, polyB->nxt(c->Next()));
}
}
} // end if c is not an intersect point
c = c->Next();
}
while (c->id() != polyB->m_first->id());
} // end if s not an intersect point
s = s->Next();
}
while(s->id() != m_first->id());
//** for testing...check number of intersections in each poly
TRACE( "boolean...phase 1 testing\n" );
int n_ints = 0;
s = m_first;
do
{
if( s->isIntersect() )
n_ints++;
s = s->Next();
} while( s->id() != m_first->id() );
int n_polyB_ints = 0;
s = polyB->m_first;
do
{
if( s->isIntersect() )
n_polyB_ints++;
s = s->Next();
} while( s->id() != polyB->m_first->id() );
if( n_ints != n_polyB_ints )
ASSERT(0);
if( n_ints%2 != 0 )
ASSERT(0);
//** end test
/*
** Phase 2 of the algorithm is to identify every intersection point as an
** entry or exit point to the other polygon. This will set the entry bits
** in each vertex object.
**
** What is really stored in the entry record for each intersection is the
** direction the algorithm should take when it arrives at that entry point.
** Depending in the operation requested (A&B, A|B, A/B, B/A) the direction is
** set as follows for entry points (f=foreward, b=Back), exit points are always set
** to the opposite:
** Enter Exit
** A B A B
** A|B b b f f
** A&B f f b b
** A\B b f f b
** B\A f b b f
**
** f = TRUE, b = FALSE when stored in the entry record
*/
BOOL A, B;
switch (oper)
{
case A_OR_B: A = FALSE; B = FALSE; break;
case A_AND_B: A = TRUE; B = TRUE; break;
case A_MINUS_B: A = FALSE; B = TRUE; break;
case B_MINUS_A: A = TRUE; B = FALSE; break;
default: A = TRUE; B = TRUE; break;
}
s = m_first;
//** testing
if( s->isIntersect() )
ASSERT(0);
//** end test
BOOL entry;
if (polyB->isInside(s)) // if we are already inside
entry = !A; // next intersection must be an exit
else // otherwise
entry = A; // next intersection must be an entry
do
{
if (s->isIntersect())
{
s->setEntry(entry);
entry = !entry;
}
s = s->Next();
}
while (s->id() != m_first->id());
/*
** Repeat for other polygon
*/
c = polyB->m_first;
if (this->isInside(c)) // if we are already inside
entry = !B; // next intersection must be an exit
else // otherwise
entry = B; // next intersection must be an entry
do
{
if (c->isIntersect())
{
c->setEntry(entry);
entry = !entry;
}
c = c->Next();
}
while (c->id() != polyB->m_first->id());
/*
** Phase 3 of the algorithm is to scan the linked lists of the
** two input polygons an construct a linked list of result
** polygons. We start at the first intersection then depending
** on whether it is an entry or exit point we continue building
** our result polygon by following the source or clip polygon
** either forwards or backwards.
*/
while (this->unckd_remain()) // Loop while unchecked intersections remain
{
vertex * v = first_unckd_intersect(); // Get the first unchecked intersect point
polygon * r = new polygon; // Create a new instance of that class
do
{
v->setChecked(); // Set checked flag true for this intersection
if (v->isEntry())
{
do
{
v = v->Next();
vertex * nv = new vertex(v->X(),v->Y(),v->Xc(),v->Yc(),v->d());
r->add(nv);
}
while (!v->isIntersect());
}
else
{
do
{
v = v->Prev();
vertex * nv = new vertex(v->X(),v->Y(),v->Xc(FALSE),v->Yc(FALSE),v->d(FALSE));
r->add(nv);
}
while (!v->isIntersect());
}
v = v->Neighbor();
}
while (!v->isChecked()); // until polygon closed
if (last) // Check in case first time thru the loop
r->m_first->setNextPoly(last); // Save ref to the last poly in the first vertex
// of this poly
last = r; // Save this polygon
} // end of while there is another intersection to check
/*
** Clean up the input polygons by deleting the intersection points
*/
res();
polyB->res();
/*
** It is possible that no intersection between the polygons was found and
** there is no result to return. In this case we make function fail
** gracefully as follows (depending on the requested operation):
**
** A|B : Return this with polyB in m_first->nextPoly
** A&B : Return this
** A\B : Return this
** B\A : return polyB
*/
polygon * p;
if (!last)
{
switch (oper)
{
case A_OR_B:
last = copy_poly();
p = polyB->copy_poly();
last->m_first->setNextPoly(p);
break;
case A_AND_B:
last = copy_poly();
break;
case A_MINUS_B:
last = copy_poly();
break;
case B_MINUS_A:
last = polyB->copy_poly();
break;
default:
last = copy_poly();
break;
}
}
else if (m_first->m_nextPoly)
{
last->m_first->m_nextPoly = m_first->NextPoly();
}
return last;
} // end of boolean function
/*
** Test if a polygon lies entirly inside this polygon
**
** First every point in the polygon is tested to determine if it is
** inside this polygon. If all points are inside, then the second
** test is performed that looks for any intersections between the
** two polygons. If no intersections are found then the polygon
** must be completely enclosed by this polygon.
*/
#if 0
function polygon::isPolyInside (p)
{
inside = TRUE;
c = p->getFirst(); // Get the first vertex in polygon p
do
{
if (!this->isInside(c)) // If vertex is NOT inside this polygon
inside = FALSE; // then set flag to false
c = c->Next(); // Get the next vertex in polygon p
}
while (c->id() != p->first->id());
if (inside)
{
c = p->getFirst(); // Get the first vertex in polygon p
s = getFirst(); // Get the first vertex in this polygon
do
{
do
{
if (this->ints(s, s->Next(),c, c->Next(), n, x, y, aS, aC))
inside = FALSE;
c = c->Next();
}
while (c->id() != p->first->id());
s = s->Next();
}
while (s->id() != m_first->id());
}
return inside;
} // end of isPolyInside
/*
** Move Polygon
**
** Translates polygon by delta X and delta Y
*/
function polygon::move (dx, dy)
{
v = getFirst();
do
{
v->setX(v->X() + dx);
v->setY(v->Y() + dy);
if (v->d() != 0)
{
v->setXc(v->Xc() + dx);
v->setYc(v->Yc() + dy);
}
v = v->Next();
}
while(v->id() != m_first->id());
} // end of move polygon
/*
** Rotate Polygon
**
** Rotates a polgon about point xr/yr by a radians
*/
function polygon::rotate (xr, yr, a)
{
this->move(-xr,-yr); // Move the polygon so that the point of
// rotation is at the origin (0,0)
if (a < 0) // We might be passed a negitive angle
a += 2*pi(); // make it positive
v = m_first;
do
{
x=v->X(); y=v->Y();
v->setX(x*cos(a) - y*sin(a)); // x' = xCos(a)-ySin(a)
v->setY(x*sin(a) + y*cos(a)); // y' = xSin(a)+yCos(a)
if (v->d() != 0)
{
x=v->Xc(); y=v->Yc();
v->setXc(x*cos(a) - y*sin(a));
v->setYc(x*sin(a) + y*cos(a));
}
v = v->Next();
}
while(v->id() != m_first->id());
this->move(xr,yr); // Move the rotated polygon back
} // end of rotate polygon
/*
** Return Bounding Rectangle for a Polygon
**
** returns a polygon object that represents the bounding rectangle
** for this polygon. Arc segments are correctly handled.
*/
function polygon::&bRect ()
{
minX = INF; minY = INF; maxX = -INF; maxY = -INF;
v = m_first;
do
{
if (v->d() != 0) // Is it an arc segment
{
vn = v->Next(); // end vertex of the arc segment
v1 = new vertex(v->Xc(), -infinity); // bottom point of vertical line thru arc center
v2 = new vertex(v->Xc(), +infinity); // top point of vertical line thru arc center
if (this->ints(v, vn, v1, v2, n, x, y, aS, aC)) // Does line intersect the arc ?
{
for (i=0; i<n; i++) // check y portion of all intersections
{
minY = min(minY, y[i], v->Y());
maxY = max(maxY, y[i], v->Y());
}
}
else // There was no intersection so bounding rect is determined
{ // by the start point only, not teh edge of the arc
minY = min(minY, v->Y());
maxY = max(maxY, v->Y());
}
v1 = NULL; v2 = NULL; // Free the memory used
h1 = new vertex(-infinity, v->Yc()); // left point of horozontal line thru arc center
h2 = new vertex(+infinity, v->Yc()); // right point of horozontal line thru arc center
if (this->ints(v, vn, h1, h2, n, x, y, aS, aC)) // Does line intersect the arc ?
{
for (i=0; i<n; i++) // check x portion of all intersections
{
minX = min(minX, x[i], v->X());
maxX = max(maxX, x[i], v->X());
}
}
else
{
minX = min(minX, v->X());
maxX = max(maxX, v->X());
}
h1 = NULL; h2 = NULL;
}
else // Straight segment so just check the vertex
{
minX = min(minX, v->X());
minY = min(minY, v->Y());
maxX = max(maxX, v->X());
maxY = max(maxY, v->Y());
}
v = v->Next();
}
while(v->id() != m_first->id());
//
// Now create an return a polygon with the bounding rectangle
//
this_class = get_class(this); // Findout the class I'm in (might be an extension of polygon)
p = new this_class; // Create a new instance of that class
p->addv(minX,minY);
p->addv(minX,maxY);
p->addv(maxX,maxY);
p->addv(maxX,minY);
return p;
} // end of bounding rectangle
#endif
// file php_polygon.cpp
// This is a port of a php class written by Brenor Brophy (see below)
/*------------------------------------------------------------------------------
** File: polygon.php
** Description: PHP class for a polygon.
** Version: 1.1
** Author: Brenor Brophy
** Email: brenor at sbcglobal dot net
** Homepage: www.brenorbrophy.com
**------------------------------------------------------------------------------
** COPYRIGHT (c) 2005 BRENOR BROPHY
**
** The source code included in this package is free software; you can
** redistribute it and/or modify it under the terms of the GNU General Public
** License as published by the Free Software Foundation. This license can be
** read at:
**
** http://www.opensource.org/licenses/gpl-license.php
**
** This program is distributed in the hope that it will be useful, but WITHOUT
** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
** FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
**------------------------------------------------------------------------------
**
** Based on the paper "Efficient Clipping of Arbitary Polygons" by Gunther
** Greiner (greiner at informatik dot uni-erlangen dot de) and Kai Hormann
** (hormann at informatik dot tu-clausthal dot de), ACM Transactions on Graphics
** 1998;17(2):71-83.
**
** Available at: www.in.tu-clausthal.de/~hormann/papers/clipping.pdf
**
** Another useful site describing the algorithm and with some example
** C code by Ionel Daniel Stroe is at:
**
** http://davis.wpi.edu/~matt/courses/clipping/
**
** The algorithm is extended by Brenor Brophy to allow polygons with
** arcs between vertices.
**
** Rev History
** -----------------------------------------------------------------------------
** 1.0 08/25/2005 Initial Release
** 1.1 09/04/2005 Added Move(), Rotate(), isPolyInside() and bRect() methods.
** Added software license language to header comments
*/
//#include "stdafx.h"
#include <stdio.h>
#include <math.h>
#include "php_polygon_vertex.h"
#include "php_polygon.h"
const double PT = 0.99999;
//const double eps = (1.0 - PT)/10.0;
const double eps = 0.0;
polygon::polygon( vertex * first )
{
m_first = first;
m_cnt = 0;
}
polygon::~polygon()
{
while( m_cnt > 1 )
{
vertex * v = getFirst();
del( v->m_nextV );
}
if( m_first )
{
delete m_first;
}
}
vertex * polygon::getFirst()
{
return m_first;
}
polygon * polygon::NextPoly()
{
return m_first->NextPoly();
}
/*
** Add a vertex object to the polygon (vertex is added at the "end" of the list)
** Which because polygons are closed lists means it is added just before the first
** vertex.
*/
void polygon::add( vertex * nv )
{
if ( m_cnt == 0 ) // If this is the first vertex in the polygon
{
m_first = nv; // Save a reference to it in the polygon
m_first->setNext(nv); // Set its pointer to point to itself
m_first->setPrev(nv); // because it is the only vertex in the list
segment * ps = m_first->Nseg(); // Get ref to the Next segment object
m_first->setPseg(ps); // and save it as Prev segment as well
}
else // At least one other vertex already exists
{
// p <-> nv <-> n
// ps ns
vertex * n = m_first; // Get a ref to the first vertex in the list
vertex * p = n->Prev(); // Get ref to previous vertex
n->setPrev(nv); // Add at end of list (just before first)
nv->setNext(n); // link the new vertex to it
nv->setPrev(p); // link to the pervious EOL vertex
p->setNext(nv); // And finally link the previous EOL vertex
// Segments
segment * ns = nv->Nseg(); // Get ref to the new next segment
segment * ps = p->Nseg(); // Get ref to the previous segment
n->setPseg(ns); // Set new previous seg for m_first
nv->setPseg(ps); // Set previous seg of the new vertex
}
m_cnt++; // Increment the count of vertices
}
/*
** Create a vertex and then add it to the polygon
*/
void polygon::addv ( double x, double y,
double xc, double yc, int d )
{
vertex * nv = new vertex( x, y, xc, yc, d );
add( nv );
}
/*
** Delete a vertex object from the polygon. This is not used by the main algorithm
** but instead is used to clean-up a polygon so that a second boolean operation can
** be performed.
*/
vertex * polygon::del( vertex * v )
{
// p <-> v <-> n Will delete v and ns
// ps ns
vertex * p = v->Prev(); // Get ref to previous vertex
vertex * n = v->Next(); // Get ref to next vertex
p->setNext(n); // Link previous forward to next
n->setPrev(p); // Link next back to previous
// Segments
segment * ps = p->Nseg(); // Get ref to previous segment
segment * ns = v->Nseg(); // Get ref to next segment
n->setPseg(ps); // Link next back to previous segment
delete ns; //AMW
v->m_nSeg = NULL; // AMW
delete v; //AMW
// ns = NULL;
// v = NULL; // Free the memory
m_cnt--; // One less vertex
return n; // Return a ref to the next valid vertex
}
/*
** Reset Polygon - Deletes all intersection vertices. This is used to
** restore a polygon that has been processed by the boolean method
** so that it can be processed again.
*/
void polygon::res()
{
vertex * v = getFirst(); // Get the first vertex
do
{
v = v->Next(); // Get the next vertex in the polygon
while (v->isIntersect()) // Delete all intersection vertices
v = del(v);
}
while (v->id() != m_first->id());
}
/*
** Copy Polygon - Returns a reference to a new copy of the poly object
** including all its vertices & their segments
*/
polygon * polygon::copy_poly()
{
polygon * n = new polygon; // Create a new instance of this class
vertex * v = getFirst();
do
{
n->addv(v->X(),v->Y(),v->Xc(),v->Yc(),v->d());
v = v->Next();
}
while (v->id() != m_first->id());
return n;
}
/*
** Insert and Sort a vertex between a specified pair of vertices (start and end)
**
** This function inserts a vertex (most likely an intersection point) between two
** other vertices. These other vertices cannot be intersections (that is they must
** be actual vertices of the original polygon). If there are multiple intersection
** points between the two vertices then the new vertex is inserted based on its
** alpha value.
*/
void polygon::insertSort( vertex * nv, vertex * s, vertex * e )
{
vertex * c = s; // Set current to the starting vertex
// Move current past any intersections
// whose alpha is lower but don't go past
// the end vertex
while( c->id() != e->id() && c->Alpha() < nv->Alpha() )
c = c->Next();
// p <-> nv <-> c
nv->setNext(c); // Link new vertex forward to curent one
vertex * p = c->Prev(); // Get a link to the previous vertex
nv->setPrev(p); // Link the new vertex back to the previous one
p->setNext(nv); // Link previous vertex forward to new vertex
c->setPrev(nv); // Link current vertex back to the new vertex
// Segments
segment * ps = p->Nseg();
nv->setPseg(ps);
segment * ns = nv->Nseg();
c->setPseg(ns);
m_cnt++; // Just added a new vertex
}
/*
** return the next non intersecting vertex after the one specified
*/
vertex * polygon::nxt( vertex * v )
{
vertex * c = v; // Initialize current vertex
while (c && c->isIntersect()) // Move until a non-intersection
c = c->Next(); // vertex if found
return c; // return that vertex
}
/*
** Check if any unchecked intersections remain in the polygon. The boolean
** method is complete when all intersections have been checked.
*/
BOOL polygon::unckd_remain()
{
BOOL remain = FALSE;
vertex * v = m_first;
do
{
if (v->isIntersect() && !v->isChecked())
remain = TRUE; // Set if an unchecked intersection is found
v = v->Next();
}
while (v->id() != m_first->id());
return remain;
}
/*
** Return a ref to the first unchecked intersection point in the polygon.
** If none are found then just the first vertex is returned.
*/
vertex * polygon::first_unckd_intersect()
{
vertex * v = m_first;
do // Do-While
{ // Not yet reached end of the polygon
v = v->Next(); // AND the vertex if NOT an intersection
} // OR it IS an intersection, but has been checked already
while(v->id() != m_first->id() && ( !v->isIntersect() || ( v->isIntersect() && v->isChecked() ) ) );
return v;
}
/*
** Return the distance between two points
*/
double polygon::dist( double x1, double y1, double x2, double y2 )
{
return sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
}
/*
** Calculate the angle between 2 points, where Xc,Yc is the center of a circle
** and x,y is a point on its circumference. All angles are relative to
** the 3 O'Clock position. Result returned in radians
*/
double polygon::angle( double xc, double yc, double x1, double y1 )
{
double d = dist(xc, yc, x1, y1); // calc distance between two points
double a1;
if ( asin( (y1-yc)/d ) >= 0 )
a1 = acos( (x1-xc)/d );
else
a1 = 2*PI - acos( (x1-xc)/d );
return a1;
}
/*
** Return Alpha value for an Arc
**
** X1/Y1 & X2/Y2 are the end points of the arc, Xc/Yc is the center & Xi/Yi
** the intersection point on the arc. d is the direction of the arc
*/
double polygon::aAlpha( double x1, double y1, double x2, double y2,
double xc, double yc, double xi, double yi, double d )
{
double sa = angle(xc, yc, x1, y1); // Start Angle
double ea = angle(xc, yc, x2, y2); // End Angle
double ia = angle(xc, yc, xi, yi); // Intersection Angle
double arc, aint;
if (d == 1) // Anti-Clockwise
{
arc = ea - sa;
aint = ia - sa;
}
else // Clockwise
{
arc = sa - ea;
aint = sa - ia;
}
if (arc < 0)
arc += 2*PI;
if (aint < 0)
aint += 2*PI;
double a = aint/arc;
return a;
}
/*
** This function handles the degenerate case where a vertex of one
** polygon lies directly on an edge of the other. This case can
** also occur during the isInside() function, where the search
** line exactly intersects with a vertex. The function works
** by shortening the line by a tiny amount.
*/
void polygon::perturb( vertex * p1, vertex * p2, vertex * q1, vertex * q2,
double aP, double aQ )
{
// if (aP == 0) // Move vertex p1 closer to p2
if( abs(aP) <= eps ) // Move vertex p1 closer to p2
{
p1->setX(p1->X() + (1-PT) * (p2->X() - p1->X()));
p1->setY(p1->Y() + (1-PT) * (p2->Y() - p1->Y()));
}
// else if (aP == 1) // Move vertex p2 closer to p1
else if( abs(1-aP) <= eps ) // Move vertex p2 closer to p1
{
p2->setX(p1->X() + PT * (p2->X() - p1->X()));
p2->setY(p1->Y() + PT * (p2->Y() - p1->Y()));
}
//** else if (aQ == 0) // Move vertex q1 closer to q2
if( abs(aQ) <= eps ) // Move vertex q1 closer to q2
{
q1->setX(q1->X() + (1-PT) * (q2->X() - q1->X()));
q1->setY(q1->Y() + (1-PT) * (q2->Y() - q1->Y()));
}
//** else if (aQ == 1) // Move vertex q2 closer to q1
else if( abs(1-aQ) <= eps ) // Move vertex q2 closer to q1
{
q2->setX(q1->X() + PT * (q2->X() - q1->X()));
q2->setY(q1->Y() + PT * (q2->Y() - q1->Y()));
}
}
/*
** Determine the intersection between two pairs of vertices p1/p2, q1/q2
**
** Either or both of the segments passed to this function could be arcs.
** Thus we must first determine if the intersection is line/line, arc/line
** or arc/arc. Then apply the correct math to calculate the intersection(s).
**
** Line/Line can have 0 (no intersection) or 1 intersection
** Line/Arc and Arc/Arc can have 0, 1 or 2 intersections
**
** The function returns TRUE is any intersections are found
** The number found is returned in n
** The arrays ix[], iy[], alphaP[] & alphaQ[] return the intersection points
** and their associated alpha values.
*/
BOOL polygon::ints( vertex * p1, vertex * p2, vertex * q1, vertex * q2,
int * n, double ix[], double iy[], double alphaP[], double alphaQ[] )
{
BOOL found = FALSE;
*n = 0; // No intersections found yet
int pt = p1->d();
int qt = q1->d(); // Do we have Arcs or Lines?
if (pt == 0 && qt == 0) // Is it line/Line ?
{
/* LINE/LINE
** Algorithm from: http://astronomy.swin.edu.au/~pbourke/geometry/lineline2d/
*/
double x1 = p1->X();
double y1 = p1->Y();
double x2 = p2->X();
double y2 = p2->Y();
double x3 = q1->X();
double y3 = q1->Y();
double x4 = q2->X();
double y4 = q2->Y();
double d = ((y4-y3)*(x2-x1)-(x4-x3)*(y2-y1));
if (d != 0)
{ // The lines intersect at a point somewhere
double ua = ((x4-x3)*(y1-y3)-(y4-y3)*(x1-x3))/d;
double ub = ((x2-x1)*(y1-y3)-(y2-y1)*(x1-x3))/d;
TRACE( " ints: ua = %.17f, ub = %.17f\n", ua, ub );
// The values of $ua and $ub tell us where the intersection occurred.
// A value between 0 and 1 means the intersection occurred within the
// line segment.
// A value less than 0 or greater than 1 means the intersection occurred
// outside the line segment
// A value of exactly 0 or 1 means the intersection occurred right at the
// start or end of the line segment. For our purposes we will consider this
// NOT to be an intersection and we will move the vertex a tiny distance
// away from the intersecting line.
// if( ua == 0 || ua == 1 || ub == 0 || ub == 1 )
if( abs(ua)<=eps || abs(1.0-ua)<=eps || abs(ub)<=eps || abs(1.0-ub)<=eps )
{
// Degenerate case - vertex touches a line
perturb(p1, p2, q1, q2, ua, ub);
//** for testing, see if we have successfully resolved the degeneracy
{
double tx1 = p1->X();
double ty1 = p1->Y();
double tx2 = p2->X();
double ty2 = p2->Y();
double tx3 = q1->X();
double ty3 = q1->Y();
double tx4 = q2->X();
double ty4 = q2->Y();
double td = ((ty4-ty3)*(tx2-tx1)-(tx4-tx3)*(ty2-ty1));
if (td != 0)
{
// The lines intersect at a point somewhere
double tua = ((tx4-tx3)*(ty1-ty3)-(ty4-ty3)*(tx1-tx3))/td;
double tub = ((tx2-tx1)*(ty1-ty3)-(ty2-ty1)*(tx1-tx3))/td;
if( abs(tua)<=eps || abs(1.0-tua)<=eps || abs(tub)<=eps || abs(1.0-tub)<=eps )
ASSERT(0);
else if( (tua > 0 && tua < 1) && (tub > 0 && tub < 1) )
ASSERT(0);
TRACE( " perturb:\n new s = (%f,%f) to (%f,%f)\n new c = (%f,%f) to (%f,%f)\n new ua = %.17f, ub = %.17f\n",
tx1, ty1, tx2, ty2, tx3, ty3, tx4, ty4, tua, tub );
}
}
//** end test
found = FALSE;
}
else if ((ua > 0 && ua < 1) && (ub > 0 && ub < 1))
{
// Intersection occurs on both line segments
double x = x1 + ua*(x2-x1);
double y = y1 + ua*(y2-y1);
iy[0] = y;
ix[0] = x;
alphaP[0] = ua;
alphaQ[0] = ub;
*n = 1;
found = TRUE;
}
else
{
// The lines do not intersect
found = FALSE;
}
}
else
{
// The lines do not intersect (they are parallel)
found = FALSE;
}
} // End of find Line/Line intersection
else if (pt != 0 && qt != 0) // Is it Arc/Arc?
{
/* ARC/ARC
** Algorithm from: http://astronomy.swin.edu.au/~pbourke/geometry/2circle/
*/
double x0 = p1->Xc();
double y0 = p1->Yc(); // Center of first Arc
double r0 = dist(x0,y0,p1->X(),p1->Y()); // Calc the radius
double x1 = q1->Xc();
double y1 = q1->Yc(); // Center of second Arc
double r1 = dist(x1,y1,q1->X(),q1->Y()); // Calc the radius
double dx = x1 - x0; // dx and dy are the vertical and horizontal
double dy = y1 - y0; // distances between the circle centers.
double d = sqrt((dy*dy) + (dx*dx)); // Distance between the centers.
if(d > (r0 + r1)) // Check for solvability.
{ // no solution. circles do not intersect.
found = FALSE;
}
else if(d < abs(r0 - r1) )
{ // no solution. one circle inside the other
found = FALSE;
}
else
{
/*
** 'xy2' is the point where the line through the circle intersection
** points crosses the line between the circle centers.
*/
double a = ((r0*r0)-(r1*r1)+(d*d))/(2.0*d); // Calc the distance from xy0 to xy2.
double x2 = x0 + (dx * a/d); // Determine the coordinates of xy2.
double y2 = y0 + (dy * a/d);
if (d == (r0 + r1)) // Arcs touch at xy2 exactly (unlikely)
{
alphaP[0] = aAlpha(p1->X(), p1->Y(), p2->X(), p2->Y(), x0, y0, x2, y2, pt);
alphaQ[0] = aAlpha(q1->X(), q1->Y(), q2->X(), q2->Y(), x1, y1, x2, y2, qt);
if ((alphaP[0] >0 && alphaP[0] < 1) && (alphaQ[0] >0 && alphaQ[0] < 1))
{
ix[0] = x2;
iy[0] = y2;
*n = 1; found = TRUE;
}
}
else // Arcs intersect at two points
{
double alP[2], alQ[2];
double h = sqrt((r0*r0) - (a*a)); // Calc the distance from xy2 to either
// of the intersection points.
double rx = -dy * (h/d); // Now determine the offsets of the
double ry = dx * (h/d);
// intersection points from xy2
double x[2], y[2];
x[0] = x2 + rx; x[1] = x2 - rx; // Calc the absolute intersection points.
y[0] = y2 + ry; y[1] = y2 - ry;
alP[0] = aAlpha(p1->X(), p1->Y(), p2->X(), p2->Y(), x0, y0, x[0], y[0], pt);
alQ[0] = aAlpha(q1->X(), q1->Y(), q2->X(), q2->Y(), x1, y1, x[0], y[0], qt);
alP[1] = aAlpha(p1->X(), p1->Y(), p2->X(), p2->Y(), x0, y0, x[1], y[1], pt);
alQ[1] = aAlpha(q1->X(), q1->Y(), q2->X(), q2->Y(), x1, y1, x[1], y[1], qt);
for (int i=0; i<=1; i++)
if ((alP[i] >0 && alP[i] < 1) && (alQ[i] >0 && alQ[i] < 1))
{
ix[*n] = x[i];
iy[*n] = y[i];
alphaP[*n] = alP[i];
alphaQ[*n] = alQ[i];
*n++;
found = TRUE;
}
}
}
} // End of find Arc/Arc intersection
else // It must be Arc/Line
{
/* ARC/LINE
** Algorithm from: http://astronomy.swin.edu.au/~pbourke/geometry/sphereline/
*/
double d, x1, x2, xc, xs, xe;
double y1, y2, yc, ys, ye;
if (pt == 0) // Segment p1,p2 is the line
{ // Segment q1,q2 is the arc
x1 = p1->X();
y1 = p1->Y();
x2 = p2->X();
y2 = p2->Y();
xc = q1->Xc();
yc = q1->Yc();
xs = q1->X();
ys = q1->Y();
xe = q2->X();
ye = q2->Y();
d = qt;
}
else // Segment q1,q2 is the line
{ // Segment p1,p2 is the arc
x1 = q1->X(); y1 = q1->Y();
x2 = q2->X(); y2 = q2->Y();
xc = p1->Xc(); yc = p1->Yc();
xs = p1->X(); ys = p1->Y();
xe = p2->X(); ye = p2->Y();
d = pt;
}
double r = dist(xc,yc,xs,ys);
double a = pow((x2 - x1),2)+pow((y2 - y1),2);
double b = 2* ( (x2 - x1)*(x1 - xc)
+ (y2 - y1)*(y1 - yc) );
double c = pow(xc,2) + pow(yc,2) +
pow(x1,2) + pow(y1,2) -
2* ( xc*x1 + yc*y1) - pow(r,2);
double i = b * b - 4 * a * c;
if ( i < 0.0 ) // no intersection
{
found = FALSE;
}
else if ( i == 0.0 ) // one intersection
{
double mu = -b/(2*a);
double x = x1 + mu*(x2-x1);
double y = y1 + mu*(y2-y1);
double al = mu; // Line Alpha
double aa = this->aAlpha(xs, ys, xe, ye, xc, yc, x, y, d); // Arc Alpha
if ((al >0 && al <1)&&(aa >0 && aa <1))
{
ix[0] = x; iy[0] = y;
*n = 1;
found = TRUE;
if (pt == 0)
{
alphaP[0] = al; alphaQ[0] = aa;
}
else
{
alphaP[0] = aa; alphaQ[0] = al;
}
}
}
else if ( i > 0.0 ) // two intersections
{
double mu[2], x[2], y[2], al[2], aa[2];
mu[0] = (-b + sqrt( pow(b,2) - 4*a*c )) / (2*a); // first intersection
x[0] = x1 + mu[0]*(x2-x1);
y[0] = y1 + mu[0]*(y2-y1);
mu[1] = (-b - sqrt(pow(b,2) - 4*a*c )) / (2*a); // second intersection
x[1] = x1 + mu[1]*(x2-x1);
y[1] = y1 + mu[1]*(y2-y1);
al[0] = mu[0];
aa[0] = aAlpha(xs, ys, xe, ye, xc, yc, x[0], y[0], d);
al[1] = mu[1];
aa[1] = aAlpha(xs, ys, xe, ye, xc, yc, x[1], y[1], d);
for (int i=0; i<=1; i++)
if ((al[i] >0 && al[i] < 1) && (aa[i] >0 && aa[i] < 1))
{
ix[*n] = x[i];
iy[*n] = y[i];
if (pt == 0)
{
alphaP[*n] = al[i];
alphaQ[*n] = aa[i];
}
else
{
alphaP[*n] = aa[i];
alphaQ[*n] = al[i];
}
*n++;
found = TRUE;
}
}
} // End of find Arc/Line intersection
return found;
} // end of intersect function
/*
** Test if a vertex lies inside the polygon
**
** This function calculates the "winding" number for the point. This number
** represents the number of times a ray emitted from the point to infinity
** intersects any edge of the polygon. An even winding number means the point
** lies OUTSIDE the polygon, an odd number means it lies INSIDE it.
**
** Right now infinity is set to -10000000, some people might argue that infinity
** actually is a bit bigger. Those people have no lives.
**
** Allan Wright 4/16/2006: I guess I have no life: I had to increase it to -1000000000
*/
BOOL polygon::isInside( vertex * v )
{
//** modified for testing
if( v->isIntersect() )
ASSERT(0);
int winding_number = 0;
int winding_number2 = 0;
int winding_number3 = 0;
int winding_number4 = 0;
//** vertex * point_at_infinity = new vertex(-10000000,v->Y()); // Create point at infinity
vertex * point_at_infinity = new vertex(-1000000000,-50000000); // Create point at infinity
vertex * point_at_infinity2 = new vertex(1000000000,+50000000); // Create point at infinity
vertex * point_at_infinity3 = new vertex(500000000,1000000000); // Create point at infinity
vertex * point_at_infinity4 = new vertex(-500000000,1000000000); // Create point at infinity
vertex * q = m_first; // End vertex of a line segment in polygon
do
{
if (!q->isIntersect())
{
int n;
double x[2], y[2], aP[2], aQ[2];
if( ints( point_at_infinity, v, q, nxt(q->Next()), &n, x, y, aP, aQ ) )
winding_number += n; // Add number of intersections found
if( ints( point_at_infinity2, v, q, nxt(q->Next()), &n, x, y, aP, aQ ) )
winding_number2 += n; // Add number of intersections found
if( ints( point_at_infinity3, v, q, nxt(q->Next()), &n, x, y, aP, aQ ) )
winding_number3 += n; // Add number of intersections found
if( ints( point_at_infinity4, v, q, nxt(q->Next()), &n, x, y, aP, aQ ) )
winding_number4 += n; // Add number of intersections found
}
q = q->Next();
}
while( q->id() != m_first->id() );
delete point_at_infinity;
delete point_at_infinity2;
if( winding_number%2 != winding_number2%2
|| winding_number3%2 != winding_number4%2
|| winding_number%2 != winding_number3%2 )
ASSERT(0);
if( winding_number%2 == 0 ) // Check even or odd
return FALSE; // even == outside
else
return TRUE; // odd == inside
}
/*
** Execute a Boolean operation on a polygon
**
** This is the key method. It allows you to AND/OR this polygon with another one
** (equvalent to a UNION or INTERSECT operation. You may also subtract one from
** the other (same as DIFFERENCE). Given two polygons A, B the following operations
** may be performed:
**
** A|B ... A OR B (Union of A and B)
** A&B ... A AND B (Intersection of A and B)
** A\B ... A - B
** B\A ... B - A
**
** A is the object and B is the polygon passed to the method.
*/
polygon * polygon::boolean( polygon * polyB, int oper )
{
polygon * last = NULL;
vertex * s = m_first; // First vertex of the subject polygon
vertex * c = polyB->getFirst(); // First vertex of the "clip" polygon
/*
** Phase 1 of the algoritm is to find all intersection points between the two
** polygons. A new vertex is created for each intersection and it is added to
** the linked lists for both polygons. The "neighbor" reference in each vertex
** stores the link between the same intersection point in each polygon.
*/
TRACE( "boolean...phase 1\n" );
do
{
TRACE( "s=(%f,%f) to (%f,%f) I=%d\n",
s->m_x, s->m_y, s->m_nextV->m_x, s->m_nextV->m_y, s->m_intersect );
if (!s->isIntersect())
{
do
{
TRACE( " c=(%f,%f) to (%f,%f) I=%d\n",
c->m_x, c->m_y, c->m_nextV->m_x, c->m_nextV->m_y, c->m_intersect );
if (!c->isIntersect())
{
int n;
double ix[2], iy[2], alphaS[2], alphaC[2];
BOOL bInt = ints(s, nxt(s->Next()),c, polyB->nxt(c->Next()), &n, ix, iy, alphaS, alphaC);
if( bInt )
{
TRACE( " int at (%f,%f) aS = %.17f, aC = %.17f\n", ix[0], iy[0], alphaS[0], alphaC[0] );
for (int i=0; i<n; i++)
{
vertex * is = new vertex(ix[i], iy[i], s->Xc(), s->Yc(), s->d(), NULL, NULL, NULL, TRUE, NULL, alphaS[i], FALSE, FALSE);
vertex * ic = new vertex(ix[i], iy[i], c->Xc(), c->Yc(), c->d(), NULL, NULL, NULL, TRUE, NULL, alphaC[i], FALSE, FALSE);
is->setNeighbor(ic);
ic->setNeighbor(is);
insertSort(is, s, this->nxt(s->Next()));
polyB->insertSort(ic, c, polyB->nxt(c->Next()));
}
}
} // end if c is not an intersect point
c = c->Next();
}
while (c->id() != polyB->m_first->id());
} // end if s not an intersect point
s = s->Next();
}
while(s->id() != m_first->id());
//** for testing...check number of intersections in each poly
TRACE( "boolean...phase 1 testing\n" );
int n_ints = 0;
s = m_first;
do
{
if( s->isIntersect() )
n_ints++;
s = s->Next();
} while( s->id() != m_first->id() );
int n_polyB_ints = 0;
s = polyB->m_first;
do
{
if( s->isIntersect() )
n_polyB_ints++;
s = s->Next();
} while( s->id() != polyB->m_first->id() );
if( n_ints != n_polyB_ints )
ASSERT(0);
if( n_ints%2 != 0 )
ASSERT(0);
//** end test
/*
** Phase 2 of the algorithm is to identify every intersection point as an
** entry or exit point to the other polygon. This will set the entry bits
** in each vertex object.
**
** What is really stored in the entry record for each intersection is the
** direction the algorithm should take when it arrives at that entry point.
** Depending in the operation requested (A&B, A|B, A/B, B/A) the direction is
** set as follows for entry points (f=foreward, b=Back), exit points are always set
** to the opposite:
** Enter Exit
** A B A B
** A|B b b f f
** A&B f f b b
** A\B b f f b
** B\A f b b f
**
** f = TRUE, b = FALSE when stored in the entry record
*/
BOOL A, B;
switch (oper)
{
case A_OR_B: A = FALSE; B = FALSE; break;
case A_AND_B: A = TRUE; B = TRUE; break;
case A_MINUS_B: A = FALSE; B = TRUE; break;
case B_MINUS_A: A = TRUE; B = FALSE; break;
default: A = TRUE; B = TRUE; break;
}
s = m_first;
//** testing
if( s->isIntersect() )
ASSERT(0);
//** end test
BOOL entry;
if (polyB->isInside(s)) // if we are already inside
entry = !A; // next intersection must be an exit
else // otherwise
entry = A; // next intersection must be an entry
do
{
if (s->isIntersect())
{
s->setEntry(entry);
entry = !entry;
}
s = s->Next();
}
while (s->id() != m_first->id());
/*
** Repeat for other polygon
*/
c = polyB->m_first;
if (this->isInside(c)) // if we are already inside
entry = !B; // next intersection must be an exit
else // otherwise
entry = B; // next intersection must be an entry
do
{
if (c->isIntersect())
{
c->setEntry(entry);
entry = !entry;
}
c = c->Next();
}
while (c->id() != polyB->m_first->id());
/*
** Phase 3 of the algorithm is to scan the linked lists of the
** two input polygons an construct a linked list of result
** polygons. We start at the first intersection then depending
** on whether it is an entry or exit point we continue building
** our result polygon by following the source or clip polygon
** either forwards or backwards.
*/
while (this->unckd_remain()) // Loop while unchecked intersections remain
{
vertex * v = first_unckd_intersect(); // Get the first unchecked intersect point
polygon * r = new polygon; // Create a new instance of that class
do
{
v->setChecked(); // Set checked flag true for this intersection
if (v->isEntry())
{
do
{
v = v->Next();
vertex * nv = new vertex(v->X(),v->Y(),v->Xc(),v->Yc(),v->d());
r->add(nv);
}
while (!v->isIntersect());
}
else
{
do
{
v = v->Prev();
vertex * nv = new vertex(v->X(),v->Y(),v->Xc(FALSE),v->Yc(FALSE),v->d(FALSE));
r->add(nv);
}
while (!v->isIntersect());
}
v = v->Neighbor();
}
while (!v->isChecked()); // until polygon closed
if (last) // Check in case first time thru the loop
r->m_first->setNextPoly(last); // Save ref to the last poly in the first vertex
// of this poly
last = r; // Save this polygon
} // end of while there is another intersection to check
/*
** Clean up the input polygons by deleting the intersection points
*/
res();
polyB->res();
/*
** It is possible that no intersection between the polygons was found and
** there is no result to return. In this case we make function fail
** gracefully as follows (depending on the requested operation):
**
** A|B : Return this with polyB in m_first->nextPoly
** A&B : Return this
** A\B : Return this
** B\A : return polyB
*/
polygon * p;
if (!last)
{
switch (oper)
{
case A_OR_B:
last = copy_poly();
p = polyB->copy_poly();
last->m_first->setNextPoly(p);
break;
case A_AND_B:
last = copy_poly();
break;
case A_MINUS_B:
last = copy_poly();
break;
case B_MINUS_A:
last = polyB->copy_poly();
break;
default:
last = copy_poly();
break;
}
}
else if (m_first->m_nextPoly)
{
last->m_first->m_nextPoly = m_first->NextPoly();
}
return last;
} // end of boolean function
/*
** Test if a polygon lies entirly inside this polygon
**
** First every point in the polygon is tested to determine if it is
** inside this polygon. If all points are inside, then the second
** test is performed that looks for any intersections between the
** two polygons. If no intersections are found then the polygon
** must be completely enclosed by this polygon.
*/
#if 0
function polygon::isPolyInside (p)
{
inside = TRUE;
c = p->getFirst(); // Get the first vertex in polygon p
do
{
if (!this->isInside(c)) // If vertex is NOT inside this polygon
inside = FALSE; // then set flag to false
c = c->Next(); // Get the next vertex in polygon p
}
while (c->id() != p->first->id());
if (inside)
{
c = p->getFirst(); // Get the first vertex in polygon p
s = getFirst(); // Get the first vertex in this polygon
do
{
do
{
if (this->ints(s, s->Next(),c, c->Next(), n, x, y, aS, aC))
inside = FALSE;
c = c->Next();
}
while (c->id() != p->first->id());
s = s->Next();
}
while (s->id() != m_first->id());
}
return inside;
} // end of isPolyInside
/*
** Move Polygon
**
** Translates polygon by delta X and delta Y
*/
function polygon::move (dx, dy)
{
v = getFirst();
do
{
v->setX(v->X() + dx);
v->setY(v->Y() + dy);
if (v->d() != 0)
{
v->setXc(v->Xc() + dx);
v->setYc(v->Yc() + dy);
}
v = v->Next();
}
while(v->id() != m_first->id());
} // end of move polygon
/*
** Rotate Polygon
**
** Rotates a polgon about point xr/yr by a radians
*/
function polygon::rotate (xr, yr, a)
{
this->move(-xr,-yr); // Move the polygon so that the point of
// rotation is at the origin (0,0)
if (a < 0) // We might be passed a negitive angle
a += 2*pi(); // make it positive
v = m_first;
do
{
x=v->X(); y=v->Y();
v->setX(x*cos(a) - y*sin(a)); // x' = xCos(a)-ySin(a)
v->setY(x*sin(a) + y*cos(a)); // y' = xSin(a)+yCos(a)
if (v->d() != 0)
{
x=v->Xc(); y=v->Yc();
v->setXc(x*cos(a) - y*sin(a));
v->setYc(x*sin(a) + y*cos(a));
}
v = v->Next();
}
while(v->id() != m_first->id());
this->move(xr,yr); // Move the rotated polygon back
} // end of rotate polygon
/*
** Return Bounding Rectangle for a Polygon
**
** returns a polygon object that represents the bounding rectangle
** for this polygon. Arc segments are correctly handled.
*/
function polygon::&bRect ()
{
minX = INF; minY = INF; maxX = -INF; maxY = -INF;
v = m_first;
do
{
if (v->d() != 0) // Is it an arc segment
{
vn = v->Next(); // end vertex of the arc segment
v1 = new vertex(v->Xc(), -infinity); // bottom point of vertical line thru arc center
v2 = new vertex(v->Xc(), +infinity); // top point of vertical line thru arc center
if (this->ints(v, vn, v1, v2, n, x, y, aS, aC)) // Does line intersect the arc ?
{
for (i=0; i<n; i++) // check y portion of all intersections
{
minY = min(minY, y[i], v->Y());
maxY = max(maxY, y[i], v->Y());
}
}
else // There was no intersection so bounding rect is determined
{ // by the start point only, not teh edge of the arc
minY = min(minY, v->Y());
maxY = max(maxY, v->Y());
}
v1 = NULL; v2 = NULL; // Free the memory used
h1 = new vertex(-infinity, v->Yc()); // left point of horozontal line thru arc center
h2 = new vertex(+infinity, v->Yc()); // right point of horozontal line thru arc center
if (this->ints(v, vn, h1, h2, n, x, y, aS, aC)) // Does line intersect the arc ?
{
for (i=0; i<n; i++) // check x portion of all intersections
{
minX = min(minX, x[i], v->X());
maxX = max(maxX, x[i], v->X());
}
}
else
{
minX = min(minX, v->X());
maxX = max(maxX, v->X());
}
h1 = NULL; h2 = NULL;
}
else // Straight segment so just check the vertex
{
minX = min(minX, v->X());
minY = min(minY, v->Y());
maxX = max(maxX, v->X());
maxY = max(maxY, v->Y());
}
v = v->Next();
}
while(v->id() != m_first->id());
//
// Now create an return a polygon with the bounding rectangle
//
this_class = get_class(this); // Findout the class I'm in (might be an extension of polygon)
p = new this_class; // Create a new instance of that class
p->addv(minX,minY);
p->addv(minX,maxY);
p->addv(maxX,maxY);
p->addv(maxX,minY);
return p;
} // end of bounding rectangle
#endif
polygon/php_polygon.h
View file @ 4ce4631d
// file php_polygon.h
// See comments in php_polygon.cpp
#ifndef PHP_POLYGON_H
#define PHP_POLYGON_H
class vertex;
class segment;
#define infinity 100000000 // for places that are far far away
#define PI 3.14159265359
enum{ A_OR_B, A_AND_B, A_MINUS_B, B_MINUS_A };
class polygon
{
public:
/*------------------------------------------------------------------------------
** This class manages a doubly linked list of vertex objects that represents
** a polygon. The class consists of basic methods to manage the list
** and methods to implement boolean operations between polygon objects.
*/
vertex * m_first; // Reference to first vertex in the linked list
int m_cnt; // Tracks number of vertices in the polygon
polygon( vertex * first = NULL );
~polygon();
vertex * getFirst();
polygon * NextPoly();
void add( vertex * nv );
void addv( double x, double y,
double xc=0, double yc=0, int d=0);
vertex * del( vertex * v );
void res();
polygon * copy_poly();
void insertSort( vertex * nv, vertex * s, vertex * e );
vertex * nxt( vertex * v );
BOOL unckd_remain();
vertex * first_unckd_intersect();
double dist( double x1, double y1, double x2, double y2 );
double angle( double xc, double yc, double x1, double y1 );
double aAlpha( double x1, double y1, double x2, double y2,
double xc, double yc, double xi, double yi, double d );
void perturb( vertex * p1, vertex * p2, vertex * q1, vertex * q2,
double aP, double aQ );
BOOL ints( vertex * p1, vertex * p2, vertex * q1, vertex * q2,
int * n, double ix[], double iy[], double alphaP[], double alphaQ[] );
BOOL isInside ( vertex * v );
polygon * boolean( polygon * polyB, int oper );
#if 0
function isPolyInside (p);
function move (dx, dy);
function rotate (xr, yr, a);
function &bRect ();
#endif
}; //end of class polygon
#endif // ifndef PHP_POLYGON_H
// file php_polygon.h
// See comments in php_polygon.cpp
#ifndef PHP_POLYGON_H
#define PHP_POLYGON_H
class vertex;
class segment;
#define infinity 100000000 // for places that are far far away
#define PI 3.14159265359
enum{ A_OR_B, A_AND_B, A_MINUS_B, B_MINUS_A };
class polygon
{
public:
/*------------------------------------------------------------------------------
** This class manages a doubly linked list of vertex objects that represents
** a polygon. The class consists of basic methods to manage the list
** and methods to implement boolean operations between polygon objects.
*/
vertex * m_first; // Reference to first vertex in the linked list
int m_cnt; // Tracks number of vertices in the polygon
polygon( vertex * first = NULL );
~polygon();
vertex * getFirst();
polygon * NextPoly();
void add( vertex * nv );
void addv( double x, double y,
double xc=0, double yc=0, int d=0);
vertex * del( vertex * v );
void res();
polygon * copy_poly();
void insertSort( vertex * nv, vertex * s, vertex * e );
vertex * nxt( vertex * v );
BOOL unckd_remain();
vertex * first_unckd_intersect();
double dist( double x1, double y1, double x2, double y2 );
double angle( double xc, double yc, double x1, double y1 );
double aAlpha( double x1, double y1, double x2, double y2,
double xc, double yc, double xi, double yi, double d );
void perturb( vertex * p1, vertex * p2, vertex * q1, vertex * q2,
double aP, double aQ );
BOOL ints( vertex * p1, vertex * p2, vertex * q1, vertex * q2,
int * n, double ix[], double iy[], double alphaP[], double alphaQ[] );
BOOL isInside ( vertex * v );
polygon * boolean( polygon * polyB, int oper );
#if 0
function isPolyInside (p);
function move (dx, dy);
function rotate (xr, yr, a);
function &bRect ();
#endif
}; //end of class polygon
#endif // ifndef PHP_POLYGON_H
polygon/php_polygon_vertex.cpp
View file @ 4ce4631d
// file php_polygon_vertex.cpp
// This is a port of a php class written by Brenor Brophy (see below)
/*------------------------------------------------------------------------------
** File: vertex.php
** Description: PHP class for a polygon vertex. Used as the base object to
** build a class of polygons.
** Version: 1.1
** Author: Brenor Brophy
** Email: brenor at sbcglobal dot net
** Homepage: www.brenorbrophy.com
**------------------------------------------------------------------------------
** COPYRIGHT (c) 2005 BRENOR BROPHY
**
** The source code included in this package is free software; you can
** redistribute it and/or modify it under the terms of the GNU General Public
** License as published by the Free Software Foundation. This license can be
** read at:
**
** http://www.opensource.org/licenses/gpl-license.php
**
** This program is distributed in the hope that it will be useful, but WITHOUT
** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
** FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
**------------------------------------------------------------------------------
**
** Based on the paper "Efficient Clipping of Arbitary Polygons" by Gunther
** Greiner (greiner at informatik dot uni-erlangen dot de) and Kai Hormann
** (hormann at informatik dot tu-clausthal dot de), ACM Transactions on Graphics
** 1998;17(2):71-83.
**
** Available at: www.in.tu-clausthal.de/~hormann/papers/clipping.pdf
**
** Another useful site describing the algorithm and with some example
** C code by Ionel Daniel Stroe is at:
**
** http://davis.wpi.edu/~matt/courses/clipping/
**
** The algorithm is extended by Brenor Brophy to allow polygons with
** arcs between vertices.
**
** Rev History
** -----------------------------------------------------------------------------
** 1.0 08/25/2005 Initial Release
** 1.1 09/04/2005 Added software license language to header comments
*/
//#include "stdafx.h"
#include <math.h>
#include "php_polygon_vertex.h"
segment::segment(double xc, double yc, int d )
{
m_xc = xc;
m_yc = yc;
m_d = d;
}
vertex::vertex( double x, double y,
double xc, double yc, double d,
vertex * nextV, vertex * prevV,
polygon * nextPoly,
BOOL intersect,
vertex * neighbor,
double alpha,
BOOL entry,
BOOL checked )
{
m_x = x;
m_y = y;
m_nextV = nextV;
m_prevV = prevV;
m_nextPoly = nextPoly;
m_intersect = intersect;
m_neighbor = neighbor;
m_alpha = alpha;
m_entry = entry;
m_checked = checked;
m_id = 0;
m_nSeg = new segment( xc, yc, d );
m_pSeg = NULL;
}
vertex::~vertex()
{
if( m_nSeg )
delete m_nSeg;
}
double vertex::Xc ( BOOL g )
{
if ( isIntersect() )
{
if ( m_neighbor->isEntry() )
return m_neighbor->m_nSeg->Xc();
else
return m_neighbor->m_pSeg->Xc();
}
else
if (g)
return m_nSeg->Xc();
else
return m_pSeg->Xc();
}
double vertex::Yc ( BOOL g )
{
if ( isIntersect() )
{
if ( m_neighbor->isEntry() )
return m_neighbor->m_nSeg->Yc();
else
return m_neighbor->m_pSeg->Yc();
}
else
if (g)
return m_nSeg->Yc();
else
return m_pSeg->Yc();
}
double vertex::d ( BOOL g )
{
if ( isIntersect() )
{
if ( m_neighbor->isEntry() )
return m_neighbor->m_nSeg->d();
else
return (-1*m_neighbor->m_pSeg->d());
}
else
if (g)
return m_nSeg->d();
else
return (-1*m_pSeg->d());
}
void vertex::setChecked( BOOL check )
{
m_checked = check;
if( m_neighbor )
if( !m_neighbor->isChecked() )
m_neighbor->setChecked();
}
// file php_polygon_vertex.cpp
// This is a port of a php class written by Brenor Brophy (see below)
/*------------------------------------------------------------------------------
** File: vertex.php
** Description: PHP class for a polygon vertex. Used as the base object to
** build a class of polygons.
** Version: 1.1
** Author: Brenor Brophy
** Email: brenor at sbcglobal dot net
** Homepage: www.brenorbrophy.com
**------------------------------------------------------------------------------
** COPYRIGHT (c) 2005 BRENOR BROPHY
**
** The source code included in this package is free software; you can
** redistribute it and/or modify it under the terms of the GNU General Public
** License as published by the Free Software Foundation. This license can be
** read at:
**
** http://www.opensource.org/licenses/gpl-license.php
**
** This program is distributed in the hope that it will be useful, but WITHOUT
** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
** FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
**------------------------------------------------------------------------------
**
** Based on the paper "Efficient Clipping of Arbitary Polygons" by Gunther
** Greiner (greiner at informatik dot uni-erlangen dot de) and Kai Hormann
** (hormann at informatik dot tu-clausthal dot de), ACM Transactions on Graphics
** 1998;17(2):71-83.
**
** Available at: www.in.tu-clausthal.de/~hormann/papers/clipping.pdf
**
** Another useful site describing the algorithm and with some example
** C code by Ionel Daniel Stroe is at:
**
** http://davis.wpi.edu/~matt/courses/clipping/
**
** The algorithm is extended by Brenor Brophy to allow polygons with
** arcs between vertices.
**
** Rev History
** -----------------------------------------------------------------------------
** 1.0 08/25/2005 Initial Release
** 1.1 09/04/2005 Added software license language to header comments
*/
//#include "stdafx.h"
#include <math.h>
#include "php_polygon_vertex.h"
segment::segment(double xc, double yc, int d )
{
m_xc = xc;
m_yc = yc;
m_d = d;
}
vertex::vertex( double x, double y,
double xc, double yc, double d,
vertex * nextV, vertex * prevV,
polygon * nextPoly,
BOOL intersect,
vertex * neighbor,
double alpha,
BOOL entry,
BOOL checked )
{
m_x = x;
m_y = y;
m_nextV = nextV;
m_prevV = prevV;
m_nextPoly = nextPoly;
m_intersect = intersect;
m_neighbor = neighbor;
m_alpha = alpha;
m_entry = entry;
m_checked = checked;
m_id = 0;
m_nSeg = new segment( xc, yc, d );
m_pSeg = NULL;
}
vertex::~vertex()
{
if( m_nSeg )
delete m_nSeg;
}
double vertex::Xc ( BOOL g )
{
if ( isIntersect() )
{
if ( m_neighbor->isEntry() )
return m_neighbor->m_nSeg->Xc();
else
return m_neighbor->m_pSeg->Xc();
}
else
if (g)
return m_nSeg->Xc();
else
return m_pSeg->Xc();
}
double vertex::Yc ( BOOL g )
{
if ( isIntersect() )
{
if ( m_neighbor->isEntry() )
return m_neighbor->m_nSeg->Yc();
else
return m_neighbor->m_pSeg->Yc();
}
else
if (g)
return m_nSeg->Yc();
else
return m_pSeg->Yc();
}
double vertex::d ( BOOL g )
{
if ( isIntersect() )
{
if ( m_neighbor->isEntry() )
return m_neighbor->m_nSeg->d();
else
return (-1*m_neighbor->m_pSeg->d());
}
else
if (g)
return m_nSeg->d();
else
return (-1*m_pSeg->d());
}
void vertex::setChecked( BOOL check )
{
m_checked = check;
if( m_neighbor )
if( !m_neighbor->isChecked() )
m_neighbor->setChecked();
}
polygon/php_polygon_vertex.h
View file @ 4ce4631d
// file php_polygon_vertex.h
// See comments in file php_polygon_vertex.cpp
#ifndef PHP_POLYGON_VERTEX_H
#define PHP_POLYGON_VERTEX_H
#include "defs-macros.h"
class vertex;
class polygon;
class segment
{
public:
segment(double xc=0.0, double yc=0.0, int d=0 );
double Xc(){ return m_xc; };
double Yc(){ return m_yc; };
int d(){ return m_d; };
void setXc( double xc ){ m_xc = xc; };
void setYc( double yc ){ m_yc = yc; };
double m_xc, m_yc; // center of arc
int m_d; // direction (-1=CW, 0=LINE, 1=CCW)
};
class vertex
{
public:
vertex( double x, double y,
double xc=0.0, double yc=0.0, double d=0.0,
vertex * nextV=NULL, vertex * prevV=NULL,
polygon * nextPoly=NULL,
BOOL intersect=FALSE,
vertex * neighbor=NULL,
double alpha=0.0,
BOOL entry=TRUE,
BOOL checked=FALSE );
~vertex();
int id() { return m_id; };
double X() { return m_x; };
void setX( double x ) { m_x = x; };
double Y() { return m_y; };
void setY( double y ) { m_y = y; };
double Xc ( BOOL g = TRUE );
double Yc ( BOOL g = TRUE );
double d ( BOOL g = TRUE );
void setXc ( double xc ) { m_nSeg->setXc(xc); };
void setYc ( double yc ) { m_nSeg->setYc(yc); };
void setNext ( vertex* nextV ){ m_nextV = nextV; };
vertex * Next (){ return m_nextV; };
void setPrev ( vertex *prevV ){ m_prevV = prevV; };
vertex * Prev (){ return m_prevV; };
void setNseg ( segment * nSeg ){ m_nSeg = nSeg; };
segment * Nseg (){ return m_nSeg; };
void setPseg ( segment * pSeg ){ m_pSeg = pSeg; };
segment * Pseg (){ return m_pSeg; };
void setNextPoly ( polygon * nextPoly ){ m_nextPoly = nextPoly; };
polygon * NextPoly (){ return m_nextPoly; };
void setNeighbor ( vertex * neighbor ){ m_neighbor = neighbor; };
vertex * Neighbor (){ return m_neighbor; };
double Alpha (){ return m_alpha; };
BOOL isIntersect (){ return m_intersect; };
void setChecked( BOOL check = TRUE);
BOOL isChecked () { return m_checked; };
void setEntry ( BOOL entry = TRUE){ m_entry = entry; }
BOOL isEntry (){ return m_entry; };
double m_x, m_y; // coords
vertex * m_nextV; // links to next and prev vertices
vertex * m_prevV; // links to next and prev vertices
segment * m_nSeg, * m_pSeg; // links to next and prev segments
polygon * m_nextPoly;
BOOL m_intersect;
vertex * m_neighbor;
double m_alpha;
BOOL m_entry;
BOOL m_checked;
int m_id;
};
#endif // ifndef PHP_POLYGON_VERTEX_H
// file php_polygon_vertex.h
// See comments in file php_polygon_vertex.cpp
#ifndef PHP_POLYGON_VERTEX_H
#define PHP_POLYGON_VERTEX_H
#include "defs-macros.h"
class vertex;
class polygon;
class segment
{
public:
segment(double xc=0.0, double yc=0.0, int d=0 );
double Xc(){ return m_xc; };
double Yc(){ return m_yc; };
int d(){ return m_d; };
void setXc( double xc ){ m_xc = xc; };
void setYc( double yc ){ m_yc = yc; };
double m_xc, m_yc; // center of arc
int m_d; // direction (-1=CW, 0=LINE, 1=CCW)
};
class vertex
{
public:
vertex( double x, double y,
double xc=0.0, double yc=0.0, double d=0.0,
vertex * nextV=NULL, vertex * prevV=NULL,
polygon * nextPoly=NULL,
BOOL intersect=FALSE,
vertex * neighbor=NULL,
double alpha=0.0,
BOOL entry=TRUE,
BOOL checked=FALSE );
~vertex();
int id() { return m_id; };
double X() { return m_x; };
void setX( double x ) { m_x = x; };
double Y() { return m_y; };
void setY( double y ) { m_y = y; };
double Xc ( BOOL g = TRUE );
double Yc ( BOOL g = TRUE );
double d ( BOOL g = TRUE );
void setXc ( double xc ) { m_nSeg->setXc(xc); };
void setYc ( double yc ) { m_nSeg->setYc(yc); };
void setNext ( vertex* nextV ){ m_nextV = nextV; };
vertex * Next (){ return m_nextV; };
void setPrev ( vertex *prevV ){ m_prevV = prevV; };
vertex * Prev (){ return m_prevV; };
void setNseg ( segment * nSeg ){ m_nSeg = nSeg; };
segment * Nseg (){ return m_nSeg; };
void setPseg ( segment * pSeg ){ m_pSeg = pSeg; };
segment * Pseg (){ return m_pSeg; };
void setNextPoly ( polygon * nextPoly ){ m_nextPoly = nextPoly; };
polygon * NextPoly (){ return m_nextPoly; };
void setNeighbor ( vertex * neighbor ){ m_neighbor = neighbor; };
vertex * Neighbor (){ return m_neighbor; };
double Alpha (){ return m_alpha; };
BOOL isIntersect (){ return m_intersect; };
void setChecked( BOOL check = TRUE);
BOOL isChecked () { return m_checked; };
void setEntry ( BOOL entry = TRUE){ m_entry = entry; }
BOOL isEntry (){ return m_entry; };
double m_x, m_y; // coords
vertex * m_nextV; // links to next and prev vertices
vertex * m_prevV; // links to next and prev vertices
segment * m_nSeg, * m_pSeg; // links to next and prev segments
polygon * m_nextPoly;
BOOL m_intersect;
vertex * m_neighbor;
double m_alpha;
BOOL m_entry;
BOOL m_checked;
int m_id;
};
#endif // ifndef PHP_POLYGON_VERTEX_H
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment