Uses of Package
org.anchoranalysis.core.exception

Package
Description
Reading and writing annotations to the filesystem.
A pairing of objects from two collections (bipartite matching).
Generates output images to illustrate a Assignment between annotations.
Beans related to reading / writing / specifying annotations.
What to compare an annotation (ground truth) against?
Annotations that use one or more marks to describe entities in an image.
Defining, loading, initializing Anchor Beans.
Define and related-classes.
Exceptions that can occur executing generic operations on Anchor Beans.
Initializing beans with particular parameters, including recursively.
Initializating a bean with parameters.
Applying permutations to a bean's fields.
Imposes a permutation value on one or more properties of a bean.
Utility beans which have a generally broader use than a specific module.
Beans that create lists or indices of colors according to particular schemes.
Setting, referencing and initializing key-value parameters.
Exceptions that can thrown when loading beans from XML.
Collection-related classes with general applicability that don't belong elsewhere.
Very general exceptions and base classes for exceptions with wide applicability.
Nested exceptions of similar type that can be combined together in a summary.
Particular types of exceptions that are guaranteed to have a text/form that gives user-friendly error descriptions.
File formats and associated extensions.
Utilities and interfaces for applying functional-programming.
Data-structures for directed and undirected graphs, with or without an edge payload.
A collection of named-elements, a NamedProvider and related operations.
Data structures like NamedProvider with supporting for adding new elements.
Classes to support getting / setting / specifying unique-integers (indices) for elements.
A range of indices from minimum to maximum.
Utilities for serializing and deserializing objects.
Utilities for converting/manipulating file-paths.
Encapsulating values or sets of named-values.
Classes related to executing an experiment by calling jobs on inputs.
Generic experiments that handle input and output in structured ways.
How a task is executed on multiple inputs.
Interfaces for replacing attributes of an experiment: input, output, task etc.
Helpful classes for logging.
Beans pertaining to feature-calculation.
A feature-list (custom list type for features) and associated providers.
Sub-feature units of calculation that can be cached.
Interfaces like FeatureCalculator but bound to particular features.
A particular stack used in feature-calculations called a EnergyStack together with related classes.
Initialization parameters used for beans in org.anchoranalysis.feature.bean.
A defined context in which one or more features are provided inputs and produce results.
Strategies to determine which child-cache (among hierarchy) to employ for a particular feature calculation.
Strategies on whether to reuse or invalidate a feature-input's cache.
Features shared for referencing among calculations.
Base classes for performing operations on Channels.
 
Classes that are used elsewhere in this package but which aren't themselves AnchorBeans.
Classes that aren't AnchorBeans that pertain to the initialization of image-related beans.
Non-bean classes relating to image-segmentation.
Non-beans to specify how to form a single-image by spatially combining other images.
Beans pertaining to ObjectMask and their collections.
Base classes to perform binary-segmentation.
Beans to define entities or operate that consider Euclidian space.
Aligning a BoundingBox to fit inside another BoundingBox.
Beans to specify a direction.
Base classes for thresholding and calculating levels for thresholding.
Converting quantities of distance between units.
Conversions and operations involving Java AWT's BufferedImage.
Converts a channel to another data-type based upon another object to which it is attached.
Converts a channel to another data-type based upon a Histogram to which it is attached.
Factory classes for creating Channel for various voxel data-types.
Classes to describe the size of images or components of images both in voxels and physically.
Suggestions on a size for an image.
Merges two or more entities.
The key data entity org.anchoranalysis.image.voxel.object and related-classes and operations.
Labelling elements (object-masks or similar) with unique successive integers in a channel.
Scaling object-collections, or lists of elements with object-representations.
Scaling elements with an associated ObjectMask either collectively or independently.
Operations that extract points from image data entities or vice versa.
Defines the key data object, Stack, and related classes.
A collection of Stacks, each with a unique identifier as a name.
Beans pertaining to feature definition and calculation.
Beans that define context (which feature, which energy-stack) for evaluating feature-inputs.
Features that convert to/from physical spatial units (e.g. meters) as opposed to pixels/voxels.
Implementations of FeatureCalculatorMulti related to images, especially to create tables of feature-calculations.
A particular implementation of FeatureCalculatorMulti for feature-calculations based upon pairs of image-objects.
Inference of machine learning models on images.
Beans to reduce the number of results that are returned from inference, by removing overlaping entities etc.
Non-bean classes to reduce the number of results that are returned from inference, by removing overlapping entities etc.
Non-beans pertaining to segmentation of images via model inference.
Reading and writing of image-related data objects to and from the filesystem.
Beans pertaining to reading Channels as input.
How to represent an object-mask in a raster that is being drawn.
Non-bean classes for reading a Channel from the filesystem.
Non-bean classes for a mapping of names to Channels.
Writing an ObjectCollection to the filesystem as RGB raster-images.
Non-bean classes for reading / writing a Stack from and to the filesystem.
Non-bean classes for reading a Stack from the filesystem.
Base classes for generators that ultimately write only a bounding-box portion of a Stack to the filesystem.
Base classes for generators that ultimately write a Stack to the filesystem.
A time-sequence of Stacks.
Data-structures to store and manipulate image raster-data or voxels.
The BinaryVoxels class and related operations.
Converting Voxels to different data-types.
Converts anchor data-structures to the BufferedImage used by Java's AWT.
The different data-types that can be used to represent voxels.
Routines for moving a KernelPointCursor around the neighboring voxels of the point.
Applying a kernel via convolution to voxels.
A region in proximity to a voxel, encompassing this voxel as well as others.
The fundamental data class that is an ObjectMask and related structures.
Predicates to match certain voxels as used in org.anchoranalysis.image.voxel.object.morphological.
Classes for calculating differnet kind of projections of voxel values across multiple buffers.
Statistics about aggregated voxel intensities.
Thresholding operations on voxels.
High-level classes for performing machine learning model inference.
Specifying how many CPUs and GPUs can be allocated for some purpose.
Non-bean classes for filesystem I/O using Bioformats.
Converts the byte stream opened by Bioformats into channels of particular data-type.
Base-classes and utilities for generators, which write different types of objects to the file system.
Converts to and from ImageJ data-structures for images.
Classes relating to creating inputs for an experiment / task.
Beans to derive names (compact unique identifiers) from files.
Classes for reading comma-separated-values (CSV) files.
Non-bean classes that relate to using files during inputting.
Non-bean classes pertaining to getting/extracting/manipulating paths as used in inputting.
Non-bean classes to help with org.anchoranalysis.io.input.bean.path.matcher.
Exceptions that may be thrown when writing files to the file-system.
Classes for outputting to particular directories.
Non-beans for generating paths for outputting files by adding a prefix, suffix etc.
Parent package and entry-point classes for the Anchor command-line launcher application.
Converting paths to/from different formats as needed by org.anchoranalysis.launcher.executor.selectparam.path.
Solving or manipulating equations.
The Histogram data class and related operations.
Beans generally related to Marks.
Beans related to creating Marks.
Operations based on sets of points.
Fitting structures to sets of points.
Proposing Marks or other data-structures with particular attributes.
Criteria for adding edges during optimization of marked-point-processes.
Creating EnergySchemes.
Saved snapshots of energy-calculations.
Factorized form of storing the energy during an energy-minimization optimization scheme.
Parameters used to initialize certain types of beans.
Non-beans for reading data structures related to marked point processes from the file system.
Non-beans for writing data structures related to marked point processes from the file system.
Non-bean classes related to Marks.
Marks implementing conic sections.
Marks implementing structures based on points.
Any Overlay related to a Mark.
Non-bean classes for proposing Marks or other data-structures with particular attributes.
Recording errors related to proposing Marks or other data-structures with particular attributes.
Overlays and related classes involving drawing entities on top of an image.
Beans relating to drawing an Overlay on an image.
An implementation of an Overlay that draws an ObjectMask on an image.
Drawing an overlay on an image.
Pairs annotations from two different sets, creating an assignment of some type.
Strategies for how to annotate an image, such label per image etc.
Morphological grayscale-reconstruction algorithm.
Implementations of MaskProvider that use FIJI.
Implementations of Thresholder that use FIJI.
Filters that perform blurring.
Implementations of ChannelProvider that are generic base-classes or otherwise abstract or general.
Implementations of DimensionsProvider.
Implementations of HistogramProvider.
Thresholding of intensity values represented in at Histogram.
Implementations of MaskProvider.
Implementations of MaskProvider that convert providers of other types to ObjectMasks.
Implementations of MaskProvider where an ObjectCollection is created by segmenting a Channel.
Implementations of ObjectFilter.
Implementations of ObjectFilter that assess each element in a collection collectively.
Implementations of ObjectFilter that combine two or more other ObjectFilters.
Implementations of ObjectFilter that independently assess each element in a collection.
Implementations of ObjectMatcher.
Implementations of ObjectCollectionProvider.
Implementations of ObjectCollectionProvider involving merging objects together.
Minima imposition for a Watershed transformation.
Grayscale reconstruction to support the Watershed transformation.
Strategies for reducing the number of elements with a list by merging/removing lower-confidence elements that overlap.
Implementations of ScaleCalculator for calculating a scaling-factor from dimensions.
Implementations of StackProvider.
Implementations of StackProvider that color portions of an image.
Implementations of ThumbnailFromObjects.
Implementations of ThumbnailFromStack.
Implementations of FeatureListProvider that derive new features with permuted property-values.
Features from combinations of ObjectMasks.
Implementations of FeatureSingleObject that use SharedObjects for calculations.
Implementations of FeatureSingleObject that use SharedObjects for calculations, and measure the degree of intersection between objects.
Implementations of VoxelScore.
Beans involving SharedObjects.
Beans involving SharedObjects and ObjectCollection.
Implementations of CalculationPart that that process a single ObjectMask.
Implementations of CalculationPart that that process a single ObjectMask - with morphological operations.
Non-bean for operations or calculations relating to intensity.
Non-beans for calculating a thresholding level from itensity values.
Non-beans pertaining to ObjectMasks.
Merging ObjectMasks.
Conditions for merging ObjectMasks.
Assigning priority when merging ObjectMasks.
Combining multiple images together into a single image.
Source of rows in feature-tables with FeatureSource and derived classes.
Different approaches for converting sets of channels (RGB, independently etc.) to another image format.
Tasks that involved stacks (usually each channel from an image) that are somehow grouped-together.
Task(s) to export histograms of intensity values.
Selecting a subset of a set of channels.
Associating labels with images.
Tasks to scale an image.
Combines multiple Channels voxel-wise to form a single aggregated Channel.
Non-bean classes pertaining to Features as used in tasks.
Non-beans for calculating Features.
Non-bean classes about grouping channels or other inputs.
Non-bean classes about labelling images.
Non-bean classes for image-segmentation.
Non-bean classes pertaining to combining stacks into a single stack.
Non-bean classes pertaining to stacks and channels as used in tasks.
Non-bean classes for thumbnail creation.
Implementations of Thresholder that call ImageJ.
Implementations of ChannelProvider that call ImageJ.
Non-bean classes involving ObjectMask that call ImageJ.
Implementations of ChannelMapCreator.
Methods for copying files on the file-system.
Rules for preserving or changing the naming of files when copying on the file-system.
Implementations of CopyFilesNaming that perform clustering of files.
Implementations of FileNamer.
Implementations of InputManager that process Stacks.
Summarizing a set of elements into a descriptive-string.
Implementations of Summarizer that summarize images.
Implementations of Summarizer that summarize generically InputFromManagers.
Implementations of Summarizer that summarize generically Paths.
Non-bean classes to help tasks in org.anchoranalysis.plugin.io.bean.file.copy.
Non-bean classes to help in processing paths.
Objects used in shared-state in Tasks in this plugin.
Converting from NamedChannelsInput to the input-type expected by a Task.
Beans related to Define involving Mark or related classes.
Implementations of StackProvider involving Mark or related classes.
Decodes the outputted tensors from a Mask R-CNN implementation.
Decodes the outputted tensors from text-segmentation models.
Segmenting a Stack using the ONNX Runtime to produce an ObjectCollection.
Non-bean classes for running an inference model with the ONNX Runtime.
Plugins that call OpenCV.
Segmentation of a Stack using OpenCV.
Conversion to/from OpenCV data-structures.
Non-bean classes pertaining to segmentation.
Features that combine or convert other features in a generic way.
Fitting geometric structures to points.
CalculationPart related to fitting ellipsoids to points by least-squares.
Non-bean convex hull operations.
Identifying the three standard axes in 3D cartesian coordinates.
Axis-aligned bounding-boxes and related operations.
Various methods to specify the orientation (general direction) of an entity.
Helper classes to execute Tasks in tests.
Testing utilities and fixtures with no greater downstream dependency than anchor-image-feature or anchor-mpp.
A mocked feature internally using a feature-calculation.