@Test
public void testCrossNeighborhoodProduct() {
Img<DoubleType> inputImg = makeInputImage();
/* old way
DiscreteNeigh neigh = new DiscreteNeigh(new long[2], new long[]{1,1}, new long[]{1,1});
Condition<long[]> condition = new OnTheXYCrossCondition();
Function<long[],DoubleType> input = new RealImageFunction<DoubleType,DoubleType>(inputImg, new DoubleType());
Function<long[],DoubleType> one = new ConstantRealFunction<long[],DoubleType>(inputImg.firstElement(),1);
Function<long[],DoubleType> conditionalFunc = new ConditionalFunction<long[],DoubleType>(condition, input, one);
Function<long[],DoubleType> prodFunc = new RealProductFunction<DoubleType>(conditionalFunc);
long[] index = new long[2];
DoubleType output = new DoubleType();
for (int x = 1; x < XSIZE-1; x++) {
for (int y = 1; y < YSIZE-1; y++) {
index[0] = x;
index[1] = y;
neigh.moveTo(index);
prodFunc.evaluate(neigh, neigh.getKeyPoint(), output);
//{
// System.out.println(" FAILURE at ("+x+","+y+"): expected ("
// +expectedValue(x,y)+") actual ("+output.getRealDouble()+")");
// success = false;
//}
assertTrue(veryClose(output.getRealDouble(), expectedValue(x,y)));
}
}
*/
ArrayList<long[]> pts = new ArrayList<long[]>();
pts.add(new long[] {-1, -1});
pts.add(new long[] {-1, 1});
pts.add(new long[] {0, 0});
pts.add(new long[] {1, -1});
pts.add(new long[] {1, 1});
GeneralPointSet neigh = new GeneralPointSet(new long[] {0, 0}, pts);
Function<long[], DoubleType> input =
new RealImageFunction<DoubleType, DoubleType>(inputImg, new DoubleType());
Function<PointSet, DoubleType> prodFunc = new RealProductFunction<DoubleType>(input);
HyperVolumePointSet space =
new HyperVolumePointSet(new long[] {1, 1}, new long[] {XSIZE - 2, YSIZE - 2});
PointSetInputIterator iter = new PointSetInputIterator(space, neigh);
DoubleType output = new DoubleType();
PointSet points = null;
while (iter.hasNext()) {
points = iter.next(points);
prodFunc.compute(points, output);
int x = (int) points.getOrigin()[0];
int y = (int) points.getOrigin()[1];
// {
// System.out.println(" Point ("+x+","+y+"): expected ("
// +expectedValue(x,y)+") actual ("+output.getRealDouble()+")");
// success = false;
// }
assertTrue(veryClose(output.getRealDouble(), expectedValue(x, y)));
}
}
/** Tests {@link OpService#run(Op, Object...)}. */
@Test
public void testRunByOp() {
final DoubleType value = new DoubleType(123.456);
assertFalse(Double.isInfinite(value.get()));
final Object result = ops.run(new InfinityOp(), value);
assertSame(value, result);
assertTrue(Double.isInfinite(value.get()));
}
/** Tests {@link OpService#op(String, Object...)}. */
@Test
public void testOpByName() {
final DoubleType value = new DoubleType(123.456);
final Op op = ops.op("test.infinity", value);
assertSame(InfinityOp.class, op.getClass());
assertFalse(Double.isInfinite(value.get()));
op.run();
assertTrue(Double.isInfinite(value.get()));
}
/** Tests {@link OpService#module(Class, Object...)}. */
@Test
public void testModuleByType() {
final DoubleType value = new DoubleType(123.456);
final Module module = ops.module(InfinityOp.class, value);
assertSame(value, module.getInput("arg"));
assertFalse(Double.isInfinite(value.get()));
module.run();
assertTrue(Double.isInfinite(value.get()));
}
@Override
public void compute(final IterableInterval<T> input, final DoubleType output) {
final double[][] matrix = getCooccurrenceMatrix(input);
final double[] pxplusy = coocPXPlusYFunc.compute(matrix);
final int nrGrayLevels = matrix.length;
final double average = sumAverageFunc.compute(input).getRealDouble();
double res = 0;
for (int i = 2; i <= 2 * nrGrayLevels; i++) {
res += (i - average) * (i - average) * pxplusy[i];
}
output.set(res);
}
/** Tests {@link OpService#run(String, Object...)}. */
@Test
public void testAliases() {
final DoubleType value = new DoubleType(123.456);
assertFalse(Double.isInfinite(value.get()));
final Object result = ops.run("infin", value);
assertSame(value, result);
assertTrue(Double.isInfinite(value.get()));
value.set(0.0);
assertFalse(Double.isInfinite(value.get()));
final Object result2 = ops.run("inf", value);
assertSame(value, result2);
assertTrue(Double.isInfinite(value.get()));
value.set(0.0);
boolean noSuchAlias = false;
try {
ops.run("infini", value);
} catch (final IllegalArgumentException exc) {
noSuchAlias = true;
}
assertTrue(noSuchAlias);
}
private double measure(final Function<PointSet, DoubleType> func, final PointSet region) {
final DoubleType output = new DoubleType();
func.compute(region, output);
return output.getRealDouble();
}
@Override
public void compute(final DoubleType arg) {
arg.set(Double.POSITIVE_INFINITY);
}
@Override
public void compute(long[] input, DoubleType output) {
output.setReal(input[position]);
}