Examples with Node ini.trakem2.display.Node used on opensource projects

Example 6 with Node

use of ini.trakem2.display.Node in project TrakEM2 by trakem2.

the class Tree method colorizeByBranchBetweennessCentrality.

public void colorizeByBranchBetweennessCentrality(final int etching_multiplier) {
    if (null == root)
        return;
    final Collection<Vertex<Node<T>>> vs = asVertices().values();
    Centrality.branchWise(vs, etching_multiplier);
    final IndexColorModel cm = Utils.fireLUT();
    final Map<Integer, Color> colors = new HashMap<Integer, Color>();
    double max = 0;
    for (final Vertex<?> v : vs) max = Math.max(max, v.centrality);
    if (0 == max) {
        Utils.logAll("Branch centrality: all have zero!");
        return;
    }
    for (final Vertex<Node<T>> v : vs) {
        final int i = (int) (255 * (v.centrality / max) + 0.5f);
        Utils.log("branch centrality: " + v.centrality + " , i: " + i);
        Color c = colors.get(i);
        if (null == c) {
            c = new Color(cm.getRed(i), cm.getGreen(i), cm.getBlue(i));
            colors.put(i, c);
        }
        v.data.setColor(c);
    }
}

Example 7 with Node

use of ini.trakem2.display.Node in project TrakEM2 by trakem2.

the class Tree method colorizeByNodeBetweennessCentrality.

public void colorizeByNodeBetweennessCentrality() {
    if (null == root)
        return;
    final HashMap<Node<T>, Vertex<Node<T>>> m = asVertices();
    Centrality.compute(m.values());
    final IndexColorModel cm = Utils.fireLUT();
    final Map<Integer, Color> colors = new HashMap<Integer, Color>();
    double max = 0;
    for (final Vertex<?> v : m.values()) max = Math.max(max, v.centrality);
    for (final Map.Entry<Node<T>, Vertex<Node<T>>> e : m.entrySet()) {
        final int i = (int) (255 * (e.getValue().centrality / max) + 0.5f);
        Color c = colors.get(i);
        if (null == c) {
            c = new Color(cm.getRed(i), cm.getGreen(i), cm.getBlue(i));
            colors.put(i, c);
        }
        e.getKey().setColor(c);
    }
}

Example 8 with Node

use of ini.trakem2.display.Node in project TrakEM2 by trakem2.

the class Display3D method show.

/**
 * Scan the {@link ProjectThing} children and assign the renderable ones to an existing {@link Display3D} for their {@link LayerSet}, or open a new one. If {@code true == wait && -1 != resample}, then the method returns only when the mesh/es have been added.
 */
public static Future<Vector<Future<Content>>> show(final ProjectThing pt, final boolean wait, final int resample) {
    if (null == pt)
        return null;
    final Future<Vector<Future<Content>>> fu = launchers.submit(new Callable<Vector<Future<Content>>>() {

        @Override
        public Vector<Future<Content>> call() {
            // Scan the given ProjectThing for 3D-viewable items
            // So: find arealist, pipe, ball, and profile_list types
            final HashSet<ProjectThing> hs = pt.findBasicTypeChildren();
            if (null == hs || 0 == hs.size()) {
                Utils.logAll("Node " + pt + " does not contain any 3D-displayable children");
                return null;
            }
            // Remove profile if it lives under a profile_list
            for (final Iterator<ProjectThing> it = hs.iterator(); it.hasNext(); ) {
                final ProjectThing pt = it.next();
                if (null != pt.getObject() && pt.getObject().getClass() == Profile.class && pt.getParent().getType().equals("profile_list")) {
                    it.remove();
                }
            }
            setWaitingCursor();
            // Start new scheduler to publish/add meshes to the 3D Viewer every 5 seconds and when done.
            final Hashtable<Display3D, Vector<Content>> contents = new Hashtable<Display3D, Vector<Content>>();
            final ScheduledExecutorService updater = Executors.newScheduledThreadPool(1);
            final AtomicInteger counter = new AtomicInteger();
            updater.scheduleWithFixedDelay(new Runnable() {

                @Override
                public void run() {
                    // Obtain a copy of the contents queue
                    final HashMap<Display3D, Vector<Content>> m = new HashMap<Display3D, Vector<Content>>();
                    synchronized (contents) {
                        m.putAll(contents);
                        contents.clear();
                    }
                    if (m.isEmpty())
                        return;
                    // Add all to the corresponding Display3D
                    for (final Map.Entry<Display3D, Vector<Content>> e : m.entrySet()) {
                        e.getKey().universe.addContentLater(e.getValue());
                        counter.getAndAdd(e.getValue().size());
                    }
                    Utils.showStatus(new StringBuilder("Rendered ").append(counter.get()).append('/').append(hs.size()).toString());
                }
            }, 100, 4000, TimeUnit.MILLISECONDS);
            // A list of all generated Content objects
            final Vector<Future<Content>> list = new Vector<Future<Content>>();
            for (final Iterator<ProjectThing> it = hs.iterator(); it.hasNext(); ) {
                // obtain the Displayable object under the node
                final ProjectThing child = it.next();
                final Object obc = child.getObject();
                final Displayable displ = obc.getClass().equals(String.class) ? null : (Displayable) obc;
                if (null != displ) {
                    if (displ.getClass().equals(Profile.class)) {
                        // handled by profile_list Thing
                        continue;
                    }
                    if (!displ.isVisible()) {
                        Utils.log("Skipping non-visible node " + displ);
                        continue;
                    }
                }
                // obtain the containing LayerSet
                final Display3D d3d;
                if (null != displ)
                    d3d = Display3D.get(displ.getLayerSet());
                else if (child.getType().equals("profile_list")) {
                    final ArrayList<ProjectThing> al_children = child.getChildren();
                    if (null == al_children || 0 == al_children.size())
                        continue;
                    // else, get the first Profile and get its LayerSet
                    d3d = Display3D.get(((Displayable) ((ProjectThing) al_children.get(0)).getObject()).getLayerSet());
                } else {
                    Utils.log("Don't know what to do with node " + child);
                    d3d = null;
                }
                if (null == d3d) {
                    Utils.log("Could not get a proper 3D display for node " + displ);
                    // java3D not installed most likely
                    return null;
                }
                boolean already;
                synchronized (d3d.ht_pt_meshes) {
                    already = d3d.ht_pt_meshes.containsKey(child);
                }
                if (already) {
                    if (child.getObject() instanceof ZDisplayable) {
                        Utils.log("Updating 3D view of " + child.getObject());
                    } else {
                        Utils.log("Updating 3D view of " + child);
                    }
                }
                list.add(d3d.executors.submit(new Callable<Content>() {

                    @Override
                    public Content call() {
                        Content c = null;
                        try {
                            c = d3d.createMesh(child, displ, resample).call();
                            Vector<Content> vc;
                            synchronized (contents) {
                                vc = contents.get(d3d);
                                if (null == vc)
                                    vc = new Vector<Content>();
                                contents.put(d3d, vc);
                            }
                            vc.add(c);
                        } catch (final Exception e) {
                            IJError.print(e);
                        }
                        return c;
                    }
                }));
                // If it's the last one:
                if (!it.hasNext()) {
                    // Add the concluding task, that waits on all and shuts down the scheduler
                    d3d.executors.submit(new Runnable() {

                        @Override
                        public void run() {
                            // Wait until all are done
                            for (final Future<Content> c : list) {
                                try {
                                    c.get();
                                } catch (final Throwable t) {
                                    IJError.print(t);
                                }
                            }
                            try {
                                // Shutdown scheduler and execute remaining tasks
                                for (final Runnable r : updater.shutdownNow()) {
                                    r.run();
                                }
                            } catch (final Throwable e) {
                                IJError.print(e);
                            }
                            // Reset cursor
                            doneWaiting();
                            Utils.showStatus(new StringBuilder("Done rendering ").append(counter.get()).append('/').append(hs.size()).toString());
                        }
                    });
                }
            }
            return list;
        }
    });
    if (wait && -1 != resample) {
        try {
            fu.get();
        } catch (final Throwable t) {
            IJError.print(t);
        }
    }
    return fu;
}

Example 9 with Node

use of ini.trakem2.display.Node in project TrakEM2 by trakem2.

the class Loader method importStack.

/**
 * Imports an image stack from a multitiff file and places each slice in the proper layer, creating new layers as it goes. If the given stack is null, popup a file dialog to choose one
 */
public Bureaucrat importStack(final Layer first_layer, final double x, final double y, final ImagePlus imp_stack_, final boolean ask_for_data, final String filepath_, final boolean one_patch_per_layer_) {
    Utils.log2("Loader.importStack filepath: " + filepath_);
    if (null == first_layer)
        return null;
    final Worker worker = new Worker("import stack") {

        @Override
        public void run() {
            startedWorking();
            try {
                String filepath = filepath_;
                boolean one_patch_per_layer = one_patch_per_layer_;
                /* On drag and drop the stack is not null! */
                // Utils.log2("imp_stack_ is " + imp_stack_);
                ImagePlus[] stks = null;
                boolean choose = false;
                if (null == imp_stack_) {
                    stks = Utils.findOpenStacks();
                    choose = null == stks || stks.length > 0;
                } else {
                    stks = new ImagePlus[] { imp_stack_ };
                }
                ImagePlus imp_stack = null;
                // ask to open a stack if it's null
                if (null == stks) {
                    // choose one
                    imp_stack = openStack();
                } else if (choose) {
                    // choose one from the list
                    final GenericDialog gd = new GenericDialog("Choose one");
                    gd.addMessage("Choose a stack from the list or 'open...' to bring up a file chooser dialog:");
                    final String[] list = new String[stks.length + 1];
                    for (int i = 0; i < list.length - 1; i++) {
                        list[i] = stks[i].getTitle();
                    }
                    list[list.length - 1] = "[  Open stack...  ]";
                    gd.addChoice("choose stack: ", list, list[0]);
                    gd.showDialog();
                    if (gd.wasCanceled()) {
                        finishedWorking();
                        return;
                    }
                    final int i_choice = gd.getNextChoiceIndex();
                    if (list.length - 1 == i_choice) {
                        // the open... command
                        imp_stack = first_layer.getProject().getLoader().openStack();
                    } else {
                        imp_stack = stks[i_choice];
                    }
                } else {
                    imp_stack = imp_stack_;
                }
                // check:
                if (null == imp_stack) {
                    finishedWorking();
                    return;
                }
                final String props = (String) imp_stack.getProperty("Info");
                // check if it's amira labels stack to prevent missimports
                if (null != props && -1 != props.indexOf("Materials {")) {
                    final YesNoDialog yn = new YesNoDialog(IJ.getInstance(), "Warning", "You are importing a stack of Amira labels as a regular image stack. Continue anyway?");
                    if (!yn.yesPressed()) {
                        finishedWorking();
                        return;
                    }
                }
                // String dir = imp_stack.getFileInfo().directory;
                final double layer_width = first_layer.getLayerWidth();
                final double layer_height = first_layer.getLayerHeight();
                final double current_thickness = first_layer.getThickness();
                double thickness = current_thickness;
                boolean expand_layer_set = false;
                boolean lock_stack = false;
                // int anchor = LayerSet.NORTHWEST; //default
                if (ask_for_data) {
                    // ask for slice separation in pixels
                    final GenericDialog gd = new GenericDialog("Slice separation?");
                    gd.addMessage("Please enter the slice thickness, in pixels");
                    // assuming pixelWidth == pixelHeight
                    gd.addNumericField("slice_thickness: ", Math.abs(imp_stack.getCalibration().pixelDepth / imp_stack.getCalibration().pixelHeight), 3);
                    if (layer_width != imp_stack.getWidth() || layer_height != imp_stack.getHeight()) {
                        gd.addCheckbox("Resize canvas to fit stack", true);
                    // gd.addChoice("Anchor: ", LayerSet.ANCHORS, LayerSet.ANCHORS[0]);
                    }
                    gd.addCheckbox("Lock stack", false);
                    final String[] importStackTypes = { "One slice per layer (Patches)", "Image volume (Stack)" };
                    if (imp_stack.getStack().isVirtual()) {
                        one_patch_per_layer = true;
                    }
                    gd.addChoice("Import stack as:", importStackTypes, importStackTypes[0]);
                    ((Component) gd.getChoices().get(0)).setEnabled(!imp_stack.getStack().isVirtual());
                    gd.showDialog();
                    if (gd.wasCanceled()) {
                        if (null == stks) {
                            // flush only if it was not open before
                            flush(imp_stack);
                        }
                        finishedWorking();
                        return;
                    }
                    if (layer_width != imp_stack.getWidth() || layer_height != imp_stack.getHeight()) {
                        expand_layer_set = gd.getNextBoolean();
                    // anchor = gd.getNextChoiceIndex();
                    }
                    lock_stack = gd.getNextBoolean();
                    thickness = gd.getNextNumber();
                    // check provided thickness with that of the first layer:
                    if (thickness != current_thickness) {
                        if (1 == first_layer.getParent().size() && first_layer.isEmpty()) {
                            final YesNoCancelDialog yn = new YesNoCancelDialog(IJ.getInstance(), "Mismatch!", "The current layer's thickness is " + current_thickness + "\nwhich is " + (thickness < current_thickness ? "larger" : "smaller") + " than\nthe desired " + thickness + " for each stack slice.\nAdjust current layer's thickness to " + thickness + " ?");
                            if (yn.cancelPressed()) {
                                // was opened new
                                if (null != imp_stack_)
                                    flush(imp_stack);
                                finishedWorking();
                                return;
                            } else if (yn.yesPressed()) {
                                first_layer.setThickness(thickness);
                            // The rest of layers, created new, will inherit the same thickness
                            }
                        } else {
                            final YesNoDialog yn = new YesNoDialog(IJ.getInstance(), "WARNING", "There's more than one layer or the current layer is not empty\nso the thickness cannot be adjusted. Proceed anyway?");
                            if (!yn.yesPressed()) {
                                finishedWorking();
                                return;
                            }
                        }
                    }
                    one_patch_per_layer = imp_stack.getStack().isVirtual() || 0 == gd.getNextChoiceIndex();
                }
                if (null == imp_stack.getStack()) {
                    Utils.showMessage("Not a stack.");
                    finishedWorking();
                    return;
                }
                // WARNING: there are fundamental issues with calibration, because the Layer thickness is disconnected from the Calibration pixelDepth
                // set LayerSet calibration if there is no calibration
                boolean calibrate = true;
                if (ask_for_data && first_layer.getParent().isCalibrated()) {
                    if (!ControlWindow.isGUIEnabled()) {
                        Utils.log2("Loader.importStack: overriding LayerSet calibration with that of the imported stack.");
                    } else {
                        final YesNoDialog yn = new YesNoDialog("Calibration", "The layer set is already calibrated. Override with the stack calibration values?");
                        if (!yn.yesPressed()) {
                            calibrate = false;
                        }
                    }
                }
                if (calibrate) {
                    first_layer.getParent().setCalibration(imp_stack.getCalibration());
                }
                if (layer_width < imp_stack.getWidth() || layer_height < imp_stack.getHeight()) {
                    expand_layer_set = true;
                }
                if (imp_stack.getStack().isVirtual()) {
                // do nothing
                } else if (null == filepath) {
                    // try to get it from the original FileInfo
                    final FileInfo fi = imp_stack.getOriginalFileInfo();
                    if (null != fi && null != fi.directory && null != fi.fileName) {
                        filepath = fi.directory.replace('\\', '/');
                        if (!filepath.endsWith("/"))
                            filepath += '/';
                        filepath += fi.fileName;
                    }
                    Utils.log2("Getting filepath from FileInfo: " + filepath);
                    // check that file exists, otherwise save a copy in the storage folder
                    if (null == filepath || (!filepath.startsWith("http://") && !new File(filepath).exists())) {
                        filepath = handlePathlessImage(imp_stack);
                    }
                } else {
                    filepath = filepath.replace('\\', '/');
                }
                // Import as Stack ZDisplayable object:
                if (!one_patch_per_layer) {
                    final Stack st = new Stack(first_layer.getProject(), new File(filepath).getName(), x, y, first_layer, filepath);
                    first_layer.getParent().add(st);
                    finishedWorking();
                    return;
                }
                // Place the first slice in the current layer, and then query the parent LayerSet for subsequent layers, and create them if not present.
                final Patch last_patch = Loader.this.importStackAsPatches(first_layer.getProject(), first_layer, x, y, imp_stack, null != imp_stack_ && null != imp_stack_.getCanvas(), filepath);
                if (null != last_patch) {
                    last_patch.setLocked(lock_stack);
                    Display.updateCheckboxes(last_patch.getLinkedGroup(null), DisplayablePanel.LOCK_STATE, true);
                }
                if (expand_layer_set) {
                    last_patch.getLayer().getParent().setMinimumDimensions();
                }
                Utils.log2("props: " + props);
                // check if it's an amira stack, then ask to import labels
                if (null != props && -1 == props.indexOf("Materials {") && -1 != props.indexOf("CoordType")) {
                    final YesNoDialog yn = new YesNoDialog(IJ.getInstance(), "Amira Importer", "Import labels as well?");
                    if (yn.yesPressed()) {
                        // select labels
                        final Collection<AreaList> alis = AmiraImporter.importAmiraLabels(first_layer, last_patch.getX(), last_patch.getY(), imp_stack.getOriginalFileInfo().directory);
                        if (null != alis) {
                            // import all created AreaList as nodes in the ProjectTree under a new imported_segmentations node
                            first_layer.getProject().getProjectTree().insertSegmentations(alis);
                            // link them to the images
                            for (final AreaList ali : alis) {
                                ali.linkPatches();
                            }
                        }
                    }
                }
            // it is safe not to flush the imp_stack, because all its resources are being used anyway (all the ImageProcessor), and it has no awt.Image. Unless it's being shown in ImageJ, and then it will be flushed on its own when the user closes its window.
            } catch (final Exception e) {
                IJError.print(e);
            }
            finishedWorking();
        }
    };
    return Bureaucrat.createAndStart(worker, first_layer.getProject());
}

Example 10 with Node

use of ini.trakem2.display.Node in project TrakEM2 by trakem2.

the class TMLHandler method endElement.

public void endElement(String namespace_URI, String local_name, String qualified_name) {
    if (null == loader)
        return;
    if (skip) {
        // reset
        skip = false;
        return;
    }
    String orig_qualified_name = qualified_name;
    // Utils.log2("endElement: " + qualified_name);
    // iterate over all open things and find the one that matches the qualified_name, and set it closed (pop it out of the list):
    qualified_name = qualified_name.toLowerCase().trim();
    if (0 == qualified_name.indexOf("t2_")) {
        qualified_name = qualified_name.substring(3);
    }
    for (int i = al_open.size() - 1; i > -1; i--) {
        Thing thing = al_open.get(i);
        if (thing.getType().toLowerCase().equals(qualified_name)) {
            al_open.remove(i);
            break;
        }
    }
    if (null != last_annotation && null != last_displayable) {
        last_displayable.setAnnotation(last_annotation.toString().trim().replaceAll("&lt;", "<"));
        last_annotation = null;
    }
    // terminate non-single clause objects
    if (orig_qualified_name.equals("t2_node")) {
        // Remove one node from the stack
        nodes.removeLast();
        taggables.removeLast();
    } else if (orig_qualified_name.equals("t2_connector")) {
        if (null != last_connector) {
            tree_root_nodes.put(last_connector, last_root_node);
            last_root_node = null;
            last_connector = null;
            last_tree = null;
            nodes.clear();
        }
        last_displayable = null;
    } else if (orig_qualified_name.equals("t2_area_list")) {
        last_area_list = null;
        last_displayable = null;
    } else if (orig_qualified_name.equals("t2_area")) {
        if (null != reca) {
            if (null != last_area_list) {
                // it's local
                last_area_list.addArea(last_area_list_layer_id, reca.getArea());
            } else {
                ((AreaTree.AreaNode) nodes.getLast()).setData(reca.getArea());
            }
            reca = null;
        }
    } else if (orig_qualified_name.equals("ict_transform_list")) {
        ct_list_stack.remove(ct_list_stack.size() - 1);
    } else if (orig_qualified_name.equals("t2_patch")) {
        if (last_patch_filters.size() > 0) {
            last_patch.setFilters(last_patch_filters.toArray(new IFilter[last_patch_filters.size()]));
        }
        if (null != last_ct) {
            last_patch.setCoordinateTransformSilently(last_ct);
            last_ct = null;
        } else if (!last_patch.checkCoordinateTransformFile()) {
            Utils.log("ERROR: could not find a file for the coordinate transform #" + last_patch.getCoordinateTransformId() + " of Patch #" + last_patch.getId());
        }
        if (!last_patch.checkAlphaMaskFile()) {
            Utils.log("ERROR: could not find a file for the alpha mask #" + last_patch.getAlphaMaskId() + " of Patch #" + last_patch.getId());
        }
        last_patch = null;
        last_patch_filters.clear();
        last_displayable = null;
    } else if (orig_qualified_name.equals("t2_ball")) {
        last_ball = null;
        last_displayable = null;
    } else if (orig_qualified_name.equals("t2_dissector")) {
        last_dissector = null;
        last_displayable = null;
    } else if (orig_qualified_name.equals("t2_treeline")) {
        if (null != last_treeline) {
            // old format:
            if (null == last_root_node && null != last_treeline_data && last_treeline_data.length() > 0) {
                last_root_node = parseBranch(Utils.trim(last_treeline_data));
                last_treeline_data = null;
            }
            // new
            tree_root_nodes.put(last_treeline, last_root_node);
            last_root_node = null;
            // always:
            last_treeline = null;
            last_tree = null;
            nodes.clear();
        }
        last_displayable = null;
    } else if (orig_qualified_name.equals("t2_areatree")) {
        if (null != last_areatree) {
            tree_root_nodes.put(last_areatree, last_root_node);
            last_root_node = null;
            last_areatree = null;
            last_tree = null;
            // the absence of this line would have made the nodes list grow with all nodes of all areatrees, which is ok but consumes memory
            nodes.clear();
        }
        last_displayable = null;
    } else if (orig_qualified_name.equals("t2_stack")) {
        if (null != last_ict) {
            last_stack.setInvertibleCoordinateTransformSilently(last_ict);
            last_ict = null;
        }
        last_stack = null;
        last_displayable = null;
    } else if (in(orig_qualified_name, all_displayables)) {
        last_displayable = null;
    }
}