/*
* (non-Javadoc)
*
* @see es.axios.udig.ui.georeferencing.internal.ui.MarkPresenter#draw()
*/
public void draw() {
assert this.context != null;
if (hide) return;
ViewportGraphics graphics = context.getGraphics();
graphics.setColor(createColor(getMarkModel().hashCode()));
if (point != null) {
final int halfsize = EXTENT_SIZE / 2;
this.extent =
new Rectangle(
(int) (point.getX() - halfsize),
(int) (point.getY() - halfsize),
EXTENT_SIZE,
EXTENT_SIZE);
graphics.fillOval(extent.x, extent.y, extent.width, extent.height);
Rectangle2D stringBounds = graphics.getStringBounds(String.valueOf(getMarkModel().getID()));
graphics.drawString(
String.valueOf(getMarkModel().getID()),
(int) point.getX(),
(int) (point.getY() + stringBounds.getHeight()),
ViewportGraphics.ALIGN_MIDDLE,
ViewportGraphics.ALIGN_BOTTOM);
}
}
public void draw(ViewportGraphics g, GraticuleStyle style) {
Color old = g.getColor();
g.setColor(style.getFontColor());
g.setFont(font);
g.drawString(
text, anchor.x, anchor.y, ViewportGraphics.ALIGN_MIDDLE, ViewportGraphics.ALIGN_MIDDLE);
// Restore old state
g.setColor(old);
}
/**
* Create horizontal line
*
* @param display - active {@link Display}
* @param g - active {@link ViewportGraphics}
* @param sx - Square width
* @param lw - line width
* @param current - Current square coordinate (corner)
* @param next - Next square coordinate (corner)
* @param gap - Gap where label is inserted (pixels)
* @param bold - flag controlling line width
* @param lines - already created square lines
* @return 'next' coordinate
*/
private Point horz(
Display display,
ViewportGraphics g,
int sx,
int lw,
Point current,
Point next,
boolean gap,
boolean bold,
List<Line> lines) {
// Initialize
List<Path> paths = new ArrayList<Path>(2);
// Create first segment
Path path = new Path(display);
// Move to last point
path.moveTo(current.x, current.y);
// Insert gap?
if (gap) {
// Calculate gap/2
int offset = Math.max(1, g.getFontHeight());
// End first segment before mid-point
Point p = offset(current, next, -offset);
path.lineTo(p.x, p.y);
paths.add(path);
// Create second segment
path = new Path(display);
// Move past mid-point
p = offset(current, next, offset);
path.moveTo(p.x, p.y);
}
// Close path
path.lineTo(next.x - (bold ? 2 * lw : lw), next.y);
paths.add(path);
lines.add(new Line(paths, bold ? 2 * lw : lw));
// Finished
return gap ? offset(current, next, 0) : next;
}
@Override
public void draw(MapGraphicContext context) {
// Initialize
ILayer graticule = context.getLayer();
GraticuleStyle style = GraticuleStyle.getStyle(graticule);
// Ensure CRS?
if (graticule instanceof Layer) {
// Initialize CRS?
if (style.isInitCRS()) {
// Only initialize once
style.setInitCRS(false);
// Apply CRS from context
GraticuleCRSConfigurator.apply((Layer) graticule, context.getCRS());
} else if (mismatch(graticule, style)) {
// Apply CRS from
GraticuleCRSConfigurator.apply((Layer) graticule, style.getCRS());
}
}
// Sanity checks
if (MAX_SCALE < context.getMap().getViewportModel().getScaleDenominator()) {
graticule.setStatus(ILayer.ERROR);
graticule.setStatusMessage(Messages.GraticuleGraphic_Maximum_Scale + MAX_SCALE);
return;
}
Unit<?> unit = CRSUtilities.getUnit(graticule.getCRS().getCoordinateSystem());
if (!SI.METER.equals(unit)) {
graticule.setStatus(ILayer.ERROR);
graticule.setStatusMessage(Messages.GraticuleGraphic_Illegal_CRS);
return;
}
final IWorkbench workbench = PlatformUI.getWorkbench();
if (workbench == null) return;
// Start working on layer
graticule.setStatus(ILayer.WORKING);
graticule.setStatusMessage(null);
// Get display to work on
final Display display = workbench.getDisplay();
// Set styles
Font plain = GraticuleStyle.getFontStyle(context).getFont();
Font bold = plain.deriveFont(Font.BOLD);
// Initialize the graphics handle
ViewportGraphics g = context.getGraphics();
// Set font size
g.setFont(bold);
// Get bounds of viewport
ReferencedEnvelope bounds = context.getViewportModel().getBounds();
try {
// Get square size limited to minimum size of 100 pixels
double size = size(context, unit, 100);
// Sanity check
if (size < 100) return;
// Convert square size to pixels
int sx = (int) (size / context.getViewportModel().getPixelSize().x);
int sy = (int) (size / context.getViewportModel().getPixelSize().y);
// Make transform from Graticule to map CRS
MathTransform transform = CRS.findMathTransform(graticule.getCRS(), context.getCRS(), false);
// Transform bounds into Graticule CRS
bounds = bounds.transform(graticule.getCRS(), true);
// Get squares inside bounds
SimpleFeatureIterator it = squares(bounds, size);
// Draw one squares at the time (only top and left lines are drawn)
while (it.hasNext()) {
// Initialize states
int i = 0;
Point current = null;
// Initialize lines
List<Line> lines = new ArrayList<Line>(2);
List<Label> labels = new ArrayList<Label>(2);
// Get next geometry
Geometry geom = (Geometry) it.next().getDefaultGeometry();
// Get coordinates in graticule CRS
Coordinate[] coords = geom.getCoordinates();
// Get x-coordinate label from upper left corner
String tx = getLabel(coords[0].x, size, unit, style);
// Get y-coordinate label from lower left corner
String ty = getLabel(coords[2].y, size, unit, style);
// Insert gap with label?
boolean vgap = isGap(tx, unit, style);
boolean hgap = isGap(ty, unit, style);
// Transform coordinates into Map CRS
coords = JTS.transform(geom, transform).getCoordinates();
// Create lines and labels for this square
for (Coordinate c : coords) {
// Build paths
switch (i) {
case 1:
// -----------------------
// Vertical line
// -----------------------
// Create line path
current =
vert(
display,
g,
sy,
style.getLineWidth(),
current,
context.worldToPixel(c),
hgap,
vgap,
lines);
// Add xx label?
if (hgap) {
labels.add(new Label(current, tx, vgap ? bold : plain));
current = context.worldToPixel(c);
}
break;
case 2:
// -----------------------
// Horizontal line
// -----------------------
// Create line path
current =
horz(
display,
g,
sx,
style.getLineWidth(),
current,
context.worldToPixel(c),
vgap,
hgap,
lines);
// Add yy label?
if (vgap) {
labels.add(new Label(current, ty, hgap ? bold : plain));
current = context.worldToPixel(c);
}
break;
default:
current = context.worldToPixel(c);
break;
}
i++;
}
// Draw lines
for (Line line : lines) line.draw(g, style);
// Draw labels?
if (style.isShowLabels()) for (Label label : labels) label.draw(g, style);
}
// // Get lower left corner coordinates
// int x = llc.x;
// int y = llc.y;
//
// // Print borders
// g.setColor(lc);
// g.setStroke(ViewportGraphics.LINE_SOLID, 5);
//
// // Inner rectangle
// g.drawRect(x + d + l, y + d + l, w - 2 * (d + l), h - 2 * (d + l));
//
// // Make white border
// g.setColor(Color.WHITE);
//
// // Left
// g.drawRect(x, y, d, h);
// g.fillRect(x, y, d, h);
//
// // Bottom
// g.drawRect(x, y, w, d);
// g.fillRect(x, y, w, d);
//
// // Right
// g.drawRect(x + w - d, y, d, h);
// g.fillRect(x + w - d, y, d, h);
//
// // Top
// g.drawRect(x, y + h - d, w, d);
// g.fillRect(x, y + h - d, w, d);
} catch (IOException ex) {
MapGraphicPlugin.log(Messages.GraticuleGraphic_Error, ex);
} catch (FactoryException ex) {
MapGraphicPlugin.log(Messages.GraticuleGraphic_Error, ex);
} catch (MismatchedDimensionException ex) {
MapGraphicPlugin.log(Messages.GraticuleGraphic_Error, ex);
} catch (TransformException ex) {
MapGraphicPlugin.log(Messages.GraticuleGraphic_Error, ex);
}
// Finished working on layer
graticule.setStatus(ILayer.DONE);
}
public void draw(ViewportGraphics g, GraticuleStyle style) {
g.setColor(style.getLineColor());
g.setStroke(style.getLineStyle(), w);
for (Path path : paths) g.drawPath(path);
}
public void draw(MapGraphicContext context) {
boolean showLabels = true;
Color gridColor = Color.black;
Font font = new Font("Times", Font.PLAIN, 8);
Envelope bounds = context.getViewportModel().getBounds();
List<Double>[] gridLines = chooseGridLines(bounds);
ViewportGraphics graphics = context.getGraphics();
int mapPixelWidth = context.getMapDisplay().getWidth();
int mapPixelHeight = context.getMapDisplay().getHeight();
graphics.setColor(gridColor);
List<Double> xCoords = gridLines[0];
List<Double> yCoords = gridLines[1];
// draw vert lines
for (int i = 0; i < xCoords.size(); i++) {
double x = xCoords.get(i).doubleValue();
for (int j = 0; j < yCoords.size() - 1; j++) {
double y1 = yCoords.get(j).doubleValue();
Coordinate lastCoord = new Coordinate(x, y1);
double y2 = yCoords.get(j + 1).doubleValue();
Coordinate thisCoord = new Coordinate(x, y2);
Point lastPixel = context.worldToPixel(lastCoord);
Point thisPixel = context.worldToPixel(thisCoord);
graphics.drawLine(lastPixel.x, lastPixel.y, thisPixel.x, thisPixel.y);
}
}
// draw horiz lines
for (int i = 0; i < yCoords.size(); i++) {
double y = yCoords.get(i).doubleValue();
for (int j = 0; j < xCoords.size() - 1; j++) {
double x1 = xCoords.get(j).doubleValue();
Coordinate lastCoord = new Coordinate(x1, y);
double x2 = xCoords.get(j + 1).doubleValue();
Coordinate thisCoord = new Coordinate(x2, y);
Point lastPixel = context.worldToPixel(lastCoord);
Point thisPixel = context.worldToPixel(thisCoord);
graphics.drawLine(lastPixel.x, lastPixel.y, thisPixel.x, thisPixel.y);
}
}
// cover the right side and bottom of map with thin strips
final int RIGHT_STRIP_WIDTH = (int) (mapPixelWidth * 0.05);
final int BOTTOM_STRIP_HEIGHT = (int) (mapPixelHeight * 0.05);
final int GRID_LINE_EXTENSION = (int) (RIGHT_STRIP_WIDTH * 0.1);
graphics.setColor(Color.white);
graphics.setBackground(Color.white);
graphics.clearRect(mapPixelWidth - RIGHT_STRIP_WIDTH, 0, RIGHT_STRIP_WIDTH, mapPixelHeight);
graphics.clearRect(0, mapPixelHeight - BOTTOM_STRIP_HEIGHT, mapPixelWidth, BOTTOM_STRIP_HEIGHT);
// outline the map
graphics.setColor(Color.BLACK);
graphics.drawRect(
0, 0, mapPixelWidth - RIGHT_STRIP_WIDTH - 1, mapPixelHeight - BOTTOM_STRIP_HEIGHT - 1);
// draw labels
graphics.setFont(font);
if (showLabels) {
graphics.setColor(gridColor);
for (int i = 1; i < yCoords.size() - 1; i++) {
double y = yCoords.get(i).doubleValue();
double x = xCoords.get(xCoords.size() - 1).doubleValue();
Point pixel = context.worldToPixel(new Coordinate(x, y));
// line is covered by white overlay
if (pixel.y > mapPixelHeight - BOTTOM_STRIP_HEIGHT) break;
graphics.drawString(
(int) (y) + "",
mapPixelWidth - RIGHT_STRIP_WIDTH + GRID_LINE_EXTENSION,
pixel.y,
ViewportGraphics.ALIGN_LEFT,
ViewportGraphics.ALIGN_MIDDLE);
}
for (int i = 1; i < xCoords.size() - 1; i++) {
double x = xCoords.get(i).doubleValue();
double y = yCoords.get(yCoords.size() - 1).doubleValue();
Point pixel = context.worldToPixel(new Coordinate(x, y));
// line is covered by white overlay
if (pixel.x > mapPixelWidth - RIGHT_STRIP_WIDTH) break;
graphics.drawString(
(int) (x) + "",
pixel.x,
mapPixelHeight - BOTTOM_STRIP_HEIGHT + GRID_LINE_EXTENSION,
ViewportGraphics.ALIGN_MIDDLE,
ViewportGraphics.ALIGN_TOP);
}
} // showlabels
}
/**
* Draws grid similarly to the "world" version, but with some changes: - Center the grid on the
* screen - label the grid lines in CRS units - outline the grid
*
* @param context
* @param showLabels is true, the bottom and right edges of the map are covered with white strips,
* and labels for the grid lines are placed in the white strips.
*/
private void drawGrid(MapGraphicContext context, boolean showLabels) {
GridStyle style = getStyle(context.getLayer());
double[] gridSize = style.getGridSize();
try {
MathTransform mt = CRS.findMathTransform(DefaultGeographicCRS.WGS84, context.getCRS(), true);
if (!mt.isIdentity()) {
double x = gridSize[0] / 2.0;
double y = gridSize[1] / 2.0;
double[] toTransform = new double[] {-x, -y, x, y};
double[] dest = new double[4];
mt.transform(toTransform, 0, dest, 0, 2);
gridSize = new double[] {Math.abs(dest[2] - dest[0]), Math.abs(dest[3] - dest[1])};
}
} catch (Exception e) {
MapGraphicPlugin.log("", e); // $NON-NLS-1$
}
Envelope bounds = context.getViewportModel().getBounds();
Coordinate centerCoord = bounds.centre();
gridSize = style.getGridSize();
Coordinate topLeftCenterCoord =
new Coordinate(centerCoord.x - gridSize[0] / 2, centerCoord.y + gridSize[1] / 2);
Coordinate topLeftMostCoord = new Coordinate(topLeftCenterCoord);
while (topLeftMostCoord.x - gridSize[0] > bounds.getMinX()) {
topLeftMostCoord.x -= gridSize[0];
}
while (topLeftMostCoord.y + gridSize[1] < bounds.getMaxY()) {
topLeftMostCoord.y += gridSize[1];
}
Coordinate coord = topLeftMostCoord;
ViewportGraphics graphics = context.getGraphics();
int mapPixelWidth = context.getMapDisplay().getWidth();
int mapPixelHeight = context.getMapDisplay().getHeight();
// cover the right side and bottom of map with thin strips
final int RIGHT_STRIP_WIDTH = (int) (mapPixelWidth * 0.05);
final int BOTTOM_STRIP_HEIGHT = (int) (mapPixelHeight * 0.03);
final int GRID_LINE_EXTENSION = (int) (RIGHT_STRIP_WIDTH * 0.1);
graphics.setColor(Color.white);
graphics.fillRect(mapPixelWidth - RIGHT_STRIP_WIDTH, 0, RIGHT_STRIP_WIDTH, mapPixelHeight);
graphics.fillRect(0, mapPixelHeight - BOTTOM_STRIP_HEIGHT, mapPixelWidth, BOTTOM_STRIP_HEIGHT);
// draw grid lines
graphics.setColor(style.getColor());
Point pixel = null;
while (true) {
pixel = context.worldToPixel(coord);
coord.x += gridSize[0];
coord.y -= gridSize[1];
Point next = context.worldToPixel(coord);
if (next.x - pixel.x < 2 || next.y - pixel.y < 2) {
context.getLayer().setStatus(ILayer.WARNING);
context.getLayer().setStatusMessage(Messages.GridMapGraphic_grids_too_close);
break;
}
if ((pixel.x >= mapPixelWidth && pixel.y >= mapPixelHeight)) break;
// draw vertical lines and labels
if (pixel.x < mapPixelWidth)
graphics.drawLine(
pixel.x, 0, pixel.x, mapPixelHeight - BOTTOM_STRIP_HEIGHT + GRID_LINE_EXTENSION);
if (showLabels) {
graphics.drawString(
(int) (coord.y) + "",
pixel.x,
mapPixelHeight - BOTTOM_STRIP_HEIGHT + GRID_LINE_EXTENSION,
ViewportGraphics.ALIGN_MIDDLE,
ViewportGraphics.ALIGN_TOP);
}
// draw horizontal lines and labels
if (pixel.y < mapPixelHeight)
graphics.drawLine(
0, pixel.y, mapPixelWidth - RIGHT_STRIP_WIDTH + GRID_LINE_EXTENSION, pixel.y);
if (showLabels) {
graphics.drawString(
(int) (coord.x) + "",
mapPixelWidth - RIGHT_STRIP_WIDTH + GRID_LINE_EXTENSION,
pixel.y,
ViewportGraphics.ALIGN_LEFT,
ViewportGraphics.ALIGN_MIDDLE);
}
pixel = next;
}
// outline the map
graphics.drawRect(
0, 0, mapPixelWidth - RIGHT_STRIP_WIDTH, mapPixelHeight - BOTTOM_STRIP_HEIGHT);
}