/** * Apply the model's position, orientation, and scale to a COLLADA root. * * @param root COLLADA root to configure. */ protected void configureColladaRoot(ColladaRoot root) { root.setResourceResolver(this); Position refPosition = this.model.getLocation().getPosition(); root.setPosition(refPosition); root.setAltitudeMode(KMLUtil.convertAltitudeMode(this.model.getAltitudeMode())); KMLOrientation orientation = this.model.getOrientation(); if (orientation != null) { Double d = orientation.getHeading(); if (d != null) root.setHeading(Angle.fromDegrees(d)); d = orientation.getTilt(); if (d != null) root.setPitch(Angle.fromDegrees(-d)); d = orientation.getRoll(); if (d != null) root.setRoll(Angle.fromDegrees(-d)); } KMLScale scale = this.model.getScale(); if (scale != null) { Double x = scale.getX(); Double y = scale.getY(); Double z = scale.getZ(); Vec4 modelScale = new Vec4(x != null ? x : 1.0, y != null ? y : 1.0, z != null ? z : 1.0); root.setModelScale(modelScale); } }
protected Tile[] buildTiles(PlaceNameService placeNameService, NavigationTile navTile) { final Angle dLat = placeNameService.getTileDelta().getLatitude(); final Angle dLon = placeNameService.getTileDelta().getLongitude(); // Determine the row and column offset from the global tiling origin for the southwest tile // corner int firstRow = Tile.computeRow(dLat, navTile.navSector.getMinLatitude()); int firstCol = Tile.computeColumn(dLon, navTile.navSector.getMinLongitude()); int lastRow = Tile.computeRow(dLat, navTile.navSector.getMaxLatitude().subtract(dLat)); int lastCol = Tile.computeColumn(dLon, navTile.navSector.getMaxLongitude().subtract(dLon)); int nLatTiles = lastRow - firstRow + 1; int nLonTiles = lastCol - firstCol + 1; Tile[] tiles = new Tile[nLatTiles * nLonTiles]; Angle p1 = Tile.computeRowLatitude(firstRow, dLat); for (int row = 0; row <= lastRow - firstRow; row++) { Angle p2; p2 = p1.add(dLat); Angle t1 = Tile.computeColumnLongitude(firstCol, dLon); for (int col = 0; col <= lastCol - firstCol; col++) { Angle t2; t2 = t1.add(dLon); // Need offset row and column to correspond to total ro/col numbering tiles[col + row * nLonTiles] = new Tile(placeNameService, new Sector(p1, p2, t1, t2), row + firstRow, col + firstCol); t1 = t2; } p1 = p2; } return tiles; }
/** * Returns the latitude and longitude of the sector's angular center: (minimum latitude + maximum * latitude) / 2, (minimum longitude + maximum longitude) / 2. * * @return The latitude and longitude of the sector's angular center */ public LatLon getCentroid() { Angle la = Angle.fromDegrees(0.5 * (this.getMaxLatitude().degrees + this.getMinLatitude().degrees)); Angle lo = Angle.fromDegrees(0.5 * (this.getMaxLongitude().degrees + this.getMinLongitude().degrees)); return new LatLon(la, lo); }
/** * Tests the equality of the sectors' angles. Sectors are equal if all of their corresponding * angles are equal. * * @param o the sector to compareTo with <code>this</code>. * @return <code>true</code> if the four corresponding angles of each sector are equal, <code> * false</code> otherwise. */ @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final gov.nasa.worldwind.geom.Sector sector = (gov.nasa.worldwind.geom.Sector) o; if (!maxLatitude.equals(sector.maxLatitude)) { return false; } if (!maxLongitude.equals(sector.maxLongitude)) { return false; } if (!minLatitude.equals(sector.minLatitude)) { return false; } //noinspection RedundantIfStatement if (!minLongitude.equals(sector.minLongitude)) { return false; } return true; }
/** * {@inheritDoc} * * @param positions Control points. This graphic uses only two control point, which determine the * midpoints of two opposite sides of the quad. See Fire Support Area (2.X.4.3.2.1.2) on pg. * 652 of MIL-STD-2525C for an example of how these points are interpreted. */ public void setPositions(Iterable<? extends Position> positions) { if (positions == null) { String message = Logging.getMessage("nullValue.PositionsListIsNull"); Logging.logger().severe(message); throw new IllegalArgumentException(message); } Iterator<? extends Position> iterator = positions.iterator(); try { Position pos1 = iterator.next(); Position pos2 = iterator.next(); LatLon center = LatLon.interpolateGreatCircle(0.5, pos1, pos2); this.quad.setCenter(center); Angle heading = LatLon.greatCircleAzimuth(pos2, pos1); this.quad.setHeading(heading.subtract(Angle.POS90)); this.positions = positions; this.shapeInvalid = true; // Need to recompute quad size } catch (NoSuchElementException e) { String message = Logging.getMessage("generic.InsufficientPositions"); Logging.logger().severe(message); throw new IllegalArgumentException(message); } }
/** * Select the visible grid elements * * @param dc the current <code>DrawContext</code>. */ protected void selectRenderables(DrawContext dc) { if (dc == null) { String message = Logging.getMessage("nullValue.DrawContextIsNull"); Logging.logger().severe(message); throw new IllegalArgumentException(message); } Sector vs = dc.getVisibleSector(); OrbitView view = (OrbitView) dc.getView(); // Compute labels offset from view center Position centerPos = view.getCenterPosition(); Double pixelSizeDegrees = Angle.fromRadians( view.computePixelSizeAtDistance(view.getZoom()) / dc.getGlobe().getEquatorialRadius()) .degrees; Double labelOffsetDegrees = pixelSizeDegrees * view.getViewport().getWidth() / 4; Position labelPos = Position.fromDegrees( centerPos.getLatitude().degrees - labelOffsetDegrees, centerPos.getLongitude().degrees - labelOffsetDegrees, 0); Double labelLatDegrees = labelPos.getLatitude().normalizedLatitude().degrees; labelLatDegrees = Math.min(Math.max(labelLatDegrees, -76), 78); labelPos = new Position( Angle.fromDegrees(labelLatDegrees), labelPos.getLongitude().normalizedLongitude(), 0); if (vs != null) { for (GridElement ge : this.gridElements) { if (ge.isInView(dc)) { if (ge.renderable instanceof GeographicText) { GeographicText gt = (GeographicText) ge.renderable; if (labelPos.getLatitude().degrees < 72 || "*32*34*36*".indexOf("*" + gt.getText() + "*") == -1) { // Adjust label position according to eye position Position pos = gt.getPosition(); if (ge.type.equals(GridElement.TYPE_LATITUDE_LABEL)) pos = Position.fromDegrees( pos.getLatitude().degrees, labelPos.getLongitude().degrees, pos.getElevation()); else if (ge.type.equals(GridElement.TYPE_LONGITUDE_LABEL)) pos = Position.fromDegrees( labelPos.getLatitude().degrees, pos.getLongitude().degrees, pos.getElevation()); gt.setPosition(pos); } } this.graticuleSupport.addRenderable(ge.renderable, GRATICULE_UTM); } } // System.out.println("Total elements: " + count + " visible sector: " + vs); } }
static Angle computeRowLatitude(int row, Angle delta) { if (delta == null) { String msg = Logging.getMessage("nullValue.AngleIsNull"); Logging.logger().severe(msg); throw new IllegalArgumentException(msg); } return Angle.fromDegrees(-90d + delta.getDegrees() * row); }
static Angle computeColumnLongitude(int column, Angle delta) { if (delta == null) { String msg = Logging.getMessage("nullValue.AngleIsNull"); Logging.logger().severe(msg); throw new IllegalArgumentException(msg); } return Angle.fromDegrees(-180 + delta.getDegrees() * column); }
/** * Creates a new <code>Sector</code> and initializes it to the specified angles. The angles are * assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude, but this * method does not verify that. * * @param minLatitude the sector's minimum latitude in degrees. * @param maxLatitude the sector's maximum latitude in degrees. * @param minLongitude the sector's minimum longitude in degrees. * @param maxLongitude the sector's maximum longitude in degrees. * @return the new <code>Sector</code> */ public static Sector fromDegrees( double minLatitude, double maxLatitude, double minLongitude, double maxLongitude) { return new Sector( Angle.fromDegrees(minLatitude), Angle.fromDegrees(maxLatitude), Angle.fromDegrees(minLongitude), Angle.fromDegrees(maxLongitude)); }
static int computeColumn(Angle delta, Angle longitude) { if (delta == null || longitude == null) { String msg = Logging.getMessage("nullValue.AngleIsNull"); Logging.logger().severe(msg); throw new IllegalArgumentException(msg); } return (int) ((longitude.getDegrees() + 180d) / delta.getDegrees()); }
/** * Computes a hash code from the sector's four angles. * * @return a hash code incorporating the sector's four angles. */ @Override public int hashCode() { int result; result = minLatitude.hashCode(); result = 29 * result + maxLatitude.hashCode(); result = 29 * result + minLongitude.hashCode(); result = 29 * result + maxLongitude.hashCode(); return result; }
protected Position computePositionFromUPS(String hemisphere, double easting, double northing) { try { UPSCoord UPS = UPSCoord.fromUPS(hemisphere, easting, northing, globe); return new Position( Angle.fromRadiansLatitude(UPS.getLatitude().radians), Angle.fromRadiansLongitude(UPS.getLongitude().radians), 10e3); } catch (IllegalArgumentException e) { return null; } }
public Sector[] subdivide() { Angle midLat = Angle.average(this.minLatitude, this.maxLatitude); Angle midLon = Angle.average(this.minLongitude, this.maxLongitude); Sector[] sectors = new Sector[4]; sectors[0] = new Sector(this.minLatitude, midLat, this.minLongitude, midLon); sectors[1] = new Sector(this.minLatitude, midLat, midLon, this.maxLongitude); sectors[2] = new Sector(midLat, this.maxLatitude, this.minLongitude, midLon); sectors[3] = new Sector(midLat, this.maxLatitude, midLon, this.maxLongitude); return sectors; }
@Override protected void doRestoreState(RestorableSupport rs, RestorableSupport.StateObject context) { super.doRestoreState(rs, context); Double la = rs.getStateValueAsDouble(context, "leftAzimuthDegrees"); if (la == null) la = this.leftAzimuth.degrees; Double ra = rs.getStateValueAsDouble(context, "rightAzimuthDegrees"); if (ra == null) ra = this.rightAzimuth.degrees; this.setAzimuths(Angle.fromDegrees(la), Angle.fromDegrees(ra)); }
public Sector(Sector sector) { if (sector == null) { throw new IllegalArgumentException("Sector Is Null"); } this.minLatitude = new Angle(sector.getMinLatitude()); this.maxLatitude = new Angle(sector.getMaxLatitude()); this.minLongitude = new Angle(sector.getMinLongitude()); this.maxLongitude = new Angle(sector.getMaxLongitude()); this.deltaLat = Angle.fromDegrees(this.maxLatitude.degrees - this.minLatitude.degrees); this.deltaLon = Angle.fromDegrees(this.maxLongitude.degrees - this.minLongitude.degrees); }
/** * Creates a new <code>Sector</code> and initializes it to the specified angles. The angles are * assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude, but this * method does not verify that. * * @param minLatitude the sector's minimum latitude. * @param maxLatitude the sector's maximum latitude. * @param minLongitude the sector's minimum longitude. * @param maxLongitude the sector's maximum longitude. * @throws IllegalArgumentException if any of the angles are null */ public Sector(Angle minLatitude, Angle maxLatitude, Angle minLongitude, Angle maxLongitude) { if (minLatitude == null || maxLatitude == null || minLongitude == null || maxLongitude == null) { throw new IllegalArgumentException("Input Angles Null"); } this.minLatitude = minLatitude; this.maxLatitude = maxLatitude; this.minLongitude = minLongitude; this.maxLongitude = maxLongitude; this.deltaLat = Angle.fromDegrees(this.maxLatitude.degrees - this.minLatitude.degrees); this.deltaLon = Angle.fromDegrees(this.maxLongitude.degrees - this.minLongitude.degrees); }
protected static Angle clampAngle(Angle a, Angle min, Angle max) { double degrees = a.degrees; double minDegrees = min.degrees; double maxDegrees = max.degrees; return Angle.fromDegrees( degrees < minDegrees ? minDegrees : (degrees > maxDegrees ? maxDegrees : degrees)); }
/** * Compute the positions of the arrow head of the graphic's legs. * * @param dc Current draw context * @param base Position of the arrow's starting point. * @param tip Position of the arrow head tip. * @param arrowLength Length of the arrowhead as a fraction of the total line length. * @param arrowAngle Angle of the arrow head. * @return Positions required to draw the arrow head. */ protected List<Position> computeArrowheadPositions( DrawContext dc, Position base, Position tip, double arrowLength, Angle arrowAngle) { // Build a triangle to represent the arrowhead. The triangle is built from two vectors, one // parallel to the // segment, and one perpendicular to it. Globe globe = dc.getGlobe(); Vec4 ptA = globe.computePointFromPosition(base); Vec4 ptB = globe.computePointFromPosition(tip); // Compute parallel component Vec4 parallel = ptA.subtract3(ptB); Vec4 surfaceNormal = globe.computeSurfaceNormalAtPoint(ptB); // Compute perpendicular component Vec4 perpendicular = surfaceNormal.cross3(parallel); double finalArrowLength = arrowLength * parallel.getLength3(); double arrowHalfWidth = finalArrowLength * arrowAngle.tanHalfAngle(); perpendicular = perpendicular.normalize3().multiply3(arrowHalfWidth); parallel = parallel.normalize3().multiply3(finalArrowLength); // Compute geometry of direction arrow Vec4 vertex1 = ptB.add3(parallel).add3(perpendicular); Vec4 vertex2 = ptB.add3(parallel).subtract3(perpendicular); return TacticalGraphicUtil.asPositionList(globe, vertex1, vertex2, ptB); }
public MeshTile[] subdivide(Level nextLevel) { Angle p0 = this.getSector().getMinLatitude(); Angle p2 = this.getSector().getMaxLatitude(); Angle p1 = Angle.midAngle(p0, p2); Angle t0 = this.getSector().getMinLongitude(); Angle t2 = this.getSector().getMaxLongitude(); Angle t1 = Angle.midAngle(t0, t2); int row = this.getRow(); int col = this.getColumn(); MeshCoords[] coords = this.coords.subdivide(); MeshTile[] subTiles = new MeshTile[4]; subTiles[0] = new MeshTile( new Sector(p0, p1, t0, t1), nextLevel, 2 * row, 2 * col, coords[0]); // Lower left quadrant. subTiles[1] = new MeshTile( new Sector(p0, p1, t1, t2), nextLevel, 2 * row, 2 * col + 1, coords[1]); // Lower right quadrant. subTiles[2] = new MeshTile( new Sector(p1, p2, t1, t2), nextLevel, 2 * row + 1, 2 * col + 1, coords[2]); // Upper right quadrant subTiles[3] = new MeshTile( new Sector(p1, p2, t0, t1), nextLevel, 2 * row + 1, 2 * col, coords[3]); // Upper left quadrant. return subTiles; }
private static MeshTile[] createTiles(LevelSet levelSet, int levelNumber, MeshCoords coords) { Sector sector = levelSet.getSector(); Level level = levelSet.getLevel(levelNumber); Angle dLat = level.getTileDelta().getLatitude(); Angle dLon = level.getTileDelta().getLongitude(); Angle latOrigin = levelSet.getTileOrigin().getLatitude(); Angle lonOrigin = levelSet.getTileOrigin().getLongitude(); // Determine the row and column offset from the common World Wind global tiling origin. int firstRow = Tile.computeRow(dLat, sector.getMinLatitude(), latOrigin); int firstCol = Tile.computeColumn(dLon, sector.getMinLongitude(), lonOrigin); int lastRow = Tile.computeRow(dLat, sector.getMaxLatitude(), latOrigin); int lastCol = Tile.computeColumn(dLon, sector.getMaxLongitude(), lonOrigin); int numLatTiles = lastRow - firstRow + 1; int numLonTiles = lastCol - firstCol + 1; AffineTransform sectorTransform = createTransform(sector, coords); MeshTile[] tiles = new MeshTile[numLatTiles * numLonTiles]; int index = 0; Angle p1 = Tile.computeRowLatitude(firstRow, dLat, latOrigin); for (int row = firstRow; row <= lastRow; row++) { Angle p2 = p1.add(dLat); Angle t1 = Tile.computeColumnLongitude(firstCol, dLon, lonOrigin); for (int col = firstCol; col <= lastCol; col++) { Angle t2 = t1.add(dLon); Sector tileSector = new Sector(p1, p2, t1, t2); MeshCoords tileCoords = transformSector(sectorTransform, tileSector); tiles[index++] = new MeshTile(tileSector, level, row, col, tileCoords); t1 = t2; } p1 = p2; } return tiles; }
protected Angle computeIconRadius(DrawContext dc, double regionPixelSize, Sector drawSector) { double minCosLat = Math.min(drawSector.getMinLatitude().cos(), drawSector.getMaxLatitude().cos()); if (minCosLat < 0.001) return Angle.POS180; Rectangle2D iconDimension = this.computeDrawDimension(regionPixelSize); // Meter double dLat = iconDimension.getHeight() / dc.getGlobe().getRadius(); double dLon = iconDimension.getWidth() / dc.getGlobe().getRadius() / minCosLat; return Angle.fromRadians(Math.sqrt(dLat * dLat + dLon * dLon) / 2); }
private void createTopLevelTiles() { MercatorSector sector = (MercatorSector) this.levels.getSector(); Level level = levels.getFirstLevel(); Angle dLat = level.getTileDelta().getLatitude(); Angle dLon = level.getTileDelta().getLongitude(); Angle latOrigin = this.levels.getTileOrigin().getLatitude(); Angle lonOrigin = this.levels.getTileOrigin().getLongitude(); // Determine the row and column offset from the common World Wind global tiling origin. int firstRow = Tile.computeRow(dLat, sector.getMinLatitude(), latOrigin); int firstCol = Tile.computeColumn(dLon, sector.getMinLongitude(), lonOrigin); int lastRow = Tile.computeRow(dLat, sector.getMaxLatitude(), latOrigin); int lastCol = Tile.computeColumn(dLon, sector.getMaxLongitude(), lonOrigin); int nLatTiles = lastRow - firstRow + 1; int nLonTiles = lastCol - firstCol + 1; this.topLevels = new ArrayList<MercatorTextureTile>(nLatTiles * nLonTiles); // Angle p1 = Tile.computeRowLatitude(firstRow, dLat); double deltaLat = dLat.degrees / 90; double d1 = -1.0 + deltaLat * firstRow; for (int row = firstRow; row <= lastRow; row++) { // Angle p2; // p2 = p1.add(dLat); double d2 = d1 + deltaLat; Angle t1 = Tile.computeColumnLongitude(firstCol, dLon, lonOrigin); for (int col = firstCol; col <= lastCol; col++) { Angle t2; t2 = t1.add(dLon); this.topLevels.add( new MercatorTextureTile(new MercatorSector(d1, d2, t1, t2), level, row, col)); t1 = t2; } d1 = d2; } }
/** * Creates a new <code>Sector</code> and initializes it to the specified angles. The angles are * assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude, but this * method does not verify that. * * @param minLatitude the sector's minimum latitude in degrees. * @param maxLatitude the sector's maximum latitude in degrees. * @param minLongitude the sector's minimum longitude in degrees. * @param maxLongitude the sector's maximum longitude in degrees. * @return the new <code>Sector</code> */ public static Sector fromDegreesAndClamp( double minLatitude, double maxLatitude, double minLongitude, double maxLongitude) { if (minLatitude < -90) { minLatitude = -90; } if (maxLatitude > 90) { maxLatitude = 90; } if (minLongitude < -180) { minLongitude = -180; } if (maxLongitude > 180) { maxLongitude = 180; } return new Sector( Angle.fromDegrees(minLatitude), Angle.fromDegrees(maxLatitude), Angle.fromDegrees(minLongitude), Angle.fromDegrees(maxLongitude)); }
protected Angle normalizedAzimuth(Angle azimuth) { if (azimuth == null) { String message = "nullValue.AzimuthIsNull"; Logging.logger().severe(message); throw new IllegalArgumentException(message); } double degrees = azimuth.degrees; double normalizedDegrees = degrees < 0.0 ? degrees + 360.0 : (degrees >= 360.0 ? degrees - 360.0 : degrees); return Angle.fromDegrees(normalizedDegrees); }
protected double[] computeAngles() { // Compute the start and sweep angles such that the partial cylinder shape tranverses a // clockwise path from // the start angle to the stop angle. Angle startAngle, stopAngle, sweepAngle; startAngle = normalizedAzimuth(this.leftAzimuth); stopAngle = normalizedAzimuth(this.rightAzimuth); int i = startAngle.compareTo(stopAngle); // Angles are equal, fallback to building a closed cylinder. if (i == 0) return null; if (i < 0) sweepAngle = stopAngle.subtract(startAngle); else // (i > 0) sweepAngle = Angle.POS360.subtract(startAngle).add(stopAngle); double[] array = new double[3]; array[0] = startAngle.radians; array[1] = stopAngle.radians; array[2] = sweepAngle.radians; return array; }
public void actionPerformed(ActionEvent e) { if (!this.isEnabled()) { return; } if (NEW_AIRSPACE.equals(e.getActionCommand())) { this.createNewEntry(this.getView().getSelectedFactory()); } else if (CLEAR_SELECTION.equals(e.getActionCommand())) { this.selectEntry(null, true); } else if (SIZE_NEW_SHAPES_TO_VIEWPORT.equals(e.getActionCommand())) { if (e.getSource() instanceof AbstractButton) { boolean selected = ((AbstractButton) e.getSource()).isSelected(); this.setResizeNewShapesToViewport(selected); } } else if (ENABLE_EDIT.equals(e.getActionCommand())) { if (e.getSource() instanceof AbstractButton) { boolean selected = ((AbstractButton) e.getSource()).isSelected(); this.setEnableEdit(selected); } } else if (OPEN.equals(e.getActionCommand())) { this.openFromFile(); } else if (OPEN_URL.equals(e.getActionCommand())) { this.openFromURL(); } else if (OPEN_DEMO_AIRSPACES.equals(e.getActionCommand())) { this.openFromPath(DEMO_AIRSPACES_PATH); this.zoomTo( LatLon.fromDegrees(47.6584074779224, -122.3059199579634), Angle.fromDegrees(-152), Angle.fromDegrees(75), 750); } else if (REMOVE_SELECTED.equals(e.getActionCommand())) { this.removeEntries(Arrays.asList(this.getSelectedEntries())); } else if (SAVE.equals(e.getActionCommand())) { this.saveToFile(); } else if (SELECTION_CHANGED.equals(e.getActionCommand())) { this.viewSelectionChanged(); } }
/** * Create the list of positions that describe the arrow. * * @param dc Current draw context. */ protected void createShapes(DrawContext dc) { this.paths = new Path[2]; int i = 0; Angle azimuth1 = LatLon.greatCircleAzimuth(this.position1, this.position2); Angle azimuth2 = LatLon.greatCircleAzimuth(this.position1, this.position3); Angle delta = azimuth2.subtract(azimuth1); int sign = delta.degrees > 0 ? 1 : -1; delta = Angle.fromDegrees(sign * 5.0); // Create a path for the line part of the arrow List<Position> positions = this.computePathPositions(this.position1, this.position2, delta); this.paths[i++] = this.createPath(positions); // Create a polygon to draw the arrow head. double arrowLength = this.getArrowLength(); Angle arrowAngle = this.getArrowAngle(); positions = this.computeArrowheadPositions( dc, positions.get(2), positions.get(3), arrowLength, arrowAngle); this.arrowHead1 = this.createPolygon(positions); this.arrowHead1.setLocations(positions); delta = delta.multiply(-1.0); positions = this.computePathPositions(this.position1, this.position3, delta); this.paths[i] = this.createPath(positions); positions = this.computeArrowheadPositions( dc, positions.get(2), positions.get(3), arrowLength, arrowAngle); this.arrowHead2 = this.createPolygon(positions); this.arrowHead2.setLocations(positions); }
protected List<Position> computePathPositions( Position startPosition, Position endPosition, Angle delta) { Angle dist = LatLon.greatCircleDistance(startPosition, endPosition); dist = dist.multiply(0.6); Angle azimuth = LatLon.greatCircleAzimuth(startPosition, endPosition); LatLon locA = LatLon.greatCircleEndPosition(startPosition, azimuth.add(delta), dist); dist = dist.multiply(0.9); LatLon locB = LatLon.greatCircleEndPosition(startPosition, azimuth.subtract(delta), dist); return Arrays.asList(startPosition, new Position(locA, 0), new Position(locB, 0), endPosition); }
public void doActionOnButton2() { ArrayList<LatLon> latlons = new ArrayList<LatLon>(); latlons.add(LatLon.fromDegrees(45.50d, -123.3d)); // latlons.add( LatLon.fromDegrees( 45.51d, -123.3d ) ); latlons.add(LatLon.fromDegrees(45.52d, -123.3d)); // latlons.add( LatLon.fromDegrees( 45.53d, -123.3d ) ); latlons.add(LatLon.fromDegrees(45.54d, -123.3d)); // latlons.add( LatLon.fromDegrees( 45.55d, -123.3d ) ); latlons.add(LatLon.fromDegrees(45.56d, -123.3d)); // latlons.add( LatLon.fromDegrees( 45.57d, -123.3d ) ); latlons.add(LatLon.fromDegrees(45.58d, -123.3d)); // latlons.add( LatLon.fromDegrees( 45.59d, -123.3d ) ); latlons.add(LatLon.fromDegrees(45.60d, -123.3d)); Sector sector = Sector.fromDegrees(44d, 46d, -123d, -121d); // Sector sector = Sector.boundingSector( latlons ); double[] elevations = new double[latlons.size()]; // request resolution of DTED2 (1degree / 3600 ) double targetResolution = Angle.fromDegrees(1d).radians / 3600; double resolutionAchieved = this.wwd .getModel() .getGlobe() .getElevationModel() .getElevations(sector, latlons, targetResolution, elevations); StringBuffer sb = new StringBuffer(); for (double e : elevations) { sb.append("\n").append(e); } sb.append("\nresolutionAchieved = ").append(resolutionAchieved); sb.append(", requested resolution = ").append(targetResolution); Logging.logger().info(sb.toString()); }
/** Create the graticule grid elements */ private void createUTMRenderables() { this.gridElements = new ArrayList<GridElement>(); ArrayList<Position> positions = new ArrayList<Position>(); // Generate meridians and zone labels int lon = -180; int zoneNumber = 1; int maxLat; for (int i = 0; i < 60; i++) { Angle longitude = Angle.fromDegrees(lon); // Meridian positions.clear(); positions.add(new Position(Angle.fromDegrees(-80), longitude, 10e3)); positions.add(new Position(Angle.fromDegrees(-60), longitude, 10e3)); positions.add(new Position(Angle.fromDegrees(-30), longitude, 10e3)); positions.add(new Position(Angle.ZERO, longitude, 10e3)); positions.add(new Position(Angle.fromDegrees(30), longitude, 10e3)); if (lon < 6 || lon > 36) { // 'regular' UTM meridians maxLat = 84; positions.add(new Position(Angle.fromDegrees(60), longitude, 10e3)); positions.add(new Position(Angle.fromDegrees(maxLat), longitude, 10e3)); } else { // Exceptions: shorter meridians around and north-east of Norway if (lon == 6) { maxLat = 56; positions.add(new Position(Angle.fromDegrees(maxLat), longitude, 10e3)); } else { maxLat = 72; positions.add(new Position(Angle.fromDegrees(60), longitude, 10e3)); positions.add(new Position(Angle.fromDegrees(maxLat), longitude, 10e3)); } } Object polyline = createLineRenderable(positions, Polyline.GREAT_CIRCLE); Sector sector = Sector.fromDegrees(-80, maxLat, lon, lon); this.gridElements.add(new GridElement(sector, polyline, GridElement.TYPE_LINE)); // Zone label GeographicText text = new UserFacingText(zoneNumber + "", Position.fromDegrees(0, lon + 3, 0)); sector = Sector.fromDegrees(-90, 90, lon + 3, lon + 3); this.gridElements.add(new GridElement(sector, text, GridElement.TYPE_LONGITUDE_LABEL)); // Increase longitude and zone number lon += 6; zoneNumber++; } // Generate special meridian segments for exceptions around and north-east of Norway for (int i = 0; i < 5; i++) { positions.clear(); lon = specialMeridians[i][0]; positions.add( new Position(Angle.fromDegrees(specialMeridians[i][1]), Angle.fromDegrees(lon), 10e3)); positions.add( new Position(Angle.fromDegrees(specialMeridians[i][2]), Angle.fromDegrees(lon), 10e3)); Object polyline = createLineRenderable(positions, Polyline.GREAT_CIRCLE); Sector sector = Sector.fromDegrees(specialMeridians[i][1], specialMeridians[i][2], lon, lon); this.gridElements.add(new GridElement(sector, polyline, GridElement.TYPE_LINE)); } // Generate parallels - no exceptions int lat = -80; for (int i = 0; i < 21; i++) { Angle latitude = Angle.fromDegrees(lat); for (int j = 0; j < 4; j++) { // Each prallel is divided into four 90 degrees segments positions.clear(); lon = -180 + j * 90; positions.add(new Position(latitude, Angle.fromDegrees(lon), 10e3)); positions.add(new Position(latitude, Angle.fromDegrees(lon + 30), 10e3)); positions.add(new Position(latitude, Angle.fromDegrees(lon + 60), 10e3)); positions.add(new Position(latitude, Angle.fromDegrees(lon + 90), 10e3)); Object polyline = createLineRenderable(positions, Polyline.LINEAR); Sector sector = Sector.fromDegrees(lat, lat, lon, lon + 90); this.gridElements.add(new GridElement(sector, polyline, GridElement.TYPE_LINE)); } // Latitude band label if (i < 20) { GeographicText text = new UserFacingText(latBands.charAt(i) + "", Position.fromDegrees(lat + 4, 0, 0)); Sector sector = Sector.fromDegrees(lat + 4, lat + 4, -180, 180); this.gridElements.add(new GridElement(sector, text, GridElement.TYPE_LATITUDE_LABEL)); } // Increase latitude lat += lat < 72 ? 8 : 12; } }