Java Views.collapseReal方法代码示例

import net.imglib2.view.Views; //导入方法依赖的package包/类
/**
 * Logic stolen from
 * <a href='https://github.com/trakem2/TrakEM2/blob/master/TrakEM2_/src/main/java/org/janelia/intensity/LinearIntensityMap.java'>
 *   TrakEM2 LinearIntensityMap
 * </a>.
 *
 * @return an accessor for deriving warped pixel intensities.
 */
public RealRandomAccess<RealComposite<DoubleType>> getAccessor() {

    final ArrayImg<DoubleType, DoubleArray> warpField =
            ArrayImgs.doubles(values, columnCount, rowCount, VALUES_PER_AFFINE);

    final CompositeIntervalView<DoubleType, RealComposite<DoubleType>>
            collapsedSource = Views.collapseReal(warpField);

    final RandomAccessible<RealComposite<DoubleType>> extendedCollapsedSource = Views.extendBorder(collapsedSource);
    final RealRandomAccessible<RealComposite<DoubleType>> coefficients =
            Views.interpolate(extendedCollapsedSource, interpolatorFactory);

    final double xScale = getXScale();
    final double yScale = getYScale();
    final double[] scale = { xScale, yScale };
    final double[] shift = { 0.5 * xScale , 0.5 * yScale };

    final ScaleAndTranslation scaleAndTranslation = new ScaleAndTranslation(scale, shift);

    final RealRandomAccessible<RealComposite<DoubleType>> stretchedCoefficients =
            RealViews.transform(coefficients, scaleAndTranslation);

    return stretchedCoefficients.realRandomAccess();
}
 

import net.imglib2.view.Views; //导入方法依赖的package包/类
@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());
}
 

import net.imglib2.view.Views; //导入方法依赖的package包/类
public AbstractLUTGrid( final int numSourceDimensions, final int numTargetDimensions,
		final RandomAccessibleInterval< DoubleType > lutArray, final double[] scale, final double[] shift )
{
	super();
	this.numSourceDimensions = numSourceDimensions;
	this.numTargetDimensions = numTargetDimensions;
	this.lutArray = lutArray;

	// generate n-1 dimensional array that has local LUTs as columns
	final CompositeIntervalView< DoubleType, RealComposite< DoubleType > > collapsedSource = Views.collapseReal( lutArray );
	this.dimensions = new FinalInterval( collapsedSource );
	this.nNonTransformedCoordinates = this.dimensions.numDimensions();
	this.lutMaxIndex = ( int ) ( this.lutArray.dimension( this.nNonTransformedCoordinates ) ) - 1;

	// generate scale transform to allow for generating interpolated
	// high-res LUT from low-res LUT
	this.scale = new double[ this.nNonTransformedCoordinates ];
	this.shift = new double[ this.nNonTransformedCoordinates ];
	copyAndFillIfNecessary( scale, this.scale );
	copyAndFillIfNecessary( shift, this.shift );

	final ScaleAndTranslation scaleAndShift = new ScaleAndTranslation( this.scale, this.shift );
	final ExtendedRandomAccessibleInterval< RealComposite< DoubleType >, CompositeIntervalView< DoubleType, RealComposite< DoubleType > > > extendedCollapsedSource =
			Views.extendBorder( collapsedSource );
	this.coefficients = RealViews.transform( Views.interpolate( extendedCollapsedSource, this.interpolatorFactory ), scaleAndShift );
	this.access = this.coefficients.realRandomAccess();
	this.currentLut = this.access.get();

}
 

import net.imglib2.view.Views; //导入方法依赖的package包/类
@Override
public CompositeIntervalView<T, RealComposite<T>> calculate(RandomAccessibleInterval<T> input) {
	List<RandomAccessibleInterval<T>> derivatives = new ArrayList<>();
	for (int i = 0; i < derivativeComputers.length; i++) {
		RandomAccessibleInterval<T> derivative = createRAI.calculate(input);
		derivativeComputers[i].compute(input, derivative);
		for (int j = 0; j < derivativeComputers.length; j++) {
			RandomAccessibleInterval<T> out = createRAI.calculate(input);
			derivativeComputers[j].compute(derivative, out);
			derivatives.add(out);
		}
	}
	RandomAccessibleInterval<T> stackedDerivatives = Views.stack(derivatives);
	return Views.collapseReal(stackedDerivatives);
}
 

import net.imglib2.view.Views; //导入方法依赖的package包/类
@Override
public CompositeIntervalView<T, RealComposite<T>> calculate(RandomAccessibleInterval<T> input) {
	List<RandomAccessibleInterval<T>> derivatives = new ArrayList<>();
	for (int i = 0; i < derivativeFunctions.length; i++) {
		RandomAccessibleInterval<T> derivative = derivativeFunctions[i].calculate(input);
		derivatives.add(derivative);
	}

	RandomAccessibleInterval<T> stacked = Views.stack(derivatives);
	return Views.collapseReal(stacked);
}
 

import net.imglib2.view.Views; //导入方法依赖的package包/类
@Override
protected RandomAccessibleInterval< double[] > estimate( final int size )
{

	{
		final ArrayRandomAccess< DoubleType > ra = summedMeasurements.randomAccess();
		for ( int n = 0; n < nSamples.length; ++n )
		{
			ra.setPosition( n, 0 );
			final double[] ns = nSamples[ n ];
			for ( int r = 0; r < ns.length; ++r )
			{
				ra.setPosition( r, 1 );
				ra.get().mul( 1.0 / ns[ r ] );
			}
		}
	}


	final CompositeIntervalView< DoubleType, RealComposite< DoubleType > > collapsed =
			Views.collapseReal( summedMeasurements );

	final RealRandomAccessible< RealComposite< DoubleType > > interpolated =
			Views.interpolate( Views.extendBorder( collapsed ), new NLinearInterpolatorFactory<>() );

	final FinalInterval fi = new FinalInterval( size );
	final IntervalView< RealComposite< DoubleType > > transformed =
			Views.interval( Views.raster( RealViews.transformReal( interpolated, scaleAndTranslation ) ), fi );

	final Cursor< RealComposite< DoubleType > > t = transformed.cursor();
	final ArrayList< double[] > list = new ArrayList<>();
	for ( int n = 0; n < size; ++n )
	{
		final RealComposite< DoubleType > c = t.next();
		final double[] target = new double[ nSamples[ 0 ].length ];
		target[ 0 ] = -1;
		for ( int i = 1; i < target.length; ++i )
			target[ i ] = -c.get( i ).get();
		list.add( target );
	}

	return new ListImg<>( list, list.size() );
}
 

import net.imglib2.view.Views; //导入方法依赖的package包/类
@Override
public CompositeIntervalView<T, RealComposite<T>> calculate(RandomAccessibleInterval<T> input) {
	return Views.collapseReal(input);
}
 

import net.imglib2.view.Views; //导入方法依赖的package包/类
@Override
public CompositeView<T, RealComposite<T>> calculate(RandomAccessible<T> input) {
	return Views.collapseReal(input, numChannels);
}