## com.bbn.openmap.proj
Class Azimuth

    java.lang.Object
      com.bbn.openmap.proj.Proj
          com.bbn.openmap.proj.Azimuth

All Implemented Interfaces:
  java.lang.Cloneable, Projection, java.io.Serializable

Direct Known Subclasses:
  Gnomonic, Orthographic

public abstract class Azimuth
extends Proj

Base of all azimuthal projections.

See Also:
  `Orthographic`, `Gnomonic`, Serialized Form

Nested Class Summary
`protected static class` `Azimuth.AzimuthVar`

Field Summary
`protected boolean` `clockwise` Traverse poly vertices in clockwise order.
`protected static java.awt.Color` `spaceColor`
`protected java.awt.Point` `world`

Fields inherited from class com.bbn.openmap.proj.Proj
`ctrLat, ctrLon, DATELINE, height, maxscale, mercator, MIN_HEIGHT, MIN_WIDTH, minscale, NORTH_POLE, NUM_DEFAULT_CIRCLE_VERTS, NUM_DEFAULT_GREAT_SEGS, pixelsPerMeter, planetPixelCircumference, planetPixelRadius, planetRadius, projID, scale, scaled_radius, SOUTH_POLE, type, width, XSCALE_THRESHOLD, XTHRESHOLD`

Constructor Summary
`Azimuth(LatLonPoint center, float scale, int width, int height, int type)` Construct an azimuthal projection.

Method Summary
`protected abstract java.awt.Point` `_forward(float lat, float lon, java.awt.Point pt, Azimuth.AzimuthVar azVar)` Forward project a point.
`protected java.util.ArrayList` `_forwardPoly(float[] rawllpts, int ltype, int nsegs, boolean isFilled)` Forward project a lat/lon Poly.
`protected void` `_panE()` Pan the map east.
`protected void` `_panN()` Pan the map north.
`protected void` `_panNE()` Pan the map northeast.
`protected void` `_panNW()` Pan the map northwest.
`protected void` `_panS()` Pan the map south.
`protected void` `_panSE()` Pan the map southeast.
`protected void` `_panSW()` Pan the map southwest.
`protected void` `_panW()` Pan the map west.
`protected void` `computeParameters()` Called when some fundamental parameters change.
`void` `drawBackground(java.awt.Graphics g)` Assume that the Graphics has been set with the Paint/Color needed, just render the shape of the background.
`void` `drawBackground(java.awt.Graphics2D g, java.awt.Paint paint)` Draw the background for the projection.
`java.awt.Point` `forward(float lat, float lon, java.awt.Point pt)` Forward project a point.
`java.awt.Point` `forward(float lat, float lon, java.awt.Point pt, boolean isRadian)` Forward project a point.
`java.awt.Point` `forward(LatLonPoint llp, java.awt.Point pt)` Forward project a point.
`boolean` `forwardRaw(float[] rawllpts, int rawoff, int[] xcoords, int[] ycoords, boolean[] visible, int copyoff, int copylen)` Forward project a raw array of radian points.
`java.lang.String` `getName()` Get the name string of the projection.
`boolean` `isClockwiseTraversal()` Get poly-traversal setting (clockwise or counter-clockwise).
`boolean` `overNorthPole()` Checks if the north pole is visible on the screen.
`boolean` `overPoint(float lat, float lon)` Checks if the point is visible on the screen.
`boolean` `overSouthPole()` Checks if the south pole is visible on the screen.
`void` `pan(float Az)` Pan the map/projection.
`void` `setClockwiseTraversal(boolean value)` Toggle clockwise traversal of poly vertices.
`java.lang.String` `toString()` Return stringified description of this projection.

Methods inherited from class com.bbn.openmap.proj.Proj

`clone, doPolyDispatch, equals, forward, forward, forwardArc, forwardArc, forwardArc, forwardCircle, forwardCircle, forwardCircle, forwardGreatPoly, forwardLine, forwardLine, forwardPoly, forwardPoly, forwardRaster, forwardRect, forwardRect, forwardRect, forwardRhumbPoly, getCenter, getHeight, getMaxScale, getMinScale, getPlanetPixelCircumference, getPlanetPixelRadius, getPlanetRadius, getPPM, getProjectionID, getProjectionType, getScale, getScale, getWidth, hashCode, init, inverse, inverse, isComplicatedLineType, isPlotable, makeClone, normalize_latitude, pan, panE, panE, panN, panN, panNE, panNE, panNW, panNW, panS, panS, panSE, panSE, panSW, panSW, panW, panW, setCenter, setCenter, setHeight, setMaxScale, setMinScale, setParms, setPlanetRadius, setPPM, setProjectionID, setScale, setWidth, wrap_longitude`

Methods inherited from class java.lang.Object
`finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface com.bbn.openmap.proj.Projection
`getLowerRight, getUpperLeft, inverse, inverse, isPlotable`

Field Detail

### world

    protected java.awt.Point world

### clockwise

    protected boolean clockwise

  Traverse poly vertices in clockwise order.

### spaceColor

    protected static java.awt.Color spaceColor

Constructor Detail

### Azimuth

    public Azimuth(LatLonPoint center,
                   float scale,
                   int width,
                   int height,
                   int type)

  Construct an azimuthal projection.

Parameters:
  `center` - LatLonPoint center of projection
  `scale` - float scale of projection
  `width` - width of screen
  `height` - height of screen
  `type` - projection type

Method Detail

### toString

    public java.lang.String toString()

  Return stringified description of this projection.

  Overrides:
    `toString` in class `Proj`
  Returns:
    String
  See Also:
    `Projection.getProjectionID()`

### computeParameters

    protected void computeParameters()

  Called when some fundamental parameters change.

  Each projection will decide how to respond to this change. For instance, they may need to recalculate "constant" parameters used in the forward() and inverse() calls.

  Specified by:
    `computeParameters` in class `Proj`

### setClockwiseTraversal

    public void setClockwiseTraversal(boolean value)

  Toggle clockwise traversal of poly vertices.

  Parameters:
    `value` - boolean

### isClockwiseTraversal

    public boolean isClockwiseTraversal()

  Get poly-traversal setting (clockwise or counter-clockwise).

  Returns:
    boolean

### forward

    public final java.awt.Point forward(LatLonPoint llp,
                                        java.awt.Point pt)

  Forward project a point. Wrapper around Azimuth-specific forwarding.

  Parameters:
    `llp` - LatLonPoint to be projected
    `pt` - Resulting XY Point
  Returns:
    Point pt

### forward

    public final java.awt.Point forward(float lat,
                                        float lon,
                                        java.awt.Point pt)

  Forward project a point. Wrapper around Azimuth-specific forwarding. Lat and lon assumed to be decimal degrees.

  Parameters:
    `lat` - float latitude in decimal degrees
    `lon` - float longitude in decimal degrees
    `pt` - Resulting XY Point
  Returns:
    Point pt

### forward

    public final java.awt.Point forward(float lat,
                                        float lon,
                                        java.awt.Point pt,
                                        boolean isRadian)

  Forward project a point. Wrapper around Azimuth-specific forwarding. Lat/lon assumed to be radians. isRadian only used to create a different method signature - assumed to be true.

  Parameters:
    `lat` - float latitude in radians
    `lon` - float longitude in radians
    `pt` - Resulting XY Point
    `isRadian` - placeholder argument indicating that lat,lon arguments are in radians (can be true or false)
  Returns:
    Point pt
  See Also:
    `Projection.forward(float,float,Point)`

### _forward

    protected abstract java.awt.Point _forward(float lat,
                                               float lon,
                                               java.awt.Point pt,
                                               Azimuth.AzimuthVar azVar)

  Forward project a point. If the point is not within the viewable hemisphere, return flags in AzimuthVar variable if specified.

  Parameters:
    `lat` - latitude in radians
    `lon` - longitude in radians
    `pt` - Point
    `azVar` - AzimuthVar or null
  Returns:
    Point pt

### pan

    public void pan(float Az)

  Pan the map/projection.
  - `pan(±180, c)` pan south
  - `pan(-90, c)` pan west
  - `pan(0, c)` pan north
  - `pan(90, c)` pan east

  Specified by:
    `pan` in interface `Projection`
  Overrides:
    `pan` in class `Proj`
  Parameters:
    `Az` - azimuth "east of north" in decimal degrees: `-180 <= Az <= 180`

### _panNW

    protected void _panNW()

  Pan the map northwest.

### _panN

    protected void _panN()

  Pan the map north.

### _panNE

    protected void _panNE()

  Pan the map northeast.

### _panE

    protected void _panE()

  Pan the map east.

### _panSE

    protected void _panSE()

  Pan the map southeast.

### _panS

    protected void _panS()

  Pan the map south.

### _panSW

    protected void _panSW()

  Pan the map southwest.

### _panW

    protected void _panW()

  Pan the map west.

### overNorthPole

    public boolean overNorthPole()

  Checks if the north pole is visible on the screen.

  Returns:
    boolean

### overSouthPole

    public boolean overSouthPole()

  Checks if the south pole is visible on the screen.

  Returns:
    boolean

### overPoint

    public boolean overPoint(float lat,
                             float lon)

  Checks if the point is visible on the screen.

  Parameters:
    `lat` - latitude in radians
    `lon` - longitude in radians
  Returns:
    boolean true if visible, false if not

### _forwardPoly

    protected java.util.ArrayList _forwardPoly(float[] rawllpts,
                                               int ltype,
                                               int nsegs,
                                               boolean isFilled)

  Forward project a lat/lon Poly. This is a complex method. Please read the in-code documentation for an explanation of the algorithm.

  Specified by:
    `_forwardPoly` in class `Proj`
  Parameters:
    `rawllpts` - float[] of lat,lon,lat,lon,... in RADIANS!
    `ltype` - line type (straight, rhumbline, greatcircle)
    `nsegs` - number of segment points (only for greatcircle or rhumbline line types, and if < 1, this value is generated internally)
    `isFilled` - filled poly?
  Returns:
    ArrayList of x[], y[], x[], y[], ... projected poly

### forwardRaw

    public boolean forwardRaw(float[] rawllpts,
                              int rawoff,
                              int[] xcoords,
                              int[] ycoords,
                              boolean[] visible,
                              int copyoff,
                              int copylen)

  Forward project a raw array of radian points. This assumes nothing about the array of coordinates. In no way does it assume the points are connected or that the composite figure is to be filled.

  It does populate a visible array indicating whether the points are visible on the projected view of the world.

  Parameters:
    `rawllpts` - array of lat,lon,... in radians
    `rawoff` - offset into rawllpts
    `xcoords` - x coordinates
    `ycoords` - y coordinates
    `visible` - coordinates visible?
    `copyoff` - offset into x,y,visible arrays
    `copylen` - number of coordinates (coordinate arrays should be at least this long, rawllpts should be at least twice as long).
  Returns:
    boolean true if all points visible, false if some points not visible.

### drawBackground

    public void drawBackground(java.awt.Graphics2D g,
                               java.awt.Paint paint)

  Draw the background for the projection.

  Specified by:
    `drawBackground` in class `Proj`
  Parameters:
    `g` - Graphics2D
    `paint` - java.awt.Paint to use for the background

### drawBackground

    public void drawBackground(java.awt.Graphics g)

  Assume that the Graphics has been set with the Paint/Color needed, just render the shape of the background.

  Specified by:
    `drawBackground` in class `Proj`

### getName

    public java.lang.String getName()

  Get the name string of the projection.

  Specified by:
    `getName` in interface `Projection`
  Overrides:
    `getName` in class `Proj`

Copyright (C) BBNT Solutions LLC; See http://openmap.bbn.com/ for details