lwgeom_geohash_precision()

int lwgeom_geohash_precision	(	GBOX	bbox,
		GBOX *	bounds
	)

Definition at line 750 of file lwalgorithm.c.

References precision, GBOX::xmax, GBOX::xmin, GBOX::ymax, and GBOX::ymin.

Referenced by lwgeom_geohash(), and test_geohash_precision().

{
        double minx, miny, maxx, maxy;
        double latmax, latmin, lonmax, lonmin;
        double lonwidth, latwidth;
        double latmaxadjust, lonmaxadjust, latminadjust, lonminadjust;
        int precision = 0;

        /* Get the bounding box, return error if things don't work out. */
        minx = bbox.xmin;
        miny = bbox.ymin;
        maxx = bbox.xmax;
        maxy = bbox.ymax;

        if ( minx == maxx && miny == maxy )
        {
                /* It's a point. Doubles have 51 bits of precision.
                ** 2 * 51 / 5 == 20 */
                return 20;
        }

        lonmin = -180.0;
        latmin = -90.0;
        lonmax = 180.0;
        latmax = 90.0;

        /* Shrink a world bounding box until one of the edges interferes with the
        ** bounds of our rectangle. */
        while ( 1 )
        {
                lonwidth = lonmax - lonmin;
                latwidth = latmax - latmin;
                latmaxadjust = lonmaxadjust = latminadjust = lonminadjust = 0.0;

                if ( minx > lonmin + lonwidth / 2.0 )
                {
                        lonminadjust = lonwidth / 2.0;
                }
                else if ( maxx < lonmax - lonwidth / 2.0 )
                {
                        lonmaxadjust = -1 * lonwidth / 2.0;
                }
                if ( lonminadjust || lonmaxadjust )
                {
                        lonmin += lonminadjust;
                        lonmax += lonmaxadjust;
                        /* Each adjustment cycle corresponds to 2 bits of storage in the
                        ** geohash.     */
                        precision++;
                }
                else
                {
                        break;
                }

                if ( miny > latmin + latwidth / 2.0 )
                {
                        latminadjust = latwidth / 2.0;
                }
                else if (maxy < latmax - latwidth / 2.0 )
                {
                        latmaxadjust = -1 * latwidth / 2.0;
                }
                /* Only adjust if adjustments are legal (we haven't crossed any edges). */
                if ( latminadjust || latmaxadjust )
                {
                        latmin += latminadjust;
                        latmax += latmaxadjust;
                        /* Each adjustment cycle corresponds to 2 bits of storage in the
                        ** geohash.     */
                        precision++;
                }
                else
                {
                        break;
                }
        }

        /* Save the edges of our bounds, in case someone cares later. */
        bounds->xmin = lonmin;
        bounds->xmax = lonmax;
        bounds->ymin = latmin;
        bounds->ymax = latmax;

        /* Each geohash character (base32) can contain 5 bits of information.
        ** We are returning the precision in characters, so here we divide. */
        return precision / 5;
}

Here is the caller graph for this function: