Java Ops类代码示例

import net.imagej.ops.Ops; //导入依赖的package包/类
@Override
public void compute(final Iterable<T> neighborhood, final T center,
	final O output)
{
	// TODO Move to initialize when NIL objects are available
	if (applyThreshold == null) {
		applyThreshold = Computers.binary(ops(), Ops.Threshold.Apply.class, output,
			center, center);
	}

	// Compute histogram for neighborhood
	final Histogram1d<T> hist = histCreator.calculate(neighborhood);

	// Compute threshold
	final T computedThreshold = center.createVariable();
	thresholdComputer.compute(hist, computedThreshold);

	// Apply threshold
	applyThreshold.compute(center, computedThreshold, output);
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
private void matchOps(final RandomAccessibleInterval<BitType> interval) {
       eulerCharacteristicOp = Hybrids.unaryCF(opService,
		Ops.Topology.EulerCharacteristic26NFloating.class, DoubleType.class,
               interval);
	eulerCorrectionOp = Hybrids.unaryCF(opService,
		Ops.Topology.EulerCorrection.class, DoubleType.class, interval);
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void matchOps(final RandomAccessibleInterval<BitType> input) {
	hollowOp = (BinaryHybridCF) Hybrids.binaryCF(opService, Ops.Morphology.Outline.class,
		RandomAccessibleInterval.class, input, true);
	boxCountOp = (UnaryFunctionOp) Functions.unary(opService, Ops.Topology.BoxCount.class,
		List.class, input, startBoxSize, smallestBoxSize, scaleFactor,
		translations);
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
private void matchOps(final RandomAccessibleInterval<BitType> subspace) {
	raiCopy = Functions.unary(opService, Ops.Copy.RAI.class,
		RandomAccessibleInterval.class, subspace);
	marchingCubes = Functions.unary(opService,
		Ops.Geometric.MarchingCubes.class, Mesh.class, subspace);
	// Create a dummy object to make op matching happy
	meshVolume = Functions.unary(opService, Ops.Geometric.Size.class,
		DoubleType.class, new DefaultMesh());
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@OpMethod(op = net.imagej.ops.logic.BooleanTypeLogic.ObjectsEqual.class)
public <T extends BooleanType<T>> T equal(final T out, final Object a,
	final Object b)
{
	@SuppressWarnings("unchecked")
	final T result = (T) ops().run(
		Ops.Logic.Equal.class, out, a, b);
	return result;
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public void initialize() {
	super.initialize();
	create = (UnaryFunctionOp) Functions.unary(ops(), Ops.Create.Img.class,
		Img.class, Dimensions.class, outType);

	sum = (UnaryHybridCF) Hybrids.unaryCF(ops(), Ops.Stats.Sum.class, outType,
		RandomAccessibleInterval.class);
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@OpMethod(op = net.imagej.ops.filter.convolve.ConvolveFFTC.class)
public <I extends RealType<I>, O extends RealType<O>, K extends RealType<K>, C extends ComplexType<C>> RandomAccessibleInterval<O> convolve(
		final RandomAccessibleInterval<O> output, final RandomAccessibleInterval<I> raiExtendedInput,
		final RandomAccessibleInterval<K> raiExtendedKernel, final RandomAccessibleInterval<C> fftInput,
		final RandomAccessibleInterval<C> fftKernel, final boolean performInputFFT) {
	@SuppressWarnings("unchecked")
	final RandomAccessibleInterval<O> result = (RandomAccessibleInterval<O>) ops().run(Ops.Filter.Convolve.class,
			output, raiExtendedInput, raiExtendedKernel, fftInput, fftKernel, performInputFFT);
	return result;
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@OpMethod(
	op = net.imagej.ops.logic.BooleanTypeLogic.ComparableGreaterThanOrEqual.class)
public <I extends Comparable<I>, O extends BooleanType<O>> O
	greaterThanOrEqual(final O out, final I a, final I b)
{
	@SuppressWarnings("unchecked")
	final O result = (O) ops().run(
		Ops.Logic.GreaterThanOrEqual.class,
		out, a, b);
	return result;
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
/**
 * Executes the "scale" operation on the given arguments.
 *
 * @param in
 * @param scaleFactors
 * @param interpolator
 * @return
 */
@OpMethod(op = net.imagej.ops.transform.scaleView.DefaultScaleView.class)
public <T extends RealType<T>> RandomAccessibleInterval<T> scaleView(
	final RandomAccessibleInterval<T> in, final double[] scaleFactors,
	final InterpolatorFactory<T, RandomAccessible<T>> interpolator)
{
	@SuppressWarnings("unchecked")
	final RandomAccessibleInterval<T> result =
		(RandomAccessibleInterval<T>) ops().run(Ops.Transform.ScaleView.class, in,
			scaleFactors, interpolator);
	return result;
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@OpMethod(op = net.imagej.ops.image.normalize.NormalizeIIComputer.class)
public
	<T extends RealType<T>> IterableInterval<T> normalize(
		final IterableInterval<T> out, final IterableInterval<T> in,
		final T sourceMin, final T sourceMax, final T targetMin)
{
	@SuppressWarnings("unchecked")
	final IterableInterval<T> result =
		(IterableInterval<T>) ops().run(
			net.imagej.ops.Ops.Image.Normalize.class, out,
			in, sourceMin, sourceMax, targetMin);
	return result;
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@Override
public void initialize() {
	mapper = Computers.unary(ops(), Ops.Map.class, out(), in(), pixConvert);
	pixConvert.checkInput(in().firstElement().createVariable(), out()
		.firstElement().createVariable());
	pixConvert.checkInput(in());
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Sinc.class)
public <I extends RealType<I>, O extends RealType<O>> O sinc(final O out,
	final I in)
{
	@SuppressWarnings("unchecked")
	final O result = (O) ops().run(net.imagej.ops.Ops.Math.Sinc.class, out, in);
	return result;
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@OpMethod(op = net.imagej.ops.convert.ConvertImages.Uint12.class)
public <C extends ComplexType<C>> Img<Unsigned12BitType> uint12(
	final IterableInterval<C> in)
{
	@SuppressWarnings("unchecked")
	final Img<Unsigned12BitType> result = (Img<Unsigned12BitType>) ops().run(
		Ops.Convert.Uint12.class, in);
	return result;
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@OpMethod(op = net.imagej.ops.logic.BooleanTypeLogic.ObjectsNotEqual.class)
public <T extends BooleanType<T>> T notEqual(final T out, final Object a,
	final Object b)
{
	@SuppressWarnings("unchecked")
	final T result = (T) ops().run(
		Ops.Logic.NotEqual.class, out, a, b);
	return result;
}
 

import net.imagej.ops.Ops; //导入依赖的package包/类
@OpMethod(op = net.imagej.ops.math.ConstantToIIOutputII.Add.class)
public <T extends NumericType<T>> IterableInterval<T> add(
	final IterableInterval<T> out, final IterableInterval<T> in,
	final T value)
{
	@SuppressWarnings("unchecked")
	final IterableInterval<T> result = (IterableInterval<T>) ops().run(
		net.imagej.ops.Ops.Math.Add.class, out, in, value);
	return result;
}