From 2ec9d8761e958a70da6b0da96395c1bd9280525f Mon Sep 17 00:00:00 2001 From: Matthias Arzt Date: Tue, 4 Jul 2023 12:03:22 +0200 Subject: [PATCH] Add MultiEmbryoRegistration --- .../MultiEmbryoRegistration.java | 140 ++++++++++++++++++ 1 file changed, 140 insertions(+) create mode 100644 src/test/java/org/mastodon/mamut/tomancak/lineage_registration/MultiEmbryoRegistration.java diff --git a/src/test/java/org/mastodon/mamut/tomancak/lineage_registration/MultiEmbryoRegistration.java b/src/test/java/org/mastodon/mamut/tomancak/lineage_registration/MultiEmbryoRegistration.java new file mode 100644 index 00000000..58e53265 --- /dev/null +++ b/src/test/java/org/mastodon/mamut/tomancak/lineage_registration/MultiEmbryoRegistration.java @@ -0,0 +1,140 @@ +package org.mastodon.mamut.tomancak.lineage_registration; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import org.apache.commons.lang3.tuple.Pair; +import org.mastodon.collection.RefIntMap; +import org.mastodon.collection.RefRefMap; +import org.mastodon.collection.ref.RefIntHashMap; +import org.mastodon.mamut.ProjectModel; +import org.mastodon.mamut.io.ProjectLoader; +import org.mastodon.mamut.model.Link; +import org.mastodon.mamut.model.Model; +import org.mastodon.mamut.model.Spot; +import org.mastodon.mamut.tomancak.lineage_registration.spatial_registration.SpatialRegistrationMethod; +import org.mastodon.mamut.views.trackscheme.MamutBranchViewTrackScheme; +import org.mastodon.model.tag.ObjTagMap; +import org.mastodon.model.tag.TagSetStructure; +import org.mastodon.util.TagSetUtils; +import org.scijava.Context; + +import mpicbg.spim.data.SpimDataException; + +/** + * Do pairwise {@link LineageRegistrationAlgorithm lineage registration} of multiple embryos. + * Tag the cells that are uniquely identified by the registration, without contradiction. + */ +public class MultiEmbryoRegistration +{ + public static void main( final String... args ) + { + final List< String > projectPaths = Arrays.asList( + "/home/arzt/Datasets/Mette/E1.mastodon", + "/home/arzt/Datasets/Mette/E2.mastodon", + "/home/arzt/Datasets/Mette/E3.mastodon" + ); + try (final Context context = new Context()) + { + final List< ProjectModel > projectModels = projectPaths.stream().map( path -> { + try + { + return ProjectLoader.open( path, context, false, true ); + } + catch ( IOException | SpimDataException e ) + { + throw new RuntimeException( e ); + } + } ).collect( Collectors.toList() ); + final List< Model > models = projectModels.stream().map( ProjectModel::getModel ).collect( Collectors.toList() ); + // FIXME: models.forEach( model -> ImproveAnglesDemo.removeBackEdges( model.getGraph() ) ); + createTags( models.get( 0 ), computeAgreement( models ) ); + projectModels.get( 0 ).getWindowManager().createView( MamutBranchViewTrackScheme.class ); + } + } + + private static RefIntMap< Spot > computeAgreement( final List< Model > models ) + { + final Map< Pair< Model, Model >, RefRefMap< Spot, Spot > > registrations = new HashMap<>(); + for ( final Pair< Model, Model > pair : makePairs( models ) ) + registrations.put( pair, register( pair.getLeft(), pair.getRight() ) ); + + final Model firstModel = models.get( 0 ); + final RefIntMap< Spot > agreement = new RefIntHashMap<>( firstModel.getGraph().vertices().getRefPool(), 0 ); + + final List< Model > otherModels = models.subList( 1, models.size() ); + for ( final Pair< Model, Model > pair : makePairs( otherModels ) ) + { + final Model otherModelA = pair.getLeft(); + final Model otherModelB = pair.getRight(); + final RefRefMap< Spot, Spot > registrationA = registrations.get( Pair.of( firstModel, otherModelA ) ); + final RefRefMap< Spot, Spot > registrationB = registrations.get( Pair.of( firstModel, otherModelB ) ); + final RefRefMap< Spot, Spot > registrationAB = registrations.get( pair ); + incrementAgreement( agreement, registrationA, registrationB, registrationAB ); + } + + return agreement; + } + + private static void incrementAgreement( final RefIntMap< Spot > agreement, final RefRefMap< Spot, Spot > registrationA, final RefRefMap< Spot, Spot > registrationB, + final RefRefMap< Spot, Spot > registrationAB ) + { + final Spot refA = registrationA.createValueRef(); + final Spot refB = registrationB.createValueRef(); + final Spot refB2 = registrationAB.createValueRef(); + for ( final Spot key : registrationA.keySet() ) + if ( registrationB.containsKey( key ) ) + { + final Spot spotA = registrationA.get( key, refA ); + final Spot spotB = registrationB.get( key, refB ); + final Spot crossSpotB = registrationAB.get( spotA, refB2 ); + final boolean correct = spotB.equals( crossSpotB ); + if ( correct ) + agreement.put( key, agreement.get( key ) + 1 ); + } + } + + private static RefRefMap< Spot, Spot > register( final Model firstModel, final Model otherModel ) + { + return LineageRegistrationAlgorithm.run( firstModel, 0, otherModel, 0, SpatialRegistrationMethod.DYNAMIC_ROOTS ).mapAB; + } + + private static List< Pair< Model, Model > > makePairs( final List< Model > otherModels ) + { + final List< Pair< Model, Model > > spokes = new ArrayList<>(); + for ( int i = 0; i < otherModels.size(); i++ ) + for ( int j = i + 1; j < otherModels.size(); j++ ) + spokes.add( Pair.of( otherModels.get( i ), otherModels.get( j ) ) ); + return spokes; + } + + private static void createTags( final Model firstModel, final RefIntMap< Spot > agreement ) + { + int max = 0; + for ( final Spot spot : agreement.keySet() ) + max = Math.max( max, agreement.get( spot ) ); + final List< Pair< String, Integer > > correct = + IntStream.rangeClosed( 0, max ).mapToObj( i -> Pair.of( String.valueOf( i ), Glasbey.GLASBEY[ i + 1 ] ) ).collect( Collectors.toList() ); + + final TagSetStructure.TagSet tagSet = TagSetUtils.addNewTagSetToModel( firstModel, "UnifiedEmbryo", correct ); + final List< TagSetStructure.Tag > tags = tagSet.getTags(); + final ObjTagMap< Link, TagSetStructure.Tag > edgeTags = firstModel.getTagSetModel().getEdgeTags().tags( tagSet ); + for ( final Spot spot : agreement.keySet() ) + { + final int value = agreement.get( spot ); + final TagSetStructure.Tag tag = tags.get( max - value ); + TagSetUtils.tagBranch( firstModel, tagSet, tag, spot ); + if ( spot.incomingEdges().size() == 1 ) + { + final Link link = spot.incomingEdges().iterator().next(); + edgeTags.set( link, tag ); + } + } + } +}