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 1943 of file measures.c.

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 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 deviding 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;
}

Here is the call graph for this function:

Here is the caller graph for this function: