Lets get started by defining an interface that will be used by different types of map projections. Most of the methods are simple setters and getters for the variables needed to compute projections, such as the center coordinate, the radius, and screen coordinate of the center point of the projection. The interface defines setters and getters for variables needed to draw an overlay showing lines of latitude and longitude. Methods for converting a screen point to a coordinate and coordinate to a screen point are defined as well. Since overlay grid and text can have lots of points, a couple methods were added to retrieve the grid and text as shapes, to speed up the computation a bit.

 /*
    * MapProjection.java
    *
    * Copyright (c) 2002, 2003, Raben Systems, Inc.
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
   *    Redistributions of source code must retain the above copyright notice,
   *    this list of conditions and the following disclaimer.
   *
   *    Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   *
   *    Neither the name of Raben Systems, Inc. nor the names of its contributors
   *    may be used to endorse or promote products derived from this software
   *    without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   *
   * Created on June 6, 2002, 6:19 PM
   */
  
  package com.raben.projection.map;
      import java.awt.geom.Point2D;   
      import java.awt.geom.GeneralPath;
      import java.awt.Graphics2D;   
      
  /***
   * Interface for map projection
   * @author  Vern Raben
   * @version $Revision: 1.2 $ $Date: 2003/10/10 18:04:23 $
   */
  public interfaceMapProjection {
      
      /*** Get center coordinate in radians
       * @return Value of property centerCoordinate.
       */
      java.awt.geom.Point2D getCenterCoordinate();        
      
      /*** Set longitude and latitude of the center coordinate in radians
       * @param centerCoordinate Point2D in radians
       */
      void setCenterCoordinate(java.awt.geom.Point2D centerCoordinate);
      
      /*** Get screen coordinates of center of map
       * @return screen coordinates of the center of map
       */
      java.awt.geom.Point2D getCenterPoint();
      
      /*** 
       * Set centerPoint screen coordinate
       * @param centerPoint Point2D The screen Location of the center of map
       */
      void setCenterPoint(java.awt.geom.Point2D centerPoint);
      
      /*** Get radius (equatorial radius for ellipsoid)
       * @return Value of property radius.
       */
      double getRadius();
      
      /*** 
       * Set radius (equatorial radius for ellipsoid)
       * @param radius New value of property radius.
       */
      void setRadius(double radius);
      
      /*** 
       * Get overlay grid for map
       * @return mapOverlay GeneneralPath
       */
      GeneralPath getOverlayGridPath();
      
      /*** 
       * Set overlay grid longitude increment in radians
       * @param longitudeIncrement Amount longitude is incremented when drawing 
       * grid
       */
      void setOverlayGridLongitudeIncrement(double longitudeIncrement);
      
      
      /*** 
       * Get overlay grid longitude increment in radians
       * @return double Amount longitude is incremented when drawing grid
       */
      double getOverlayGridLongitudeIncrement(); 
      
     /***
      * Set overlay grid latitude increment in radians
      * @param latitudeIncrement Amount latitude is incremented when drawing grid
      */
     void setOverlayGridLatitudeIncrement(double latitudeIncrement); 
     
     /***
      * Get overlay grid latitude increment in radians
      * @return double Amount latitude is incremented when drawing grid
      */
     double getOverlayGridLatitudeIncrement();     
     
     /***
      * Set overlay grid incrment in radians along the grid line
      * @param gridIncrement in radians
      */
     void setOverlayGridIncrement(double gridIncrement);
         
     /***
      * Get overlay grid incrment in radians along the grid line
      * @return double Grid increment in radians along grid line
      */
     double getOverlayGridIncrement();     
     
     /*** Get text overlay for the map
      * @param g2D Graphics resource
      * @return mapOverlayText GeneralPath
      */
     GeneralPath getTextPath(Graphics2D g2D);
 
     /***
      * Add overlay text
      * @param coordTxt to be added to overlay
      */
     void addOverlayText(CoordinateText coordTxt);   
     
     /***
      * Get coordinate for a given Location in screen coordinates
      * @param loc Point2D Screen Location
      * @return Point2D Coordinate of the point in radians
      */
     Point2D getCoordinateForLocation(Point2D loc);     
     
    /*** 
      * Get latitude range in radians (example -PI/4 to +PI/4 = PI/2)
      * Default is PI
      * @return latitude range in radians
      */
     double getLatitudeRange();    
     
     
     /***
      * Get Location for specified coordinate in radians
      * @param coordinate Point2D Longitude and latitude of coordinate in radians
      * @return Point2D Screen Location of the coordinate
      */
     Point2D getLocationForCoordinate(Point2D coordinate); 
     
     /***
      * Normalize coordinate so that longitude is in the range -PI to +PI 
      * radians and latitude is in the range -PI_OVER_2 to +PI_OVER_2 radians;
      * @param coordinate in radians
      */
     void normalizeCoordinate(Point2D coordinate);
         
     /***
      * Set latitude range in radians (example -PI/4 to +PI/4 = PI/2)
      * @param latitudeRange double in radians
      */
     void setLatitudeRange(double latitudeRange);
     
     /***
      * Convert coordinate in radians to degrees
      * @param radians Point2D coordinate in radians
      * @return Point2D coordinate in degrees
      */
     Point2D toDegrees(Point2D radians);
     
     /***
      * Convert coordinate in degrees to radians
      * @param degrees Point2D in degrees
      * @return Point2D Coordinate in radians
      */
     Point2D toRadians(Point2D degrees);
 
     /***
      * Get eccentricity for ellipsoid
      * @return double
      */
     double getEccentricity();
     
     /***
      * Set eccentricity for ellipsoid
      * @param eccentricity double
      */
     void setEccentricity(double eccentricity);
     
     /*** Normalize latitude so that its in range -PI_OVER_2 to +PI_OVER_2
      * @param latitude double (in radians)
      * @return double Normalized latitude in radians
      */
     double normalizeLatitude(double latitude);
     
     /*** Normalize longitude so that its in range -PI to +PI
      * @param longitude double (in radians)
      * @return double Normalize longitude in radians
      */
     double normalizeLongitude(double longitude);
     
     /*** Get projection name
      * @return ProjectionName
      */
     ProjectionName getProjectionName();
     
     /*** Getter for property textRadius.
      * @return Value of property textRadius.
      */
     double getTextRadius();
     
     /*** Setter for property textRadius.
      * @param textRadius New value of property textRadius.
      */
     void setTextRadius(double textRadius);
     
     /*** Set coordinate text to be displayed
      * @param coordinateTextList The list of coordinate text to be displayed
      */
     void setCoordinateTextList(CoordinateTextList coordinateTextList);
     
     /*** Set whether projection is mirrored by display routine
      * affects text display only
      * @param textMirrored True if the text should be mirrored 
      * (flipped horizontally)
      */
     void setTextMirrored(boolean textMirrored);
     
     /*** Returns whther or not text is inverted (flipped vertically)
      * @return Value of property inverted.
      */
     boolean isTextInverted();
     
     /***
      * Returns whether text is mirrored  (flipped horizontally)
      * @return Value of property mirror.
      */
     boolean isTextMirrored();
     
     /*** Set whether or not text is inverted (flipped vertically)
      * @param textInverted True if text should be inverted
      */
     void setTextInverted(boolean textInverted);
     
 }
 

Next we'll define a skeletal implementation of the MapProjection interface