Projection (osmdroid-android 6.1.1 API)

java.lang.Object
- org.osmdroid.views.Projection

All Implemented Interfaces:

IProjection
```
public class Projection
extends Object
implements IProjection
```
A Projection serves to translate between the coordinate system of x/y on-screen pixel coordinates and that of latitude/longitude points on the surface of the earth. You obtain a Projection from MapView.getProjection(). You should not hold on to this object for more than one draw, since the projection of the map could change.

Uses the web mercator projection Note: This class will "wrap" all pixel and lat/long values that overflow their bounds (rather than clamping to their bounds).

Field Summary

Fields
Modifier and Type	Field and Description
`double`	`mProjectedMapSize` Size of the "projected" map: a virtual map with the largest zoom level WARNING: `mProjectedMapSize` MUST NOT be a static member, as it depends on `TileSystem.getTileSize()`

Constructor Summary

Constructors
Constructor and Description
`Projection(double pZoomLevel, int pWidth, int pHeight, GeoPoint pCenter, float pOrientation, boolean pHorizontalWrapEnabled, boolean pVerticalWrapEnabled, int pMapCenterOffsetX, int pMapCenterOffsetY)`
`Projection(double pZoomLevel, Rect pScreenRect, GeoPoint pCenter, long pScrollX, long pScrollY, float pOrientation, boolean pHorizontalWrapEnabled, boolean pVerticalWrapEnabled, TileSystem pTileSystem, int pMapCenterOffsetX, int pMapCenterOffsetY)`
`Projection(MapView mapView)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`adjustOffsets(BoundingBox pBoundingBox)` Deprecated. Use `adjustOffsets(double, double, boolean, int)` instead
`(package private) void`	`adjustOffsets(double pNorthOrWest, double pSouthOrEast, boolean isLatitude, int pExtraSize)` Adjust offsets so that north and south (if latitude, west and east if longitude) actually "fit" into the screen, with a tolerance of extraSize pixels.
`void`	`adjustOffsets(IGeoPoint pGeoPoint, PointF pPixel)` Adjust the offsets so that this geo point projects into that pixel
`(package private) void`	`adjustOffsets(long pDeltaX, long pDeltaY)`
`void`	`detach()`
`IGeoPoint`	`fromPixels(int x, int y)` Create a new GeoPoint from pixel coordinates relative to the top-left of the MapView that provided this PixelConverter.
`IGeoPoint`	`fromPixels(int pPixelX, int pPixelY, GeoPoint pReuse)` note: if `MapView.setHorizontalMapRepetitionEnabled(boolean)` or `MapView.setVerticalMapRepetitionEnabled(boolean)` is false, then this can return values that beyond the max extents of the world.
`IGeoPoint`	`fromPixels(int pPixelX, int pPixelY, GeoPoint pReuse, boolean forceWrap)` * note: if `MapView.setHorizontalMapRepetitionEnabled(boolean)` or `MapView.setVerticalMapRepetitionEnabled(boolean)` is false, then this can return values that beyond the max extents of the world.
`BoundingBox`	`getBoundingBox()`
`long`	`getCleanMercator(long pMercator, boolean wrapEnabled)`
`GeoPoint`	`getCurrentCenter()`
`int`	`getHeight()`
`Rect`	`getIntrinsicScreenRect()`
`Matrix`	`getInvertedScaleRotateCanvasMatrix()` This will provide a Matrix that will revert the current map's scaling and rotation.
`PointL`	`getLongPixelsFromProjected(PointL in, double powerDifference, boolean pCloser, PointL reuse)`
`long`	`getLongPixelXFromLongitude(double pLongitude)`
`long`	`getLongPixelXFromLongitude(double pLongitude, boolean forceWrap)`
`long`	`getLongPixelYFromLatitude(double pLatitude)`
`long`	`getLongPixelYFromLatitude(double pLatitude, boolean forceWrap)`
`long`	`getMercatorFromTile(int pTile)`
`RectL`	`getMercatorViewPort(RectL pReuse)`
`long`	`getMercatorXFromPixel(int pPixelX)`
`long`	`getMercatorYFromPixel(int pPixelY)`
`IGeoPoint`	`getNorthEast()` Get the coordinates of the most north-easterly visible point of the map.
`long`	`getOffsetX()`
`long`	`getOffsetY()`
`Projection`	`getOffspring(double pZoomLevel, Rect pScreenRect)`
`float`	`getOrientation()`
`Rect`	`getPixelFromTile(int pTileX, int pTileY, Rect pReuse)`
`Point`	`getPixelsFromProjected(PointL in, double powerDifference, Point reuse)` Deprecated. Use `getLongPixelsFromProjected(PointL, double, boolean, PointL)` instead
`double`	`getProjectedPowerDifference()`
`Matrix`	`getScaleRotateCanvasMatrix()` This will provide a Matrix that will revert the current map's scaling and rotation.
`int`	`getScreenCenterX()`
`int`	`getScreenCenterY()`
`Rect`	`getScreenRect()`
`static long`	`getScrollableOffset(long pPixelMin, long pPixelMax, double pWorldSize, int pScreenSize, int pExtraSize)`
`IGeoPoint`	`getSouthWest()` Get the coordinates of the most south-westerly visible point of the map.
`int`	`getTileFromMercator(long pMercator)`
`int`	`getWidth()`
`double`	`getZoomLevel()`
`boolean`	`isHorizontalWrapEnabled()`
`boolean`	`isVerticalWrapEnabled()`
`float`	`metersToEquatorPixels(float meters)` Converts a distance in meters (along the equator) to one in (horizontal) pixels at the current zoomlevel.
`float`	`metersToPixels(float meters)` Converts a distance in meters to one in (horizontal) pixels at the current zoomlevel and at the current latitude at the center of the screen.
`float`	`metersToPixels(float meters, double latitude, double zoomLevel)`
`void`	`restore(Canvas pCanvas, boolean pForce)`
`Point`	`rotateAndScalePoint(int x, int y, Point reuse)` This will apply the current map's scaling and rotation for a point.
`void`	`save(Canvas pCanvas, boolean pMapRotation, boolean pForce)`
`(package private) boolean`	`setMapScroll(MapView pMapView)`
`PointL`	`toMercatorPixels(int pPixelX, int pPixelY, PointL reuse)`
`Point`	`toPixels(IGeoPoint in, Point reuse)` Converts the given `IGeoPoint` to onscreen pixel coordinates, relative to the top-left of the `MapView` that provided this Projection.
`Point`	`toPixels(IGeoPoint in, Point reuse, boolean forceWrap)`
`Point`	`toPixelsFromMercator(long pMercatorX, long pMercatorY, Point reuse)` Deprecated. Use `getLongPixelsFromProjected(PointL, double, boolean, PointL)` instead
`Point`	`toPixelsFromProjected(PointL in, Point reuse)` Deprecated. Use `getLongPixelsFromProjected(PointL, double, boolean, PointL)` instead
`PointL`	`toProjectedPixels(double latitude, double longitude, boolean pWrapEnabled, PointL reuse)`
`PointL`	`toProjectedPixels(double latitude, double longitude, PointL reuse)` Performs only the first computationally heavy part of the projection.
`PointL`	`toProjectedPixels(GeoPoint geoPoint, PointL reuse)` A wrapper for `toProjectedPixels(double, double, PointL)`
`PointL`	`toProjectedPixels(long latituteE6, long longitudeE6, PointL reuse)` Deprecated. Use `toProjectedPixels(double, double, PointL)` instead
`Point`	`unrotateAndScalePoint(int x, int y, Point reuse)` This will revert the current map's scaling and rotation for a point.

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

- Field Detail
  - mProjectedMapSize
```
public final double mProjectedMapSize
```
    Size of the "projected" map: a virtual map with the largest zoom level WARNING: `mProjectedMapSize` MUST NOT be a static member, as it depends on TileSystem.getTileSize()
- Constructor Detail
  - Projection
```
Projection(MapView mapView)
```
  - Projection
```
public Projection(double pZoomLevel,
                  Rect pScreenRect,
                  GeoPoint pCenter,
                  long pScrollX,
                  long pScrollY,
                  float pOrientation,
                  boolean pHorizontalWrapEnabled,
                  boolean pVerticalWrapEnabled,
                  TileSystem pTileSystem,
                  int pMapCenterOffsetX,
                  int pMapCenterOffsetY)
```
    Since:
    
    6.0.0
  - Projection
```
public Projection(double pZoomLevel,
                  int pWidth,
                  int pHeight,
                  GeoPoint pCenter,
                  float pOrientation,
                  boolean pHorizontalWrapEnabled,
                  boolean pVerticalWrapEnabled,
                  int pMapCenterOffsetX,
                  int pMapCenterOffsetY)
```
    Since:
    
    6.1.0
- Method Detail
  - getOffspring
```
public Projection getOffspring(double pZoomLevel,
                               Rect pScreenRect)
```
    Since:
    
    6.0.0
  - getZoomLevel
```
public double getZoomLevel()
```
  - getBoundingBox
```
public BoundingBox getBoundingBox()
```
  - getScreenRect
```
public Rect getScreenRect()
```
  - getIntrinsicScreenRect
```
public Rect getIntrinsicScreenRect()
```
  - fromPixels
```
public IGeoPoint fromPixels(int x,
                            int y)
```
    Description copied from interface: IProjection
    
    Create a new GeoPoint from pixel coordinates relative to the top-left of the MapView that provided this PixelConverter.
    
    Specified by:
    
    fromPixels in interface IProjection
  - fromPixels
```
public IGeoPoint fromPixels(int pPixelX,
                            int pPixelY,
                            GeoPoint pReuse)
```
    note: if MapView.setHorizontalMapRepetitionEnabled(boolean) or MapView.setVerticalMapRepetitionEnabled(boolean) is false, then this can return values that beyond the max extents of the world. This may or may not be desired. https://github.com/osmdroid/osmdroid/pull/722 for more information and the discussion associated with this.
    
    Parameters:
    
    pPixelX -
    
    pPixelY -
    
    pReuse -
    
    Returns:
  - fromPixels
```
public IGeoPoint fromPixels(int pPixelX,
                            int pPixelY,
                            GeoPoint pReuse,
                            boolean forceWrap)
```
    * note: if MapView.setHorizontalMapRepetitionEnabled(boolean) or MapView.setVerticalMapRepetitionEnabled(boolean) is false, then this can return values that beyond the max extents of the world. This may or may not be desired. https://github.com/osmdroid/osmdroid/pull/722 for more information and the discussion associated with this.
    
    Parameters:
    
    pPixelX -
    
    pPixelY -
    
    pReuse -
    
    forceWrap -
    
    Returns:
  - toPixels
```
public Point toPixels(IGeoPoint in,
                      Point reuse)
```
    Description copied from interface: IProjection
    
    Converts the given IGeoPoint to onscreen pixel coordinates, relative to the top-left of the MapView that provided this Projection.
    
    Specified by:
    
    toPixels in interface IProjection
    
    Parameters:
    
    in - The latitude/longitude pair to convert.
    
    reuse - A pre-existing object to use for the output; if null, a new Point will be allocated and returned.
  - toPixels
```
public Point toPixels(IGeoPoint in,
                      Point reuse,
                      boolean forceWrap)
```
  - getLongPixelXFromLongitude
```
public long getLongPixelXFromLongitude(double pLongitude,
                                       boolean forceWrap)
```
    Since:
    
    6.0.0 TODO refactor
  - getLongPixelXFromLongitude
```
public long getLongPixelXFromLongitude(double pLongitude)
```
    Since:
    
    6.0.0 TODO refactor
  - getLongPixelYFromLatitude
```
public long getLongPixelYFromLatitude(double pLatitude,
                                      boolean forceWrap)
```
    Since:
    
    6.0.0 TODO refactor
  - getLongPixelYFromLatitude
```
public long getLongPixelYFromLatitude(double pLatitude)
```
    Since:
    
    6.0.0 TODO refactor
  - toProjectedPixels
```
public PointL toProjectedPixels(GeoPoint geoPoint,
                                PointL reuse)
```
    A wrapper for toProjectedPixels(double, double, PointL)
  - toProjectedPixels
```
@Deprecated
public PointL toProjectedPixels(long latituteE6,
                                             long longitudeE6,
                                             PointL reuse)
```
    Deprecated. Use toProjectedPixels(double, double, PointL) instead
    
    Performs only the first computationally heavy part of the projection. Call getLongPixelsFromProjected(PointL, double, boolean, PointL) to get the final position.
    
    Parameters:
    
    latituteE6 - the latitute of the point
    
    longitudeE6 - the longitude of the point
    
    reuse - just pass null if you do not have a PointL to be 'recycled'.
    
    Returns:
    
    intermediate value to be stored and passed to toMapPixelsTranslated.
  - toProjectedPixels
```
public PointL toProjectedPixels(double latitude,
                                double longitude,
                                PointL reuse)
```
    Performs only the first computationally heavy part of the projection. Call getLongPixelsFromProjected(PointL, double, boolean, PointL) to get the final position.
    
    Parameters:
    
    latitude - the latitute of the point
    
    longitude - the longitude of the point
    
    reuse - just pass null if you do not have a PointL to be 'recycled'.
    
    Returns:
    
    intermediate value to be stored and passed to toMapPixelsTranslated.
  - toProjectedPixels
```
public PointL toProjectedPixels(double latitude,
                                double longitude,
                                boolean pWrapEnabled,
                                PointL reuse)
```
    Since:
    
    6.0.0
  - toPixelsFromProjected
```
@Deprecated
public Point toPixelsFromProjected(PointL in,
                                                Point reuse)
```
    Deprecated. Use getLongPixelsFromProjected(PointL, double, boolean, PointL) instead
    
    Performs the second computationally light part of the projection.
    
    Parameters:
    
    in - the PointL calculated by the toProjectedPixels(double, double, PointL)
    
    reuse - just pass null if you do not have a Point to be 'recycled'.
    
    Returns:
    
    the Point containing the coordinates of the initial GeoPoint passed to the toProjectedPixels(double, double, PointL).
  - toPixelsFromMercator
```
@Deprecated
public Point toPixelsFromMercator(long pMercatorX,
                                               long pMercatorY,
                                               Point reuse)
```
    Deprecated. Use getLongPixelsFromProjected(PointL, double, boolean, PointL) instead
  - toMercatorPixels
```
public PointL toMercatorPixels(int pPixelX,
                               int pPixelY,
                               PointL reuse)
```
  - metersToEquatorPixels
```
public float metersToEquatorPixels(float meters)
```
    Description copied from interface: IProjection
    
    Converts a distance in meters (along the equator) to one in (horizontal) pixels at the current zoomlevel. In the default Mercator projection, the actual number of pixels for a given distance will get higher as you move away from the equator.
    
    Specified by:
    
    metersToEquatorPixels in interface IProjection
    
    Parameters:
    
    meters - the distance in meters
    
    Returns:
    
    The number of pixels corresponding to the distance, if measured along the equator, at the current zoom level. The return value may only be approximate.
  - metersToPixels
```
public float metersToPixels(float meters)
```
    Converts a distance in meters to one in (horizontal) pixels at the current zoomlevel and at the current latitude at the center of the screen.
    
    Parameters:
    
    meters - the distance in meters
    
    Returns:
    
    The number of pixels corresponding to the distance, if measured at the center of the screen, at the current zoom level. The return value may only be approximate.
  - metersToPixels
```
public float metersToPixels(float meters,
                            double latitude,
                            double zoomLevel)
```
    Since:
    
    6.0
  - getNorthEast
```
public IGeoPoint getNorthEast()
```
    Description copied from interface: IProjection
    
    Get the coordinates of the most north-easterly visible point of the map.
    
    Specified by:
    
    getNorthEast in interface IProjection
  - getSouthWest
```
public IGeoPoint getSouthWest()
```
    Description copied from interface: IProjection
    
    Get the coordinates of the most south-westerly visible point of the map.
    
    Specified by:
    
    getSouthWest in interface IProjection
  - getInvertedScaleRotateCanvasMatrix
```
public Matrix getInvertedScaleRotateCanvasMatrix()
```
    This will provide a Matrix that will revert the current map's scaling and rotation. This can be useful when drawing to a fixed location on the screen.
  - unrotateAndScalePoint
```
public Point unrotateAndScalePoint(int x,
                                   int y,
                                   Point reuse)
```
    This will revert the current map's scaling and rotation for a point. This can be useful when drawing to a fixed location on the screen.
  - rotateAndScalePoint
```
public Point rotateAndScalePoint(int x,
                                 int y,
                                 Point reuse)
```
    This will apply the current map's scaling and rotation for a point. This can be useful when converting MotionEvents to a screen point.
  - detach
```
public void detach()
```
    Since:
    
    5.6
  - getPixelFromTile
```
public Rect getPixelFromTile(int pTileX,
                             int pTileY,
                             Rect pReuse)
```
    Since:
    
    6.0.0
  - getMercatorFromTile
```
public long getMercatorFromTile(int pTile)
```
    Since:
    
    6.0.0
  - getScaleRotateCanvasMatrix
```
public Matrix getScaleRotateCanvasMatrix()
```
    This will provide a Matrix that will revert the current map's scaling and rotation. This can be useful when drawing to a fixed location on the screen.
  - getProjectedPowerDifference
```
public double getProjectedPowerDifference()
```
    Since:
    
    6.0.0
  - getPixelsFromProjected
```
@Deprecated
public Point getPixelsFromProjected(PointL in,
                                                 double powerDifference,
                                                 Point reuse)
```
    Deprecated. Use getLongPixelsFromProjected(PointL, double, boolean, PointL) instead
    
    Since:
    
    6.0.0
  - getLongPixelsFromProjected
```
public PointL getLongPixelsFromProjected(PointL in,
                                         double powerDifference,
                                         boolean pCloser,
                                         PointL reuse)
```
    Parameters:
    
    in - Input point: a geo point projected to the map with the largest zoom level (aka "projected" map)
    
    powerDifference - Factor between the large "projected" map and the wanted projection zoom level
    
    pCloser - "Should we move the resulting point - modulo the map size - so that it's as close to the screen limits as possible?"
    
    Since:
    
    6.0.0
  - getTileFromMercator
```
public int getTileFromMercator(long pMercator)
```
    Since:
    
    6.0.0
  - getMercatorViewPort
```
public RectL getMercatorViewPort(RectL pReuse)
```
    Since:
    
    6.0.0
  - getScreenCenterX
```
public int getScreenCenterX()
```
    Since:
    
    6.0.0
  - getScreenCenterY
```
public int getScreenCenterY()
```
    Since:
    
    6.0.0
  - getMercatorXFromPixel
```
public long getMercatorXFromPixel(int pPixelX)
```
    Since:
    
    6.0.0
  - getMercatorYFromPixel
```
public long getMercatorYFromPixel(int pPixelY)
```
    Since:
    
    6.0.0
  - getCleanMercator
```
public long getCleanMercator(long pMercator,
                             boolean wrapEnabled)
```
    Since:
    
    6.0.0
  - getCurrentCenter
```
public GeoPoint getCurrentCenter()
```
    Since:
    
    6.0.0
  - getOffsetX
```
public long getOffsetX()
```
  - getOffsetY
```
public long getOffsetY()
```
  - save
```
public void save(Canvas pCanvas,
                 boolean pMapRotation,
                 boolean pForce)
```
    Since:
    
    6.0.0
  - restore
```
public void restore(Canvas pCanvas,
                    boolean pForce)
```
    Since:
    
    6.0.0
  - adjustOffsets
```
public void adjustOffsets(IGeoPoint pGeoPoint,
                          PointF pPixel)
```
    Adjust the offsets so that this geo point projects into that pixel
    
    Since:
    
    6.0.0
  - adjustOffsets
```
@Deprecated
public void adjustOffsets(BoundingBox pBoundingBox)
```
    Deprecated. Use adjustOffsets(double, double, boolean, int) instead
    
    Adjust the offsets so that either this bounding box is bigger than the screen and contains it or it is smaller and it is centered
    
    Since:
    
    6.0.0
  - adjustOffsets
```
void adjustOffsets(double pNorthOrWest,
                   double pSouthOrEast,
                   boolean isLatitude,
                   int pExtraSize)
```
    Adjust offsets so that north and south (if latitude, west and east if longitude) actually "fit" into the screen, with a tolerance of extraSize pixels. Used in order to ensure scroll limits.
    
    Since:
    
    6.0.0
  - adjustOffsets
```
void adjustOffsets(long pDeltaX,
                   long pDeltaY)
```
    Since:
    
    6.0.0
  - getScrollableOffset
```
public static long getScrollableOffset(long pPixelMin,
                                       long pPixelMax,
                                       double pWorldSize,
                                       int pScreenSize,
                                       int pExtraSize)
```
    Parameters:
    
    pPixelMin - Pixel position of the limit (left)
    
    pPixelMax - Pixel position of the limit (right)
    
    pWorldSize - World map size - for modulo adjustments
    
    pScreenSize - Screen size
    
    pExtraSize - Extra size to consider at each side of the screen
    
    Returns:
    
    the offset to apply so that the limits are within the screen
    
    Since:
    
    6.0.0
  - setMapScroll
```
boolean setMapScroll(MapView pMapView)
```
    Since:
    
    6.0.0
  - isHorizontalWrapEnabled
```
public boolean isHorizontalWrapEnabled()
```
    Since:
    
    6.1.0
  - isVerticalWrapEnabled
```
public boolean isVerticalWrapEnabled()
```
    Since:
    
    6.1.0
  - getOrientation
```
public float getOrientation()
```
    Since:
    
    6.1.0
  - getWidth
```
public int getWidth()
```
    Since:
    
    6.1.0
  - getHeight
```
public int getHeight()
```
    Since:
    
    6.1.0

Class Projection

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

mProjectedMapSize

Constructor Detail

Projection

Projection

Projection

Method Detail

getOffspring

getZoomLevel

getBoundingBox

getScreenRect

getIntrinsicScreenRect

fromPixels

fromPixels

fromPixels

toPixels

toPixels

getLongPixelXFromLongitude

getLongPixelXFromLongitude

getLongPixelYFromLatitude

getLongPixelYFromLatitude

toProjectedPixels

toProjectedPixels

toProjectedPixels

toProjectedPixels

toPixelsFromProjected

toPixelsFromMercator

toMercatorPixels

metersToEquatorPixels

metersToPixels

metersToPixels

getNorthEast

getSouthWest

getInvertedScaleRotateCanvasMatrix

unrotateAndScalePoint

rotateAndScalePoint

detach

getPixelFromTile

getMercatorFromTile

getScaleRotateCanvasMatrix

getProjectedPowerDifference

getPixelsFromProjected

getLongPixelsFromProjected

getTileFromMercator

getMercatorViewPort

getScreenCenterX

getScreenCenterY

getMercatorXFromPixel

getMercatorYFromPixel

getCleanMercator

getCurrentCenter

getOffsetX

getOffsetY

save

restore

adjustOffsets

adjustOffsets

adjustOffsets

adjustOffsets

getScrollableOffset

setMapScroll

isHorizontalWrapEnabled

isVerticalWrapEnabled

getOrientation

getWidth

getHeight