@Test
public void testCopy() {
DataAccess da1 = createDataAccess(name);
da1.create(1001 * 4);
da1.setHeader(4, 12);
da1.setInt(1 * 4, 1);
da1.setInt(123 * 4, 321);
da1.setInt(1000 * 4, 1111);
DataAccess da2 = createDataAccess(name + "2");
da2.create(10);
da1.copyTo(da2);
assertEquals(12, da2.getHeader(4));
assertEquals(1, da2.getInt(1 * 4));
assertEquals(321, da2.getInt(123 * 4));
assertEquals(1111, da2.getInt(1000 * 4));
da2.setInt(1 * 4, 2);
assertEquals(2, da2.getInt(1 * 4));
da2.flush();
da1.flush();
// make sure they are independent!
assertEquals(1, da1.getInt(1 * 4));
da1.close();
da2.close();
}
@Test
public void testBoundsCheck() {
DataAccess da = createDataAccess(name);
da.setSegmentSize(128);
da.create(128 * 11);
da.setInt(32 * 4, 302);
// make smaller
da.trimTo(128 * 1);
try {
assertEquals(302, da.getInt(32 * 4));
assertTrue(false);
} catch (Exception ex) {
}
da.close();
da = createDataAccess(name);
da.create(128);
da.setInt(31 * 4, 200);
try {
// this should fail with an index out of bounds exception
da.setInt(32 * 4, 220);
assertFalse(true);
} catch (Exception ex) {
}
da.close();
}
@Test
public void testLoadFlush() {
DataAccess da = createDataAccess(name);
assertFalse(da.loadExisting());
da.create(300);
da.setInt(7 * 4, 123);
assertEquals(123, da.getInt(7 * 4));
da.setInt(10 * 4, Integer.MAX_VALUE / 3);
assertEquals(Integer.MAX_VALUE / 3, da.getInt(10 * 4));
da.flush();
// check noValue clearing
assertEquals(0, da.getInt(2 * 4));
assertEquals(0, da.getInt(3 * 4));
assertEquals(123, da.getInt(7 * 4));
assertEquals(Integer.MAX_VALUE / 3, da.getInt(10 * 4));
da.close();
// cannot load data if already closed
try {
da.loadExisting();
assertTrue(false);
} catch (Exception ex) {
assertEquals("already closed", ex.getMessage());
}
da = createDataAccess(name);
assertTrue(da.loadExisting());
assertEquals(123, da.getInt(7 * 4));
da.close();
}
@Test
public void testSet_GetBytes() {
DataAccess da = createDataAccess(name);
da.create(300);
assertEquals(128, da.getSegmentSize());
byte[] bytes = BitUtil.BIG.fromInt(Integer.MAX_VALUE / 3);
da.setBytes(8, bytes, bytes.length);
bytes = new byte[4];
da.getBytes(8, bytes, bytes.length);
assertEquals(Integer.MAX_VALUE / 3, BitUtil.BIG.toInt(bytes));
da.setBytes(127, bytes, bytes.length);
da.getBytes(127, bytes, bytes.length);
assertEquals(Integer.MAX_VALUE / 3, BitUtil.BIG.toInt(bytes));
da.close();
long bytePos = 4294967296L + 11111;
int segmentSizePower = 24;
int segmentSizeInBytes = 1 << segmentSizePower;
int indexDivisor = segmentSizeInBytes - 1;
int bufferIndex = (int) (bytePos >>> segmentSizePower);
int index = (int) (bytePos & indexDivisor);
assertEquals(256, bufferIndex);
assertEquals(11111, index);
}
@Test
public void testTrimTo() {
DataAccess da = createDataAccess(name);
da.setSegmentSize(128);
da.create(128 * 11);
da.setInt(1 * 4, 10);
da.setInt(27 * 4, 200);
da.setInt(31 * 4, 301);
da.setInt(32 * 4, 302);
da.setInt(337 * 4, 4000);
// now 11 segments: (337 + 1) * 4 = 1352
assertEquals(11, da.getSegments());
assertEquals(11 * 128, da.getCapacity());
// now 3 segments
da.trimTo(128 * 2 + 1);
assertEquals(3, da.getSegments());
// now 2 segments
da.trimTo(128 * 2);
assertEquals(2, da.getSegments());
assertEquals(301, da.getInt(31 * 4));
assertEquals(302, da.getInt(32 * 4));
// now only one segment
da.trimTo(128 * 1);
assertEquals(1, da.getSegments());
assertEquals(301, da.getInt(31 * 4));
// at least one segment
da.trimTo(0);
assertEquals(1, da.getSegments());
da.close();
}
@Test
public void testEnsureCapacity() {
DataAccess da = createDataAccess(name);
da.create(128);
da.setInt(31 * 4, 200);
assertEquals(200, da.getInt(31 * 4));
da.ensureCapacity(2 * 128);
assertEquals(200, da.getInt(31 * 4));
// now it shouldn't fail
da.setInt(32 * 4, 220);
assertEquals(220, da.getInt(32 * 4));
da.close();
// ensure some bigger area
da = createDataAccess(name);
da.create(200 * 4);
da.ensureCapacity(600 * 4);
da.close();
}
@Test
public void testRenameNoFlush() {
DataAccess da = createDataAccess(name);
da.create(100);
da.setInt(17 * 4, 17);
try {
da.rename(name + "wow");
assertTrue(false);
} catch (Exception ex) {
}
da.close();
}
@Test
public void testLoadClose() {
DataAccess da = createDataAccess(name);
da.create(300);
da.setInt(2 * 4, 321);
da.flush();
da.close();
da = createDataAccess(name);
assertTrue(da.loadExisting());
assertEquals(321, da.getInt(2 * 4));
da.close();
}
@Test
public void testRenameFlush() {
DataAccess da = createDataAccess(name);
da.create(100);
da.setInt(17 * 4, 17);
da.flush();
assertTrue(new File(directory + name).exists());
da.rename(name + "wow");
assertFalse(new File(directory + name).exists());
assertTrue(new File(directory + name + "wow").exists());
assertEquals(17, da.getInt(17 * 4));
da.close();
da = createDataAccess(name + "wow");
assertTrue(da.loadExisting());
assertEquals(17, da.getInt(17 * 4));
da.close();
}
@Test
public void testSet_Get_Short_Long() {
DataAccess da = createDataAccess(name);
da.create(300);
da.setShort(6, (short) (Short.MAX_VALUE / 5));
assertEquals(Short.MAX_VALUE / 5, da.getShort(6));
da.setShort(8, (short) (Short.MAX_VALUE / 7));
assertEquals(Short.MAX_VALUE / 7, da.getShort(8));
// currently RAMIntDA does not support arbitrary byte positions
if (!(da instanceof RAMIntDataAccess)) {
da.setShort(7, (short) (Short.MAX_VALUE / 3));
assertEquals(Short.MAX_VALUE / 3, da.getShort(7));
// should be overwritten
assertNotEquals(Short.MAX_VALUE / 3, da.getShort(8));
}
da.close();
}
@Test
public void testHeader() {
DataAccess da = createDataAccess(name);
da.create(300);
da.setHeader(7 * 4, 123);
assertEquals(123, da.getHeader(7 * 4));
da.setHeader(10 * 4, Integer.MAX_VALUE / 3);
assertEquals(Integer.MAX_VALUE / 3, da.getHeader(10 * 4));
da.setHeader(11 * 4, Helper.degreeToInt(123.321));
assertEquals(123.321, Helper.intToDegree(da.getHeader(11 * 4)), 1e-4);
da.flush();
da.close();
da = createDataAccess(name);
assertTrue(da.loadExisting());
assertEquals(123, da.getHeader(7 * 4));
da.close();
}
@Test
public void testSegments() {
DataAccess da = createDataAccess(name);
da.setSegmentSize(128);
da.create(10);
assertEquals(1, da.getSegments());
da.ensureCapacity(500);
int olds = da.getSegments();
assertTrue(olds > 3);
da.setInt(400, 321);
da.flush();
da.close();
da = createDataAccess(name);
assertTrue(da.loadExisting());
assertEquals(olds, da.getSegments());
assertEquals(321, da.getInt(400));
da.close();
}
@Override
public double getEle(double lat, double lon) {
lat = (int) (lat * precision) / precision;
lon = (int) (lon * precision) / precision;
int intKey = calcIntKey(lat, lon);
HeightTile demProvider = cacheData.get(intKey);
if (demProvider == null) {
if (!cacheDir.exists()) cacheDir.mkdirs();
String fileDetails = getFileString(lat, lon);
if (fileDetails == null) return 0;
int minLat = down(lat);
int minLon = down(lon);
demProvider = new HeightTile(minLat, minLon, WIDTH, precision);
cacheData.put(intKey, demProvider);
try {
String zippedURL = baseUrl + "/" + fileDetails + "hgt.zip";
File file = new File(cacheDir, new File(zippedURL).getName());
InputStream is;
// get zip file if not already in cacheDir - unzip later and in-memory only!
if (!file.exists()) {
for (int i = 0; i < 2; i++) {
try {
downloader.downloadFile(zippedURL, file.getAbsolutePath());
break;
} catch (FileNotFoundException ex) {
// now try with point if mirror is used
zippedURL = baseUrl + "/" + fileDetails + ".hgt.zip";
continue;
}
}
}
is = new FileInputStream(file);
ZipInputStream zis = new ZipInputStream(is);
zis.getNextEntry();
BufferedInputStream buff = new BufferedInputStream(zis);
byte[] bytes = new byte[2 * WIDTH * WIDTH];
DataAccess heights = getDirectory().find("dem" + intKey);
heights.create(bytes.length);
demProvider.setHeights(heights);
int len;
while ((len = buff.read(bytes)) > 0) {
for (int bytePos = 0; bytePos < len; bytePos += 2) {
short val = BIT_UTIL.toShort(bytes, bytePos);
if (val < -1000 || val > 10000) {
// TODO fill unassigned gaps with neighbor values -> flood fill algorithm !
// -> calculate mean with an associated weight of how long the distance to the
// neighbor is
// throw new IllegalStateException("Invalid height value "
// + val
// + ", y:" + bytePos / WIDTH + ", x:" + (WIDTH -
// bytePos % WIDTH));
val = Short.MIN_VALUE;
}
heights.setShort(bytePos, val);
}
}
// demProvider.toImage(file.getName() + ".png");
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
short val = demProvider.getHeight(lat, lon);
if (val == Short.MIN_VALUE) return Double.NaN;
return val;
}
@Override
public void create(long initBytes) {
turnCosts.create((long) initBytes * turnCostsEntryBytes);
}
