## com.bbn.openmap.proj
Class Cylindrical

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

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

Direct Known Subclasses:
  CADRG, LLXY, Mercator

public abstract class Cylindrical
extends Proj

Base of all cylindrical projections.

See Also:
  `Projection`, `Proj`, `Mercator`, `CADRG`, Serialized Form

Field Summary
`protected int` `half_world`
`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
`Cylindrical(LatLonPoint center, float scale, int width, int height, int type)` Construct a cylindrical projection.

Method Summary
`protected java.util.ArrayList` `_forwardPoly(float[] rawllpts, int ltype, int nsegs, boolean isFilled)` Forward project a raw float[] Poly.
`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.
`static void` `dumpPoly(float[] rawllpts, int[] xs, int[] ys)`
`boolean` `forwardRaw(float[] rawllpts, int rawoff, int[] xcoords, int[] ycoords, boolean[] visible, int copyoff, int copylen)` Forward project a raw array of radian points.
`LatLonPoint` `getLowerRight()` Get the lower right (southeast) point of the projection.
`java.lang.String` `getName()` Get the name string of the projection.
`LatLonPoint` `getUpperLeft()` Get the upper left (northwest) point of the projection.
`void` `pan(float Az)` Pan the map/projection.
`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
`forward, forward, forward, inverse, inverse, isPlotable`

Field Detail

### world

    protected java.awt.Point world

### half_world

    protected int half_world

Constructor Detail

### Cylindrical

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

  Construct a cylindrical 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`

### 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`

### getUpperLeft

    public LatLonPoint getUpperLeft()

  Get the upper left (northwest) point of the projection.

  Returns the upper left point (or closest equivalent) of the projection based on the center point and height and width of screen.

  Returns:
    LatLonPoint

### getLowerRight

    public LatLonPoint getLowerRight()

  Get the lower right (southeast) point of the projection.

  Returns the lower right point (or closest equivalent) of the projection based on the center point and height and width of screen.

  Returns:
    LatLonPoint

### 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.

### _forwardPoly

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

  Forward project a raw float[] Poly.

  Implementation:
  For the cylindrical "boxy" family of projections, we project all the points, and check the horizontal (longitudinal) spacing between vertices as we go. If the spacing is greater than half the world width (circumference) in pixels, we assume that the segment has wrapped off one edge of the screen and back onto the other side. (NOTE that our restrictions on line segments mentioned in the Projection interface do not allow for lines >= 180 degrees of arc or for the difference in longitude between two points to be >= 180 degrees of arc).

  For the case where a segment wraps offscreen, we keep track of the wrapping adjustment factor, and shift the points as we go. After projecting and shifting all the points, we have a single continuous x-y polygon. We then need to make shifted copies of this polygon for the maxima and minima wrap values calculated during the projection process. This allows us to see the discontinuous (wrapped) sections on the screen when they are drawn.

  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 segments between vertices (or if < 0, generate this value internally)
    `isFilled` - filled poly? this is currently ignored for cylindrical projections.
  Returns:
    ArrayList of x[], y[], x[], y[], ... the projected poly

### dumpPoly

    public static final void dumpPoly(float[] rawllpts,
                                      int[] xs,
                                      int[] ys)

### 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