Index: trunk/doc-rnd/hacking/renames =================================================================== --- trunk/doc-rnd/hacking/renames (revision 4988) +++ trunk/doc-rnd/hacking/renames (revision 4989) @@ -681,3 +681,19 @@ poly_ChkContour -> pcb_poly_contour_check poly_CheckInside -> pcb_poly_contour_inside Touching -> pcb_poly_touching +pcb_poly_m_copy0 -> pcb_polyarea_m_copy0 +pcb_poly_m_include -> pcb_polyarea_m_include +pcb_poly_copy0 -> pcb_polyarea_copy0 +pcb_poly_copy1 -> pcb_polyarea_copy1 +pcb_poly_contour_include -> pcb_polyarea_contour_include +pcb_poly_contour_exclide -> pcb_polyarea_contour_exclide +pcb_poly_contour_check -> pcb_polyarea_contour_check +pcb_poly_contour_inside -> pcb_polyarea_contour_inside +pcb_poly_touching -> pcb_polyarea_touching +poly_InsideContour -> pcb_poly_contour_inside +poly_ContourInContour -> pcb_poly_contour_in_contour +poly_Create -> pcb_polyarea_create +poly_Free -> pcb_polyarea_free +poly_Init -> pcb_polyarea_init +poly_FreeContours -> pcb_poly_contours_free +poly_Valid -> pcb_poly_valid Index: trunk/src/find_geo.c =================================================================== --- trunk/src/find_geo.c (revision 4988) +++ trunk/src/find_geo.c (revision 4989) @@ -638,9 +638,9 @@ pl1 = PinPoly(PV1, PIN_SIZE(PV1) + Bloat, 0); pl2 = PinPoly(PV2, PIN_SIZE(PV2) + Bloat, 0); - ret = pcb_poly_touching(pl1, pl2); - poly_Free(&pl1); - poly_Free(&pl2); + ret = pcb_polyarea_touching(pl1, pl2); + pcb_polyarea_free(&pl1); + pcb_polyarea_free(&pl2); return ret; } @@ -684,9 +684,9 @@ pl = PinPoly(PV, PIN_SIZE(PV), 0); lp = LinePoly(Line, Line->Thickness + Bloat); - ret = pcb_poly_touching(lp, pl); - poly_Free(&pl); - poly_Free(&lp); + ret = pcb_polyarea_touching(lp, pl); + pcb_polyarea_free(&pl); + pcb_polyarea_free(&lp); return ret; } Index: trunk/src/hid_draw_helpers.c =================================================================== --- trunk/src/hid_draw_helpers.c (revision 4988) +++ trunk/src/hid_draw_helpers.c (revision 4989) @@ -69,7 +69,7 @@ pcb_pline_t *local_pl = pl; fill_contour(gc, pl); - poly_FreeContours(&local_pl); + pcb_poly_contours_free(&local_pl); } static void fill_clipped_contour(pcb_hid_gc_t gc, pcb_pline_t * pl, const pcb_box_t * clip_box) @@ -83,8 +83,8 @@ clip_poly = RectPoly(clip_box->X1, clip_box->X2, clip_box->Y1, clip_box->Y2); pcb_poly_contour_copy(&pl_copy, pl); - piece_poly = poly_Create(); - pcb_poly_contour_include(piece_poly, pl_copy); + piece_poly = pcb_polyarea_create(); + pcb_polyarea_contour_include(piece_poly, pl_copy); x = poly_Boolean_free(piece_poly, clip_poly, &clipped_pieces, PBO_ISECT); if (x != err_ok || clipped_pieces == NULL) return; @@ -95,7 +95,7 @@ fill_contour(gc, draw_piece->contours); } while ((draw_piece = draw_piece->f) != clipped_pieces); - poly_Free(&clipped_pieces); + pcb_polyarea_free(&clipped_pieces); } /* If at least 50% of the bounding box of the polygon is on the screen, Index: trunk/src/obj_pinvia.c =================================================================== --- trunk/src/obj_pinvia.c (revision 4988) +++ trunk/src/obj_pinvia.c (revision 4989) @@ -211,7 +211,7 @@ if ((PCB_FLAG_SQUARE_GET(Pin) > 1) && (PCB_FLAG_TEST(PCB_FLAG_SQUARE, Pin))) { pcb_polyarea_t *p = PinPoly(Pin, PIN_SIZE(Pin), Pin->Clearance); poly_bbox(p, &Pin->BoundingBox); - poly_Free(&p); + pcb_polyarea_free(&p); } /* the bounding box covers the extent of influence Index: trunk/src/obj_poly.c =================================================================== --- trunk/src/obj_poly.c (revision 4988) +++ trunk/src/obj_poly.c (revision 4989) @@ -110,8 +110,8 @@ free(polygon->HoleIndex); if (polygon->Clipped) - poly_Free(&polygon->Clipped); - poly_FreeContours(&polygon->NoHoles); + pcb_polyarea_free(&polygon->Clipped); + pcb_poly_contours_free(&polygon->NoHoles); reset_obj_mem(pcb_polygon_t, polygon); } Index: trunk/src/polyarea.h =================================================================== --- trunk/src/polyarea.h (revision 4988) +++ trunk/src/polyarea.h (revision 4989) @@ -116,20 +116,20 @@ pcb_rtree_t *contour_tree; }; -pcb_bool pcb_poly_m_copy0(pcb_polyarea_t ** dst, const pcb_polyarea_t * srcfst); -void pcb_poly_m_include(pcb_polyarea_t ** list, pcb_polyarea_t * a); +pcb_bool pcb_polyarea_m_copy0(pcb_polyarea_t ** dst, const pcb_polyarea_t * srcfst); +void pcb_polyarea_m_include(pcb_polyarea_t ** list, pcb_polyarea_t * a); -pcb_bool pcb_poly_copy0(pcb_polyarea_t ** dst, const pcb_polyarea_t * src); -pcb_bool pcb_poly_copy1(pcb_polyarea_t * dst, const pcb_polyarea_t * src); +pcb_bool pcb_polyarea_copy0(pcb_polyarea_t ** dst, const pcb_polyarea_t * src); +pcb_bool pcb_polyarea_copy1(pcb_polyarea_t * dst, const pcb_polyarea_t * src); -pcb_bool pcb_poly_contour_include(pcb_polyarea_t * p, pcb_pline_t * c); -pcb_bool pcb_poly_contour_exclide(pcb_polyarea_t * p, pcb_pline_t * c); +pcb_bool pcb_polyarea_contour_include(pcb_polyarea_t * p, pcb_pline_t * c); +pcb_bool pcb_polyarea_contour_exclide(pcb_polyarea_t * p, pcb_pline_t * c); -pcb_bool pcb_poly_contour_check(pcb_pline_t * a); +pcb_bool pcb_polyarea_contour_check(pcb_pline_t * a); -pcb_bool pcb_poly_contour_inside(pcb_polyarea_t * c, pcb_vector_t v0); -pcb_bool pcb_poly_touching(pcb_polyarea_t * p1, pcb_polyarea_t * p2); +pcb_bool pcb_polyarea_contour_inside(pcb_polyarea_t * c, pcb_vector_t v0); +pcb_bool pcb_polyarea_touching(pcb_polyarea_t * p1, pcb_polyarea_t * p2); /**********************************************************************/ @@ -138,14 +138,14 @@ /* checks whether point lies within contour independently of its orientation */ -int poly_InsideContour(pcb_pline_t * c, pcb_vector_t v); -int poly_ContourInContour(pcb_pline_t * poly, pcb_pline_t * inner); -pcb_polyarea_t *poly_Create(void); +int pcb_poly_contour_inside(pcb_pline_t * c, pcb_vector_t v); +int pcb_poly_contour_in_contour(pcb_pline_t * poly, pcb_pline_t * inner); +pcb_polyarea_t *pcb_polyarea_create(void); -void poly_Free(pcb_polyarea_t ** p); -void poly_Init(pcb_polyarea_t * p); -void poly_FreeContours(pcb_pline_t ** pl); -pcb_bool poly_Valid(pcb_polyarea_t * p); +void pcb_polyarea_free(pcb_polyarea_t ** p); +void pcb_polyarea_init(pcb_polyarea_t * p); +void pcb_poly_contours_free(pcb_pline_t ** pl); +pcb_bool pcb_poly_valid(pcb_polyarea_t * p); enum pcb_poly_bool_op_e { PBO_UNITE, Index: trunk/src/polygon.c =================================================================== --- trunk/src/polygon.c (revision 4988) +++ trunk/src/polygon.c (revision 4989) @@ -182,7 +182,7 @@ void ComputeNoHoles(pcb_polygon_t * poly) { - poly_FreeContours(&poly->NoHoles); + pcb_poly_contours_free(&poly->NoHoles); if (poly->Clipped) NoHolesPolygonDicer(poly, NULL, add_noholes_polyarea, poly); else @@ -240,10 +240,10 @@ pcb_polyarea_t *p; pcb_poly_contour_pre(contour, pcb_true); assert(contour->Flags.orient == PLF_DIR); - if (!(p = poly_Create())) + if (!(p = pcb_polyarea_create())) return NULL; - pcb_poly_contour_include(p, contour); - assert(poly_Valid(p)); + pcb_polyarea_contour_include(p, contour); + assert(pcb_poly_valid(p)); return p; } @@ -255,7 +255,7 @@ pcb_vector_t v; int hole = 0; - if ((np = poly_Create()) == NULL) + if ((np = pcb_polyarea_create()) == NULL) return NULL; /* first make initial polygon contour */ @@ -282,9 +282,9 @@ pcb_poly_contour_inv(contour); assert(contour->Flags.orient == (hole ? PLF_INV : PLF_DIR)); - pcb_poly_contour_include(np, contour); + pcb_polyarea_contour_include(np, contour); contour = NULL; - assert(poly_Valid(np)); + assert(pcb_poly_valid(np)); hole++; } @@ -703,21 +703,21 @@ assert(p); if (!p->Clipped) { if (fnp) - poly_Free(&np); + pcb_polyarea_free(&np); return 1; } - assert(poly_Valid(p->Clipped)); - assert(poly_Valid(np)); + assert(pcb_poly_valid(p->Clipped)); + assert(pcb_poly_valid(np)); if (fnp) x = poly_Boolean_free(p->Clipped, np, &merged, PBO_SUB); else { x = poly_Boolean(p->Clipped, np, &merged, PBO_SUB); - poly_Free(&p->Clipped); + pcb_polyarea_free(&p->Clipped); } - assert(!merged || poly_Valid(merged)); + assert(!merged || pcb_poly_valid(merged)); if (x != err_ok) { fprintf(stderr, "Error while clipping PBO_SUB: %d\n", x); - poly_Free(&merged); + pcb_polyarea_free(&merged); p->Clipped = NULL; if (p->NoHoles) printf("Just leaked in Subtract\n"); @@ -725,7 +725,7 @@ return -1; } p->Clipped = biggest(merged); - assert(!p->Clipped || poly_Valid(p->Clipped)); + assert(!p->Clipped || pcb_poly_valid(p->Clipped)); if (!p->Clipped) pcb_message(PCB_MSG_DEFAULT, "Polygon cleared out of existence near (%d, %d)\n", (p->BoundingBox.X1 + p->BoundingBox.X2) / 2, (p->BoundingBox.Y1 + p->BoundingBox.Y2) / 2); @@ -1062,7 +1062,7 @@ x = poly_Boolean_free(np, orig_poly, &clipped_np, PBO_ISECT); if (x != err_ok) { fprintf(stderr, "Error while clipping PBO_ISECT: %d\n", x); - poly_Free(&clipped_np); + pcb_polyarea_free(&clipped_np); goto fail; } @@ -1069,11 +1069,11 @@ x = poly_Boolean_free(p->Clipped, clipped_np, &merged, PBO_UNITE); if (x != err_ok) { fprintf(stderr, "Error while clipping PBO_UNITE: %d\n", x); - poly_Free(&merged); + pcb_polyarea_free(&merged); goto fail; } p->Clipped = biggest(merged); - assert(!p->Clipped || poly_Valid(p->Clipped)); + assert(!p->Clipped || pcb_poly_valid(p->Clipped)); return 1; fail: @@ -1176,12 +1176,12 @@ if (inhibit) return 0; if (p->Clipped) - poly_Free(&p->Clipped); + pcb_polyarea_free(&p->Clipped); p->Clipped = original_poly(p); - poly_FreeContours(&p->NoHoles); + pcb_poly_contours_free(&p->NoHoles); if (!p->Clipped) return 0; - assert(poly_Valid(p->Clipped)); + assert(pcb_poly_valid(p->Clipped)); if (PCB_FLAG_TEST(PCB_FLAG_CLEARPOLY, p)) clearPoly(Data, layer, p, NULL, 0); else @@ -1560,11 +1560,11 @@ { pcb_polyarea_t *x; pcb_bool ans; - ans = pcb_poly_touching(a, p->Clipped); + ans = pcb_polyarea_touching(a, p->Clipped); /* argument may be register, so we must copy it */ x = a; if (fr) - poly_Free(&x); + pcb_polyarea_free(&x); return ans; } @@ -1575,7 +1575,7 @@ pcb_vector_t v; v[0] = X; v[1] = Y; - if (pcb_poly_contour_inside(p->Clipped, v)) + if (pcb_polyarea_contour_inside(p->Clipped, v)) return pcb_true; if (PCB_FLAG_TEST(PCB_FLAG_FULLPOLY, p)) { @@ -1583,7 +1583,7 @@ /* Check all clipped-away regions that are now drawn because of full-poly */ for (tmp.Clipped = p->Clipped->f; tmp.Clipped != p->Clipped; tmp.Clipped = tmp.Clipped->f) - if (pcb_poly_contour_inside(tmp.Clipped, v)) + if (pcb_polyarea_contour_inside(tmp.Clipped, v)) return pcb_true; } @@ -1600,7 +1600,7 @@ pcb_vector_t v; v[0] = X; v[1] = Y; - return poly_InsideContour(p->Clipped->contours, v); + return pcb_poly_contour_inside(p->Clipped->contours, v); } pcb_bool IsRectangleInPolygon(pcb_coord_t X1, pcb_coord_t Y1, pcb_coord_t X2, pcb_coord_t Y2, pcb_polygon_t *p) @@ -1623,7 +1623,7 @@ /* Don't bother removing it from the pcb_polyarea_t's rtree since we're going to free the pcb_polyarea_t below anyway */ emit(p, user_data); - poly_Free(&pa); + pcb_polyarea_free(&pa); return; } else { @@ -1661,9 +1661,9 @@ { pcb_polyarea_t *main_contour, *cur, *next; - main_contour = poly_Create(); + main_contour = pcb_polyarea_create(); /* copy the main poly only */ - pcb_poly_copy1(main_contour, p->Clipped); + pcb_polyarea_copy1(main_contour, p->Clipped); /* clip to the bounding box */ if (clip) { pcb_polyarea_t *cbox = RectPoly(clip->X1, clip->X2, clip->Y1, clip->Y2); Index: trunk/src/polygon1.c =================================================================== --- trunk/src/polygon1.c (revision 4988) +++ trunk/src/polygon1.c (revision 4989) @@ -892,7 +892,7 @@ pcb_pline_t *me = (pcb_pline_t *) cl; pcb_pline_t *check = (pcb_pline_t *) b; - if (poly_ContourInContour(check, me)) + if (pcb_poly_contour_in_contour(check, me)) return R_DIR_FOUND_CONTINUE; return R_DIR_NOT_FOUND; } @@ -1170,7 +1170,7 @@ if (check->Flags.orient == PLF_DIR) { return R_DIR_NOT_FOUND; } - if (poly_ContourInContour(info->want_inside, check)) { + if (pcb_poly_contour_in_contour(info->want_inside, check)) { info->result = check; longjmp(info->jb, 1); } @@ -1239,12 +1239,12 @@ */ pa_info = (struct polyarea_info *) pcb_heap_remove_smallest(heap); if (pcb_heap_is_empty(heap)) { /* only one possibility it must be the right one */ - assert(poly_ContourInContour(pa_info->pa->contours, curh)); + assert(pcb_poly_contour_in_contour(pa_info->pa->contours, curh)); container = pa_info->pa->contours; } else { do { - if (poly_ContourInContour(pa_info->pa->contours, curh)) { + if (pcb_poly_contour_in_contour(pa_info->pa->contours, curh)) { container = pa_info->pa->contours; break; } @@ -1726,7 +1726,7 @@ if (is_first && is_last) { remove_polyarea(pieces, a); - poly_Free(&a); /* NB: Sets a to NULL */ + pcb_polyarea_free(&a); /* NB: Sets a to NULL */ } } @@ -1851,7 +1851,7 @@ } remove_polyarea(pieces, a); - poly_Free(&a); /* NB: Sets a to NULL */ + pcb_polyarea_free(&a); /* NB: Sets a to NULL */ continue; } @@ -1947,7 +1947,7 @@ if (is_first && is_last) { remove_polyarea(pieces, a); - poly_Free(&a); /* NB: Sets a to NULL */ + pcb_polyarea_free(&a); /* NB: Sets a to NULL */ } } @@ -2024,7 +2024,7 @@ } /* determine if two polygons touch or overlap */ -pcb_bool pcb_poly_touching(pcb_polyarea_t * a, pcb_polyarea_t * b) +pcb_bool pcb_polyarea_touching(pcb_polyarea_t * a, pcb_polyarea_t * b) { jmp_buf e; int code; @@ -2031,9 +2031,9 @@ if ((code = setjmp(e)) == 0) { #ifdef DEBUG - if (!poly_Valid(a)) + if (!pcb_poly_valid(a)) return -1; - if (!poly_Valid(b)) + if (!pcb_poly_valid(b)) return -1; #endif M_pcb_polyarea_t_intersect(&e, a, b, pcb_false); @@ -2053,7 +2053,7 @@ { pcb_polyarea_t *a = NULL, *b = NULL; - if (!pcb_poly_m_copy0(&a, a_org) || !pcb_poly_m_copy0(&b, b_org)) + if (!pcb_polyarea_m_copy0(&a, a_org) || !pcb_polyarea_m_copy0(&b, b_org)) return err_no_memory; return poly_Boolean_free(a, b, res, action); @@ -2079,7 +2079,7 @@ case PBO_SUB: case PBO_ISECT: if (b != NULL) - poly_Free(&b); + pcb_polyarea_free(&b); return err_ok; } } @@ -2092,7 +2092,7 @@ return err_ok; case PBO_ISECT: if (a != NULL) - poly_Free(&a); + pcb_polyarea_free(&a); return err_ok; } } @@ -2099,8 +2099,8 @@ if ((code = setjmp(e)) == 0) { #ifdef DEBUG - assert(poly_Valid(a)); - assert(poly_Valid(b)); + assert(pcb_poly_valid(a)); + assert(pcb_poly_valid(b)); #endif /* intersect needs to make a list of the contours in a and b which are intersected */ @@ -2116,7 +2116,7 @@ M_pcb_polyarea_t_label_separated(a_isected, b, pcb_false); M_pcb_polyarea_t_Collect_separated(&e, a_isected, res, &holes, action, pcb_false); M_B_AREA_Collect(&e, b, res, &holes, action); - poly_Free(&b); + pcb_polyarea_free(&b); /* free a_isected */ while ((p = a_isected) != NULL) { @@ -2133,10 +2133,10 @@ } if (code) { - poly_Free(res); + pcb_polyarea_free(res); return code; } - assert(!*res || poly_Valid(*res)); + assert(!*res || pcb_poly_valid(*res)); return code; } /* poly_Boolean_free */ @@ -2174,9 +2174,9 @@ if ((code = setjmp(e)) == 0) { #ifdef DEBUG - if (!poly_Valid(a)) + if (!pcb_poly_valid(a)) return -1; - if (!poly_Valid(b)) + if (!pcb_poly_valid(b)) return -1; #endif M_pcb_polyarea_t_intersect(&e, a, b, pcb_true); @@ -2186,7 +2186,7 @@ M_pcb_polyarea_t_Collect(&e, a, aandb, &holes, PBO_ISECT, pcb_false); InsertHoles(&e, *aandb, &holes); - assert(poly_Valid(*aandb)); + assert(pcb_poly_valid(*aandb)); /* delete holes if any left */ while ((p = holes) != NULL) { holes = p->next; @@ -2197,9 +2197,9 @@ clear_marks(b); M_pcb_polyarea_t_Collect(&e, a, aminusb, &holes, PBO_SUB, pcb_false); InsertHoles(&e, *aminusb, &holes); - poly_Free(&a); - poly_Free(&b); - assert(poly_Valid(*aminusb)); + pcb_polyarea_free(&a); + pcb_polyarea_free(&b); + assert(pcb_poly_valid(*aminusb)); } /* delete holes if any left */ while ((p = holes) != NULL) { @@ -2209,12 +2209,12 @@ if (code) { - poly_Free(aandb); - poly_Free(aminusb); + pcb_polyarea_free(aandb); + pcb_polyarea_free(aminusb); return code; } - assert(!*aandb || poly_Valid(*aandb)); - assert(!*aminusb || poly_Valid(*aminusb)); + assert(!*aandb || pcb_poly_valid(*aandb)); + assert(!*aminusb || pcb_poly_valid(*aminusb)); return code; } /* poly_AndSubtract_free */ @@ -2453,7 +2453,7 @@ /**********************************************************************/ /* polygon routines */ -pcb_bool pcb_poly_copy0(pcb_polyarea_t ** dst, const pcb_polyarea_t * src) +pcb_bool pcb_polyarea_copy0(pcb_polyarea_t ** dst, const pcb_polyarea_t * src) { *dst = NULL; if (src != NULL) @@ -2462,10 +2462,10 @@ return pcb_false; (*dst)->contour_tree = r_create_tree(NULL, 0, 0); - return pcb_poly_copy1(*dst, src); + return pcb_polyarea_copy1(*dst, src); } -pcb_bool pcb_poly_copy1(pcb_polyarea_t * dst, const pcb_polyarea_t * src) +pcb_bool pcb_polyarea_copy1(pcb_polyarea_t * dst, const pcb_polyarea_t * src) { pcb_pline_t *cur, **last = &dst->contours; @@ -2481,7 +2481,7 @@ return pcb_true; } -void pcb_poly_m_include(pcb_polyarea_t ** list, pcb_polyarea_t * a) +void pcb_polyarea_m_include(pcb_polyarea_t ** list, pcb_polyarea_t * a) { if (*list == NULL) a->f = a->b = a, *list = a; @@ -2492,7 +2492,7 @@ } } -pcb_bool pcb_poly_m_copy0(pcb_polyarea_t ** dst, const pcb_polyarea_t * srcfst) +pcb_bool pcb_polyarea_m_copy0(pcb_polyarea_t ** dst, const pcb_polyarea_t * srcfst) { const pcb_polyarea_t *src = srcfst; pcb_polyarea_t *di; @@ -2501,15 +2501,15 @@ if (src == NULL) return pcb_false; do { - if ((di = poly_Create()) == NULL || !pcb_poly_copy1(di, src)) + if ((di = pcb_polyarea_create()) == NULL || !pcb_polyarea_copy1(di, src)) return pcb_false; - pcb_poly_m_include(dst, di); + pcb_polyarea_m_include(dst, di); } while ((src = src->f) != srcfst); return pcb_true; } -pcb_bool pcb_poly_contour_include(pcb_polyarea_t * p, pcb_pline_t * c) +pcb_bool pcb_polyarea_contour_include(pcb_polyarea_t * p, pcb_pline_t * c) { pcb_pline_t *tmp; @@ -2577,7 +2577,7 @@ return R_DIR_FOUND_CONTINUE; } -int poly_InsideContour(pcb_pline_t * c, pcb_vector_t p) +int pcb_poly_contour_inside(pcb_pline_t * c, pcb_vector_t p) { struct pip info; pcb_box_t ray; @@ -2594,7 +2594,7 @@ return info.f; } -pcb_bool pcb_poly_contour_inside(pcb_polyarea_t * p, pcb_vector_t v0) +pcb_bool pcb_polyarea_contour_inside(pcb_polyarea_t * p, pcb_vector_t v0) { pcb_pline_t *cur; @@ -2601,9 +2601,9 @@ if ((p == NULL) || (v0 == NULL) || (p->contours == NULL)) return pcb_false; cur = p->contours; - if (poly_InsideContour(cur, v0)) { + if (pcb_poly_contour_inside(cur, v0)) { for (cur = cur->next; cur != NULL; cur = cur->next) - if (poly_InsideContour(cur, v0)) + if (pcb_poly_contour_inside(cur, v0)) return pcb_false; return pcb_true; } @@ -2618,7 +2618,7 @@ return pcb_false; cur = p; do { - if (pcb_poly_contour_inside(cur, v0)) + if (pcb_polyarea_contour_inside(cur, v0)) return pcb_true; } while ((cur = cur->f) != p); @@ -2759,7 +2759,7 @@ * common points between their contours. (Identical contours * are treated as being inside each other). */ -int poly_ContourInContour(pcb_pline_t * poly, pcb_pline_t * inner) +int pcb_poly_contour_in_contour(pcb_pline_t * poly, pcb_pline_t * inner) { pcb_vector_t point; assert(poly != NULL); @@ -2768,16 +2768,16 @@ /* We need to prove the "inner" contour is not outside * "poly" contour. If it is outside, we can return. */ - if (!poly_InsideContour(poly, inner->head.point)) + if (!pcb_poly_contour_inside(poly, inner->head.point)) return 0; poly_ComputeInteriorPoint(inner, point); - return poly_InsideContour(poly, point); + return pcb_poly_contour_inside(poly, point); } return 0; } -void poly_Init(pcb_polyarea_t * p) +void pcb_polyarea_init(pcb_polyarea_t * p) { p->f = p->b = p; p->contours = NULL; @@ -2784,16 +2784,16 @@ p->contour_tree = r_create_tree(NULL, 0, 0); } -pcb_polyarea_t *poly_Create(void) +pcb_polyarea_t *pcb_polyarea_create(void) { pcb_polyarea_t *res; if ((res = (pcb_polyarea_t *) malloc(sizeof(pcb_polyarea_t))) != NULL) - poly_Init(res); + pcb_polyarea_init(res); return res; } -void poly_FreeContours(pcb_pline_t ** pline) +void pcb_poly_contours_free(pcb_pline_t ** pline) { pcb_pline_t *pl; @@ -2803,7 +2803,7 @@ } } -void poly_Free(pcb_polyarea_t ** p) +void pcb_polyarea_free(pcb_polyarea_t ** p) { pcb_polyarea_t *cur; @@ -2810,13 +2810,13 @@ if (*p == NULL) return; for (cur = (*p)->f; cur != *p; cur = (*p)->f) { - poly_FreeContours(&cur->contours); + pcb_poly_contours_free(&cur->contours); r_destroy_tree(&cur->contour_tree); cur->f->b = cur->b; cur->b->f = cur->f; free(cur); } - poly_FreeContours(&cur->contours); + pcb_poly_contours_free(&cur->contours); r_destroy_tree(&cur->contour_tree); free(*p), *p = NULL; } @@ -2842,7 +2842,7 @@ } /* inside_sector */ /* returns pcb_true if bad contour */ -pcb_bool pcb_poly_contour_check(pcb_pline_t * a) +pcb_bool pcb_polyarea_contour_check(pcb_pline_t * a) { pcb_vnode_t *a1, *a2, *hit1, *hit2; pcb_vector_t i1, i2; @@ -2926,7 +2926,7 @@ } -pcb_bool poly_Valid(pcb_polyarea_t * p) +pcb_bool pcb_poly_valid(pcb_polyarea_t * p) { pcb_pline_t *c; @@ -2933,13 +2933,13 @@ if ((p == NULL) || (p->contours == NULL)) return pcb_false; - if (p->contours->Flags.orient == PLF_INV || pcb_poly_contour_check(p->contours)) { + if (p->contours->Flags.orient == PLF_INV || pcb_polyarea_contour_check(p->contours)) { #ifndef NDEBUG pcb_vnode_t *v, *n; DEBUGP("Invalid Outer pcb_pline_t\n"); if (p->contours->Flags.orient == PLF_INV) DEBUGP("failed orient\n"); - if (pcb_poly_contour_check(p->contours)) + if (pcb_polyarea_contour_check(p->contours)) DEBUGP("failed self-intersection\n"); v = &p->contours->head; do { @@ -2951,15 +2951,15 @@ return pcb_false; } for (c = p->contours->next; c != NULL; c = c->next) { - if (c->Flags.orient == PLF_DIR || pcb_poly_contour_check(c) || !poly_ContourInContour(p->contours, c)) { + if (c->Flags.orient == PLF_DIR || pcb_polyarea_contour_check(c) || !pcb_poly_contour_in_contour(p->contours, c)) { #ifndef NDEBUG pcb_vnode_t *v, *n; DEBUGP("Invalid Inner pcb_pline_t orient = %d\n", c->Flags.orient); if (c->Flags.orient == PLF_DIR) DEBUGP("failed orient\n"); - if (pcb_poly_contour_check(c)) + if (pcb_polyarea_contour_check(c)) DEBUGP("failed self-intersection\n"); - if (!poly_ContourInContour(p->contours, c)) + if (!pcb_poly_contour_in_contour(p->contours, c)) DEBUGP("failed containment\n"); v = &c->head; do { Index: trunk/src_plugins/jostle/jostle.c =================================================================== --- trunk/src_plugins/jostle/jostle.c (revision 4988) +++ trunk/src_plugins/jostle/jostle.c (revision 4989) @@ -382,22 +382,22 @@ fprintf(stderr, "hit! %p\n", (void *)line); p[0] = line->Point1.X; p[1] = line->Point1.Y; - if (poly_InsideContour(info->brush->contours, p)) { + if (pcb_poly_contour_inside(info->brush->contours, p)) { pcb_fprintf(stderr, "\tinside1 %ms,%ms\n", p[0], p[1]); inside++; } p[0] = line->Point2.X; p[1] = line->Point2.Y; - if (poly_InsideContour(info->brush->contours, p)) { + if (pcb_poly_contour_inside(info->brush->contours, p)) { pcb_fprintf(stderr, "\tinside2 %ms,%ms\n", p[0], p[1]); inside++; } lp = LinePoly(line, line->Thickness); - if (!pcb_poly_touching(lp, info->brush)) { + if (!pcb_polyarea_touching(lp, info->brush)) { /* not a factor */ return 0; } - poly_Free(&lp); + pcb_polyarea_free(&lp); if (inside) { /* XXX not done! XXX if this is part of a series of lines passing @@ -410,7 +410,7 @@ * around. Use a very fine line. XXX can still graze. */ lp = LinePoly(line, 1); - if (!pcb_poly_m_copy0(©, info->brush)) + if (!pcb_polyarea_m_copy0(©, info->brush)) return 0; r = poly_Boolean_free(copy, lp, &tmp, PBO_SUB); if (r != err_ok) { @@ -482,7 +482,7 @@ if (info->line == NULL || (!nocentroid && (big - small) < info->centroid)) { pcb_fprintf(stderr, "\tkeep it!\n"); if (info->smallest) { - poly_Free(&info->smallest); + pcb_polyarea_free(&info->smallest); } info->centroid = nocentroid ? DBL_MAX : (big - small); info->side = side; @@ -532,7 +532,7 @@ if (found) { expand = NULL; MakeBypassingLines(info.smallest, info.layer, info.line, info.side, &expand); - poly_Free(&info.smallest); + pcb_polyarea_free(&info.smallest); poly_Boolean_free(info.brush, expand, &info.brush, PBO_UNITE); } } while (found); Index: trunk/src_plugins/polycombine/polycombine.c =================================================================== --- trunk/src_plugins/polycombine/polycombine.c (revision 4988) +++ trunk/src_plugins/polycombine/polycombine.c (revision 4989) @@ -48,7 +48,7 @@ *forward = pcb_true; - if ((np = poly_Create()) == NULL) + if ((np = pcb_polyarea_create()) == NULL) return NULL; /* first make initial polygon contour */ @@ -79,9 +79,9 @@ pcb_poly_contour_inv(contour); assert(contour->Flags.orient == (hole ? PLF_INV : PLF_DIR)); - pcb_poly_contour_include(np, contour); + pcb_polyarea_contour_include(np, contour); contour = NULL; - assert(poly_Valid(np)); + assert(pcb_poly_valid(np)); hole++; } @@ -131,11 +131,11 @@ { /* int contours_isect;*/ /* Should check outer contours don't intersect? */ -/* contours_isect = pcb_poly_touching(outer, inner);*/ +/* contours_isect = pcb_polyarea_touching(outer, inner);*/ /* Cheat and assume simple single contour polygons for now */ /* return contours_isect ? - 0 : poly_ContourInContour (outer->contours, inner->contours);*/ - return poly_ContourInContour(outer->contours, inner->contours); + 0 : pcb_poly_contour_in_contour(outer->contours, inner->contours);*/ + return pcb_poly_contour_in_contour(outer->contours, inner->contours); }