Tile based argument

Following the TFS strategy the generated URL like http://.../TFS.php?z=4&x=23&y=10

I need to find the meaning of xyz ... there is no stragety http://dev.openlayers.org/releases/OpenLayers-2.12/doc/apidocs/files/Ope...

But http://dev.openlayers.org/releases/OpenLayers-2.12/doc/apidocs/files/Ope... has the z/x/y.png construct.

Do you know how to calculate the bounding box from z/x/y ?

I hope to add the argument handler today/tomorrow.

My initial thought were to add a new argument handler but I guess BBOX is similar to tile that much we better could merge these.

Here is my bad patch first as I guess it points some puzzles.

- the new handler doesn't show up: I guess I missed a step

- debugging by using http://api.drupal.org/api/views/views.api.php/function/hook_views_plugin... (hook_views_plugins_alter) reveils a weird argument 'default handler': our querystring handler from views_geojson_views_plugins ... I'm not sure why we provide a default handler

Next comment will contain a changed BBOX argument handler.

(put this on needs review as I'd love to know what these two points mean)

It removed the bbox logic from the ->query

This patch changes views_geojson_bbox_argument by adding a few more settings.

It has some todos and it should have a conditional field set for the zxy selection.

Please give it a quick review :p

The algorithm zxy is I guess done here in reverse.

https://github.com/openlayers/openlayers/blob/master/lib/OpenLayers/Laye...

    getXYZ: function(bounds) {
        var res = this.getServerResolution();
        var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));
        var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h));
        var z = this.getServerZoom();

        if (this.wrapDateLine) {
            var limit = Math.pow(2, z);
            x = ((x % limit) + limit) % limit;
        }

        return {'x': x, 'y': y, 'z': z};
    },

This uses some extra settings which we probably need too

• ServerResolution : we do not have a resolution for vector based data right?
• TileSize.w : is this in px (250 default)?
• TileSize.h : in px ?

Furthermore the x,y are left,top oriented not center.

New patch has

- some reordering
- options_from to choose what strategy to use

As I'm struggling with the client side for tiles (http://gaganb.wordpress.com/2012/02/15/tile-feature-strategy-in-openlayers/) seems to have bug(s) :( I still haven't implemented the inverse of #5.

Reattaching image

Should we focus on this feature only for GeoJSON or a new project like views_geo_filter? See my comment #2 in #1877072: Allow BBOX in other display format..

Doing a views caching is possible with ZXY but almost futile for BBOX when users are allowed to drag the maps.

I must investigate on the views caching algorithm whether it is possible at all as ZXY has one argument handler but 3 arguments :(

But we probably take varnish as the cache engine processing ZXY request.

I'm not sure how we could sub class a default argument handler. That requires a module? A did not find docs on it :(

But I still don't know how #10

I'm not sure how we could sub class a default argument handler. That requires a module? A did not find docs on it :(

should be handled. I'm tempted to create the views_geo_filters project to provide all views BBOX and/or ZXY filtering capabilities. Maybe I'm on the wrong thought track? It also depends on my customer mapping wishes with aren't still that clear :(

This http://wiki.osgeo.org/wiki/WMS_Tiling_Client_Recommendation states one should publish capabilities using ZXY ... that is probably true for BBOX too?

There is code in Openlayers.Map.js doing it another way. Maybe that helps

calculateBounds: function(center, resolution) {
var extent = null;
if (center == null) {
center = this.getCachedCenter();
}
if (resolution == null) {
resolution = this.getResolution();
}
if ((center != null) && (resolution != null)) {
var halfWDeg = (this.size.w * resolution) / 2;
var halfHDeg = (this.size.h * resolution) / 2;
extent = new OpenLayers.Bounds(center.lon - halfWDeg,
center.lat - halfHDeg,
center.lon + halfWDeg,
center.lat + halfHDeg);
}
return extent;
}, 

So we want to reduce our geojson request by transforming request like

http://.../geo/feeds/restaurants?bbox=4.6663614729841,52.285497251916,5.1078745270159,52.453194957342

which is not cachable into several ZXY requests based which are.

http://.../geo/feeds/restaurants/?z=12&x=?&y=?

But the algorithm should use 'resolution' similar to #16?

I just realize I haven't tested the layer request yet :( as it prob looks like

http://.../geo/feeds/restaurants/12/4/7 instead of it's bounding box sibling.

This is my reference http://dev.openlayers.org/docs/files/OpenLayers/Layer/XYZ-js.html where the request going to Drupal is constructed. That is the getBounds() is converted to one or more ZXY request.

On the receiving part (views_geojson) we need to translate the Z/X/Y arguments back to bounding box arguments. As the combination of Z/X/Y is limited we can enable caching for it which would boost performance.

So I expect a function in PHP like this.

function views_geojson_zxy_to_bbox($z, $x, $y) {
  // heavy calculation ;)

  return array( 'left' => $left,  'top' => $left,  'bottom' => $bottom,  'right' => $right,);
}