From 5dda601073fa7db78bc1ae54ddc1919b878e00d5 Mon Sep 17 00:00:00 2001
From: Luc Maisonobe <luc@orekit.org>
Date: Fri, 21 Nov 2014 10:20:47 +0100
Subject: [PATCH] Replaced pixel by cell for Digital Elevation Model elements.
---
.../intersection/BasicScanAlgorithm.java | 8 ++--
.../intersection/IntersectionAlgorithm.java | 4 +-
.../duvenhage/DuvenhageAlgorithm.java | 8 ++--
.../duvenhage/MinMaxTreeTile.java | 32 ++++++-------
.../org/orekit/rugged/raster/SimpleTile.java | 16 +++----
.../java/org/orekit/rugged/raster/Tile.java | 32 ++++++-------
.../org/orekit/rugged/raster/TileUpdater.java | 12 ++---
.../rugged/utils/ExtendedEllipsoid.java | 8 ++--
.../intersection/AbstractAlgorithmTest.java | 4 +-
.../duvenhage/MinMaxTreeTileTest.java | 6 +--
.../rugged/raster/CliffsElevationUpdater.java | 8 ++--
.../orekit/rugged/raster/SimpleTileTest.java | 46 +++++++++----------
.../raster/VolcanicConeElevationUpdater.java | 8 ++--
13 files changed, 96 insertions(+), 96 deletions(-)
diff --git a/core/src/main/java/org/orekit/rugged/intersection/BasicScanAlgorithm.java b/core/src/main/java/org/orekit/rugged/intersection/BasicScanAlgorithm.java
index 401450c9..68313b43 100644
--- a/core/src/main/java/org/orekit/rugged/intersection/BasicScanAlgorithm.java
+++ b/core/src/main/java/org/orekit/rugged/intersection/BasicScanAlgorithm.java
@@ -124,15 +124,15 @@ public class BasicScanAlgorithm implements IntersectionAlgorithm {
for (final SimpleTile tile : scannedTiles) {
for (int i = latitudeIndex(tile, minLatitude); i <= latitudeIndex(tile, maxLatitude); ++i) {
for (int j = longitudeIndex(tile, minLongitude); j <= longitudeIndex(tile, maxLongitude); ++j) {
- final NormalizedGeodeticPoint gp = tile.pixelIntersection(entryPoint, ellipsoid.convertLos(entryPoint, los), i, j);
+ final NormalizedGeodeticPoint gp = tile.cellIntersection(entryPoint, ellipsoid.convertLos(entryPoint, los), i, j);
if (gp != null) {
- // improve the point, by projecting it back on the 3D line, fixing the small body curvature at pixel level
+ // improve the point, by projecting it back on the 3D line, fixing the small body curvature at cell level
final Vector3D delta = ellipsoid.transform(gp).subtract(position);
final double s = Vector3D.dotProduct(delta, los) / los.getNormSq();
final GeodeticPoint projected = ellipsoid.transform(new Vector3D(1, position, s, los),
ellipsoid.getBodyFrame(), null);
- final NormalizedGeodeticPoint gpImproved = tile.pixelIntersection(projected, ellipsoid.convertLos(projected, los), i, j);
+ final NormalizedGeodeticPoint gpImproved = tile.cellIntersection(projected, ellipsoid.convertLos(projected, los), i, j);
if (gpImproved != null) {
final Vector3D point = ellipsoid.transform(gpImproved);
@@ -168,7 +168,7 @@ public class BasicScanAlgorithm implements IntersectionAlgorithm {
final GeodeticPoint projected = ellipsoid.transform(new Vector3D(1, position, s, los),
ellipsoid.getBodyFrame(), null);
final Tile tile = cache.getTile(projected.getLatitude(), projected.getLongitude());
- return tile.pixelIntersection(projected, ellipsoid.convertLos(projected, los),
+ return tile.cellIntersection(projected, ellipsoid.convertLos(projected, los),
tile.getFloorLatitudeIndex(projected.getLatitude()),
tile.getFloorLongitudeIndex(projected.getLongitude()));
} catch (OrekitException oe) {
diff --git a/core/src/main/java/org/orekit/rugged/intersection/IntersectionAlgorithm.java b/core/src/main/java/org/orekit/rugged/intersection/IntersectionAlgorithm.java
index 9bda9c04..43795c88 100644
--- a/core/src/main/java/org/orekit/rugged/intersection/IntersectionAlgorithm.java
+++ b/core/src/main/java/org/orekit/rugged/intersection/IntersectionAlgorithm.java
@@ -40,8 +40,8 @@ public interface IntersectionAlgorithm {
* <p>
* This method is used to refine an intersection when a close guess is
* already known. The intersection is typically looked for by a direct
- * {@link org.orekit.rugged.raster.Tile#pixelIntersection(GeodeticPoint,
- * Vector3D, int, int) pixel intersection} in the tile which already
+ * {@link org.orekit.rugged.raster.Tile#cellIntersection(GeodeticPoint,
+ * Vector3D, int, int) cell intersection} in the tile which already
* contains the close guess, or any similar very fast algorithm.
* </p>
* @param ellipsoid reference ellipsoid
diff --git a/core/src/main/java/org/orekit/rugged/intersection/duvenhage/DuvenhageAlgorithm.java b/core/src/main/java/org/orekit/rugged/intersection/duvenhage/DuvenhageAlgorithm.java
index ec96a6ff..7a7a39d1 100644
--- a/core/src/main/java/org/orekit/rugged/intersection/duvenhage/DuvenhageAlgorithm.java
+++ b/core/src/main/java/org/orekit/rugged/intersection/duvenhage/DuvenhageAlgorithm.java
@@ -170,7 +170,7 @@ public class DuvenhageAlgorithm implements IntersectionAlgorithm {
final Vector3D entryP = ellipsoid.pointAtAltitude(position, los, tile.getMaxElevation());
final NormalizedGeodeticPoint entry = ellipsoid.transform(entryP, ellipsoid.getBodyFrame(), null,
tile.getMinimumLongitude());
- return tile.pixelIntersection(entry, ellipsoid.convertLos(entryP, exitP),
+ return tile.cellIntersection(entry, ellipsoid.convertLos(entryP, exitP),
tile.getFloorLatitudeIndex(closeGuess.getLatitude()),
tile.getFloorLongitudeIndex(closeGuess.getLongitude()));
} else {
@@ -179,7 +179,7 @@ public class DuvenhageAlgorithm implements IntersectionAlgorithm {
final GeodeticPoint projected = ellipsoid.transform(new Vector3D(1, position, s, los),
ellipsoid.getBodyFrame(), null);
final Tile tile = cache.getTile(projected.getLatitude(), projected.getLongitude());
- return tile.pixelIntersection(projected, ellipsoid.convertLos(projected, los),
+ return tile.cellIntersection(projected, ellipsoid.convertLos(projected, los),
tile.getFloorLatitudeIndex(projected.getLatitude()),
tile.getFloorLongitudeIndex(projected.getLongitude()));
}
@@ -226,8 +226,8 @@ public class DuvenhageAlgorithm implements IntersectionAlgorithm {
}
if (entryLat == exitLat && entryLon == exitLon) {
- // we have narrowed the search down to a single Digital Elevation Model pixel
- return tile.pixelIntersection(entry, ellipsoid.convertLos(entry, los), exitLat, exitLon);
+ // we have narrowed the search down to a single Digital Elevation Model cell
+ return tile.cellIntersection(entry, ellipsoid.convertLos(entry, los), exitLat, exitLon);
}
// find the deepest level in the min/max kd-tree at which entry and exit share a sub-tile
diff --git a/core/src/main/java/org/orekit/rugged/intersection/duvenhage/MinMaxTreeTile.java b/core/src/main/java/org/orekit/rugged/intersection/duvenhage/MinMaxTreeTile.java
index 273bb4d0..fc0267be 100644
--- a/core/src/main/java/org/orekit/rugged/intersection/duvenhage/MinMaxTreeTile.java
+++ b/core/src/main/java/org/orekit/rugged/intersection/duvenhage/MinMaxTreeTile.java
@@ -25,17 +25,17 @@ import org.orekit.rugged.raster.SimpleTile;
/** Simple implementation of a {@link org.orekit.rugged.raster.Tile}
* with a min/max kd tree.
* <p>
- * A n level min/max kd-tree contains sub-tiles merging individual pixels
+ * A n level min/max kd-tree contains sub-tiles merging individual cells
* together from coarse-grained (at level 0) to fine-grained (at level n-1).
- * Level n-1, which is the deepest one, is computed from the raw pixels by
- * merging adjacent pixels pairs columns (i.e. pixels at indices (i, 2j)
+ * Level n-1, which is the deepest one, is computed from the raw cells by
+ * merging adjacent cells pairs columns (i.e. cells at indices (i, 2j)
* and (i, 2j+1) are merged together by computing and storing the minimum
* and maximum in a sub-tile. Level n-1 therefore has the same number of rows
* but half the number of columns of the raw tile, and its sub-tiles are
- * 1 pixel high and 2 pixels wide. Level n-2 is computed from level n-1 by
+ * 1 cell high and 2 cells wide. Level n-2 is computed from level n-1 by
* merging sub-tiles rows. Level n-2 therefore has half the number of rows
* and half the number of columns of the raw tile, and its sub-tiles are
- * 2 pixels high and 2 pixels wide. Level n-3 is again computed by merging
+ * 2 cells high and 2 cells wide. Level n-3 is again computed by merging
* columns, level n-4 merging rows and so on. As depth decreases, the number
* of sub-tiles decreases and their size increase. Level 0 is reached when
* there is only either one row or one column of large sub-tiles.
@@ -129,8 +129,8 @@ public class MinMaxTreeTile extends SimpleTile {
}
/** Get the minimum elevation at some level tree.
- * @param i row index of the pixel
- * @param j column index of the pixel
+ * @param i row index of the cell
+ * @param j column index of the cell
* @param level tree level
* @return minimum elevation
* @see #getLevels()
@@ -152,8 +152,8 @@ public class MinMaxTreeTile extends SimpleTile {
}
/** Get the maximum elevation at some level tree.
- * @param i row index of the pixel
- * @param j column index of the pixel
+ * @param i row index of the cell
+ * @param j column index of the cell
* @param level tree level
* @return maximum elevation
* @see #getLevels()
@@ -174,12 +174,12 @@ public class MinMaxTreeTile extends SimpleTile {
}
- /** Get the deepest level at which two pixels are merged in the same min/max sub-tile.
- * @param i1 row index of first pixel
- * @param j1 column index of first pixel
- * @param i2 row index of second pixel
- * @param j2 column index of second pixel
- * @return deepest level at which two pixels are merged in the same min/max sub-tile,
+ /** Get the deepest level at which two cells are merged in the same min/max sub-tile.
+ * @param i1 row index of first cell
+ * @param j1 column index of first cell
+ * @param i2 row index of second cell
+ * @param j2 column index of second cell
+ * @return deepest level at which two cells are merged in the same min/max sub-tile,
* or -1 if they are never merged in the same sub-tile
* @see #getLevels()
* @see #getMinElevation(int, int, int)
@@ -362,7 +362,7 @@ public class MinMaxTreeTile extends SimpleTile {
/** Preprocess recursive application of a function.
* <p>
- * At start, the min/max should be computed for each pixel using the four corners values.
+ * At start, the min/max should be computed for each cell using the four corners values.
* </p>
* @param preprocessed preprocessed array to fill up
* @param elevations raw elevations te preprocess
diff --git a/core/src/main/java/org/orekit/rugged/raster/SimpleTile.java b/core/src/main/java/org/orekit/rugged/raster/SimpleTile.java
index 2219f3a0..d1a08daa 100644
--- a/core/src/main/java/org/orekit/rugged/raster/SimpleTile.java
+++ b/core/src/main/java/org/orekit/rugged/raster/SimpleTile.java
@@ -31,7 +31,7 @@ import org.orekit.rugged.utils.NormalizedGeodeticPoint;
*/
public class SimpleTile implements Tile {
- /** Tolerance used to interpolate points slightly out of tile (in pixels). */
+ /** Tolerance used to interpolate points slightly out of tile (in cells). */
private static final double TOLERANCE = 1.0 / 8.0;
/** Minimum latitude. */
@@ -204,7 +204,7 @@ public class SimpleTile implements Tile {
/** {@inheritDoc}
* <p>
- * This classes uses an arbitrary 1/8 pixel tolerance for interpolating
+ * This classes uses an arbitrary 1/8 cell tolerance for interpolating
* slightly out of tile points.
* </p>
*/
@@ -246,15 +246,15 @@ public class SimpleTile implements Tile {
/** {@inheritDoc} */
@Override
- public NormalizedGeodeticPoint pixelIntersection(final GeodeticPoint p, final Vector3D los,
- final int latitudeIndex, final int longitudeIndex)
+ public NormalizedGeodeticPoint cellIntersection(final GeodeticPoint p, final Vector3D los,
+ final int latitudeIndex, final int longitudeIndex)
throws RuggedException {
- // ensure neighboring pixels to not fall out of tile
+ // ensure neighboring cells to not fall out of tile
final int iLat = FastMath.max(0, FastMath.min(latitudeRows - 2, latitudeIndex));
final int jLong = FastMath.max(0, FastMath.min(longitudeColumns - 2, longitudeIndex));
- // Digital Elevation Mode coordinates at pixel vertices
+ // Digital Elevation Mode coordinates at cell vertices
final double x00 = getLongitudeAtIndex(jLong);
final double y00 = getLatitudeAtIndex(iLat);
final double z00 = getElevationAtIndices(iLat, jLong);
@@ -330,8 +330,8 @@ public class SimpleTile implements Tile {
/** Interpolate point along a line.
* @param t abscissa along the line
* @param p start point
- * @param dxP relative coordinate of the start point with respect to current pixel
- * @param dyP relative coordinate of the start point with respect to current pixel
+ * @param dxP relative coordinate of the start point with respect to current cell
+ * @param dyP relative coordinate of the start point with respect to current cell
* @param los direction of the line-of-sight, in geodetic space
* @param centralLongitude reference longitude lc such that the point longitude will
* be normalized between lc-Ï€ and lc+Ï€
diff --git a/core/src/main/java/org/orekit/rugged/raster/Tile.java b/core/src/main/java/org/orekit/rugged/raster/Tile.java
index b42825e5..b0ce5bbf 100644
--- a/core/src/main/java/org/orekit/rugged/raster/Tile.java
+++ b/core/src/main/java/org/orekit/rugged/raster/Tile.java
@@ -23,10 +23,10 @@ import org.orekit.rugged.utils.NormalizedGeodeticPoint;
/** Interface representing a raster tile.
* <p>
- * The elevations are considered to be at the <em>center</em> of each pixels.
+ * The elevations are considered to be at the <em>center</em> of each cells.
* The minimum latitude and longitude hence correspond to the <em>center</em>
- * of the most South-West pixel, and the maximum latitude and longitude
- * correspond to the <em>center</em> of the most North-East pixel.
+ * of the most South-West cell, and the maximum latitude and longitude
+ * correspond to the <em>center</em> of the most North-East cell.
* </p>
* @author Luc Maisonobe
*/
@@ -120,14 +120,14 @@ public interface Tile extends UpdatableTile {
/** Get minimum latitude of grid interpolation points.
* @return minimum latitude of grid interpolation points
- * (latitude of the center of the pixels of South row)
+ * (latitude of the center of the cells of South row)
*/
double getMinimumLatitude();
/** Get the latitude at some index.
* @param latitudeIndex latitude index
* @return latitude at the specified index
- * (latitude of the center of the pixels of specified row)
+ * (latitude of the center of the cells of specified row)
*/
double getLatitudeAtIndex(int latitudeIndex);
@@ -141,20 +141,20 @@ public interface Tile extends UpdatableTile {
* <em>never</em> return {@link Location#HAS_INTERPOLATION_NEIGHBORS}!
* </p>
* @return maximum latitude
- * (latitude of the center of the pixels of North row)
+ * (latitude of the center of the cells of North row)
*/
double getMaximumLatitude();
/** Get minimum longitude.
* @return minimum longitude
- * (longitude of the center of the pixels of West column)
+ * (longitude of the center of the cells of West column)
*/
double getMinimumLongitude();
/** Get the longitude at some index.
* @param longitudeIndex longitude index
* @return longitude at the specified index
- * (longitude of the center of the pixels of specified column)
+ * (longitude of the center of the cells of specified column)
*/
double getLongitudeAtIndex(int longitudeIndex);
@@ -168,7 +168,7 @@ public interface Tile extends UpdatableTile {
* <em>never</em> return {@link Location#HAS_INTERPOLATION_NEIGHBORS}!
* </p>
* @return maximum longitude
- * (longitude of the center of the pixels of East column)
+ * (longitude of the center of the cells of East column)
*/
double getMaximumLongitude();
@@ -232,10 +232,10 @@ public interface Tile extends UpdatableTile {
/** Interpolate elevation.
* <p>
* In order to cope with numerical accuracy issues when computing
- * points at tile boundary, a slight tolerance (typically 1/8 pixel)
+ * points at tile boundary, a slight tolerance (typically 1/8 cell)
* around the tile is allowed. Elevation can therefore be interpolated
* (really extrapolated in this case) even for points slightly overshooting
- * tile boundaries, using the closest tile pixel. Attempting to interpolate
+ * tile boundaries, using the closest tile cell. Attempting to interpolate
* too far from the tile will trigger an exception.
* </p>
* @param latitude ground point latitude
@@ -246,17 +246,17 @@ public interface Tile extends UpdatableTile {
double interpolateElevation(double latitude, double longitude)
throws RuggedException;
- /** Find the intersection of a line-of-sight and a Digital Elevation Model pixel.
+ /** Find the intersection of a line-of-sight and a Digital Elevation Model cell.
* @param p point on the line
* @param los line-of-sight, in the topocentric frame (East, North, Zenith) of the point,
* scaled to match radians in the horizontal plane and meters along the vertical axis
- * @param latitudeIndex latitude index of the Digital Elevation Model pixel
- * @param longitudeIndex longitude index of the Digital Elevation Model pixel
+ * @param latitudeIndex latitude index of the Digital Elevation Model cell
+ * @param longitudeIndex longitude index of the Digital Elevation Model cell
* @return point corresponding to line-of-sight crossing the Digital Elevation Model surface
- * if it lies within the pixel, null otherwise
+ * if it lies within the cell, null otherwise
* @exception RuggedException if intersection point cannot be computed
*/
- NormalizedGeodeticPoint pixelIntersection(GeodeticPoint p, Vector3D los,
+ NormalizedGeodeticPoint cellIntersection(GeodeticPoint p, Vector3D los,
int latitudeIndex, int longitudeIndex)
throws RuggedException;
diff --git a/core/src/main/java/org/orekit/rugged/raster/TileUpdater.java b/core/src/main/java/org/orekit/rugged/raster/TileUpdater.java
index ea81174e..45fc62da 100644
--- a/core/src/main/java/org/orekit/rugged/raster/TileUpdater.java
+++ b/core/src/main/java/org/orekit/rugged/raster/TileUpdater.java
@@ -37,23 +37,23 @@ public interface TileUpdater {
* UpdatableTile#setGeometry(double, double, double, double, int, int)
* tile.setGeometry} once at the start of the method to set up the tile
* geometry, and then calling {@link UpdatableTile#setElevation(int, int,
- * double) tile.setElevation} once for each pixel in the tile to set the
- * pixel elevation.
+ * double) tile.setElevation} once for each cell in the tile to set the
+ * cell elevation.
* </p>
* <p>
* The implementation must fulfill the requirements:
* </p>
* <ul>
* <li>
- * The tiles must overlap each other by one pixel (i.e. pixels
+ * The tiles must overlap each other by one cell (i.e. cells
* that belong to the northernmost row of one tile must also belong
- * to the sourthernmost row of another tile and pixels that
+ * to the sourthernmost row of another tile and cells that
* belong to the easternmost column of one tile must also belong
* to the westernmost column of another tile).
* </li>
* <li>
* As elevations are interpolated within Digital Elevation Model
- * pixels using four pixels at indices (kLat, kLon), (kLat+1, kLon),
+ * cells using four cells at indices (kLat, kLon), (kLat+1, kLon),
* (kLat, kLon+1), (kLat+1, kLon+1). A point in the northernmost row
* (resp. easternmost column) miss neighboring points at row kLat+1
* (resp. neighboring points at column kLon+1) and therefore cannot
@@ -65,7 +65,7 @@ public interface TileUpdater {
* required neighbors.
* </li>
* <li>
- * The elevation at grid point as set when calling {@link
+ * The elevation at cells as set when calling {@link
* UpdatableTile#setElevation(int, int, double) tile.setElevation(kLat, kLon,
* elevation)} must be the elevation corresponding to the latitude
* {@code minLatitude + kLat * latitudeStep} and longitude {@code
diff --git a/core/src/main/java/org/orekit/rugged/utils/ExtendedEllipsoid.java b/core/src/main/java/org/orekit/rugged/utils/ExtendedEllipsoid.java
index 909fd51f..0e624b38 100644
--- a/core/src/main/java/org/orekit/rugged/utils/ExtendedEllipsoid.java
+++ b/core/src/main/java/org/orekit/rugged/utils/ExtendedEllipsoid.java
@@ -58,7 +58,7 @@ public class ExtendedEllipsoid extends OneAxisEllipsoid {
}
/** Get point at some latitude along a pixel line of sight.
- * @param position pixel position (in body frame)
+ * @param position cell position (in body frame)
* @param los pixel line-of-sight, not necessarily normalized (in body frame)
* @param latitude latitude with respect to ellipsoid
* @param closeReference reference point used to select the closest solution
@@ -130,7 +130,7 @@ public class ExtendedEllipsoid extends OneAxisEllipsoid {
}
/** Get point at some longitude along a pixel line of sight.
- * @param position pixel position (in body frame)
+ * @param position cell position (in body frame)
* @param los pixel line-of-sight, not necessarily normalized (in body frame)
* @param longitude longitude with respect to ellipsoid
* @return point at longitude
@@ -153,7 +153,7 @@ public class ExtendedEllipsoid extends OneAxisEllipsoid {
}
/** Get point on ground along a pixel line of sight.
- * @param position pixel position (in body frame)
+ * @param position cell position (in body frame)
* @param los pixel line-of-sight, not necessarily normalized (in body frame)
* @param centralLongitude reference longitude lc such that the point longitude will
* be normalized between lc-Ï€ and lc+Ï€
@@ -178,7 +178,7 @@ public class ExtendedEllipsoid extends OneAxisEllipsoid {
}
/** Get point at some altitude along a pixel line of sight.
- * @param position pixel position (in body frame)
+ * @param position cell position (in body frame)
* @param los pixel line-of-sight, not necessarily normalized (in body frame)
* @param altitude altitude with respect to ellipsoid
* @return point at altitude
diff --git a/core/src/test/java/org/orekit/rugged/intersection/AbstractAlgorithmTest.java b/core/src/test/java/org/orekit/rugged/intersection/AbstractAlgorithmTest.java
index d906f179..820931ac 100644
--- a/core/src/test/java/org/orekit/rugged/intersection/AbstractAlgorithmTest.java
+++ b/core/src/test/java/org/orekit/rugged/intersection/AbstractAlgorithmTest.java
@@ -62,7 +62,7 @@ public abstract class AbstractAlgorithmTest {
setUpMayonVolcanoContext();
// test point approximately 1.6km North-North-West and 800 meters below volcano summit
- // note that this test point is EXACTLY at a pixel corner, and even at corners of
+ // note that this test point is EXACTLY at a cell corner, and even at corners of
// middle level (12 and above) sub-tiles
final double latitude = FastMath.toRadians(13.27);
final double longitude = FastMath.toRadians(123.68);
@@ -227,7 +227,7 @@ public abstract class AbstractAlgorithmTest {
FastMath.toRadians(-9.4369),
120.0);
- // pixels are about 10m x 10m here and a tile covers 1km x 1km
+ // cells are about 10m x 10m here and a tile covers 1km x 1km
updater = new CliffsElevationUpdater(north, south,
120.0, 0.0,
FastMath.toRadians(0.015), 101);
diff --git a/core/src/test/java/org/orekit/rugged/intersection/duvenhage/MinMaxTreeTileTest.java b/core/src/test/java/org/orekit/rugged/intersection/duvenhage/MinMaxTreeTileTest.java
index 7a6c4883..e5f87e03 100644
--- a/core/src/test/java/org/orekit/rugged/intersection/duvenhage/MinMaxTreeTileTest.java
+++ b/core/src/test/java/org/orekit/rugged/intersection/duvenhage/MinMaxTreeTileTest.java
@@ -117,9 +117,9 @@ public class MinMaxTreeTileTest {
double max = Double.NEGATIVE_INFINITY;
for (int i = neighbors[0]; i < FastMath.min(neighbors[1] + 1, nbRows); ++i) {
for (int j = neighbors[2]; j < FastMath.min(neighbors[3] + 1, nbColumns); ++j) {
- double pixelValue = tile.getElevationAtIndices(i, j);
- min = FastMath.min(min, pixelValue);
- max = FastMath.max(max, pixelValue);
+ double cellValue = tile.getElevationAtIndices(i, j);
+ min = FastMath.min(min, cellValue);
+ max = FastMath.max(max, cellValue);
}
}
diff --git a/core/src/test/java/org/orekit/rugged/raster/CliffsElevationUpdater.java b/core/src/test/java/org/orekit/rugged/raster/CliffsElevationUpdater.java
index 63aab374..09b71b04 100644
--- a/core/src/test/java/org/orekit/rugged/raster/CliffsElevationUpdater.java
+++ b/core/src/test/java/org/orekit/rugged/raster/CliffsElevationUpdater.java
@@ -49,11 +49,11 @@ public class CliffsElevationUpdater implements TileUpdater {
double y2My1 = point2.getLatitude() - point1.getLatitude();
tile.setGeometry(minLatitude, minLongitude, step, step, n, n);
for (int i = 0; i < n; ++i) {
- double pixelLatitude = minLatitude + i * step;
+ double cellLatitude = minLatitude + i * step;
for (int j = 0; j < n; ++j) {
- double pixelLongitude = minLongitude + j * step;
- double xMx1 = pixelLongitude - point1.getLongitude();
- double yMy1 = pixelLatitude - point1.getLatitude();
+ double cellLongitude = minLongitude + j * step;
+ double xMx1 = cellLongitude - point1.getLongitude();
+ double yMy1 = cellLatitude - point1.getLatitude();
if (yMy1 * x2Mx1 > xMx1 * y2My1) {
// left side of the point1 to point2 track
tile.setElevation(i, j, top);
diff --git a/core/src/test/java/org/orekit/rugged/raster/SimpleTileTest.java b/core/src/test/java/org/orekit/rugged/raster/SimpleTileTest.java
index f2704894..66950871 100644
--- a/core/src/test/java/org/orekit/rugged/raster/SimpleTileTest.java
+++ b/core/src/test/java/org/orekit/rugged/raster/SimpleTileTest.java
@@ -123,13 +123,13 @@ public class SimpleTileTest {
tile.setElevation(50, 100, 1000.0);
tile.tileUpdateCompleted();
- // indices correspond to pixels centers
+ // indices correspond to cells centers
double latCenterColumn50 = tile.getLatitudeAtIndex(50);
double latCenterColumn51 = tile.getLatitudeAtIndex(51);
double lonCenterRow23 = tile.getLongitudeAtIndex(23);
double lonCenterRow24 = tile.getLongitudeAtIndex(24);
- // getLatitudeIndex shift indices 1/2 pixel, so that
+ // getLatitudeIndex shift indices 1/2 cell, so that
// the specified latitude is always between index and index+1
// so despite latWestColumn51 is very close to column 51 center,
// getLatitudeIndex should return 50
@@ -139,7 +139,7 @@ public class SimpleTileTest {
Assert.assertTrue(tile.getLatitudeAtIndex(retrievedLatIndex) < latWestColumn51);
Assert.assertTrue(latWestColumn51 < tile.getLatitudeAtIndex(retrievedLatIndex + 1));
- // getLongitudeIndex shift indices 1/2 pixel, so that
+ // getLongitudeIndex shift indices 1/2 cell, so that
// the specified longitude is always between index and index+1
// so despite lonSouthRow24 is very close to row 24 center,
// getLongitudeIndex should return 23
@@ -186,7 +186,7 @@ public class SimpleTileTest {
tile.setElevation(1, 0, 162.0);
tile.setElevation(1, 1, 95.0);
tile.tileUpdateCompleted();
- // the following points are 1/16 pixel out of tile
+ // the following points are 1/16 cell out of tile
Assert.assertEquals(151.875, tile.interpolateElevation(-0.0625, 0.5), 1.0e-10);
Assert.assertEquals(127.125, tile.interpolateElevation( 1.0625, 0.5), 1.0e-10);
Assert.assertEquals(124.875, tile.interpolateElevation( 0.5, -0.0625), 1.0e-10);
@@ -202,7 +202,7 @@ public class SimpleTileTest {
tile.setElevation(1, 0, 162.0);
tile.setElevation(1, 1, 95.0);
tile.tileUpdateCompleted();
- // the following points are 3/16 pixel out of tile
+ // the following points are 3/16 cell out of tile
checkOutOfBound(-0.1875, 0.5, tile);
checkOutOfBound( 1.1875, 0.5, tile);
checkOutOfBound( 0.5, -0.1875, tile);
@@ -210,7 +210,7 @@ public class SimpleTileTest {
}
@Test
- public void testPixelIntersection() throws RuggedException {
+ public void testCellIntersection() throws RuggedException {
SimpleTile tile = new SimpleTileFactory().createTile();
tile.setGeometry(0.0, 0.0, 0.025, 0.025, 50, 50);
tile.setElevation(20, 14, 91.0);
@@ -224,10 +224,10 @@ public class SimpleTileTest {
GeodeticPoint gpB = new GeodeticPoint(tile.getLatitudeAtIndex(20) + 0.7 * tile.getLatitudeStep(),
tile.getLongitudeAtIndex(14) + 0.9 * tile.getLongitudeStep(),
10.0);
- GeodeticPoint gpIAB = tile.pixelIntersection(gpA, los(gpA, gpB), 20, 14);
+ GeodeticPoint gpIAB = tile.cellIntersection(gpA, los(gpA, gpB), 20, 14);
checkInLine(gpA, gpB, gpIAB);
checkOnTile(tile, gpIAB);
- GeodeticPoint gpIBA = tile.pixelIntersection(gpB, los(gpB, gpA), 20, 14);
+ GeodeticPoint gpIBA = tile.cellIntersection(gpB, los(gpB, gpA), 20, 14);
checkInLine(gpA, gpB, gpIBA);
checkOnTile(tile, gpIBA);
@@ -238,7 +238,7 @@ public class SimpleTileTest {
}
@Test
- public void testPixelIntersection2Solutions() throws RuggedException {
+ public void testCellIntersection2Solutions() throws RuggedException {
SimpleTile tile = new SimpleTileFactory().createTile();
tile.setGeometry(0.0, 0.0, 0.025, 0.025, 50, 50);
tile.setElevation(20, 14, 91.0);
@@ -255,10 +255,10 @@ public class SimpleTileTest {
// the line from gpA to gpB should traverse the DEM twice within the tile
// we use the points in the two different orders to retrieve both solutions
- GeodeticPoint gpIAB = tile.pixelIntersection(gpA, los(gpA, gpB), 20, 14);
+ GeodeticPoint gpIAB = tile.cellIntersection(gpA, los(gpA, gpB), 20, 14);
checkInLine(gpA, gpB, gpIAB);
checkOnTile(tile, gpIAB);
- GeodeticPoint gpIBA = tile.pixelIntersection(gpB, los(gpB, gpA), 20, 14);
+ GeodeticPoint gpIBA = tile.cellIntersection(gpB, los(gpB, gpA), 20, 14);
checkInLine(gpA, gpB, gpIBA);
checkOnTile(tile, gpIBA);
@@ -269,7 +269,7 @@ public class SimpleTileTest {
}
@Test
- public void testPixelIntersectionNoSolutions() throws RuggedException {
+ public void testCellIntersectionNoSolutions() throws RuggedException {
SimpleTile tile = new SimpleTileFactory().createTile();
tile.setGeometry(0.0, 0.0, 0.025, 0.025, 50, 50);
tile.setElevation(20, 14, 91.0);
@@ -284,12 +284,12 @@ public class SimpleTileTest {
tile.getLongitudeAtIndex(14) + 0.9 * tile.getLongitudeStep(),
190.0);
- Assert.assertNull(tile.pixelIntersection(gpA, los(gpA, gpB), 20, 14));
+ Assert.assertNull(tile.cellIntersection(gpA, los(gpA, gpB), 20, 14));
}
@Test
- public void testPixelIntersectionLinearOnly() throws RuggedException {
+ public void testCellIntersectionLinearOnly() throws RuggedException {
SimpleTile tile = new SimpleTileFactory().createTile();
tile.setGeometry(0.0, 0.0, 0.025, 0.025, 50, 50);
tile.setElevation(0, 0, 30.0);
@@ -304,10 +304,10 @@ public class SimpleTileTest {
tile.getLongitudeAtIndex(0) + 0.50 * tile.getLongitudeStep(),
20.0);
- GeodeticPoint gpIAB = tile.pixelIntersection(gpA, los(gpA, gpB), 0, 0);
+ GeodeticPoint gpIAB = tile.cellIntersection(gpA, los(gpA, gpB), 0, 0);
checkInLine(gpA, gpB, gpIAB);
checkOnTile(tile, gpIAB);
- GeodeticPoint gpIBA = tile.pixelIntersection(gpB, los(gpB, gpA), 0, 0);
+ GeodeticPoint gpIBA = tile.cellIntersection(gpB, los(gpB, gpA), 0, 0);
checkInLine(gpA, gpB, gpIBA);
checkOnTile(tile, gpIBA);
@@ -318,7 +318,7 @@ public class SimpleTileTest {
}
@Test
- public void testPixelIntersectionLinearIntersectionOutside() throws RuggedException {
+ public void testCellIntersectionLinearIntersectionOutside() throws RuggedException {
SimpleTile tile = new SimpleTileFactory().createTile();
tile.setGeometry(0.0, 0.0, 0.025, 0.025, 50, 50);
tile.setElevation(0, 0, 30.0);
@@ -333,12 +333,12 @@ public class SimpleTileTest {
tile.getLongitudeAtIndex(0) + 0.50 * tile.getLongitudeStep(),
55.0);
- Assert.assertNull(tile.pixelIntersection(gpA, los(gpA, gpB), 0, 0));
+ Assert.assertNull(tile.cellIntersection(gpA, los(gpA, gpB), 0, 0));
}
@Test
- public void testPixelIntersectionLinearNoIntersection() throws RuggedException {
+ public void testCellIntersectionLinearNoIntersection() throws RuggedException {
SimpleTile tile = new SimpleTileFactory().createTile();
tile.setGeometry(0.0, 0.0, 0.025, 0.025, 50, 50);
tile.setElevation(0, 0, 30.0);
@@ -353,12 +353,12 @@ public class SimpleTileTest {
tile.getLongitudeAtIndex(0) + 0.50 * tile.getLongitudeStep(),
50.0);
- Assert.assertNull(tile.pixelIntersection(gpA, los(gpA, gpB), 0, 0));
+ Assert.assertNull(tile.cellIntersection(gpA, los(gpA, gpB), 0, 0));
}
@Test
- public void testPixelIntersectionConstant0() throws RuggedException {
+ public void testCellIntersectionConstant0() throws RuggedException {
SimpleTile tile = new SimpleTileFactory().createTile();
tile.setGeometry(0.0, 0.0, 0.025, 0.025, 50, 50);
tile.setElevation(0, 0, 30.0);
@@ -373,10 +373,10 @@ public class SimpleTileTest {
tile.getLongitudeAtIndex(0) + 0.50 * tile.getLongitudeStep(),
37.5);
- GeodeticPoint gpIAB = tile.pixelIntersection(gpA, los(gpA, gpB), 0, 0);
+ GeodeticPoint gpIAB = tile.cellIntersection(gpA, los(gpA, gpB), 0, 0);
checkInLine(gpA, gpB, gpIAB);
checkOnTile(tile, gpIAB);
- GeodeticPoint gpIBA = tile.pixelIntersection(gpB, los(gpB, gpA), 0, 0);
+ GeodeticPoint gpIBA = tile.cellIntersection(gpB, los(gpB, gpA), 0, 0);
checkInLine(gpA, gpB, gpIBA);
checkOnTile(tile, gpIBA);
diff --git a/core/src/test/java/org/orekit/rugged/raster/VolcanicConeElevationUpdater.java b/core/src/test/java/org/orekit/rugged/raster/VolcanicConeElevationUpdater.java
index 70be7682..fae00fd3 100644
--- a/core/src/test/java/org/orekit/rugged/raster/VolcanicConeElevationUpdater.java
+++ b/core/src/test/java/org/orekit/rugged/raster/VolcanicConeElevationUpdater.java
@@ -46,12 +46,12 @@ public class VolcanicConeElevationUpdater implements TileUpdater {
double sinSlope = FastMath.sin(slope);
tile.setGeometry(minLatitude, minLongitude, step, step, n, n);
for (int i = 0; i < n; ++i) {
- double pixelLatitude = minLatitude + i * step;
+ double cellLatitude = minLatitude + i * step;
for (int j = 0; j < n; ++j) {
- double pixelLongitude = minLongitude + j * step;
+ double cellLongitude = minLongitude + j * step;
double distance = Constants.WGS84_EARTH_EQUATORIAL_RADIUS *
- FastMath.hypot(pixelLatitude - summit.getLatitude(),
- pixelLongitude - summit.getLongitude());
+ FastMath.hypot(cellLatitude - summit.getLatitude(),
+ cellLongitude - summit.getLongitude());
double altitude = FastMath.max(summit.getAltitude() - distance * sinSlope,
base);
tile.setElevation(i, j, altitude);
--
GitLab