public TiePointGrid cloneTiePointGrid() { final float[] srcTiePoints = this.getTiePoints(); final float[] destTiePoints = new float[srcTiePoints.length]; System.arraycopy(srcTiePoints, 0, destTiePoints, 0, srcTiePoints.length); TiePointGrid clone = new TiePointGrid(this.getName(), this.getRasterWidth(), this.getRasterHeight(), this.getOffsetX(), this.getOffsetY(), this.getSubSamplingX(), this.getSubSamplingY(), destTiePoints, this.getDiscontinuity()); clone.setUnit(getUnit()); clone.setDescription(getDescription()); return clone; }
gcList = new ArrayList<GeoCoding>(); centerLineList = new ArrayList<PolyLine>(); final float osX = lonGrid.getOffsetX(); final float osY = lonGrid.getOffsetY(); final float ssX = lonGrid.getSubSamplingX(); final float ssY = lonGrid.getSubSamplingY(); final float[] latFloats = (float[]) latgrid.getDataElems(); final float[] lonFloats = (float[]) lonGrid.getDataElems(); final int stripeW = lonGrid.getRasterWidth(); final int gcStripeSceneWidth = lonGrid.getSceneRasterWidth(); final int tpRasterHeight = lonGrid.getRasterHeight(); final int sceneHeight = lonGrid.getSceneRasterHeight(); final int stripeH; if (isHighResolution(sceneHeight, tpRasterHeight)) {
public static TiePointGrid createZenithFromElevationAngleTiePointGrid(TiePointGrid elevationAngleGrid) { final float[] elevationAngles = elevationAngleGrid.getTiePoints(); final float[] zenithAngles = new float[elevationAngles.length]; for (int i = 0; i < zenithAngles.length; i++) { zenithAngles[i] = 90.0f - elevationAngles[i]; } return new TiePointGrid(elevationAngleGrid.getName(), elevationAngleGrid.getRasterWidth(), elevationAngleGrid.getRasterHeight(), elevationAngleGrid.getOffsetX(), elevationAngleGrid.getOffsetY(), elevationAngleGrid.getSubSamplingX(), elevationAngleGrid.getSubSamplingY(), zenithAngles); }
ExpectedTiePointGrid(TiePointGrid tiePointGrid, Random random) { this(); this.name = tiePointGrid.getName(); this.description = tiePointGrid.getDescription(); this.offsetX = String.valueOf(tiePointGrid.getOffsetX()); this.offsetY = String.valueOf(tiePointGrid.getOffsetY()); this.subSamplingX = String.valueOf(tiePointGrid.getSubSamplingX()); this.subSamplingY = String.valueOf(tiePointGrid.getSubSamplingY()); expectedPixels = createExpectedPixels(tiePointGrid, random); }
private void writeTiePointGrid(TiePointGrid grid, String path) throws IOException { final int w = grid.getRasterWidth(); final int h = grid.getRasterHeight(); long[] dims = new long[]{h, w}; int dataTypeID = -1; int datasetID = -1; try { dataTypeID = createH5TypeID(grid.getDataType()); dataSpaceID = H5.H5Screate_simple(2, dims, null); datasetID = H5.H5Dcreate(_fileID, path + "/" + grid.getName(), dataTypeID, dataSpaceID, createScalarAttribute(datasetID, "scene_raster_width", grid.getSceneRasterWidth()); createScalarAttribute(datasetID, "scene_raster_height", grid.getSceneRasterHeight()); createScalarAttribute(datasetID, "offset_x", grid.getOffsetX()); createScalarAttribute(datasetID, "offset_y", grid.getOffsetY()); createScalarAttribute(datasetID, "sub_sampling_x", grid.getSubSamplingX()); createScalarAttribute(datasetID, "sub_sampling_y", grid.getSubSamplingY()); createScalarAttribute(datasetID, "raster_width", grid.getRasterWidth()); createScalarAttribute(datasetID, "raster_height", grid.getRasterHeight()); createScalarAttribute(datasetID, "unit", grid.getUnit()); createScalarAttribute(datasetID, "description", grid.getDescription()); createScalarAttribute(datasetID, "CLASS", "IMAGE"); createScalarAttribute(datasetID, "IMAGE_VERSION", 1.0F); HDF5Constants.H5S_ALL,
/** * Constructs geo-coding based on two given tie-point grids. * * @param latGrid the latitude grid * @param lonGrid the longitude grid * @param datum the geodetic datum */ public TiePointGeoCoding(TiePointGrid latGrid, TiePointGrid lonGrid, Datum datum) { Guardian.assertNotNull("latGrid", latGrid); Guardian.assertNotNull("lonGrid", lonGrid); Guardian.assertNotNull("datum", datum); if (latGrid.getRasterWidth() != lonGrid.getRasterWidth() || latGrid.getRasterHeight() != lonGrid.getRasterHeight() || latGrid.getOffsetX() != lonGrid.getOffsetX() || latGrid.getOffsetY() != lonGrid.getOffsetY() || latGrid.getSubSamplingX() != lonGrid.getSubSamplingX() || latGrid.getSubSamplingY() != lonGrid.getSubSamplingY()) { throw new IllegalArgumentException("latGrid is not compatible with lonGrid"); } this.latGrid = latGrid; this.lonGrid = lonGrid; this.datum = datum; approximationsComputed = false; }
public void testClone() { TiePointGrid grid = new TiePointGrid("abc", 2, 2, 0.1f, 0.2f, 0.3f, 0.4f, new float[]{1.2f, 2.3f, 3.4f, 4.5f}); grid.setDescription("Aha!"); grid.setDiscontinuity(TiePointGrid.DISCONT_AT_180); TiePointGrid gridClone = grid.cloneTiePointGrid(); assertEquals("abc", gridClone.getName()); assertEquals("Aha!", gridClone.getDescription()); assertEquals(TiePointGrid.DISCONT_AT_180, gridClone.getDiscontinuity()); assertEquals(2, gridClone.getRasterWidth()); assertEquals(2, gridClone.getRasterHeight()); assertEquals(0.1f, gridClone.getOffsetX()); assertEquals(0.2f, gridClone.getOffsetY()); assertEquals(0.3f, gridClone.getSubSamplingX()); assertEquals(0.4f, gridClone.getSubSamplingY()); assertNotNull(gridClone.getData()); assertEquals(true, gridClone.getData().getElems() instanceof float[]); float[] dataClone = (float[]) gridClone.getData().getElems(); assertEquals(4, dataClone.length); assertEquals(1.2f, dataClone[0]); assertEquals(2.3f, dataClone[1]); assertEquals(3.4f, dataClone[2]); assertEquals(4.5f, dataClone[3]); assertNotSame(grid.getData().getElems(), dataClone); } }
16, 17, 18, 19, 20 }; final TiePointGrid tiePointGrid1 = new TiePointGrid("tpg1n", 5, 4, 2, 3, 4, 5, tpg1tp); tiePointGrid1.setDescription("tpg1d"); tiePointGrid1.setUnit("tpg1u"); sourceProduct.addTiePointGrid(tiePointGrid1); 17, 18, 19, 20 }; final TiePointGrid tiePointGrid2 = new TiePointGrid("tpg2n", 4, 5, 1.2f, 1.4f, 5, 4, tpg2tp); tiePointGrid2.setDescription("tpg2d"); tiePointGrid2.setUnit("tpg2u"); sourceProduct.addTiePointGrid(tiePointGrid2); assertEquals("tpg1n", sourceProduct.getTiePointGridAt(0).getName()); assertEquals(5, sourceProduct.getTiePointGridAt(0).getRasterWidth()); assertEquals(4, sourceProduct.getTiePointGridAt(0).getRasterHeight()); assertEquals(2.0f, sourceProduct.getTiePointGridAt(0).getOffsetX(), 1.0e-5); assertEquals(3.0f, sourceProduct.getTiePointGridAt(0).getOffsetY(), 1.0e-5); assertEquals(4.0f, sourceProduct.getTiePointGridAt(0).getSubSamplingX(), 1.0e-5); assertEquals(5.0f, sourceProduct.getTiePointGridAt(0).getSubSamplingY(), 1.0e-5); assertEquals(tpg1tp, sourceProduct.getTiePointGridAt(0).getDataElems()); assertEquals("tpg2n", sourceProduct.getTiePointGridAt(1).getName()); assertEquals(4, sourceProduct.getTiePointGridAt(1).getRasterWidth()); assertEquals(5, sourceProduct.getTiePointGridAt(1).getRasterHeight()); assertEquals(1.2f, sourceProduct.getTiePointGridAt(1).getOffsetX(), 1.0e-5); assertEquals(1.4f, sourceProduct.getTiePointGridAt(1).getOffsetY(), 1.0e-5); assertEquals(5.0f, sourceProduct.getTiePointGridAt(1).getSubSamplingX(), 1.0e-5); assertEquals(4.0f, sourceProduct.getTiePointGridAt(1).getSubSamplingY(), 1.0e-5);
@Override protected RasterDataNode createRasterDataNode() { return new TiePointGrid("dafault", 2, 2, 0, 0, 1, 1, new float[]{1f, 2f, 3f, 4f}); }
final float rightOffsetX = falseTiePointGrid.getOffsetX(); final float falseOffsetY = falseTiePointGrid.getOffsetY(); final float rightSubsamplingX = falseTiePointGrid.getSubSamplingX(); final float rightSubsamplingY = falseTiePointGrid.getSubSamplingY(); final int tpRasterHeight = srcProduct.getTiePointGrid(lonGridName).getRasterHeight(); final int scanlineHeight; if (isHighResolution(sceneRasterHeight, tpRasterHeight)) { recalculatedLatFloats = srcProduct.getTiePointGrid(latGridName).getPixels(region.x, startY, region.width, extendedHeight, recalculatedLatFloats); recalculatedLonFloats = srcProduct.getTiePointGrid(lonGridName).getPixels(region.x, startY, region.width, extendedHeight, recalculatedLonFloats); final TiePointGrid correctedLatTiePointGrid = new TiePointGrid(latGridName, region.width, extendedHeight, recalculatedLatFloats ); final TiePointGrid correctedLonTiePointGrid = new TiePointGrid(lonGridName, region.width, extendedHeight,
@Test public void testTiePointFlipping_Vertical() throws IOException { final Product flipped = ProductFlipper.createFlippedProduct(product, ProductFlipper.FLIP_VERTICAL, "v", "v"); final TiePointGrid flippedT1 = flipped.getTiePointGrid("t1"); final float[] expectedT1 = { 0.3f, 0.2f, 0.4f, 0.8f, 0.9f, 0.4f, 0.6f, 0.3f, 0.4f }; assertTrue(Arrays.equals(expectedT1, (float[]) flippedT1.getDataElems())); assertEquals(0, flippedT1.getOffsetX(), 1.0e-6); assertEquals(6, flippedT1.getOffsetY(), 1.0e-6); assertEquals(5, flippedT1.getSubSamplingX(), 1.0e-6); assertEquals(5, flippedT1.getSubSamplingY(), 1.0e-6); final TiePointGrid flippedT2 = flipped.getTiePointGrid("t3"); assertEquals(1, flippedT2.getOffsetX(), 1.0e-6); assertEquals(9, flippedT2.getOffsetY(), 1.0e-6); assertEquals(3, flippedT2.getSubSamplingX(), 1.0e-6); assertEquals(3, flippedT2.getSubSamplingY(), 1.0e-6); GeneralPath[] flippedPath = ProductUtils.createGeoBoundaryPaths(flipped); assertEquals(1, flippedPath.length); final Rectangle2D expBounds = geoBoundaryPath[0].getBounds2D(); final Rectangle2D actualBounds = flippedPath[0].getBounds2D(); assertEquals(expBounds.getMinX(), actualBounds.getMinX(), 1.0e-6); assertEquals(expBounds.getMinY(), actualBounds.getMinY(), 1.0e-6); assertEquals(expBounds.getMaxX(), actualBounds.getMaxX(), 1.0e-6); assertEquals(expBounds.getMaxY(), actualBounds.getMaxY(), 1.0e-6); }
private double[][] createWarpPoints(TiePointGrid lonGrid, Rectangle subsetRect) { final TiePointGrid latGrid = getLatGrid(); final int w = latGrid.getRasterWidth(); final int sw = subsetRect.width; final int sh = subsetRect.height; i = i2; lat = latGrid.getRasterData().getElemFloatAt(j * w + i); lon = lonGrid.getRasterData().getElemFloatAt(j * w + i); x = latGrid.getOffsetX() + i * latGrid.getSubSamplingX(); y = latGrid.getOffsetY() + j * latGrid.getSubSamplingY(); data[k][0] = lat; data[k][1] = lon;
/** * Parses a complete tie point grid and adds it to the tie poinzts grids vector */ private void parseTiePointGrid(String tiePtName, String description) throws IOException { TiePointGrid grid = null; int arraySize = ATSR_TIE_PT_GRID_WIDTH * ATSR_TIE_PT_GRID_HEIGHT; float[] fData = parseFloatArray(ANGLE_PARAMETER_SIZE, arraySize); grid = new TiePointGrid(tiePtName, ATSR_TIE_PT_GRID_WIDTH, ATSR_TIE_PT_GRID_HEIGHT, ATSR_TIE_PT_OFFS_X, 0, ATSR_TIE_PT_SUBS_X, ATSR_TIE_PT_SUBS_Y, fData); grid.setUnit(ANGLE_UNIT); if (description != null) { grid.setDescription(description); } _tiePointGrids.add(grid); } }
private int findStart(int x) { int increaseDecreaseCount = 0; final float[] latPoints = _latGrid.getTiePoints(); int latWidth = _latGrid.getRasterWidth(); for(int i=1; i<_latGrid.getRasterHeight(); i++) { float p0 = latPoints[(i - 1) * latWidth + x]; float p1 = latPoints[i * latWidth + x]; if (Float.isNaN(p0) || p0 > 90.0 || p0 < -90.0 || Float.isNaN(p1) || p1 > 90.0 || p1 < -90.0) { continue; } int change = 0; if((p0 - p1) < -0.001) { // increase change = +1; } else if((p1 - p0) < -0.001) { // decrease change = -1; } if (increaseDecreaseCount > 1 && change == -1) { return (int)(i*_latGrid.getSubSamplingY()); } else if (increaseDecreaseCount < -1 && change == +1) { return (int)(i*_latGrid.getSubSamplingY()); } else { increaseDecreaseCount += change; } } return -1; }
if (isDiscontNotInit()) { initDiscont(); final float sinAngle = sinGrid.getPixelFloat(x, y); final float cosAngle = cosGrid.getPixelFloat(x, y); final float v = (float) (MathUtils.RTOD * Math.atan2(sinAngle, cosAngle)); if (discontinuity == DISCONT_AT_360 && v < 0.0) { final int i = MathUtils.floorAndCrop(fi, 0, getRasterWidth() - 2); final int j = MathUtils.floorAndCrop(fj, 0, getRasterHeight() - 2); return interpolate(fi - i, fj - j, i, j);
contextProduct.addTiePointGrid(new TiePointGrid(grid.getName(), 10, 10, 0, 0, 1, 1, new float[100]));
private TiePointGrid addTiePointGrid(Product product, String name, String units, int height, float[] data, int discontinuity) { final TiePointGrid grid = new TiePointGrid(name, TIE_POINT_GRID_WIDTH, height, TIE_POINT_OFFSET_X + 0.5f, 0.5f, TIE_POINT_SAMPLING_X, 1, data, discontinuity); grid.setUnit(units); product.addTiePointGrid(grid); return grid; }
public void testInterpolation() { TiePointGrid grid = new TiePointGrid("x", 3, 5, 0.5f, 0.5f, 4, 2, _tiePoints); float[][] interpolated = new float[][]{ {0.0F, 0.5F, 1.0F, 1.5F, 2.0F}, {0.5F, 1.0F, 1.5F, 2.0F, 2.5F}, {1.0F, 1.5F, 2.0F, 2.5F, 3.0F}, {1.5F, 2.0F, 2.5F, 3.0F, 3.5F}, {2.0F, 2.5F, 3.0F, 3.5F, 4.0F}, {2.5F, 3.0F, 3.5F, 4.0F, 4.5F}, {3.0F, 3.5F, 4.0F, 4.5F, 5.0F}, {3.5F, 4.0F, 4.5F, 5.0F, 5.5F}, {4.0F, 4.5F, 5.0F, 5.5F, 6.0F} }; for (int j = 0; j < 8; j++) { for (int i = 0; i < 4; i++) { int x = i * 4 / 2; int y = j * 2 / 2; assertEquals(interpolated[j][i], grid.getPixelFloat(x, y), _eps); } } }
/** * Returns the width in pixels of the scene represented by this tie-point grid. The value returned is * <code>(getRasterWidth() - 1) * getSubSamplingX() + 1</code> * * @return the scene width in pixels */ @Override public int getSceneRasterWidth() { if (getProduct() != null) { return getProduct().getSceneRasterWidth(); } else { return Math.round((getRasterWidth() - 1) * getSubSamplingX() + 1); } }