@Override public AffineTransform3D get( final double t ) { final AffineTransform3D transform = new AffineTransform3D(); transform.set( transformStart ); // center shift transform.set( transform.get( 0, 3 ) - cX, 0, 3 ); transform.set( transform.get( 1, 3 ) - cY, 1, 3 ); // rotate final double[] qAddCurrent = new double[4]; final AffineTransform3D tAddCurrent = new AffineTransform3D(); LinAlgHelpers.quaternionPower( qAddEnd, t, qAddCurrent ); final double[][] m = new double[3][4]; LinAlgHelpers.quaternionToR( qAddCurrent, m ); tAddCurrent.set( m ); transform.preConcatenate( tAddCurrent ); // center un-shift transform.set( transform.get( 0, 3 ) + cX, 0, 3 ); transform.set( transform.get( 1, 3 ) + cY, 1, 3 ); return transform; } }
public void addIllumination(int id, double[] shift) { AffineTransform3D t = new AffineTransform3D(); t.translate( shift ); illumTransforms.put( id, t.copy() ); }
/** * Rotate by d radians around axis. Keep screen coordinates ( * {@link #centerX}, {@link #centerY}) fixed. */ private void rotate( final int axis, final double d ) { // center shift affine.set( affine.get( 0, 3 ) - centerX, 0, 3 ); affine.set( affine.get( 1, 3 ) - centerY, 1, 3 ); // rotate affine.rotate( axis, d ); // center un-shift affine.set( affine.get( 0, 3 ) + centerX, 0, 3 ); affine.set( affine.get( 1, 3 ) + centerY, 1, 3 ); }
private void scale( final double s, final double x, final double y ) { // center shift affine.set( affine.get( 0, 3 ) - x, 0, 3 ); affine.set( affine.get( 1, 3 ) - y, 1, 3 ); // scale affine.scale( s ); // center un-shift affine.set( affine.get( 0, 3 ) + x, 0, 3 ); affine.set( affine.get( 1, 3 ) + y, 1, 3 ); }
/** * Scale the affine transform (use with scaleBoundingBox so it is the right image, but just smaller) * * @param t transform * @param factor scaling factor */ public static void scaleTransform( final AffineTransform3D t, final double factor ) { final AffineTransform3D at = new AffineTransform3D(); at.scale( factor ); t.preConcatenate( at ); }
final int timepoint = state.getCurrentTimepoint(); if ( !source.isPresent( timepoint ) ) return new AffineTransform3D(); final AffineTransform3D sourceTransform = new AffineTransform3D(); source.getSourceTransform( timepoint, 0, sourceTransform ); final double[] centerGlobal = new double[ 3 ]; final double[] translation = new double[ 3 ]; sourceTransform.apply( centerSource, centerGlobal ); LinAlgHelpers.quaternionApply( qViewer, centerGlobal, translation ); LinAlgHelpers.scale( translation, -1, translation ); LinAlgHelpers.setCol( 3, translation, m ); final AffineTransform3D viewerTransform = new AffineTransform3D(); viewerTransform.set( m ); final double[] pGlobal = new double[ 3 ]; final double[] pScreen = new double[ 3 ]; sourceTransform.apply( pSource, pGlobal ); viewerTransform.apply( pGlobal, pScreen ); final double scaleX = cX / pScreen[ 0 ]; final double scaleY = cY / pScreen[ 1 ]; else scale = Math.min( scaleX, scaleY ); viewerTransform.scale( scale ); viewerTransform.set( viewerTransform.get( 0, 3 ) + cX, 0, 3 );
final AffineTransform3D tGV = new AffineTransform3D(); renderState.getViewerTransform( tGV ); tGV.set( tGV.get( 0, 3 ) - canvasW / 2, 0, 3 ); tGV.set( tGV.get( 1, 3 ) - canvasH / 2, 1, 3 ); tGV.scale( ( double ) width / canvasW ); tGV.set( tGV.get( 0, 3 ) + width / 2, 0, 3 ); tGV.set( tGV.get( 1, 3 ) + height / 2, 1, 3 ); final AffineTransform3D affine = new AffineTransform3D(); final AffineTransform3D tSV = new AffineTransform3D(); renderState.getSources().get( 0 ).getSpimSource().getSourceTransform( 0, 0, tSV ); tSV.preConcatenate( tGV ); final double[] sO = new double[] { 0, 0, 0 }; final double[] sX = new double[] { 1, 0, 0 }; final double[] vO = new double[ 3 ]; final double[] vX = new double[ 3 ]; tSV.apply( sO, vO ); tSV.apply( sX, vX ); LinAlgHelpers.subtract( vO, vX, vO ); final double dd = LinAlgHelpers.length( vO ); affine.set( 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -dd * stepSize * step ); affine.concatenate( tGV ); renderState.setViewerTransform( affine ); renderer.requestRepaint();
final AffineTransform3D cropToGlobal = globalToCropTransform.inverse(); final AffineTransform3D sourceToGlobal = new AffineTransform3D(); source.getSourceTransform( timepoint, 0, sourceToGlobal ); final AffineTransform3D globalToSource = sourceToGlobal.inverse(); final AffineTransform3D cropToSource = globalToSource.copy(); cropToSource.concatenate( cropToGlobal ); cropToSource.apply( corner, sourceCorner ); sourceCorners.add( sourceCorner ); final AffineTransform3D croppedSourceTransform = new AffineTransform3D(); croppedSourceTransform.set( 1, 0, 0, sourceInterval.min( 0 ), 0, 1, 0, sourceInterval.min( 1 ), 0, 0, 1, sourceInterval.min( 2 ) ); croppedSourceTransform.preConcatenate( sourceToGlobal );
@Override public AffineTransform3D deserialize( final JsonElement json, final Type typeOfT, final JsonDeserializationContext context ) throws JsonParseException { final double[] data = context.deserialize( json, double[].class ); final AffineTransform3D t = new AffineTransform3D(); t.set( data ); return t; }
AffineTransform3D translation = new AffineTransform3D(); translation.set( generateRegularGrid.get( i ).copy().getRowPackedCopy()); translation.set( translation.get( 0, 3 ) * calibration.asAffine3D().get( 0, 0 ), 0, 3 ); translation.set( translation.get( 1, 3 ) * calibration.asAffine3D().get( 1, 1 ), 1, 3 ); translation.set( translation.get( 2, 3 ) * calibration.asAffine3D().get( 2, 2 ), 2, 3 ); vr.preconcatenateTransform( new ViewTransformAffine( "Translation to Regular Grid", translation )); AffineTransform3D rotation = new AffineTransform3D(); Pair< Double, Integer > rotAngleAndAxis = getRoatationFromMetadata( vd.getViewSetup().getAttribute( Angle.class ) ); if (rotAngleAndAxis != null) rotation.rotate( rotAngleAndAxis.getB(), rotAngleAndAxis.getA() ); vr.preconcatenateTransform( new ViewTransformAffine( "Rotation from Metadata", rotation.copy() ));
final AffineTransform3D sourceToScreen = new AffineTransform3D(); sourceToScreen.set( screenTransform ); final AffineTransform3D sourceTransform = new AffineTransform3D(); source.getSourceTransform( timepoint, mipmapIndex, sourceTransform ); sourceToScreen.concatenate( sourceTransform ); final double[] zero = new double[] { 0, 0, 0 }; final double[] tzero = new double[ 3 ]; final double[] tone = new double[ 3 ]; final double[] diff = new double[ 2 ]; sourceToScreen.apply( zero, tzero ); for ( int i = 0; i < 3; ++i ) sourceToScreen.apply( one, tone ); LinAlgHelpers.subtract( tone, tzero, tone ); diff[0] = tone[0];
public static void reCenterViews(final BigDataViewer viewer, final Collection<BasicViewDescription< ? >> selectedViews, final ViewRegistrations viewRegistrations) AffineTransform3D currentViewerTransform = viewer.getViewer().getDisplay().getTransformEventHandler().getTransform().copy(); final int cX = viewer.getViewer().getWidth() / 2; // size of the display area of the frame final int cY = viewer.getViewer().getHeight() / 2; // size of the display area of the frame ( bb.max( 2 ) - bb.min( 2 ) )/2 + bb.min( 2 ) }; final RealInterval bounds = currentViewerTransform.estimateBounds( bb ); IOFunctions.println( printRealInterval( bounds )); final double oldZ = currentViewerTransform.get( 2, 3 ); currentViewerTransform.set( 0, 0, 3 ); currentViewerTransform.set( 0, 1, 3 ); currentViewerTransform.set( 0, 2, 3 ); currentViewerTransform.preConcatenate( scale ); currentViewerTransform.apply( com, com ); currentViewerTransform.set( -com[0] + cX , 0, 3 ); currentViewerTransform.set( -com[1] + cY , 1, 3 ); currentViewerTransform.set( oldZ, 2, 3 ); else currentViewerTransform.set( -com[2], 2, 3 );
@Override public AffineTransform3D get( final double t ) { final AffineTransform3D transform = new AffineTransform3D(); transform.set( transformStart ); final double sx = transform.get( 0, 3 ); final double sy = transform.get( 1, 3 ); final double sz = transform.get( 2, 3 ); final double tx = targetTranslation[ 0 ]; final double ty = targetTranslation[ 1 ]; final double tz = targetTranslation[ 2 ]; transform.set( sx + t * ( tx - sx ), 0, 3 ); transform.set( sy + t * ( ty - sy ), 1, 3 ); transform.set( sz + t * ( tz - sz ), 2, 3 ); return transform; } }
private ArrayList< double[] > transformedPoints(int tp, int angle, int channel, int tile, int illumination) AffineTransform3D transform = new AffineTransform3D(); transform.preConcatenate( tpTransforms.get( tp ) ); transform.preConcatenate( angleTransforms.get( angle ) ); transform.preConcatenate( channelTransforms.get( channel ) ); transform.preConcatenate( illumTransforms.get( illumination ) ); transform.preConcatenate( tileTransforms.get( tile ) ); transform.apply( p, pt ); transformed.add( pt );
public void addTile(int id, double[] shift) { AffineTransform3D t = new AffineTransform3D(); t.translate( shift ); tileTransforms.put( id, t.copy().inverse() ); }
@Override protected void draw( final Graphics2D graphics ) { if ( points == null ) return; col = new Color( info.getColor().get() ); final AffineTransform3D transform = new AffineTransform3D(); getCurrentTransform3D( transform ); final double[] lPos = new double[ 3 ]; final double[] gPos = new double[ 3 ]; for ( final RealLocalizable p : points ) { p.localize( lPos ); transform.apply( lPos, gPos ); final double size = getPointSize( gPos ); final int x = ( int ) ( gPos[ 0 ] - 0.5 * size ); final int y = ( int ) ( gPos[ 1 ] - 0.5 * size ); final int w = ( int ) size; graphics.setColor( getColor( gPos ) ); graphics.fillOval( x, y, w, w ); } }
final AffineTransform3D s = new AffineTransform3D(); s.set( factors[ 0 ], 0.0, 0.0, 0.0, 0.0, factors[ 1 ], 0.0, 0.0, AffineTransform3D model = m.copy(); model.concatenate( s ); m.concatenate( mrImgLoader.getSetupImgLoader( viewId.getViewSetupId() ).getMipmapTransforms()[ bestLevel ] );
public RandomAccessibleIntervalMipmapSource( final RandomAccessibleInterval< T >[] imgs, final T type, final double[][] mipmapScales, final VoxelDimensions voxelDimensions, final AffineTransform3D sourceTransform, final String name ) { super( type, name ); assert imgs.length == mipmapScales.length : "Number of mipmaps and scale factors do not match."; this.mipmapSources = imgs; this.mipmapTransforms = new AffineTransform3D[ mipmapScales.length ]; for ( int s = 0; s < mipmapScales.length; ++s ) { final AffineTransform3D mipmapTransform = new AffineTransform3D(); mipmapTransform.set( mipmapScales[ s ][ 0 ], 0, 0, 0.5 * ( mipmapScales[ s ][ 0 ] - 1 ), 0, mipmapScales[ s ][ 1 ], 0, 0.5 * ( mipmapScales[ s ][ 1 ] - 1 ), 0, 0, mipmapScales[ s ][ 2 ], 0.5 * ( mipmapScales[ s ][ 2 ] - 1 ) ); mipmapTransform.preConcatenate(sourceTransform); mipmapTransforms[ s ] = mipmapTransform; } this.voxelDimensions = voxelDimensions; }
public void addAngle(int id, int axis, double degrees) { AffineTransform3D t = new AffineTransform3D(); t.rotate( axis, Math.toRadians( degrees ) ); angleTransforms.put( id, t.copy() ); }