lw_dist2d_fast_ptarray_ptarray()

int lw_dist2d_fast_ptarray_ptarray	(	POINTARRAY *	l1,
		POINTARRAY *	l2,
		DISTPTS *	dl,
		GBOX *	box1,
		GBOX *	box2
	)

The new faster calculation comparing pointarray to another pointarray the arrays can come from both polygons and linestrings.

The naming is not good but comes from that it compares a chosen selection of the points not all of them

Definition at line 2046 of file measures.c.

{
        /*here we define two lists to hold our calculated "z"-values and the order number in the geometry*/
 
        double k, thevalue;
        float deltaX, deltaY, c1m, c2m;
        POINT2D c1, c2;
        const POINT2D *theP;
        float min1X, max1X, max1Y, min1Y, min2X, max2X, max2Y, min2Y;
        int t;
        int n1 = l1->npoints;
        int n2 = l2->npoints;
 
        LISTSTRUCT *list1, *list2;
        list1 = (LISTSTRUCT *)lwalloc(sizeof(LISTSTRUCT) * n1);
        list2 = (LISTSTRUCT *)lwalloc(sizeof(LISTSTRUCT) * n2);
 
        LWDEBUG(2, "lw_dist2d_fast_ptarray_ptarray is called");
 
        max1X = box1->xmax;
        min1X = box1->xmin;
        max1Y = box1->ymax;
        min1Y = box1->ymin;
        max2X = box2->xmax;
        min2X = box2->xmin;
        max2Y = box2->ymax;
        min2Y = box2->ymin;
        /*we want the center of the bboxes, and calculate the slope between the centerpoints*/
        c1.x = min1X + (max1X - min1X) / 2;
        c1.y = min1Y + (max1Y - min1Y) / 2;
        c2.x = min2X + (max2X - min2X) / 2;
        c2.y = min2Y + (max2Y - min2Y) / 2;
 
        deltaX = (c2.x - c1.x);
        deltaY = (c2.y - c1.y);
 
        /*Here we calculate where the line perpendicular to the center-center line crosses the axes for each vertex
        if the center-center line is vertical the perpendicular line will be horizontal and we find it's crossing the
        Y-axes with z = y-kx */
        if ((deltaX * deltaX) < (deltaY * deltaY)) /*North or South*/
        {
                k = -deltaX / deltaY;
                for (t = 0; t < n1; t++) /*for each segment in L1 */
                {
                        theP = getPoint2d_cp(l1, t);
                        thevalue = theP->y - (k * theP->x);
                        list1[t].themeasure = thevalue;
                        list1[t].pnr = t;
                }
                for (t = 0; t < n2; t++) /*for each segment in L2*/
                {
                        theP = getPoint2d_cp(l2, t);
                        thevalue = theP->y - (k * theP->x);
                        list2[t].themeasure = thevalue;
                        list2[t].pnr = t;
                }
                c1m = c1.y - (k * c1.x);
                c2m = c2.y - (k * c2.x);
        }
 
        /*if the center-center line is horizontal the perpendicular line will be vertical. To eliminate problems with
         dividing by zero we are here mirroring the coordinate-system and we find it's crossing the X-axes with z =
         x-(1/k)y */
        else /*West or East*/
        {
                k = -deltaY / deltaX;
                for (t = 0; t < n1; t++) /*for each segment in L1 */
                {
                        theP = getPoint2d_cp(l1, t);
                        thevalue = theP->x - (k * theP->y);
                        list1[t].themeasure = thevalue;
                        list1[t].pnr = t;
                        /* lwnotice("l1 %d, measure=%f",t,thevalue ); */
                }
                for (t = 0; t < n2; t++) /*for each segment in L2*/
                {
                        theP = getPoint2d_cp(l2, t);
                        thevalue = theP->x - (k * theP->y);
                        list2[t].themeasure = thevalue;
                        list2[t].pnr = t;
                        /* lwnotice("l2 %d, measure=%f",t,thevalue ); */
                }
                c1m = c1.x - (k * c1.y);
                c2m = c2.x - (k * c2.y);
        }
 
        /*we sort our lists by the calculated values*/
        qsort(list1, n1, sizeof(LISTSTRUCT), struct_cmp_by_measure);
        qsort(list2, n2, sizeof(LISTSTRUCT), struct_cmp_by_measure);
 
        if (c1m < c2m)
        {
                if (!lw_dist2d_pre_seg_seg(l1, l2, list1, list2, k, dl))
                {
                        lwfree(list1);
                        lwfree(list2);
                        return LW_FALSE;
                }
        }
        else
        {
                dl->twisted = ((dl->twisted) * (-1));
                if (!lw_dist2d_pre_seg_seg(l2, l1, list2, list1, k, dl))
                {
                        lwfree(list1);
                        lwfree(list2);
                        return LW_FALSE;
                }
        }
        lwfree(list1);
        lwfree(list2);
        return LW_TRUE;
}

References getPoint2d_cp(), lw_dist2d_pre_seg_seg(), LW_FALSE, LW_TRUE, lwalloc(), LWDEBUG, lwfree(), POINTARRAY::npoints, LISTSTRUCT::pnr, struct_cmp_by_measure(), LISTSTRUCT::themeasure, DISTPTS::twisted, POINT2D::x, GBOX::xmax, GBOX::xmin, POINT2D::y, GBOX::ymax, and GBOX::ymin.

Referenced by lw_dist2d_distribute_fast().

Here is the call graph for this function:

Here is the caller graph for this function: