/** * Create and set the graphic within the state machine. The GraphicAttributes describe the type of * poly to create. */ public void createGraphic(GraphicAttributes ga) { init(); stateMachine.setUndefined(); int renderType = OMGraphic.RENDERTYPE_LATLON; int lineType = OMGraphic.LINETYPE_GREATCIRCLE; if (ga != null) { renderType = ga.getRenderType(); lineType = ga.getLineType(); } if (Debug.debugging("eomg")) { Debug.output("EditableOMPoly.createGraphic(): rendertype = " + renderType); } if (lineType == OMGraphic.LINETYPE_UNKNOWN) { lineType = OMGraphic.LINETYPE_GREATCIRCLE; if (ga != null) ga.setLineType(OMGraphic.LINETYPE_GREATCIRCLE); } this.poly = (OMPoly) createGraphic(renderType, lineType); if (ga != null) { ga.setRenderType(poly.getRenderType()); ga.setTo(poly, true); } }
/** * Draw the EditableOMPoly parts into the java.awt.Graphics object. The grab points are only * rendered if the poly machine state is PolySelectedState.POLY_SELECTED. * * @param graphics java.awt.Graphics. */ public void render(java.awt.Graphics graphics) { Debug.message("eomg", "EditableOMPoly.render()"); State state = getStateMachine().getState(); if (poly != null && !(state instanceof PolyUndefinedState)) { poly.setVisible(true); poly.render(graphics); poly.setVisible(false); } else { Debug.message("eomg", "EditableOMPoly.render: null or undefined poly."); return; } // Render the points actually on the polygon if (state instanceof GraphicSelectedState || state instanceof PolyAddNodeState || state instanceof PolyDeleteNodeState) { for (GrabPoint gb : polyGrabPoints) { if (gb != null) { gb.setVisible(true); gb.render(graphics); gb.setVisible(false); } } } // In certain conditions, render the offset grab point. if (state instanceof GraphicSelectedState || state instanceof GraphicEditState /* * || * state * instanceof * PolySetOffsetState */) { if (gpo != null && poly.getRenderType() == OMGraphic.RENDERTYPE_OFFSET) { gpo.setVisible(true); gpo.render(graphics); gpo.setVisible(false); } } }
/** * Called to set the OffsetGrabPoint to the current mouse location, and update the OffsetGrabPoint * with all the other GrabPoint locations, so everything can shift smoothly. Should also set the * OffsetGrabPoint to the movingPoint. Should be called only once at the beginning of the general * movement, in order to set the movingPoint. After that, redraw(e) should just be called, and the * movingPoint will make the adjustments to the graphic that are needed. */ public void move(MouseEvent e) { // Need to check to see if the OffsetGrabPoint is currently // being used. If not, just use it, otherwise, will need to // create a special one for the move. Point2D pnt = getProjectionPoint(e); int x = (int) pnt.getX(); int y = (int) pnt.getY(); if (poly.getRenderType() == OMGraphic.RENDERTYPE_OFFSET) { gpm = new OffsetGrabPoint(x, y); gpm.clear(); } else { gpm = gpo; gpm.clear(); gpm.set(x, y); } // Move all the other points along with the offset point... addPolyGrabPointsToOGP(gpm); movingPoint = gpm; }
/** * Delete a point at a certain point in the polygon coordinate list. If the position is less than * zero, the deleted point will be the starting point. If the position is greater than the list of * current points, the point will be deleted from the end of the poly. */ public void deletePoint(int position) { int renderType = poly.getRenderType(); boolean needToHookUp = false; if (position <= 0 && isEnclosed()) { // if the position is 0 and the polygon is enclosed, we // need to disengage the two points, then reattach. enclose(false); needToHookUp = true; } if (renderType == OMGraphic.RENDERTYPE_LATLON) { Debug.message("eomg", "EditableOMPoly: removing point from lat/lon poly"); if (projection != null) { double[] ll = poly.getLatLonArray(); double[] newll = new double[ll.length - 2]; int actualPosition = (position == Integer.MAX_VALUE ? ll.length : position * 2); if (actualPosition >= ll.length) { // Pull the new points off the end System.arraycopy(ll, 0, newll, 0, ll.length - 2); position = (ll.length - 2) / 2; } else if (actualPosition <= 0) { // Pull the new points off the beginning System.arraycopy(ll, 2, newll, 0, ll.length - 2); position = 0; } else { // actualPosition because there are 2 floats for // every // position. System.arraycopy(ll, 0, newll, 0, actualPosition); System.arraycopy( ll, actualPosition + 2, newll, actualPosition, ll.length - actualPosition - 2); } poly.setLocation((double[]) newll, poly.getUnits()); } } else { // Grab the projected endpoints Debug.message("eomg", "EditableOMPoly: removing point from x/y or offset poly"); int currentLength = poly.xs.length; int[] newxs = new int[currentLength - 1]; int[] newys = new int[currentLength - 1]; if (position >= currentLength) { // Pull the points from the end... System.arraycopy(poly.xs, 0, newxs, 0, currentLength - 1); System.arraycopy(poly.ys, 0, newys, 0, currentLength - 1); position = currentLength - 1; } else if (position <= 0) { // Pull the points from the beginning... System.arraycopy(poly.xs, 1, newxs, 0, currentLength - 1); System.arraycopy(poly.ys, 1, newys, 0, currentLength - 1); position = 0; } else { System.arraycopy(poly.xs, 0, newxs, 0, position); System.arraycopy(poly.xs, position + 1, newxs, position, currentLength - position - 1); System.arraycopy(poly.ys, 0, newys, 0, position); System.arraycopy(poly.ys, position + 1, newys, position, currentLength - position - 1); } if (poly.getRenderType() == OMGraphic.RENDERTYPE_OFFSET) { poly.setLocation(poly.lat, poly.lon, poly.getUnits(), newxs, newys); } else { poly.setLocation(newxs, newys); } } if (projection != null) { poly.regenerate(projection); } // Remove the GrabPoint for the deleted spot. GrabPoint gp = (GrabPoint) polyGrabPoints.remove(position); if (gpo != null && gp != null) { gpo.removeGrabPoint(gp); } if (needToHookUp) { enclose(true); } }
/** * Add a point at a certain point in the polygon coordinate list. If the position is less than * zero, the point will be the starting point. If the position is greater than the list of current * points, the point will be added to the end of the poly. This method is convenient because it * lets you define the GrabPoint object to use for the node, in case you need a special type of * GrabPoint. * * @return the index for the point in the polygon, starting with 0. */ public int addPoint(GrabPoint gp, int position) { if (gp == null) { return -1; } int x = gp.getX(); int y = gp.getY(); int renderType = poly.getRenderType(); boolean rads = (poly.getUnits() == OMGraphic.RADIANS); if (renderType == OMGraphic.RENDERTYPE_LATLON) { Debug.message("eomg", "EditableOMPoly: adding point to lat/lon poly"); if (projection != null) { double[] ll = poly.getLatLonArray(); int actualPosition = (position == Integer.MAX_VALUE ? ll.length : position * 2); LatLonPoint llpnt = projection.inverse(x, y, new LatLonPoint.Double()); if (Debug.debugging("eomp")) { Debug.output( "EditableOMPoly: adding point to lat/lon poly at " + x + ", " + y + ": " + llpnt + ", at the end of "); for (int j = 0; j < ll.length; j += 2) { Debug.output(ll[j] + ", " + ll[j + 1]); } } double[] newll = new double[ll.length + 2]; double newlat; double newlon; if (rads) { newlat = llpnt.getRadLat(); newlon = llpnt.getRadLon(); } else { newlat = llpnt.getY(); newlon = llpnt.getX(); } if (actualPosition >= ll.length) { // Put the new points at the end if (ll.length != 0) { System.arraycopy(ll, 0, newll, 0, ll.length); } newll[ll.length] = newlat; newll[ll.length + 1] = newlon; position = ll.length / 2; } else if (actualPosition <= 0) { // Put the new point at the beginning System.arraycopy(ll, 0, newll, 2, ll.length); newll[0] = newlat; newll[1] = newlon; position = 0; } else { // actualPosition because there are 2 floats for // every // position. newll[actualPosition] = newlat; newll[actualPosition + 1] = newlon; System.arraycopy(ll, 0, newll, 0, actualPosition); System.arraycopy( ll, actualPosition, newll, actualPosition + 2, ll.length - actualPosition); } poly.setLocation((double[]) newll, poly.getUnits()); } } else if (renderType == OMGraphic.RENDERTYPE_XY) { // Grab the projected endpoints Debug.message("eomg", "EditableOMPoly: adding point to x/y poly"); int currentLength = poly.xs.length; int[] newxs = new int[currentLength + 1]; int[] newys = new int[currentLength + 1]; if (position >= currentLength) { // Put the new points at the end System.arraycopy(poly.xs, 0, newxs, 0, currentLength); System.arraycopy(poly.ys, 0, newys, 0, currentLength); newxs[currentLength] = x; newys[currentLength] = y; position = currentLength; } else if (position <= 0) { // Put the new points at the beginning System.arraycopy(poly.xs, 0, newxs, 1, currentLength); System.arraycopy(poly.ys, 0, newys, 1, currentLength); newxs[0] = x; newys[0] = y; position = 0; } else { newxs[position] = x; newys[position] = y; System.arraycopy(poly.xs, 0, newxs, 0, position); System.arraycopy(poly.xs, position, newxs, position + 1, currentLength - position); System.arraycopy(poly.ys, 0, newys, 0, position); System.arraycopy(poly.ys, position, newys, position + 1, currentLength - position); } poly.setLocation(newxs, newys); } else { // Rendertype is offset... // Grab the projected endpoints Debug.message("eomg", "EditableOMPoly: adding point to offset poly"); int currentLength = poly.xs.length; int[] newxs = new int[currentLength + 1]; int[] newys = new int[currentLength + 1]; if (position >= currentLength) { // Put the new points at the end position = currentLength; System.arraycopy(poly.xs, 0, newxs, 0, currentLength); System.arraycopy(poly.ys, 0, newys, 0, currentLength); } else if (position <= 0) { // Put the new points at the beginning position = 0; System.arraycopy(poly.xs, 0, newxs, 1, currentLength); System.arraycopy(poly.ys, 0, newys, 1, currentLength); } else { System.arraycopy(poly.xs, 0, newxs, 0, position); System.arraycopy(poly.xs, position, newxs, position + 1, currentLength - position); System.arraycopy(poly.ys, 0, newys, 0, position); System.arraycopy(poly.ys, position, newys, position + 1, currentLength - position); } int offsetX; int offsetY; if (gpo.getX() == -1 && gpo.getY() == -1) { offsetX = projection.getWidth() / 2; offsetY = projection.getHeight() / 2; } else { offsetX = gpo.getX(); offsetY = gpo.getY(); } if (poly.coordMode == OMPoly.COORDMODE_ORIGIN || position == 0) { // cover // the // first // point newxs[position] = x - offsetX; newys[position] = y - offsetY; } else { // CMode Previous offset deltas newxs[position] = x - offsetX - newxs[position - 1]; newys[position] = y - offsetY - newys[position - 1]; } if (position == 0) { // Could call projection.getCenter() but that might // break if/when we make other projection // libraries/paradigms active. LatLonPoint llpnt = projection.inverse(offsetX, offsetY, new LatLonPoint.Double()); if (rads) { poly.lat = llpnt.getRadLat(); poly.lon = llpnt.getRadLon(); } else { poly.lat = llpnt.getY(); poly.lon = llpnt.getX(); } } poly.setLocation(poly.lat, poly.lon, poly.getUnits(), newxs, newys); } // Need to reset the arrowhead when an end point is added, // removing it from the shape when the point gets added. // Otherwise, you end up with a arrowhead at each junction of // the polygon. OMArrowHead omah = poly.getArrowHead(); poly.setArrowHead(null); // Reset the arrowhead so it will get drawn on the new // segment. poly.setArrowHead(omah); polyGrabPoints.add(position, gp); if (gpo != null) { gpo.addGrabPoint(gp); } // This is the standard call that needs to be made here, the // arrowhead changes are around this. poly.regenerate(projection); gp.generate(projection); return position; }
/** * Take the current location of the GrabPoints, and modify the location parameters of the OMPoly * with them. Called when you want the graphic to change according to the grab points. */ public void setGrabPoints() { int i; GrabPoint gb; // just to use a temp marker LatLonPoint llp = new LatLonPoint.Double(); int renderType = poly.getRenderType(); if (renderType == OMGraphic.RENDERTYPE_LATLON) { if (projection != null) { double[] radCoords = new double[polyGrabPoints.size() * 2]; // OK, this code resets the location of every point slightly to // the inverse location of the grab points. So if you grab one // node and move it, all of the precise values of each node // actually changes. As we go through the array of grab points, // we can check the corresponding projected location of the // current node and it matches the grab point, just use the // current poly value. double[] currentCoords = poly.getLatLonArray(); Point2D testPoint = new Point2D.Double(); for (i = 0; i < polyGrabPoints.size(); i++) { gb = (GrabPoint) polyGrabPoints.get(i); boolean useGrabPointLocation = true; try { double radLat = currentCoords[i * 2]; double lat = Math.toDegrees(radLat); double radLon = currentCoords[i * 2 + 1]; double lon = Math.toDegrees(radLon); testPoint = projection.forward(lat, lon, testPoint); if (testPoint.getX() == gb.getX() && testPoint.getY() == gb.getY()) { // The projected location of the current node is the // same as the grab point, use that location. radCoords[2 * i] = radLat; radCoords[2 * i + 1] = radLon; useGrabPointLocation = false; } } catch (Exception e) { // If anything goes wrong, don't worry about it, just // use the // projected inverse of grab point } if (useGrabPointLocation) { projection.inverse(gb.getX(), gb.getY(), llp); radCoords[2 * i] = llp.getRadLat(); radCoords[2 * i + 1] = llp.getRadLon(); } } poly.setLocation(radCoords, OMGraphic.RADIANS); } else { Debug.message( "eomg", "EditableOMPoly.setGrabPoints: projection is null, can't figure out LATLON points for poly."); } } else if (renderType == OMGraphic.RENDERTYPE_OFFSET) { // Do the offset point. if (projection != null) { projection.inverse(gpo.getX(), gpo.getY(), llp); } else { Debug.message( "eomg", "EditableOMPoly.setGrabPoints: projection is null, can't figure out LATLON points for poly offset."); } } if (renderType == OMGraphic.RENDERTYPE_XY || renderType == OMGraphic.RENDERTYPE_OFFSET) { int[] ints = new int[polyGrabPoints.size() * 2]; if (renderType == OMGraphic.RENDERTYPE_OFFSET && gpo != null) { // If offset rendertype, the x-y have to be offset // distances, not screen pixel locations. For the // polygon, you also need to take into account that // the ints can represent 2 different things: distance // from the origin (Offset) or distance from the // previous point. Need to check with the poly to // find out which to do. GrabPoint previous = gpo; for (i = 0; i < polyGrabPoints.size(); i++) { gb = (GrabPoint) polyGrabPoints.get(i); if (poly.coordMode == OMPoly.COORDMODE_PREVIOUS) { ints[2 * i] = gb.getX() - previous.getX(); ints[2 * i + 1] = gb.getY() - previous.getY(); previous = gb; } else { ints[2 * i] = gb.getX() - gpo.getX(); ints[2 * i + 1] = gb.getY() - gpo.getY(); } } double newlat = llp.getRadLat(); double newlon = llp.getRadLon(); poly.setLocation(newlat, newlon, OMGraphic.RADIANS, ints); } else { for (i = 0; i < polyGrabPoints.size(); i++) { gb = (GrabPoint) polyGrabPoints.get(i); ints[2 * i] = gb.getX(); ints[2 * i + 1] = gb.getY(); } poly.setLocation(ints); } } }
/** * Set the grab points for the graphic provided, setting them on the extents of the graphic. * Called when you want to set the grab points off the points of the graphic. */ public void setGrabPoints(OMGraphic graphic) { if (!(graphic instanceof OMPoly)) { return; } assertGrabPoints(); polyGrabPoints.clear(); arrayCleared = true; gpo.clear(); OMPoly poly = (OMPoly) graphic; boolean ntr = poly.getNeedToRegenerate(); int renderType = poly.getRenderType(); Point p = new Point(); GrabPoint gb; int i; int npts; boolean geoProj = projection instanceof GeoProj; if (ntr == false) { if (renderType == OMGraphic.RENDERTYPE_LATLON) { Debug.message("eomg", "EditableOMPoly: modifying lat/lon line"); if (projection != null) { double[] ll = poly.getLatLonArray(); boolean rads = poly.getUnits() == OMGraphic.RADIANS; gb = null; // reset for this loop for (i = 0; i < ll.length; i += 2) { if (geoProj) { ((GeoProj) projection).forward(ll[i], ll[i + 1], p, rads); } else { projection.forward(ll[i], ll[i + 1], p); } // Need to add a grab point for this // coordinate gb = new OffsetGrabPoint((int) p.getX(), (int) p.getY()); polyGrabPoints.add(gb); } } } else if (renderType == OMGraphic.RENDERTYPE_OFFSET) { // Grab the projected endpoints Debug.message("eomg", "EditableOMPoly: modifying offset poly"); int x; int y; npts = poly.xs.length; // Check to see if the poly is a offset poly, and set // the // offset grab point accordingly. if (projection != null) { if (geoProj) { ((GeoProj) projection).forward(poly.lat, poly.lon, p, true); } else { projection.forward(poly.lat, poly.lon, p); } gpo.set((int) p.getX(), (int) p.getY()); if (poly.coordMode == OMPoly.COORDMODE_ORIGIN) { for (i = 0; i < npts; i++) { x = (int) (poly.xs[i] + p.getX()); y = (int) (poly.ys[i] + p.getY()); gb = new OffsetGrabPoint(x, y); polyGrabPoints.add(gb); } } else { // CMode Previous offset deltas int lastX = (int) p.getX(); int lastY = (int) p.getY(); for (i = 0; i < npts; i++) { x = poly.xs[i] + lastX; y = poly.ys[i] + lastY; gb = new OffsetGrabPoint(x, y); polyGrabPoints.add(gb); lastX += x; lastY += y; } } } } else { npts = poly.xs.length; Debug.message("eomg", "EditableOMPoly: modifying x/y poly"); for (i = 0; i < npts; i++) { gb = new OffsetGrabPoint(poly.xs[i], poly.ys[i]); polyGrabPoints.add(gb); } } // Add the || to maintain manualEnclosed if it was // externally set before the OMPoly is actually defined, // indicating that the user wants to draw a polygon. setEnclosed(syncEnclosed() || isEnclosed()); addPolyGrabPointsToOGP(gpo); } else { Debug.message("eomg", "EditableOMPoly.setGrabPoints: graphic needs to be regenerated "); } }