Uses of Interface com.bbn.openmap.proj.Projection (OpenMap API)
Date: 2016-12-09

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Interface
com.bbn.openmap.proj.Projection

Packages that use Projection
com.bbn.openmap | The com.bbn.openmap package contains the core OpenMap classes.
com.bbn.openmap.dataAccess.asrp |
com.bbn.openmap.dataAccess.dted |
com.bbn.openmap.dataAccess.image |
com.bbn.openmap.dataAccess.mapTile |
com.bbn.openmap.dataAccess.shape | This package provides read and write access to ESRI shape files, including the .shp, .dbf and .shx files.
com.bbn.openmap.event | Provides the various event object and listener interfaces for using the MapBean.
com.bbn.openmap.geo | Package that contains classes to do calculations in lat/lon space.
com.bbn.openmap.graphicLoader | The GraphicLoader package is designed to provide support for components that need to drive changes in OMGraphics over a map.
com.bbn.openmap.gui | This package contains the main OpenMap Swing GUI components.
com.bbn.openmap.gui.menu | This package contains OpenMap Swing GUI components that can be used in menus.
com.bbn.openmap.gui.time |
com.bbn.openmap.image | This package has classes that provide image creation and manipulation capabilities.
com.bbn.openmap.layer | Contains OpenMap layers that read and display a variety of data formats, and a few that create their own data for display.
com.bbn.openmap.layer.beanbox | Provides a sample openmap application that uses the openmap beanbox.
com.bbn.openmap.layer.daynight | Provides an OpenMap layer that displays day/night shading.
com.bbn.openmap.layer.dted | Provides a layer that displays DTED (Digital Terrain Elevation Data) data.
com.bbn.openmap.layer.e00 | This package contains a Layer that displays e00 data.
com.bbn.openmap.layer.learn |
com.bbn.openmap.layer.link | Provide classes to handle the link protocol: a layer that displays link data, classes to assist in writing a link server, and methods that read and write in the link protocol format.
com.bbn.openmap.layer.location | Provides a layer that can display location data - data that represents a location with a graphic and a name.
com.bbn.openmap.layer.mif | This package contains a Layer that displays MapInfo data (.mif files).
com.bbn.openmap.layer.policy | Contains policy objects that affect the behavior of OMGraphicHandlerLayers.
com.bbn.openmap.layer.rpf | Provides a layer that displays RPF (Raster Product Format) data.
com.bbn.openmap.layer.shape | Provides an OpenMap layer for dealing with shape files.
com.bbn.openmap.layer.shape.areas | Provides an extension to the ShapeLayer that deals with attributes files for shapefiles.
com.bbn.openmap.layer.terrain | This package contains the TerrainLayer, which lets you run LOS and path elevation profile queries over the map.
com.bbn.openmap.layer.vpf | This package contains code for dealing with NIMA data distributed in Vector Product Format.
com.bbn.openmap.omGraphics | Provides geographically based graphics classes.
com.bbn.openmap.omGraphics.geom | This package contains the basic foundation classes for OMGraphics, classes that describe the geometry of OMGraphics without any reference to rendering attributes.
com.bbn.openmap.omGraphics.grid | Provides a number of generator classes for OMGrid data.
com.bbn.openmap.omGraphics.labeled | Provides a simple extension to the OMGraphics, where a text string can be attached to a graphic object.
com.bbn.openmap.omGraphics.rule |
com.bbn.openmap.omGraphics.time |
com.bbn.openmap.omGraphics.util | This package contains simple utility classes used specifically for OMGraphics.
com.bbn.openmap.plugin | Provides support for writing OpenMap PlugIns.
com.bbn.openmap.plugin.earthImage | This package contains a plugin that can read in an image, assumed to be in the Mercator projection and covering the entire Earth, and warp it to any OpenMap projection.
com.bbn.openmap.plugin.esri | A PlugIn package that handles ESRI shape files.
com.bbn.openmap.plugin.graphicLoader | The GraphicLoader PlugIn package is designed to provide support for GraphicLoaders, which in turn are objects that need to drive changes in OMGraphics over a map.
com.bbn.openmap.plugin.shis | This package contains a plugin that can fetch images from a com.bbn.openmap.image.SimpleHttpImageServer.
com.bbn.openmap.plugin.wms | This package contains a plugin that can contact, retrieve and display the image received from an OpenGIS Web Map Server (WMS).
com.bbn.openmap.proj | Provides projection classes.
com.bbn.openmap.tools.dnd | This package contains classes to support Java Drag and Drop functionality on the map.
com.bbn.openmap.tools.drawing | Provides classes to implement a drawing tool.
com.bbn.openmap.tools.roads | Provides classes to determine routes given a set of roads and intersections.

Uses of Projection in com.bbn.openmap

Methods in com.bbn.openmap that return Projection
`Projection` | `MapBean.getProjection()` Get the projection property, reflects the projection with no rotation.
`Projection` | `MapBean.RotationHelper.getProjection()`
`Projection` | `Layer.getProjection()` Get the latest projection.
`Projection` | `MapBean.getRotatedProjection()`
`Projection` | `Layer.setProjection(ProjectionEvent projEvent)` This method lets you take the ProjectionEvent received from the MapBean, and lets you know if you should do something with it.

Methods in com.bbn.openmap with parameters of type Projection
`boolean` | `Layer.isProjectionOK(Projection proj)` Method that responds whether the Layer should render on the map, given a particular projection.
`void` | `ProjectionPainter.renderDataForProjection(Projection proj, java.awt.Graphics g)` Given a projection and Graphics, paint graphic objects inside the Graphics.
`void` | `Layer.renderDataForProjection(Projection proj, java.awt.Graphics g)` This method is here to provide a default action for Layers as they act as a ProjectionPainter.
`protected java.awt.image.BufferedImage` | `BufferedMapBean.resetDrawingBuffer(java.awt.image.BufferedImage currentImageBuffer, Projection proj)` Provide a drawing buffer for the layers based on the projection parameters.
`void` | `MapBean.setProjection(Projection aProjection)` Set the projection.
`void` | `Layer.setProjection(Projection proj)` Set the projection the layer should use for calculations.
`protected boolean` | `MapBean.RotationHelper.updateForBufferDimensions(Projection proj)` We're going to try to do buffering with a image that will cover all of the corners when the map is rotated.

Uses of Projection in com.bbn.openmap.dataAccess.asrp

Methods in com.bbn.openmap.dataAccess.asrp with parameters of type Projection
`OMGraphicList` | `ASRPDirectory.checkProjAndGetTiledImages(Projection proj)` Get an OMGraphicList of files that cover the projection.
`OMGraphicList` | `ASRPDirectoryHandler.getCoverageBounds(Projection proj, DrawingAttributes da)`
`OMGraphicList` | `ASRPDirectory.getTiledImages(Projection proj)` Assumes that the projection checks have occurred, have passed, and just fetches the image tiles.
`protected OMGraphicList` | `ASRPDirectory.getTiledImages(java.awt.Rectangle rect, Projection proj)` Provide an OMGraphicList containing the tile blocks described by the rectangle.
`boolean` | `ASRPDirectory.isOnMap(Projection proj)` Return true of current bounds covers the projection area.
`boolean` | `ASRPDirectory.validScale(Projection proj)`

Uses of Projection in com.bbn.openmap.dataAccess.dted

Methods in com.bbn.openmap.dataAccess.dted with parameters of type Projection
`OMGraphic` | `DTEDSlopeGenerator.generate(OMGrid grid, Projection proj)` Called from the OMGrid.generate() method to tell the generator to create something to represent the grid contents.
`OMGraphic` | `DTEDFrame.getImage(Projection proj)` If you just want to get an image for the DTEDFrame, then call this.
`OMGraphicList` | `DTEDFrameCacheHandler.getRectangle(Projection proj)` The call to the cache that lets you choose what kind of information is returned.
`void` | `DTEDFrameCacheHandler.setProjection(Projection proj)` The method to call to let the cache handler know what the projection looks like so it can figure out which frames (and subframes) will be needed.
`void` | `DTEDFrameCacheHandler.setProjection(Projection proj, double lat1, double lon1, double lat2, double lon2)` The method to call to let the cache handler know what the projection looks like so it can figure out which frames (and subframes) will be needed.

Uses of Projection in com.bbn.openmap.dataAccess.image

Methods in com.bbn.openmap.dataAccess.image with parameters of type Projection
`boolean` | `ErrImageTile.generate(Projection proj)`
`boolean` | `ImageTile.regenerate(Projection p)`
`protected boolean` | `ImageTile.shouldFetchForProjection(Projection proj)` Checking to see of the image needs to be updated for the projection parameters, namely scale.
`protected boolean` | `ImageTile.updateImageForProjection(Projection proj)` Called from within generate.

Uses of Projection in com.bbn.openmap.dataAccess.mapTile

Fields in com.bbn.openmap.dataAccess.mapTile declared as Projection
`protected Projection` | `StandardMapTileFactory.lastProj`
`protected Projection` | `MapTileMakerComponent.proj`

Methods in com.bbn.openmap.dataAccess.mapTile with parameters of type Projection
`protected OMGraphic` | `StandardMapTileFactory.createOMGraphicFromBufferedImage(java.awt.image.BufferedImage bi, int x, int y, int zoomLevel, Projection proj)` Creates an OMRaster appropriate for projection and other parameters from a buffered image.
`protected boolean` | `ZoomLevelMakerFace.generate(Projection proj)` Called from the MapTileMakerComponent, so this ZLIF is ready to paint its boundaries if it is activated.
`java.lang.Object` | `StandardMapTileFactory.get(java.lang.Object key, int x, int y, int zoomLevel, Projection proj)` The main call to retrieve something from the cache, modified to allow load method to do some projection calculations to initialize tile parameters.
`CacheObject` | `StandardMapTileFactory.getEmptyTile(java.lang.Object key, int x, int y, int zoomLevel, Projection proj)` Call to make when you want the tile factory to create some empty tile representation for the given location.
`java.awt.image.BufferedImage` | `WholeWorldTileHandler.getImageForEmptyTile(java.lang.String imagePath, int x, int y, int zoomLevel, MapTileCoordinateTransform mtcTransform, Projection proj)`
`java.awt.image.BufferedImage` | `SimpleEmptyTileHandler.getImageForEmptyTile(java.lang.String imagePath, int x, int y, int zoomLevel, MapTileCoordinateTransform mtcTransform, Projection proj)`
`java.awt.image.BufferedImage` | `ShpFileEmptyTileHandler.getImageForEmptyTile(java.lang.String imagePath, int x, int y, int zoomLevel, MapTileCoordinateTransform mtcTransform, Projection proj)`
`java.awt.image.BufferedImage` | `MapTileMaker.getImageForEmptyTile(java.lang.String imagePath, int x, int y, int zoomLevel, MapTileCoordinateTransform mtcTransform, Projection proj)` EmptyTileHandler method, called when a MapTileFactory needs to create and return a missing tile.
`java.awt.image.BufferedImage` | `EmptyTileHandler.getImageForEmptyTile(java.lang.String imagePath, int x, int y, int zoomLevel, MapTileCoordinateTransform mtcTransform, Projection proj)` The main call from the MapTileFactory to return something for the given missing tile.
`float` | `MapTileCoordinateTransform.getScaleForZoomAndProjection(Projection proj, int zoom)` Get the scale value for a Projection and discrete zoom level.
`float` | `AbstractMapTileCoordinateTransform.getScaleForZoomAndProjection(Projection proj, int zoom)` Get the scale value for a Projection and discrete zoom level.
`float[]` | `MapTileCoordinateTransform.getScalesForZoomLevels(Projection proj, int highZoomLevel)` Creates an array of scale values for different zoom levels.
`float[]` | `AbstractMapTileCoordinateTransform.getScalesForZoomLevels(Projection proj, int highZoomLevel)` Creates an array of scale values for different zoom levels.
`protected void` | `StandardMapTileFactory.getTiles(int uvleft, int uvright, int uvup, int uvbottom, ZoomLevelInfo zoomLevelInfo, Projection proj, OMGraphicList list)`
`OMGraphicList` | `StandardMapTileFactory.getTiles(Projection proj)` Returns projected tiles for the given projection.
`OMGraphicList` | `MapTileFactory.getTiles(Projection proj)` Create an OMGraphicList with a set of tiles on it.
`OMGraphicList` | `StandardMapTileFactory.getTiles(Projection proj, int zoomLevel)` Returns projected tiles for given projection at specified zoom level.
`OMGraphicList` | `MapTileFactory.getTiles(Projection proj, int zoomLevel)` Create an OMGraphicList that covers the projection with tiles that suit the specified zoom level.
`OMGraphicList` | `StandardMapTileFactory.getTiles(Projection proj, int zoomLevel, OMGraphicList list)` Returns projected tiles for given projection at specified zoom level.
`OMGraphicList` | `MapTileFactory.getTiles(Projection proj, int zoomLevel, OMGraphicList list)` Add tiles to OMGraphicList provided that suit the given projection.
`int` | `MapTileCoordinateTransform.getZoomLevelForProj(Projection proj)` Given a projection, figure out the appropriate zoom level for it.
`int` | `AbstractMapTileCoordinateTransform.getZoomLevelForProj(Projection proj)` Given a projection, figure out the appropriate zoom level for it.
`int` | `MapTileCoordinateTransform.getZoomLevelForProj(Projection proj, int zoomLevelTileSize)` Given a projection, figure out the appropriate zoom level for it.
`int` | `AbstractMapTileCoordinateTransform.getZoomLevelForProj(Projection proj, int zoomLevelTileSize)` Given a projection, figure out the appropriate zoom level for it.
`CacheObject` | `TileMillMapTileFactory.load(java.lang.Object key, int x, int y, int zoomLevel, Projection proj)` Fetches a new tile from the database.
`CacheObject` | `StandardMapTileFactory.load(java.lang.Object key, int x, int y, int zoomLevel, Projection proj)` Called to load cache object from data source, when not found in cache.
`CacheObject` | `ServerMapTileFactory.load(java.lang.Object key, int x, int y, int zoomLevel, Projection proj)` Checks the local directory first for a locally cached version of the tile before going off to the server.
`CacheObject` | `DebugMapTileFactory.load(java.lang.Object key, int x, int y, int zoomLevel, Projection proj)`

Uses of Projection in com.bbn.openmap.dataAccess.shape

Fields in com.bbn.openmap.dataAccess.shape declared as Projection
`protected Projection` | `EsriShapeExport.projection` The projection needed to convert other OMGraphicTypes to polygons.

Methods in com.bbn.openmap.dataAccess.shape that return Projection
`Projection` | `EsriShapeExport.getProjection()`

Methods in com.bbn.openmap.dataAccess.shape with parameters of type Projection
`static OMPoly` | `EsriPolygonList.convert(OMCircle omCircle, Projection proj)`
`static OMGraphicList` | `EsriPolygonList.convert(OMRangeRings omRR, Projection proj)`
`OMGraphicList` | `EsriGraphicFactory.getEsriGraphics(BinaryFile shp, DrawingAttributes drawingAttributes, java.lang.Object pointRepresentation, Projection mapProj, OMGraphicList list)` Create an OMGraphicList containing OMGraphics representing shape file contents.
`OMGraphicList` | `EsriGraphicFactory.getEsriGraphics(LittleEndianInputStream iStream, DrawingAttributes drawingAttributes, java.lang.Object pointRepresentation, Projection mapProj, OMGraphicList list)` Create OMGraphics from input stream from shp file.
`protected void` | `EsriGraphicFactory.projGraphicAndAdd(OMGraphic eg, OMGraphicList list, Projection mapProj)`
`void` | `EsriShapeExport.setProjection(Projection proj)`

Constructors in com.bbn.openmap.dataAccess.shape with parameters of type Projection
`EsriShapeExport(OMGraphicList list, Projection proj, java.lang.String pathToFile)` Create an EsriShapeExport object.

Uses of Projection in com.bbn.openmap.event

Fields in com.bbn.openmap.event declared as Projection
`protected Projection` | `ProjectionEvent.projection`

Methods in com.bbn.openmap.event that return Projection
`Projection` | `ProjectionEvent.getProjection()` Get the Projection.

Methods in com.bbn.openmap.event with parameters of type Projection
`void` | `ProjectionSupport.fireProjectionChanged(Projection proj)` Send a center event to all registered listeners.
`void` | `OverviewMapStatusListener.setSourceMapProjection(Projection proj)`

Constructors in com.bbn.openmap.event with parameters of type Projection
`ProjectionEvent(java.lang.Object source, Projection aProj)` Construct a ProjectionEvent.

Uses of Projection in com.bbn.openmap.geo

Methods in com.bbn.openmap.geo with parameters of type Projection
`boolean` | `OMGeo.Pt.generate(Projection proj)`
`boolean` | `OMGeo.Line.generate(Projection proj)`
`boolean` | `OMGeo.Polyline.generate(Projection proj)`

Uses of Projection in com.bbn.openmap.graphicLoader

Fields in com.bbn.openmap.graphicLoader declared as Projection
`protected Projection` | `AbstractGraphicLoader.proj`

Methods in com.bbn.openmap.graphicLoader that return Projection
`Projection` | `AbstractGraphicLoader.getProjection()`

Methods in com.bbn.openmap.graphicLoader with parameters of type Projection
`boolean` | `PathGLPoint.generate(Projection p)`
`void` | `GraphicLoader.setProjection(Projection p)` Let the GraphicLoader know what the projection is.
`void` | `AbstractGraphicLoader.setProjection(Projection p)` Calls manageGraphics() if projection is different().

Uses of Projection in com.bbn.openmap.gui

Fields in com.bbn.openmap.gui declared as Projection
`protected Projection` | `ScaleTextPanel.projection` The last projection received from the MapBean, so it can be used to compare it to any more that come in.

Methods in com.bbn.openmap.gui that return Projection
`Projection` | `MapWindow.getProjection()`

Methods in com.bbn.openmap.gui with parameters of type Projection
`protected void` | `EmbeddedNavPanel.changeSliderValue(Projection projection)`
`static MapBean` | `BasicMapPanel.createMapBean(Projection proj, javax.swing.border.Border border)` A static method that creates a MapBean and sets its projection and border to the values given.
`protected int` | `EmbeddedScaleDisplayPanel.getPtAtDistanceFromLatLon(LatLonPoint loc2, double unitDist, Projection projection, Length uom)`
`void` | `ScaleTextPanel.setProjection(Projection aProjection)` Called to set the scale setting on the scale text object.
`void` | `MapWindow.setProjection(Projection proj)`

Uses of Projection in com.bbn.openmap.gui.menu

Fields in com.bbn.openmap.gui.menu declared as Projection
`protected Projection` | `ProjectionMenu.projection`

Methods in com.bbn.openmap.gui.menu with parameters of type Projection
`void` | `ProjectionMenu.fireProjectionChanged(Projection p)` Fire the changed projection from the support.
`protected void` | `ProjectionMenu.setProjection(Projection aProjection)` Set the projection.

Uses of Projection in com.bbn.openmap.gui.time

Methods in com.bbn.openmap.gui.time with parameters of type Projection
`protected OMGraphicList` | `TimelineLayer.constructTimeLines(Projection projection)`
`boolean` | `TimeSliderLayer.TimeDrape.generate(Projection proj)`
`boolean` | `TimelineLayer.EventMarkerLine.generate(Projection proj)`
`boolean` | `TimelineLayer.SelectionArea.generate(Projection proj)`
`boolean` | `TimelineLayer.SelectionArea.PreTime.generate(Projection proj)`
`boolean` | `TimelineLayer.SelectionArea.PostTime.generate(Projection proj)`
`boolean` | `TimelineLayer.CurrentTimeMarker.generate(Projection proj)`
`boolean` | `TimelineLayer.TimeHashMarks.generate(Projection proj, boolean realTimeMode, double timeSpanMinutes, long gameStartTimeMillis)`
`OMGraphicList` | `TimeSliderLayer.getControlWidgetList(Projection proj)` All we want to do here is reset the current position of all of the widgets, and generate them with the projection for the new position.
`protected OMGraphic` | `TimelineLayer.getCurrentTimeMarker(Projection proj)`
`protected OMGraphicList` | `TimelineLayer.getEventList(java.util.Iterator<OMEvent> it, Projection projection)`
`protected OMGraphicList` | `TimelineLayer.getEventList(Projection projection)`
`OMGraphicList` | `TimelineLayer.TimeHashFactory.getHashMarks(Projection proj, boolean realTimeMode, long gameStartTimeMillis)`
`TimelineLayer.SelectionArea` | `TimelineLayer.getSelectionRectangle(Projection proj)`
`protected void` | `TimelineLayer.SelectionArea.updateY(Projection proj)`
`protected void` | `TimelineLayer.SelectionArea.PlayFilterSection.updateY(Projection proj)`

Uses of Projection in com.bbn.openmap.image

Fields in com.bbn.openmap.image declared as Projection
`protected Projection` | `MapRequestHandler.defaultProjection` The default projection that provides projection parameters that are missing from the request.
`protected Projection` | `MagicPlanetImageComponent.proj`

Methods in com.bbn.openmap.image that return Projection
`Projection` | `MapRequestHandler.getDefaultProjection()` Get the Projection being used for parameters in case some parameters are missing from request strings.
`Projection` | `MagicPlanetImageComponent.getProj()` Get the image projection.
`protected Projection` | `MapRequestHandler.initProjection(java.util.Properties props)` Set up the default projection, which parts are used if any parts of a projection are missing on an image request.

Methods in com.bbn.openmap.image with parameters of type Projection
`byte[]` | `ImageServer.createImage(Projection proj)` Use the ProjectionPainter interface of the layers to create an image.
`byte[]` | `ImageServer.createImage(Projection proj, int scaledWidth, int scaledHeight)` Use the ProjectionPainter interface of the layers to create an image.
`byte[]` | `ImageServer.createImage(Projection proj, int scaledWidth, int scaledHeight, int includedLayerMask)` Use the ProjectionPainter interface of the layers to create an image.
`byte[]` | `ImageServer.createImage(Projection proj, int scaledWidth, int scaledHeight, int includedLayerMask, java.awt.Paint background)` Use the ProjectionPainter interface of the layers to create an image.
`byte[]` | `ImageServer.createImage(Projection proj, int scaledWidth, int scaledHeight, java.util.List<java.lang.String> showLayers)` Use the ProjectionPainter interface of the layers to create an image.
`byte[]` | `ImageServer.createImage(Projection proj, int scaledWidth, int scaledHeight, java.util.List<java.lang.String> showLayers, java.awt.Paint background)` Use the ProjectionPainter interface of the layers to create an image.
`static java.lang.String` | `ImageServer.createImageFile(java.lang.String prefix, java.util.Properties props, Projection proj, java.lang.String outputPath)` For convenience, to create an image file based on the contents of a properties file (like an openmap.properties file).
`byte[]` | `ImageServer.createImageFromLayers(Projection proj, int scaledWidth, int scaledHeight, java.util.List<Layer> showLayers)` Use the ProjectionPainter interface of the layers to create an image.
`byte[]` | `ImageServer.createImageFromLayers(Projection proj, int scaledWidth, int scaledHeight, java.util.List<Layer> layers, java.awt.Paint background)` Create an image from a set of layers.
`static Proj` | `ImageServerUtils.createOMProjection(java.util.Properties props, Projection defaultProj)` Create an OpenMap projection from the values stored in a Properties object.
`void` | `MapRequestHandler.setDefaultProjection(Projection proj)` Set the default projection to grab parameters from in case some projection terms are missing from the request string.
`void` | `MagicPlanetImageComponent.setProj(Projection proj)` Set the image projection.

Uses of Projection in com.bbn.openmap.layer

Fields in com.bbn.openmap.layer declared as Projection
`protected Projection` | `OverviewMapAreaLayer.sourceMapProjection`

Methods in com.bbn.openmap.layer that return Projection
`Projection` | `BufferedLayer.BLMapBean.getRotatedProjection()`

Methods in com.bbn.openmap.layer with parameters of type Projection
`void` | `ScaleFilterLayer.renderDataForProjection(Projection proj, java.awt.Graphics g)` Implementing the ProjectionPainter interface.
`void` | `OMGraphicHandlerLayer.renderDataForProjection(Projection proj, java.awt.Graphics g)` This method is here to provide a default action for Layers as they act as a ProjectionPainter.
`void` | `GraticuleLayer.renderDataForProjection(Projection proj, java.awt.Graphics g)` Implementing the ProjectionPainter interface.
`void` | `BufferedLayer.renderDataForProjection(Projection proj, java.awt.Graphics g)` Part of the ProjectionPainter interface.
`void` | `DrawingToolLayer.saveOMGraphics(Projection proj)` Get the current OMGraphicList and save it out to the file named in this class.
`void` | `OverviewMapAreaLayer.setSourceMapProjection(Projection proj)` Set with the projection of the source MapBean, before changing the projection of the overview MapBean.

Uses of Projection in com.bbn.openmap.layer.beanbox

Fields in com.bbn.openmap.layer.beanbox declared as Projection
`protected Projection` | `SimpleBeanLayer.projection`

Methods in com.bbn.openmap.layer.beanbox that return Projection
`Projection` | `SimpleBeanLayer.getProjection()` Gets the current projection

Uses of Projection in com.bbn.openmap.layer.daynight

Methods in com.bbn.openmap.layer.daynight with parameters of type Projection
`protected OMGraphic` | `DayNightLayer.createImage(Projection projection)` Create the OMGraphic that acts as an overlay showing the day/night terminator.

Uses of Projection in com.bbn.openmap.layer.dted

Methods in com.bbn.openmap.layer.dted with parameters of type Projection
`float[]` | `DTEDCoverageManager.getCoverage(Projection proj)` Get a percentage value of how much of the map is covered for a projection.
`OMGraphicList` | `DTEDCoverageManager.getCoverageRects(int startx, int starty, int endx, int endy, int lineType, Projection proj)` Method looks at the coverage arrays, and returns the applicable rectangles representing the frame coverages.
`OMGraphicList` | `DTEDCoverageManager.getCoverageRects(Projection proj)` Method organizes the query based on the projection, and returns the applicable rectangles representing the frame coverage.
`OMGraphic` | `DTEDSubframedFrame.getImage(DTEDFrameSubframeInfo dfsi, DTEDFrameColorTable colortable, Projection proj)` If you just want to get an image for the DTEDFrame, then call this.
`OMGraphic` | `DTEDSubframedFrame.getImage(Projection proj)` If you just want to get an image for the DTEDFrame, then call this.
`OMGraphic` | `DTEDFrameSubframe.getImage(Projection proj)`
`protected abstract OMGraphic` | `DTEDFrameSubframe.ImageCreator.getImage(Projection proj)` Get the proper OMGraphic given the projection type.
`protected OMGraphic` | `DTEDFrameSubframe.Pixels.getImage(Projection proj)`
`protected OMGraphic` | `DTEDFrameSubframe.BitsAndColors.getImage(Projection proj)`
`OMGraphic` | `DTEDFrameSubframe.getImageIfCurrent(Projection proj, DTEDFrameSubframeInfo dfsi)`
`OMGraphic` | `DTEDCacheHandler.getNextImage(Projection proj)` Returns the next OMRaster image.
`OMGraphicList` | `DTEDCacheManager.getRectangle(Projection proj)` The call to the cache that lets you choose what kind of information is returned.
`OMGraphic` | `DTEDSubframedFrame.getSubframeImage(DTEDFrameSubframeInfo dfsi, DTEDFrameColorTable colortable, Projection proj)` Return the subframe image as described in the DTEDFrameSubframeInfo.
`void` | `DTEDCacheHandler.setProjection(Projection proj, double lat1, double lon1, double lat2, double lon2)` The method to call to let the cache handler know what the projection looks like so it can figure out which frames (and subframes) will be needed.

Uses of Projection in com.bbn.openmap.layer.e00

Methods in com.bbn.openmap.layer.e00 with parameters of type Projection
`boolean` | `TX7.generate(Projection proj)` generate with a new projection

Uses of Projection in com.bbn.openmap.layer.learn

Methods in com.bbn.openmap.layer.learn with parameters of type Projection
`protected void` | `ProjectionResponseLayer.getPoints(DataBounds dataBounds, OMGraphicList retList, Projection proj)` Using this method to look at data source and create OMGraphics based on DataBounds, and render them differently depending on where they are.
`protected void` | `SimpleAnimationLayer.ManageGraphicsTask.moveRandomly(OMPoint point, double factor, Projection proj)` Simple method to move an OMPoint around randomly.
`protected void` | `SimpleAnimationLayer.ManageGraphicsTask.moveRandomly(OMScalingIcon point, double factor, Projection proj)` Simple method to move an OMPoint around randomly.

Uses of Projection in com.bbn.openmap.layer.link

Fields in com.bbn.openmap.layer.link declared as Projection
`protected Projection` | `LinkOMGraphicList.currentProjection`

Methods in com.bbn.openmap.layer.link that return Projection
`Projection` | `LinkOMGraphicList.getProjection()`

Methods in com.bbn.openmap.layer.link with parameters of type Projection
`protected LinkOMGraphicList` | `BufferedLinkLayer.getAllGraphics(ClientLink link, Projection proj)` Creates the LinkMapRequest, and gets the results.
`boolean` | `LinkOMGraphicList.getNeedToRegenerate(Projection proj)` Check whether the list needs to be regenerated, considering the projection that the OMGraphics were projected with when the list was read.
`void` | `Link.readAndParse(Projection proj, OMGridGenerator generator)` Called to begin reading the information coming off the link.
`void` | `Link.readAndParse(Projection proj, OMGridGenerator generator, Layer layer)` Called to begin reading the information coming off the link.
`protected java.lang.String` | `LinkActionList.readGestureResponses(Layer layer, Projection proj, OMGridGenerator generator)` If a ACTIONS_HEADER has been encountered coming off the link, then this method should be called to read the string of gesture that follows.
`protected GraphicUpdate` | `LinkActionList.readGraphic(int graphicAction, LinkProperties graphicProperties, Projection proj, OMGridGenerator generator)` Read a graphic's particulars, for upates and additions.
`protected java.lang.String` | `LinkGraphicList.readGraphics(LinkOMGraphicList graphics, Projection proj, OMGridGenerator generator)` If a GRAPHICS_RESPONSE_HEADER has been encountered coming off the link, then this method should be called to read the string of graphics that follows.
`protected void` | `LinkLayer.sendMapRequest(ClientLink link, Projection proj)` Creates the LinkMapRequest.
`void` | `LinkOMGraphicList.setProjection(Projection proj)`

Constructors in com.bbn.openmap.layer.link with parameters of type Projection
`LinkActionList(Link link, Layer layer, Projection proj, OMGridGenerator generator)` Read the gesture section off the link, from the client.
`LinkGraphicList(Link link, LinkOMGraphicList graphicList, Projection proj, OMGridGenerator generator)` Read the graphics section off the link, if you want the graphics to be projected as they come off the link.

Uses of Projection in com.bbn.openmap.layer.location

Methods in com.bbn.openmap.layer.location with parameters of type Projection
`protected void` | `Location.declutterLabel(DeclutterMatrix declutter, Projection proj)` Given the label is this location has a height and width, find a clean place on the map for it.
`protected void` | `ByteRasterLocation.declutterLabel(DeclutterMatrix declutter, Projection proj)` Given the label is this location has a height and width, find a clean place on the map for it.
`boolean` | `Location.generate(Projection proj)` Prepare the graphic for rendering.
`boolean` | `Location.generate(Projection proj, DeclutterMatrix declutterMatrix)` Generate the location, and use the declutter matrix to place the label is a spot so that it doesn't interset with other labels.
`void` | `Location.setLocation(int x, int y, Projection proj)` Convenience method that lets you provide a screen x, y and a projection to the location, and let the location hash out how to place itself based on it's rendertype.

Uses of Projection in com.bbn.openmap.layer.mif

Methods in com.bbn.openmap.layer.mif with parameters of type Projection
`boolean` | `OMSubtraction.generate(Projection proj)`
`boolean` | `MIFText.generate(Projection proj)` Overriden from OMText so that we can handle a flag `renderText` to signal to the render method if the scale is appropriate to render the text or not.
`boolean` | `MIFPoint.generate(Projection proj)` Overriden from OMPoint so that we can handle a flag `renderPoint` to signal to the render method if the scale is appropriate to render the point or not.

Uses of Projection in com.bbn.openmap.layer.policy

Methods in com.bbn.openmap.layer.policy with parameters of type Projection
`protected void` | `BufferedImageRenderPolicy.ImageBuffer.generate(Projection proj)`
`boolean` | `BufferedImageRenderPolicy.ImageBuffer.paint(java.awt.Graphics2D g, Projection proj)` Return true if something was rendered.
`void` | `StandardRenderPolicy.prePrepare(Projection newProj)` The StandardRenderPolicy doesn't need to do anything before prepare() returns.
`void` | `RenderPolicy.prePrepare(Projection newProjection)` Be very careful with doing things in this method.
`void` | `BufferedImageRenderPolicy.prePrepare(Projection newProj)` Called from the OMGraphicHandlerLayer's projectionChanged() method.
`protected void` | `BufferedImageRenderPolicy.ImageBuffer.update(OMGraphicList list, Projection proj)` Get the updated BufferedImage, with current OMGraphics rendered into it.
`protected OMScalingRaster` | `BufferedImageRenderPolicy.ImageBuffer.updateRaster(java.awt.image.BufferedImage imageBuffer, Projection proj)`

Uses of Projection in com.bbn.openmap.layer.rpf

Methods in com.bbn.openmap.layer.rpf with parameters of type Projection
`java.util.List<RpfTocEntry>` | `RpfTocHandler.getBestCoverageEntry(double ullat, double ullon, double lrlat, double lrlon, Projection proj, RpfViewAttributes viewAtts)` Given a coordinate box and a scale, find the entry in the table of contents file with the right data.
`float` | `RpfFrameProvider.getCalculatedCoverage(double ullat, double ullon, double lrlat, double lrlon, Projection p, java.lang.String chartSeries)` Given an area and a two-letter chart series code, find the percentage of coverage on the map that that chart series can offer.
`float` | `RpfFrameCacheHandler.getCalculatedCoverage(double ullat, double ullon, double lrlat, double lrlon, Projection p, java.lang.String chartSeries)` Given an area and a two-letter chart series code, find the percentage of coverage on the map that that chart series can offer.
`java.util.List<RpfCoverageBox>` | `RpfFrameProvider.getCatalogCoverage(double ullat, double ullon, double lrlat, double lrlon, Projection p, java.lang.String chartSeries)` Given a projection that describes a map or geographical area, return RpfCoverageBoxes that let you know what bounding boxes of data are available.
`java.util.Vector<RpfCoverageBox>` | `RpfFrameCacheHandler.getCatalogCoverage(double ullat, double ullon, double lrlat, double lrlon, Projection proj, java.lang.String chartSeries)` RpfFrameProvider interface method.
`protected void` | `RpfCoverageManager.getCatalogCoverage(double ullat, double ullon, double lrlat, double lrlon, Projection proj, java.lang.String chartSeries, java.util.Map<RpfProductInfo,RpfCoverage.RpfCoverageControl> coverages)` Get the map coverage
`void` | `RpfTocHandler.getCatalogCoverage(double ullat, double ullon, double lrlat, double lrlon, Projection proj, java.lang.String chartSeriesCode, java.util.Vector<RpfCoverageBox> coverages)` Given a coordinate box and a scale, return the entries that have coverage over the given area.
`java.util.List<RpfCoverageBox>` | `RpfFrameProvider.getCoverage(double ullat, double ullon, double lrlat, double lrlon, Projection p)` Given a projection that describes a map or geographical area, return RpfCoverageBoxes that let you know how to locate and ask for RpfSubframes.
`java.util.Vector<RpfCoverageBox>` | `RpfFrameCacheHandler.getCoverage(double ullat, double ullon, double lrlat, double lrlon, Projection proj)` Given a projection which describes the map (or area of interest), return the best RpfTocEntry, from all the A.TOC, that covers the area.
`OMGraphic` | `RpfSubframe.getImage(Projection proj)`
`protected abstract OMGraphic` | `RpfSubframe.ImageCreator.getImage(Projection proj)` Get the proper OMGraphic given the projection type.
`protected OMGraphic` | `RpfSubframe.Pixels.getImage(Projection proj)`
`protected OMGraphic` | `RpfSubframe.BitsAndColors.getImage(Projection proj)`
`OMGraphicList` | `RpfCacheManager.getRectangle(Projection proj)` The call to the cache that lets you choose what kind of information is returned.
`protected OMGraphicList` | `RpfCacheHandler.getSubframes(float ullat, float ullon, float lrlat, float lrlon, Projection proj, OMGraphicList omGraphics)`
`void` | `RpfCoverage.prepare(Projection projection, java.lang.String chartSeries)` Prepares the graphics for the layer.
`static float` | `RpfFrameCacheHandler.scaleDifference(Projection proj, RpfCoverageBox box)`
`void` | `RpfCacheHandler.setCache(float ullat, float ullon, float lrlat, float lrlon, Projection proj)` Called to prepare the cache for subframes that will fit into the next request.

Uses of Projection in com.bbn.openmap.layer.shape

Methods in com.bbn.openmap.layer.shape with parameters of type Projection
`protected void` | `SpatialIndexHandler.checkSpatialIndexEntries(double xmin, double ymin, double xmax, double ymax, OMGraphicList retList, Projection proj)` Checks the buffered list of OMGraphics from the shp file and figures out of they intersect the provided bounds.
`protected void` | `BufferedShapeLayer.checkSpatialIndexEntries(double xmin, double ymin, double xmax, double ymax, OMGraphicList retList, Projection proj)`
`OMGraphic` | `SpatialIndex.evaluate(OMGraphic omg, OMGraphicList labels, Projection mapProj)` Evaluates the OMGraphic against the DbfHandler rules.
`OMGraphicList` | `SpatialIndex.evaluateDbf(OMGraphicList retList, Projection mapProj)` Takes the contents of the list and evaluates them against the information contained in the DbfHandler set in this SpatialIndex class.
`OMGraphicList` | `SpatialIndex.getAllOMGraphics(OMGraphicList retList, DrawingAttributes drawingAttributes, Projection mapProj, GeoCoordTransformation dataProj)` Retrieves all OMGraphics in the shape file.
`OMGraphicList` | `SpatialIndexHandler.getGraphics(double xmin, double ymin, double xmax, double ymax, OMGraphicList list, Projection proj)` Given a bounding box, create OMGraphics from the ESRI records in the shape file.
`OMGraphicList` | `SpatialIndex.getOMGraphics(double xmin, double ymin, double xmax, double ymax, OMGraphicList list, DrawingAttributes drawingAttributes, Projection mapProj, GeoCoordTransformation dataProj)` Locates OMGraphics in the shape file that intersect with the given rectangle.

Uses of Projection in com.bbn.openmap.layer.shape.areas

Methods in com.bbn.openmap.layer.shape.areas with parameters of type Projection
`OMGraphicList` | `AreaHandler.getGraphics(double ulLat, double ulLon, double lrLat, double lrLon, Projection proj)` Get the graphics for a particular lat/lon area.

Uses of Projection in com.bbn.openmap.layer.terrain

Methods in com.bbn.openmap.layer.terrain with parameters of type Projection
`void` | `TerrainTool.setScreenParameters(Projection p)` Let the tool know what the screen looks like.
`void` | `ProfileGenerator.setScreenParameters(Projection p)`
`void` | `LOSGenerator.setScreenParameters(Projection p)` Called on every getRectangle, in order to let the cache get sized right, and to reset the graphics if the scale changed (since they won't make sense.

Uses of Projection in com.bbn.openmap.layer.vpf

Methods in com.bbn.openmap.layer.vpf with parameters of type Projection
`OMGraphicList` | `VPFAutoFeatureGraphicWarehouse.getFeatures(LibrarySelectionTable lst, LatLonPoint ll1, LatLonPoint ll2, Projection proj, OMGraphicList omgList)` This is where the magic happens.

Uses of Projection in com.bbn.openmap.omGraphics

Fields in com.bbn.openmap.omGraphics declared as Projection
`protected Projection` | `OMWarpingImage.lastProjection`
`protected Projection` | `OMScalingRaster.lastProjection` This lastProjection is used to keep track of the last projection used to warp or scale the image, an used during the rendering process to check if we should rework the image to be displayed.
`protected Projection` | `EditableOMGraphic.projection` The projection of the map.

Methods in com.bbn.openmap.omGraphics that return Projection
`Projection` | `EditableOMGraphic.getProjection()` Get the current projection.

Methods in com.bbn.openmap.omGraphics with parameters of type Projection
`void` | `OMText.evaluateRotationAngle(Projection proj)` Set the renderRotationAngle based on the projection angle and OMText settings.
`protected void` | `OMRaster.evaluateRotationAngle(Projection proj)` Set the renderRotationAngle based on the projection angle and OMRaster settings.
`void` | `OMLabeler.evaluateRotationAngle(Projection proj)` Evaluate the current projection in case it has information that affects placement, like rotation.
`boolean` | `SinkGraphic.generate(Projection proj)` This graphic generates nothing, successfully.
`boolean` | `OMWarpingImage.generate(Projection proj)`
`boolean` | `OMText.generate(Projection proj)` Prepares the text for rendering.
`boolean` | `OMSpline.generate(Projection proj)` Prepare the spline for rendering.
`boolean` | `OMShape.generate(Projection proj)`
`boolean` | `OMShape.PROJECTED.generate(Projection proj)`
`boolean` | `OMScalingRaster.generate(Projection proj)` Prepare the graphics for rendering.
`boolean` | `OMRect.generate(Projection proj)` Prepare the rectangle for rendering.
`boolean` | `OMRaster.generate(Projection proj)` Prepare the graphics for rendering.
`boolean` | `OMRangeRings.generate(Projection proj)` Prepare the circles for rendering.
`boolean` | `OMPoly.generate(Projection proj)` Prepare the poly for rendering.
`boolean` | `OMPoint.generate(Projection proj)` Prepare the point for rendering.
`boolean` | `OMPoint.Image.generate(Projection proj)` Prepare the point image for rendering.
`boolean` | `OMList.generate(Projection p)` Prepare the graphics for rendering.
`boolean` | `OMLine.generate(Projection proj)` Prepare the line for rendering.
`boolean` | `OMGrid.generate(Projection proj)` Generate OMGraphics based on the data array.
`abstract boolean` | `OMGraphicAdapter.generate(Projection proj)` Prepare the graphic for rendering.
`boolean` | `OMGeometry.generate(Projection proj)` Prepare the geometry for rendering.
`boolean` | `OMEllipse.generate(Projection proj)`
`boolean` | `OMDistance.generate(Projection proj)` Prepare the poly for rendering.
`boolean` | `OMBitmap.generate(Projection proj)` Create the rendered image from the pixel values.
`boolean` | `OMArc.generate(Projection proj)` Prepare the arc for rendering.
`boolean` | `EditableOMText.generate(Projection proj)` Use the current projection to place the graphics on the screen.
`boolean` | `EditableOMScalingRaster.generate(Projection proj)` Use the current projection to place the graphics on the screen.
`boolean` | `EditableOMRect.generate(Projection proj)` Use the current projection to place the graphics on the screen.
`boolean` | `EditableOMPoly.generate(Projection proj)` Use the current projection to place the graphics on the screen.
`boolean` | `EditableOMPoint.generate(Projection proj)` Use the current projection to place the graphics on the screen.
`boolean` | `EditableOMLine.generate(Projection proj)` Use the current projection to place the graphics on the screen.
`boolean` | `EditableOMGraphicList.generate(Projection proj)` Use the current projection to place the graphics on the screen.
`abstract boolean` | `EditableOMGraphic.generate(Projection proj)` Use the current projection to place the graphics on the screen.
`boolean` | `EditableOMCircle.generate(Projection proj)` Use the current projection to place the graphics on the screen.
`boolean` | `OMList.generate(Projection p, boolean forceProjectAll)` Prepare the graphics for rendering.
`boolean` | `OMGeometryList.generate(Projection p, boolean forceProjectAll)` Prepare the geometries for rendering.
`boolean` | `OMAreaList.generate(Projection p, boolean forceProjectAll)` Create the GeneralPath used for the internal Shape objects held by the OMGeometries added.
`protected void` | `EditableOMPoly.generateGrabPoints(Projection proj)` Generate the grab points, checking the OMGraphic to see if it contains information about what the grab points should look like.
`OMGraphic` | `OMGrid.generateGridObjects(Projection proj)` Called from generate() if there isn't a OMGridGenerator.
`int` | `OMGrid.interpValueAt(double lat, double lon, Projection proj)` Interpolated value at a given lat/lon - should be more precise than valueAt(), but that depends on the resolution of the data.
`boolean` | `OMScalingRaster.isOnMap(Projection proj)` Test to see if projected image is on map.
`boolean` | `OMScalingIcon.isOnMap(Projection proj)`
`protected boolean` | `OMScalingRaster.position(Projection proj)` Since the image doesn't necessarily need to be regenerated when it is merely moved, raster objects have this function, called from generate() and when a placement attribute is changed.
`protected boolean` | `OMScalingIcon.position(Projection proj)` Since the image doesn't necessarily need to be regenerated when it is merely moved, raster objects have this function, called from generate() and when a placement attribute is changed.
`protected boolean` | `OMRasterObject.position(Projection proj)` Since the image doesn't necessarily need to be regenerated when it is merely moved, raster objects have this function, called from generate() and when a placement attribute is changed.
`void` | `OMList.project(Projection p)` Projects any graphics needing projection.
`void` | `OMList.project(Projection p, boolean forceProjectAll)` Projects the OMGraphics on the list.
`boolean` | `OMRasterObject.regenerate(Projection proj)` Overrides OMGraphicAdapter version to handle OMRasterObject getNeedToReposition.
`boolean` | `OMGraphicAdapter.regenerate(Projection proj)` Invoke this to regenerate a "dirty" graphic.
`boolean` | `OMGraphic.regenerate(Projection proj)` Invoke this to regenerate a "dirty" graphic.
`boolean` | `OMGeometry.regenerate(Projection proj)` Invoke this to regenerate a "dirty" graphic.
`void` | `EditableOMText.regenerate(Projection proj)` Given a new projection, the grab points may need to be repositioned off the current position of the graphic.
`void` | `EditableOMScalingRaster.regenerate(Projection proj)` Given a new projection, the grab points may need to be repositioned off the current position of the graphic.
`void` | `EditableOMRect.regenerate(Projection proj)` Given a new projection, the grab points may need to be repositioned off the current position of the graphic.
`void` | `EditableOMPoly.regenerate(Projection proj)` Given a new projection, the grab points may need to be repositioned off the current position of the graphic.
`void` | `EditableOMPoint.regenerate(Projection proj)` Given a new projection, the grab points may need to be repositioned off the current position of the graphic.
`void` | `EditableOMLine.regenerate(Projection proj)` Given a new projection, the grab points may need to be repositioned off the current position of the graphic.
`void` | `EditableOMGraphicList.regenerate(Projection proj)` Given a new projection, the grab points may need to be repositioned off the current position of the graphic.
`abstract void` | `EditableOMGraphic.regenerate(Projection proj)` Given a new projection, the grab points may need to be repositioned off the current position of the graphic.
`void` | `EditableOMCircle.regenerate(Projection proj)` Given a new projection, the grab points may need to be repositioned off the current position of the graphic.
`protected void` | `OMScalingRaster.scaleTo(Projection thisProj)` Take the current projection and the sourceImage, and make the image that gets displayed fit the projection.
`protected void` | `OMScalingIcon.scaleTo(Projection thisProj)` Over-riding this so we don't clip rotated icons near the edge of the map.
`void` | `OMGraphicList.setGridGenerator(OMGridGenerator generator, Projection proj)` Goes through the list, finds the OMGrid objects, and sets the generator for all of them.
`void` | `OMGraphicAdapter.setLabelLocation(float[] xpoints, float[] ypoints, Projection proj)`
`protected void` | `OMGraphicAdapter.setLabelLocation(java.awt.geom.GeneralPath gp, Projection proj)` Checks the attributes for a label and moves the label accordingly.
`protected void` | `OMGraphicAdapter.setLabelLocation(int[] xpoints, int[] ypoints, Projection proj)` Checks the attributes for a label and moves the label accordingly.
`protected void` | `OMGraphicAdapter.setLabelLocation(java.awt.geom.Point2D p, Projection proj)` Checks the attributes for a label and moves the label accordingly.
`void` | `EditableOMGraphicList.setProjection(Projection proj)` Set the current projection.
`void` | `EditableOMGraphic.setProjection(Projection proj)` Set the current projection.
`protected boolean` | `OMWarpingImage.updateImageForProjection(Projection proj)` Called from within generate.
`protected boolean` | `OMScalingRaster.updateImageForProjection(Projection proj)` Called from within generate.
`protected java.awt.geom.GeneralPath` | `OMGeometryList.updateShape(java.awt.geom.GeneralPath currentShape, OMGeometry geometry, Projection p, boolean forceProject)` Given an OMGeometry, check its visibility and if visible, generate it if required and add the result to the provided current shape.
`protected void` | `OMGeometryList.updateShape(OMGeometry geometry, Projection p, boolean forceProject)` Deprecated. use the new paradigm from the other updateShape
`protected void` | `OMAreaList.updateShape(OMGeometry geometry, Projection p, boolean forceProject)` Given a OMGeometry, it calls generate/regenerate on it, and then adds the GeneralPath shape within it to the OMGeometryList shape object.
`java.lang.Object` | `OMGrid.valueAt(double lat, double lon, Projection proj)` The value at the closest SW post to the given lat/lon.

Uses of Projection in com.bbn.openmap.omGraphics.geom

Methods in com.bbn.openmap.omGraphics.geom with parameters of type Projection
`boolean` | `PolygonGeometry.LL.generate(Projection proj)`
`boolean` | `PolygonGeometry.XY.generate(Projection proj)`
`boolean` | `PolygonGeometry.Offset.generate(Projection proj)`
`abstract boolean` | `BasicGeometry.generate(Projection proj)` Prepare the geometry for rendering.
`boolean` | `BasicGeometry.regenerate(Projection proj)` Invoke this to regenerate a "dirty" graphic.

Uses of Projection in com.bbn.openmap.omGraphics.grid

Methods in com.bbn.openmap.omGraphics.grid with parameters of type Projection
`OMGraphic` | `OMGridObjects.generate(int id, Projection proj)`
`OMGraphic` | `SlopeGenerator.generate(OMGrid grid, Projection proj)` Called from the OMGrid.generate() method to tell the generator to create something to represent the grid contents.
`OMGraphic` | `SinkGenerator.generate(OMGrid grid, Projection proj)`
`OMGraphic` | `SimpleColorGenerator.generate(OMGrid grid, Projection proj)` Going to return an OMRaster, sized to the current projection, and colored according to the colortable.
`OMGraphic` | `OMGridGenerator.generate(OMGrid grid, Projection proj)`
`OMRaster` | `SlopeGenerator.generateRasterForProjection(OMGrid grid, Projection proj)` A more defining API method to get what this SlopeGenerator can create.

Uses of Projection in com.bbn.openmap.omGraphics.labeled

Methods in com.bbn.openmap.omGraphics.labeled with parameters of type Projection
`boolean` | `LabeledOMSpline.generate(Projection proj)`
`boolean` | `LabeledOMPoly.generate(Projection proj)`
`protected java.awt.Point` | `LabeledOMSpline.getTextPoint(Projection proj)`
`protected java.awt.Point` | `LabeledOMPoly.getTextPoint(Projection proj)` Calculate where the text point ought to go.

Uses of Projection in com.bbn.openmap.omGraphics.rule

Methods in com.bbn.openmap.omGraphics.rule with parameters of type Projection
`OMGraphic` | `IndexRule.evaluate(java.util.List<?> record, OMGraphic omg, Projection proj)` Evaluate the record against this rule.
`OMGraphic` | `RuleHandler.evaluate(OMGraphic omg, OMGraphicList labelList, Projection proj)` This is the main call that a layer would use to modify/update an OMGraphic based on dbf file contents.
`OMGraphic` | `Rule.evaluate(T record, OMGraphic omg, Projection proj)` Evaluate the record against this rule.

Uses of Projection in com.bbn.openmap.omGraphics.time

Methods in com.bbn.openmap.omGraphics.time with parameters of type Projection
`void` | `TemporalOMScalingIcon.generate(Projection p, long time)` Prepare the ScenarioPoint to be rendered in its position at a certain time.
`void` | `TemporalOMPoint.generate(Projection p, long time)` Prepare the ScenarioPoint to be rendered in its position at a certain time.
`void` | `TemporalOMGraphicList.generate(Projection proj, long time)` Calls generate(proj, time) on temporal geometries, regular generate(proj) on non-temporal OMGeometries.
`void` | `TemporalOMGraphic.generate(Projection proj, long time)`

Uses of Projection in com.bbn.openmap.omGraphics.util

Methods in com.bbn.openmap.omGraphics.util with parameters of type Projection
`DataBounds` | `ImageWarp.calculateProjectedImageBounds(Projection p)` Returns the image bounds of the image as it would be warped to the provided projection.
`void` | `ArcCalc.generate(Projection proj)`
`int[]` | `ImageWarp.getImagePixels(Projection p)` Given a projection, return the pixels for an image that will cover the projection area.
`OMRaster` | `ImageWarp.getOMRaster(Projection p)` Return an OMRaster that covers the given projection, with the image warped for the projection.

Uses of Projection in com.bbn.openmap.plugin

Fields in com.bbn.openmap.plugin declared as Projection
`protected Projection` | `WebImagePlugIn.currentProjection` The last projection object received.

Methods in com.bbn.openmap.plugin with parameters of type Projection
`abstract java.lang.String` | `WebImagePlugIn.createQueryString(Projection p)` Create the query to be sent to the server, based on current settings.
`protected void` | `WebImagePlugIn.fetchImageAndAddToList(Projection p, OMGraphicList list)` Image fetching code, where the query is created based on the provided projection.
`OMGraphicList` | `WebImagePlugIn.getRectangle(Projection p)` The getRectangle call is the main call into the PlugIn module.
`OMGraphicList` | `UTMGridPlugIn.getRectangle(Projection p)` The getRectangle call is the main call into the PlugIn module.
`OMGraphicList` | `PlugIn.getRectangle(Projection p)` The getRectangle call is the main call into the PlugIn module.
`OMGraphicList` | `OMGraphicHandlerPlugIn.getRectangle(Projection p)` The getRectangle call is the main call into the PlugIn module.
`OMGraphicList` | `CSVTiledImagePlugIn.getRectangle(Projection p)` The getRectangle call is the main call into the PlugIn module.
`abstract OMGraphicList` | `AbstractPlugIn.getRectangle(Projection p)` The getRectangle call is the main call into the PlugIn module.

Uses of Projection in com.bbn.openmap.plugin.earthImage

Methods in com.bbn.openmap.plugin.earthImage with parameters of type Projection
`OMRaster` | `EarthImagePlugIn.ImageTranslator.getImage(Projection p)` Given a projection, create an OMRaster that reflects the image warped to that projection.
`OMGraphicList` | `EarthImagePlugIn.getRectangle(Projection p)`

Uses of Projection in com.bbn.openmap.plugin.esri

Fields in com.bbn.openmap.plugin.esri declared as Projection
`protected Projection` | `EsriPlugIn.proj` The last projection.

Methods in com.bbn.openmap.plugin.esri with parameters of type Projection
`OMGraphicList` | `EsriPlugIn.getRectangle(Projection p)` The getRectangle call is the main call into the PlugIn module.

Uses of Projection in com.bbn.openmap.plugin.graphicLoader

Methods in com.bbn.openmap.plugin.graphicLoader with parameters of type Projection
`OMGraphicList` | `GraphicLoaderPlugIn.getRectangle(Projection p)` The getRectangle call is the main call into the PlugIn module.

Uses of Projection in com.bbn.openmap.plugin.shis

Methods in com.bbn.openmap.plugin.shis with parameters of type Projection
`java.lang.String` | `SHISPlugIn.createQueryString(Projection p)` When a projection is received, translate it into a valid request for a SimpleHttpImageServer, and then return the image received back from it.

Uses of Projection in com.bbn.openmap.plugin.wms

Methods in com.bbn.openmap.plugin.wms with parameters of type Projection
`java.lang.String` | `WMSPlugIn.createQueryString(Projection p)` Create the query to be sent to the server, based on current settings.

Uses of Projection in com.bbn.openmap.proj

Subinterfaces of Projection in com.bbn.openmap.proj
`interface` | `EqualArc` A designator interface to let layers know that a Projection is an Equal Arc projection, meaning that the variations in latitude and longitude are constant.

Classes in com.bbn.openmap.proj that implement Projection
`class` | `AspectRatioProjection` A Projection that wraps another projection, but stretch the image to another aspect ratio.
`class` | `Azimuth` Base of all azimuthal projections.
`class` | `CADRG` Implements the CADRG projection.
`class` | `Cartesian` The Cartesian projection is a non-wrapping, straight-forward scaling projection drawn in 2D.
`class` | `Cylindrical` Base of all cylindrical projections.
`class` | `DatumShiftProjection` This projection wraps another projection and adds datum handling.
`class` | `GeoProj` GeoProj is the base class of all Projections that deal with coordinates on the world sphere.
`class` | `Gnomonic` Implements the Gnomonic projection.
`class` | `LambertConformal` Implements the LambertConformalConic projection.
`class` | `LLXY` Implements the LLXY projection, which is basically something where the lat/lon and pixel ratios are the same.
`class` | `Mercator` Implements the Mercator projection.
`class` | `Orthographic` Implements the Orthographic projection.
`class` | `Proj` Proj is the base class of all Projections.
`class` | `UTMProjection` A OpenMap Projection class that uses the `UTMPoint` to do its calculation.

Fields in com.bbn.openmap.proj with type parameters of type Projection
`java.lang.Class<? extends Projection>` | `ProjectionStack.ProjHolder.projClass`
`protected java.lang.Class<? extends Projection>` | `BasicProjectionLoader.projClass`

Methods in com.bbn.openmap.proj that return Projection
`Projection` | `ProjectionStack.ProjHolder.create(int width, int height)`
`Projection` | `UTMProjectionLoader.create(java.util.Properties props)`
`Projection` | `ProjectionLoader.create(java.util.Properties props)` Create the projection with the given parameters.
`Projection` | `OrthographicLoader.create(java.util.Properties props)` Create the projection with the given parameters.
`Projection` | `MercatorLoader.create(java.util.Properties props)` Create the projection with the given parameters.
`Projection` | `LLXYLoader.create(java.util.Properties props)` Create the projection with the given parameters.
`Projection` | `LambertConformalLoader.create(java.util.Properties props)` Create the projection with the given parameters.
`Projection` | `GnomonicLoader.create(java.util.Properties props)` Create the projection with the given parameters.
`Projection` | `CartesianLoader.create(java.util.Properties props)` Create the projection with the given parameters.
`Projection` | `CADRGLoader.create(java.util.Properties props)` Create the projection with the given parameters.
`abstract Projection` | `BasicProjectionLoader.create(java.util.Properties props)` Create the projection with the given parameters.
`Projection` | `ProjectionFactory.getDefaultProjectionFromEnvironment(Environment e)` Looks at the Environment settings for the default projection and returns a Projection suited for those settings.
`Projection` | `ProjectionFactory.getDefaultProjectionFromEnvironment(Environment environment, int width, int height)` Looks at the Environment settings for the default projection and returns a Projection suited for those settings.
`Projection` | `Projection.makeClone()` Clone the projection.
`Projection` | `Proj.makeClone()` Clone the projection.
`Projection` | `ProjectionFactory.makeProjection(java.lang.Class<? extends Projection> projClass, java.awt.geom.Point2D center, float scale, int width, int height)` Create a projection.
`Projection` | `ProjectionFactory.makeProjection(ProjectionLoader loader, java.awt.geom.Point2D center, float scale, int width, int height)` Call the provided ProjectionLoader to create the projection with the given parameters.
`Projection` | `ProjectionFactory.makeProjection(ProjectionLoader loader, java.awt.geom.Point2D center, float scale, int width, int height, java.util.Properties projProps)` Call the provided ProjectionLoader to create the projection with the given parameters.
`Projection` | `ProjectionFactory.makeProjection(java.lang.String projClassName, java.awt.geom.Point2D center, float scale, int width, int height)` Create a projection.
`Projection` | `ProjectionFactory.makeProjection(java.lang.String projClassName, Projection p)` Makes a new projection based on the given projection class name and parameters from the given projection.

Methods in com.bbn.openmap.proj that return types with arguments of type Projection
`java.lang.Class<? extends Projection>` | `ProjectionFactory.getProjClassForName(java.lang.String name)` Return the Projection Class with the given pretty name.
`java.lang.Class<? extends Projection>` | `ProjectionLoader.getProjectionClass()` Get a class name to use for the projection.
`java.lang.Class<? extends Projection>` | `BasicProjectionLoader.getProjectionClass()` Get a class name to use for the projection.

Methods in com.bbn.openmap.proj with parameters of type Projection
`static LLXY` | `LLXY.convertProjection(Projection proj)`
`static CADRG` | `CADRG.convertProjection(Projection proj)`
`boolean` | `ProjectionStack.ProjHolder.equals(Projection proj)`
`static double[]` | `ProjMath.getProjectionScreenOutlineCoords(Projection sourceMapProjection)` Walks around the perimeter of the sourceMapProjection and returns the lat/lon coords of the outline.
`static java.awt.geom.Rectangle2D` | `ProjMath.getRatioBox(Projection proj, java.awt.geom.Point2D pt1, java.awt.geom.Point2D pt2, boolean zoomOnCenter)` Given a projection to match against and the starting point of a box (pt1), look at pt2 to see if it represents the ratio of the projection map size.
`static java.awt.Point` | `ProjMath.getRatioPoint(Projection proj, java.awt.Point pt1, java.awt.Point pt2)` Given a projection and the starting point of a box (pt1), look at pt2 to see if it represents the ratio of the projection map size.
`protected static float` | `ProjMath.getScale(java.awt.geom.Point2D ll1, java.awt.geom.Point2D ll2, java.awt.geom.Point2D point1, java.awt.geom.Point2D point2, Projection projection)` Given a couple of points representing a bounding box, find out what the scale should be in order to make those points appear at the corners of the projection.
`static float` | `ProjMath.getScale(java.awt.geom.Point2D ll1, java.awt.geom.Point2D ll2, Projection projection)` Given a couple of points representing a bounding box, find out what the scale should be in order to make those points appear at the corners of the projection.
`static float` | `ProjMath.getScale(java.awt.Point point1, java.awt.Point point2, Projection projection)` Given a couple of points representing a bounding box, find out what the scale should be in order to make those points appear at the corners of the projection.
`static float` | `ProjMath.getScaleFromProjected(java.awt.geom.Point2D point1, java.awt.geom.Point2D point2, Projection projection)` Given a couple of points representing a bounding box of projected coordinates, find out what the scale should be in order to make those points appear at the corners of the projection, with the intention that the bounding box will then fill the projected space.
`static boolean` | `ProjMath.isVisible(Projection sourceMapProjection, java.awt.geom.Point2D llp)` Returns true if the Point is visible on the provided projection.
`Projection` | `ProjectionFactory.makeProjection(java.lang.String projClassName, Projection p)` Makes a new projection based on the given projection class name and parameters from the given projection.

Method parameters in com.bbn.openmap.proj with type arguments of type Projection
`Projection` | `ProjectionFactory.makeProjection(java.lang.Class<? extends Projection> projClass, java.awt.geom.Point2D center, float scale, int width, int height)` Create a projection.

Constructors in com.bbn.openmap.proj with parameters of type Projection
`ProjectionStack.ProjHolder(Projection proj, ProjectionFactory projectionFactory)`

Constructor parameters in com.bbn.openmap.proj with type arguments of type Projection
`BasicProjectionLoader(java.lang.Class<? extends Projection> pClass, java.lang.String pName, java.lang.String pDescription)` Set the basic parameters needed for a ProjectionLoader.

Uses of Projection in com.bbn.openmap.tools.dnd

Fields in com.bbn.openmap.tools.dnd declared as Projection
`protected Projection` | `DefaultDnDCatcher.proj`

Methods in com.bbn.openmap.tools.dnd that return Projection
`Projection` | `DefaultDnDCatcher.getProjection()` Gets current projection.
`Projection` | `DefaultDnDCatcher.setProjection(ProjectionEvent projEvent)` This method lets you take the ProjectionEvent received from the MapBean, and lets you know if you should do something with it.

Methods in com.bbn.openmap.tools.dnd with parameters of type Projection
`void` | `DefaultDnDCatcher.setProjection(Projection projection)` Sets the current projection.

Uses of Projection in com.bbn.openmap.tools.drawing

Fields in com.bbn.openmap.tools.drawing declared as Projection
`protected Projection` | `OMDrawingTool.projection` The current projection.

Methods in com.bbn.openmap.tools.drawing that return Projection
`Projection` | `OMDrawingTool.getProjection()` Get the current projection, if one has been provided.

Methods in com.bbn.openmap.tools.drawing with parameters of type Projection
`void` | `OMDrawingTool.setProjection(Projection proj)` Set the current projection.

Uses of Projection in com.bbn.openmap.tools.roads

Methods in com.bbn.openmap.tools.roads that return Projection
`Projection` | `RoadLayer.getProjection()`
`Projection` | `RoadFinder.getProjection()`
`Projection` | `LayerView.getProjection()` Needed to find the height and width of the displayed routes, etc.

Methods in com.bbn.openmap.tools.roads with parameters of type Projection
`protected Segment` | `RoadFinder.getPathSegment(Projection proj, Road road, boolean reverse)` Converts a road into a path segment - reverse parameter guarantees the ordering of the points is consistent across multiple path segments in the whole route.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

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