Examples with ItemMesh uk.ac.sussex.gdsc.smlm.ij.ij3d.ItemMesh used on opensource projects

Example 1 with ItemMesh

use of uk.ac.sussex.gdsc.smlm.ij.ij3d.ItemMesh in project GDSC-SMLM by aherbert.

the class ImageJ3DResultsViewer method createItemMesh.

private static ItemMesh createItemMesh(final ImageJ3DResultsViewerSettingsOrBuilder settings, LocalList<Point3f> points, final Point3f[] sphereSize, float transparency, float[] alpha) {
    final Rendering rendering = Rendering.forNumber(settings.getRendering());
    final int colorDepth = (alpha != null) ? 4 : 3;
    final Shape3D shape = Shape3DHelper.createShape(rendering, colorDepth);
    final GeometryArray ga = (GeometryArray) shape.getGeometry();
    final Appearance appearance = shape.getAppearance();
    // Estimate the largest array required for the data.
    // The mesh is created by reference using an array for coords, normals and colors.
    final int singlePointVertexSize = ga.getValidVertexCount();
    int singlePointIndexSize = 0;
    final int stride = Math.max(3, colorDepth);
    if (ga instanceof IndexedGeometryArray) {
        // Indexed arrays may have much larger index array than the vertex array
        singlePointIndexSize = ((IndexedGeometryArray) ga).getIndexCount();
    }
    final int singlePointSize = Math.max(singlePointIndexSize, stride * singlePointVertexSize);
    final long arraySize = (long) points.size() * singlePointSize;
    if (arraySize > CustomContentHelper.MAX_ARRAY_SIZE) {
        final double capacity = (double) arraySize / CustomContentHelper.MAX_ARRAY_SIZE;
        // @formatter:off
        IJ.error(TITLE, TextUtils.wrap(String.format("The results will generate data of %d values. " + "This is amount of data is not supported (%.2fx capacity). " + "Please choose a different dataset with fewer points or " + "different rendering model.", arraySize, capacity), 80));
        // @formatter:on
        return null;
    }
    // Support drawing as points ...
    if (settings.getRendering() == 0) {
        final ItemMesh mesh = new ReferenceItemMesh(points.toArray(new Point3f[0]), ga, appearance, null, null, transparency);
        if (alpha != null) {
            mesh.setItemAlpha(alpha);
        }
        mesh.getAppearance().getPointAttributes().setPointSize(sphereSize[0].x);
        return mesh;
    }
    final int triangles = Shape3DHelper.getNumberOfTriangles(rendering);
    final long size = (long) points.size() * triangles;
    if (size > 10000000L) {
        final ExtendedGenericDialog egd = new ExtendedGenericDialog(TITLE);
        egd.addMessage("The results will generate a large mesh of " + size + " triangles.\nThis may take a long time to render and may run out of memory.");
        egd.setOKLabel("Continue");
        egd.showDialog();
        if (egd.wasCanceled()) {
            return null;
        }
    }
    IJ.showStatus("Creating 3D mesh ...");
    final ItemMesh mesh = new ReferenceItemMesh(points.toArray(new Point3f[0]), ga, appearance, sphereSize, null, transparency);
    if (alpha != null) {
        mesh.setItemAlpha(alpha);
    }
    return mesh;
}

Example 2 with ItemMesh

use of uk.ac.sussex.gdsc.smlm.ij.ij3d.ItemMesh in project GDSC-SMLM by aherbert.

the class ImageJ3DResultsViewerDemo method run.

@Override
public void run(String arg) {
    if (ImageJ3DViewerUtils.JAVA_3D_VERSION == null) {
        IJ.error(TITLE, "Java 3D is not available");
        return;
    }
    final boolean renderingTest = true;
    if (renderingTest) {
        // Put all the shapes from rendering on a view and see how they look.
        final Image3DUniverse univ = new Image3DUniverse();
        univ.showAttribute(DefaultUniverse.ATTRIBUTE_SCALEBAR, false);
        univ.show();
        final ImageWindow3D w = univ.getWindow();
        GUI.center(w);
        // Test how many vertices a primitive sphere has
        float x = 0;
        final float y = 0;
        final float space = 2.5f;
        for (final Rendering rendering : Rendering.values()) {
            final Shape3D shape = Shape3DHelper.createShape(rendering, 3);
            final Appearance a = shape.getAppearance();
            final ItemMesh mesh = new ReferenceItemMesh(new Point3f[] { new Point3f(x, y, 0) }, (GeometryArray) shape.getGeometry(), a, null, null, 0f);
            ImageJUtils.log("R=%s %s  Vc=%d  V=%d  T=%d", rendering, shape.getGeometry().getClass().getSimpleName(), mesh.getVerticesCountPerItem(), mesh.getVerticesPerItem(), Shape3DHelper.getNumberOfTriangles(rendering));
            if (rendering == Rendering.POINT) {
                a.getPointAttributes().setPointSize(10);
            }
            univ.addCustomMesh(mesh, x + "," + y);
            x += space;
        }
        return;
    }
    final boolean sphereTest = true;
    if (sphereTest) {
        // Sphere test
        // Put lots of spheres on a view and see how they look.
        // Is it worth supporting an ItemTriangleStripMesh so we can control
        // the sphere better than the icosahedron?
        final Image3DUniverse univ = new Image3DUniverse();
        univ.showAttribute(DefaultUniverse.ATTRIBUTE_SCALEBAR, false);
        univ.show();
        final ImageWindow3D w = univ.getWindow();
        GUI.center(w);
        // Test how many vertices a primitive sphere has
        float x = 0;
        float y = 0;
        final float space = 2.5f;
        Appearance app = null;
        for (int d = 0; d < 4; d++) {
            final List<Point3f> points = customnode.MeshMaker.createIcosahedron(d, 1f);
            final Pair<Point3f[], int[]> p = CustomContentHelper.createIndexedObject(points);
            final int v = points.size();
            final int t = v / 3;
            ImageJUtils.log("Icosahedron divisions = %d, V=%d, T=%d, Vi=%d (%.2f), i=%d", d, v, t, p.getKey().length, v / (double) p.getKey().length, p.getValue().length);
            CustomMesh mesh = new ItemTriangleMesh(points.toArray(new Point3f[0]), new Point3f[] { new Point3f(x, y, 0) }, null, null, 0);
            app = mesh.getAppearance();
            univ.addCustomMesh(mesh, x + "," + y + "," + t);
            final float y2 = y + space;
            mesh = new ItemIndexedTriangleMesh(p.getKey(), p.getValue(), new Point3f[] { new Point3f(x, y2, 0) }, null, null, 0);
            univ.addCustomMesh(mesh, x + "," + y2 + "," + t);
            x += space;
        }
        // Avoid null pointer warnings
        if (app == null) {
            throw new NullPointerException();
        }
        // The T=800 sphere looks about the same as the Icosahedron(div=3) T=1280
        // This may be a better super-high resolution option.
        x = 0;
        y += 2 * space;
        app = (Appearance) app.cloneNodeComponent(true);
        // a.getColoringAttributes().setColor(0, 1, 0);
        app.getMaterial().setDiffuseColor(0, 1, 0);
        for (int d = 4; d < 50; d += 4) {
            // This is a triangle strip array so is more space efficient
            final Sphere s = new Sphere(1, Primitive.GENERATE_NORMALS, d);
            final int t = s.getNumTriangles();
            ImageJUtils.log("Sphere divisions = %d, V=%d, T=%d", d, s.getNumVertices(), t);
            final ItemGeometryGroup g = new ItemGeometryGroup(new Point3f[] { new Point3f(x, y, 0) }, (GeometryArray) s.getShape().getGeometry(), app, null, null, null);
            final String name = x + "," + y + "," + t;
            final CustomContent content = new CustomContent(name, true);
            content.getCurrent().display(new ItemGroupNode(g));
            univ.addContent(content);
            x += space;
        }
        return;
    }
    LocalList<Point3f> pointList;
    float scale;
    if (MemoryPeakResults.isMemoryEmpty()) {
        pointList = new LocalList<>();
        int range;
        // 9 points
        range = 1;
        // range = 49; // 99^3 = 970299 points
        for (int x = -range; x <= range; x++) {
            for (int y = -range; y <= range; y++) {
                for (int z = -range; z <= range; z++) {
                    pointList.add(new Point3f(x, y, z));
                }
            }
        }
        scale = 0.25f;
    } else {
        final ImageJ3DResultsViewerSettings.Builder settings = SettingsManager.readImageJ3DResultsViewerSettings(0).toBuilder();
        final ExtendedGenericDialog gd = new ExtendedGenericDialog(TITLE);
        gd.addMessage("Select a dataset to display");
        ResultsManager.addInput(gd, settings.getInputOption(), InputSource.MEMORY);
        gd.showDialog();
        if (gd.wasCanceled()) {
            return;
        }
        final String name = ResultsManager.getInputSource(gd);
        settings.setInputOption(name);
        SettingsManager.writeSettings(settings);
        final MemoryPeakResults results = ResultsManager.loadInputResults(name, false, null, null);
        if (MemoryPeakResults.isEmpty(results)) {
            IJ.error(TITLE, "No results could be loaded");
            IJ.showStatus("");
            return;
        }
        pointList = ImageJ3DResultsViewer.getPoints(results, settings);
        if (pointList == null) {
            return;
        }
        scale = 10f;
    }
    final Image3DUniverse univ = new Image3DUniverse();
    univ.showAttribute(DefaultUniverse.ATTRIBUTE_SCALEBAR, false);
    univ.show();
    final ImageWindow3D w = univ.getWindow();
    GUI.center(w);
    final View view = univ.getViewer().getView();
    view.setTransparencySortingPolicy(View.TRANSPARENCY_SORT_GEOMETRY);
    // I am not sure if this is required if objects are sorted.
    // view.setDepthBufferFreezeTransparent(false)
    IJ.showStatus("Creating points ...");
    final Point3f[] points = pointList.toArray(new Point3f[0]);
    final Point3f[] sizes = new Point3f[] { new Point3f(scale, scale, scale) };
    final Appearance appearance = new Appearance();
    final TransparencyAttributes ta = new TransparencyAttributes();
    ta.setTransparency(0.5f);
    ta.setTransparencyMode(TransparencyAttributes.FASTEST);
    appearance.setTransparencyAttributes(ta);
    final ItemGeometryGroup pointGroup = new ItemGeometryGroup(points, null, appearance, sizes, null, null);
    // pointGroup = new OrderedItemGeometryGroup(points, null, appearance, sizes, null, null);
    // // This supports transparency sorting
    // BranchGroup bg = new BranchGroup();
    // bg.addChild(pointGroup);
    // bg.compile();
    // univ.getScene().addChild(bg);
    // // This does not since ContentInstant uses an OrderedPath to show:
    // // the content; the object bounding box, coordinate system and point list
    // final Content c = new Content("Test");
    // final ContentInstant content = c.getCurrent();
    // content.display(new PointGroupNode(pointGroup));
    // univ.addContent(c);
    // This does since ItemGeometryNode uses a Group to show the points as individual shapes
    // and the CustomContentInstant uses a group not an ordered group so show all the adornments.
    IJ.showStatus("Displaying points ...");
    final CustomContent c = new CustomContent("Test", false);
    final ContentInstant content = c.getCurrent();
    content.display(new ItemGroupNode(pointGroup));
    univ.addContent(c);
    IJ.showStatus("Done");
}

Example 3 with ItemMesh

use of uk.ac.sussex.gdsc.smlm.ij.ij3d.ItemMesh in project GDSC-SMLM by aherbert.

the class ImageJ3DResultsViewer method run.

@Override
public void run(String arg) {
    // For testing
    // if (true || Utils.isExtraOptions())
    // {
    // new ImageJ3DResultsViewerDemo().run(arg);
    // return;
    // }
    SmlmUsageTracker.recordPlugin(this.getClass(), arg);
    if (ImageJ3DViewerUtils.JAVA_3D_VERSION == null) {
        IJ.error(TITLE, "Java 3D is not available");
        return;
    }
    if (MemoryPeakResults.isMemoryEmpty()) {
        IJ.error(TITLE, "There are no fitting results in memory");
        return;
    }
    final ImageJ3DResultsViewerSettings.Builder settings = SettingsManager.readImageJ3DResultsViewerSettings(0).toBuilder();
    addToSelection.set(settings.getAddToSelection());
    // Get a list of the window titles available. Allow the user to select
    // an existing window or a new one.
    final String title = TITLE;
    final List<Image3DUniverse> univList = new LocalList<>();
    final List<String> titleList = new LocalList<>();
    titleList.add("New window");
    buildWindowList(title, univList, titleList);
    final String[] titles = titleList.toArray(new String[0]);
    final ExtendedGenericDialog gd = new ExtendedGenericDialog(TITLE);
    gd.addMessage("Select a dataset to display");
    ResultsManager.addInput(gd, settings.getInputOption(), InputSource.MEMORY);
    // The behaviour is to allow the settings to store if the user prefers a new window
    // or to reuse an existing window. If 'new window' then a new window should always
    // be selected. Otherwise open in the same window as last time. If there was no last
    // window then the settings will carried over from the last ImageJ session.
    final String window = (settings.getNewWindow()) ? "" : lastWindow.get();
    gd.addChoice("Window", titles, window);
    gd.addSlider("Transparancy", 0, 0.9, settings.getTransparency(), new OptionListener<Double>() {

        @Override
        public boolean collectOptions(Double value) {
            return collectOptions(false);
        }

        @Override
        public boolean collectOptions() {
            return collectOptions(true);
        }

        private boolean collectOptions(boolean silent) {
            final ExtendedGenericDialog egd = new ExtendedGenericDialog("Transparancy options", null);
            egd.addCheckbox("Support_dynamic_transparency", settings.getSupportDynamicTransparency());
            egd.addCheckbox("Enable_dynamic_transparency", settings.getEnableDynamicTransparency());
            egd.setSilent(silent);
            egd.showDialog(true, gd);
            if (egd.wasCanceled()) {
                return false;
            }
            settings.setSupportDynamicTransparency(egd.getNextBoolean());
            settings.setEnableDynamicTransparency(egd.getNextBoolean());
            return true;
        }
    });
    gd.addChoice("Colour", LutHelper.getLutNames(), settings.getLut());
    gd.addChoice("Rendering", RENDERING, settings.getRendering(), new OptionListener<Integer>() {

        @Override
        public boolean collectOptions(Integer value) {
            settings.setRendering(value);
            return collectOptions(false);
        }

        @Override
        public boolean collectOptions() {
            return collectOptions(true);
        }

        private boolean collectOptions(boolean silent) {
            final ExtendedGenericDialog egd = new ExtendedGenericDialog("Drawing mode options", null);
            final int rendering = settings.getRendering();
            if (rendering != 0) {
                return false;
            }
            egd.addNumericField("Pixel_size", settings.getPixelSize(), 2, 6, "px");
            egd.setSilent(silent);
            egd.showDialog(true, gd);
            if (egd.wasCanceled()) {
                return false;
            }
            settings.setPixelSize(egd.getNextNumber());
            return true;
        }
    });
    gd.addCheckbox("Shaded", settings.getShaded());
    gd.addChoice("Size_mode", SIZE_MODE, settings.getSizeMode(), new OptionListener<Integer>() {

        @Override
        public boolean collectOptions(Integer value) {
            settings.setSizeMode(value);
            return collectOptions(false);
        }

        @Override
        public boolean collectOptions() {
            return collectOptions(true);
        }

        private boolean collectOptions(boolean silent) {
            final ExtendedGenericDialog egd = new ExtendedGenericDialog("Size mode options", null);
            final SizeMode mode = SizeMode.forNumber(settings.getSizeMode());
            if (mode == SizeMode.FIXED_SIZE) {
                egd.addNumericField("Size", settings.getSize(), 2, 6, "nm");
            } else {
                // Other modes do not require options
                return false;
            }
            egd.setSilent(silent);
            egd.showDialog(true, gd);
            if (egd.wasCanceled()) {
                return false;
            }
            settings.setSize(egd.getNextNumber());
            return true;
        }
    });
    gd.addChoice("Sort_mode", SORT_MODE, settings.getSortMode(), new OptionListener<Integer>() {

        @Override
        public boolean collectOptions(Integer value) {
            settings.setSortMode(value);
            return collectOptions(false);
        }

        @Override
        public boolean collectOptions() {
            return collectOptions(true);
        }

        private boolean collectOptions(boolean silent) {
            final ExtendedGenericDialog egd = new ExtendedGenericDialog("Sort mode options", null);
            final SortMode mode = SortMode.forNumber(settings.getSortMode());
            if (mode == SortMode.NONE) {
                return false;
            }
            egd.addMessage(TextUtils.wrap("Note: The sort mode is used to correctly render transparent objects. " + "For non-transparent objects faster rendering is achieved with a reverse " + "sort to put close objects at the front.", 80));
            egd.addMessage(TextUtils.wrap(mode.getDetails(), 80));
            egd.addMessage("Define the direction of the view");
            egd.addNumericField("Direction_x", settings.getSortDirectionX(), 3, 10, "");
            egd.addNumericField("Direction_y", settings.getSortDirectionY(), 3, 10, "");
            egd.addNumericField("Direction_z", settings.getSortDirectionZ(), 3, 10, "");
            if (mode == SortMode.PERSPECTIVE) {
                egd.addMessage("Define the view eye position");
                egd.addNumericField("Eye_x", settings.getSortEyeX(), 3, 10, "nm");
                egd.addNumericField("Eye_y", settings.getSortEyeY(), 3, 10, "nm");
                egd.addNumericField("Eye_z", settings.getSortEyeZ(), 3, 10, "nm");
            }
            egd.setSilent(silent);
            egd.showDialog(true, gd);
            if (egd.wasCanceled()) {
                return false;
            }
            settings.setSortDirectionX(egd.getNextNumber());
            settings.setSortDirectionY(egd.getNextNumber());
            settings.setSortDirectionZ(egd.getNextNumber());
            if (mode == SortMode.PERSPECTIVE) {
                settings.setSortEyeX(egd.getNextNumber());
                settings.setSortEyeY(egd.getNextNumber());
                settings.setSortEyeZ(egd.getNextNumber());
            }
            return true;
        }
    });
    gd.addChoice("Transparency_mode", TRANSPARENCY_MODE, settings.getTransparencyMode(), new OptionListener<Integer>() {

        @Override
        public boolean collectOptions(Integer value) {
            settings.setTransparencyMode(value);
            return collectOptions(false);
        }

        @Override
        public boolean collectOptions() {
            return collectOptions(true);
        }

        private boolean collectOptions(boolean silent) {
            final ExtendedGenericDialog egd = new ExtendedGenericDialog("Transparency mode options", null);
            final TransparencyMode mode = TransparencyMode.forNumber(settings.getTransparencyMode());
            if (mode == TransparencyMode.NONE) {
                return false;
            }
            egd.addSlider("Min_transparancy", 0, 0.95, settings.getMinTransparency());
            egd.addSlider("Max_transparancy", 0, 0.95, settings.getMaxTransparency());
            egd.setSilent(silent);
            egd.showDialog(true, gd);
            if (egd.wasCanceled()) {
                return false;
            }
            settings.setMinTransparency(egd.getNextNumber());
            settings.setMaxTransparency(egd.getNextNumber());
            return true;
        }
    });
    addColourMode(settings, gd);
    gd.addMessage("2D options");
    gd.addChoice("Depth_mode", DEPTH_MODE, settings.getDepthMode(), new OptionListener<Integer>() {

        @Override
        public boolean collectOptions(Integer value) {
            settings.setDepthMode(value);
            return collectOptions(false);
        }

        @Override
        public boolean collectOptions() {
            return collectOptions(true);
        }

        private boolean collectOptions(boolean silent) {
            final ExtendedGenericDialog egd = new ExtendedGenericDialog("Depth mode options", null);
            final DepthMode mode = DepthMode.forNumber(settings.getDepthMode());
            if (mode == DepthMode.NONE) {
                return false;
            }
            egd.addNumericField("Depth_range", settings.getDepthRange(), 2, 6, "nm");
            if (mode == DepthMode.DITHER) {
                egd.addNumericField("Dither_seed", settings.getDitherSeed(), 0);
            }
            egd.setSilent(silent);
            egd.showDialog(true, gd);
            if (egd.wasCanceled()) {
                return false;
            }
            settings.setDepthRange(egd.getNextNumber());
            if (mode == DepthMode.DITHER) {
                settings.setDitherSeed((int) egd.getNextNumber());
            }
            return true;
        }
    });
    addHelp(gd);
    gd.showDialog();
    if (gd.wasCanceled()) {
        return;
    }
    final String name = ResultsManager.getInputSource(gd);
    final int windowChoice = gd.getNextChoiceIndex();
    lastWindow.set(titles[windowChoice]);
    settings.setInputOption(name);
    settings.setTransparency(gd.getNextNumber());
    settings.setLut(gd.getNextChoiceIndex());
    settings.setRendering(gd.getNextChoiceIndex());
    settings.setShaded(gd.getNextBoolean());
    settings.setSizeMode(gd.getNextChoiceIndex());
    settings.setSortMode(gd.getNextChoiceIndex());
    settings.setTransparencyMode(gd.getNextChoiceIndex());
    settings.setColourMode(gd.getNextChoiceIndex());
    settings.setDepthMode(gd.getNextChoiceIndex());
    gd.collectOptions();
    if (windowChoice == 0) {
        // Store if the user chose a new window when they had a choice of an existing window
        if (titleList.size() > 1) {
            settings.setNewWindow(true);
        // Otherwise they had no choice so leave the preferences as they are.
        }
    } else {
        // This was not a new window
        settings.setNewWindow(false);
    }
    SettingsManager.writeSettings(settings);
    MemoryPeakResults results = ResultsManager.loadInputResults(name, false, null, null);
    if (MemoryPeakResults.isEmpty(results)) {
        IJ.error(TITLE, "No results could be loaded");
        return;
    }
    // Determine if the drawing mode is supported and compute the point size
    final Point3f[] sphereSize = createSphereSize(results, settings);
    if (sphereSize == null) {
        return;
    }
    // Cache the table settings
    resultsTableSettings.set(settings.getResultsTableSettings());
    // Create a 3D viewer.
    if (windowChoice == 0) {
        univ = createImage3DUniverse(title, titleList);
    } else {
        // Ignore the new window
        univ = univList.get(windowChoice - 1);
    }
    lastWindow.set(univ.getWindow().getTitle());
    results = results.copy();
    // Commence a digest
    final Future<PeakResultsDigest> futureDigest = PeakResultsDigest.digestLater(executorService, results.toArray());
    final LocalList<Point3f> points = getPoints(results, settings);
    final ResultsMetaData data = new ResultsMetaData(settings.build(), results, points, sphereSize);
    sort(data);
    final float[] alpha = createAlpha(results, settings, sphereSize);
    final float transparency = getTransparency(settings);
    final Color3f[] colors = createColour(results, settings);
    ContentNode contentNode;
    // Build to support true transparency (depends on settings).
    // Currently this is not supported for PointArrays as they require colouring
    // in the coordinate data.
    IJ.showStatus("Creating 3D geometry ...");
    if (settings.getSupportDynamicTransparency()) {
        final ItemGeometryGroup pointGroup = createItemGroup(settings, sphereSize, points, alpha, transparency, colors);
        if (pointGroup == null) {
            IJ.showStatus("");
            return;
        }
        if (settings.getEnableDynamicTransparency()) {
            final long total = points.size() + getTotalTransparentObjects(univ, name);
            activateDynamicTransparency(univ, total, settings.getEnableDynamicTransparency());
        } else {
            activateDynamicTransparency(univ, 0, settings.getEnableDynamicTransparency());
        }
        contentNode = new ItemGroupNode(pointGroup);
    } else {
        final ItemMesh mesh = createItemMesh(settings, points, sphereSize, transparency, alpha);
        if (mesh == null) {
            IJ.showStatus("");
            return;
        }
        setColour(mesh, colors);
        contentNode = new CustomMeshNode(mesh);
    }
    IJ.showStatus("Creating 3D content ...");
    // Use custom content to support adding new switchable nodes
    final CustomContent content = new CustomContent(name, !settings.getSupportDynamicTransparency());
    final CustomContentInstant contentInstant = (CustomContentInstant) content.getCurrent();
    contentInstant.setTransparency((float) settings.getTransparency());
    contentInstant.setShaded(settings.getShaded());
    contentInstant.showCoordinateSystem(UniverseSettings.showLocalCoordinateSystemsByDefault);
    contentInstant.display(contentNode);
    createHighlightColour(settings.getHighlightColour());
    content.setUserData(data);
    // Prevent relative rotation
    content.setLocked(true);
    // Set up the click selection node
    data.createClickSelectionNode(contentInstant);
    // Set up the results selection model
    data.digest = PeakResultsDigest.waitForDigest(futureDigest, -1);
    if (data.digest == null) {
        IJ.error(TITLE, "Failed to identify repeat results set");
        IJ.showStatus("");
        return;
    }
    Triple<PeakResultTableModel, ListSelectionModel, PeakResultTableModelFrame> triplet = resultsTables.get(data.digest);
    if (triplet == null) {
        triplet = Triple.of(new PeakResultTableModel(results, false, // Note the settings do not matter until the table is set live
        resultsTableSettings.get()), new DefaultListSelectionModel(), null);
        triplet.getLeft().setCheckDuplicates(true);
        resultsTables.put(data.digest, triplet);
    }
    // Preserve orientation on the content
    final boolean auto = univ.getAutoAdjustView();
    final Content oldContent = univ.getContent(name);
    if (oldContent == null) {
        univ.setAutoAdjustView(true);
    } else {
        univ.removeContent(name);
        univ.setAutoAdjustView(false);
    }
    IJ.showStatus("Drawing 3D content ... ");
    final StopWatch sw = StopWatch.createStarted();
    final Future<Content> future = univ.addContentLater(content);
    Content added = null;
    for (; ; ) {
        try {
            // Wait for 1 second
            for (int i = 0; i < 20; i++) {
                Thread.sleep(50);
                if (future.isDone()) {
                    // Only get the result when finished, so avoiding a blocking wait
                    added = future.get();
                    break;
                }
            }
            if (added != null) {
                break;
            }
            final long seconds = sw.getTime(TimeUnit.SECONDS);
            if (seconds % 20 == 0) {
                final ExtendedGenericDialog egd = new ExtendedGenericDialog(TITLE, null);
                egd.addMessage("Current wait time is " + sw.toString());
                egd.setOKLabel("Wait");
                egd.showDialog();
                if (egd.wasCanceled()) {
                    future.cancel(true);
                    break;
                }
            }
            IJ.showStatus("Drawing 3D content ... " + seconds);
        } catch (final InterruptedException ex) {
            Thread.currentThread().interrupt();
        } catch (final ExecutionException ex) {
            break;
        }
    }
    univ.setAutoAdjustView(auto);
    // Initialise the selection model
    if (added != null) {
        data.addSelectionModel(triplet);
    }
    IJ.showStatus("");
}