Package | Description |
---|---|
org.anchoranalysis.feature.bean |
Beans pertaining to feature-calculation.
|
org.anchoranalysis.feature.bean.list |
A feature-list (custom list type for features) and associated providers.
|
org.anchoranalysis.feature.bean.operator |
Features that are sufficiently generic to work on any input-type.
|
org.anchoranalysis.feature.bean.provider |
Provider of a single feature.
|
org.anchoranalysis.feature.bean.results |
Defines base class
FeatureResults together with
some implementations. |
org.anchoranalysis.feature.calculate |
Sub-feature units of calculation that can be cached.
|
org.anchoranalysis.feature.calculate.bound |
Interfaces like
FeatureCalculator but bound to
particular features. |
org.anchoranalysis.feature.calculate.cache |
Classes to cache feature-results or parts of feature-results that occur repeatedly among features
or across calculations of the same feature.
|
org.anchoranalysis.feature.calculate.cache.part |
Equivalent classes to
org.anchoranalysis.feature.calculate.part after having been
resolved against a cache. |
org.anchoranalysis.feature.calculate.part |
A sub-part of the calculation of a feature, that can be cached, and reused by other features.
|
org.anchoranalysis.feature.initialization |
Initialization parameters used for beans in
org.anchoranalysis.feature.bean . |
org.anchoranalysis.feature.input |
Base classes providing inputs to feature calculations.
|
org.anchoranalysis.feature.name |
Data objects for the names of features.
|
org.anchoranalysis.feature.session |
A defined context in which one or more features are provided inputs and produce results.
|
org.anchoranalysis.feature.session.cache |
Creates a
FeatureCalculationCache to use
during feature-calculations. |
org.anchoranalysis.feature.session.cache.finder |
Strategies to determine which child-cache (among hierarchy) to employ for a particular feature
calculation.
|
org.anchoranalysis.feature.session.calculator |
Base classes for methods to calculate results from features.
|
org.anchoranalysis.feature.session.replace |
Strategies on whether to reuse or invalidate a feature-input's cache.
|
org.anchoranalysis.feature.shared |
Features shared for referencing among calculations.
|
org.anchoranalysis.feature.store |
A collection of named-
Feature s. |
org.anchoranalysis.image.feature.bean |
Beans pertaining to feature definition and calculation.
|
org.anchoranalysis.image.feature.bean.evaluator |
Beans that define context (which feature, which energy-stack) for evaluating feature-inputs.
|
org.anchoranalysis.image.feature.bean.object.collection |
Features that operate on a
ObjectCollection . |
org.anchoranalysis.image.feature.bean.object.pair |
Features that operate on a pair of
ObjectMask s. |
org.anchoranalysis.image.feature.bean.object.single |
Features that operate on a single
ObjectMask . |
org.anchoranalysis.image.feature.calculator |
Implementations of
FeatureCalculatorMulti
related to images, especially to create tables of feature-calculations. |
org.anchoranalysis.image.feature.input |
Image-related implementations of
FeatureInput . |
org.anchoranalysis.mpp.feature.addcriteria |
Criteria for adding edges during optimization of marked-point-processes.
|
org.anchoranalysis.mpp.feature.bean.energy.element |
Implementations and helper classes for calculating energy during an energy-minimization
optimization scheme.
|
org.anchoranalysis.mpp.feature.bean.mark |
Features calculated on a
Mark . |
org.anchoranalysis.mpp.feature.bean.mark.collection |
Features calculated on a
org.anchoranalysis.mpp.feature.bean.mark.collection . |
org.anchoranalysis.mpp.feature.energy.scheme |
Factorized form of storing the energy during an energy-minimization optimization scheme.
|
org.anchoranalysis.mpp.feature.input |
Inputs to mark-point-processes related
Feature s. |
org.anchoranalysis.mpp.io.bean.report.feature |
Beans for communicating feature-values from data-structures in human-readable manner.
|
org.anchoranalysis.plugin.image.feature.bean.dimensions |
Features that are calculated from
Dimensions . |
org.anchoranalysis.plugin.image.feature.bean.list.permute |
Implementations of
FeatureListProvider that derive
new features with permuted property-values. |
org.anchoranalysis.plugin.image.feature.bean.object.combine |
Features from combinations of
ObjectMask s. |
org.anchoranalysis.plugin.image.feature.bean.shared |
Beans involving
SharedObjects . |
org.anchoranalysis.plugin.image.feature.bean.shared.object |
Beans involving
SharedObjects and
ObjectCollection . |
org.anchoranalysis.plugin.image.feature.object.calculation.delegate |
Implementations of
CalculationPart as used by
features elsewhere in this package. |
org.anchoranalysis.plugin.image.task.bean.feature |
Tasks pertaining to
Feature s. |
org.anchoranalysis.plugin.image.task.bean.feature.source |
Source of rows in feature-tables with
FeatureSource and derived classes. |
org.anchoranalysis.plugin.image.task.feature |
Non-bean classes pertaining to
Feature s as used in tasks. |
org.anchoranalysis.plugin.image.task.feature.calculator |
Non-beans for calculating
Feature s. |
org.anchoranalysis.plugin.ml.bean.classifier |
Beans that perform classification in some way.
|
org.anchoranalysis.plugin.mpp.bean.check |
Implementations of
CheckMark . |
org.anchoranalysis.plugin.mpp.experiment.bean.feature.source |
Implementations of
FeatureSource . |
org.anchoranalysis.plugin.mpp.feature.bean.memo.ind |
Implementations of
FeatureSingleMemo . |
org.anchoranalysis.plugin.operator.feature.bean |
Features that combine or convert other features in a generic way.
|
org.anchoranalysis.plugin.operator.feature.bean.arithmetic |
Arithmetic involving features.
|
org.anchoranalysis.plugin.operator.feature.bean.conditional |
Conditional operations involving features.
|
org.anchoranalysis.plugin.operator.feature.bean.list |
Operations that extract a single value from a list of features.
|
org.anchoranalysis.plugin.operator.feature.bean.range |
Features that compare against a range of values.
|
org.anchoranalysis.plugin.operator.feature.bean.replace |
Replaces particular values if they are returned from a feature.
|
org.anchoranalysis.plugin.operator.feature.bean.statistics |
Converts feature values based upon a statistical measure of distribution.
|
org.anchoranalysis.plugin.operator.feature.physical |
Converting to/from physical units.
|
org.anchoranalysis.test.feature |
Testing utilities and fixtures with no greater downstream dependency than anchor-feature.
|
org.anchoranalysis.test.feature.plugins |
Testing utilities and fixtures with no greater downstream dependency than
anchor-image-feature or anchor-mpp.
|
org.anchoranalysis.test.feature.plugins.mockfeature |
A mocked feature internally using a feature-calculation.
|
Modifier and Type | Class and Description |
---|---|
class |
Feature<T extends FeatureInput>
Base class for a measurement that calculates a result (double) given input parameters.
|
Modifier and Type | Method and Description |
---|---|
FeatureList<FeatureInput> |
Feature.createListChildFeatures()
Returns a list of Features that exist as bean-properties of this feature, either directly or
in lists.
|
abstract Class<? extends FeatureInput> |
Feature.inputType()
The class corresponding to feature input-type.
|
Modifier and Type | Method and Description |
---|---|
protected void |
Feature.assignTo(Feature<FeatureInput> target)
Copies fields in this (base) class to
target . |
Modifier and Type | Class and Description |
---|---|
class |
Define<T extends FeatureInput>
Specifies a list of features directly without assigning any custom-naming.
|
class |
DefinedNamed<T extends FeatureInput>
Specifies features via a list of names and associated with features.
|
class |
DefineSingle<T extends FeatureInput>
Specifies a single feature directly without assigning any custom-naming.
|
class |
FeatureList<T extends FeatureInput>
A list of features with the same input-type.
|
class |
FeatureListProvider<T extends FeatureInput>
Provides a list of
Feature s with identical input-type. |
class |
ReferencingFeatureListProvider<T extends FeatureInput>
A base class for implementations of
FeatureListProvider that may reference features
created elsewhere. |
Modifier and Type | Method and Description |
---|---|
static <T extends FeatureInput> |
FeatureListFactory.empty()
Creates an empty list of features
|
<S extends FeatureInput,E extends Exception> |
FeatureList.filterAndMap(java.util.function.Predicate<Feature<T>> predicate,
CheckedFunction<Feature<T>,Feature<S>,E> mappingFunction)
|
static <S,T extends FeatureInput,E extends Exception> |
FeatureListFactory.flatMapFromOptional(Iterable<S> iterable,
CheckedFunction<S,Optional<FeatureList<T>>,E> flatMapFunc)
Creates a new feature-list by flat-mapping an iterable to an optional feature
|
static <T extends FeatureInput> |
FeatureListFactory.from(Feature<T>... feature)
Creates a list for one or more features
|
static <T extends FeatureInput> |
FeatureListFactory.fromIterable(Iterable<Feature<T>> iterable)
Creates a list of features from an iterable
|
static <T extends FeatureInput> |
FeatureListFactory.fromProvider(Provider<Feature<T>> featureProvider)
Creates a list for a single-feature created from a provider
|
static <T extends FeatureInput> |
FeatureListFactory.fromProviders(Collection<FeatureProvider<T>> providers)
Creates a list of features from a collection of feature-providers
|
static <T extends FeatureInput> |
FeatureListFactory.fromStream(java.util.stream.Stream<Feature<T>> stream)
Creates a list of features from a stream
|
<S extends FeatureInput,E extends Exception> |
FeatureList.map(CheckedFunction<Feature<T>,Feature<S>,E> mapFunc)
Creates a new feature-list where each feature is the result of applying a map-function to an
existing feature.
|
static <S,T extends FeatureInput,E extends Exception> |
FeatureListFactory.mapFrom(Iterable<S> iterable,
CheckedFunction<S,Feature<T>,E> mapFunc)
|
static <S,T extends FeatureInput,E extends Exception> |
FeatureListFactory.mapFromFiltered(Iterable<S> iterable,
java.util.function.Predicate<S> predicate,
CheckedFunction<S,Feature<T>,E> mapFunc)
Creates a new feature-list by filtering an iterable and then mapping it to a feature
|
static <T extends FeatureInput> |
FeatureListFactory.mapFromRange(int startInclusive,
int endExclusive,
java.util.function.IntFunction<Feature<T>> mapFunc)
Creates a new feature-list by mapping integers (from a range) each to a feature
|
static <T extends FeatureInput,E extends Exception> |
FeatureListFactory.mapFromRangeOptional(int startInclusive,
int endExclusive,
Class<? extends Exception> throwableClass,
CheckedIntFunction<Optional<Feature<T>>,E> mapFunc)
Creates a new feature-list by mapping integers (from a range) each to an optional feature
|
static <T extends FeatureInput> |
FeatureListFactory.wrapDuplicate(List<Feature<T>> list)
Wraps an existing list, WITHOUT reusing the list in the internals of the
FeatureList
i.e. |
static <T extends FeatureInput> |
FeatureListFactory.wrapReuse(List<Feature<T>> list)
Wraps an existing list, reusing the list in the internals of the
FeatureList |
Modifier and Type | Method and Description |
---|---|
FeatureList<FeatureInput> |
PrependName.get() |
FeatureListProvider<FeatureInput> |
PrependName.getItem()
Provides the features and names before any prepending.
|
Modifier and Type | Method and Description |
---|---|
void |
PrependName.setItem(FeatureListProvider<FeatureInput> item)
Provides the features and names before any prepending.
|
Modifier and Type | Class and Description |
---|---|
class |
Constant<T extends FeatureInput>
A constant value that is entirely invariant to the feature-input.
|
class |
FeatureBinary<T extends FeatureInput>
A base class for a
Feature that is a binary-function of the results from two other
features. |
class |
FeatureFromList<T extends FeatureInput>
A base class for a
Feature that is a function of the results from a list of other
features. |
class |
FeatureGeneric<T extends FeatureInput>
Base class for features that broadly accept any type of feature-input.
|
class |
FeatureUnary<T extends FeatureInput,S extends FeatureInput>
A feature that contains another feature as a bean-parameter.
|
class |
FeatureUnary<T extends FeatureInput,S extends FeatureInput>
A feature that contains another feature as a bean-parameter.
|
class |
FeatureUnaryGeneric<T extends FeatureInput>
A
FeatureUnary that accepts any FeatureInput irrespective of type. |
class |
Reference<T extends FeatureInput>
Uses another feature to calculate the value.
|
class |
Sum<T extends FeatureInput>
Sums the results after calculating a list of
Feature s. |
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FeatureGeneric.inputType() |
Class<? extends FeatureInput> |
FeatureUnary.inputType() |
Class<? extends FeatureInput> |
FeatureFromList.inputType() |
Class<? extends FeatureInput> |
FeatureBinary.inputType() |
Modifier and Type | Class and Description |
---|---|
class |
FeatureProvider<T extends FeatureInput>
Provides a single
Feature . |
class |
FeatureProviderDefine<T extends FeatureInput>
Defines a single
Feature to provide via a bean property. |
Modifier and Type | Method and Description |
---|---|
Feature<FeatureInput> |
FeatureProviderReference.get() |
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FeatureResults.inputType() |
Modifier and Type | Interface and Description |
---|---|
interface |
FeatureCalculationInput<T extends FeatureInput>
Gives a
FeatureInput the necessary context for feature-calculation, including associating
it with a cache. |
interface |
FeatureCalculator<T extends FeatureInput>
Calculates
FeatureCalculationInput when passed a particular Feature and
corresponding FeatureCalculationInput . |
Modifier and Type | Interface and Description |
---|---|
interface |
FeatureCalculatorMulti<T extends FeatureInput>
Like a
FeatureCalculator but is permanently associated with one or more Feature s. |
class |
FeatureCalculatorMultiChangeInput<T extends FeatureInput>
A
FeatureCalculatorMulti but changes the input before calculation. |
interface |
FeatureCalculatorSingle<T extends FeatureInput>
Like a
FeatureCalculator but is permanently associated with a single Feature . |
class |
FeatureCalculatorSingleChangeInput<T extends FeatureInput>
A
FeatureCalculatorSingle but changes the input before calculation. |
class |
FeatureCalculatorSingleFromMulti<T extends FeatureInput>
Exposes a
FeatureCalculatorMulti as a FeatureCalculatorSingle . |
Modifier and Type | Interface and Description |
---|---|
interface |
CalculateForChild<T extends FeatureInput>
Performs calculations using child-caches instead of the main cache
|
interface |
FeatureCalculationCache<T extends FeatureInput>
A context in which to calculate features while caching certain duplicated internal calculations
among the features.
|
interface |
FeatureSymbolCalculator<T extends FeatureInput>
Resolves and calculates a feature by a symbol.
|
Modifier and Type | Method and Description |
---|---|
<S extends FeatureInput,U> |
CalculateForChild.calculate(ChildCacheName childCacheName,
S input,
java.util.function.Function<CalculationPartResolver<S>,ResolvedPart<U,S>> resolver)
Calculates a
CalculationPart in a child-cache. |
<S extends FeatureInput> |
CalculateForChild.calculate(Feature<S> feature,
CalculationPart<S,T> calculation,
ChildCacheName childCacheName)
Calculates a feature in a child-cache using a new input created from a
CalculationPart . |
<S extends FeatureInput> |
CalculateForChild.calculate(Feature<S> feature,
S input,
ChildCacheName childCacheName)
Calculates a feature in a child-cache.
|
<V extends FeatureInput> |
FeatureCalculationCache.childCacheFor(ChildCacheName childName,
Class<? extends FeatureInput> inputType,
CacheCreator cacheCreator)
Gets/creates a child-cache for a given name.
|
<T extends FeatureInput> |
CacheCreator.create(Class<? extends FeatureInput> inputType)
Creates a
FeatureCalculationCache that accepts a particular input type. |
Modifier and Type | Method and Description |
---|---|
<V extends FeatureInput> |
FeatureCalculationCache.childCacheFor(ChildCacheName childName,
Class<? extends FeatureInput> inputType,
CacheCreator cacheCreator)
Gets/creates a child-cache for a given name.
|
<T extends FeatureInput> |
CacheCreator.create(Class<? extends FeatureInput> inputType)
Creates a
FeatureCalculationCache that accepts a particular input type. |
Modifier and Type | Class and Description |
---|---|
class |
ResolvedPart<S,T extends FeatureInput>
Like a
CalculationPart but has been resolved against a cache to reuse any existing
identical instance. |
class |
ResolvedPartMap<S,T extends FeatureInput,U>
A
CalculationPartMap that has been resolved against a cache. |
Modifier and Type | Class and Description |
---|---|
class |
CalculationPart<S,T extends FeatureInput>
A sub-part of the calculation of a feature, that can be cached, and reused by other features.
|
class |
CalculationPartMap<S,T extends FeatureInput,U,E extends Exception>
Similar to a
CalculationPart but stores several evaluation results, differentiated by a
key. |
interface |
CalculationPartResolver<T extends FeatureInput>
Searches a cache to reuses a
CalculationPart if it already exists. |
Modifier and Type | Method and Description |
---|---|
NamedProviderStore<FeatureList<FeatureInput>> |
FeatureRelatedInitialization.getFeatureLists()
Gets the underlying
NamedProviderStore that provides shared-features. |
Modifier and Type | Method and Description |
---|---|
void |
FeatureRelatedInitialization.populate(List<NamedBean<FeatureListProvider<FeatureInput>>> namedProviders,
Logger logger)
Adds features into the shared-feature storage from a list of named-beans.
|
Modifier and Type | Interface and Description |
---|---|
interface |
FeatureInputDictionary
A
FeatureInputWithResolution that has an optional associated Dictionary . |
interface |
FeatureInputWithResolution
A
FeatureInput that exposes the Resolution of an image or scene. |
Modifier and Type | Class and Description |
---|---|
class |
FeatureInputDimensions
A
FeatureInput that exposes the Dimensions of an image or scene. |
class |
FeatureInputEnergy
A
FeatureInputDimensions that has an optional EnergyStack associated with it. |
class |
FeatureInputNull
A
FeatureInput with no associated parameterization. |
class |
FeatureInputResults
A
FeatureInput with the stored results from a prior feature-calculation. |
Modifier and Type | Method and Description |
---|---|
static <T extends FeatureInput> |
FeatureInputType.determineInputType(List<Feature<T>> list)
Finds a common input-type for classes in the list, throwing an exception if any two types
aren't compatible.
|
Modifier and Type | Method and Description |
---|---|
static Class<? extends FeatureInput> |
FeatureInputType.determineInputType(Class<? extends FeatureInput> inputType1,
Class<? extends FeatureInput> inputType2)
Finds a common input-type for two classes, throwing an exception if the two types aren't
compatible.
|
static <T extends FeatureInput> |
FeatureInputType.determineInputType(List<Feature<T>> list)
Finds a common input-type for classes in the list, throwing an exception if any two types
aren't compatible.
|
static Optional<Class<? extends FeatureInput>> |
FeatureInputType.prefer(Class<? extends FeatureInput> inputType1,
Class<? extends FeatureInput> inputType2)
Prefer to keep descriptor whose input-class is a sub-class rather than a super-class.
|
static Class<? extends FeatureInput> |
FeatureInputType.prefer(Feature<?> feature1,
Feature<?> feature2)
Like
FeatureInputType.prefer(Class, Class) but accepts features directly as input. |
Modifier and Type | Method and Description |
---|---|
static Class<? extends FeatureInput> |
FeatureInputType.determineInputType(Class<? extends FeatureInput> inputType1,
Class<? extends FeatureInput> inputType2)
Finds a common input-type for two classes, throwing an exception if the two types aren't
compatible.
|
static Class<? extends FeatureInput> |
FeatureInputType.determineInputType(Class<? extends FeatureInput> inputType1,
Class<? extends FeatureInput> inputType2)
Finds a common input-type for two classes, throwing an exception if the two types aren't
compatible.
|
static boolean |
FeatureInputType.isCompatibleWith(Class<? extends FeatureInput> sourceType,
Class<? extends FeatureInput> otherType)
Can these parameters be used with a particular feature?
|
static boolean |
FeatureInputType.isCompatibleWith(Class<? extends FeatureInput> sourceType,
Class<? extends FeatureInput> otherType)
Can these parameters be used with a particular feature?
|
static Optional<Class<? extends FeatureInput>> |
FeatureInputType.prefer(Class<? extends FeatureInput> inputType1,
Class<? extends FeatureInput> inputType2)
Prefer to keep descriptor whose input-class is a sub-class rather than a super-class.
|
static Optional<Class<? extends FeatureInput>> |
FeatureInputType.prefer(Class<? extends FeatureInput> inputType1,
Class<? extends FeatureInput> inputType2)
Prefer to keep descriptor whose input-class is a sub-class rather than a super-class.
|
Modifier and Type | Method and Description |
---|---|
static void |
AssignFeatureNameUtilities.assignWithPrefix(Feature<? extends FeatureInput> feature,
String existingName,
String prefix)
Assigns a new custom-name to a feature, by combining an existing-name with a prefix.
|
Modifier and Type | Class and Description |
---|---|
class |
SequentialSession<T extends FeatureInput>
Calculates features with successively different inputs, without caching any results from one
input to the next.
|
class |
SessionInputSequential<T extends FeatureInput>
A feature-input that will be used in a
SequentialSession |
Modifier and Type | Method and Description |
---|---|
static <T extends FeatureInput> |
FeatureSession.calculateWith(Feature<T> feature,
T input,
Logger logger)
Starts a feature-session for a single feature - and performs a calculation.
|
static <T extends FeatureInput> |
FeatureSession.with(Feature<T> feature,
FeatureInitialization initialization,
SharedFeatures sharedFeatures,
Logger logger)
Starts a feature-session for a single feature, with specific initialization.
|
static <T extends FeatureInput> |
FeatureSession.with(Feature<T> feature,
Logger logger)
Starts a feature-session for a single feature.
|
static <T extends FeatureInput> |
FeatureSession.with(Feature<T> feature,
SharedFeatures sharedFeatures,
Logger logger)
Starts a feature-session for a single feature, with default initialization.
|
static <T extends FeatureInput> |
FeatureSession.with(FeatureList<T> features,
FeatureInitialization initialization,
Optional<SharedFeatures> sharedFeatures,
Logger logger,
BoundReplaceStrategy<T,? extends ReplaceStrategy<T>> replaceStrategy)
Starts a feature-session for a list of features, with particular initialization, and a
replaceStrategy . |
static <T extends FeatureInput> |
FeatureSession.with(FeatureList<T> features,
FeatureInitialization initialization,
SharedFeatures sharedFeatures,
Logger logger)
Starts a feature-session for a list of features, with particular initialization.
|
static <T extends FeatureInput> |
FeatureSession.with(FeatureList<T> features,
Logger logger)
Starts a feature-session for a list of features, with default initialization.
|
Modifier and Type | Method and Description |
---|---|
<T extends FeatureInput> |
HorizontalCacheCreator.create(Class<? extends FeatureInput> inputType) |
Modifier and Type | Method and Description |
---|---|
<T extends FeatureInput> |
HorizontalCacheCreator.create(Class<? extends FeatureInput> inputType) |
Constructor and Description |
---|
HorizontalCacheCreator(FeatureList<? extends FeatureInput> namedFeatures,
SharedFeatures sharedFeatures,
FeatureInitialization initialization,
Logger logger) |
Modifier and Type | Interface and Description |
---|---|
interface |
CacheSupplier<T extends FeatureInput,E extends Exception>
Supplies a
LRUCache that maps a feature input-type to a corresponding to FeatureCalculationInput . |
class |
CacheTransferSource<T extends FeatureInput>
An existing cache that can be used as a source for child-caches elsewhere.
|
Modifier and Type | Method and Description |
---|---|
<V extends FeatureInput> |
ChildCacheFinder.childCacheFor(FeatureCalculationCache<?> parentCache,
CacheCreator factory,
ChildCacheName childCacheName,
V input)
Selects a child-cache given a parent and a child-name.
|
<V extends FeatureInput> |
DefaultChildCacheFinder.childCacheFor(FeatureCalculationCache<?> parentCache,
CacheCreator factory,
ChildCacheName childName,
V input) |
<V extends FeatureInput> |
CheckCacheForSpecificChildren.childCacheFor(FeatureCalculationCache<?> parentCache,
CacheCreator factory,
ChildCacheName childName,
V input) |
Modifier and Type | Method and Description |
---|---|
Iterator<CacheTransferSource<? extends FeatureInput>> |
CacheTransferSourceCollection.iterator() |
Modifier and Type | Method and Description |
---|---|
void |
CacheTransferSourceCollection.add(CacheTransferSource<? extends FeatureInput> source)
Adds a source.
|
Modifier and Type | Method and Description |
---|---|
static <T extends FeatureInput> |
FeatureCalculatorCache.cache(FeatureCalculatorMulti<T> calculator)
Creates a cached version of a
FeatureCalculatorMulti with a default cache-size. |
static <T extends FeatureInput> |
FeatureCalculatorCache.cache(FeatureCalculatorMulti<T> calculator,
int cacheSize)
Creates a cached version of a
FeatureCalculatorMulti with a particular cache-size. |
static <T extends FeatureInput> |
FeatureCalculatorCache.cache(FeatureCalculatorSingle<T> calculator)
Creates a cached version of a
FeatureCalculatorSingle with a default cache-size. |
static <T extends FeatureInput> |
FeatureCalculatorCache.cache(FeatureCalculatorSingle<T> calculator,
int cacheSize)
Creates a cached version of a
FeatureCalculatorSingle with a particular cache-size. |
Modifier and Type | Class and Description |
---|---|
class |
AlwaysNew<T extends FeatureInput>
Always create a new
SessionInputSequential with no reuse or caching between calls. |
class |
BoundReplaceStrategy<T extends FeatureInput,S extends ReplaceStrategy<T>>
Attaches a replacement-strategy to a session lazily.
|
class |
CacheAndReuseStrategy<T extends FeatureInput>
Reuse an existing
FeatureCalculationInput , as stored in a least-recently used cache, and
without invalidating it. |
interface |
ReplaceStrategy<T extends FeatureInput>
Different strategies on associating a
FeatureCalculationInput with a particular input . |
class |
ReuseSingletonStrategy<T extends FeatureInput>
Always re-use an existing
SessionInputSequential , invalidating it each time a new call
occurs. |
Modifier and Type | Class and Description |
---|---|
class |
SharedFeaturesSubset<T extends FeatureInput>
A subset of features from
SharedFeatures that share a common feature input-type. |
Modifier and Type | Method and Description |
---|---|
<S extends FeatureInput> |
SharedFeatures.subsetCompatibleWith(Class<? extends FeatureInput> inputType)
Extracts the subset of inputs that are compatible with a particular input-type.
|
Modifier and Type | Method and Description |
---|---|
Optional<Feature<FeatureInput>> |
SharedFeatures.getOptional(String key) |
Iterator<NameValue<Feature<FeatureInput>>> |
SharedFeatures.iterator() |
Modifier and Type | Method and Description |
---|---|
void |
SharedFeatures.addFromList(FeatureList<FeatureInput> list)
Add features from a feature-list.
|
void |
SharedFeatures.addFromProviders(NamedProvider<FeatureList<FeatureInput>> provider)
Add features from a
NamedProvider of feature-lists. |
boolean |
SharedFeatures.contains(Feature<FeatureInput> feature)
Whether a particular feature is contained in this instance.
|
void |
SharedFeatures.removeIfExists(FeatureList<FeatureInput> featuresToRemove)
Remove all features, if they currently exist, from
features . |
<S extends FeatureInput> |
SharedFeatures.subsetCompatibleWith(Class<? extends FeatureInput> inputType)
Extracts the subset of inputs that are compatible with a particular input-type.
|
Modifier and Type | Class and Description |
---|---|
class |
NamedFeatureStore<T extends FeatureInput>
Stores
Feature s, each with an associated name, with list-like access and map-like access. |
Modifier and Type | Method and Description |
---|---|
<T extends FeatureInput> |
NamedFeatureStoreFactory.createNamedFeatureList(List<NamedBean<FeatureListProvider<T>>> namedFeatures)
Create a
NamedFeatureStore from a list of beans. |
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FeatureEnergy.inputType() |
Class<? extends FeatureInput> |
FeatureHistogram.inputType() |
Class<? extends FeatureInput> |
FeatureImageMetadata.inputType() |
Class<? extends FeatureInput> |
FeatureStack.inputType() |
Modifier and Type | Class and Description |
---|---|
class |
FeatureEvaluator<T extends FeatureInput>
Defines a feature and provides a means to calculate inputs for it, a session.
|
class |
FeatureListEvaluator<T extends FeatureInput>
Defines a list of features and provides a means to calculate inputs for it, a session.
|
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FeatureObjectCollection.inputType() |
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FeaturePairObjects.inputType() |
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FeatureSingleObject.inputType() |
Modifier and Type | Interface and Description |
---|---|
interface |
FeatureTableCalculator<T extends FeatureInput>
A feature-calculator with additional functions for encoding the output in in a tabular-format
with column-names.
|
class |
NamedFeatureCalculatorMulti<T extends FeatureInput>
A
FeatureCalculatorMulti with associated feature-names |
Modifier and Type | Class and Description |
---|---|
class |
FeatureInputHistogram |
class |
FeatureInputImageMetadata
A
FeatureInput that provides ImageMetadata . |
class |
FeatureInputObjectCollection |
class |
FeatureInputPairObjects
A pair of objects (first and second) and maybe a merged version of both
|
class |
FeatureInputSingleObject
An input representing a single object-mask (with maybe an energy-stack associated)
|
class |
FeatureInputStack |
Modifier and Type | Interface and Description |
---|---|
interface |
OrderedFeatureList<T extends FeatureInput> |
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FeatureSingleMemo.inputType() |
Class<? extends FeatureInput> |
FeatureAllMemo.inputType() |
Class<? extends FeatureInput> |
AsSingle.inputType() |
Class<? extends FeatureInput> |
FeaturePairMemo.inputType() |
Modifier and Type | Class and Description |
---|---|
class |
FeatureInputMark |
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FeatureMark.inputType() |
Modifier and Type | Class and Description |
---|---|
class |
FeatureInputMarkCollection |
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FeatureMarkCollection.inputType() |
Modifier and Type | Method and Description |
---|---|
<T extends FeatureInput> |
EnergyScheme.getElemByCliqueSize(int cliqueSize) |
Modifier and Type | Class and Description |
---|---|
class |
FeatureInputAllMemo |
class |
FeatureInputPairMemo |
class |
FeatureInputSingleMemo |
Modifier and Type | Class and Description |
---|---|
class |
ReportFeatureEvaluator<T extends FeatureInput> |
class |
ReportFeatureForMarks<T extends FeatureInput> |
class |
ReportFeatureOnObjectsBase<T extends FeatureInput> |
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FromDimensionsBase.inputType() |
Modifier and Type | Class and Description |
---|---|
class |
PermuteFeature<S,T extends FeatureInput>
Permutes one or more properties of a Feature, so as to create a set of Features
|
class |
PermuteFeatureBase<T extends FeatureInput>
Creates permutations of a feature by modifying a particular property of it in different ways.
|
static interface |
PermuteFirstSecondOrder.CreateFirstSecondOrder<T extends FeatureInput> |
Modifier and Type | Class and Description |
---|---|
class |
CombineObjectsForFeatures<T extends FeatureInput>
A way to combine (or not combine) objects so that they provide a feature-table.
|
Modifier and Type | Class and Description |
---|---|
class |
ParamFromCollection<T extends FeatureInput>
Retrieves a parameter as stored in a
Dictionary in SharedObjects . |
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
FeatureSingleObjectFromShared.inputType() |
Modifier and Type | Class and Description |
---|---|
class |
CalculateInputFromDelegate<S,T extends FeatureInput,U>
A base class for
CalculationPart s that derive from an existing "delegate" calculation. |
class |
CalculateInputFromDelegateOption<S extends FeatureInput,T extends FeatureInput,U>
Like
CalculateInputFromDelegate except assumes optional return value and no parameters. |
class |
CalculateInputFromDelegateOption<S extends FeatureInput,T extends FeatureInput,U>
Like
CalculateInputFromDelegate except assumes optional return value and no parameters. |
Modifier and Type | Method and Description |
---|---|
static <S extends FeatureInput,T extends FeatureInput,U> |
CalculateInputFromDelegateOption.calc(FeatureCalculationInput<T> input,
CalculationPart<U,T> delegate,
java.util.function.Function<ResolvedPart<U,T>,CalculateInputFromDelegateOption<S,T,U>> createFromDelegate,
Feature<S> feature,
ChildCacheName cacheName,
double emptyValue)
Calculates a feature using a cached-calculation as delegate.
|
static <S extends FeatureInput,T extends FeatureInput,U> |
CalculateInputFromDelegateOption.calc(FeatureCalculationInput<T> input,
CalculationPart<U,T> delegate,
java.util.function.Function<ResolvedPart<U,T>,CalculateInputFromDelegateOption<S,T,U>> createFromDelegate,
Feature<S> feature,
ChildCacheName cacheName,
double emptyValue)
Calculates a feature using a cached-calculation as delegate.
|
Modifier and Type | Class and Description |
---|---|
class |
ExportFeatures<T extends InputFromManager,S,U extends FeatureInput>
Calculates features and exports them as a CSV file.
|
Modifier and Type | Class and Description |
---|---|
class |
FeatureSource<T extends InputFromManager,S,U extends FeatureInput>
Extracts features from some kind of inputs to produce one or more rows in a feature-table.
|
class |
SingleRowPerInput<T extends InputFromManager,S extends FeatureInput>
Base class for exporting features, where features are calculated per-image using a
NamedFeatureStore . |
Modifier and Type | Method and Description |
---|---|
static <T extends FeatureInput> |
FeatureExporter.create(FeatureOutputNames outputNames,
FeatureTableCalculator<T> features,
LabelHeaders identifierHeaders,
Optional<InputGrouper> grouper,
FeatureExporterContext context)
Alternative static constructor that creates a shared-state from a
NamedFeatureStore . |
static <T extends FeatureInput> |
FeatureExporter.create(List<NamedBean<FeatureListProvider<T>>> features,
LabelHeaders metadataHeaders,
FeatureOutputNames outputNames,
Optional<InputGrouper> grouper,
FeatureExporterContext context)
Alternative static constructor that creates a shared-state from a list of named
FeatureListProvider s. |
static <T extends FeatureInput> |
FeatureExporter.create(NamedFeatureStore<T> featureStore,
LabelHeaders metadataHeaders,
FeatureOutputNames outputNames,
Optional<InputGrouper> grouper,
FeatureExporterContext context)
Alternative static constructor that creates a shared-state from a
NamedFeatureStore . |
Modifier and Type | Class and Description |
---|---|
class |
CalculateFeaturesForObjects<T extends FeatureInput> |
Modifier and Type | Class and Description |
---|---|
class |
FeatureListProviderLDAClassifier<T extends FeatureInput> |
Modifier and Type | Method and Description |
---|---|
FeatureList<FeatureInput> |
FeatureListProviderSVMClassifier.get() |
Modifier and Type | Class and Description |
---|---|
class |
FeatureValueCheckMark<T extends FeatureInput> |
Modifier and Type | Class and Description |
---|---|
class |
FromObjects<T extends FeatureInput>
Extracts features for each object in a collection.
|
Modifier and Type | Method and Description |
---|---|
Class<? extends FeatureInput> |
AsMark.inputType() |
Class<? extends FeatureInput> |
AsObject.inputType() |
Modifier and Type | Class and Description |
---|---|
class |
WithValueBase<T extends FeatureInput>
Operations that use a specified constant value
|
Modifier and Type | Class and Description |
---|---|
class |
AbsoluteValue<T extends FeatureInput> |
class |
AddConstantTo<T extends FeatureInput> |
class |
ConstantToThePowerOf<T extends FeatureInput> |
class |
Divide<T extends FeatureInput> |
class |
DivideByConstant<T extends FeatureInput> |
class |
InvertedMax<T extends FeatureInput>
Finds the repciprocal (multiplicate inverse), but imposes a maximum ceiling via a constant.
|
class |
Multiply<T extends FeatureInput> |
class |
MultiplyByConstant<T extends FeatureInput> |
class |
SubtractFrom<T extends FeatureInput> |
class |
ToThePowerOfConstant<T extends FeatureInput> |
Modifier and Type | Class and Description |
---|---|
class |
IfCondition<T extends FeatureInput>
The result of featureCondition is compared to a threshold, and then either the underlying feature
is calculated (positive case), or featureElse is (negative case)
|
Modifier and Type | Class and Description |
---|---|
class |
Maximum<T extends FeatureInput> |
class |
Mean<T extends FeatureInput>
Arithmetic mean of a list of features
|
class |
MeanGeometric<T extends FeatureInput> |
class |
Minimum<T extends FeatureInput> |
Modifier and Type | Class and Description |
---|---|
class |
CompareWithRange<T extends FeatureInput>
Compares a value with a range, returning specified constants if its inside the range, below it or
above it
|
class |
CompareWithRangeFeature<T extends FeatureInput>
Like
CompareWithRange but uses features to calculate boundary values |
class |
IfConditionWithinRange<T extends FeatureInput>
Calculates a value if a condition lies within a certain range, otherwise returns constants
|
class |
IfOutsideRange<T extends FeatureInput>
Clamps a value if it lies outside the range - instead returning particular constants if below or
above an acceptable range
|
class |
NormalizedRange<T extends FeatureInput>
The range of two feature values (i.e.
|
class |
Range<T extends FeatureInput>
The statistical range between two values i.e.
|
class |
RangeCompareBase<T extends FeatureInput> |
class |
RangeCompareFromScalars<T extends FeatureInput>
A base-class for setting the boundaries of the range using constant scalars
|
Modifier and Type | Class and Description |
---|---|
class |
ReplaceInfinity<T extends FeatureInput> |
class |
ReplaceNaN<T extends FeatureInput> |
class |
ReplaceUnusualValue<T extends FeatureInput>
Calculates the underlying feature, but replaces the result with a constant if it happens to be an
"unusual" value
|
Modifier and Type | Class and Description |
---|---|
class |
GaussianCumulative<T extends FeatureInput> |
class |
StatisticalBase<T extends FeatureInput>
Calculates a score based upon the statistical mean and std-deviation.
|
class |
ZScore<T extends FeatureInput> |
Modifier and Type | Class and Description |
---|---|
class |
ConvertUnits<T extends FeatureInput> |
Modifier and Type | Method and Description |
---|---|
static <T extends FeatureInput> |
ConstantsInListFixture.create()
Creates a feature-list associated with the fixture.
|
Modifier and Type | Method and Description |
---|---|
static <T extends FeatureInput> |
FeatureTestCalculator.assertDoubleResult(String message,
Feature<T> feature,
T input,
double expectedResult) |
static <T extends FeatureInput> |
FeatureTestCalculator.assertDoubleResult(String message,
Feature<T> feature,
T input,
Optional<SharedObjects> sharedObjects,
double expectedResult) |
static <T extends FeatureInput> |
FeatureTestCalculatorDuo.assertDoubleResult(String message,
Feature<T> feature,
T inputPositive,
T inputNegative,
double expectedResultPositive,
double expectedResultNegative) |
static <T extends FeatureInput> |
FeatureTestCalculator.assertIntResult(String message,
Feature<T> feature,
T input,
int expectedResult) |
static <T extends FeatureInput> |
FeatureTestCalculator.assertIntResult(String message,
Feature<T> feature,
T input,
Optional<SharedObjects> sharedObjects,
int expectedResult) |
static <T extends FeatureInput> |
FeatureTestCalculatorDuo.assertIntResult(String message,
Feature<T> feature,
T inputPositive,
T inputNegative,
int expectedResultPositive,
int expectedResultNegative) |
static <T extends FeatureInput> |
FeaturesFromXmlFixture.createFeatureList(String xmlPath,
TestLoader loader) |
static <T extends FeatureInput> |
FeaturesFromXmlFixture.createNamedFeatureProviders(String xmlPath,
TestLoader loader) |
Modifier and Type | Method and Description |
---|---|
static <T extends FeatureInput> |
MockFeatureWithCalculationFixture.createMockFeatureWithCalculation(java.util.function.ToDoubleFunction<T> funcCalculation)
Creates a mock-feature (using a mock-FeatureCalculation under the hood) with a result
calculated using a lambda
|
Modifier and Type | Method and Description |
---|---|
protected double |
MockFeatureWithCalculation.calculate(FeatureCalculationInput<FeatureInput> input) |
Copyright © 2010–2023 Owen Feehan, ETH Zurich, University of Zurich, Hoffmann-La Roche. All rights reserved.