@Override public void addOverlays(final ImageDisplay display, final List<? extends Overlay> overlays) { for (final Overlay overlay : overlays) { display.display(overlay); } }
/** Ensures the position of the relevant axis is within the legal range. */ private void clampPosition() { if (axis == null) return; final long pos = display.getLongPosition(axis); if (pos < first || pos > last) { display.setPosition(first, axis); } }
/** Creates an animation for the given {@link ImageDisplay}. */ public Animation(final ImageDisplay display) { this.display = display; display.getContext().inject(this); // assign default animation options if (display.numDimensions() > 2) { if (display.dimensionIndex(Axes.TIME) >= 0) { // animation over time is preferred by default axis = Axes.TIME; } else if (display.dimensionIndex(Axes.Z) >= 0) { // failing that, animation over Z is OK axis = Axes.Z; } else { // no preferred animation axes; use first non-spatial axis axis = display.axis(2).type(); } final int axisIndex = display.dimensionIndex(axis); last = display.dimension(axisIndex) - 1; } }
private void fillIndex(ImageDisplay disp, AxisType axis, long[] workspace) { final int index = disp.dimensionIndex(axis); if (index != -1) workspace[index] = disp.getLongPosition(index); } }
final Data data = display.getActiveView().getData(); for (int i = 0; i < data.numDimensions(); i++) { AxisType axisType = data.axis(i).type(); (axisType == Axes.CHANNEL)) final int axisIndex = display.dimensionIndex(axisType); final long size = display.dimension(axisIndex); final AxisSubrange subrange = new AxisSubrange(0, size - 1); definition.constrain(axisType, subrange); final long pos = display.getLongPosition(axisType); final AxisSubrange subrange = new AxisSubrange(pos); definition.constrain(axisType, subrange);
private void createSliders() { if (display.dimensionIndex(axis) >= 0) continue; // axis still active sliderPanel.remove(axisSliders.get(axis)); sliderPanel.remove(axisLabels.get(axis)); for (int i = 0; i < display.numDimensions(); i++) { final AxisType axis = display.axis(i).type(); if (axis.isXY()) continue; // skip spatial axes final int min = (int) display.min(i); final int max = (int) display.max(i) + 1; final int value = (int) display.getLongPosition(axis);
@Override public void divideCompositeOverlay(final CompositeOverlay overlay) { final List<Overlay> subcomponents = overlay.getSubcomponents(); // to each display that owns the composite // reference the original overlays (if not already) final List<ImageDisplay> owners = getDisplays(overlay); for (final ImageDisplay owner : owners) { boolean changes = false; final List<Overlay> displayOverlays = getOverlays(owner); for (final Overlay subcomponent : subcomponents) { if (!displayOverlays.contains(subcomponent)) { owner.display(subcomponent); changes = true; } } if (changes) owner.update(); } // delete the composite overlay removeOverlay(overlay); }
/** * When a tool creates an overlay, add the overlay/figure combo to an * {@link OverlayFigureView}. */ @EventHandler protected void onEvent(final FigureCreatedEvent event) { final ImageDisplay display = event.getDisplay(); if (display != getDisplay()) return; // not this canvas's display final OverlayView overlay = event.getView(); for (int i = 0; i < display.numDimensions(); i++) { final AxisType axisType = display.axis(i).type(); if (axisType.isXY()) continue; if (overlay.getData().dimensionIndex(axisType) < 0) { overlay.setPosition(display.getLongPosition(axisType), axisType); } } if (drawingView.getSelectedFigures().contains(event.getFigure())) { overlay.setSelected(true); } final OverlayFigureView figureView = new OverlayFigureView(displayViewer, overlay, event.getFigure()); figureViews.add(figureView); display.add(overlay); display.update(); }
@Override public DatasetView getActiveDatasetView(final ImageDisplay display) { if (display == null) return null; final DataView activeView = display.getActiveView(); if (activeView instanceof DatasetView) { return (DatasetView) activeView; } return null; }
private void updateAxis(final AxisType axis) { final int value = (int) display.getLongPosition(axis); if (axis == Axes.CHANNEL) updateColorBar(value); final JScrollBar scrollBar = axisSliders.get(axis); if (scrollBar != null) scrollBar.setValue(value); getDisplay().update(); }
@Override public void figureRemoved(final FigureEvent e) { final ImageDisplay d = getDisplay(); if (d.isVisible(overlayView)) { DataView view = getDataView(); // TODO : replace next two lines with call to OverlayService to // removeOverlay(d, getDataView().getData()); d.remove(view); view.dispose(); // end TODO replace dispose(); d.update(); } } });
return false; final Data data = display.getActiveView().getData(); final int axisIndex = data.dimensionIndex(axis); if (axisIndex < 0) { err = "Undefined axis " + axis + " for display " + display.getName(); return false; if (indices.get(0) > dimension) { err = "Axis range fully beyond dimensions of display " + display.getName() + " for axis " + axis; return false; err = "Axis range partially beyond dimensions of display " + display.getName() + " for axis " + axis; return false;
@Override public void run() { display.getCanvas().setZoom(1); } });
@Override public void adjustmentValueChanged(final AdjustmentEvent e) { display.setPosition(slider.getValue(), axis); } });
/** * Returns the calibration values that will be present in the output data. * This method assumes all calibrations are linear and should be avoided. Use * getOutputCalibratedAxes() for access to calibration information. * * @deprecated */ @Deprecated public double[] getOutputCalibration(final AxisType[] outputAxes) { final double[] cal = new double[outputAxes.length]; int a = 0; for (int i = 0; i < outputAxes.length; i++) { final int axisIndex = display.dimensionIndex(outputAxes[i]); if (axisIndex >= 0) cal[a++] = display.axis(axisIndex).averageScale(0, 1); } return cal; }
@Override public void removeOverlay(final ImageDisplay display, final Overlay overlay) { final ArrayList<DataView> overlayViews = new ArrayList<>(); final List<DataView> views = display; for (final DataView view : views) { final Data data = view.getData(); if (data == overlay) overlayViews.add(view); } for (final DataView view : overlayViews) { display.remove(view); view.dispose(); } display.update(); }
public DelayedPositionEvent(final ImageDisplay display, final AxisType axis) { super(display); if (display.dimensionIndex(axis) < 0) { throw new IllegalArgumentException("Invalid axis: " + axis); } this.axis = axis; }
/** * Updates the given {@link ImagePlus}'s position to match that of its * paired {@link ImageDisplay}. */ @Override public void updateLegacyImage(ImageDisplay disp, ImagePlus imp) { // When this is called we know that we have a IJ1 compatible display. So we // can make assumptions about dimensional sizes re: safe casting. final int cPos = (int) calcIJ1ChannelPos(disp); final int zPos = (int) disp.getLongPosition(Axes.Z); final int tPos = (int) disp.getLongPosition(Axes.TIME); imp.setPosition(cPos+1, zPos+1, tPos+1); }
/** * A convenience method for defining a SamplingDefinition that returns a * complete copy of an ImageDisplay. * * @param display The ImageDisplay to sample * @return The specified SamplingDefinition */ public static SamplingDefinition sampleAllPlanes(final ImageDisplay display) { final SamplingDefinition definition = new SamplingDefinition(display); for (int i = 0; i < display.numDimensions(); i++) { final AxisType axisType = display.axis(i).type(); final long size = display.dimension(i); final AxisSubrange subrange = new AxisSubrange(0, size - 1); definition.constrain(axisType, subrange); } return definition; }
@Override public Dimension getPreferredSize() { final Dimension drawViewSize = super.getPreferredSize(); if (drawViewSize.width > 0 && drawViewSize.height > 0) { // NB: Current preferred size is OK. return drawViewSize; } // NB: One or more figures in the drawing view are not initialized yet. // So we calculate the projected size manually. final RealRect imageBounds = getDisplay().getPlaneExtents(); final double zoomFactor = getDisplay().getCanvas().getZoomFactor(); final int x = (int) (imageBounds.width * zoomFactor); final int y = (int) (imageBounds.height * zoomFactor); // HACK: Add extra space to avoid unnecessary scroll bars. final int extra = 2; return new Dimension(x + extra, y + extra); } };