public class TiledConvolution extends java.lang.Object implements Convolution
This object is built on the base of some parent object,
Convolution, and some tiler (an instance of
This object works almost identically to the parent object with the only difference,
that it uses the specified tiler for performing all operations.
More precisely, each method of this object creates an implementation p of
interface. The only thing, performed by
process method of
that object p, is calling the same method of parent object with the arguments
(the source matrix is retrieved from src, the result is saved into dest).
The dependence aperture p.
is calculated automatically on the base of the patterns and the performed operation.
Then, the method of this object executes the required operation with help of
asConvolution(Matrix, WeightedPattern) is an exception
from this rule. These methods of this class works in the same way, as in
ContinuedConvolution class, the continuation mode of which is equal to
Note: in improbable cases, when the dimensions of the source matrix and/or
the sizes of the pattern are extremely large (about 263),
so that the necessary appended matrices should have dimensions or total number of elements,
TiledApertureProcessorFactory class, "Restriction" section for precise details.
Of course, these are very improbable cases.
This class is immutable and thread-safe: there are no ways to modify settings of the created instance.
|Modifier and Type||Method and Description|
Returns an immutable view of the passed source matrix, such that any reading data from it calculates and returns the convolution of the source matrix by the specified pattern.
Returns the current context used by this instance for all operations.
Switches the context: returns an instance, identical to this one excepting that it uses the specified newContext for all operations.
Returns a new updatable matrix, containing the convolution of the source matrix by the specified pattern.
Returns new instance of this class with the passed parent
Returns true, if this class works in the default
Returns the parent
Returns the processing tiler that will be used for tiled processing the source matrices.
public static TiledConvolution getInstance(Convolution parent, TiledApertureProcessorFactory tiler)
Convolutionobject and the specified processing tiler.
context of the created object is retrieved from
context of the passed tiler
is automatically replaced with the same one — the current
of the created object is
context of the passed tiler is not important
and can be null.
parent- parent object: the instance of
Convolutioninterface that will perform all operations.
tiler- the tiler, which will be used for processing matrices by this class.
java.lang.NullPointerException- if parent or tiler argument is null.
public Convolution parent()
Convolutionobject, passed to
public TiledApertureProcessorFactory tiler()
public ArrayContext context()
public Convolution context(ArrayContext newContext)
subtaskof the full task.
public boolean isPseudoCyclic()
pseudo-cyclic continuation mode. More precisely, returns true if and only if
public double increment(java.lang.Class<?> elementType)
public Matrix<? extends PArray> asConvolution(Matrix<? extends PArray> src, WeightedPattern pattern)
type(PArray.class), src, pattern). In other words, the element type of the returned matrix is chosen the same as in src matrix.
public <T extends PArray> Matrix<T> asConvolution(java.lang.Class<? extends T> requiredType, Matrix<? extends PArray> src, WeightedPattern pattern)
Convolution.convolution(Class, Matrix, WeightedPattern)method about the "convolution" term.
The matrix, returned by this method, is immutable, and the class of its built-in array
implements one of the basic interfaces
The class of desired interface (one of 8 possible classes) must be passed as requiredType argument.
So, it defines the element type of the returned matrix.
For example, if requiredType=
ByteArray.class, the returned matrix consists of byte
elements. The rules of casting the real numbers, results of the convolution, to the desired element type
are the same as in
Arrays.asFuncArray(boolean, net.algart.math.functions.Func, Class, PArray...)
method with the argument truncateOverflows=true.
The result is usually "lazy", that means that this method finishes immediately and all
actual calculations are performed while getting elements of the returned matrix.
It is true for all implementations provided by this package.
However, some implementations may not support lazy dilation;
then this method will be equivalent to
Convolution.convolution(Class, Matrix, WeightedPattern).
Please note: this method does not require time, but the resulting matrix can work slowly!
for example, reading all its content than work much slower than
Convolution.convolution(Class, Matrix, WeightedPattern) method for some complex patterns.
Usually you should use it only for very little patterns, or if you know that the implementation
of this interface does not provide better algorithm for non-"lazy"
Convolution.convolution(Class, , Matrix, WeightedPattern) method.
public Matrix<? extends UpdatablePArray> convolution(Matrix<? extends PArray> src, WeightedPattern pattern)
Usually convolution means the weighted sum of the set of matrices,
obtained by pseudo-cyclic shifting the source matrix by the vectors,
equal to all pattern points, with weights, equal to
of the pattern points.
More precisely, let mi=
where ip is the point #i from all points contained in the pattern,
and let wi=pattern.
Then the every element of the returned matrix is the weighted sum of all corresponding elements
of all mi matrices:
element typeof the created matrix is the same as the element type of the source one. The byte and short elements are considered to be unsigned. If the element type if integer, the precise is rounded to the nearest integer.
BasicConvolution class strictly complies this definition.
However, other implementations of this interface may use alternate definitions of the convolution term.
For example, elements outside the matrix may be supposed to be filled according some non-trivial rules
instead of pseudo-cyclic continuation
or only some region of the matrix may be processed, etc.
src- the source matrix.
pattern- the pattern.
Convolution.asConvolution(Class, Matrix, WeightedPattern)
public <T extends PArray> Matrix<? extends T> convolution(java.lang.Class<? extends T> requiredType, Matrix<? extends PArray> src, WeightedPattern pattern)