Window (Javadocs: proscene)

java.lang.Object
- remixlab.dandelion.core.Eye
- - remixlab.dandelion.core.Window

All Implemented Interfaces:

Copyable
```
public class Window
extends Eye
implements Copyable
```
2D implementation of the Eye abstract class.
Attention: the Eye.frame() Frame.magnitude() is used to scale the view. The Window magnitude is thus generally different from that of the scene. Use Eye.eyeCoordinatesOf(Vec) and Eye.worldCoordinatesOf(Vec) (or any of the powerful Frame transformations ( Frame.coordinatesOf(Vec), Frame.transformOf(Vec), ...)) to convert to and from the Eye Eye.frame() coordinate system.

Nested Class Summary
- Nested classes/interfaces inherited from class remixlab.dandelion.core.Eye
  Eye.Visibility

Field Summary
- Fields inherited from class remixlab.dandelion.core.Eye
  anchorFlag, lastNonFrameUpdate, pupFlag, pupVec

Constructor Summary

Constructors
Constructor and Description

Window(AbstractScene scn)

Constructors
Constructor and Description
`Window(AbstractScene scn)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Vec`	`at()` 2D Windows return the postion.
`Eye.Visibility`	`ballVisibility(Vec center, float radius)` Returns `Eye.Visibility.VISIBLE`, `Eye.Visibility.INVISIBLE`, or `Eye.Visibility.SEMIVISIBLE`, depending whether the sphere (of radius `radius` and center `center`) is visible, invisible, or semi-visible, respectively.
`Eye.Visibility`	`boxVisibility(Vec p1, Vec p2)` Returns `Eye.Visibility.VISIBLE`, `Eye.Visibility.INVISIBLE`, or `Eye.Visibility.SEMIVISIBLE`, depending whether the axis aligned box (defined by corners `p1` and `p2`) is visible, invisible, or semi-visible, respectively.
`float[][]`	`computeBoundaryEquations()` Convenience function that in 2D simply returns `computeFrustumPlanesCoefficients(new float [4][3])` and in 3D `computeFrustumPlanesCoefficients(new float [6][4])`.
`float[][]`	`computeBoundaryEquations(float[][] coef)` Fills `coef` with the 6 plane equations of the camera frustum and returns it.
`void`	`computeProjection()` Computes the projection matrix associated with the Eye.
`void`	`computeView()` Computes the View matrix associated with the Eye's `Eye.position()` and `Eye.orientation()`.
`float`	`distanceToAnchor()` Returns the Eye `Eye.position()` to `Eye.anchor()` distance in Scene units.
`float`	`distanceToBoundary(int index, Vec pos)` Returns the signed distance between point `pos` and plane `index` in Scene units.
`float`	`distanceToSceneCenter()` Returns the Eye `Eye.position()` to `Eye.sceneCenter()` distance in Scene units.
`void`	`fitBall(Vec center, float radius)` Moves the Eye so that the ball defined by `center` and `radius` is visible and fits the window.
`void`	`fitBoundingBox(Vec min, Vec max)` Moves the Eye so that the (world axis aligned) bounding box (`min` , `max`) is entirely visible, using `Eye.fitBall(Vec, float)`.
`void`	`fitScreenRegion(Rect rectangle)` Moves the Eye so that the rectangular screen region defined by `rectangle` (pixel units, with origin in the upper left corner) fits the screen.
`void`	`fromView(Mat mv, boolean recompute)` Sets the Eye `Eye.position()` and `Eye.orientation()` from an OpenGL-like View matrix.
`Window`	`get()` Returns a deep copy of the object.
`void`	`interpolateToZoomOnPixel(Point pixel)` Makes the Eye smoothly zoom on the `Camera.pointUnderPixel(Point)` `pixel` and returns the world coordinates of the `Camera.pointUnderPixel(Point)`.
`boolean`	`isPointVisible(float x, float y)` Same as `return isPointVisible(new Vec(x, y))`.
`boolean`	`isPointVisible(Vec point)` Returns `true` if `point` is visible (i.e, lies within the Eye boundary) and `false` otherwise.
`void`	`lookAt(float x, float y)` Same as `lookAt(new Vec(x,y))`.
`void`	`lookAt(Vec target)` 2D Windows simply call `frame().setPosition(target.x(), target.y())`.
`float`	`sceneToPixelRatio(Vec position)` Returns the ratio of scene (units) to pixel at `position`.
`void`	`setAnchor(float x, float y)` Same as `setAnchor(new Vec(x,y))`.
`boolean`	`setAnchorFromPixel(Point pixel)` The `Eye.anchor()` is set to the point located under `pixel` on screen.
`void`	`setOrientation(float angle)`
`void`	`setOrientation(Rotation q)` Sets the Eye `Eye.orientation()`, defined in the world coordinate system.
`void`	`setPosition(float x, float y)` Same as `setPosition(new Vec(x,y))`.
`void`	`setSceneBoundingBox(Vec min, Vec max)` Similar to `Eye.setSceneRadius(float)` and `Eye.setSceneCenter(Vec)`, but the scene limits are defined by a (world axis aligned) bounding box.
`boolean`	`setSceneCenterFromPixel(Point pixel)` The `Eye.sceneCenter()` is set to the point located under `pixel` on screen.
`void`	`setUpVector(float x, float y)` Same as `setUpVector(new Vec(x,y))`.
`void`	`setUpVector(float x, float y, boolean noMove)` Same as `setUpVector(new Vec(x,y), boolean noMove)`.
`void`	`setUpVector(Vec up, boolean noMove)` Rotates the Eye so that its `Eye.upVector()` becomes `up` (defined in the world coordinate system).

Methods inherited from class remixlab.dandelion.core.Eye
addKeyFrameToPath, anchor, anyInterpolationStarted, areBoundaryEquationsEnabled, aspectRatio, centerScene, deletePath, enableBoundaryEquations, eyeCoordinatesOf, flip, flySpeed, frame, fromView, getBoundaryEquations, getBoundaryWidthHeight, getBoundaryWidthHeight, getOrthoWidthHeight, getOrthoWidthHeight, getProjection, getProjection, getProjection, getProjection, getView, getView, getView, getView, getViewport, getViewport, interpolateTo, interpolateTo, interpolateToFitScene, interpolateToZoomOnPixel, interpolateToZoomOnRegion, keyFrameInterpolator, keyFrameInterpolatorArray, keyFrameInterpolatorList, keyFrameInterpolatorMap, lastNonFrameUpdate, lastUpdate, orientation, pixelToSceneRatio, playPath, position, project, project, projectedCoordinatesOf, projectedCoordinatesOf, projectedCoordinatesOf, projectedCoordinatesOf, rescalingOrthoFactor, resetPath, rightVector, rotationSensitivity, scalingSensitivity, scene, sceneCenter, sceneRadius, screenHeight, screenWidth, setAnchor, setAnchorFromPixel, setAspectRatio, setFlySpeed, setFrame, setKeyFrameInterpolator, setPosition, setProjection, setProjection, setProjection, setRotationSensitivity, setScalingSensitivity, setSceneCenter, setSceneCenterFromPixel, setSceneRadius, setScreenWidthAndHeight, setSpinningSensitivity, setTranslationSensitivity, setUpVector, showEntireScene, spinningSensitivity, stopInterpolations, translationSensitivity, unproject, unproject, unprojectedCoordinatesOf, unprojectedCoordinatesOf, unprojectedCoordinatesOf, unprojectedCoordinatesOf, updateBoundaryEquations, upVector, viewDirection, worldCoordinatesOf

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Window
```
public Window(AbstractScene scn)
```
- Method Detail
  - get
```
public Window get()
```
    Description copied from interface: Copyable
    
    Returns a deep copy of the object.
    Typical implementation should simple look like: return new Object(this).
    
    Specified by:
    
    get in interface Copyable
    
    Specified by:
    
    get in class Eye
  - computeView
```
public void computeView()
```
    Description copied from class: Eye
    
    Computes the View matrix associated with the Eye's Eye.position() and Eye.orientation().
    This matrix converts from the world coordinates system to the Eye coordinates system, so that coordinates can then be projected on screen using the projection matrix (see Eye.computeProjection()).
    Use Eye.getView() to retrieve this matrix.
    Note: You must call this method if your Eye is not associated with a Scene and is used for offscreen computations (using projectedCoordinatesOf() for instance).
    
    Specified by:
    
    computeView in class Eye
  - computeProjection
```
public void computeProjection()
```
    Description copied from class: Eye
    
    Computes the projection matrix associated with the Eye.
    If Eye is a 3D PERSPECTIVE Camera, defines a projection matrix using the Camera.fieldOfView(), Eye.aspectRatio(), Camera.zNear() and Camera.zFar() parameters. If Eye is a 3D ORTHOGRAPHIC Camera, the frustum's width and height are set using Eye.getBoundaryWidthHeight(). Both types use Camera.zNear() and Camera.zFar() to place clipping planes. These values are determined from sceneRadius() and sceneCenter() so that they best fit the scene size.
    Use Eye.getProjection() to retrieve this matrix.
    Note: You must call this method if your Eye is not associated with a Scene and is used for offscreen computations (using projectedCoordinatesOf() for instance).
    
    Specified by:
    
    computeProjection in class Eye
    
    See Also:
    
    Eye.setProjection(Mat)
  - fromView
```
public void fromView(Mat mv,
                     boolean recompute)
```
    Description copied from class: Eye
    
    Sets the Eye Eye.position() and Eye.orientation() from an OpenGL-like View matrix.
    After this method has been called, Eye.getView() returns a matrix equivalent to mv. Only the Eye.position() and Eye.orientation() of the Eye are modified.
    
    Specified by:
    
    fromView in class Eye
  - setUpVector
```
public void setUpVector(Vec up,
                        boolean noMove)
```
    Description copied from class: Eye
    
    Rotates the Eye so that its Eye.upVector() becomes up (defined in the world coordinate system).
    The Eye is rotated around an axis orthogonal to up and to the current Eye.upVector() direction.
    Use this method in order to define the Eye horizontal plane.
    When noMove is set to false, the orientation modification is compensated by a translation, so that the Eye.anchor() stays projected at the same position on screen. This is especially useful when the Eye is an observer of the scene (default action binding).
    When noMove is true, the Eye Eye.position() is left unchanged, which is an intuitive behavior when the Eye is in first person mode.
    
    Specified by:
    
    setUpVector in class Eye
    
    See Also:
    
    Eye.lookAt(Vec), Eye.setOrientation(Rotation)
  - setUpVector
```
public void setUpVector(float x,
                        float y)
```
    Same as setUpVector(new Vec(x,y)).
    
    See Also:
    
    Eye.setUpVector(Vec)
  - setUpVector
```
public void setUpVector(float x,
                        float y,
                        boolean noMove)
```
    Same as setUpVector(new Vec(x,y), boolean noMove).
    
    See Also:
    
    setUpVector(Vec, boolean)
  - setPosition
```
public void setPosition(float x,
                        float y)
```
    Same as setPosition(new Vec(x,y)).
    
    See Also:
    
    Eye.setPosition(Vec)
  - setSceneCenterFromPixel
```
public boolean setSceneCenterFromPixel(Point pixel)
```
    Description copied from class: Eye
    
    The Eye.sceneCenter() is set to the point located under pixel on screen.
    2D windows always returns true.
    3D Cameras returns true if a point was found under pixel and false if none was found (in this case no Eye.sceneCenter() is set).
    
    Specified by:
    
    setSceneCenterFromPixel in class Eye
  - fitBoundingBox
```
public void fitBoundingBox(Vec min,
                           Vec max)
```
    Description copied from class: Eye
    
    Moves the Eye so that the (world axis aligned) bounding box (min , max) is entirely visible, using Eye.fitBall(Vec, float).
    
    Specified by:
    
    fitBoundingBox in class Eye
  - fitBall
```
public void fitBall(Vec center,
                    float radius)
```
    Description copied from class: Eye
    
    Moves the Eye so that the ball defined by center and radius is visible and fits the window.
    In 3D the Camera is simply translated along its Eye.viewDirection() so that the sphere fits the screen. Its Eye.orientation() and its Camera.fieldOfView() are unchanged. You should therefore orientate the Camera before you call this method.
    
    Specified by:
    
    fitBall in class Eye
    
    See Also:
    
    Eye.lookAt(Vec), Eye.setOrientation(Rotation), Eye.setUpVector(Vec, boolean)
  - setSceneBoundingBox
```
public void setSceneBoundingBox(Vec min,
                                Vec max)
```
    Description copied from class: Eye
    
    Similar to Eye.setSceneRadius(float) and Eye.setSceneCenter(Vec), but the scene limits are defined by a (world axis aligned) bounding box.
    
    Specified by:
    
    setSceneBoundingBox in class Eye
  - fitScreenRegion
```
public void fitScreenRegion(Rect rectangle)
```
    Description copied from class: Eye
    
    Moves the Eye so that the rectangular screen region defined by rectangle (pixel units, with origin in the upper left corner) fits the screen.
    in 3D the Camera is translated (its Eye.orientation() is unchanged) so that rectangle is entirely visible. Since the pixel coordinates only define a frustum in 3D, it's the intersection of this frustum with a plane (orthogonal to the Eye.viewDirection() and passing through the Eye.sceneCenter()) that is used to define the 3D rectangle that is eventually fitted.
    
    Specified by:
    
    fitScreenRegion in class Eye
  - setOrientation
```
public void setOrientation(Rotation q)
```
    Description copied from class: Eye
    
    Sets the Eye Eye.orientation(), defined in the world coordinate system.
    
    Specified by:
    
    setOrientation in class Eye
  - setOrientation
```
public void setOrientation(float angle)
```
  - computeBoundaryEquations
```
public float[][] computeBoundaryEquations()
```
    Description copied from class: Eye
    
    Convenience function that in 2D simply returns computeFrustumPlanesCoefficients(new float [4][3]) and in 3D computeFrustumPlanesCoefficients(new float [6][4]).
    Attention: You should not call this method explicitly, unless you need the frustum equations to be updated only occasionally (rare). Use AbstractScene.enableBoundaryEquations() which automatically update the frustum equations every frame instead.
    
    Specified by:
    
    computeBoundaryEquations in class Eye
    
    See Also:
    
    Eye.computeBoundaryEquations(float[][])
  - computeBoundaryEquations
```
public float[][] computeBoundaryEquations(float[][] coef)
```
    Description copied from class: Eye
    
    Fills coef with the 6 plane equations of the camera frustum and returns it.
    In 2D the four 4-component vectors of coef respectively correspond to the left, right, top and bottom Window boundary lines. Each vector holds a plane equation of the form:
    a*x + b*y + c = 0 where a, b and c are the 3 components of each vector, in that order.
    
    In 3D the six 4-component vectors of coef respectively correspond to the left, right, near, far, top and bottom Camera frustum planes. Each vector holds a plane equation of the form:
    a*x + b*y + c*z + d = 0
    where a, b, c and d are the 4 components of each vector, in that order.
    This format is compatible with the gl.glClipPlane() function. One camera frustum plane can hence be applied in an other viewer to visualize the culling results:
    // Retrieve place equations
    float [][] coef = mainViewer.camera().getFrustumPlanesCoefficients();
    // These two additional clipping planes (which must have been enabled)
    // will reproduce the mainViewer's near and far clipping.
    gl.glClipPlane(GL.GL_CLIP_PLANE0, coef[2]);
    gl.glClipPlane(GL.GL_CLIP_PLANE1, coef[3]);
    
    Attention: You should not call this method explicitly, unless you need the frustum equations to be updated only occasionally (rare). Use AbstractScene.enableBoundaryEquations() which automatically update the frustum equations every frame instead.
    
    Specified by:
    
    computeBoundaryEquations in class Eye
    
    See Also:
    
    Eye.computeBoundaryEquations()
  - distanceToBoundary
```
public float distanceToBoundary(int index,
                                Vec pos)
```
    Description copied from class: Eye
    
    Returns the signed distance between point pos and plane index in Scene units. The distance is negative if the point lies in the planes's boundary halfspace, and positive otherwise.
    index is a value between 0 and 5 which respectively correspond to the left, right, near, far, top and bottom Eye boundary planes.
    Attention: The eye boundary plane equations should be updated before calling this method. You may compute them explicitly (by calling Eye.computeBoundaryEquations() ) or enable them to be automatic updated in your Scene setup (with AbstractScene.enableBoundaryEquations()).
    
    Overrides:
    
    distanceToBoundary in class Eye
    
    See Also:
    
    Eye.isPointVisible(Vec), Eye.ballVisibility(Vec, float), Eye.boxVisibility(Vec, Vec), Eye.computeBoundaryEquations(), Eye.updateBoundaryEquations(), Eye.getBoundaryEquations(), AbstractScene.enableBoundaryEquations()
  - boxVisibility
```
public Eye.Visibility boxVisibility(Vec p1,
                                    Vec p2)
```
    Description copied from class: Eye
    
    Returns Eye.Visibility.VISIBLE, Eye.Visibility.INVISIBLE, or Eye.Visibility.SEMIVISIBLE, depending whether the axis aligned box (defined by corners p1 and p2) is visible, invisible, or semi-visible, respectively.
    Attention: The Eye boundary plane equations should be updated before calling this method. You may compute them explicitly (by calling Eye.computeBoundaryEquations() ) or enable them to be automatic updated in your Scene setup (with AbstractScene.enableBoundaryEquations()).
    
    Specified by:
    
    boxVisibility in class Eye
    
    See Also:
    
    Eye.distanceToBoundary(int, Vec), Eye.isPointVisible(Vec), Eye.ballVisibility(Vec, float), Eye.computeBoundaryEquations(), Eye.updateBoundaryEquations(), Eye.getBoundaryEquations(), AbstractScene.enableBoundaryEquations()
  - ballVisibility
```
public Eye.Visibility ballVisibility(Vec center,
                                     float radius)
```
    Description copied from class: Eye
    
    Returns Eye.Visibility.VISIBLE, Eye.Visibility.INVISIBLE, or Eye.Visibility.SEMIVISIBLE, depending whether the sphere (of radius radius and center center) is visible, invisible, or semi-visible, respectively.
    Attention: The Eye boundary plane equations should be updated before calling this method. You may compute them explicitly (by calling Eye.computeBoundaryEquations() ) or enable them to be automatic updated in your Scene setup (with AbstractScene.enableBoundaryEquations()).
    
    Specified by:
    
    ballVisibility in class Eye
    
    See Also:
    
    Eye.distanceToBoundary(int, Vec), Eye.isPointVisible(Vec), Eye.boxVisibility(Vec, Vec), Eye.computeBoundaryEquations(), Eye.updateBoundaryEquations(), Eye.getBoundaryEquations(), AbstractScene.enableBoundaryEquations()
  - isPointVisible
```
public boolean isPointVisible(Vec point)
```
    Description copied from class: Eye
    
    Returns true if point is visible (i.e, lies within the Eye boundary) and false otherwise.
    Attention: The Eye boundary plane equations should be updated before calling this method. You may compute them explicitly (by calling Eye.computeBoundaryEquations() ) or enable them to be automatic updated in your Scene setup (with AbstractScene.enableBoundaryEquations()).
    
    Specified by:
    
    isPointVisible in class Eye
    
    See Also:
    
    Eye.distanceToBoundary(int, Vec), Eye.ballVisibility(Vec, float), Eye.boxVisibility(Vec, Vec), Eye.computeBoundaryEquations(), Eye.updateBoundaryEquations(), Eye.getBoundaryEquations(), AbstractScene.enableBoundaryEquations()
  - isPointVisible
```
public boolean isPointVisible(float x,
                              float y)
```
    Same as return isPointVisible(new Vec(x, y)).
    
    See Also:
    
    isPointVisible(Vec)
  - sceneToPixelRatio
```
public float sceneToPixelRatio(Vec position)
```
    Description copied from class: Eye
    
    Returns the ratio of scene (units) to pixel at position.
    A line of n * sceneToPixelRatio() scene units, located at position in the world coordinates system, will be projected with a length of n pixels on screen.
    Use this method to scale objects so that they have a constant pixel size on screen. The following code will draw a 20 pixel line, starting at Eye.sceneCenter() and always directed along the screen vertical direction:
    beginShape(LINES);
    vertex(sceneCenter().x, sceneCenter().y, sceneCenter().z);
    Vec v = Vec.add(sceneCenter(), Vec.mult(upVector(), 20 * sceneToPixelRatio(sceneCenter())));
    vertex(v.x, v.y, v.z);
    endShape();
    
    Specified by:
    
    sceneToPixelRatio in class Eye
  - lookAt
```
public void lookAt(Vec target)
```
    Description copied from class: Eye
    
    2D Windows simply call frame().setPosition(target.x(), target.y()). 3D Cameras set Eye.orientation(), so that it looks at point target defined in the world coordinate system (The Camera Eye.position() is not modified. Simply Camera.setViewDirection(Vec)).
    
    Specified by:
    
    lookAt in class Eye
    
    See Also:
    
    Eye.at(), Eye.setUpVector(Vec), Eye.setOrientation(Rotation), Eye.showEntireScene(), Eye.fitBall(Vec, float), Eye.fitBoundingBox(Vec, Vec)
  - lookAt
```
public void lookAt(float x,
                   float y)
```
    Same as lookAt(new Vec(x,y)).
    
    See Also:
    
    lookAt(Vec)
  - setAnchor
```
public void setAnchor(float x,
                      float y)
```
    Same as setAnchor(new Vec(x,y)).
    
    See Also:
    
    AbstractScene.setAnchor(Vec)
  - setAnchorFromPixel
```
public boolean setAnchorFromPixel(Point pixel)
```
    Description copied from class: Eye
    
    The Eye.anchor() is set to the point located under pixel on screen.
    2D windows always returns true.
    3D Cameras returns true if a point was found under pixel and false if none was found (in this case no Eye.anchor() is set).
    
    Specified by:
    
    setAnchorFromPixel in class Eye
  - interpolateToZoomOnPixel
```
public void interpolateToZoomOnPixel(Point pixel)
```
    Description copied from class: Eye
    
    Makes the Eye smoothly zoom on the Camera.pointUnderPixel(Point) pixel and returns the world coordinates of the Camera.pointUnderPixel(Point).
    In 3D nothing happens if no Camera.pointUnderPixel(Point) is found. Otherwise a KeyFrameInterpolator is created that animates the Camera on a one second path that brings the Camera closer to the point under pixel.
    
    Specified by:
    
    interpolateToZoomOnPixel in class Eye
    
    See Also:
    
    Eye.interpolateToFitScene()
  - distanceToSceneCenter
```
public float distanceToSceneCenter()
```
    Description copied from class: Eye
    
    Returns the Eye Eye.position() to Eye.sceneCenter() distance in Scene units.
    3D Cameras return the projected Eye Eye.position() to Eye.sceneCenter() distance along the Camera Z axis and use it in Camera.zNear() and Camera.zFar() to optimize the Z range.
    
    Specified by:
    
    distanceToSceneCenter in class Eye
  - distanceToAnchor
```
public float distanceToAnchor()
```
    Description copied from class: Eye
    
    Returns the Eye Eye.position() to Eye.anchor() distance in Scene units.
    3D Cameras return the projected Eye Eye.position() to Eye.anchor() distance along the Camera Z axis and use it in Eye.getBoundaryWidthHeight(float[]) so that when the Camera is translated forward then its frustum is narrowed, making the object appear bigger on screen, as intuitively expected.
    
    Specified by:
    
    distanceToAnchor in class Eye
  - at
```
public Vec at()
```
    Description copied from class: Eye
    
    2D Windows return the postion. 3D Cameras return a point defined in the world coordinate system where the camera is pointing at (just in front of Eye.viewDirection()). Useful for setting the Processing camera() which uses a similar approach of that found in gluLookAt.
    
    Specified by:
    
    at in class Eye
    
    See Also:
    
    Eye.lookAt(Vec)

Class Window

Nested Class Summary

Nested classes/interfaces inherited from class remixlab.dandelion.core.Eye

Field Summary

Fields inherited from class remixlab.dandelion.core.Eye

Constructor Summary

Method Summary

Methods inherited from class remixlab.dandelion.core.Eye

Methods inherited from class java.lang.Object

Constructor Detail

Window

Method Detail

get

computeView

computeProjection

fromView

setUpVector

setUpVector

setUpVector

setPosition

setSceneCenterFromPixel

fitBoundingBox

fitBall

setSceneBoundingBox

fitScreenRegion

setOrientation

setOrientation

computeBoundaryEquations

computeBoundaryEquations

distanceToBoundary

boxVisibility

ballVisibility

isPointVisible

isPointVisible

sceneToPixelRatio

lookAt

lookAt

setAnchor

setAnchorFromPixel

interpolateToZoomOnPixel

distanceToSceneCenter

distanceToAnchor

at