Named exports from ol/transform

src/ol/renderer/Map.js

@@ -10,7 +10,7 @@ import {TRUE} from '../functions.js';
 import {visibleAtResolution} from '../layer/Layer.js';
 import {getLayerRendererPlugins} from '../plugins.js';
 import {iconImageCache} from '../style.js';
-import _ol_transform_ from '../transform.js';
+import {compose as composeTransform, invert as invertTransform, setFromArray as transformSetFromArray} from '../transform.js';
 
 /**
  * @constructor
@@ -56,14 +56,14 @@ MapRenderer.prototype.calculateMatrices2D = function(frameState) {
   const coordinateToPixelTransform = frameState.coordinateToPixelTransform;
   const pixelToCoordinateTransform = frameState.pixelToCoordinateTransform;
 
-  _ol_transform_.compose(coordinateToPixelTransform,
+  composeTransform(coordinateToPixelTransform,
     frameState.size[0] / 2, frameState.size[1] / 2,
     1 / viewState.resolution, -1 / viewState.resolution,
     -viewState.rotation,
     -viewState.center[0], -viewState.center[1]);
 
-  _ol_transform_.invert(
-    _ol_transform_.setFromArray(pixelToCoordinateTransform, coordinateToPixelTransform));
+  invertTransform(
+    transformSetFromArray(pixelToCoordinateTransform, coordinateToPixelTransform));
 };
 
 

src/ol/renderer/canvas/ImageLayer.js

@@ -13,7 +13,7 @@ import {assign} from '../../obj.js';
 import {getLayerRendererPlugins} from '../../plugins.js';
 import RendererType from '../Type.js';
 import IntermediateCanvasRenderer from '../canvas/IntermediateCanvas.js';
-import _ol_transform_ from '../../transform.js';
+import {create as createTransform, compose as composeTransform} from '../../transform.js';
 
 /**
  * @constructor
@@ -35,7 +35,7 @@ const CanvasImageLayerRenderer = function(imageLayer) {
    * @private
    * @type {ol.Transform}
    */
-  this.imageTransform_ = _ol_transform_.create();
+  this.imageTransform_ = createTransform();
 
   /**
    * @type {!Array.<string>}
@@ -175,13 +175,13 @@ CanvasImageLayerRenderer.prototype.prepareFrame = function(frameState, layerStat
     const imagePixelRatio = image.getPixelRatio();
     const scale = pixelRatio * imageResolution /
         (viewResolution * imagePixelRatio);
-    const transform = _ol_transform_.compose(this.imageTransform_,
+    const transform = composeTransform(this.imageTransform_,
       pixelRatio * size[0] / 2, pixelRatio * size[1] / 2,
       scale, scale,
       0,
       imagePixelRatio * (imageExtent[0] - viewCenter[0]) / imageResolution,
       imagePixelRatio * (viewCenter[1] - imageExtent[3]) / imageResolution);
-    _ol_transform_.compose(this.coordinateToCanvasPixelTransform,
+    composeTransform(this.coordinateToCanvasPixelTransform,
       pixelRatio * size[0] / 2 - transform[4], pixelRatio * size[1] / 2 - transform[5],
       pixelRatio / viewResolution, -pixelRatio / viewResolution,
       0,

src/ol/renderer/canvas/IntermediateCanvas.js

@@ -6,7 +6,7 @@ import {scale as scaleCoordinate} from '../../coordinate.js';
 import {createCanvasContext2D} from '../../dom.js';
 import {containsExtent, intersects} from '../../extent.js';
 import CanvasLayerRenderer from '../canvas/Layer.js';
-import _ol_transform_ from '../../transform.js';
+import {create as createTransform, apply as applyTransform} from '../../transform.js';
 
 /**
  * @constructor
@@ -22,7 +22,7 @@ const IntermediateCanvasRenderer = function(layer) {
    * @protected
    * @type {ol.Transform}
    */
-  this.coordinateToCanvasPixelTransform = _ol_transform_.create();
+  this.coordinateToCanvasPixelTransform = createTransform();
 
   /**
    * @private
@@ -128,7 +128,7 @@ IntermediateCanvasRenderer.prototype.forEachLayerAtCoordinate = function(coordin
     // so that for example also transparent polygons are detected
     return CanvasLayerRenderer.prototype.forEachLayerAtCoordinate.apply(this, arguments);
   } else {
-    const pixel = _ol_transform_.apply(this.coordinateToCanvasPixelTransform, coordinate.slice());
+    const pixel = applyTransform(this.coordinateToCanvasPixelTransform, coordinate.slice());
     scaleCoordinate(pixel, frameState.viewState.resolution / this.renderedResolution);
 
     if (!this.hitCanvasContext_) {

src/ol/renderer/canvas/Layer.js

@@ -9,7 +9,7 @@ import RenderEventType from '../../render/EventType.js';
 import {rotateAtOffset} from '../../render/canvas.js';
 import CanvasImmediateRenderer from '../../render/canvas/Immediate.js';
 import LayerRenderer from '../Layer.js';
-import _ol_transform_ from '../../transform.js';
+import {create as createTransform, apply as applyTransform, compose as composeTransform} from '../../transform.js';
 
 /**
  * @constructor
@@ -31,7 +31,7 @@ const CanvasLayerRenderer = function(layer) {
    * @private
    * @type {ol.Transform}
    */
-  this.transform_ = _ol_transform_.create();
+  this.transform_ = createTransform();
 
 };
 
@@ -54,10 +54,10 @@ CanvasLayerRenderer.prototype.clip = function(context, frameState, extent) {
   const bottomRight = getBottomRight(/** @type {ol.Extent} */ (extent));
   const bottomLeft = getBottomLeft(/** @type {ol.Extent} */ (extent));
 
-  _ol_transform_.apply(frameState.coordinateToPixelTransform, topLeft);
-  _ol_transform_.apply(frameState.coordinateToPixelTransform, topRight);
-  _ol_transform_.apply(frameState.coordinateToPixelTransform, bottomRight);
-  _ol_transform_.apply(frameState.coordinateToPixelTransform, bottomLeft);
+  applyTransform(frameState.coordinateToPixelTransform, topLeft);
+  applyTransform(frameState.coordinateToPixelTransform, topRight);
+  applyTransform(frameState.coordinateToPixelTransform, bottomRight);
+  applyTransform(frameState.coordinateToPixelTransform, bottomLeft);
 
   context.save();
   rotateAtOffset(context, -rotation, width / 2, height / 2);
@@ -168,7 +168,7 @@ CanvasLayerRenderer.prototype.getTransform = function(frameState, offsetX) {
   const angle = -viewState.rotation;
   const dx2 = -viewState.center[0] + offsetX;
   const dy2 = -viewState.center[1];
-  return _ol_transform_.compose(this.transform_, dx1, dy1, sx, sy, angle, dx2, dy2);
+  return composeTransform(this.transform_, dx1, dy1, sx, sy, angle, dx2, dy2);
 };
 
 

src/ol/renderer/canvas/Map.js

@@ -3,7 +3,7 @@
  */
 // FIXME offset panning
 
-import _ol_transform_ from '../../transform.js';
+import {create as createTransform, apply as applyTransform, compose as composeTransform} from '../../transform.js';
 import {inherits} from '../../index.js';
 import {stableSort} from '../../array.js';
 import {CLASS_UNSELECTABLE} from '../../css.js';
@@ -56,7 +56,7 @@ const CanvasMapRenderer = function(container, map) {
    * @private
    * @type {ol.Transform}
    */
-  this.transform_ = _ol_transform_.create();
+  this.transform_ = createTransform();
 
 };
 
@@ -123,7 +123,7 @@ CanvasMapRenderer.prototype.getTransform = function(frameState) {
   const angle = -viewState.rotation;
   const dx2 = -viewState.center[0];
   const dy2 = -viewState.center[1];
-  return _ol_transform_.compose(this.transform_, dx1, dy1, sx, sy, angle, dx2, dy2);
+  return composeTransform(this.transform_, dx1, dy1, sx, sy, angle, dx2, dy2);
 };
 
 
@@ -216,7 +216,7 @@ CanvasMapRenderer.prototype.forEachLayerAtPixel = function(pixel, frameState, ca
   const layerStates = frameState.layerStatesArray;
   const numLayers = layerStates.length;
 
-  const coordinate = _ol_transform_.apply(
+  const coordinate = applyTransform(
     frameState.pixelToCoordinateTransform, pixel.slice());
 
   let i;

src/ol/renderer/canvas/TileLayer.js

@@ -10,7 +10,7 @@ import {createCanvasContext2D} from '../../dom.js';
 import {containsExtent, createEmpty, equals, getIntersection, isEmpty} from '../../extent.js';
 import RendererType from '../Type.js';
 import IntermediateCanvasRenderer from '../canvas/IntermediateCanvas.js';
-import _ol_transform_ from '../../transform.js';
+import {create as createTransform, compose as composeTransform} from '../../transform.js';
 
 /**
  * @constructor
@@ -68,7 +68,7 @@ const CanvasTileLayerRenderer = function(tileLayer) {
    * @private
    * @type {ol.Transform}
    */
-  this.imageTransform_ = _ol_transform_.create();
+  this.imageTransform_ = createTransform();
 
   /**
    * @protected
@@ -275,13 +275,13 @@ CanvasTileLayerRenderer.prototype.prepareFrame = function(frameState, layerState
   }
 
   const scale = this.renderedResolution / viewResolution;
-  const transform = _ol_transform_.compose(this.imageTransform_,
+  const transform = composeTransform(this.imageTransform_,
     pixelRatio * size[0] / 2, pixelRatio * size[1] / 2,
     scale, scale,
     0,
     (this.renderedExtent_[0] - viewCenter[0]) / this.renderedResolution * pixelRatio,
     (viewCenter[1] - this.renderedExtent_[3]) / this.renderedResolution * pixelRatio);
-  _ol_transform_.compose(this.coordinateToCanvasPixelTransform,
+  composeTransform(this.coordinateToCanvasPixelTransform,
     pixelRatio * size[0] / 2 - transform[4], pixelRatio * size[1] / 2 - transform[5],
     pixelRatio / viewResolution, -pixelRatio / viewResolution,
     0,

src/ol/renderer/canvas/VectorTileLayer.js

@@ -19,7 +19,13 @@ import _ol_render_replay_ from '../../render/replay.js';
 import RendererType from '../Type.js';
 import CanvasTileLayerRenderer from '../canvas/TileLayer.js';
 import {getSquaredTolerance as getSquaredRenderTolerance, renderFeature} from '../vector.js';
-import _ol_transform_ from '../../transform.js';
+import {
+  create as createTransform,
+  compose as composeTransform,
+  reset as resetTransform,
+  scale as scaleTransform,
+  translate as translateTransform
+} from '../../transform.js';
 
 
 /**
@@ -79,7 +85,7 @@ const CanvasVectorTileLayerRenderer = function(layer) {
    * @private
    * @type {ol.Transform}
    */
-  this.tmpTransform_ = _ol_transform_.create();
+  this.tmpTransform_ = createTransform();
 
   // Use lower resolution for pure vector rendering. Closest resolution otherwise.
   this.zDirection = layer.getRenderMode() == VectorTileRenderType.VECTOR ? 1 : 0;
@@ -327,7 +333,7 @@ CanvasVectorTileLayerRenderer.prototype.getReplayTransform_ = function(tile, fra
   const size = frameState.size;
   const offsetX = Math.round(pixelRatio * size[0] / 2);
   const offsetY = Math.round(pixelRatio * size[1] / 2);
-  return _ol_transform_.compose(this.tmpTransform_,
+  return composeTransform(this.tmpTransform_,
     offsetX, offsetY,
     tileResolution / renderResolution, tileResolution / renderResolution,
     viewState.rotation,
@@ -502,9 +508,9 @@ CanvasVectorTileLayerRenderer.prototype.renderTileImage_ = function(
         continue;
       }
       const pixelScale = pixelRatio / resolution;
-      const transform = _ol_transform_.reset(this.tmpTransform_);
-      _ol_transform_.scale(transform, pixelScale, -pixelScale);
-      _ol_transform_.translate(transform, -tileExtent[0], -tileExtent[3]);
+      const transform = resetTransform(this.tmpTransform_);
+      scaleTransform(transform, pixelScale, -pixelScale);
+      translateTransform(transform, -tileExtent[0], -tileExtent[3]);
       const replayGroup = sourceTile.getReplayGroup(layer, tile.tileCoord.toString());
       replayGroup.replay(context, transform, 0, {}, replays);
     }

src/ol/renderer/webgl/ImageLayer.js

@@ -10,7 +10,16 @@ import {getIntersection, isEmpty} from '../../extent.js';
 import {TRUE} from '../../functions.js';
 import RendererType from '../Type.js';
 import WebGLLayerRenderer from '../webgl/Layer.js';
-import _ol_transform_ from '../../transform.js';
+import {
+  create as createTransform,
+  rotate as rotateTransform,
+  translate as translateTransform,
+  scale as scaleTransform,
+  reset as resetTransform,
+  apply as applyTransform,
+  invert as invertTransform,
+  multiply as multiplyTransform
+} from '../../transform.js';
 import _ol_webgl_ from '../../webgl.js';
 import {createTexture} from '../../webgl/Context.js';
 
@@ -183,9 +192,9 @@ WebGLImageLayerRenderer.prototype.prepareFrame = function(frameState, layerState
 
     // Translate and scale to flip the Y coord.
     const texCoordMatrix = this.texCoordMatrix;
-    _ol_transform_.reset(texCoordMatrix);
-    _ol_transform_.scale(texCoordMatrix, 1, -1);
-    _ol_transform_.translate(texCoordMatrix, 0, -1);
+    resetTransform(texCoordMatrix);
+    scaleTransform(texCoordMatrix, 1, -1);
+    translateTransform(texCoordMatrix, 0, -1);
 
     this.image_ = image;
     this.texture = texture;
@@ -212,18 +221,18 @@ WebGLImageLayerRenderer.prototype.updateProjectionMatrix_ = function(canvasWidth
   const canvasExtentHeight = canvasHeight * viewResolution;
 
   const projectionMatrix = this.projectionMatrix;
-  _ol_transform_.reset(projectionMatrix);
-  _ol_transform_.scale(projectionMatrix,
+  resetTransform(projectionMatrix);
+  scaleTransform(projectionMatrix,
     pixelRatio * 2 / canvasExtentWidth,
     pixelRatio * 2 / canvasExtentHeight);
-  _ol_transform_.rotate(projectionMatrix, -viewRotation);
-  _ol_transform_.translate(projectionMatrix,
+  rotateTransform(projectionMatrix, -viewRotation);
+  translateTransform(projectionMatrix,
     imageExtent[0] - viewCenter[0],
     imageExtent[1] - viewCenter[1]);
-  _ol_transform_.scale(projectionMatrix,
+  scaleTransform(projectionMatrix,
     (imageExtent[2] - imageExtent[0]) / 2,
     (imageExtent[3] - imageExtent[1]) / 2);
-  _ol_transform_.translate(projectionMatrix, 1, 1);
+  translateTransform(projectionMatrix, 1, 1);
 
 };
 
@@ -248,7 +257,7 @@ WebGLImageLayerRenderer.prototype.forEachLayerAtPixel = function(pixel, frameSta
   if (this.getLayer().getSource().forEachFeatureAtCoordinate !== nullFunction) {
     // for ImageCanvas sources use the original hit-detection logic,
     // so that for example also transparent polygons are detected
-    const coordinate = _ol_transform_.apply(
+    const coordinate = applyTransform(
       frameState.pixelToCoordinateTransform, pixel.slice());
     const hasFeature = this.forEachFeatureAtCoordinate(coordinate, frameState, 0, TRUE, this);
 
@@ -266,7 +275,7 @@ WebGLImageLayerRenderer.prototype.forEachLayerAtPixel = function(pixel, frameSta
         frameState.size, imageSize);
     }
 
-    const pixelOnFrameBuffer = _ol_transform_.apply(
+    const pixelOnFrameBuffer = applyTransform(
       this.hitTransformationMatrix_, pixel.slice());
 
     if (pixelOnFrameBuffer[0] < 0 || pixelOnFrameBuffer[0] > imageSize[0] ||
@@ -304,25 +313,25 @@ WebGLImageLayerRenderer.prototype.forEachLayerAtPixel = function(pixel, frameSta
 WebGLImageLayerRenderer.prototype.getHitTransformationMatrix_ = function(mapSize, imageSize) {
   // the first matrix takes a map pixel, flips the y-axis and scales to
   // a range between -1 ... 1
-  const mapCoordTransform = _ol_transform_.create();
-  _ol_transform_.translate(mapCoordTransform, -1, -1);
-  _ol_transform_.scale(mapCoordTransform, 2 / mapSize[0], 2 / mapSize[1]);
-  _ol_transform_.translate(mapCoordTransform, 0, mapSize[1]);
-  _ol_transform_.scale(mapCoordTransform, 1, -1);
+  const mapCoordTransform = createTransform();
+  translateTransform(mapCoordTransform, -1, -1);
+  scaleTransform(mapCoordTransform, 2 / mapSize[0], 2 / mapSize[1]);
+  translateTransform(mapCoordTransform, 0, mapSize[1]);
+  scaleTransform(mapCoordTransform, 1, -1);
 
   // the second matrix is the inverse of the projection matrix used in the
   // shader for drawing
-  const projectionMatrixInv = _ol_transform_.invert(this.projectionMatrix.slice());
+  const projectionMatrixInv = invertTransform(this.projectionMatrix.slice());
 
   // the third matrix scales to the image dimensions and flips the y-axis again
-  const transform = _ol_transform_.create();
-  _ol_transform_.translate(transform, 0, imageSize[1]);
-  _ol_transform_.scale(transform, 1, -1);
-  _ol_transform_.scale(transform, imageSize[0] / 2, imageSize[1] / 2);
-  _ol_transform_.translate(transform, 1, 1);
+  const transform = createTransform();
+  translateTransform(transform, 0, imageSize[1]);
+  scaleTransform(transform, 1, -1);
+  scaleTransform(transform, imageSize[0] / 2, imageSize[1] / 2);
+  translateTransform(transform, 1, 1);
 
-  _ol_transform_.multiply(transform, projectionMatrixInv);
-  _ol_transform_.multiply(transform, mapCoordTransform);
+  multiplyTransform(transform, projectionMatrixInv);
+  multiplyTransform(transform, mapCoordTransform);
 
   return transform;
 };

src/ol/renderer/webgl/Layer.js

@@ -8,7 +8,7 @@ import WebGLImmediateRenderer from '../../render/webgl/Immediate.js';
 import LayerRenderer from '../Layer.js';
 import {fragment, vertex} from '../webgl/defaultmapshader.js';
 import Locations from '../webgl/defaultmapshader/Locations.js';
-import _ol_transform_ from '../../transform.js';
+import {create as createTransform} from '../../transform.js';
 import {create, fromTransform} from '../../vec/mat4.js';
 import _ol_webgl_ from '../../webgl.js';
 import WebGLBuffer from '../../webgl/Buffer.js';
@@ -64,13 +64,13 @@ const WebGLLayerRenderer = function(mapRenderer, layer) {
    * @protected
    * @type {ol.Transform}
    */
-  this.texCoordMatrix = _ol_transform_.create();
+  this.texCoordMatrix = createTransform();
 
   /**
    * @protected
    * @type {ol.Transform}
    */
-  this.projectionMatrix = _ol_transform_.create();
+  this.projectionMatrix = createTransform();
 
   /**
    * @type {Array.<number>}

src/ol/renderer/webgl/TileLayer.js

@@ -16,7 +16,13 @@ import WebGLLayerRenderer from '../webgl/Layer.js';
 import {fragment, vertex} from '../webgl/tilelayershader.js';
 import Locations from '../webgl/tilelayershader/Locations.js';
 import {toSize} from '../../size.js';
-import _ol_transform_ from '../../transform.js';
+import {
+  reset as resetTransform,
+  rotate as rotateTransform,
+  scale as scaleTransform,
+  translate as translateTransform,
+  apply as applyTransform
+} from '../../transform.js';
 import _ol_webgl_ from '../../webgl.js';
 import WebGLBuffer from '../../webgl/Buffer.js';
 
@@ -355,21 +361,21 @@ WebGLTileLayerRenderer.prototype.prepareFrame = function(frameState, layerState,
   this.scheduleExpireCache(frameState, tileSource);
 
   const texCoordMatrix = this.texCoordMatrix;
-  _ol_transform_.reset(texCoordMatrix);
-  _ol_transform_.translate(texCoordMatrix,
+  resetTransform(texCoordMatrix);
+  translateTransform(texCoordMatrix,
     (Math.round(center[0] / tileResolution) * tileResolution - framebufferExtent[0]) /
           (framebufferExtent[2] - framebufferExtent[0]),
     (Math.round(center[1] / tileResolution) * tileResolution - framebufferExtent[1]) /
           (framebufferExtent[3] - framebufferExtent[1]));
   if (viewState.rotation !== 0) {
-    _ol_transform_.rotate(texCoordMatrix, viewState.rotation);
+    rotateTransform(texCoordMatrix, viewState.rotation);
   }
-  _ol_transform_.scale(texCoordMatrix,
+  scaleTransform(texCoordMatrix,
     frameState.size[0] * viewState.resolution /
           (framebufferExtent[2] - framebufferExtent[0]),
     frameState.size[1] * viewState.resolution /
           (framebufferExtent[3] - framebufferExtent[1]));
-  _ol_transform_.translate(texCoordMatrix, -0.5, -0.5);
+  translateTransform(texCoordMatrix, -0.5, -0.5);
 
   return true;
 };
@@ -387,7 +393,7 @@ WebGLTileLayerRenderer.prototype.forEachLayerAtPixel = function(pixel, frameStat
     pixel[0] / frameState.size[0],
     (frameState.size[1] - pixel[1]) / frameState.size[1]];
 
-  const pixelOnFrameBufferScaled = _ol_transform_.apply(
+  const pixelOnFrameBufferScaled = applyTransform(
     this.texCoordMatrix, pixelOnMapScaled.slice());
   const pixelOnFrameBuffer = [
     pixelOnFrameBufferScaled[0] * this.framebufferDimension,

src/ol/renderer/webgl/VectorLayer.js

@@ -9,7 +9,7 @@ import WebGLReplayGroup from '../../render/webgl/ReplayGroup.js';
 import RendererType from '../Type.js';
 import {defaultOrder as defaultRenderOrder, getTolerance as getRenderTolerance, getSquaredTolerance as getSquaredRenderTolerance, renderFeature} from '../vector.js';
 import WebGLLayerRenderer from '../webgl/Layer.js';
-import _ol_transform_ from '../../transform.js';
+import {apply as applyTransform} from '../../transform.js';
 
 /**
  * @constructor
@@ -186,7 +186,7 @@ WebGLVectorLayerRenderer.prototype.hasFeatureAtCoordinate = function(coordinate,
  * @inheritDoc
  */
 WebGLVectorLayerRenderer.prototype.forEachLayerAtPixel = function(pixel, frameState, callback, thisArg) {
-  const coordinate = _ol_transform_.apply(
+  const coordinate = applyTransform(
     frameState.pixelToCoordinateTransform, pixel.slice());
   const hasFeature = this.hasFeatureAtCoordinate(coordinate, frameState);