public void testGetCoordinatesBetween() {
try {
// what if the null value is passed
CoordinateSequence[] cs = nullLine.getCoordinatesBetween(0.0, 5.0);
assertTrue("cs.length = " + cs.length + ". Should be 1", cs.length == 1);
assertEquals(cs[0].size(), 0);
arbitraryLine.measureOnLength(false);
// what if from/to is outside of the range of values
double maxM = arbitraryLine.getMaxM();
cs = arbitraryLine.getCoordinatesBetween(maxM + 1.0, maxM + 10.0);
// check for several ascending M-values
int minIdx = (int) (Math.random() * (arbitraryLine.getNumPoints() - 1));
int maxIdx = Math.min((arbitraryLine.getNumPoints() - 1), minIdx + 10);
double minM = ((MCoordinate) arbitraryLine.getCoordinateN(minIdx)).m;
maxM = ((MCoordinate) arbitraryLine.getCoordinateN(maxIdx)).m;
cs = arbitraryLine.getCoordinatesBetween(minM, maxM);
assertNotNull(cs);
assertTrue(cs.length > 0);
Coordinate[] coar = cs[0].toCoordinateArray();
int j = 0;
for (int i = minIdx; i <= maxIdx; i++) {
assertEquals((MCoordinate) arbitraryLine.getCoordinateN(i), coar[j]);
j++;
}
minM = Math.max(0.0, minM - Math.random() * 10);
cs = arbitraryLine.getCoordinatesBetween(minM, maxM);
coar = cs[0].toCoordinateArray();
MCoordinate mctest = (MCoordinate) coar[0];
MCoordinate mcexp = (MCoordinate) arbitraryLine.getCoordinateAtM(minM);
assertEquals(mcexp, mctest);
assertEquals(mctest.m, minM, DoubleComparator.defaultNumericalPrecision());
maxM = Math.min(arbitraryLine.getLength(), maxM + Math.random() * 10);
cs = arbitraryLine.getCoordinatesBetween(minM, maxM);
coar = cs[0].toCoordinateArray();
mctest = (MCoordinate) coar[coar.length - 1];
mcexp = (MCoordinate) arbitraryLine.getCoordinateAtM(maxM);
assertEquals(mcexp.x, mctest.x, Math.ulp(mcexp.x) * 100);
assertEquals(mcexp.y, mctest.y, Math.ulp(mcexp.y) * 100);
assertEquals(mctest.m, maxM, DoubleComparator.defaultNumericalPrecision());
} catch (Exception e) {
e.printStackTrace();
assertTrue(false); // should never reach here
}
}
public void testGetCoordinateAtM() {
// what if null string
try {
Coordinate mc = nullLine.getCoordinateAtM(2);
assertNull(mc);
// get two neighbouring points along the arbitraryline
arbitraryLine.measureOnLength(false);
int elem1Indx = (int) (Math.random() * (arbitraryLine.getNumPoints() - 1));
int elem2Indx = 0;
if (elem1Indx == arbitraryLine.getNumPoints() - 1) {
elem2Indx = elem1Indx - 1;
} else {
elem2Indx = elem1Indx + 1;
}
// if m is value of a coordinate, the returned coordinate should
// equal that coordinate
MCoordinate mco1 = (MCoordinate) arbitraryLine.getCoordinateN(elem1Indx);
MCoordinate mcotest = (MCoordinate) arbitraryLine.getCoordinateAtM(mco1.m);
assertNotSame(mco1, mcotest);
assertEquals(mco1.x, mcotest.x, Math.ulp(100 * mco1.x));
assertEquals(mco1.y, mcotest.y, Math.ulp(100 * mco1.y));
assertEquals(mco1.m, mcotest.m, Math.ulp(100 * mco1.m));
MCoordinate mco2 = (MCoordinate) arbitraryLine.getCoordinateN(elem2Indx);
double offset = Math.random();
double newM = mco1.m + offset * (mco2.m - mco1.m);
MCoordinate mcexp =
new MCoordinate(
mco1.x + offset * (mco2.x - mco1.x),
mco1.y + offset * (mco2.y - mco1.y),
Double.NaN,
mco1.m + offset * (mco2.m - mco1.m));
MCoordinate mctest = (MCoordinate) arbitraryLine.getCoordinateAtM(newM);
assertEquals(mcexp.x, mctest.x, 0.0001);
assertEquals(mcexp.y, mctest.y, 0.0001);
assertEquals(mcexp.m, mctest.m, 0.0001);
} catch (Exception e) {
System.err.println(e);
}
}
public void testmeasureOnLength() {
arbitraryLine.measureOnLength(false);
double maxM = arbitraryLine.getMaxM();
double minM = arbitraryLine.getMinM();
assertEquals(maxM, arbitraryLine.getLength(), DoubleComparator.defaultNumericalPrecision());
assertEquals(minM, 0.0d, DoubleComparator.defaultNumericalPrecision());
MCoordinate mco = (MCoordinate) arbitraryLine.getCoordinateN(arbitraryLine.getNumPoints() - 1);
assertEquals(mco.m, maxM, DoubleComparator.defaultNumericalPrecision());
mco = (MCoordinate) arbitraryLine.getCoordinateN(0);
assertEquals(mco.m, minM, DoubleComparator.defaultNumericalPrecision());
}
public void testReverseMeasures() {
nullLine.reverseMeasures();
arbitraryLine.measureOnLength(false);
arbitraryLine.reverseMeasures();
assertTrue(arbitraryLine.getMeasureDirection() == MGeometry.DECREASING);
double mlast = arbitraryLine.getMatN(arbitraryLine.getNumPoints() - 1);
arbitraryLine.reverseMeasures();
assertTrue(arbitraryLine.getMeasureDirection() == MGeometry.INCREASING);
double mfirst = arbitraryLine.getMatN(0);
assertEquals(mlast, mfirst, DoubleComparator.defaultNumericalPrecision());
}
public void testGetMatCoordinate() {
try {
// what in case of the null string
assertTrue(Double.isNaN(nullLine.getMatCoordinate(new Coordinate(1.0, 1.0), 1.0)));
// get two neighbouring points along the arbitraryline
arbitraryLine.measureOnLength(false);
int elem1Indx = (int) (Math.random() * (arbitraryLine.getNumPoints() - 1));
int elem2Indx = 0;
if (elem1Indx == arbitraryLine.getNumPoints() - 1) {
elem2Indx = elem1Indx - 1;
} else {
elem2Indx = elem1Indx + 1;
}
// if a coordinate of the geometry is passed, it should return
// exactly that m-value
MCoordinate mco1 = (MCoordinate) arbitraryLine.getCoordinateN(elem1Indx);
double m = arbitraryLine.getMatCoordinate(mco1, 0.00001);
assertEquals(mco1.m, m, DoubleComparator.defaultNumericalPrecision());
// check for a coordinate between mco1 and mco2 (neighbouring
// coordinates)
MCoordinate mco2 = (MCoordinate) arbitraryLine.getCoordinateN(elem2Indx);
double offset = Math.random();
double expectedM = mco1.m + offset * (mco2.m - mco1.m);
Coordinate mctest =
new Coordinate(mco1.x + offset * (mco2.x - mco1.x), mco1.y + offset * (mco2.y - mco1.y));
double testM = arbitraryLine.getMatCoordinate(mctest, offset);
assertEquals(expectedM, testM, DoubleComparator.defaultNumericalPrecision());
} catch (Exception e) {
e.printStackTrace();
assertTrue(false); // should never reach here
}
}
public void testGetMeasureDirection() {
assertTrue(nullLine.isMonotone(false));
assertTrue(
arbitraryLine.isMonotone(false)
|| (!arbitraryLine.isMonotone(false)
&& arbitraryLine.getMeasureDirection() == MGeometry.NON_MONOTONE));
arbitraryLine.measureOnLength(false);
assertEquals(MGeometry.INCREASING, arbitraryLine.getMeasureDirection());
arbitraryLine.reverseMeasures();
assertEquals(MGeometry.DECREASING, arbitraryLine.getMeasureDirection());
for (int i = 0; i < arbitraryLine.getNumPoints(); i++) {
arbitraryLine.setMeasureAtIndex(i, 0.0);
}
assertEquals(MGeometry.CONSTANT, arbitraryLine.getMeasureDirection());
}
public void testGetClosestPoint() {
try {
if (!arbitraryLine.isMonotone(false)) {
Coordinate mc = arbitraryLine.getClosestPoint(new Coordinate(1.0, 2.0), 0.1);
assertTrue(false); // should never evaluate this
}
} catch (Exception e) {
assertTrue(
((MGeometryException) e).getType() == MGeometryException.OPERATION_REQUIRES_MONOTONE);
}
try {
// check reaction on null string
MCoordinate mc = nullLine.getClosestPoint(new Coordinate(0.0, 1.0), 1.0);
assertNull(mc);
// must return the very same coordinate if the coordinate is a
// coordinate of the line
arbitraryLine.measureOnLength(false);
int selp = (int) (arbitraryLine.getNumPoints() / 2);
MCoordinate mcexp = (MCoordinate) arbitraryLine.getCoordinateN(selp);
MCoordinate mctest = arbitraryLine.getClosestPoint(mcexp, 1);
assertEquals(mcexp, mctest);
// must not return a point that is beyond the tolerance
mctest = controlledLine.getClosestPoint(new Coordinate(20.0, 20, 0), 1.0);
assertNull(mctest);
// check for cases of circular MGeometry: lowest measure should be
// return.
ringLine.measureOnLength(false);
assertTrue(ringLine.isRing());
assertTrue(ringLine.isMonotone(false));
assertTrue(ringLine.getMeasureDirection() == MGeometry.INCREASING);
MCoordinate expCo = MCoordinate.create2dWithMeasure(0.0, 0.0, 0.0);
MCoordinate testCo = ringLine.getClosestPoint(expCo, 0.1);
assertTrue(DoubleComparator.equals(testCo.m, expCo.m));
ringLine.reverseMeasures();
testCo = ringLine.getClosestPoint(expCo, 0.1);
assertTrue(DoubleComparator.equals(testCo.m, expCo.m));
ringLine.measureOnLength(false);
int n = ringLine.getNumPoints() - 1;
ringLine.setMeasureAtIndex(n, 100.0);
ringLine.setMeasureAtIndex(0, 0.0);
testCo = ringLine.getClosestPoint(expCo, 0.001);
assertTrue(DoubleComparator.equals(testCo.m, 0.0));
// get two neighbouring points along the arbitraryline
arbitraryLine.measureOnLength(false);
int elem1Indx = (int) (Math.random() * (arbitraryLine.getNumPoints() - 1));
int elem2Indx = 0;
if (elem1Indx == arbitraryLine.getNumPoints() - 1) {
elem2Indx = elem1Indx - 1;
} else {
elem2Indx = elem1Indx + 1;
}
// testsuite-suite whether a coordinate between these two returns exactly
MCoordinate mco1 = (MCoordinate) arbitraryLine.getCoordinateN(elem1Indx);
MCoordinate mco2 = (MCoordinate) arbitraryLine.getCoordinateN(elem2Indx);
double d = mco1.distance(mco2);
double offset = Math.random();
mcexp =
MCoordinate.create2dWithMeasure(
mco1.x + offset * (mco2.x - mco1.x), mco1.y + offset * (mco2.y - mco1.y), 0.0);
mctest = arbitraryLine.getClosestPoint(mcexp, d);
mcexp.m = mco1.m + offset * (mco2.m - mco1.m);
assertEquals(mcexp.x, mctest.x, 0.001);
assertEquals(mcexp.y, mctest.y, 0.001);
assertEquals(mcexp.z, mctest.z, 0.001);
double delta = Math.random();
MCoordinate mcin =
MCoordinate.create2dWithMeasure(
mco1.x + offset * (mco2.x - mco1.x) + delta,
mco1.y + offset * (mco2.y - mco1.y) + delta,
0.0);
// returned point is on the line
mctest = arbitraryLine.getClosestPoint(mcin, d);
assertEquals(mcin.x, mctest.x, delta * Math.sqrt(2));
assertEquals(mcin.y, mctest.y, delta * Math.sqrt(2));
} catch (Exception e) {
e.printStackTrace();
assertTrue(false); // should never reach this point
}
}