ReactOS 0.4.15-dev-5672-gf73ac17
directedLine.cc
Go to the documentation of this file.
1/*
2** License Applicability. Except to the extent portions of this file are
3** made subject to an alternative license as permitted in the SGI Free
4** Software License B, Version 1.1 (the "License"), the contents of this
5** file are subject only to the provisions of the License. You may not use
6** this file except in compliance with the License. You may obtain a copy
7** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
8** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
9**
10** http://oss.sgi.com/projects/FreeB
11**
12** Note that, as provided in the License, the Software is distributed on an
13** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
14** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
15** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
16** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
17**
18** Original Code. The Original Code is: OpenGL Sample Implementation,
19** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
20** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
21** Copyright in any portions created by third parties is as indicated
22** elsewhere herein. All Rights Reserved.
23**
24** Additional Notice Provisions: The application programming interfaces
25** established by SGI in conjunction with the Original Code are The
26** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
27** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
28** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
29** Window System(R) (Version 1.3), released October 19, 1998. This software
30** was created using the OpenGL(R) version 1.2.1 Sample Implementation
31** published by SGI, but has not been independently verified as being
32** compliant with the OpenGL(R) version 1.2.1 Specification.
33**
34*/
35/*
36*/
37
38//#include <stdlib.h>
39//#include <stdio.h>
40#include <math.h>
41//#include "glimports.h"
42//#include "zlassert.h"
43
44#include "quicksort.h"
45//#include "directedLine.h"
46#include "polyDBG.h"
47
48#ifdef __WATCOMC__
49#pragma warning 726 10
50#endif
51
52//we must return the newLine
54{
55 if(begin->head()[0] == end->tail()[0] &&
56 begin->head()[1] == end->tail()[1]
57 )
58 {
59 directedLine *ret = begin->prev;
60 begin->prev->next = end->next;
61 end->next->prev = begin->prev;
62 delete begin->sline;
63 delete end->sline;
64 delete begin;
65 delete end;
66
67 return ret;
68 }
69
70 directedLine* newLine;
71 sampledLine* sline = new sampledLine(begin->head(), end->tail());
72 newLine = new directedLine(INCREASING, sline);
73 directedLine *p = begin->prev;
75 p->next = newLine;
76 n->prev = newLine;
77 newLine->prev = p;
78 newLine->next = n;
79
80 delete begin->sline;
81 delete end->sline;
82 delete begin;
83 delete end;
84 return newLine;
85}
86
87
89{
90 //make sure that dline->prev->tail is the same as
91 //dline->next->head. This is for numerical erros.
92 //for example, if we delete a line which is almost degeneate
93 //within (epsilon), then we want to make that the polygon after deletion
94 //is still a valid polygon
95
96 dline->next->head()[0] = dline->prev->tail()[0];
97 dline->next->head()[1] = dline->prev->tail()[1];
98
99 dline->prev->next = dline->next;
100 dline->next->prev = dline->prev;
101
102 delete dline;
103
104}
105
106static Int myequal(Real a[2], Real b[2])
107{
108 /*
109 if(a[0]==b[0] && a[1] == b[1])
110 return 1;
111 else
112 return 0;
113 */
114
115
116 if(fabs(a[0]-b[0]) < 0.00001 &&
117 fabs(a[1]-b[1]) < 0.00001)
118 return 1;
119 else
120 return 0;
121
122}
123
125{
126 //if there is only one edge or two edges, don't do anything
127 if(this->next == this)
128 return this;
129 if(this->next == this->prev)
130 return this;
131
132 //find a nondegenerate line
135 if(! myequal(head(), tail()))
136 /*
137 if(head()[0] != tail()[0] ||
138 head()[1] != tail()[1])
139 */
140 first = this;
141 else
142 {
143 for(temp = this->next; temp != this; temp = temp->next)
144 {
145 /*
146 if(temp->head()[0] != temp->tail()[0] ||
147 temp->head()[1] != temp->tail()[1])
148 */
149 if(! myequal(temp->head(), temp->tail()))
150 {
151 first = temp;
152 break;
153 }
154
155 }
156 }
157
158 //if there are no non-degenerate lines, then we simply return NULL.
159 if(first == NULL)
160 {
162 return NULL;
163 }
164
165 directedLine* tempNext = NULL;
166 for(temp =first->next; temp != first; temp = tempNext)
167 {
168 tempNext = temp->getNext();
169/*
170 if(temp->head()[0] == temp->tail()[0] &&
171 temp->head()[1] == temp->tail()[1])
172*/
173
174 if(myequal(temp->head(), temp->tail()))
176 }
177 return first;
178}
179
181{
183 directedLine *tempNext = NULL;
185 directedLine* retEnd = NULL;
186 for(temp=this; temp != NULL; temp = tempNext)
187 {
188 tempNext = temp->nextPolygon;
189 temp->nextPolygon = NULL;
190 if(ret == NULL)
191 {
192 ret = retEnd = temp->deleteDegenerateLines();
193
194 }
195 else
196 {
197 directedLine *newPolygon = temp->deleteDegenerateLines();
198 if(newPolygon != NULL)
199 {
200 retEnd->nextPolygon = temp->deleteDegenerateLines();
201 retEnd = retEnd->nextPolygon;
202 }
203 }
204 }
205 return ret;
206}
207
209{
211 directedLine *tempNext = NULL;
213 directedLine* retEnd = NULL;
214 cutOccur = 0;
215 for(temp=this; temp != NULL; temp = tempNext)
216 {
217 int eachCutOccur=0;
218 tempNext = temp->nextPolygon;
219 temp->nextPolygon = NULL;
220 if(ret == NULL)
221 {
222
223 ret = retEnd = DBG_cutIntersectionPoly(temp, eachCutOccur);
224 if(eachCutOccur)
225 cutOccur = 1;
226 }
227 else
228 {
229
230 retEnd->nextPolygon = DBG_cutIntersectionPoly(temp, eachCutOccur);
231 retEnd = retEnd->nextPolygon;
232 if(eachCutOccur)
233 cutOccur = 1;
234 }
235 }
236 return ret;
237}
238
239
241{
242 directedLine *temp, *tempNext;
243 prev->next = NULL;
244 for(temp=this; temp != NULL; temp = tempNext)
245 {
246 tempNext = temp->next;
247 delete temp->sline;
248 delete temp;
249 }
250}
251
253{
254 directedLine *temp, *tempNext;
255 for(temp=this; temp != NULL; temp=tempNext)
256 {
257 tempNext = temp->nextPolygon;
258 temp->deleteSinglePolygonWithSline();
259 }
260}
261
263{
264 directedLine *temp, *tempNext;
265 prev->next = NULL;
266 for(temp=this; temp != NULL; temp = tempNext)
267 {
268 tempNext = temp->next;
269 delete temp;
270 }
271}
272
274{
275 directedLine *temp, *tempNext;
276 for(temp=this; temp != NULL; temp=tempNext)
277 {
278 tempNext = temp->nextPolygon;
279 temp->deleteSinglePolygon();
280 }
281}
282
283
284/*a loop by itself*/
286{
287 direction = dir;
288 sline = sl;
289 next = this;
290 prev = this;
292// prevPolygon = NULL;
293 rootBit = 0;/*important to initilzae to 0 meaning not root yet*/
294
295 rootLink = NULL;
296
297}
298
300{
301 direction = dir;
302 sline = sl;
303}
304
306{
307 next = this;
308 prev = this;
310 rootBit = 0;/*important to initilzae to 0 meaning not root yet*/
311 rootLink = NULL;
313 sline = NULL;
314}
315
317{
318}
319
321{
322
323 return (direction==INCREASING)? (sline->get_points())[0] : (sline->get_points())[sline->get_npoints()-1];
324}
325
327{
328 return (direction==INCREASING)? (sline->get_points())[i] : (sline->get_points())[sline->get_npoints() - 1 -i];
329}
330
332{
333 return (direction==DECREASING)? (sline->get_points())[0] : (sline->get_points())[sline->get_npoints()-1];
334}
335
336 /*insert a new line between prev and this*/
338{
339 nl->next = this;
340 nl->prev = prev;
341 prev->next = nl;
342 prev = nl;
343 nl->rootLink = this; /*assuming that 'this' is the root!!!*/
344}
345
347{
348 Int ret=0;
350 if(next == this) return 1;
351
352 ret = 1;
353 for(temp = next; temp != this; temp = temp->next)
354 ret++;
355 return ret;
356}
357
359{
360 Int ret=0;
362 for(temp=this; temp!= NULL; temp=temp->nextPolygon)
363 {
364 ret += temp->numEdges();
365 }
366 return ret;
367}
368
369/*return 1 if the double linked list forms a polygon.
370 */
372{
374
375 /*a polygon contains at least 3 edges*/
376 if(numEdges() <=2) return 0;
377
378 /*check this edge*/
379 if(! isConnected()) return 0;
380
381 /*check all other edges*/
382 for(temp=next; temp != this; temp = temp->next){
383 if(!isConnected()) return 0;
384 }
385 return 1;
386}
387
388/*check if the head of this edge is connected to
389 *the tail of the prev
390 */
392{
393 if( (head()[0] == prev->tail()[0]) && (head()[1] == prev->tail()[1]))
394 return 1;
395 else
396 return 0;
397}
398
400{
401 if(A[1] < B[1]) return -1;
402 if(A[1] == B[1] && A[0] < B[0]) return -1;
403 if(A[1] == B[1] && A[0] == B[0]) return 0;
404 return 1;
405}
406
408{
409 if(A[0] < B[0]) return -1;
410 if(A[0] == B[0] && A[1] < B[1]) return -1;
411 if(A[0] == B[0] && A[1] == B[1]) return 0;
412 return 1;
413}
414
415/*compare two vertices NOT lines!
416 *A vertex is the head of a directed line.
417 *(x_1, y_1) <= (x_2, y_2) if
418 *either y_1 < y_2
419 *or y_1 == y_2 && x_1 < x_2.
420 *return -1 if this->head() <= nl->head(),
421 *return 1 otherwise
422 */
424{
425 if(head()[1] < nl->head()[1]) return -1;
426 if(head()[1] == nl->head()[1] && head()[0] < nl->head()[0]) return -1;
427 return 1;
428}
429
430/*compare two vertices NOT lines!
431 *A vertex is the head of a directed line.
432 *(x_1, y_1) <= (x_2, y_2) if
433 *either x_1 < x_2
434 *or x_1 == x_2 && y_1 < y_2.
435 *return -1 if this->head() <= nl->head(),
436 *return 1 otherwise
437 */
439{
440 if(head()[0] < nl->head()[0]) return -1;
441 if(head()[0] == nl->head()[0] && head()[1] < nl->head()[1]) return -1;
442 return 1;
443}
444
445/*used by sort precedures
446 */
448{
449 return v1->compInY(v2);
450}
451#ifdef NOT_USED
452static Int compInX(directedLine* v1, directedLine* v2)
453{
454 return v1->compInX(v2);
455}
456#endif
457
458/*sort all the vertices NOT the lines!
459 *a vertex is the head of a directed line
460 */
462{
463 Int total_num_edges = 0;
464 directedLine** array = toArrayAllPolygons(total_num_edges);
465 quicksort( (void**)array, 0, total_num_edges-1, (Int (*)(void *, void *)) compInY2);
466
467 return array;
468}
469
471{
472 if(direction == INCREASING)
473 printf("direction is INCREASING\n");
474 else
475 printf("direction is DECREASING\n");
476 printf("head=%f,%f)\n", head()[0], head()[1]);
477 sline->print();
478}
479
480/*print one polygon*/
482{
484 printSingle();
485 for(temp = next; temp!=this; temp=temp->next)
486 temp->printSingle();
487}
488
489/*print all the polygons*/
491{
493 for(temp = this; temp!=NULL; temp = temp->nextPolygon)
494 {
495 printf("polygon:\n");
496 temp->printList();
497 }
498}
499
500/*insert this polygon into the head of the old polygon List*/
502{
503 /*this polygon is a root*/
504 setRootBit();
505 if(oldList == NULL) return this;
506 nextPolygon = oldList;
507/* oldList->prevPolygon = this;*/
508 return this;
509}
510
511/*cutoff means delete. but we don't deallocate any space,
512 *so we use cutoff instead of delete
513 */
515{
517 directedLine* prev_polygon = NULL;
518 if(p == NULL) return this;
519
520 for(temp=this; temp != p; temp = temp->nextPolygon)
521 {
522 if(temp == NULL)
523 {
524 fprintf(stderr, "in cutoffPolygon, not found\n");
525 exit(1);
526 }
527 prev_polygon = temp;
528 }
529
530/* prev_polygon = p->prevPolygon;*/
531
532 p->resetRootBit();
533 if(prev_polygon == NULL) /*this is the one to cutoff*/
534 return nextPolygon;
535 else {
536 prev_polygon->nextPolygon = p->nextPolygon;
537 return this;
538 }
539}
540
542{
543 if(nextPolygon == NULL) return 1;
544 else return 1+nextPolygon->numPolygons();
545}
546
547
548/*let array[index ...] denote
549 *all the edges in this polygon
550 *return the next available index of array.
551 */
553{
555 array[index++] = this;
556 for(temp = next; temp != this; temp = temp->next)
557 {
558 array[index++] = temp;
559 }
560 return index;
561}
562
563/*the space is allocated. The caller is responsible for
564 *deallocate the space.
565 *total_num_edges is set to be the total number of edges of all polygons
566 */
568{
569 total_num_edges=numEdgesAllPolygons();
570 directedLine** ret = (directedLine**) malloc(sizeof(directedLine*) * total_num_edges);
571 assert(ret);
572
574 Int index = 0;
575 for(temp=this; temp != NULL; temp=temp->nextPolygon) {
576 index = temp->toArraySinglePolygon(ret, index);
577 }
578 return ret;
579}
580
581/*assume the polygon is a simple polygon, return
582 *the area enclosed by it.
583 *if thee order is counterclock wise, the area is positive.
584 */
586{
588 Real ret=0.0;
589 Real x1,y1,x2,y2;
590 x1 = this->head()[0];
591 y1 = this->head()[1];
592 x2 = this->next->head()[0];
593 y2 = this->next->head()[1];
594 ret = -(x2*y1-x1*y2);
595 for(temp=this->next; temp!=this; temp = temp->next)
596 {
597 x1 = temp->head()[0];
598 y1 = temp->head()[1];
599 x2 = temp->next->head()[0];
600 y2 = temp->next->head()[1];
601 ret += -( x2*y1-x1*y2);
602 }
603 return Real(0.5)*ret;
604}
605
606/*******************split or combine polygons begin********************/
607/*conect a diagonal of a single simple polygon or two simple polygons.
608 *If the two vertices v1 (head) and v2 (head) are in the same simple polygon,
609 *then we actually split the simple polygon into two polygons.
610 *If instead two vertices velong to two difference polygons,
611 *then we combine the two polygons into one polygon.
612 *It is upto the caller to decide whether this is a split or a
613 *combination.
614 *
615 *Case Split:
616 *split a single simple polygon into two simple polygons by
617 *connecting a diagonal (two vertices).
618 *v1, v2: the two vertices are the head() of the two directedLines.
619 * this routine generates one new sampledLine which is returned in
620 *generatedLine,
621 *and it generates two directedLines returned in ret_p1 and ret_p2.
622 *ret_p1 and ret_p2 are used as the entry to the two new polygons.
623 *Notice the caller should not deallocate the space of v2 and v2 after
624 *calling this function, since all of the edges are connected to
625 *ret_p1 or ret_p2.
626 *
627 *combine:
628 *combine two simpolygons into one by connecting one diagonal.
629 *the returned polygon is returned in ret_p1.
630 */
631/*ARGSUSED*/
633 directedLine** ret_p1,
634 directedLine** ret_p2,
635 sampledLine** generatedLine,
636 directedLine* polygonList )
637{
638 sampledLine *nsline = new sampledLine(2);
639
640
641
642 nsline->setPoint(0, v1->head());
643 nsline->setPoint(1, v2->head());
644
645
646
647 /*the increasing line is from v1 head to v2 head*/
648 directedLine* newLineInc = new directedLine(INCREASING, nsline);
649
650
651
652 directedLine* newLineDec = new directedLine(DECREASING, nsline);
653
654
655 directedLine* v1Prev = v1->prev;
656 directedLine* v2Prev = v2->prev;
657
658 v1 ->prev = newLineDec;
659 v2Prev ->next = newLineDec;
660 newLineDec->next = v1;
661 newLineDec->prev = v2Prev;
662
663 v2 ->prev = newLineInc;
664 v1Prev ->next = newLineInc;
665 newLineInc->next = v2;
666 newLineInc->prev = v1Prev;
667
668 *ret_p1 = newLineDec;
669 *ret_p2 = newLineInc;
670 *generatedLine = nsline;
671}
672
673//see the function connectDiangle
674/*ARGSUSED*/
676 directedLine** ret_p1,
677 directedLine** ret_p2,
678 directedLine* polygonList )
679{
680 sampledLine *nsline = new sampledLine(2);
681 sampledLine *nsline2 = new sampledLine(2);
682
683 nsline->setPoint(0, v1->head());
684 nsline->setPoint(1, v2->head());
685 nsline2->setPoint(0, v1->head());
686 nsline2->setPoint(1, v2->head());
687
688 /*the increasing line is from v1 head to v2 head*/
689 directedLine* newLineInc = new directedLine(INCREASING, nsline);
690
691 directedLine* newLineDec = new directedLine(DECREASING, nsline2);
692
693 directedLine* v1Prev = v1->prev;
694 directedLine* v2Prev = v2->prev;
695
696 v1 ->prev = newLineDec;
697 v2Prev ->next = newLineDec;
698 newLineDec->next = v1;
699 newLineDec->prev = v2Prev;
700
701 v2 ->prev = newLineInc;
702 v1Prev ->next = newLineInc;
703 newLineInc->next = v2;
704 newLineInc->prev = v1Prev;
705
706 *ret_p1 = newLineDec;
707 *ret_p2 = newLineInc;
708
709}
710
712{
713 if(v1 == v2) return 1;
715 for(temp = v1->next; temp != v1; temp = temp->next)
716 {
717 if(temp == v2) return 1;
718 }
719 return 0;
720}
721
723{
724 if(rootBit) return this;
726 for(temp = next; temp != this; temp = temp->next)
727 if(temp -> rootBit ) return temp;
728 return NULL; /*should not happen*/
729}
730
732{
733 directedLine* tempRoot;
734 directedLine* tempLink;
735 tempRoot = this;
736 tempLink = rootLink;
737 while(tempLink != NULL){
738 tempRoot = tempLink;
739 tempLink = tempRoot->rootLink;
740 }
741 return tempRoot;
742}
743
744/*******************split or combine polygons end********************/
745
746/*****************IO stuff begin*******************/
747
748/*format:
749 *#polygons
750 * #vertices
751 * vertices
752 * #vertices
753 * vertices
754 *...
755 */
757{
758 FILE* fp = fopen(filename, "w");
759 assert(fp);
760 Int nPolygons = numPolygons();
762 fprintf(fp, "%i\n", nPolygons);
763 for(root = this; root != NULL; root = root->nextPolygon)
764 {
766 Int npoints=0;
767 npoints = root->get_npoints()-1;
768 for(temp = root->next; temp != root; temp=temp->next)
769 npoints += temp->get_npoints()-1;
770 fprintf(fp, "%i\n", npoints/*root->numEdges()*/);
771
772
773 for(Int i=0; i<root->get_npoints()-1; i++){
774 fprintf(fp, "%f ", root->getVertex(i)[0]);
775 fprintf(fp, "%f ", root->getVertex(i)[1]);
776 }
777
778 for(temp=root->next; temp != root; temp = temp->next)
779 {
780 for(Int i=0; i<temp->get_npoints()-1; i++){
781
782 fprintf(fp, "%f ", temp->getVertex(i)[0]);
783 fprintf(fp, "%f ", temp->getVertex(i)[1]);
784 }
785 fprintf(fp,"\n");
786 }
787 fprintf(fp, "\n");
788 }
789 fclose(fp);
790}
791
793{
794 Int i,j;
795 FILE* fp = fopen(filename, "r");
796 Int nPolygons;
797 int result;
798
799 assert(fp);
800 result = fscanf(fp, "%i", &nPolygons);
801 assert(result != EOF);
803
804 for(i=0; i<nPolygons; i++)
805 {
806 Int nEdges;
807 result = fscanf(fp, "%i", &nEdges);
808 assert(result != EOF);
809 Real vert[2][2] = { { 0 } };
810 Real VV[2][2];
811 /*the first two vertices*/
812 result = fscanf(fp, "%f", &(vert[0][0]));
813 assert(result != EOF);
814 result = fscanf(fp, "%f", &(vert[0][1]));
815 assert(result != EOF);
816 result = fscanf(fp, "%f", &(vert[1][0]));
817 assert(result != EOF);
818 result = fscanf(fp, "%f", &(vert[1][1]));
819 assert(result != EOF);
820 VV[1][0] = vert[0][0];
821 VV[1][1] = vert[0][1];
822 sampledLine *sLine = new sampledLine(2, vert);
823 directedLine *thisPoly = new directedLine(INCREASING, sLine);
824thisPoly->rootLinkSet(NULL);
825
826 directedLine *dLine;
827 for(j=2; j<nEdges; j++)
828 {
829 vert[0][0]=vert[1][0];
830 vert[0][1]=vert[1][1];
831 result = fscanf(fp, "%f", &(vert[1][0]));
832 assert(result != EOF);
833 result = fscanf(fp, "%f", &(vert[1][1]));
834 assert(result != EOF);
835 sLine = new sampledLine(2,vert);
836 dLine = new directedLine(INCREASING, sLine);
837dLine->rootLinkSet(thisPoly);
838 thisPoly->insert(dLine);
839 }
840
841 VV[0][0]=vert[1][0];
842 VV[0][1]=vert[1][1];
843 sLine = new sampledLine(2,VV);
844 dLine = new directedLine(INCREASING, sLine);
845dLine->rootLinkSet(thisPoly);
846 thisPoly->insert(dLine);
847
848 ret = thisPoly->insertPolygon(ret);
849 }
850 fclose(fp);
851 return ret;
852}
853
854
855
856
857
858
859
860
unsigned int dir
Definition: maze.c:112
#define index(s, c)
Definition: various.h:29
struct _root root
Definition: ehthrow.cxx:93
Definition: ehthrow.cxx:54
short isConnected()
short direction
Definition: directedLine.h:42
directedLine * cutoffPolygon(directedLine *p)
directedLine * prev
Definition: directedLine.h:45
void rootLinkSet(directedLine *r)
Definition: directedLine.h:155
directedLine * deleteChain(directedLine *begin, directedLine *end)
Definition: directedLine.cc:53
sampledLine * sline
Definition: directedLine.h:43
directedLine * deleteDegenerateLines()
void deleteSinglePolygon()
directedLine ** sortAllPolygons()
void writeAllPolygons(char *filename)
directedLine * nextPolygon
Definition: directedLine.h:50
void connectDiagonal(directedLine *v1, directedLine *v2, directedLine **ret_p1, directedLine **ret_p2, sampledLine **generatedLine, directedLine *list)
directedLine * cutIntersectionAllPoly(int &cutOccur)
void deletePolygonList()
directedLine * insertPolygon(directedLine *newpolygon)
directedLine * findRoot()
void deleteSingleLine(directedLine *dline)
Definition: directedLine.cc:88
void deleteSinglePolygonWithSline()
Real * getVertex(Int i)
directedLine * next
Definition: directedLine.h:44
Int compInX(directedLine *nl)
directedLine * rootLinkFindRoot()
Int samePolygon(directedLine *v1, directedLine *v2)
Int compInY(directedLine *nl)
void printSingle()
void connectDiagonal_2slines(directedLine *v1, directedLine *v2, directedLine **ret_p1, directedLine **ret_p2, directedLine *list)
Real * head()
directedLine ** toArrayAllPolygons(Int &total_num_edges)
void init(short dir, sampledLine *sl)
directedLine * deleteDegenerateLinesAllPolygons()
void setRootBit()
Definition: directedLine.h:151
void insert(directedLine *nl)
void deletePolygonListWithSline()
Int toArraySinglePolygon(directedLine **array, Int index)
void printAllPolygons()
short isPolygon()
directedLine * rootLink
Definition: directedLine.h:58
Real * tail()
void printList()
Int numEdgesAllPolygons()
void setPoint(Int i, Real p[2])
Definition: sampledLine.cc:45
Real2 * get_points()
Definition: sampledLine.h:57
Int get_npoints()
Definition: sampledLine.h:56
void print()
Definition: sampledLine.cc:129
#define malloc
Definition: debug_ros.c:4
int Int
Definition: definitions.h:37
float Real
Definition: definitions.h:36
Int compV2InY(Real A[2], Real B[2])
static Int myequal(Real a[2], Real b[2])
directedLine * readAllPolygons(char *filename)
static Int compInY2(directedLine *v1, directedLine *v2)
Int compV2InX(Real A[2], Real B[2])
@ INCREASING
Definition: directedLine.h:39
@ DECREASING
Definition: directedLine.h:39
#define NULL
Definition: types.h:112
#define assert(x)
Definition: debug.h:53
#define printf
Definition: freeldr.h:94
GLuint GLuint end
Definition: gl.h:1545
GLdouble n
Definition: glext.h:7729
GLuint index
Definition: glext.h:6031
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
const GLint * first
Definition: glext.h:5794
GLfloat GLfloat p
Definition: glext.h:8902
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
GLfloat GLfloat v1
Definition: glext.h:6062
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
GLuint64EXT * result
Definition: glext.h:11304
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
_Check_return_ _CRT_JIT_INTRINSIC double __cdecl fabs(_In_ double x)
Definition: fabs.c:17
#define EOF
Definition: stdio.h:24
#define stderr
Definition: stdio.h:100
_Check_return_ _CRTIMP int __cdecl fscanf(_Inout_ FILE *_File, _In_z_ _Scanf_format_string_ const char *_Format,...)
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
const char * filename
Definition: ioapi.h:137
directedLine * DBG_cutIntersectionPoly(directedLine *polygon, int &cutOccur)
Definition: polyDBG.cc:549
void quicksort(void *v[], int left, int right, int(*comp)(void *, void *))
Definition: quicksort.cc:62
static calc_node_t temp
Definition: rpn_ieee.c:38
#define exit(n)
Definition: config.h:202
int ret
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3710
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG y1
Definition: winddi.h:3709
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3708
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG _In_ LONG y2
Definition: winddi.h:3711
static clock_t begin
Definition: xmllint.c:458