net.imglib2.converter.Converter Java Examples

@Override
public void compute(final I center,
	final RectangleNeighborhood<Composite<DoubleType>> neighborhood,
	final BitType output)
{

	final DoubleType sum = new DoubleType();
	integralMean.compute(neighborhood, sum);

	// Subtract the contrast
	sum.sub(new DoubleType(c));

	// Set value
	final Converter<I, DoubleType> conv = new RealDoubleConverter<>();
	final DoubleType centerPixelAsDoubleType = new DoubleType();
	conv.convert(center, centerPixelAsDoubleType);

	output.set(centerPixelAsDoubleType.compareTo(sum) > 0);
}
 

public ConvertedDataSource(
		final DataSource<D, T> source,
		final Converter<D, U> dataTypeConverter,
		final Converter<T, V> typeConverter,
		final Supplier<U> dataTypeSupplier,
		final Supplier<V> typeSupplier,
		final Function<Interpolation, InterpolatorFactory<U, RandomAccessible<U>>> dataInterpolation,
		final Function<Interpolation, InterpolatorFactory<V, RandomAccessible<V>>> interpolation,
		final String name)
{
	super();
	this.source = source;
	this.dataTypeConverter = dataTypeConverter;
	this.typeConverter = typeConverter;
	this.dataTypeExtensionSupplier = dataTypeSupplier;
	this.typeExtensionSupplier = typeSupplier;
	this.dataInterpolation = dataInterpolation;
	this.interpolation = interpolation;
	this.name = name;
}
 

@Override
public void compute(final I center,
	final RectangleNeighborhood<Composite<DoubleType>> neighborhood,
	final BitType output)
{

	final DoubleType mean = new DoubleType();
	integralMean.compute(neighborhood, mean);

	final DoubleType variance = new DoubleType();
	integralVariance.compute(neighborhood, variance);

	final DoubleType stdDev = new DoubleType(Math.sqrt(variance.get()));

	final DoubleType threshold = new DoubleType(mean.getRealDouble() * (1.0d +
		p * Math.exp(-q * mean.getRealDouble()) + k * ((stdDev.getRealDouble() /
			r) - 1.0)));

	// Set value
	final Converter<I, DoubleType> conv = new RealDoubleConverter<>();
	final DoubleType centerPixelAsDoubleType = variance; // NB: Reuse
	// DoubleType
	conv.convert(center, centerPixelAsDoubleType);

	output.set(centerPixelAsDoubleType.compareTo(threshold) > 0);
}
 

private static <D extends NativeType<D> & RealType<D>, T extends RealType<T>> RealComposite<T>  createExtension(
		final D d,
		final T t,
		final Converter<D, T> converter,
		final long size,
		IntFunction<D> valueAtIndex
)
{
	LOG.debug("Creating extension with size {}", size);
	final ArrayImg<D, ?> img = new ArrayImgFactory<>(d).create(1, size);
	img.setLinkedType((D) d.getNativeTypeFactory().createLinkedType((NativeImg)img));
	final CompositeIntervalView<D, RealComposite<D>> collapsed = Views.collapseReal(img);
	RealComposite<D> extensionCopy = collapsed.randomAccess().get();
	for (int channel = 0; channel < size; ++channel)
		extensionCopy.get(channel).set(valueAtIndex.apply(channel));
	return Views.collapseReal(Converters.convert((RandomAccessibleInterval<D>)img, converter, t.createVariable())).randomAccess().get();
}
 

@Override
public void compute(final I center,
	final RectangleNeighborhood<Composite<DoubleType>> neighborhood,
	final BitType output)
{

	final DoubleType mean = new DoubleType();
	integralMean.compute(neighborhood, mean);

	final DoubleType variance = new DoubleType();
	integralVariance.compute(neighborhood, variance);

	final DoubleType stdDev = new DoubleType(Math.sqrt(variance.get()));

	final DoubleType threshold = new DoubleType(mean.getRealDouble() * (1.0d +
		k * ((Math.sqrt(stdDev.getRealDouble()) / r) - 1.0)));

	// Set value
	final Converter<I, DoubleType> conv = new RealDoubleConverter<>();
	final DoubleType centerPixelAsDoubleType = variance; // NB: Reuse
	// DoubleType
	conv.convert(center, centerPixelAsDoubleType);

	output.set(centerPixelAsDoubleType.compareTo(threshold) > 0);
}
 

public VolatileHierarchyProjectorPreMultiply(
		final List<? extends RandomAccessible<A>> sources,
		final Converter<? super A, ARGBType> converter,
		final RandomAccessibleInterval<ARGBType> target,
		final int numThreads,
		final ExecutorService executorService)
{
	this(
			sources,
			converter,
			target,
			ArrayImgs.bytes(Intervals.dimensionsAsLongArray(target)),
			numThreads,
			executorService
	    );
}
 

public static <T, B extends BooleanType<B>> BiFunction<TLongHashSet, Double, Converter<T, B>> create(
		final DataSource<T, ?> source,
		final int level)
{
	final T t = source.getDataType();

	if (t instanceof LabelMultisetType)
		return new LabelMultisetTypeMaskGenerator(source, level);

	if (t instanceof IntegerType<?>)
	{
		final IntegerTypeMaskGenerator integerTypeMaskGenerator = new IntegerTypeMaskGenerator();
		return (l, minLabelRatio) -> integerTypeMaskGenerator.apply(l);
	}

	return null;
}
 

public AbstractMeshCacheLoader(
		final Supplier<RandomAccessibleInterval<T>> data,
		final BiFunction<K, Double, Converter<T, BoolType>> getMaskGenerator,
		final AffineTransform3D transform)
{
	super();
	LOG.debug("Constructiong {}", getClass().getName());
	this.data = data;
	this.getMaskGenerator = getMaskGenerator;
	this.transform = transform;
}
 

private static <D extends NativeType<D> & RealType<D>, T extends RealType<T>> RealComposite<T>  createExtension(
		final D d,
		final T t,
		final Converter<D, T> converter,
		final long size
) {
	return createExtension(d, t, converter, size, channel -> d);
}
 

private static <D extends NativeType<D> & RealType<D>, T extends RealType<T>> RealComposite<T>  copyExtension(
		final RealComposite<D> extension,
		final T t,
		final Converter<D, T> converter,
		final long size
)
{
	return createExtension(extension.get(0).createVariable(), t, converter, size, extension::get);
}
 

public SegmentMeshCacheLoader(
		final Supplier<RandomAccessibleInterval<T>> data,
		final BiFunction<TLongHashSet, Double, Converter<T, BoolType>> getMaskGenerator,
		final AffineTransform3D transform)
{
	super(data, getMaskGenerator, transform);
}
 

@Override
public Converter<LabelMultisetType, B> apply(final TLongHashSet validLabels, final Double minLabelRatio)
{
	return minLabelRatio == null || minLabelRatio == 0.0
			? new LabelMultisetTypeMask<>(validLabels)
			: new LabelMultisetTypeMaskWithMinLabelRatio<>(validLabels, minLabelRatio, numFullResPixels);
}
 

@Override
public void initialize() {
	es = ts.getExecutorService();

	createOp = Functions.unary(ops(), CreateImgFromDimsAndType.class, RandomAccessibleInterval.class,
			new FinalInterval(in().dimension(0), in().dimension(1), numOrientations), new FloatType());

	createImgOp = Functions.unary(ops(), CreateImgFromDimsAndType.class, RandomAccessibleInterval.class,
			new FinalInterval(in().dimension(0), in().dimension(1)), new FloatType());

	converterToFloat = new Converter<T, FloatType>() {
		@Override
		public void convert(final T arg0, final FloatType arg1) {
			arg1.setReal(arg0.getRealFloat());
		}
	};

	converterGetMax = new Converter<GenericComposite<FloatType>, FloatType>() {
		@Override
		public void convert(GenericComposite<FloatType> input, FloatType output) {
			int idx = 0;
			float max = 0;
			for (int i = 0; i < in().dimension(2); i++) {
				if (Math.abs(input.get(i).getRealFloat()) > max) {
					max = Math.abs(input.get(i).getRealFloat());
					idx = i;
				}
			}
			output.setReal(input.get(idx).getRealFloat());
		}
	};
}
 

public ConvertedRandomAccessibleInterval(final RandomAccessibleInterval<A> source, final Converter<? super A, ?
		super B> converter, final Supplier<B> b)
{
	super(source);
	this.converter = converter;
	this.supplier = b;
}
 

@Override
public void compute(final I center,
	final RectangleNeighborhood<Composite<DoubleType>> neighborhood,
	final BitType output)
{

	final DoubleType threshold = new DoubleType(0.0d);

	final DoubleType mean = new DoubleType();
	integralMean.compute(neighborhood, mean);

	threshold.add(mean);

	final DoubleType variance = new DoubleType();
	integralVariance.compute(neighborhood, variance);

	final DoubleType stdDev = new DoubleType(Math.sqrt(variance.get()));
	stdDev.mul(k);

	threshold.add(stdDev);

	// Subtract the contrast
	threshold.sub(new DoubleType(c));

	// Set value
	final Converter<I, DoubleType> conv = new RealDoubleConverter<>();
	final DoubleType centerPixelAsDoubleType = variance; // NB: Reuse
	// DoubleType
	conv.convert(center, centerPixelAsDoubleType);

	output.set(centerPixelAsDoubleType.compareTo(threshold) > 0);
}
 

public LabelSourceStatePaintHandler(
		final MaskedSource<T, ?> source,
		final FragmentSegmentAssignment fragmentSegmentAssignment,
		final BooleanSupplier isVisible,
		final Consumer<FloodFillState> floodFillStateUpdate,
		final SelectedIds selectedIds,
		final LongFunction<Converter<T, BoolType>> maskForLabel) {
	this.source = source;
	this.fragmentSegmentAssignment = fragmentSegmentAssignment;
	this.isVisible = isVisible;
	this.floodFillStateUpdate = floodFillStateUpdate;
	this.selectedIds = selectedIds;
	this.maskForLabel = maskForLabel;
}
 

@SuppressWarnings({"unchecked", "rawtypes"})
private static <D> LongFunction<Converter<D, BoolType>> equalsMaskForType(final D d)
{
	if (d instanceof LabelMultisetType) { return (LongFunction) equalMaskForLabelMultisetType(); }

	if (d instanceof IntegerType<?>) { return (LongFunction) equalMaskForIntegerType(); }

	if (d instanceof RealType<?>) { return (LongFunction) equalMaskForRealType(); }

	return null;
}
 

@Override
public Iterator<LabelMultisetType> iterator() {
	return new Iterator<LabelMultisetType>() {

		final Iterator<? extends Pair<LabelMultisetType, UnsignedLongType>> iterator = backgroundAndCanvas.iterator();

		final Converter<UnsignedLongType, LabelMultisetType> conv = new FromIntegerTypeConverter<>();

		final LabelMultisetType type = FromIntegerTypeConverter.getAppropriateType();

		@Override
		public boolean hasNext() {
			return iterator.hasNext();
		}

		@Override
		public LabelMultisetType next() {
			final Pair<LabelMultisetType, UnsignedLongType> p = iterator.next();
			final UnsignedLongType b = p.getB();
			if (Label.regular(b.getIntegerLong())) {
				conv.convert(b, type);
				return type;
			} else
				return p.getA();
		}
	};
}
 

public RestrictPainting(
		final ViewerPanelFX viewer,
		final SourceInfo sourceInfo,
		final Runnable requestRepaint,
		final LongFunction<Converter<?, BoolType>> maskForLabel)
{
	super();
	this.viewer = viewer;
	this.sourceInfo = sourceInfo;
	this.requestRepaint = requestRepaint;
	this.maskForLabel = maskForLabel;
}
 

@SuppressWarnings({"unchecked", "rawtypes"})
@Override
protected MinimalSourceState<?, ?, ?, Converter<?, ARGBType>> makeState(
		final JsonObject map,
		final DataSource<?, ?> source,
		final Composite<ARGBType, ARGBType> composite,
		final Converter<?, ARGBType> converter,
		final String name,
		final SourceState<?, ?>[] dependsOn,
		final JsonDeserializationContext context) throws ClassNotFoundException
{
	return new MinimalSourceState(source, converter, composite, name, dependsOn);
}
 

SimpleVolatileProjector(
		final RandomAccessible<A> source,
		final Converter<? super A, ARGBType> converter,
		final RandomAccessibleInterval<ARGBType> target,
		final int numThreads,
		final ExecutorService executorService)
{
	super(source, converter, target, numThreads, executorService);
}
 

public VolatileHierarchyProjector(
		final List< ? extends RandomAccessible< A > > sources,
		final Converter< ? super A, B > converter,
		final RandomAccessibleInterval< B > target,
		final RandomAccessibleInterval< ByteType > mask,
		final int numThreads,
		final ExecutorService executorService )
{
	super( Math.max( 2, sources.get( 0 ).numDimensions() ), converter, target );

	this.sources.addAll( sources );
	numInvalidLevels = sources.size();

	this.mask = mask;

	iterableTarget = Views.iterable( target );

	target.min(min);
	target.max(max);
	sourceInterval = new FinalInterval( min, max );

	width = ( int )target.dimension( 0 );
	height = ( int )target.dimension( 1 );
	cr = -width;

	this.numThreads = numThreads;
	this.executorService = executorService;

	lastFrameRenderNanoTime = -1;
	clearMask();
}
 

public VolatileHierarchyProjector(
		final List< ? extends RandomAccessible< A > > sources,
		final Converter< ? super A, B > converter,
		final RandomAccessibleInterval< B > target,
		final int numThreads,
		final ExecutorService executorService )
{
	this( sources, converter, target, ArrayImgs.bytes( Intervals.dimensionsAsLongArray( target ) ), numThreads, executorService );
}
 

public VolatileHierarchyProjectorPreMultiply(
		final List<? extends RandomAccessible<A>> sources,
		final Converter<? super A, ARGBType> converter,
		final RandomAccessibleInterval<ARGBType> target,
		final RandomAccessibleInterval<ByteType> mask,
		final int numThreads,
		final ExecutorService executorService)
{
	super(Math.max(2, sources.get(0).numDimensions()), converter, target);

	this.sources.addAll(sources);
	numInvalidLevels = sources.size();

	this.mask = mask;

	iterableTarget = Views.iterable(target);

	target.min(min);
	target.max(max);
	sourceInterval = new FinalInterval(min, max);

	width = (int) target.dimension(0);
	height = (int) target.dimension(1);
	cr = -width;

	this.numThreads = numThreads;
	this.executorService = executorService;

	lastFrameRenderNanoTime = -1;
	clearMask();
}
 

public SimpleInterruptibleProjectorPreMultiply(
		final RandomAccessible<A> source,
		final Converter<? super A, ARGBType> converter,
		final RandomAccessibleInterval<ARGBType> target,
		final int numThreads,
		final ExecutorService executorService)
{
	super(source.numDimensions(), converter, target);
	this.source = source;
	this.numThreads = numThreads;
	this.executorService = executorService;
	lastFrameRenderNanoTime = -1;
}
 

public ConvertedRandomAccess(final RandomAccess<A> source, final Converter<? super A, ? super B> converter, final
Supplier<B> b)
{
	super(source);
	this.converter = converter;
	this.supplier = b;
	this.converted = b.get();
}
 

@Override
public void compute(final RectangleNeighborhood<I> input,
	final DoubleType output)
{
	// computation according to
	// https://en.wikipedia.org/wiki/Summed_area_table
	final IntegralCursor<I> cursor = new IntegralCursor<>(input);
	final int dimensions = input.numDimensions();

	// Compute \sum (-1)^{dim - ||cornerVector||_{1}} * I(x^{cornerVector})
	final DoubleType sum = new DoubleType();
	sum.setZero();

	// Convert from input to return type
	final Converter<I, DoubleType> conv = new RealDoubleConverter<>();
	final DoubleType valueAsDoubleType = new DoubleType();

	while (cursor.hasNext()) {
		final I value = cursor.next().copy();
		conv.convert(value, valueAsDoubleType);

		// Obtain the cursor position encoded as corner vector
		final int cornerInteger = cursor.getCornerRepresentation();

		// Determine if the value has to be added (factor==1) or subtracted
		// (factor==-1)
		final DoubleType factor = new DoubleType(Math.pow(-1.0d, dimensions -
			IntegralMean.norm(cornerInteger)));
		valueAsDoubleType.mul(factor);

		sum.add(valueAsDoubleType);
	}

	output.set(sum);
}
 

public ConvertedRandomAccessible(final RandomAccessible<A> source, final Converter<? super A, ? super B>
		converter, final Supplier<B> b)
{
	super(source);
	this.converter = converter;
	this.converted = b.get();
	this.supplier = b;
}
 

@Override
public void compute(final RectangleNeighborhood<Composite<I>> input,
	final DoubleType output)
{
	// computation according to
	// https://en.wikipedia.org/wiki/Summed_area_table
	final IntegralCursor<Composite<I>> cursorS1 = new IntegralCursor<>(input);
	final int dimensions = input.numDimensions();

	// Compute \sum (-1)^{dim - ||cornerVector||_{1}} * I(x^{cornerVector})
	final DoubleType sum1 = new DoubleType();
	sum1.setZero();

	// Convert from input to return type
	final Converter<I, DoubleType> conv = new RealDoubleConverter<>();

	// Compute \sum (-1)^{dim - ||cornerVector||_{1}} * I(x^{cornerVector})
	final DoubleType sum2 = new DoubleType();
	sum2.setZero();

	final DoubleType valueAsDoubleType = new DoubleType();

	while (cursorS1.hasNext()) {
		final Composite<I> compositeValue = cursorS1.next();
		final I value1 = compositeValue.get(0).copy();
		conv.convert(value1, valueAsDoubleType);

		// Obtain the cursor position encoded as corner vector
		final int cornerInteger1 = cursorS1.getCornerRepresentation();

		// Determine if the value has to be added (factor==1) or subtracted
		// (factor==-1)
		final DoubleType factor = new DoubleType(Math.pow(-1.0d, dimensions -
			IntegralMean.norm(cornerInteger1)));
		valueAsDoubleType.mul(factor);

		sum1.add(valueAsDoubleType);

		final I value2 = compositeValue.get(1).copy();
		conv.convert(value2, valueAsDoubleType);

		// Determine if the value has to be added (factor==1) or subtracted
		// (factor==-1)
		valueAsDoubleType.mul(factor);

		sum2.add(valueAsDoubleType);
	}

	final int area = (int) Intervals.numElements(Intervals.expand(input, -1l));

	valueAsDoubleType.set(area); // NB: Reuse available DoubleType
	sum1.mul(sum1);
	sum1.div(valueAsDoubleType); // NB

	sum2.sub(sum1);
	valueAsDoubleType.sub(new DoubleType(1)); // NB
	sum2.div(valueAsDoubleType); // NB

	output.set(sum2);
}
 

@Override
public void compute(final RectangleNeighborhood<Composite<I>> input,
	final DoubleType output)
{
	// computation according to
	// https://en.wikipedia.org/wiki/Summed_area_table
	final IntegralCursor<Composite<I>> cursor = new IntegralCursor<>(input);
	final int dimensions = input.numDimensions();

	// Compute \sum (-1)^{dim - ||cornerVector||_{1}} * I(x^{cornerVector})
	final DoubleType sum = new DoubleType();
	sum.setZero();

	// Convert from input to return type
	final Converter<I, DoubleType> conv = new RealDoubleConverter<>();
	final DoubleType valueAsDoubleType = new DoubleType();

	while (cursor.hasNext()) {
		final I value = cursor.next().get(0).copy();
		conv.convert(value, valueAsDoubleType);

		// Obtain the cursor position encoded as corner vector
		final int cornerInteger = cursor.getCornerRepresentation();

		// Determine if the value has to be added (factor==1) or subtracted
		// (factor==-1)
		final DoubleType factor = new DoubleType(Math.pow(-1.0d, dimensions -
			IntegralMean.norm(cornerInteger)));
		valueAsDoubleType.mul(factor);

		sum.add(valueAsDoubleType);
	}

	final int area = (int) Intervals.numElements(Intervals.expand(input, -1l));

	// Compute mean by dividing the sum divided by the number of elements
	valueAsDoubleType.set(area); // NB: Reuse DoubleType
	sum.div(valueAsDoubleType);

	output.set(sum);
}