Get world position, extracted from world transform
@param  {clay.Vector3} [out]
@return {clay.Vector3}
340513
function (out) {
        // PENDING
        if (this.transformNeedsUpdate()) {
            this.updateWorldTransform();
        }
        var m = this.worldTransform.array;
        if (out) {
            var arr = out.array;
            arr[0] = m[12];
            arr[1] = m[13];
            arr[2] = m[14];
            return out;
        }
        else {
            return new Vector3(m[12], m[13], m[14]);
        }
    }
618455
def in?(bounding_box)
      top, left, bottom, right = bounding_box.coords
      (left..right) === @lng && (top..bottom) === @lat
    end
1181651
def get_trans(self, out_vec=None):
        

        if out_vec:
            return out_vec.set(*self.data[3][:3])

        return Vec3(*self.data[3][:3])
774300
function() {
        if (arguments.length > 0) {
            var bounds = this.adjustBounds(arguments[0]);
            var res = this.getServerResolution();
            var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));
            var y = Math.round((this.tileOrigin.lat - bounds.top) / (res * this.tileSize.h));
            var z = this.getZoomForResolution( res );
            var w = this.standardTileSize;
            var h = this.standardTileSize;
            if (x == this.tierSizeInTiles[z].w -1 ) {
                var w = this.tierImageSize[z].w % this.standardTileSize;
            }
            if (y == this.tierSizeInTiles[z].h -1 ) {
                var h = this.tierImageSize[z].h % this.standardTileSize;
            }
            return (new OpenLayers.Size(w, h));
        } else {
            return this.tileSize;
        }
    }
1128632
function (el) {
		var offsets = el.getPosition(); // #1496
		return {
			left: offsets.x,
			top: offsets.y
		};
	}
1107311
def get_position():
    
    e = Quartz.CGEventCreate(None)
    point = Quartz.CGEventGetLocation(e)
    return (point.x, point.y)
533949
public static AffineTransformation getWorldToRectangle( Envelope worldEnvelope, Rectangle pixelRectangle ) {
        int cols = (int) pixelRectangle.getWidth();
        int rows = (int) pixelRectangle.getHeight();
        double worldWidth = worldEnvelope.getWidth();
        double worldHeight = worldEnvelope.getHeight();

        double x = -worldEnvelope.getMinX();
        double y = -worldEnvelope.getMinY();
        AffineTransformation translate = AffineTransformation.translationInstance(x, y);
        double xScale = cols / worldWidth;
        double yScale = rows / worldHeight;
        AffineTransformation scale = AffineTransformation.scaleInstance(xScale, yScale);

        int m00 = 1;
        int m10 = 0;
        int m01 = 0;
        int m11 = -1;
        int m02 = 0;
        int m12 = rows;
        AffineTransformation mirror_y = new AffineTransformation(m00, m01, m02, m10, m11, m12);

        AffineTransformation world2pixel = new AffineTransformation(translate);
        world2pixel.compose(scale);
        world2pixel.compose(mirror_y);
        return world2pixel;
    }
236593
function _Transform(position, rotation) {
  var _position = new Vector3();
  var _rotation = Quaternion.identity;
  var _localPosition = _position;
  var _localRotation = _rotation;
  var _parent = undefined;
  var _children = [];
  this.name = "object";

  if(position && (position instanceof Vector3)) {
    _position = position;
    _localPosition = position;
  }
  if(rotation && (rotation instanceof Quaternion)) {
    _rotation = rotation;
    _localRotation = rotation;
  }

  /**
   * Position of the object in world coordinate system
   */
  Object.defineProperty(this, "position", {
    get: function() { return _position; },
    set: function(val) {
      if(val instanceof Vector3) {
        _position = val;
        _localPosition = _getLocalPositionFromWorldPosition(this);
        _adjustChildren(_children);
      }
    }
  });

  /**
   * Rotation of the object in world coordinate system
   */
  Object.defineProperty(this, "rotation", {
    get: function() { return _rotation; },
    set: function(val) {
      if(val instanceof Quaternion) {
        _rotation = val;
        _localRotation = _getLocalRotationFromWorldRotation(this);
        _adjustChildren(_children);
      }
    }
  });

  /**
   * Position of the object in local coordinate system
   */
  Object.defineProperty(this, "localPosition", {
    get: function() { return _localPosition; },
    set: function(val) {
      if(val instanceof Vector3) {
        _localPosition = val;
        _position = _getWorldPositionFromLocalPosition(this);
      }
    }
  });

  /**
   * Rotation of the object in local coordinate system
   */
  Object.defineProperty(this, "localRotation", {
    get: function() { return _localRotation; },
    set: function(val) {
      if(val instanceof Quaternion) {
        _localRotation = val;
        _rotation = _getWorldRotationFromLocalRotation(this);
      }
    }
  });

  /**
   * Parent transform
   * Set to undefined if there is none
   */
  Object.defineProperty(this, "parent", {
    get: function() { return _parent; },
    set: function(val) {
      if(val instanceof _Transform) {
        _parent = val;
        _localRotation = _getLocalRotationFromWorldRotation(this);
        _localPosition = _getLocalPositionFromWorldPosition(this);
        _parent.addChild(this);
      } else if(val === undefined) {
        var temp = _parent;
        _parent = undefined;
        _localRotation = _rotation;
        _localPosition = _position;
        temp.removeChild(this);
      }
    }
  });

  readonly(this, "forward", _getForward(this));
  readonly(this, "right", _getRight(this));
  readonly(this, "up", _getUp(this));
  readonly(this, "localToWorldMatrix", _getLocalToWorldMatrix(this));
  readonly(this, "worldToLocalMatrix", _getWorldtoLocalMatrix(this));
  readonly(this, "root", _getRoot(this));

  /**
   * Adds a new child transform
   *
   * @param {Transform} transform
   */
  this.addChild = function(child) {
    if(!(child instanceof _Transform))
      throw new TypeError("Child must be a Transform.")

    if(child.parent !== this)
      child.parent = this;

    _children.push(child);
  }

  /**
   * Removes a previously added child transform
   *
   * @param {Transform} transform
   */
  this.removeChild = function(child) {
    if(!(child instanceof _Transform))
      throw new TypeError("Child must be a Transform.")

    if(child.parent === this)
      child.parent = undefined;

    var index = _children.indexOf(child);

    if(index != -1)
      _children.splice(index, 1);
  }
}
1294322
function toLocalPoint(globalPosition) {

    var viewbox = canvas.viewbox();

    var clientRect = canvas._container.getBoundingClientRect();

    return {
      x: viewbox.x + (globalPosition.x - clientRect.left) / viewbox.scale,
      y: viewbox.y + (globalPosition.y - clientRect.top) / viewbox.scale
    };
  }
821153
function _getWorldPositionFromLocalPosition(transform) {
  if (transform.parent === undefined)
    return transform.localPosition;
  else
    return transform.parent.position.add(transform.parent.rotation.mulVector3(transform.localPosition));
}
1085128
function getRotation(start, end) {
  return getAngle(end[1], end[0], PROPS_CLIENT_XY) - getAngle(start[1], start[0], PROPS_CLIENT_XY);
}
893763
public Vector3f transformPosition(Vector3fc v, Vector3f dest) {
        return transformPosition(v.x(), v.y(), v.z(), dest);
    }
1034435
public void getFeature3D( int feature , Point4D_F64 out ) {
		out.x = X.get(0,feature);
		out.y = X.get(1,feature);
		out.z = X.get(2,feature);
		out.w = X.get(3,feature);
	}
669570
function _getBoundingBox (result) {
  if (!result.viewport) {
    return;
  }
  const upperLeft = result.viewport.topLeftPoint;
  const bottomRight = result.viewport.btmRightPoint;

  return {
    south: bottomRight.lat,
    west: upperLeft.lon,
    north: upperLeft.lat,
    east: bottomRight.lon
  };
}
662357
function _getAngleAxis(quaternion) {
  return function() {
    var sqrt = Math.sqrt(1 - quaternion.w * quaternion.w);
    return {
      axis: new Vector3(quaternion.x / sqrt, quaternion.y / sqrt, quaternion.z / sqrt),
      angle: 2 * Math.acos(quaternion.w) * radToDeg
    };
  }
}
585610
function(out) { 
      if (!out) {
        out = vec3.create();
      }
      vec3.add(out, self.atom_one.pos(), self.atom_two.pos());
      vec3.scale(out, out, 0.5);
      return out;
    }
1263020
def to_world(self, shape, dst_crs=None):
        """"""
        if dst_crs is None:
            dst_crs = self.crs
        shp = transform(shape, self.crs, dst_crs, dst_affine=self.affine)
        return GeoVector(shp, dst_crs)