| Modifier and Type | Method and Description |
|---|---|
Layer |
LayerBottle.unBottle(MessageXC xc) |
| Modifier and Type | Method and Description |
|---|---|
Bottle<Layer> |
LayerBottler.bottle(Object o,
MessageXC xc) |
| Constructor and Description |
|---|
LayerBottle(Layer l) |
| Modifier and Type | Method and Description |
|---|---|
Project |
Project.createSubproject(Rectangle roi,
Layer first,
Layer last,
boolean ignore_hidden_patches)
Create a new subproject for the given layer range and ROI.
|
void |
Project.select(Layer layer)
Find the node in the layer tree with a Thing that contains the given object, and set it selected/highlighted, deselecting everything else first.
|
| Modifier and Type | Field and Description |
|---|---|
protected Layer |
Node.la |
Layer |
VectorDataTransform.layer |
Layer |
Region.layer |
protected Layer |
LayerPanel.layer |
protected Layer |
GroupingMode.layer |
protected Layer |
Displayable.layer |
Layer |
Coordinate.layer |
| Modifier and Type | Field and Description |
|---|---|
static Comparator<Layer> |
Layer.COMPARATOR
Compare layers by Z.
|
protected HashMap<Layer,LayerSet.LayerBucket> |
LayerSet.lbucks
For fast search.
|
protected Map<Layer,Set<Node<T>>> |
Tree.node_layer_map |
| Modifier and Type | Method and Description |
|---|---|
Layer |
Layer.clone(Project pr,
LayerSet ls,
Rectangle roi,
boolean copy_id,
boolean ignore_hidden_patches)
Make a copy of this layer into the given LayerSet, enclosing only Displayable objects within the roi, and translating them for that roi x,y.
|
static Layer |
Layer.create(Project project,
LayerSet parent)
Creates a new Layer asking for z and thickness, and adds it to the parent and returns it.
|
abstract Layer |
ZDisplayable.getFirstLayer()
Returns the layer of lowest Z coordinate where this ZDisplayable has a point in.
|
Layer |
Tree.getFirstLayer() |
Layer |
Stack.getFirstLayer() |
Layer |
Polyline.getFirstLayer()
Returns the layer of lowest Z coordinate where this ZDisplayable has a point in, or the creation layer if no points yet.
|
Layer |
Pipe.getFirstLayer()
Returns the layer of lowest Z coordinate where this ZDisplayable has a point in, or the creation layer if no points yet.
|
Layer |
Dissector.getFirstLayer() |
Layer |
Ball.getFirstLayer()
Returns the layer of lowest Z coordinate where this ZDisplayable has a point in, or the creation layer if no points yet.
|
Layer |
AreaList.getFirstLayer()
Returns the layer of lowest Z coordinate Layer where this ZDisplayable has a point in.
|
static Layer |
Display.getFrontLayer()
Get the layer of the front Display, or null if none.
|
static Layer |
Display.getFrontLayer(Project project)
Get the layer of an open Display of the given Project, or null if none.
|
Layer |
AreaList.getLastLayer()
Returns the layer of highest Z coordinate Layer where this ZDisplayable has a point in.
|
Layer |
Selection.getLayer()
Returns the Layer of the Display, or if the latter is null, that of the first selected Displayable.
|
Layer |
Node.getLayer() |
Layer |
Displayable.getLayer() |
Layer |
Display.getLayer() |
Layer |
LayerSet.getLayer(double z)
Returns the first layer found with the given Z coordinate, rounded to seventh decimal precision, or null if none found.
|
Layer |
LayerSet.getLayer(double z,
double thickness,
boolean create)
Returns null if none has the given z and thickness.
|
Layer |
LayerSet.getLayer(int i)
Find a layer by index, or null if none.
|
Layer |
LayerSet.getLayer(long id)
Find a layer with the given id, or null if none.
|
Layer |
LayerSet.getLayer(Long id)
Same as getLayer(long) but without box/unbox.
|
Layer |
LayerSet.getNearestLayer(double z) |
Layer |
LayerSet.getParent() |
Layer |
LayerSet.next(Layer layer) |
Layer |
LayerSet.nextNonEmpty(Layer layer) |
Layer |
LayerSet.previous(Layer layer) |
Layer |
LayerSet.previousNonEmpty(Layer layer) |
protected Layer |
Tree.toClosestPaintedNode(Layer active_layer,
float wx,
float wy,
double magnification)
Also sets the last visited and the receiver node.
|
| Modifier and Type | Method and Description |
|---|---|
static List<Layer> |
Layer.createMany(Project project,
LayerSet parent)
Pops up a dialog to choose the first Z coord, the thickness, the number of layers,
and whether to skip the creation of any layers whose Z and thickness match
that of existing layers.
|
List<Layer> |
LayerSet.getColorCueLayerRange(Layer active_layer)
Returns the list of layers to paint by considering the range of n_layers_color_cue around the active layer index.
|
List<Layer> |
AreaList.getLayerRange()
Get the range of layers between the first and last layers in which this AreaList paints to.
|
ArrayList<Layer> |
LayerSet.getLayers()
Returns a copy of the layer list.
|
List<Layer> |
LayerSet.getLayers(int first,
int last)
Returns a sublist of layers from first to last, both inclusive.
|
List<Layer> |
LayerSet.getLayers(Layer first,
Layer last)
Returns the layer range from first to last, both included.
|
Collection<Layer> |
Tree.getLayersWithData() |
Collection<Layer> |
Displayable.getLayersWithData()
Override it to provide Layer pointers directly.
|
ArrayList<Layer> |
LayerSet.getNeighborLayers(Layer layer,
int n)
Get up to 'n' layers before and after the given layers.
|
Map<Layer,double[]> |
Ball.getRawBalls()
Returns the raw data for the balls, sorted by Layer ID versus double[]{z,y,r} .
|
| Modifier and Type | Method and Description |
|---|---|
void |
AreaWrapper.add(Area wa,
Layer layer)
Add an area in world coordinates.
|
void |
LayerSet.add(Layer layer)
Add a new Layer, inserted according to its Z.
|
protected static void |
Display.add(Layer layer,
Displayable displ) |
protected static void |
Display.add(Layer layer,
Displayable displ,
boolean activate)
Find the displays that show the given Layer, and add the given Displayable to the GUI and sets it active only in the front Display and only if 'activate' is true.
|
int |
ManualAlignMode.Landmarks.add(Layer layer,
double x_p,
double y_p)
Returns the index of the newly added point, or -1 if the layer doesn't match.
|
protected static void |
Display.addAll(Layer layer,
Collection<? extends Displayable> coll) |
void |
LayerSet.addLayerContentStep(Layer la)
For the Displayable contained in a Layer: their number, and their stack order.
|
void |
LayerSet.addLayerEditedStep(Layer layer)
For the Z and thickness of a layer.
|
void |
LayerSet.addSilently(Layer layer)
Add a new Layer silently, ordering by z as well.
|
void |
LayerSet.addTransformStep(Layer layer)
Add an undo step for the transformations of all Displayable in the layer.
|
protected Node<T> |
Tree.adjustEdgeConfidence(int inc,
float x,
float y,
Layer layer,
DisplayCanvas dc)
Expects world coordinates.
|
protected Node<Float> |
Treeline.adjustNodeRadius(float inc,
float x,
float y,
Layer layer,
DisplayCanvas dc) |
boolean |
DisplayCanvas.animateBrowsing(Rectangle target_,
Layer target_layer)
Smoothly move the canvas from its current position until the given rectangle is included within the srcRect.
|
boolean |
VectorData.apply(Layer la,
Area roi,
CoordinateTransform ict)
Applies the 2D transform @ict (which is expected to operate on the
world coordinates version of the data contained here) only to the
data that falls within the @param roi (in world coords), and then
recomputes the bounding box and affine transform (to a translation
or identity).
|
boolean |
Tree.apply(Layer la,
Area roi,
CoordinateTransform ict) |
boolean |
Profile.apply(Layer la,
Area roi,
CoordinateTransform ict) |
boolean |
Polyline.apply(Layer la,
Area roi,
CoordinateTransform ict) |
boolean |
Pipe.apply(Layer la,
Area roi,
CoordinateTransform ict) |
boolean |
Dissector.apply(Layer la,
Area roi,
CoordinateTransform ict) |
boolean |
DLabel.apply(Layer la,
Area roi,
CoordinateTransform ict) |
boolean |
Ball.apply(Layer la,
Area roi,
CoordinateTransform ict) |
boolean |
AreaList.apply(Layer la,
Area roi,
CoordinateTransform ct) |
protected boolean |
Polyline.calculateBoundingBox(boolean adjust_position,
Layer la) |
protected boolean |
Pipe.calculateBoundingBox(boolean adjust_position,
Layer la) |
protected abstract boolean |
ZDisplayable.calculateBoundingBox(Layer la) |
boolean |
Tree.calculateBoundingBox(Layer la) |
protected boolean |
Stack.calculateBoundingBox(Layer la) |
protected boolean |
Polyline.calculateBoundingBox(Layer la) |
protected boolean |
Pipe.calculateBoundingBox(Layer la) |
protected boolean |
Dissector.calculateBoundingBox(Layer la) |
protected boolean |
Ball.calculateBoundingBox(Layer la) |
boolean |
AreaTree.calculateBoundingBox(Layer la) |
boolean |
AreaList.calculateBoundingBox(Layer la)
Calculate box, make this width,height be that of the box, and translate all areas to fit in.
|
boolean |
AreaContainer.calculateBoundingBox(Layer layer)
May have the side effect of updating the buckets of the containing container of this Displayable.
|
boolean |
Profile.canSendTo(Layer target_layer)
Returns false if the target_layer contains a profile that is directly linked to this profile.
|
boolean |
Displayable.canSendTo(Layer layer)
Subclasses can specify the behaviour, for the default is true.
|
static void |
Display.clearSelection(Layer layer) |
Displayable |
LayerSet.clone(Project pr,
Layer first,
Layer last,
Rectangle roi,
boolean add_to_tree,
boolean copy_id,
boolean ignore_hidden_patches)
Clone the contents of this LayerSet, from first to last given layers, and cropping for the given rectangle;
does NOT copy the ZDisplayable, which may be copied using the LayerSet.cloneInto method.
|
static void |
LayerSet.cloneInto(LayerSet src,
Layer src_first,
Layer src_last,
Project pr,
LayerSet copy,
Rectangle roi,
boolean copy_id) |
static void |
Display.close(Layer layer)
Find all Display instances that contain the layer and close them and remove the Display from the database.
|
int |
Layer.compareTo(Layer layer) |
boolean |
LayerSet.contains(Layer layer) |
boolean |
Tree.contains(Layer layer,
double x,
double y)
Returns true if the given point falls within a certain distance of any of the treeline segments,
where a segment is defined as the line between a clicked point and the next.
|
boolean |
Polyline.contains(Layer layer,
double x,
double y) |
boolean |
Pipe.contains(Layer layer,
double x,
double y)
Test whether the Pipe contains the given point at the given layer.
|
boolean |
Dissector.contains(Layer layer,
double x,
double y) |
boolean |
Displayable.contains(Layer layer,
double x_p,
double y_p)
Calls contains(x_p, y_p) unless overriden -- in ZDisplayable objects, it tests whether the given point is contained in the part of the ZDisplayable that shows in the given layer.
|
boolean |
Ball.contains(Layer layer,
double x,
double y)
Test whether the Ball contains the given point at the given layer.
|
boolean |
AreaList.contains(Layer layer,
double x,
double y)
Returns whether the point x,y is contained in this object at the given Layer.
|
protected boolean |
Polyline.containsLocal(Layer layer,
double x,
double y,
double radius) |
LayerSet |
LayerSet.create(Layer parent_layer)
Create a new LayerSet in the middle of the parent Layer.
|
static void |
Display.createDisplay(Project project,
Layer layer)
Creates a new Display with adjusted magnification to fit in the screen.
|
protected Node<T> |
Tree.createNewNode(float lx,
float ly,
Layer layer,
Node<?> modelNode)
Create a new node, copying some properties from the modelNode such as radius or color.
|
protected void |
Display.duplicateLinkAndSendTo(Displayable active,
int position,
Layer other_layer) |
void |
AreaList.fillHoles(Layer la) |
ArrayList<Displayable> |
LayerSet.find(Class<?> c,
Layer layer,
Area aroi,
boolean visible_only)
Find any Displayable or ZDisplayable objects of class C which intersect with the Area @param aroi.
|
ArrayList<Displayable> |
LayerSet.find(Class<?> c,
Layer layer,
Area aroi,
boolean visible_only,
boolean instance_of)
Find any Displayable or ZDisplayable objects of class C which intersect with the Area @param aroi.
|
ArrayList<Displayable> |
LayerSet.find(Class<?> c,
Layer layer,
int x,
int y,
boolean visible_only) |
ArrayList<ZDisplayable> |
LayerSet.find(Layer first,
Layer last,
Area area)
Find the ZDisplayable objects that intersect with the 3D roi defined by the first and last layers, and the area -all in world coordinates.
|
protected Map<Displayable,List<Area>> |
LayerSet.findAreas(Layer layer,
Rectangle box,
boolean visible)
Find all java.awt.geom.Area in layer that intersect with box, if visible.
|
Node<T> |
Tree.findClosestNodeW(float wx,
float wy,
Layer layer,
double magnification)
Expects world coords; with precision depending on magnification.
|
protected Coordinate<Node<T>> |
Tree.findNearAndGetNext(float x,
float y,
Layer layer,
DisplayCanvas dc) |
protected Coordinate<Node<T>> |
Tree.findNearAndGetPrevious(float x,
float y,
Layer layer,
DisplayCanvas dc) |
Node<T>[] |
Tree.findNearestEdge(float x_pl,
float y_pl,
Layer layer,
double magnification)
Considering only the set of consecutive layers currently painted, find a point near an edge
with accuracy depending upon magnification.
|
Node<T> |
Tree.findNearestEndNode(float lx,
float ly,
Layer layer)
Find the spatially closest node, in calibrated coords.
|
Node<T> |
Tree.findNearestNode(float lx,
float ly,
Layer layer)
Find the spatially closest node, in calibrated coords; expects local coords.
|
Coordinate<Node<T>> |
Tree.findNextBranchOrEndPoint(float x,
float y,
Layer layer,
DisplayCanvas dc)
If the node found near x,y,layer is a branch point, returns it; otherwise the next down
the chain; on reaching an end point, returns it.
|
Node<T> |
Tree.findNode(float lx,
float ly,
Layer layer,
double magnification)
Find a node in @param layer near the local coords lx,ly, with precision depending on magnification.
|
protected Node<T> |
Tree.findNodeNear(float x,
float y,
Layer layer,
DisplayCanvas dc) |
protected Node<T> |
Tree.findNodeNear(float x,
float y,
Layer layer,
DisplayCanvas dc,
boolean use_receiver_when_null)
Expects world coordinates.
|
Coordinate<Node<T>> |
Tree.findPreviousBranchOrRootPoint(float x,
float y,
Layer layer,
DisplayCanvas dc) |
Collection<Displayable> |
LayerSet.findZDisplayables(Class<?> c,
Layer layer,
Area aroi,
boolean visible_only,
boolean instance_of)
Find ZDisplayable objects of the given class that intersect the given area in the given layer.
|
Collection<Displayable> |
LayerSet.findZDisplayables(Class<?> c,
Layer layer,
int x,
int y,
boolean visible_only)
Find ZDisplayable objects of Class c that contain the point x,y in the given layer.
|
Collection<Displayable> |
LayerSet.findZDisplayables(Class<?> c,
Layer layer,
int x,
int y,
boolean visible_only,
boolean instance_of)
Find ZDisplayable objects of Class c that contain the point x,y in the given layer.
|
Collection<Displayable> |
LayerSet.findZDisplayables(Class<?> c,
Layer layer,
Rectangle r,
boolean visible_only) |
Collection<Displayable> |
LayerSet.findZDisplayables(Class<?> c,
Layer layer,
Rectangle r,
boolean visible_only,
boolean instance_of)
Find ZDisplayable objects of the given class that intersect the given rectangle in the given layer.
|
Collection<Displayable> |
LayerSet.findZDisplayables(Layer layer,
int x,
int y,
boolean visible_only)
Find ZDisplayable objects that contain the point x,y in the given layer.
|
Collection<Displayable> |
LayerSet.findZDisplayables(Layer layer,
Rectangle r,
boolean visible_only)
Find ZDisplayable objects that intersect the given rectangle in the given layer.
|
Node<T> |
Tree.firstIntersectingNode(Layer layer,
Area area)
Expects Area in world coords.
|
Bureaucrat |
Tree.generateReviewStackForSlab(float x,
float y,
Layer layer,
double magnification) |
Bureaucrat |
Tree.generateSubtreeReviewStacks(int x,
int y,
Layer layer,
double magnification) |
Area |
AreaList.getArea(Layer la) |
Area |
Tree.getAreaAt(Layer layer)
In world coordinates.
|
Area |
Polyline.getAreaAt(Layer layer)
A little square for each pixel in @param layer.
|
Area |
Pipe.getAreaAt(Layer layer) |
Area |
Dissector.getAreaAt(Layer layer) |
Area |
Displayable.getAreaAt(Layer layer)
This area is meant to represent the entire area where a Displayable paints to in the @param layer.
|
Area |
Ball.getAreaAt(Layer layer) |
Area |
AreaList.getAreaAt(Layer layer)
In world coordinates, a copy of the area at
layer. |
protected Area |
Patch.getAreaForBucket(Layer l)
Use this instead of getAreaAt which calls getArea which is ...
|
protected Area |
Displayable.getAreaForBucket(Layer layer)
Should call getAreaAt(layer), or methods that are similar but faster.
|
List<Area> |
AreaTree.getAreas(Layer layer,
Rectangle box)
Return the list of areas, in world coordinates, at the given layer, that intersect the given bounding box.
|
List<Area> |
AreaList.getAreas(Layer layer,
Rectangle box) |
List<Area> |
AreaContainer.getAreas(Layer layer,
Rectangle box) |
Rectangle |
Tree.getBounds(Rectangle tmp,
Layer layer) |
Rectangle |
Pipe.getBounds(Rectangle r,
Layer layer)
Returns the bounds of this object as it shows in the given layer, set into @param r.
|
Rectangle |
Displayable.getBounds(Rectangle r,
Layer layer)
Will fill bounding box values into given rectangle -- only that part of this object showing in the given layer will be included in the box.
|
Rectangle |
AreaList.getBounds(Rectangle r,
Layer layer)
Returns the bounds of this object as it shows in the given layer.
|
HashMap<Displayable,HashSet<Bucket>> |
LayerSet.getBucketMap(Layer la) |
HashMap<Displayable,HashSet<Bucket>> |
Layer.getBucketMap(Layer layer) |
HashMap<Displayable,HashSet<Bucket>> |
Bucketable.getBucketMap(Layer layer) |
static int |
Bucket.getBucketSide(Bucketable container,
Layer la) |
List<Layer> |
LayerSet.getColorCueLayerRange(Layer active_layer)
Returns the list of layers to paint by considering the range of n_layers_color_cue around the active layer index.
|
protected byte |
Display.getLayerCompositeMode(Layer layer) |
List<Layer> |
LayerSet.getLayers(Layer first,
Layer last)
Returns the layer range from first to last, both included.
|
ArrayList<Layer> |
LayerSet.getNeighborLayers(Layer layer,
int n)
Get up to 'n' layers before and after the given layers.
|
Set<Node<T>> |
Tree.getNodesAt(Layer layer)
|
protected Set<Node<T>> |
Tree.getNodesToPaint(Layer active_layer) |
protected Set<Node<T>> |
Tree.getNodesToPaint(Layer active_layer,
List<Layer> color_cue_layers) |
ArrayList<ZDisplayable> |
LayerSet.getZDisplayables(Class<?> c,
Layer layer,
Area aroi,
boolean visible_only)
Deprecated.
|
ArrayList<ZDisplayable> |
LayerSet.getZDisplayables(Class<?> c,
Layer layer,
Area aroi,
boolean visible_only,
boolean instance_of)
Deprecated.
|
boolean |
Displayable.hasLinkedGroupWithinLayer(Layer la) |
int |
LayerSet.indexOf(Layer layer)
From zero to size-1.
|
boolean |
AreaList.interpolate(Layer first,
Layer last,
boolean always_use_distance_map)
Interpolate areas between the given first and last layers,
both of which must contain an area.
|
boolean |
Tree.intersects(Layer layer,
Area area)
Expects Area in world coords.
|
boolean |
Pipe.intersects(Layer layer,
Area area)
Expects Area in world coords.
|
boolean |
Displayable.intersects(Layer layer,
Area area)
Calls intersects(area) unless overriden -- intended for ZDisplayable objects to return whether they intersect the given area at the given layer.
|
boolean |
AreaList.intersects(Layer layer,
Area area) |
boolean |
Tree.intersects(Layer layer,
Rectangle r)
Expects Rectangle in world coords.
|
boolean |
Pipe.intersects(Layer layer,
Rectangle r)
Expects Rectangle in world coords.
|
boolean |
Displayable.intersects(Layer layer,
Rectangle r) |
boolean |
AreaList.intersects(Layer layer,
Rectangle r) |
boolean |
Connector.intersectsOrigin(Area area,
Layer la) |
boolean |
Connector.intersectsOrigin(double wx,
double wy,
Layer la)
|
boolean |
LayerSet.isEmptyAt(Layer layer) |
boolean |
Displayable.isOnlyLinkedTo(Class<?> c,
Layer layer)
Check if this object is directly linked only to Displayable objects of the given class in the same layer (returns true).
|
protected boolean |
Tree.isRoughlyInside(Layer layer,
Rectangle box)
Fast and dirty, never returns a false negative but may return a false positive.
|
boolean |
Profile.isRoughlyInside(Layer layer,
Rectangle r) |
boolean |
Polyline.isRoughlyInside(Layer layer,
Rectangle r) |
boolean |
Pipe.isRoughlyInside(Layer layer,
Rectangle r) |
protected boolean |
Patch.isRoughlyInside(Layer l,
Rectangle r) |
protected boolean |
Displayable.isRoughlyInside(Layer layer,
Rectangle r)
If this Displayable intersects with @param r or almost intersects, then returns true.
|
protected boolean |
Ball.isRoughlyInside(Layer layer,
Rectangle r) |
boolean |
AreaList.isRoughlyInside(Layer layer,
Rectangle box) |
boolean |
Display.isShowing(Layer layer) |
void |
AreaWrapper.keyPressed(KeyEvent ke,
DisplayCanvas dc,
Layer la) |
protected boolean |
ZDisplayable.layerRemoved(Layer la)
Update internal datastructures to reflect the fact that @param layer has been removed from the containing LayerSet.
|
protected boolean |
Tree.layerRemoved(Layer la) |
protected boolean |
Polyline.layerRemoved(Layer la) |
protected boolean |
Pipe.layerRemoved(Layer la) |
protected boolean |
Dissector.layerRemoved(Layer la) |
protected boolean |
Connector.layerRemoved(Layer la)
If the root node is in Layer @param la, then all nodes are removed.
|
protected boolean |
Ball.layerRemoved(Layer la) |
protected boolean |
AreaList.layerRemoved(Layer la) |
static ij.process.ImageProcessor |
Patch.makeFlatImage(int type,
Layer layer,
Rectangle srcRect,
double scale,
Collection<Patch> patches,
Color background)
Defaults to setMinAndMax = true.
|
static ij.process.ImageProcessor |
Patch.makeFlatImage(int type,
Layer layer,
Rectangle srcRect,
double scale,
Collection<Patch> patches,
Color background,
boolean setMinAndMax)
Creates an ImageProcessor of the specified type.
|
boolean |
Tree.markNear(float x,
float y,
Layer layer,
double magnification) |
void |
Treeline.mouseDragged(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
Tree.mouseDragged(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
Profile.mouseDragged(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old)
Execute the mouseDragged MouseEvent on this Profile.
|
void |
Polyline.mouseDragged(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
Pipe.mouseDragged(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
Dissector.mouseDragged(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
Displayable.mouseDragged(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
DLabel.mouseDragged(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
Ball.mouseDragged(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
AreaWrapper.mouseDragged(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
AreaTree.mouseDragged(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
AreaList.mouseDragged(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
Treeline.mousePressed(MouseEvent me,
Layer la,
int x_p,
int y_p,
double mag) |
void |
Tree.mousePressed(MouseEvent me,
Layer layer,
int x_p,
int y_p,
double mag) |
void |
Profile.mousePressed(MouseEvent me,
Layer layer,
int x_p,
int y_p,
double mag)
Execute the mousePressed MouseEvent on this Profile.
|
void |
Polyline.mousePressed(MouseEvent me,
Layer layer,
int x_p,
int y_p,
double mag) |
void |
Pipe.mousePressed(MouseEvent me,
Layer layer,
int x_p,
int y_p,
double mag) |
void |
Patch.mousePressed(MouseEvent me,
Layer la,
int x_p,
int y_p,
double mag) |
void |
Dissector.mousePressed(MouseEvent me,
Layer la,
int x_p,
int y_p,
double mag) |
void |
Displayable.mousePressed(MouseEvent me,
Layer layer,
int x_p,
int y_p,
double mag) |
void |
DLabel.mousePressed(MouseEvent me,
Layer layer,
int x_p,
int y_p,
double mag) |
void |
Connector.mousePressed(MouseEvent me,
Layer layer,
int x_p,
int y_p,
double mag)
Add a root or child nodes to root.
|
void |
Ball.mousePressed(MouseEvent me,
Layer layer,
int x_p,
int y_p,
double mag) |
void |
AreaWrapper.mousePressed(MouseEvent me,
Layer la,
int x_p_w,
int y_p_w,
double mag) |
void |
AreaTree.mousePressed(MouseEvent me,
Layer la,
int x_p,
int y_p,
double mag) |
void |
AreaList.mousePressed(MouseEvent me,
Layer la,
int x_p_w,
int y_p_w,
double mag) |
void |
AreaWrapper.mousePressed(MouseEvent me,
Layer la,
int x_p_w,
int y_p_w,
double mag,
List<Runnable> post_tasks) |
void |
Treeline.mouseReleased(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
Tree.mouseReleased(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
Profile.mouseReleased(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r)
Execute the mouseReleased MouseEvent on this Profile.
|
void |
Polyline.mouseReleased(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
Pipe.mouseReleased(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
Dissector.mouseReleased(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
Displayable.mouseReleased(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
DLabel.mouseReleased(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
Ball.mouseReleased(MouseEvent me,
Layer layer,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
AreaWrapper.mouseReleased(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
AreaTree.mouseReleased(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
AreaList.mouseReleased(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
void |
LayerSet.move(Set<Displayable> hs_d,
Layer source,
Layer target)
Move all Displayable objects in the HashSet to the given target layer.
|
void |
LayerSet.moveDown(Layer layer,
Displayable d)
Move the given Displayable to the next layer if possible.
|
void |
LayerSet.moveUp(Layer layer,
Displayable d)
Move the given Displayable to the previous layer if possible.
|
Node<Float> |
Treeline.RadiusNode.newInstance(float lx,
float ly,
Layer layer) |
abstract Node<T> |
Node.newInstance(float x,
float y,
Layer layer) |
Node<Float> |
Connector.ConnectorNode.newInstance(float lx,
float ly,
Layer layer) |
Node<Area> |
AreaTree.AreaNode.newInstance(float lx,
float ly,
Layer layer) |
Node<Float> |
Treeline.newNode(float lx,
float ly,
Layer la,
Node<?> modelNode) |
protected abstract Node<T> |
Tree.newNode(float lx,
float ly,
Layer layer,
Node<?> modelNode) |
Node<Float> |
Connector.newNode(float lx,
float ly,
Layer la,
Node<?> modelNode) |
Node<Area> |
AreaTree.newNode(float lx,
float ly,
Layer la,
Node<?> modelNode) |
Layer |
LayerSet.next(Layer layer) |
Layer |
LayerSet.nextNonEmpty(Layer layer) |
void |
LayerSet.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer) |
void |
Tree.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Stack.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers)
Slow paint: will wait until the image is generated and cached, then paint it.
|
void |
Profile.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Polyline.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Pipe.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Patch.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> _ignored) |
void |
Paintable.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
GroupingMode.ScreenPatchRange.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Dissector.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Displayable.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
DLabel.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Ball.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
AreaList.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Tree.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers,
boolean with_arrows,
boolean with_tags) |
void |
AreaTree.AreaNode.paintData(Graphics2D g,
Rectangle srcRect,
Tree<Area> tree,
AffineTransform to_screen,
Color cc,
Layer active_layer) |
void |
Treeline.RadiusNode.paintData(Graphics2D g,
Rectangle srcRect,
Tree<Float> tree,
AffineTransform to_screen,
Color cc,
Layer active_layer) |
void |
Connector.ConnectorNode.paintData(Graphics2D g,
Rectangle srcRect,
Tree<Float> tree,
AffineTransform to_screen,
Color cc,
Layer active_layer) |
abstract void |
Node.paintData(Graphics2D g,
Rectangle srcRect,
Tree<T> tree,
AffineTransform to_screen,
Color cc,
Layer active_layer) |
void |
Patch.paintOffscreen(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Displayable.paintOffscreen(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers)
Paints waiting for data to load, if necessary.
|
BufferedImage |
DisplayCanvas.paintOffscreen(Layer active_layer,
int g_width,
int g_height,
Rectangle srcRect,
double magnification,
Displayable active,
int c_alphas,
Rectangle clipRect,
Loader loader,
HashMap<Color,Layer> hm,
ArrayList<LayerPanel> blending_list,
int mode,
GraphicsSource graphics_source,
boolean prepaint,
ArrayList<Displayable> al_top)
Deprecated.
|
BufferedImage |
DisplayCanvas.paintOffscreen(Layer active_layer,
List<Layer> layers,
ArrayList<Displayable> al_paint,
Displayable active,
int g_width,
int g_height,
int c_alphas,
Loader loader,
HashMap<Color,Layer> hm,
ArrayList<LayerPanel> blending_list,
int mode,
GraphicsSource graphics_source,
boolean prepaint,
int first_non_patch) |
BufferedImage |
DisplayCanvas.paintOffscreen(Layer active_layer,
List<Layer> layers,
int g_width,
int g_height,
Rectangle srcRect,
double magnification,
Displayable active,
int c_alphas,
Rectangle clipRect,
Loader loader,
HashMap<Color,Layer> hm,
ArrayList<LayerPanel> blending_list,
int mode,
GraphicsSource graphics_source,
boolean prepaint,
ArrayList<Displayable> al_top,
boolean preload)
This method uses data only from the arguments, and changes none.
|
boolean |
ZDisplayable.paintsAt(Layer layer)
Check if this instance will paint anything at the level of the given Layer.
|
boolean |
Tree.paintsAt(Layer layer) |
boolean |
Ball.paintsAt(Layer layer) |
boolean |
AreaList.paintsAt(Layer layer) |
void |
Tree.paintSnapshot(Graphics2D g,
Layer layer,
List<Layer> layers,
Rectangle srcRect,
double mag) |
void |
Patch.paintSnapshot(Graphics2D g,
Layer layer,
List<Layer> layers,
Rectangle srcRect,
double mag) |
void |
Dissector.paintSnapshot(Graphics2D g,
Layer layer,
List<Layer> layers,
Rectangle srcRect,
double mag)
Always paint as box.
|
void |
Displayable.paintSnapshot(Graphics2D g,
Layer layer,
List<Layer> layers,
Rectangle srcRect,
double mag) |
void |
Stack.prePaint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> _ignored)
Will not paint but fork a task to create an image to paint later, when not already cached.
|
void |
Patch.prePaint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> _ignored)
Paint first whatever is available, then request that the proper image be loaded and painted.
|
void |
Paintable.prePaint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
GroupingMode.ScreenPatchRange.prePaint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Displayable.prePaint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
Layer |
LayerSet.previous(Layer layer) |
Layer |
LayerSet.previousNonEmpty(Layer layer) |
void |
LayerSet.recreateBuckets(Layer layer,
boolean layer_buckets)
|
void |
LayerSet.remove(Layer layer)
Remove a child.
|
static void |
Display.remove(Layer layer)
Find all Display instances that are showing the layer and either move to the next or previous layer, or close it if none.
|
static void |
Display.remove(Layer layer,
Displayable displ)
Find the displays that show the given Layer, and remove the given Displayable from the GUI.
|
void |
LayerSet.removeFromOffscreens(Layer la) |
void |
Tree.repaint(boolean repaint_navigator,
Layer la)
Repaints in the given ImageCanvas only the area corresponding to the bounding box of this Pipe.
|
void |
Polyline.repaint(boolean repaint_navigator,
Layer la)
Repaints in the given ImageCanvas only the area corresponding to the bounding box of this Pipe.
|
void |
Pipe.repaint(boolean repaint_navigator,
Layer la)
Repaints in the given ImageCanvas only the area corresponding to the bounding box of this Pipe.
|
void |
Ball.repaint(boolean repaint_navigator,
Layer layer)
Repaints in the given ImageCanvas only the area corresponding to the bounding box of this Profile.
|
static void |
Display.repaint(Layer layer)
Repaint the entire Layer, in all Displays showing it, including the tabs.
|
static void |
Display.repaint(Layer layer,
Displayable displ)
Repaint the DisplayablePanel (and DisplayNavigator) only for the given Displayable, in all Displays showing the given Layer.
|
static void |
Display.repaint(Layer layer,
Displayable displ,
int extra) |
static void |
Display.repaint(Layer layer,
Displayable displ,
Rectangle r,
int extra) |
static void |
Display.repaint(Layer layer,
Displayable displ,
Rectangle r,
int extra,
boolean repaint_navigator)
Find the displays that show the given Layer, and repaint the given Displayable; does NOT update graphics for the offscreen image.
|
static void |
Display.repaint(Layer layer,
Displayable displ,
Rectangle r,
int extra,
boolean update_graphics,
boolean repaint_navigator) |
static void |
Display.repaint(Layer layer,
int extra,
Rectangle r,
boolean update_navigator) |
static void |
Display.repaint(Layer layer,
int extra,
Rectangle r,
boolean update_navigator,
boolean update_graphics) |
static void |
Display.repaint(Layer layer,
Rectangle r,
int extra)
Repaint the given Rectangle in all Displays showing the layer, updating the offscreen image if any.
|
static void |
Display.repaint(Layer layer,
Rectangle r,
int extra,
boolean update_graphics)
Repaint the given Rectangle in all Displays showing the layer, optionally updating the offscreen image (if any).
|
protected static void |
Display.repaintSnapshots(Layer layer) |
protected void |
LayerSet.reposition(Layer layer)
Used by the Layer.setZ method.
|
boolean |
Tree.reRoot(float x,
float y,
Layer layer,
double magnification)
Reroots at the point closest to the x,y,layer_id world coordinate.
|
Collection<Displayable> |
LayerSet.roughlyFindZDisplayables(Layer layer,
Rectangle r,
boolean visible_only)
Find ZDisplayable objects that intersect the given rectangle in the given layer.
|
void |
Selection.selectAll(Layer layer)
Select all objects in the given layer, preserving the active one (if any) as active.
|
void |
Ball.set(int i,
double x,
double y,
Layer la,
double radius)
Set the x,y,radius raw pixel values for the ball at index i.
|
protected void |
Display.setColorChannel(Layer layer,
Color color)
Set a layer to be painted as a specific color channel in the canvas.
|
static void |
Display.setFront(Layer layer,
Displayable displ)
Grab the last selected display (or create an new one if none) and show in it the layer,centered on the Displayable object.
|
void |
ZDisplayable.setLayer(Layer layer) |
void |
Node.setLayer(Layer la) |
void |
Displayable.setLayer(Layer layer) |
void |
Display.setLayer(Layer new_layer) |
void |
LayerSet.setLayer(Layer layer,
boolean update)
'update' in database or not.
|
void |
Displayable.setLayer(Layer layer,
boolean update_db) |
protected void |
Display.setLayerCompositeMode(Layer layer,
byte compositeMode) |
void |
LayerSet.setParent(Layer layer) |
static void |
Display.setUpdateGraphics(Layer layer,
boolean update)
Flag the DisplayCanvas of Displays showing the given Layer to update their offscreen images.
|
static void |
Display.setUpdateGraphics(Layer layer,
Displayable displ)
Mark the canvas for updating the offscreen images if the given Displayable is NOT the active.
|
void |
Display.show(Layer layer,
Displayable displ,
boolean select,
boolean shift_down)
Set this Display to show the specific layer, centered at the @param displ, and perhaps selected,
adding to the selection instead of clearing it if @param shift_down is true.
|
static void |
Display.showCentered(Layer layer,
Displayable displ,
boolean select,
boolean shift_down)
Show the given Displayable centered and selected.
|
static void |
Display.showFront(Layer layer)
Show the layer in the front Display, or in a new Display if the front Display is showing a layer from a different LayerSet.
|
static void |
Display3D.showOrthoslices(ij.ImagePlus imp,
String title,
int wx,
int wy,
float scale2D,
Layer first) |
List<Tree<T>> |
Tree.splitNear(float x,
float y,
Layer layer,
double magnification)
Split the Tree into new Tree at the point closest to the x,y,layer world coordinate.
|
void |
AreaWrapper.subtract(Area wa,
Layer layer)
Subtract an area in world coordinates.
|
protected Layer |
Tree.toClosestPaintedNode(Layer active_layer,
float wx,
float wy,
double magnification)
Also sets the last visited and the receiver node.
|
void |
Display.toLayer(Layer la)
Calls setLayer(la) on the SetLayerThread.
|
void |
ZDisplayable.transformPoints(Layer layer,
double dx,
double dy,
double rot,
double xo,
double yo)
Deprecated.
|
void |
AreaList.transformPoints(Layer layer,
double dx,
double dy,
double rot,
double xo,
double yo) |
static void |
Display.update(Layer layer)
Find all Display instances that contain the layer and repaint them, in the Swing GUI thread.
|
void |
LayerSet.updateBucket(Displayable d,
Layer layer) |
void |
Layer.updateBucket(Displayable d,
Layer layer)
Update buckets of a position change for the given Displayable.
|
void |
Bucketable.updateBucket(Displayable d,
Layer layer) |
void |
ZDisplayable.updateBucket(Layer la) |
static void |
Display.updatePanel(Layer layer,
Displayable displ) |
static void |
Display.updatePanelIndex(Layer layer,
Displayable displ)
Deprecated.
|
static void |
Display.updateTitle(Layer layer)
Update the Display's title in all Displays showing the given Layer.
|
static void |
Display.updateTitle(Layer layer,
Displayable displ)
Update the title of the given Displayable in its DisplayablePanel, if any.
|
| Modifier and Type | Method and Description |
|---|---|
void |
LayerSet.addLayerEditedStep(List<Layer> al)
For the Z and thickness of a list of layers.
|
void |
LayerSet.addTransformStep(List<Layer> layers) |
Collection<Displayable> |
LayerSet.addTransformStepWithDataForAll(Collection<Layer> layers)
Includes all ZDisplayable that paint at any of the given layers.
|
boolean |
NonLinearTransformMode.apply(Set<Layer> sublist) |
protected void |
AffineTransformMode.applyAndPropagate(Set<Layer> sublist)
Skips current layer, since its done already.
|
static boolean |
Displayable.areThereLayerCrossLinks(Set<Layer> sublist,
boolean ignore_stacks)
Returns true if any Displayable objects of different layers in sublist are linked to each other.
|
boolean |
ZDisplayable.crop(List<Layer> range)
Retain the data within the layer range, and through out all the rest.
|
boolean |
Tree.crop(List<Layer> range)
Retain the data within the layer range, and through out all the rest.
|
boolean |
Polyline.crop(List<Layer> range)
Retain the data within the layer range, and through out all the rest.
|
boolean |
Pipe.crop(List<Layer> range)
Retain the data within the layer range, and through out all the rest.
|
boolean |
Dissector.crop(List<Layer> range)
Retain the data within the layer range, and through out all the rest.
|
boolean |
Connector.crop(List<Layer> range)
If the root node (the origin) does not remain within the range, this Connector is left empty.
|
boolean |
Ball.crop(List<Layer> range)
Retain the data within the layer range, and throw out all the rest.
|
boolean |
AreaList.crop(List<Layer> range)
Retain the data within the layer range, and through out all the rest.
|
static <T extends Displayable> |
Display.find(String regex,
boolean visible_only,
Class<T> c,
List<Layer> layers) |
protected Set<Node<T>> |
Tree.getNodesToPaint(Layer active_layer,
List<Layer> color_cue_layers) |
protected int |
Display.getPaintMode(HashMap<Color,Layer> hm,
ArrayList<LayerPanel> list)
Sets the values atomically, returns the painting mode.
|
void |
Tree.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Stack.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers)
Slow paint: will wait until the image is generated and cached, then paint it.
|
void |
Profile.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Polyline.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Pipe.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Patch.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> _ignored) |
void |
Paintable.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
GroupingMode.ScreenPatchRange.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Dissector.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Displayable.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
DLabel.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Ball.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
AreaList.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Tree.paint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers,
boolean with_arrows,
boolean with_tags) |
void |
Patch.paintOffscreen(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Displayable.paintOffscreen(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers)
Paints waiting for data to load, if necessary.
|
BufferedImage |
DisplayCanvas.paintOffscreen(Layer active_layer,
int g_width,
int g_height,
Rectangle srcRect,
double magnification,
Displayable active,
int c_alphas,
Rectangle clipRect,
Loader loader,
HashMap<Color,Layer> hm,
ArrayList<LayerPanel> blending_list,
int mode,
GraphicsSource graphics_source,
boolean prepaint,
ArrayList<Displayable> al_top)
Deprecated.
|
BufferedImage |
DisplayCanvas.paintOffscreen(Layer active_layer,
List<Layer> layers,
ArrayList<Displayable> al_paint,
Displayable active,
int g_width,
int g_height,
int c_alphas,
Loader loader,
HashMap<Color,Layer> hm,
ArrayList<LayerPanel> blending_list,
int mode,
GraphicsSource graphics_source,
boolean prepaint,
int first_non_patch) |
BufferedImage |
DisplayCanvas.paintOffscreen(Layer active_layer,
List<Layer> layers,
ArrayList<Displayable> al_paint,
Displayable active,
int g_width,
int g_height,
int c_alphas,
Loader loader,
HashMap<Color,Layer> hm,
ArrayList<LayerPanel> blending_list,
int mode,
GraphicsSource graphics_source,
boolean prepaint,
int first_non_patch) |
BufferedImage |
DisplayCanvas.paintOffscreen(Layer active_layer,
List<Layer> layers,
int g_width,
int g_height,
Rectangle srcRect,
double magnification,
Displayable active,
int c_alphas,
Rectangle clipRect,
Loader loader,
HashMap<Color,Layer> hm,
ArrayList<LayerPanel> blending_list,
int mode,
GraphicsSource graphics_source,
boolean prepaint,
ArrayList<Displayable> al_top,
boolean preload)
This method uses data only from the arguments, and changes none.
|
BufferedImage |
DisplayCanvas.paintOffscreen(Layer active_layer,
List<Layer> layers,
int g_width,
int g_height,
Rectangle srcRect,
double magnification,
Displayable active,
int c_alphas,
Rectangle clipRect,
Loader loader,
HashMap<Color,Layer> hm,
ArrayList<LayerPanel> blending_list,
int mode,
GraphicsSource graphics_source,
boolean prepaint,
ArrayList<Displayable> al_top,
boolean preload)
This method uses data only from the arguments, and changes none.
|
void |
Tree.paintSnapshot(Graphics2D g,
Layer layer,
List<Layer> layers,
Rectangle srcRect,
double mag) |
void |
Patch.paintSnapshot(Graphics2D g,
Layer layer,
List<Layer> layers,
Rectangle srcRect,
double mag) |
void |
Dissector.paintSnapshot(Graphics2D g,
Layer layer,
List<Layer> layers,
Rectangle srcRect,
double mag)
Always paint as box.
|
void |
Displayable.paintSnapshot(Graphics2D g,
Layer layer,
List<Layer> layers,
Rectangle srcRect,
double mag) |
void |
Stack.prePaint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> _ignored)
Will not paint but fork a task to create an image to paint later, when not already cached.
|
void |
Patch.prePaint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> _ignored)
Paint first whatever is available, then request that the proper image be loaded and painted.
|
void |
Paintable.prePaint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
GroupingMode.ScreenPatchRange.prePaint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
Displayable.prePaint(Graphics2D g,
Rectangle srcRect,
double magnification,
boolean active,
int channels,
Layer active_layer,
List<Layer> layers) |
void |
LayerSet.recreateBuckets(Collection<Layer> layers,
boolean layer_buckets)
Regenerate the quad-tree bucket system for the ZDisplayable instances that have data at each of the given layers,
and optionally regenerate the buckets as well for the 2D Displayable instances of that layer as well.
|
| Constructor and Description |
|---|
AreaNode(float lx,
float ly,
Layer la) |
ConnectorNode(float lx,
float ly,
Layer la) |
ConnectorNode(float lx,
float ly,
Layer la,
float radius) |
Coordinate(double x,
double y,
Layer layer,
T object) |
Display(Project project,
Layer layer)
A new Display from scratch, to show the given Layer.
|
Display(Project project,
Layer layer,
Displayable displ)
Open a new Display centered around the given Displayable.
|
Display(Project project,
long id,
Layer layer,
HashMap<String,String> ht)
Reconstruct a Display from an XML entry, to be opened when everything is ready.
|
Display(Project project,
long id,
Layer layer,
Object[] props)
For reconstruction purposes.
|
Landmarks(Layer layer) |
LayerPanel(Display display,
Layer layer) |
LayerSet(Project project,
String title,
double x,
double y,
Layer parent,
float layer_width,
float layer_height)
Create a new LayerSet with a 0,0,0 rotation vector and default 20,20 px Displayable width,height.
|
Node(float x,
float y,
Layer la) |
RadiusNode(float lx,
float ly,
Layer la) |
RadiusNode(float lx,
float ly,
Layer la,
float radius) |
Region(Rectangle r,
Layer layer,
T object) |
Stack(Project project,
String title,
double x,
double y,
Layer initial_layer,
String file_path) |
VectorDataTransform(Layer layer) |
| Modifier and Type | Method and Description |
|---|---|
static Segmentation.BlowCommander |
Segmentation.blowRoi(AreaWrapper aw,
Layer layer,
Rectangle srcRect,
int x_p_w,
int y_p_w,
List<Runnable> post_tasks) |
static Segmentation.BlowCommander |
Segmentation.blowRoi(AreaWrapper aw,
Layer layer,
Rectangle srcRect,
int x_p_w,
int y_p_w,
Runnable post_task) |
static Bureaucrat |
Segmentation.fastMarching(AreaWrapper aw,
Layer layer,
Rectangle srcRect,
int x_p_w,
int y_p_w,
List<Runnable> post_tasks) |
static Bureaucrat |
Segmentation.fastMarching(AreaWrapper aw,
Layer layer,
Rectangle srcRect,
int x_p_w,
int y_p_w,
Runnable post_task) |
Patch |
PatchStack.getPatch(Layer layer,
Patch p)
If the 'p' is contained in this PatchStack, get the first Patch found to be contained here and in the given 'layer'
|
static Bureaucrat |
Segmentation.magicWand(AreaWrapper aw,
Layer layer,
Rectangle srcRect,
int x_p_w,
int y_p_w,
List<Runnable> post_tasks,
boolean inverse,
boolean subtract) |
static Bureaucrat |
Segmentation.magicWand(AreaWrapper aw,
Layer layer,
Rectangle srcRect,
int x_p_w,
int y_p_w,
Runnable post_task,
boolean inverse,
boolean subtract) |
void |
Segmentation.BlowCommander.mouseDragged(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_d_old,
int y_d_old) |
void |
Segmentation.BlowCommander.mouseReleased(MouseEvent me,
Layer la,
int x_p,
int y_p,
int x_d,
int y_d,
int x_r,
int y_r) |
boolean |
StitchingTEM.PhaseCorrelationParam.setup(Layer layer)
Run setup on a Patch of the layer, if any.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
ContrastEnhancerWrapper.applyLayerWise(Collection<Layer> layers) |
static Bureaucrat |
Blending.blend(List<Layer> layers,
boolean respect_current_mask,
Filter<Patch> filter) |
static void |
Blending.blendLayerWise(List<Layer> layers,
boolean respect_current_mask,
Filter<Patch> filter) |
static void |
StitchingTEM.montageWithPhaseCorrelation(List<Layer> layers,
Worker worker) |
static Bureaucrat |
StitchingTEM.montageWithPhaseCorrelationTask(List<Layer> layers) |
| Constructor and Description |
|---|
BlowCommander(AreaWrapper aw,
Layer layer,
Rectangle srcRect,
int x_p_w,
int y_p_w,
List<Runnable> post_tasks) |
BlowRunner(AreaWrapper aw,
Layer layer,
Rectangle srcRect,
int x_p_w,
int y_p_w) |
| Constructor and Description |
|---|
LayerStack(List<Layer> layers,
Rectangle roi,
double scale,
int type,
Class<?> clazz,
int c_alphas,
boolean invert)
If
scale <=0 || scale > 1, throws IllegalArgumentException. |
| Modifier and Type | Method and Description |
|---|---|
static Collection<AreaList> |
AmiraImporter.extractAmiraLabels(ij.ImagePlus labels,
AmiraParameters ap,
Layer first_layer,
double xo,
double yo)
Returns an ArrayList containing all AreaList objects.
|
static Map<Float,AreaList> |
AmiraImporter.extractAreaLists(ij.ImagePlus imp,
Layer first_layer,
double base_x,
double base_y,
float alpha,
boolean add_background)
Returns a map of label vs AreaList.
|
static Collection<AreaList> |
AmiraImporter.importAmiraLabels(Layer first_layer,
double xo,
double yo,
String default_dir)
Returns the array of AreaList or null if the file dialog is canceled.
|
| Modifier and Type | Method and Description |
|---|---|
Bureaucrat |
Loader.generateLayerMipMaps(Layer[] la,
int starting_level)
Does nothing unless overriden.
|
Image |
Loader.getFlatAWTImage(Layer layer,
Rectangle srcRect_,
double scale,
int c_alphas,
int type,
Class<?> clazz,
List<? extends Displayable> al_displ,
boolean quality,
Color background) |
Image |
Loader.getFlatAWTImage(Layer layer,
Rectangle srcRect_,
double scale,
int c_alphas,
int type,
Class<?> clazz,
List<? extends Displayable> al_displ,
boolean quality,
Color background,
Displayable active) |
ij.ImagePlus |
Loader.getFlatImage(Layer layer,
Rectangle srcRect_,
double scale,
int c_alphas,
int type,
Class<?> clazz,
boolean quality) |
ij.ImagePlus |
Loader.getFlatImage(Layer layer,
Rectangle srcRect_,
double scale,
int c_alphas,
int type,
Class<?> clazz,
List<? extends Displayable> al_displ) |
ij.ImagePlus |
Loader.getFlatImage(Layer layer,
Rectangle srcRect_,
double scale,
int c_alphas,
int type,
Class<?> clazz,
List<? extends Displayable> al_displ,
boolean quality) |
ij.ImagePlus |
Loader.getFlatImage(Layer layer,
Rectangle srcRect_,
double scale,
int c_alphas,
int type,
Class<?> clazz,
List<? extends Displayable> al_displ,
boolean quality,
Color background)
Returns a screenshot of the given layer for the given magnification and srcRect.
|
ij.ImagePlus |
Loader.getFlatImage(Layer layer,
Rectangle srcRect_,
double scale,
int c_alphas,
int type,
Class<?> clazz,
List<? extends Displayable> al_displ,
boolean quality,
Color background,
Displayable active) |
Bureaucrat |
Loader.importGrid(Layer layer) |
Bureaucrat |
Loader.importGrid(Layer layer,
String dir)
Import a grid of images and put them in the layer.
|
Bureaucrat |
Loader.importImage(Layer layer,
double x,
double y,
String path,
boolean synch_mipmap_generation)
Import an image into the given layer, in a separate task thread.
|
Bureaucrat |
Loader.importImages(Layer ref_layer) |
Bureaucrat |
Loader.importImages(Layer ref_layer,
String abs_text_file_path_,
String column_separator_,
double layer_thickness_,
double calibration_,
boolean homogenize_contrast_,
float scale_,
int border_width_)
Import images from the given text file, which is expected to contain 4 columns or optionally 9 columns:
|
Bureaucrat |
Loader.importLabelsAsAreaLists(Layer layer) |
Bureaucrat |
Loader.importLabelsAsAreaLists(Layer first_layer,
String path_,
double base_x_,
double base_y_,
float alpha_,
boolean add_background_)
If base_x or base_y are Double.MAX_VALUE, then those values are asked for in a GenericDialog.
|
Bureaucrat |
Loader.importSequenceAsGrid(Layer layer) |
Bureaucrat |
Loader.importSequenceAsGrid(Layer layer,
String dir) |
Bureaucrat |
Loader.importSequenceAsGrid(Layer first_layer,
String dir,
String[] image_file_names)
Import a sequence of images as a grid, and put them in the layer.
|
Bureaucrat |
Loader.importStack(Layer first_layer,
double x,
double y,
ij.ImagePlus imp_stack_,
boolean ask_for_data,
String filepath_,
boolean one_patch_per_layer_)
Imports an image stack from a multitiff file and places each slice in the proper layer, creating new layers as it goes.
|
Bureaucrat |
Loader.importStack(Layer first_layer,
ij.ImagePlus imp_stack_,
boolean ask_for_data) |
Bureaucrat |
Loader.importStack(Layer first_layer,
ij.ImagePlus imp_stack_,
boolean ask_for_data,
String filepath_) |
protected abstract Patch |
Loader.importStackAsPatches(Project project,
Layer first_layer,
double x,
double y,
ij.ImagePlus stack,
boolean as_copy,
String filepath) |
protected Patch |
FSLoader.importStackAsPatches(Project project,
Layer first_layer,
double x,
double y,
ij.ImagePlus imp_stack,
boolean as_copy,
String filepath)
Returns the last Patch.
|
protected Patch |
DBLoader.importStackAsPatches(Project project,
Layer first_layer,
double x,
double y,
ij.ImagePlus imp_stack,
boolean as_copy,
String filepath)
Returns the last Patch.
|
protected Patch |
Loader.importStackAsPatches(Project project,
Layer first_layer,
ij.ImagePlus stack,
boolean as_copy,
String filepath) |
Bureaucrat |
Loader.makeFlatImage(Layer[] layer,
Rectangle srcRect,
double scale,
int c_alphas,
int type,
boolean force_to_file,
boolean quality) |
Bureaucrat |
Loader.makeFlatImage(Layer[] layer,
Rectangle srcRect,
double scale,
int c_alphas,
int type,
boolean force_to_file,
boolean quality,
Color background) |
Bureaucrat |
Loader.makeFlatImage(Layer[] layer,
Rectangle srcRect,
double scale,
int c_alphas,
int type,
boolean force_to_file,
String format,
boolean quality,
Color background)
If the srcRect is null, makes a flat 8-bit or RGB image of the entire layer.
|
Bureaucrat |
Loader.makePrescaledTiles(Layer[] layers,
Class<?> clazz,
Rectangle srcRect,
int c_alphas,
int type,
String target_dir,
int strategy,
Saver saver,
int tileSide,
int directory_structure_type,
boolean skip_empty_tiles,
boolean use_layer_indices,
int n_threads) |
static Bureaucrat |
ExportMultilevelTiles.makePrescaledTiles(Layer[] layers,
Class<?> clazz,
Rectangle srcRect,
int c_alphas,
int type,
String target_dir,
int strategy,
Saver saver,
int tileSide,
int directory_structure_type,
boolean skip_empty_tiles,
boolean use_layer_indices,
int n_threads)
Generate e.g.
|
void |
Loader.recreateBuckets(Layer[] la)
Recreate buckets for each Layer, one thread per layer, in as many threads as CPUs.
|
static Iterable<Rectangle> |
ProjectTiler.tileSequence(Layer srcLayer,
int tileWidth,
int tileHeight,
boolean onlyVisibleImages)
Return a lazy sequence of Rectangle instances, each specifying a tile that contains at least
parts of one Patch.
|
| Modifier and Type | Method and Description |
|---|---|
Bureaucrat |
Loader.enhanceContrast(Collection<Layer> layers)
Homogenize contrast layer-wise, for all given layers.
|
static Worker |
ExportMultilevelTiles.exportFromMipMaps(TreeMap<Integer,Layer> indices,
int smallestIndex,
String dir,
Saver saver,
Rectangle srcRect,
int c_alphas,
int type,
Class<?> clazz,
int tileSide,
int directory_structure_type,
boolean use_layer_indices,
boolean skip_empty_tiles,
int n_threads) |
static Worker |
ExportMultilevelTiles.exportFromMipMapsLayerWise(TreeMap<Integer,Layer> indices,
int smallestIndex,
String dir,
Saver saver,
Rectangle srcRect,
int c_alphas,
int type,
Class<?> clazz,
int tileSide,
int directory_structure_type,
boolean use_layer_indices,
boolean skip_empty_tiles,
int n_threads)
When I/O limited, optimize parallel mipmap loading (so that no Thread is waiting on any other Thread to finish loading a mipmap)
by generating tiles Patch-wise, processing one Patch at a time, and one Layer per Thread.
|
static Worker |
ExportMultilevelTiles.exportFromOriginals(TreeMap<Integer,Layer> indices,
int smallestIndex,
String dir,
Saver saver,
Rectangle srcRect,
int c_alphas,
int type,
Class<?> clazz,
int tileSide,
int directory_structure_type,
boolean use_layer_indices,
boolean skip_empty_tiles,
int n_threads) |
Bureaucrat |
Loader.maskBordersLayerWise(Collection<Layer> layers,
int left,
int top,
int right,
int bottom)
Make the border have an alpha of zero.
|
void |
Loader.recreateBuckets(Collection<Layer> col) |
| Modifier and Type | Method and Description |
|---|---|
void |
LayerTree.addLayer(LayerSet layer_set,
Layer layer)
Used by the Loader.importStack and the "many new layers" command.
|
Profile |
ProjectTree.duplicateChild(Profile original,
int position,
Layer layer)
Implements the "Duplicate, link and send to next/previous layer" functionality.
|
boolean |
LayerTree.remove(Layer layer,
boolean check) |
void |
LayerTree.selectNode(Layer layer)
Deselects whatever node is selected in the tree, and tries to select the one that contains the given object.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
Utils.addLayerChoice(String label,
Layer selected,
GenericDialog gd) |
static void |
Utils.addLayerRangeChoices(Layer selected,
GenericDialog gd) |
static void |
Utils.addLayerRangeChoices(Layer first,
Layer last,
GenericDialog gd) |
| Modifier and Type | Method and Description |
|---|---|
static List<Point3f> |
AreaUtils.generateTriangles(Displayable d,
double scale,
int resample_,
Map<Layer,Area> areas)
Expects areas in local coordinates to the Displayable @param d.
|
static void |
Utils.paint(Pipe pipe,
Map<Layer,ij.process.ImageProcessor> slices,
int value,
float scale)
Paints an approximation of the pipe into the set of slices.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
DistortionCorrectionTask.run(DistortionCorrectionTask.CorrectDistortionFromSelectionParam p,
List<Patch> patches,
Displayable active,
Layer layer) |
static void |
DistortionCorrectionTask.run(DistortionCorrectionTask.CorrectDistortionFromSelectionParam p,
List<Patch> patches,
Displayable active,
Layer layer,
Worker worker) |
| Modifier and Type | Method and Description |
|---|---|
static void |
Align.alignLayer(Layer layer,
int numThreads)
Align all
patches in a Layer. |
static void |
AlignLayersTask.alignLayers(Layer l) |
static void |
AlignLayersTask.alignLayers(Layer l,
Rectangle fov) |
static Bureaucrat |
AlignLayersTask.alignLayersTask(Layer l) |
static Bureaucrat |
AlignLayersTask.alignLayersTask(Layer l,
Rectangle fov) |
static void |
AlignTask.alignMultiLayerMosaic(Layer l,
Patch nail)
Align a multi-layer mosaic.
|
static Bureaucrat |
AlignTask.alignMultiLayerMosaicTask(Layer l) |
static Bureaucrat |
AlignTask.alignMultiLayerMosaicTask(Layer l,
Patch nail) |
protected static void |
RegularizedAffineLayerAlignment.applyTransformToLayer(Layer layer,
AffineTransform affine,
Filter<Patch> filter) |
protected static void |
ElasticLayerAlignment.applyTransformToLayer(Layer layer,
CoordinateTransform mlt,
Filter<Patch> filter) |
static List<Patch> |
AlignmentUtils.filterPatches(Layer layer,
Filter<Patch> filter) |
static String |
AlignmentUtils.layerName(Layer layer) |
static void |
AlignTask.transformPatchesAndVectorData(Layer layer,
AffineTransform a) |
| Modifier and Type | Method and Description |
|---|---|
static void |
Align.alignLayersLinearly(List<Layer> layers,
int numThreads)
Align a range of layers by accumulating pairwise alignments of contiguous layers.
|
static void |
Align.alignLayersLinearly(List<Layer> layers,
int numThreads,
Filter<Patch> filter)
Align a range of layers by accumulating pairwise alignments of contiguous layers.
|
static void |
AlignTask.alignMultiLayerMosaicTask(List<Layer> layerRange,
Patch nail,
Align.Param cp,
Align.ParamOptimize p,
Align.ParamOptimize pcp,
boolean tilesAreInPlaceIn,
boolean largestGraphOnlyIn,
boolean hideDisconnectedTilesIn,
boolean deleteDisconnectedTilesIn,
boolean deformIn) |
void |
ElasticLayerAlignment.exec(ElasticLayerAlignment.Param param,
Project project,
List<Layer> layerRange,
Set<Layer> fixedLayers,
Set<Layer> emptyLayers,
Rectangle box,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Filter<Patch> filter) |
void |
ElasticLayerAlignment.exec(ElasticLayerAlignment.Param param,
Project project,
List<Layer> layerRange,
Set<Layer> fixedLayers,
Set<Layer> emptyLayers,
Rectangle box,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Filter<Patch> filter) |
void |
ElasticLayerAlignment.exec(ElasticLayerAlignment.Param param,
Project project,
List<Layer> layerRange,
Set<Layer> fixedLayers,
Set<Layer> emptyLayers,
Rectangle box,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Filter<Patch> filter) |
void |
RegularizedAffineLayerAlignment.exec(List<Layer> layerRange,
Set<Layer> fixedLayers,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
RegularizedAffineLayerAlignment.exec(List<Layer> layerRange,
Set<Layer> fixedLayers,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
ElasticLayerAlignment.exec(Project project,
List<Layer> layerRange,
Set<Layer> fixedLayers,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
ElasticLayerAlignment.exec(Project project,
List<Layer> layerRange,
Set<Layer> fixedLayers,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Rectangle fov,
Filter<Patch> filter)
Stateful.
|
void |
RegularizedAffineLayerAlignment.exec(RegularizedAffineLayerAlignment.Param param,
List<Layer> layerRange,
Set<Layer> fixedLayers,
Set<Layer> emptyLayers,
Rectangle box,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Filter<Patch> filter) |
void |
RegularizedAffineLayerAlignment.exec(RegularizedAffineLayerAlignment.Param param,
List<Layer> layerRange,
Set<Layer> fixedLayers,
Set<Layer> emptyLayers,
Rectangle box,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Filter<Patch> filter) |
void |
RegularizedAffineLayerAlignment.exec(RegularizedAffineLayerAlignment.Param param,
List<Layer> layerRange,
Set<Layer> fixedLayers,
Set<Layer> emptyLayers,
Rectangle box,
boolean propagateTransformBefore,
boolean propagateTransformAfter,
Filter<Patch> filter) |
protected static void |
AlignmentUtils.extractAndSaveLayerFeatures(List<Layer> layerRange,
Rectangle box,
double scale,
Filter<Patch> filter,
FloatArray2DSIFT.Param siftParam,
boolean clearCache,
int numThreads)
Extract SIFT features and save them into the project folder.
|
static void |
AlignTask.montageLayers(Align.ParamOptimize p,
List<Layer> layers,
boolean tilesAreInPlaceIn,
boolean largestGraphOnlyIn,
boolean hideDisconnectedTilesIn,
boolean deleteDisconnectedTilesIn) |
static void |
AlignTask.montageLayers(Align.ParamOptimize p,
List<Layer> layers,
boolean tilesAreInPlaceIn,
boolean largestGraphOnlyIn,
boolean hideDisconnectedTilesIn,
boolean deleteDisconnectedTilesIn,
boolean sloppyOverlapTest) |
static void |
AlignTask.montageLayers(ElasticMontage.Param p,
List<Layer> layers) |
static Bureaucrat |
AlignTask.montageLayersTask(List<Layer> layers)
Montage each layer independently.
|
| Constructor and Description |
|---|
BlockMatchPairCallable(Triple<Integer,Integer,AbstractModel<?>> pair,
List<Layer> layerRange,
boolean layer1Fixed,
boolean layer2Fixed,
Filter<Patch> filter,
ElasticLayerAlignment.Param param,
Collection<? extends Point> sourcePoints1,
Collection<? extends Point> sourcePoints2,
Rectangle box) |
| Modifier and Type | Method and Description |
|---|---|
static void |
ExportUnsignedShort.exportTEST(Layer layer,
int tileWidth,
int tileHeight) |
static Iterable<Callable<ExportedTile>> |
ExportUnsignedShort.exportTiles(Layer layer,
int tileWidth,
int tileHeight,
boolean visible_only)
Create constant size tiles that carpet the areas of the
layer where there are images;
these tiles are returned in a lazy sequence of Callable objects that create a tripled
consisting of the ShortProcessor and the X and Y pixel coordinates of that tile. |
| Modifier and Type | Method and Description |
|---|---|
static ij.ImageStack |
ExportUnsignedShort.makeFlatImageStack(List<Layer> layers,
Rectangle roi,
double backgroundValue)
Returns a stack of ShortProcessor, with dimensions as in the
roi. |
| Modifier and Type | Method and Description |
|---|---|
<M extends Model<M> & Affine1D<M>> |
MatchIntensities.run(List<Layer> layers,
int radius,
double scale,
int numCoefficients,
double lambda1,
double lambda2,
double neighborWeight,
Rectangle roi) |
| Modifier and Type | Method and Description |
|---|---|
static ij.process.FloatProcessor |
LayerZPosition.calculateNCCSimilarity(List<Layer> layers,
Rectangle fov,
int r,
double s) |
static ij.process.FloatProcessor |
LayerZPosition.calculateSIFTSimilarity(List<Layer> layers,
Rectangle fov,
int r,
Align.Param p) |
void |
LayerZPosition.invokeNCC(List<Layer> layers,
Rectangle fov)
Run plugin with NCC similarity.
|
void |
LayerZPosition.invokeSIFT(List<Layer> layers,
Rectangle fov)
Run plugin with SIFT consensus similarity.
|
static void |
LayerZPosition.optimize(List<Layer> layers,
ij.process.FloatProcessor matrix,
int rad,
int iter,
double reg,
int innerIter,
double innerReg,
boolean reord) |
static void |
LayerZPosition.runNCC(List<Layer> layers,
Rectangle fov,
int r,
double s,
int iter,
double reg,
int innerIter,
double innerReg,
boolean reord)
Run thickness estimation for a list of layers using NCC similarity.
|
static void |
LayerZPosition.runSIFT(List<Layer> layers,
Rectangle fov,
int r,
Align.Param p) |
Copyright © 2015–2021 Fiji. All rights reserved.