use of net.imglib2.RandomAccessible in project imagej-ops by imagej.
the class AddDimensionViewTest method addDimensionTest.
@Test
public void addDimensionTest() {
Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[] { 10, 10 }, new DoubleType());
MixedTransformView<DoubleType> il2 = Views.addDimension((RandomAccessible<DoubleType>) img);
MixedTransformView<DoubleType> opr = ops.transform().addDimensionView((RandomAccessible<DoubleType>) img);
assertEquals(il2.numDimensions(), opr.numDimensions());
boolean[] il2Transform = new boolean[3];
boolean[] oprTransform = new boolean[3];
il2.getTransformToSource().getComponentZero(il2Transform);
opr.getTransformToSource().getComponentZero(oprTransform);
for (int i = 0; i < il2Transform.length; i++) {
assertEquals(il2Transform[i], oprTransform[i]);
}
}
use of net.imglib2.RandomAccessible in project imagej-ops by imagej.
the class CollapseNumericViewTest method defaultCollapseNumericTest.
@Test
public void defaultCollapseNumericTest() {
Img<NativeARGBDoubleType> img = new ArrayImgFactory<NativeARGBDoubleType>().create(new int[] { 10, 10 }, new NativeARGBDoubleType());
CompositeIntervalView<NativeARGBDoubleType, NumericComposite<NativeARGBDoubleType>> il2 = Views.collapseNumeric((RandomAccessibleInterval<NativeARGBDoubleType>) img);
CompositeIntervalView<NativeARGBDoubleType, NumericComposite<NativeARGBDoubleType>> opr = ops.transform().collapseNumericView((RandomAccessibleInterval<NativeARGBDoubleType>) img);
assertEquals(il2.numDimensions(), opr.numDimensions());
CompositeView<NativeARGBDoubleType, NumericComposite<NativeARGBDoubleType>> il2_2 = Views.collapseNumeric((RandomAccessible<NativeARGBDoubleType>) img, 1);
CompositeView<NativeARGBDoubleType, NumericComposite<NativeARGBDoubleType>> opr_2 = ops.transform().collapseNumericView((RandomAccessible<NativeARGBDoubleType>) img, 1);
assertEquals(il2_2.numDimensions(), opr_2.numDimensions());
}
use of net.imglib2.RandomAccessible in project imagej-ops by imagej.
the class CollapseRealViewTest method defaultCollapseRealTest.
@Test
public void defaultCollapseRealTest() {
Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[] { 10, 10 }, new DoubleType());
CompositeIntervalView<DoubleType, RealComposite<DoubleType>> il2 = Views.collapseReal((RandomAccessibleInterval<DoubleType>) img);
CompositeIntervalView<DoubleType, RealComposite<DoubleType>> opr = ops.transform().collapseRealView((RandomAccessibleInterval<DoubleType>) img);
assertEquals(il2.numDimensions(), opr.numDimensions());
CompositeView<DoubleType, RealComposite<DoubleType>> il2_2 = Views.collapseReal((RandomAccessible<DoubleType>) img, 1);
CompositeView<DoubleType, RealComposite<DoubleType>> opr_2 = ops.transform().collapseRealView((RandomAccessible<DoubleType>) img, 1);
assertEquals(il2_2.numDimensions(), opr_2.numDimensions());
}
use of net.imglib2.RandomAccessible in project imagej-ops by imagej.
the class CollapseViewTest method collapseRATest.
@Test
public void collapseRATest() {
Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[] { 10, 10, 10 }, new DoubleType());
CompositeView<DoubleType, ? extends GenericComposite<DoubleType>> il2 = Views.collapse((RandomAccessible<DoubleType>) img);
CompositeView<DoubleType, ? extends GenericComposite<DoubleType>> opr = ops.transform().collapseView((RandomAccessible<DoubleType>) img);
assertEquals(il2.numDimensions(), opr.numDimensions());
}
use of net.imglib2.RandomAccessible in project imagej-ops by imagej.
the class Watershed method compute.
@Override
public void compute(final RandomAccessibleInterval<T> in, final ImgLabeling<Integer, IntType> out) {
final RandomAccess<T> raIn = in.randomAccess();
RandomAccess<B> raMask = null;
if (mask != null) {
raMask = mask.randomAccess();
}
// stores the size of each dimension
final long[] dimensSizes = new long[in.numDimensions()];
in.dimensions(dimensSizes);
// calculates the number of points in the n-d space
long numPixels = Intervals.numElements(in);
// the pixels indices are stored in an array, which is sorted depending
// on the pixel values
final List<Long> imiList = new ArrayList<>();
if (mask != null) {
final Cursor<Void> c = Regions.iterable(mask).localizingCursor();
while (c.hasNext()) {
c.next();
imiList.add(IntervalIndexer.positionToIndex(c, in));
}
} else {
for (long i = 0; i < numPixels; i++) {
imiList.add(i);
}
}
final Long[] imi = imiList.toArray(new Long[imiList.size()]);
/*
* Sort the pixels of imi in the increasing order of their grey value
* (only the pixel indices are stored)
*/
Arrays.sort(imi, new Comparator<Long>() {
@Override
public int compare(final Long o1, final Long o2) {
IntervalIndexer.indexToPosition(o1, in, raIn);
final T value = raIn.get().copy();
IntervalIndexer.indexToPosition(o2, in, raIn);
return value.compareTo(raIn.get());
}
});
// lab and dist store the values calculated after each phase
final RandomAccessibleInterval<IntType> lab = ops().create().img(in, new IntType());
// extend border to be able to do a quick check, if a voxel is inside
final ExtendedRandomAccessibleInterval<IntType, RandomAccessibleInterval<IntType>> labExt = Views.extendBorder(lab);
final OutOfBounds<IntType> raLab = labExt.randomAccess();
final RandomAccessibleInterval<IntType> dist = ops().create().img(in, new IntType());
final RandomAccess<IntType> raDist = dist.randomAccess();
// initial values
for (final IntType pixel : Views.flatIterable(lab)) {
pixel.set(INIT);
}
int current_label = 0;
int current_dist;
final ArrayList<Long> fifo = new ArrayList<>();
// RandomAccess for Neighborhoods
final Shape shape;
if (useEightConnectivity) {
shape = new RectangleShape(1, true);
} else {
shape = new DiamondShape(1);
}
final RandomAccessible<Neighborhood<T>> neighborhoods = shape.neighborhoodsRandomAccessible(in);
final RandomAccess<Neighborhood<T>> raNeighbor = neighborhoods.randomAccess();
/*
* Start flooding
*/
for (int j = 0; j < imi.length; j++) {
IntervalIndexer.indexToPosition(imi[j], in, raIn);
final T actualH = raIn.get().copy();
int i = j;
while (actualH.compareTo(raIn.get()) == 0) {
final long p = imi[i];
IntervalIndexer.indexToPosition(p, in, raIn);
raLab.setPosition(raIn);
raLab.get().set(MASK);
raNeighbor.setPosition(raIn);
final Cursor<T> neighborHood = raNeighbor.get().cursor();
while (neighborHood.hasNext()) {
neighborHood.fwd();
raLab.setPosition(neighborHood);
if (!raLab.isOutOfBounds()) {
final int f = raLab.get().get();
if ((f > 0) || (f == WSHED)) {
raDist.setPosition(raIn);
raDist.get().set(1);
fifo.add(p);
break;
}
}
}
i++;
if (i == imi.length) {
break;
}
IntervalIndexer.indexToPosition(imi[i], in, raIn);
}
current_dist = 1;
// add fictitious pixel
fifo.add(-1l);
while (true) {
long p = fifo.remove(0);
if (p == -1) {
if (fifo.isEmpty()) {
break;
}
fifo.add(-1l);
current_dist++;
p = fifo.remove(0);
}
IntervalIndexer.indexToPosition(p, in, raNeighbor);
final Cursor<T> neighborHood = raNeighbor.get().cursor();
raLab.setPosition(raNeighbor);
int labp = raLab.get().get();
final long[] posNeighbor = new long[neighborHood.numDimensions()];
while (neighborHood.hasNext()) {
neighborHood.fwd();
neighborHood.localize(posNeighbor);
raLab.setPosition(posNeighbor);
if (!raLab.isOutOfBounds()) {
raDist.setPosition(posNeighbor);
final int labq = raLab.get().get();
final int distq = raDist.get().get();
if ((distq < current_dist) && ((labq > 0) || (labq == WSHED))) {
// the watersheds
if (labq > 0) {
if ((labp == MASK) || (labp == WSHED)) {
labp = labq;
} else {
if (labp != labq) {
labp = WSHED;
}
}
} else {
if (labp == MASK) {
labp = WSHED;
}
}
raLab.setPosition(raNeighbor);
raLab.get().set(labp);
} else {
if ((labq == MASK) && (distq == 0)) {
raDist.setPosition(posNeighbor);
raDist.get().set(current_dist + 1);
fifo.add(IntervalIndexer.positionToIndex(posNeighbor, dimensSizes));
}
}
}
}
}
// checks if new minima have been discovered
IntervalIndexer.indexToPosition(imi[j], in, raIn);
i = j;
while (actualH.compareTo(raIn.get()) == 0) {
final long p = imi[i];
IntervalIndexer.indexToPosition(p, dist, raDist);
// the distance associated with p is reseted to 0
raDist.get().set(0);
raLab.setPosition(raDist);
if (raLab.get().get() == MASK) {
current_label++;
fifo.add(p);
raLab.get().set(current_label);
while (!fifo.isEmpty()) {
final long q = fifo.remove(0);
IntervalIndexer.indexToPosition(q, in, raNeighbor);
final Cursor<T> neighborHood = raNeighbor.get().cursor();
final long[] posNeighbor = new long[neighborHood.numDimensions()];
while (neighborHood.hasNext()) {
neighborHood.fwd();
neighborHood.localize(posNeighbor);
raLab.setPosition(posNeighbor);
if (!raLab.isOutOfBounds()) {
final long r = IntervalIndexer.positionToIndex(posNeighbor, dimensSizes);
if (raLab.get().get() == MASK) {
fifo.add(r);
raLab.get().set(current_label);
}
}
}
}
}
i++;
if (i == imi.length) {
break;
}
IntervalIndexer.indexToPosition(imi[i], in, raIn);
}
j = i - 1;
}
/*
* Draw output and remove as the case may be the watersheds
*/
final Cursor<LabelingType<Integer>> cursorOut = out.cursor();
while (cursorOut.hasNext()) {
cursorOut.fwd();
boolean maskValue = true;
if (mask != null) {
raMask.setPosition(cursorOut);
if (!raMask.get().get()) {
maskValue = false;
}
}
raLab.setPosition(cursorOut);
if (!maskValue) {
cursorOut.get().clear();
} else {
if (!drawWatersheds && raLab.get().get() == WSHED) {
raNeighbor.setPosition(cursorOut);
final Cursor<T> neighborHood = raNeighbor.get().cursor();
int newLab = WSHED;
while (neighborHood.hasNext()) {
neighborHood.fwd();
raLab.setPosition(neighborHood);
if (!raLab.isOutOfBounds()) {
newLab = raLab.get().get();
if (newLab > WSHED) {
break;
}
}
}
if (newLab == WSHED) {
cursorOut.get().clear();
} else {
cursorOut.get().add(newLab);
}
} else {
cursorOut.get().add(raLab.get().get());
}
}
}
/*
* Merge already present labels before calculation of watershed
*/
if (out() != null) {
final Cursor<LabelingType<Integer>> cursor = out().cursor();
final RandomAccess<LabelingType<Integer>> raOut = out.randomAccess();
while (cursor.hasNext()) {
cursor.fwd();
raOut.setPosition(cursor);
final List<Integer> labels = new ArrayList<>();
cursor.get().iterator().forEachRemaining(labels::add);
raOut.get().addAll(labels);
}
}
}
Aggregations