protected Vec4[] calculateNormals(int width, int height, Vec4[] verts, int padding) { int padding2 = padding * 2; if (verts.length != (width + padding2) * (height + padding2)) throw new IllegalStateException("Illegal vertices length"); Vec4[] norms = new Vec4[width * height]; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { // v2 // | // v1-v0-v3 // | // v4 Vec4 v0 = verts[getArrayIndex(width + padding2, height + padding2, x + padding, y + padding)]; if (v0 != null) { Vec4 v1 = verts[ getArrayIndex(width + padding2, height + padding2, x + padding - 1, y + padding)]; Vec4 v2 = verts[ getArrayIndex(width + padding2, height + padding2, x + padding, y + padding - 1)]; Vec4 v3 = verts[ getArrayIndex(width + padding2, height + padding2, x + padding + 1, y + padding)]; Vec4 v4 = verts[ getArrayIndex(width + padding2, height + padding2, x + padding, y + padding + 1)]; Vec4[] normals = new Vec4[4]; normals[0] = v1 != null && v2 != null ? v1.subtract3(v0).cross3(v0.subtract3(v2)).normalize3() : null; normals[1] = v2 != null && v3 != null ? v2.subtract3(v0).cross3(v0.subtract3(v3)).normalize3() : null; normals[2] = v3 != null && v4 != null ? v3.subtract3(v0).cross3(v0.subtract3(v4)).normalize3() : null; normals[3] = v4 != null && v1 != null ? v4.subtract3(v0).cross3(v0.subtract3(v1)).normalize3() : null; Vec4 normal = Vec4.ZERO; for (Vec4 n : normals) { if (n != null) normal = normal.add3(n); } if (normal != Vec4.ZERO) { norms[getArrayIndex(width, height, x, y)] = normal.normalize3(); } } } } return norms; }
/** * 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); }
/** * Determine the positions that make up the arrowhead. * * @param dc Current draw context. * @param startPosition Position of the arrow's base. * @param endPosition Position of the arrow head tip. * @return Positions that define the arrowhead. */ protected List<Position> computeArrowheadPositions( DrawContext dc, Position startPosition, Position endPosition) { Globe globe = dc.getGlobe(); // Arrowhead looks like this: // _ // A\ | 1/2 width // ________B\ _| // Pt. 1 / // C/ // | | // Length Vec4 p1 = globe.computePointFromPosition(startPosition); Vec4 pB = globe.computePointFromPosition(endPosition); // Find vector in the direction of the arrow Vec4 vB1 = p1.subtract3(pB); double arrowLengthFraction = this.getArrowLength(); // Find the point at the base of the arrowhead Vec4 arrowBase = pB.add3(vB1.multiply3(arrowLengthFraction)); Vec4 normal = globe.computeSurfaceNormalAtPoint(arrowBase); // Compute the length of the arrowhead double arrowLength = vB1.getLength3() * arrowLengthFraction; double arrowHalfWidth = arrowLength * this.getArrowAngle().tanHalfAngle(); // Compute a vector perpendicular to the segment and the normal vector Vec4 perpendicular = vB1.cross3(normal); perpendicular = perpendicular.normalize3().multiply3(arrowHalfWidth); // Find points A and C Vec4 pA = arrowBase.add3(perpendicular); Vec4 pC = arrowBase.subtract3(perpendicular); return TacticalGraphicUtil.asPositionList(globe, pA, pB, pC); }
public void lookAt(Position lookAtPos, long timeToMove) { BasicFlyView view = (BasicFlyView) this.getView(); Vec4 lookDirection; double distanceToSurface; Vec4 currentLookAtPt = view.getCenterPoint(); Position newPosition; if (currentLookAtPt == null) { view.getGlobe().computePointFromPosition(lookAtPos); double elevAtLookAtPos = view.getGlobe().getElevation(lookAtPos.getLatitude(), lookAtPos.getLongitude()); newPosition = new Position(lookAtPos, elevAtLookAtPos + 10000); } else { Vec4 currentEyePt = view.getEyePoint(); distanceToSurface = currentEyePt.distanceTo3(currentLookAtPt); lookDirection = currentLookAtPt.subtract3(currentEyePt).normalize3(); Vec4 newLookAtPt = view.getGlobe().computePointFromPosition(lookAtPos); Vec4 flyToPoint = newLookAtPt.add3(lookDirection.multiply3(-distanceToSurface)); newPosition = view.getGlobe().computePositionFromPoint(flyToPoint); } ViewUtil.ViewState viewCoords = view.getViewState(newPosition, lookAtPos); FlyToFlyViewAnimator panAnimator = FlyToFlyViewAnimator.createFlyToFlyViewAnimator( view, view.getEyePosition(), newPosition, view.getHeading(), viewCoords.getHeading(), view.getPitch(), viewCoords.getPitch(), view.getEyePosition().getElevation(), viewCoords.getPosition().getElevation(), timeToMove, WorldWind.ABSOLUTE); this.gotoAnimControl.put(VIEW_ANIM_PAN, panAnimator); this.getView().firePropertyChange(AVKey.VIEW, null, this.getView()); view.firePropertyChange(AVKey.VIEW, null, view); }
/** * Compute points on either side of a line segment. This method requires a point on the line, and * either a next point, previous point, or both. * * @param point Center point about which to compute side points. * @param prev Previous point on the line. May be null if {@code next} is non-null. * @param next Next point on the line. May be null if {@code prev} is non-null. * @param leftPositions Left position will be added to this list. * @param rightPositions Right position will be added to this list. * @param halfWidth Distance from the center line to the left or right lines. * @param globe Current globe. */ protected void generateParallelPoints( Vec4 point, Vec4 prev, Vec4 next, List<Position> leftPositions, List<Position> rightPositions, double halfWidth, Globe globe) { if ((point == null) || (prev == null && next == null)) { String message = Logging.getMessage("nullValue.PointIsNull"); Logging.logger().severe(message); throw new IllegalArgumentException(message); } if (leftPositions == null || rightPositions == null) { String message = Logging.getMessage("nullValue.PositionListIsNull"); Logging.logger().severe(message); throw new IllegalArgumentException(message); } if (globe == null) { String message = Logging.getMessage("nullValue.GlobeIsNull"); Logging.logger().severe(message); throw new IllegalArgumentException(message); } Vec4 offset; Vec4 normal = globe.computeSurfaceNormalAtPoint(point); // Compute vector in the direction backward along the line. Vec4 backward = (prev != null) ? prev.subtract3(point) : point.subtract3(next); // Compute a vector perpendicular to segment BC, and the globe normal vector. Vec4 perpendicular = backward.cross3(normal); double length; // If both next and previous points are supplied then calculate the angle that bisects the angle // current, next, prev. if (next != null && prev != null && !Vec4.areColinear(prev, point, next)) { // Compute vector in the forward direction. Vec4 forward = next.subtract3(point); // Calculate the vector that bisects angle ABC. offset = forward.normalize3().add3(backward.normalize3()); offset = offset.normalize3(); // Compute the scalar triple product of the vector BC, the normal vector, and the offset // vector to // determine if the offset points to the left or the right of the control line. double tripleProduct = perpendicular.dot3(offset); if (tripleProduct < 0) { offset = offset.multiply3(-1); } // Determine the length of the offset vector that will keep the left and right lines parallel // to the control // line. Angle theta = backward.angleBetween3(offset); if (!Angle.ZERO.equals(theta)) length = halfWidth / theta.sin(); else length = halfWidth; } else { offset = perpendicular.normalize3(); length = halfWidth; } offset = offset.multiply3(length); // Determine the left and right points by applying the offset. Vec4 ptRight = point.add3(offset); Vec4 ptLeft = point.subtract3(offset); // Convert cartesian points to geographic. Position posLeft = globe.computePositionFromPoint(ptLeft); Position posRight = globe.computePositionFromPoint(ptRight); leftPositions.add(posLeft); rightPositions.add(posRight); }
protected void onMoveTo( Position focalPosition, ViewInputAttributes.DeviceAttributes deviceAttributes, ViewInputAttributes.ActionAttributes actionAttribs) { BasicFlyView view = (BasicFlyView) this.getView(); if (view == null) // include this test to ensure any derived implementation performs it { return; } // We're treating a speed parameter as smoothing here. A greater speed results in greater // smoothing and // slower response. Therefore the min speed used at lower altitudes ought to be *greater* than // the max // speed used at higher altitudes. double smoothing = this.getScaleValueElevation(deviceAttributes, actionAttribs); if (!actionAttribs.isEnableSmoothing()) smoothing = 0.0; Vec4 currentLookAtPt = view.getCenterPoint(); if (currentLookAtPt == null) { currentLookAtPt = view.getGlobe().computePointFromPosition(focalPosition); } Vec4 currentEyePt = view.getEyePoint(); double distanceToSurface = currentEyePt.distanceTo3(currentLookAtPt); Vec4 lookDirection = currentEyePt.subtract3(currentLookAtPt).normalize3(); Vec4 newLookAtPt = view.getGlobe().computePointFromPosition(focalPosition); Vec4 flyToPoint = newLookAtPt.add3(lookDirection.multiply3(distanceToSurface)); Position newPosition = view.getGlobe().computePositionFromPoint(flyToPoint); ViewUtil.ViewState viewCoords = view.getViewState(newPosition, focalPosition); this.stopAnimators(); this.gotoAnimControl.put( VIEW_ANIM_HEADING, new RotateToAngleAnimator( view.getHeading(), viewCoords.getHeading(), smoothing, ViewPropertyAccessor.createHeadingAccessor(view))); this.gotoAnimControl.put( VIEW_ANIM_PITCH, new RotateToAngleAnimator( view.getPitch(), viewCoords.getPitch(), smoothing, ViewPropertyAccessor.createPitchAccessor(view))); double elevation = ((FlyViewLimits) view.getViewPropertyLimits()) .limitEyeElevation(newPosition, view.getGlobe()); if (elevation != newPosition.getElevation()) { newPosition = new Position(newPosition, elevation); } this.gotoAnimControl.put( VIEW_ANIM_POSITION, new MoveToPositionAnimator( view.getEyePosition(), newPosition, smoothing, ViewPropertyAccessor.createEyePositionAccessor(view))); view.firePropertyChange(AVKey.VIEW, null, view); }