pointarray_to_encoded_polyline()

static char * pointarray_to_encoded_polyline ( const POINTARRAY *  pa, int  precision  )

static

Definition at line 68 of file lwout_encoded_polyline.c.

References getPoint2d_cp(), lwalloc(), lwfree(), POINTARRAY::npoints, stringbuffer_aprintf(), stringbuffer_create(), stringbuffer_destroy(), stringbuffer_getstringcopy(), POINT2D::x, and POINT2D::y.

Referenced by lwline_to_encoded_polyline().

{
        int i;
        const POINT2D* prevPoint;
        int* delta;
        char* encoded_polyline = NULL;
        stringbuffer_t* sb;
        double scale = pow(10, precision);

        /* Empty input is empty string */
        if (pa->npoints == 0) {
                encoded_polyline = lwalloc(1 * sizeof(char));
                encoded_polyline[0] = 0;
                return encoded_polyline;
        }

        delta = lwalloc(2 * sizeof(int) * pa->npoints);

        /* Take the double value and multiply it by 1x10^precision, rounding the
         * result */
        prevPoint = getPoint2d_cp(pa, 0);
        delta[0] = round(prevPoint->y * scale);
        delta[1] = round(prevPoint->x * scale);

        /* Points only include the offset from the previous point */
        for (i = 1; i < pa->npoints; i++)
        {
                const POINT2D* point = getPoint2d_cp(pa, i);
                delta[2 * i] = round(point->y * scale) - round(prevPoint->y * scale);
                delta[(2 * i) + 1] =
                        round(point->x * scale) - round(prevPoint->x * scale);
                prevPoint = point;
        }

        /* value to binary: a negative value must be calculated using its two's
         * complement */
        for (i = 0; i < pa->npoints * 2; i++)
        {
                /* Multiply by 2 for a signed left shift */
                delta[i] *= 2;
                /* if value is negative, invert this encoding */
                if (delta[i] < 0) {
                        delta[i] = ~(delta[i]);
                }
        }

        sb = stringbuffer_create();
        for (i = 0; i < pa->npoints * 2; i++)
        {
                int numberToEncode = delta[i];

                while (numberToEncode >= 0x20)
                {
                        /* Place the 5-bit chunks into reverse order or
                         each value with 0x20 if another bit chunk follows and add 63*/
                        int nextValue = (0x20 | (numberToEncode & 0x1f)) + 63;
                        stringbuffer_aprintf(sb, "%c", (char)nextValue);

                        /* Break the binary value out into 5-bit chunks */
                        numberToEncode >>= 5;
                }

                numberToEncode += 63;
                stringbuffer_aprintf(sb, "%c", (char)numberToEncode);
        }

        lwfree(delta);
        encoded_polyline = stringbuffer_getstringcopy(sb);
        stringbuffer_destroy(sb);

        return encoded_polyline;
}

Here is the call graph for this function:

Here is the caller graph for this function: