?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use internal SNAPSHOT couplings again
[trakem2.git] / TrakEM2_ / src / main / java / ini / trakem2 / display / NonLinearTransformMode.java
blob889c23bf113018b9a4751dc238bb0df78440e4db
1 package ini.trakem2.display;
2
3 import ini.trakem2.utils.Bureaucrat;
4 import ini.trakem2.utils.ProjectToolbar;
5 import ini.trakem2.utils.Utils;
6 import ini.trakem2.utils.Worker;
7
8 import java.awt.BasicStroke;
9 import java.awt.Graphics2D;
10 import java.awt.Rectangle;
11 import java.awt.Stroke;
12 import java.awt.event.MouseEvent;
13 import java.awt.geom.AffineTransform;
14 import java.util.ArrayList;
15 import java.util.Collection;
16 import java.util.HashMap;
17 import java.util.HashSet;
18 import java.util.List;
19 import java.util.Set;
20 import java.util.concurrent.Future;
21
22 import mpicbg.models.AbstractAffineModel2D;
23 import mpicbg.models.CoordinateTransformMesh;
24 import mpicbg.models.IllDefinedDataPointsException;
25 import mpicbg.models.NoninvertibleModelException;
26 import mpicbg.models.NotEnoughDataPointsException;
27 import mpicbg.models.Point;
28 import mpicbg.models.PointMatch;
29 import mpicbg.models.SimilarityModel2D;
30 import mpicbg.models.TranslationModel2D;
31 import mpicbg.trakem2.transform.AffineModel2D;
32 import mpicbg.trakem2.transform.CoordinateTransform;
33 import mpicbg.trakem2.transform.CoordinateTransformList;
34 import mpicbg.trakem2.transform.MovingLeastSquaresTransform2;
35 import mpicbg.trakem2.transform.TransformMeshMappingWithMasks;
36 import mpicbg.trakem2.transform.TransformMeshMappingWithMasks.ImageProcessorWithMasks;
37
38 public class NonLinearTransformMode extends GroupingMode {
39
40 protected void doPainterUpdate( final Rectangle r, final double m )
41 {
42 try
43 {
44 final CoordinateTransform mlst = createCT();
45 final SimilarityModel2D toWorld = new SimilarityModel2D();
46 toWorld.set( 1.0f / ( float )m, 0, r.x - ScreenPatchRange.pad / ( float )m, r.y - ScreenPatchRange.pad / ( float )m );
47
48 final mpicbg.models.CoordinateTransformList< mpicbg.models.CoordinateTransform > ctl = new mpicbg.models.CoordinateTransformList< mpicbg.models.CoordinateTransform >();
49 ctl.add( toWorld );
50 ctl.add( mlst );
51 ctl.add( toWorld.createInverse() );
52
53 final CoordinateTransformMesh ctm = new CoordinateTransformMesh( ctl, 32, r.width * ( float )m + 2 * ScreenPatchRange.pad, r.height * ( float )m + 2 * ScreenPatchRange.pad );
54 final TransformMeshMappingWithMasks< CoordinateTransformMesh > mapping = new TransformMeshMappingWithMasks< CoordinateTransformMesh >( ctm );
55
56 final HashMap<Paintable, GroupingMode.ScreenPatchRange<?>> screenPatchRanges = this.screenPatchRanges; // keep a pointer to the current list
57 for ( final GroupingMode.ScreenPatchRange spr : screenPatchRanges.values())
58 {
59 if (screenPatchRanges != this.screenPatchRanges) {
60 // List has been updated; restart painting
61 // TODO should it call itself: doPainterUpdate( r, m );
62 break;
63 }
64 spr.update( mapping );
65 }
66 }
67 catch ( NotEnoughDataPointsException e ) {}
68 catch ( NoninvertibleModelException e ) {}
69 catch ( IllDefinedDataPointsException e ) {}
70 catch ( Exception e ) { e.printStackTrace(); }
71 }
72
73 private class NonLinearTransformSource extends GroupingMode.GroupedGraphicsSource {
74 public void paintOnTop(final Graphics2D g, final Display display, final Rectangle srcRect, final double magnification) {
75
76 final Stroke original_stroke = g.getStroke();
77 final AffineTransform original = g.getTransform();
78 g.setTransform( new AffineTransform() );
79 g.setStroke( new BasicStroke( 1.0f ) );
80 for ( final Point p : points )
81 {
82 final float[] w = p.getW();
83 Utils.drawPoint( g, Math.round( ( float )magnification * ( w[ 0 ] - srcRect.x ) ), Math.round( ( float )magnification * ( w[ 1 ] - srcRect.y ) ) );
84 }
85
86 g.setTransform( original );
87 g.setStroke( original_stroke );
88 }
89 }
90
91 protected ScreenPatchRange createScreenPathRange(final PatchRange range, final Rectangle srcRect, final double magnification) {
92 return new NonLinearTransformMode.ScreenPatchRange(range, srcRect, magnification);
93 }
94
95 private static class ScreenPatchRange extends GroupingMode.ScreenPatchRange<TransformMeshMappingWithMasks<?>> {
96 ScreenPatchRange( final PatchRange range, final Rectangle srcRect, final double magnification ) {
97 super(range, srcRect, magnification);
98 }
99 public void update( final TransformMeshMappingWithMasks< ? > mapping )
100 {
101 ipTransformed.reset();
102 if ( mask == null )
103 {
104 mapping.map( ip, ipTransformed );
105 }
106 else
107 {
108 maskTransformed.reset();
109 final ImageProcessorWithMasks ipm = new ImageProcessorWithMasks( ip, mask, null );
110 final ImageProcessorWithMasks tpm = new ImageProcessorWithMasks( ipTransformed, maskTransformed, null );
111 mapping.map( ipm, tpm );
112 }
113 if (null != transformedImage) transformedImage.flush();
114 transformedImage = super.makeImage( ipTransformed, maskTransformed );
115 }
116 }
117
118 protected GroupingMode.GroupedGraphicsSource createGroupedGraphicSource() {
119 return new NonLinearTransformSource();
120 }
121
122 public NonLinearTransformMode(final Display display, final List<Displayable> selected) {
123 super(display, selected);
124 ProjectToolbar.setTool(ProjectToolbar.SELECT);
125 super.initThreads();
126 }
127
128 public NonLinearTransformMode(final Display display) {
129 this(display, display.getSelection().getSelected());
130 }
131
132 private Collection< Point > points = new ArrayList< Point >();
133
134 private Point p_clicked = null;
135
136 @Override
137 public void mousePressed( MouseEvent me, int x_p, int y_p, double magnification )
138 {
139 /* find if clicked on a point */
140 p_clicked = null;
141 float min = Float.MAX_VALUE;
142 final Point mouse = new Point( new float[]{ x_p, y_p } );
143 final float a = ( float )( 64 / magnification / magnification);
144 for ( final Point p : points )
145 {
146 final float sd = Point.squareDistance( p, mouse );
147 if ( sd < min && sd < a )
148 {
149 p_clicked = p;
150 min = sd;
151 }
152 }
153
154 if ( me.isShiftDown() )
155 {
156 if ( null == p_clicked )
157 {
158 /* add one */
159 try
160 {
161 if ( points.size() > 0 )
162 {
163 /*
164 * Create a pseudo-invertible (TransformMesh) for the screen.
165 */
166 final CoordinateTransform mlst = createCT();
167 final SimilarityModel2D toWorld = new SimilarityModel2D();
168 toWorld.set( 1.0f / ( float )magnification, 0, srcRect.x, srcRect.y );
169 final SimilarityModel2D toScreen = toWorld.createInverse();
170
171 final mpicbg.models.CoordinateTransformList< mpicbg.models.CoordinateTransform > ctl = new mpicbg.models.CoordinateTransformList< mpicbg.models.CoordinateTransform >();
172 ctl.add( toWorld );
173 ctl.add( mlst );
174 ctl.add( toScreen );
175
176 final CoordinateTransformMesh ctm = new CoordinateTransformMesh(
177 ctl,
178 32,
179 ( int )Math.ceil( srcRect.width * magnification ),
180 ( int )Math.ceil( srcRect.height * magnification ) );
181
182 final float[] l = mouse.getL();
183 toScreen.applyInPlace( l );
184 ctm.applyInverseInPlace( l );
185 toWorld.applyInPlace( l );
186 }
187 points.add( mouse );
188 p_clicked = mouse;
189 }
190 catch ( Exception e )
191 {
192 Utils.log( "Could not add point" );
193 e.printStackTrace();
194 }
195 }
196 else if ( Utils.isControlDown( me ) )
197 {
198 // remove it
199 points.remove(p_clicked);
200 p_clicked = null;
201 }
202 }
203 }
204
205 @Override
206 public void mouseDragged( MouseEvent me, int x_p, int y_p, int x_d, int y_d, int x_d_old, int y_d_old )
207 {
208 if ( null != p_clicked )
209 {
210 final float[] w = p_clicked.getW();
211 w[ 0 ] += x_d - x_d_old;
212 w[ 1 ] += y_d - y_d_old;
213 painter.update();
214 }
215 }
216
217 @Override
218 public void mouseReleased( MouseEvent me, int x_p, int y_p, int x_d, int y_d, int x_r, int y_r )
219 {
220 // bring to screen coordinates
221 mouseDragged( me, x_p, y_p, x_r, y_r, x_d, y_d );
222 p_clicked = null; // so isDragging can return the right state
223 }
224
225 public boolean isDragging()
226 {
227 return null != p_clicked;
228 }
229
230 private final void setUndoState() {
231 layer.getParent().addEditStep(new Displayable.DoEdits(new HashSet<Displayable>(originalPatches)).init(new String[]{"data", "at", "width", "height"}));
232 }
233
234 final private Future< Boolean > applyToPatch( final Patch patch ) throws Exception
235 {
236 final Rectangle pbox = patch.getCoordinateTransformBoundingBox();
237 final AffineTransform pat = new AffineTransform();
238 pat.translate( -pbox.x, -pbox.y );
239 pat.preConcatenate( patch.getAffineTransform() );
240
241 final AffineModel2D toWorld = new AffineModel2D();
242 toWorld.set( pat );
243
244 final CoordinateTransform mlst = createCT();
245
246 final CoordinateTransformList< CoordinateTransform > ctl = new CoordinateTransformList< CoordinateTransform >();
247 ctl.add( toWorld );
248 ctl.add( mlst );
249 ctl.add( toWorld.createInverse() );
250
251 patch.appendCoordinateTransform( ctl );
252 return patch.updateMipMaps();
253 }
254
255 public boolean apply()
256 {
257 return apply( null );
258 }
259
260 public boolean apply( final Set< Layer > sublist )
261 {
262
263 /* Set undo step to reflect initial state before any transformations */
264 setUndoState();
265
266 Bureaucrat.createAndStart( new Worker.Task( "Applying transformations" )
267 {
268 public void exec()
269 {
270 final ArrayList< Future< Boolean > > futures = new ArrayList< Future< Boolean > >();
271
272 synchronized ( updater )
273 {
274 /* apply to selected patches */
275 for ( final Paintable p : screenPatchRanges.keySet() )
276 {
277 if ( p instanceof Patch )
278 {
279 try
280 {
281 futures.add( applyToPatch( ( Patch )p ) );
282 }
283 catch ( Exception e )
284 {
285 e.printStackTrace();
286 }
287 }
288 }
289 /* apply to other layers if there are any */
290 if ( !( sublist == null || sublist.isEmpty() ) )
291 {
292 for ( final Layer layer : sublist )
293 {
294 for ( final Displayable p : layer.getDisplayables( Patch.class ) )
295 {
296 try
297 {
298 futures.add( applyToPatch( ( Patch )p ) );
299 }
300 catch ( Exception e )
301 {
302 e.printStackTrace();
303 }
304 }
305 }
306 }
307 }
308
309 /* Flush images */
310 for ( GroupingMode.ScreenPatchRange<?> spr : new HashSet< GroupingMode.ScreenPatchRange<?> >( screenPatchRanges.values() ) )
311 {
312 spr.flush();
313 }
314
315 /* Wait until all mipmaps are regenerated */
316 for ( Future<?> fu : futures )
317 try
318 {
319 fu.get();
320 }
321 catch ( Exception ie )
322 {}
323
324 // Set undo step to reflect final state after applying transformations
325 setUndoState();
326
327 }
328 }, layer.getProject() );
329
330 super.quitThreads();
331
332 return true;
333 }
334
335 private CoordinateTransform createCT() throws Exception
336 {
337 final Collection< PointMatch > pm = new ArrayList<PointMatch>();
338 for ( Point p : points )
339 {
340 pm.add( new PointMatch( new Point( p.getL() ), new Point( p.getW() ) ) );
341 }
342 /*
343 * TODO replace this with the desired parameters of the transformation
344 */
345 final MovingLeastSquaresTransform2 mlst = new MovingLeastSquaresTransform2();
346 mlst.setAlpha( 1.0f );
347 Class< ? extends AbstractAffineModel2D< ? > > c = AffineModel2D.class;
348 switch (points.size()) {
349 case 1:
350 c = TranslationModel2D.class;
351 break;
352 case 2:
353 c = SimilarityModel2D.class;
354 break;
355 default:
356 break;
357 }
358 mlst.setModel( c );
359 mlst.setMatches( pm );
360
361 return mlst;
362 }
363 }
register/edit/analyze/3D model TB of images