/** * Returns whether the second axis is colinear with the first axis. This method returns {@code true} * if the {@linkplain #absolute absolute} direction of the given directions are equal. * For example "down" is considered colinear with "up". * * @param d1 the first axis direction to compare. * @param d2 the second axis direction to compare. * @return {@code true} if both directions are colinear. */ public static boolean isColinear(final AxisDirection d1, final AxisDirection d2) { return Objects.equals(absolute(d1), absolute(d2)); }
/** * Tests {@link AxisDirections#indexOfColinear(CoordinateSystem, AxisDirection)}. */ @Test public void testIndexOfColinear() { assertEquals(1, AxisDirections.indexOfColinear(HardCodedCS.GEODETIC_3D, AxisDirection.NORTH)); assertEquals(1, AxisDirections.indexOfColinear(HardCodedCS.GEODETIC_3D, AxisDirection.SOUTH)); }
int c = AxisDirections.angleForCompass(source, target); if (c != Integer.MIN_VALUE) { return new Angle(c * (360.0 / AxisDirections.COMPASS_COUNT)); c = AxisDirections.angleForGeocentric(source, target); if (c != Integer.MIN_VALUE) { return new Angle(c * 90); c = AxisDirections.angleForDisplay(source, target); if (c != Integer.MIN_VALUE) { return new Angle(c * (360 / AxisDirections.DISPLAY_COUNT)); srcMeridian = AxisDirections.isUserDefined(source) ? DirectionAlongMeridian.parse(source) : null; tgtMeridian = AxisDirections.isUserDefined(target) ? DirectionAlongMeridian.parse(target) : null; if (srcMeridian != null && tgtMeridian != null) { return new Angle(srcMeridian.angle(tgtMeridian)); final boolean srcVrt = AxisDirections.isVertical(source); final boolean tgtVrt = AxisDirections.isVertical(target); if (tgtVrt) { if (srcVrt) { return new Angle(source.equals(target) ? 0 : target.equals(AxisDirection.UP) ? 180 : -180); } else if (AxisDirections.isCompass(source) || srcMeridian != null) { return target.equals(AxisDirection.UP) ? ElevationAngle.ZENITH : ElevationAngle.NADIR; if (AxisDirections.isCompass(target) || tgtMeridian != null) { return source.equals(AxisDirection.UP) ? ElevationAngle.NADIR : ElevationAngle.ZENITH;
@Override public AxisDirection getDirectionReplacement(final CoordinateSystemAxis axis, final AxisDirection direction) { /* * For now we do not touch to inter-cardinal directions (e.g. "North-East") * because it is not clear which normalization policy would match common usage. */ if (!AxisDirections.isIntercardinal(direction)) { /* * Change the direction only if the axis allows negative values. * If the axis accepts only positive values, then the direction * is considered non-invertible. */ if (axis == null || axis.getMinimumValue() < 0) { return AxisDirections.absolute(direction); } } return direction; } },
final AxisDirection baseDirection = AxisDirections.find(m.group(1), NORTH_SOUTH); if (baseDirection == null) { // We require "North" or "South" direction. return null; final String group = m.group(3); if (group != null) { final AxisDirection sgn = AxisDirections.find(group, EAST_WEST); if (sgn == null) { // We require "East" or "West" direction. return null; if (sgn != AxisDirections.absolute(sgn)) { meridian = -meridian;
if (axis.sourceDimensions.length == 1) { final DimensionNameType name; if (AxisDirections.isVertical(axis.direction)) { name = DimensionNameType.VERTICAL; } else if (AxisDirections.isTemporal(axis.direction)) { name = DimensionNameType.TIME; } else {
if (contains(name, "radius", true)) { return contains(name, "Geocentric", false) ? "R" : "r"; if (isCompass(direction)) { if (!isIntercardinal(direction) && Units.isAngular(unit)) { if (contains(name, "Spherical", false)) { return NORTH.equals(absolute(direction)) ? "φ′" : "θ"; } else { return NORTH.equals(absolute(direction)) ? "φ" : "λ"; if (contains(name, "Gravity", false)) return "H"; if (contains(name, "Elevation", false)) return "φ"; if (contains(name, "Geocentric", false)) return "r"; return "h"; } else if (DOWN.equals(direction)) { return "D"; // "Depth" } else if (isGeocentric(direction)) { final String abbreviation = ABBREVIATIONS.get(absolute(direction)); if (abbreviation != null) { return abbreviation;
AxisDirection check = AxisDirections.fromAbbreviation(abbreviation); final boolean isSigned = (dir != null); // Whether 'dir' takes in account the direction of positive values. boolean isConsistent = true; dir = check; } else if (check != null) { isConsistent = AxisDirections.isColinear(dir, check); dir = check; } else if (check != null) { isConsistent = AxisDirections.isColinear(dir, check); Resources.Keys.AmbiguousAxisDirection_4, axis.getFilename(), axis.getName(), dir, check); if (isSigned) { if (AxisDirections.isOpposite(dir)) { check = AxisDirections.opposite(check); // Apply the sign of 'dir' on 'check'.
/** * Returns {@code true} if the given direction is an "opposite" direction. * If the given argument is {@code null} or is not a known direction, then * this method conservatively returns {@code false}. * * @param dir the direction to test, or {@code null}. * @return {@code true} if the given direction is an "opposite". */ public static boolean isOpposite(final AxisDirection dir) { final AxisDirection opposite = opposite(dir); return (opposite != null) && opposite.ordinal() < dir.ordinal(); }
AxisDirections.suggestAbbreviation(axis.getName().getCode(), newDir, newUnit); final Map<String,Object> properties = new HashMap<>(); if (newAbbr.equals(abbreviation)) { if (sameDirection || newDir.equals(AxisDirections.opposite(direction))) { final UnitConverter c; try {
/** * Returns the index of the first dimension in {@code cs} where axes are colinear with the {@code subCS} axes. * If no such dimension is found, returns -1. * * @param cs the coordinate system which contains all axes. * @param subCS the coordinate system to search into {@code cs}. * @return the first dimension of a sequence of axes colinear with {@code subCS} axes, or {@code -1} if none. * * @since 0.5 */ public static int indexOfColinear(final CoordinateSystem cs, final CoordinateSystem subCS) { final int dim = indexOfColinear(cs, subCS.getAxis(0).getDirection()); if (dim >= 0) { int i = subCS.getDimension(); if (dim + i > cs.getDimension()) { return -1; } while (--i > 0) { // Intentionally exclude 0. if (!absolute(subCS.getAxis(i).getDirection()).equals( absolute(cs.getAxis(i + dim).getDirection()))) { return -1; } } } return dim; }
SingleCRS second = CRS.getVerticalComponent(this, true); if (first != null && second != null) { // Should not be null, but we are paranoiac. if (AxisDirection.UP.equals(AxisDirections.absolute(cs.getAxis(0).getDirection()))) { formatter.newLine(); final PrimeMeridian pm = datum.getPrimeMeridian(); final Unit<Angle> angularUnit = AxisDirections.getAngularUnit(cs, null); if (convention != Convention.WKT2_SIMPLIFIED || // Really this specific enum, not Convention.isSimplified(). ReferencingUtilities.getGreenwichLongitude(pm, Units.DEGREE) != 0)
/** * This is a work around for RFE #4093999 in Sun's bug database * ("Relax constraint on placement of this()/super() call in constructors"). * * @param components the coordinate systems. */ @Workaround(library="JDK", version="1.7") private DefaultCompoundCS(final CoordinateSystem[] components, final CoordinateSystemAxis[] axes) { super(singletonMap(NAME_KEY, AxisDirections.appendTo(new StringBuilder(60).append("Compound CS"), axes)), axes); this.components = UnmodifiableArrayList.wrap(components); }
@Override public boolean accept(final CoordinateSystemAxis axis) { return !AxisDirections.isVertical(axis.getDirection()); } });
abbr = Character.toString(abbreviation).intern(); } else if (direction != null && unit != null) { abbr = AxisDirections.suggestAbbreviation(name, direction, unit); } else { abbr = null;
final AxisDirection dir = axis.getDirection(); int unitIndex = 0; if (!AxisDirections.isCardinal(dir)) { if (!AxisDirections.isVertical(dir)) { throw new FactoryException(Errors.format(Errors.Keys.UnsupportedAxisDirection_1, dir));
/** * Returns the index of the first dimension in {@code cs} where axes are colinear with the {@code subCS} axes. * If no such dimension is found, returns -1. * * @param cs the coordinate system which contains all axes. * @param subCS the coordinate system to search into {@code cs}. * @return the first dimension of a sequence of axes colinear with {@code subCS} axes, or {@code -1} if none. * * @since 0.5 */ public static int indexOfColinear(final CoordinateSystem cs, final CoordinateSystem subCS) { final int dim = indexOfColinear(cs, subCS.getAxis(0).getDirection()); if (dim >= 0) { int i = subCS.getDimension(); if (dim + i > cs.getDimension()) { return -1; } while (--i > 0) { // Intentionally exclude 0. if (!isColinear(subCS.getAxis(i).getDirection(), cs.getAxis(i + dim).getDirection())) { return -1; } } } return dim; }
for (int i=0; i<compass.length; i++) { final AxisDirection direction = compass[i]; final AxisDirection opposite = AxisDirections.opposite(direction); final String message = direction.name(); int io = i+h, in = i; assertEquals(message, base + i, direction.ordinal()); assertEquals(message, base + io, opposite.ordinal()); assertEquals(message, 0, AxisDirections.angleForCompass(direction, direction)); assertEquals(message, h, abs(AxisDirections.angleForCompass(direction, opposite))); assertEquals(message, in, AxisDirections.angleForCompass(direction, NORTH));
/** * Returns the arithmetic (counterclockwise) angle from this direction to the specified direction, * in degrees. This method returns a value between -180° and +180°, or {@link Double#NaN} if the * {@linkplain #baseDirection base directions} don't match. * A positive angle denote a right-handed system. * * <div class="note"><b>Example:</b> * The angle from <cite>"North along 90 deg East"</cite> to <cite>"North along 0 deg</cite> is 90°.</div> */ public double angle(final DirectionAlongMeridian other) { if (!baseDirection.equals(other.baseDirection)) { return Double.NaN; } /* * Example: angle between (NORTH along 90°E, NORTH along 0°) shall be +90° */ double angle = Longitude.normalize(meridian - other.meridian); /* * Reverses the sign for axis oriented toward SOUTH, * so a positive angle is a right-handed system. */ if (AxisDirections.isOpposite(baseDirection)) { angle = -angle; } return angle; }
/** * Tests {@link AxisDirections#isIntercardinal(AxisDirection)}. */ @Test public void testIsIntercardinal() { assertFalse(AxisDirections.isIntercardinal(NORTH)); assertTrue (AxisDirections.isIntercardinal(NORTH_NORTH_EAST)); assertTrue (AxisDirections.isIntercardinal(NORTH_EAST)); assertTrue (AxisDirections.isIntercardinal(EAST_NORTH_EAST)); assertFalse(AxisDirections.isIntercardinal(EAST)); assertTrue (AxisDirections.isIntercardinal(EAST_SOUTH_EAST)); assertTrue (AxisDirections.isIntercardinal(SOUTH_EAST)); assertTrue (AxisDirections.isIntercardinal(SOUTH_SOUTH_EAST)); assertFalse(AxisDirections.isIntercardinal(SOUTH)); assertTrue (AxisDirections.isIntercardinal(SOUTH_SOUTH_WEST)); assertTrue (AxisDirections.isIntercardinal(SOUTH_WEST)); assertTrue (AxisDirections.isIntercardinal(WEST_SOUTH_WEST)); assertFalse(AxisDirections.isIntercardinal(WEST)); assertTrue (AxisDirections.isIntercardinal(WEST_NORTH_WEST)); assertTrue (AxisDirections.isIntercardinal(NORTH_WEST)); assertTrue (AxisDirections.isIntercardinal(NORTH_NORTH_WEST)); assertFalse(AxisDirections.isIntercardinal(UP)); assertFalse(AxisDirections.isIntercardinal(FUTURE)); assertFalse(AxisDirections.isIntercardinal(OTHER)); }