All Classes and Interfaces
Class
Description
Implementation of basic functions of
MutableArray interface.A skeletal implementation of the
ArrayContext interface to minimize
the effort required to implement this interface.A skeletal implementation of the
ArrayProcessorWithContextSwitching interface.Implementation of almost all basic functions of
BitArray interface.Implementation of almost all basic functions of
ByteArray interface.Implementation of almost all basic functions of
CharArray interface.A skeletal implementation of the
Context interface to minimize
the effort required to implement this interface.A skeletal implementation of the
CoordinateTransformationOperator interface to minimize
the effort required to implement this interface.A skeletal implementation of the
DataFileModel interface to minimize
the effort required to implement this interface for processing usual disk files.Implementation of almost all basic functions of
DoubleArray interface.Implementation of almost all basic functions of
FloatArray interface.A skeletal implementation of the
Func interface to minimize
the effort required to implement this interface.Implementation of almost all basic functions of
IntArray interface.A skeletal implementation of the
IterativeArrayProcessor interface.Implementation of almost all basic functions of
LongArray interface.A skeletal implementation of the
Matrix interface to minimize
the effort required to implement this interface.A skeletal implementation of the
MemoryModel interface to minimize
the effort required to implement this interface.A skeletal implementation of the
Morphology interface to minimize
the effort required to implement this interface.Implementation of almost all basic functions of
ObjectArray interface.A skeletal implementation of the
Pattern interface to minimize
the effort required to implement this interface.A skeletal implementation of the
RankMorphology interface to minimize
the effort required to implement this interface.Implementation of almost all basic functions of
ShortArray interface.A skeletal implementation of the
SpectralTransform interface to minimize
the effort required to implement this interface.A skeletal implementation of the
ThreadPoolFactory interface.A skeletal implementation of the
UniformGridPattern interface to minimize
the effort required to implement this interface.Implementation of almost all basic functions of
UpdatableBitArray interface.Implementation of almost all basic functions of
UpdatableByteArray interface.Implementation of almost all basic functions of
UpdatableCharArray interface.Implementation of almost all basic functions of
UpdatableDoubleArray interface.Implementation of almost all basic functions of
UpdatableFloatArray interface.Implementation of almost all basic functions of
UpdatableIntArray interface.Implementation of almost all basic functions of
UpdatableLongArray interface.Implementation of almost all basic functions of
UpdatableObjectArray interface.Implementation of almost all basic functions of
UpdatableShortArray interface.A skeletal implementation of the
WeightedPattern interface to minimize
the effort required to implement this interface.A skeletal implementation of the
SkeletonPixelClassifier abstract class,
minimizing the effort required to implement its abstract methods.A function, transformed by
ApertureFilterOperator
in n-dimensional Euclidean space.Aperture filtering operator in n-dimensional Euclidean space:
g(x) = O f(x) =
apertureFunc(f(x+a0), f(x+a1), ...,
f(x+am-1)) ,
where x is a point of the n-dimensional space,
apertureFunc is some function with m arguments (the aperture function),
{ai} is a set of points with (usually) little coordinates (the aperture),
f is the source mathematical function
and g is the result of applying the operator to f.
Abstract aperture matrix processor: an algorithm, processing a group of
n-dimensional matrices and returning a group of resulting matrices,
where the value of every element of every resulting matrix depends only on
the elements of the source matrices in some aperture "around" the same position.AlgART array of any elements, read-only access.
Comparison interface, designed for comparing elements in some data array.
Version of
ArrayComparator for a case of 32-bit indexes (int instead of long).The context of processing AlgART arrays.
The array processing event: an argument of
ArrayContext.updateProgress(Event) method.Exchanging interface, designed for exchanging (swapping) two elements in some data array.
Version of
ArrayExchanger for a case of 32-bit indexes (int instead of long).The context informing the module, working with
AlgART arrays,
about the preferred memory model.A simple pool of the
unresizable AlgART arrays
(usually work buffers) with the same size and type of elements,
based on a list of SoftReference or WeakReference.Abstract array processor: an algorithm processing AlgART arrays or matrices.
Array processor allowing to switch the current context.
A set of static methods useful for working with
AlgART arrays.The information about the copying, returned by
Arrays.compareAndCopy(ArrayContext, UpdatableArray, Array) and
Matrices.compareAndCopy(ArrayContext, Matrix, Matrix) methods.Implementation of
Arrays.ParallelExecutor performing
simple copying of the source array.The information about the internal algorithm, which was used by copying methods of this package:
Arrays.copy(ArrayContext, UpdatableArray, Array),
Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean),
Arrays.compareAndCopy(ArrayContext, UpdatableArray, Array),
Matrices.copy(ArrayContext, Matrix, Matrix), etc.The information about the copying, returned by copying methods of this package:
Arrays.copy(ArrayContext, UpdatableArray, Array),
Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean),
Matrices.copy(ArrayContext, Matrix, Matrix), etc.The helper class for
Arrays.rangeOf(PArray, MinMaxInfo) method, containing information
about the minimum and maximum in some AlgART array.The class simplifying the parallel processing a large AlgART array in several threads,
where each thread process a set of ranges of the source array (
Array.subArray).A set of static methods for getting some important global settings,
stored in system properties and used for customizing modules processing
AlgART arrays.Global synchronizer, used for all disk operations, performed by this package.
Describes when to execute the task passed to
Arrays.addShutdownTask(Runnable, TaskExecutionOrder) method.Selecting algorithms.
Sorting algorithms.
The context informing the module, working with
AlgART arrays,
about the preferred thread pool factory.The simplest complete implementation of
Morphology interface.Almost complete implementation of
RankMorphology interface with an instantiation method
of some complete implementation.Ready classifier of pixel of 2-dimensional
thinning skeletons.AlgART array of boolean values, read-only access.
Stack of boolean values.
A simple class allowing to reuse Java boolean[] array many times.
2-dimensional object boundaries scanner: the class allowing to trace boundaries of objects,
"drawn" at some 2-dimensional bit matrix.
The pixel side.
The step of scanning the boundary: moving from one boundary segment to the next boundary segment.
Wrapper of a boundary scanner, that measures some simple parameters of every scanned boundary.
The class describing what parameters of the connected object boundary should be measured by
Boundary2DSimpleMeasurer class.Abstract wrapper of a boundary scanner:
special variant of
Boundary2DScanner class, that redirects all methods to some
parent scanner and, maybe, performs some additional actions.The memory model, based on ByteBuffer and other buffers from
package.
AlgART array of byte values, read-only access.
Special version of
ArraySelector class, optimized for selecting from byte[] arrays.A simple class allowing to reuse Java byte[] array many times.
Stack of byte values.
AlgART array of char values, read-only access.
A simple class allowing to reuse Java char[] array many times.
Stack of char values.
Functions for checking collinearity of vectors.
Thrown when two collinear (or almost collinear) vectors or segments are detected,
but it is not permitted for the given situation.
Utilities useful for working with lists of
AlgART matrices,
representing channels in a color image.The memory model allowing to create combined arrays:
special kind of AlgART arrays, that store an array of Java objects with minimal amount of memory,
namely in one or several another "parallel" arrays.
A skeleton class allowing to simplify implementation of
CombinedMemoryModel.Combiner interface.A version of
CombinedMemoryModel.AbstractByteBufferCombiner skeleton class
implementing CombinedMemoryModel.CombinerInPlace interface.Special version of
CombinedMemoryModel.Combiner interface allowing
to optimize block access to the combined array.This interface should be implemented to allow saving objects
in arrays created via
combined memory model.Special version of
CombinedMemoryModel.Combiner interface allowing
to load an element without creating new Java object.Array of samples, where each sample is a complex number, represented by a pair of double values,
stored in two AlgART arrays
UpdatablePNumberArray.Array of samples, where each sample is a vector of complex numbers with some fixed length,
represented by an array of pairs of double values,
stored in two AlgART arrays
UpdatablePNumberArray.Connected objects scanner: the class performing scanning and clearing connected objects,
"drawn" on some n-dimensional updatable bit matrix.
Visitor of matrix elements.
The simplest implementation of
ConnectedObjectScanner.ElementVisitor interface.Connectivity kind of connected objects in the matrix.
Trivial constant function:
f(x0, x1, ..., xn-1) = c,
where c is a constant.
Execution context for any modules.
The filter allowing to transform any
Convolution object to another instance of that interface,
which uses some non-trivial form of continuation outside the source matrix.The filter allowing to transform any
Morphology object to another instance of that interface,
which uses some non-trivial form of continuation outside the source matrix.The filter allowing to transform any
RankMorphology object to another instance of that interface,
which uses some non-trivial form of continuation outside the source matrix.The filter allowing to transform any
streaming aperture procesor
to another instance of that class, which uses some non-trivial form of continuation outside the source matrix.Joiner of
contours.Contour line style for 2-dimensional object boundaries, traced by
Boundary2DScanner.Array of 2D contours.
Contrasting function: by default,
f(x0, x1, x2, x3) =
M * (x0/x1) * (x−x2) /
max(x3−x2,threshold),
where x = (x1<x2 ?
x2 : x1>x3 ? x3 : x1)
is x1, truncated to x2..x3 range,
M and threshold are constants.
Coordinate transformation operator in n-dimensional Euclidean space:
g(x) = O f(x) = f(map(x)) ,
where x is a point of the n-dimensional space,
map is some mapping of this space, f is the source mathematical function
and g is the result of applying the operator to f.
A function, the arguments of which are transformed by some
coordinate transformation operator
in n-dimensional Euclidean space.The context informing the module, working with
AlgART arrays,
about some current folder (usually a disk directory).Complete description of precision characteristics of rank operations, described in
RankMorphology
interface.Data buffer for bit elements.
Data buffer: an interface allowing to read and write blocks
from / to some linear data storage, containing a sequence of elements
of any Java type, with maximal performance.
Access mode, describing access to
data buffers.Unchecked exception thrown by
DataBuffer methods from(),
to() and cnt(), if the values, they should be returned
by these methods, are greater than Integer.MAX_VALUE.Data buffer for byte elements.
Data buffer for char elements.
Data buffer for double elements.
Some "data file" (usually disk file) that supports file-mapping operation.
An object allowing to access mapped data, returned by the
DataFile.map(net.algart.arrays.DataFile.Range, boolean) method.Possible results of
DataFile.open(boolean) method.Pair of 2 long values position
and length, describing the range position..position+length-1
of linear addresses in some
data file.Data file model: the factory allowing to create and remove some file-like objects
("
data files").Data buffer for float elements.
Data buffer for int elements.
Data buffer for long elements.
Data buffer for Object elements.
Data buffer for short elements.
A simple implementation of
ArrayContext interface,
based on the memory,
thread pool,
interruption and
progress contexts defined in this package.An adapter class containing the simplest ("empty") implementations of the following standard contexts:
InterruptionContext, ArrayMemoryContext, ArrayThreadPoolContext,
ProgressUpdater, StatusUpdater.Default implementation of
DataFileModel that creates usual Java files,
which are mapped via standard Java technique (FileChannel.map method).A simple implementation of
ThreadPoolFactory interface.Unchecked exception thrown if the n-dimensional simplex
Matrices.Simplex
cannot be constructed because all vertices lies on the same hyperplane.Helper class for calculation of the rectangular dependence aperture of some matrix processing algorithms.
Direct accessible array: an object that can be viewed as a Java array or a part of Java array.
Interface, used by
Pattern implementations to indicate that
they are simultaneously DirectPointSetPattern and UniformGridPattern.Quotient of two numbers:
f(x0, x1) =
scale*x0/x1 ,
where scale is a constant, passed to
DividingFunc.getInstance(double) method.AlgART array of double values, read-only access.
A simple class allowing to reuse Java double[] array many times.
Stack of double values.
The simplest algorithm of multidimensional skeletonization of binary matrices, based on sequential
erosions of the matrix by some small pattern.Exponent function:
f(x0) =
bx0
(b is the base of the exponent).
Fast Fourier transform (FFT).
Finalizer: an universal tool allowing to perform any task on deallocation of some object.
AlgART array of float values, read-only access.
A simple class allowing to reuse Java float[] array many times.
Stack of float values.
Frame: a pair of the
AlgART matrix and its position;
in other words, an n-dimensional matrix, placed by some way in n-dimensional space.Abstract mathematical function
f(x0, x1, ..., xn-1),
or f(x), where x is a point of the n-dimensional space.
"Updatable" mathematical function: an extension of
Func interface
allowing assigning values to the function result, that leads to
corresponding correction of arguments.Rounding mode, in which
GeneralizedBitProcessing class works: see comments to that class.Algorithm of processing bit arrays, that should be generalized for another element types via
GeneralizedBitProcessing class.Histogram: an array of non-negative integer numbers b[v], 0≤v<M,
where every element b[v] represents the number of occurrence of the value v
in some source array A, consisting of integer elements in 0..M−1 range.
Checked exception thrown if the format of byte[] or String
serialized form of the
MatrixInfo is invalid.AlgART array of int values, read-only access.
Service class that quickly returns all integer points of Bresenham circles
with integer radii.
The class allowing to execute some action, interruptable via standard Java technique,
in terms of some
InterruptionContext.The context allowing the user to interrupt any algorithm.
The interruption event: an argument of
InterruptionContext.Listener.interruptionRequested(InterruptionContext.Event) method.Unchecked analog of the standard InterruptedException.
A simple class allowing to reuse Java int[] array many times.
Stack of int values.
Inverse function:
f(x0, x1, ..., xn-1) =
c/x0
(c is some constant).
Updatable extension of the inverse function.Point in multidimensional space with integer coordinates.
Set-theoretic union of several 2-dimensional
rectangles
with integer coordinates of vertices and sides, parallel to coordinate axes.Rectangular integer area, i.e.
hyperparallelepiped in multidimensional space with integer coordinates of vertices.
An iterative algorithm processing some AlgART array (arrays) or matrix (matrices).
Iterative erosion of the matrix.
Iterative opening of the matrix.
A simple pool of the Java arrays (usually work buffers) with the same size and type of elements,
based on a list of SoftReference.
Some operations for Java array manipulation, in addition to java.util.Arrays.
Implementation of
ArrayExchanger, that simultaneously exchanges two pairs elements at the same
positions in two arrays: some byte[] array and some int[] array.Simple implementation of
ArrayComparator, comparing elements of byte[] array.Simple implementation of
ArrayExchanger, exchanging elements of byte[] array.Implementation of
ArrayExchanger, that simultaneously exchanges two pairs elements at the same
positions in two arrays: some char[] array and some int[] array.Simple implementation of
ArrayComparator, comparing elements of char[] array.Simple implementation of
ArrayExchanger, exchanging elements of char[] array.Implementation of
ArrayExchanger, that simultaneously exchanges two pairs elements at the same
positions in two arrays: some double[] array and some int[] array.Simple implementation of
ArrayComparator, comparing elements of double[] array.Simple implementation of
ArrayExchanger, exchanging elements of double[] array.Implementation of
ArrayExchanger, that simultaneously exchanges two pairs elements at the same
positions in two arrays: some float[] array and some int[] array.Simple implementation of
ArrayComparator, comparing elements of float[] array.Simple implementation of
ArrayExchanger, exchanging elements of float[] array.Implementation of
ArrayExchanger, that simultaneously exchanges two pairs elements at the same
positions in two arrays: some int[] array and some int[] array.Simple implementation of
ArrayComparator, comparing elements of int[] array.Simple implementation of
ArrayExchanger, exchanging elements of int[] array.Implementation of
ArrayExchanger, that simultaneously exchanges two pairs elements at the same
positions in two arrays: some long[] array and some int[] array.Simple implementation of
ArrayComparator, comparing elements of long[] array.Simple implementation of
ArrayExchanger, exchanging elements of long[] array.Implementation of
ArrayExchanger, that simultaneously exchanges two pairs elements at the same
positions in two arrays: some short[] array and some int[] array.Simple implementation of
ArrayComparator, comparing elements of short[] array.Simple implementation of
ArrayExchanger, exchanging elements of short[] array.Some operations for Java NIO buffers manipulation in the same manner as array operations from
JArrays and java.util.Arrays classes.The memory model, storing array elements in an external file.
Linear function:
f(x0, x1, ..., xn-1) =
b + a0x0 + a1x1
+...+ an-1xn-1.
Updatable extension of the linear function
with one argument.Linear operator (affine transformation):
O f(x) = f(Ax + b) ,
where the numeric n x n matrix A
and the n-dimensional vector b are parameters of the transformation.
Logarithm function:
f(x0) =
logb(x0)
(b is the base of the logarithm).
AlgART array of long values, read-only access.
A simple class allowing to reuse Java long[] array many times.
Stack of long values.
Utilities useful for working with
AlgART matrices.Convex hyperpolyhedron: an intersection of several n-dimensional
half-spaces and some
hyperparallelepiped.Hyperparallelepiped: the simplest n-dimensional region.
Interpolation method for representing AlgART matrix as a mathematical
function.Region in n-dimensional space.
Resizing mode for
Matrices.asResized method.Resizing method with averaging (while compression).
Simplex: the simplest n-dimensional hyperpolyhedron with n+1 vertices.
AlgART matrix: multidimensional array.
Continuation mode for submatrices, created by
Matrix.subMatrix(long[], long[], ContinuationMode continuationMode),
Matrix.subMatr(long[], long[], ContinuationMode continuationMode) and similar methods.Full structural information about the
AlgART matrix, consisting of elements
of some primitive types, in a form convenient for serialization.Maximum from 2 arguments, selected by 1st argument:
f(x0, x1, ..., xn-1) =
max(xi+1, xj+1),
i=(int)x[0] (x0 cast to integer type),
j=(i−1+indexShift)%(n−1)+1 ,
where indexShift is an integer constant, passed to
MaxFromTwoSelectedNumbersFunc.getInstance(int) method.Virtual memory model: implementations of this abstract factory is
the main way of creating new AlgART arrays.
Minimum from 2 arguments, selected by 1st argument:
f(x0, x1, ..., xn-1) =
min(xi+1, xj+1),
i=(int)x[0] (x0 cast to integer type),
j=(i−1+indexShift)%(n−1)+1 ,
where indexShift is an integer constant, passed to
MinFromTwoSelectedNumbersFunc.getInstance(int) method.Mathematical morphology over
n-dimensional matrices with a random
n-dimensional structuring element (shape), represented by Pattern class.Subtraction mode for some methods of
Morphology interface.Product from several numbers:
f(x0, x1, ..., xn-1) =
scale*x0x1...xn-1,
where scale is a constant, passed to
MultiplyingFunc.getInstance(double) method.AlgART one-dimensional array of any elements, full access (reading, writing, resizing).
Resizable AlgART array of boolean values.
Resizable AlgART array of byte values.
Resizable AlgART array of char values.
Resizable AlgART array of double values.
Resizable AlgART array of float values.
Integer signed value with 128-bit precision: −2128<x<2128.
Resizable AlgART array of int values.
Resizable AlgART array of long values.
Resizable AlgART array of some objects (non-primitive values) with the specified generic type E,
read-write and resize access.
Special version of
MutableObjectArray allowing
to load an element without creating new Java object.Resizable AlgART array of primitive elements (boolean, char, byte, short, int, long, float or double).
Resizable AlgART array of any fixed-point numeric, character or bit primitive elements
(byte, short, int, long, char or boolean).
Resizable AlgART array of any floating-point primitive elements (float or double).
Resizable AlgART array of any fixed-point numeric primitive elements (byte, short, int or long).
Resizable AlgART array of any numeric primitive elements (byte, short, int, long, float or double).
Resizable AlgART array of short values.
Unchecked exception thrown by
DirectAccessible.javaArray() method,
if the object cannot be viewed as a Java array.Unchecked exception thrown by
Matrix.ContinuationMode.continuationConstant() method,
if the continuation mode is not a constant continuation.AlgART array of some objects (non-primitive values) with the specified generic type E,
read-only access.
Special version of
ObjectArray allowing
to load an element without creating new Java object.Stack of some objects (non-primitive values).
Algorithm of 2-dimensional skeletonization of binary matrices based on 8 thinning steps,
corresponding to 8 directions with the step 45 degree, based on analysis of 3x3 aperture.
Abstract operator: a transformation from one
mathematical function to another.Right orthonormal basis in 3D Euclidean space: 3 orthogonal unit vectors i, j, k.
Operations with bit arrays packed into long[] Java arrays.
Operations with bit arrays packed into byte[] Java arrays.
Operations with bit arrays packed into java.nio.LongBuffer.
AlgART array of primitive elements (boolean, char, byte, short, int, long, float or double),
read-only access.
Pattern: non-empty set of
real points in multidimensional space
(points with real coordinates).A set of static methods operating with and returning
patterns.AlgART array of any fixed-point primitive numeric, character or bit elements
(byte, short, int, long, char or boolean), read-only access.
AlgART array of any floating-point primitive elements (float or double), read-only access.
AlgART array of any fixed-point primitive numeric elements (byte, short, int or long),
read-only access.
AlgART array of any primitive numeric elements (byte, short, int, long, float or double),
read-only access.
Point in multidimensional space with real coordinates.
Power function:
f(x0, x1) =
scale*x0x1 or
f(x0) =
scale*x0c,
where c and scale are constants.
Updatable extension of the power function
with one argument.The context allowing to inform the user about the percents of some long-working method.
Projective operator (projective transformation):
O f(x) = f(y) ,
yi =
(aix + bi) / (cx + d)
(ai means the line i of the matrix A),
where the numeric n x n matrix A,
the n-dimensional vectors b and c and the number d
are parameters of the transformation.
Algorithm of 2-dimensional skeletonization of binary matrices based on 4 thinning steps,
corresponding to 4 directions with the step 90 degree, based on analysis of 3x5 aperture.
Interface, used by
Pattern implementations to indicate that
they support quick access to the number of points in pattern.Rank operations over
n-dimensional matrices:
percentile, rank, mean between given percentiles or values, etc.,
calculated on all matrix elements in an aperture with the fixed shape, represented by Pattern class.Some predefined precision characteristics of rank operations, described in
RankMorphology
interface.A set of
streaming aperture processors,
implementing all operations, specified in RankMorphology interface.Array of samples, where each sample is a real number, represented by a double value,
stored in an AlgART array
UpdatablePNumberArray.Array of samples, where each sample is a vector of real numbers with some fixed length,
represented by an array of double values,
stored in an AlgART arras
UpdatablePNumberArray.The context allowing to inform the application that some rectangular region
of some 2D matrix or image has been updated.
Rectangular real area, i.e.
hyperparallelepiped in multidimensional space with real coordinates of vertices.
Absolute value function:
f(x0) = in
if min<=x0<=max and
f(x0) = out
in other case, where min, max, in, out are parameters of this function.
Interface, used by
Pattern implementations to indicate that
they are rectangular patterns, i.e.
consist of all points of some uniform grid inside some hyperparallelepiped.Array of samples for transforming by some spectral algorithm like FFT.
Selecting constant function:
f(x0, x1, ..., xn-1)
= values[(int)x0],
where values is the given array of constants.
Fast Hartley transform (FHT)
(in multidimensional case — the separable fast Hartley transform).
AlgART array of short values, read-only access.
A simple class allowing to reuse Java short[] array many times.
Stack of short values.
The degenerate memory model that does not allow to create any AlgART arrays.
The simplest memory model, based on usual Java arrays.
The simplest implementation of the
Pattern interface, based on a set (java.util.Set
or some equivalent form), containing all pattern points.Unchecked exception thrown by some methods, processing several AlgART arrays or matrices,
when the passed arrays / matrices have different lengths / dimensions.
Classifier of pixels of skeletons (bit matrices, generated by skeletonization algorithms),
separating them into "nodes", "branch pixels" and other groups.
Style of interpretation of non-negative results while detecting pixel types of the skeleton.
Scanner of skeletons (bit matrices, generated by skeletonization algorithms), allowing
to scan a skeleton, find and traverse all its structural elements like nodes and branches.
Spectral transform: Fourier, Hartley, Hadamar, etc.
Resizable stack of any elements.
Alternative implementation of
DataFileModel, that creates usual Java files,
but emulates mapping via standard read/write operations.The context allowing to inform the user about execution of a long-working method
via some status line or its analog.
Abstract mathematical function, depending on coordinates in n-dimensional space
and several values.
Directional infinite straight line in 3D space.
Streaming aperture matrix processor: an algorithm, processing one or
several
n-dimensional matrices and returning one resulting matrix,
where the value of every element of the resulting matrix depends on (and only on)
the source elements in an aperture with the fixed shape "around" the same position.Stronger version of
Quadruple3x5ThinningSkeleton2D skeletonization algorithm.A tool allowing to build a new context, called "sub-context",
that inherits behavior of an existing context with some changes or extensions.
A wrapper around the parent context, allowing to describe a subtask of some long-working task.
Summing histogram: an extension of r1≤k≤r2 , or with values, lying in some range
v1≤A[k]≤v2 .
Histogram class, allowing quick calculation of sums
of all elements of the sorted source array A[k] with indexes, lying in some range
The helper class for static methods of v(r) function between
two given values: minValue≤v≤maxValue .
SummingHistogram class,
calculating the integrals of Common 2-dimensional skeletonization algorithm of binary matrices, based on ≤8 thinning steps,
corresponding to all or some from 8 directions with the step 45 degree.
The factory allowing to get a thread pool (ExecutorService)
for processing some AlgART array.
Tiler: generator of tiled
aperture matrix processors.Additional information about the current processed tile, available for tiled aperture processors
via their context.
The filter allowing to transform any
Convolution object to another instance of that interface,
which uses some given tiler for processing the source matrix
(an argument of Convolution methods).The filter allowing to transform any
Morphology object to another instance of that interface,
which uses some given tiler for processing the source matrix
(an argument of Morphology methods).The filter allowing to transform any
RankMorphology object to another instance of that interface,
which uses some given tiler for processing the source matrices
(arguments of RankMorphology methods).Unchecked exception thrown if the current or desired array length is extremely large.
Error thrown if a
pattern is extremely large to be correctly processed.Unchecked error thrown if the elements of
trusted immutable
AlgART arrays have been changed.Interface, used by
Pattern implementations to indicate that
they are uniform-grid patterns, i.e.
subsets of the set of all mesh nodes of some uniform grids.Unchecked exception thrown by
Context.as(Class) method
when it cannot serve the request.Unchecked exception thrown by methods, creating new AlgART arrays
(as
MemoryModel.newEmptyArray(Class)), if the specified element type
is not supported by the memory model.AlgART one-dimensional array of any elements, read/write access, no resizing.
AlgART array of boolean values, read/write access, no resizing.
AlgART array of byte values, read/write access, no resizing.
AlgART array of char values, read/write access, no resizing.
AlgART array of double values, read/write access, no resizing.
AlgART array of float values, read/write access, no resizing.
AlgART array of int values, read/write access, no resizing.
AlgART array of long values, read/write access, no resizing.
AlgART array of some objects (non-primitive values) with the specified generic type E,
read/write access, no resizing.
Special version of
UpdatableObjectArray allowing
to load an element without creating new Java object.AlgART array of primitive elements (boolean, char, byte, short, int, long, float or double),
read/write access, no resizing.
AlgART array of any fixed-point primitive numeric, character or bit elements
(byte, short, int, long, char or boolean),
read/write access, no resizing.
AlgART array of any floating-point primitive elements (float or double), read/write access, no resizing.
AlgART array of any fixed-point primitive numeric elements (byte, short, int or long),
read/write access, no resizing.
AlgART array of any primitive numeric elements (byte, short, int, long, float or double),
read-only access.
AlgART array of short values, read/write access, no resizing.
Annotation indicating that a Java method, parameter, constructor or field
is likely to be used for external communication, for example, they are accessed from some native code via JNI.
Weaker version of
OctupleThinningSkeleton2D skeletonization algorithm.Weighted mean of 2 numbers:
f(x0, x1, x2) =
scale*x0x1 + (1-scale*x0)x2,
where scale is a constant, passed to
WeightedMeanFunc.getInstance(double) method.A set of static methods operating with and returning
weighted patterns.