Merge pull request #3571 from ahocevar/vector-wrapx

Add wrapX support for vector layers (canvas renderer only)

test/spec/ol/proj/proj.test.js

@@ -138,6 +138,46 @@ describe('ol.proj', function() {
     });
   });
 
+  describe('canWrapX()', function() {
+
+    it('requires an extent for allowing wrapX', function() {
+      var proj = new ol.proj.Projection({
+        code: 'foo',
+        global: true
+      });
+      expect(proj.canWrapX()).to.be(false);
+      proj.setExtent([1, 2, 3, 4]);
+      expect(proj.canWrapX()).to.be(true);
+      proj = new ol.proj.Projection({
+        code: 'foo',
+        global: true,
+        extent: [1, 2, 3, 4]
+      });
+      expect(proj.canWrapX()).to.be(true);
+      proj.setExtent(null);
+      expect(proj.canWrapX()).to.be(false);
+    });
+
+    it('requires global to be true for allowing wrapX', function() {
+      var proj = new ol.proj.Projection({
+        code: 'foo',
+        extent: [1, 2, 3, 4]
+      });
+      expect(proj.canWrapX()).to.be(false);
+      proj.setGlobal(true);
+      expect(proj.canWrapX()).to.be(true);
+      proj = new ol.proj.Projection({
+        code: 'foo',
+        global: true,
+        extent: [1, 2, 3, 4]
+      });
+      expect(proj.canWrapX()).to.be(true);
+      proj.setGlobal(false);
+      expect(proj.canWrapX()).to.be(false);
+    });
+
+  });
+
   describe('transformExtent()', function() {
 
     it('transforms an extent given projection identifiers', function() {

test/spec/ol/renderer/canvas/canvasmaprenderer.test.js

@@ -0,0 +1,90 @@
+goog.provide('ol.test.renderer.canvas.Map');
+
+describe('ol.renderer.canvas.Map', function() {
+
+  describe('constructor', function() {
+
+    it('creates a new instance', function() {
+      var map = new ol.Map({
+        target: document.createElement('div')
+      });
+      var renderer = new ol.renderer.canvas.Map(map.viewport_, map);
+      expect(renderer).to.be.a(ol.renderer.canvas.Map);
+    });
+
+  });
+
+  describe('#renderFrame()', function() {
+    var layer, map, renderer;
+
+    beforeEach(function() {
+      map = new ol.Map({});
+      map.on('postcompose', function() {});
+      layer = new ol.layer.Vector({
+        source: new ol.source.Vector({wrapX: true})
+      });
+      renderer = map.getRenderer();
+      renderer.layerRenderers_ = {};
+      var layerRenderer = new ol.renderer.canvas.Layer(layer);
+      layerRenderer.prepareFrame = function() { return true; };
+      layerRenderer.getImage = function() { return null; };
+      renderer.layerRenderers_[goog.getUid(layer)] = layerRenderer;
+    });
+
+    it('uses correct extent and offset on wrapped worlds', function() {
+      var spy = sinon.spy(renderer, 'getTransform');
+      var proj = new ol.proj.Projection({
+        code: 'foo',
+        extent: [-180, -90, 180, 90],
+        global: true
+      });
+      var frameState = {
+        coordinateToPixelMatrix: map.coordinateToPixelMatrix_,
+        pixelToCoordinateMatrix: map.pixelToCoordinateMatrix_,
+        pixelRatio: 1,
+        size: [100, 100],
+        skippedFeatureUids: {},
+        extent: proj.getExtent(),
+        viewState: {
+          center: [0, 0],
+          projection: proj,
+          resolution: 1,
+          rotation: 0
+        },
+        layerStates: {},
+        layerStatesArray: [{
+          layer: layer,
+          sourceState: 'ready',
+          visible: true,
+          minResolution: 1,
+          maxResolution: 2
+        }],
+        postRenderFunctions: []
+      };
+      frameState.focus = [0, 0];
+      // focus is on real world
+      renderer.renderFrame(frameState);
+      expect(spy.getCall(0).args[1]).to.be(0);
+      expect(renderer.replayGroup.maxExtent_).to.eql([-180, -90, 180, 90]);
+      frameState.focus = [-200, 0];
+      // focus is one world left of the real world
+      renderer.renderFrame(frameState);
+      expect(spy.getCall(1).args[1]).to.be(360);
+      expect(renderer.replayGroup.maxExtent_).to.eql([180, -90, 540, 90]);
+      frameState.focus = [200, 0];
+      // focus is one world right of the real world
+      renderer.renderFrame(frameState);
+      expect(spy.getCall(2).args[1]).to.be(-360);
+      expect(renderer.replayGroup.maxExtent_).to.eql([-540, -90, -180, 90]);
+    });
+  });
+
+});
+
+
+goog.require('ol.layer.Vector');
+goog.require('ol.Map');
+goog.require('ol.proj.Projection');
+goog.require('ol.renderer.canvas.Layer');
+goog.require('ol.renderer.canvas.Map');
+goog.require('ol.source.Vector');

test/spec/ol/renderer/canvas/canvasvectorlayerrenderer.test.js

@@ -5,14 +5,10 @@ describe('ol.renderer.canvas.VectorLayer', function() {
   describe('constructor', function() {
 
     it('creates a new instance', function() {
-      var map = new ol.Map({
-        target: document.createElement('div')
-      });
       var layer = new ol.layer.Vector({
         source: new ol.source.Vector()
       });
-      var renderer = new ol.renderer.canvas.VectorLayer(map.getRenderer(),
-          layer);
+      var renderer = new ol.renderer.canvas.VectorLayer(layer);
       expect(renderer).to.be.a(ol.renderer.canvas.VectorLayer);
     });
 
@@ -59,27 +55,24 @@ describe('ol.renderer.canvas.VectorLayer', function() {
   });
 
   describe('#forEachFeatureAtCoordinate', function() {
-    var renderer;
+    var layer, renderer;
 
     beforeEach(function() {
-      var map = new ol.Map({});
-      var layer = new ol.layer.Vector({
+      layer = new ol.layer.Vector({
         source: new ol.source.Vector()
       });
-      renderer = new ol.renderer.canvas.VectorLayer(
-          map.getRenderer(), layer);
+      renderer = new ol.renderer.canvas.VectorLayer(layer);
       var replayGroup = {};
       renderer.replayGroup_ = replayGroup;
       replayGroup.forEachFeatureAtCoordinate = function(coordinate,
           resolution, rotation, skippedFeaturesUids, callback) {
-        var geometry = new ol.geom.Point([0, 0]);
         var feature = new ol.Feature();
-        callback(geometry, feature);
-        callback(geometry, feature);
+        callback(feature);
+        callback(feature);
       };
     });
 
-    it('calls callback once per feature', function() {
+    it('calls callback once per feature with a layer as 2nd arg', function() {
       var spy = sinon.spy();
       var coordinate = [0, 0];
       var frameState = {
@@ -92,6 +85,7 @@ describe('ol.renderer.canvas.VectorLayer', function() {
       renderer.forEachFeatureAtCoordinate(
           coordinate, frameState, spy, undefined);
       expect(spy.callCount).to.be(1);
+      expect(spy.getCall(0).args[1]).to.equal(layer);
     });
   });