@Override
public void set(int[] indexes, double value) {
int d = indexes.length;
if (d == 0) {
set(value);
}
T slice = slices[indexes[0]];
switch (d) {
case 0:
throw new VectorzException("Can't do 0D set on SliceArray!");
case 1:
slice.set(value);
return;
case 2:
slice.set(indexes[1], value);
return;
case 3:
slice.set(indexes[1], indexes[2], value);
return;
default:
slice.set(Arrays.copyOfRange(indexes, 1, d), value);
return;
}
}
/**
* Processes the next frame in the sequence.
*
* @param frame Next frame in the video sequence
* @return If a fatal error occurred or not.
*/
public boolean process(I frame) {
// update the feature tracker
tracker.process(frame);
totalProcessed++;
// set up data structures and spawn tracks
if (totalProcessed == 1) {
tracker.spawnTracks();
tracker.setKeyFrame();
worldToKey.set(worldToInit);
worldToCurr.set(worldToInit);
return true;
}
// fit the motion model to the feature tracks
List<KeyFrameTrack> pairs = tracker.getPairs();
if (!modelMatcher.process((List) pairs)) {
return false;
}
// refine the motion estimate
if (modelRefiner == null
|| !modelRefiner.fitModel(modelMatcher.getMatchSet(), modelMatcher.getModel(), keyToCurr)) {
keyToCurr.set(modelMatcher.getModel());
}
// Update the motion
worldToKey.concat(keyToCurr, worldToCurr);
return true;
}
/** Makes the current frame the first frame and discards its past history */
public void reset() {
worldToKey.set(worldToInit);
keyToCurr.set(worldToInit);
worldToCurr.set(worldToInit);
tracker.reset();
tracker.spawnTracks();
tracker.setKeyFrame();
totalProcessed = 0;
}
/**
* calc a vector orthogonal to the given one
*
* @param dir the given vector
* @return a normalised vector orthogonal to dir
*/
@SuppressWarnings("unchecked")
public static <T extends Tuple2d> T getOrthogonalDirection(final T dir) {
T orth = (T) dir.clone();
if (dir.x == 0) orth.set(1, 0);
else if (dir.y == 0) orth.set(0, 1);
else {
orth.set(-dir.y / dir.x, 1);
}
return normalize(orth);
}
/** Make the current frame the first frame in the sequence */
public void changeKeyFrame() {
tracker.spawnTracks();
tracker.setKeyFrame();
totalSpawned = tracker.getActiveTracks().size();
worldToKey.set(worldToCurr);
}
@Override
public RandomAccessibleInterval<V> compute(
RandomAccessibleInterval<T> input, RandomAccessibleInterval<V> output) {
setUpNeighbours(input.numDimensions());
// OutOfBounds for marker
V zeroV = output.randomAccess().get().createVariable();
zeroV.set(getVMinValue(zeroV));
OutOfBounds<V> marker =
new OutOfBoundsConstantValueFactory<V, RandomAccessibleInterval<V>>(zeroV).create(output);
Cursor<V> cur = new Cursor<V>(output);
// OutOfBounds for mask
T zeroT = input.randomAccess().get().createVariable();
zeroT.set(getTMinValue(zeroT));
OutOfBounds<T> mask =
new OutOfBoundsConstantValueFactory<T, RandomAccessibleInterval<T>>(zeroT).create(input);
scanInRasterOrder(cur, marker, mask);
scanInAntiRasterOrder(cur, marker, mask);
propagate(marker, mask, m_neighbours);
return output;
}
/**
* Inserts a node before an existing child.
*
* @param ref existing child of this node, or {@code null} for append
* @param child node to insert
*/
public T insertBefore(T ref, T child) {
Preconditions.checkArgument(ref == null || ref.parent == this);
return ref == null
? append(child) // \u2620
: ref == first
? prepend(child) // \u2620
: (ref.prev.next = (ref.prev = child.set(self(), ref.prev, ref)));
}
/**
* Inserts a node after an existing child.
*
* @param ref existing child of this node, or {@code null} for prepend
* @param child node to insert
*/
public T insertAfter(T ref, T child) {
Preconditions.checkArgument(ref == null || ref.parent == this);
return ref == null
? prepend(child) // \u2620
: (ref == last
? append(child) // \u2620
: (ref.next.prev = (ref.next = child.set(self(), ref, ref.next))));
}
@SafeVarargs
public static <T extends Bits<T>> T with(T start, T... others) {
T t = with(start);
for (T e : others) {
t = t.set(e);
}
return t;
}
public void create(T obj) {
String key = kayVeepUtilities.getKey();
obj.setId(key);
this.data.store(obj);
this.updateMapping(obj);
Long createdTime = System.currentTimeMillis();
this.created.store(obj.getId(), createdTime);
obj.set("created_time", createdTime);
}
public T loadById(String id) {
T obj = this.data.load(id, this.dataType);
if (obj != null) {
// this.load_raw_properties(obj);
this.updateMapping(obj);
obj.set("created_time", this.created.load(obj.getId()));
obj.set("updated_time", this.updated.load(obj.getId()));
}
return obj;
}
/**
* calc a normalised copy of vector
*
* @param p the vector to normalise
* @return normalised version
*/
@SuppressWarnings("unchecked")
public static <T extends Tuple2d> T normalize(final T p) {
double length = Math.sqrt(p.getX() * p.getX() + p.getY() * p.getY());
T x = (T) p.clone();
x.set(p.getX(), p.getY());
x.scale(1 / length);
return x;
}
public void store(T obj) {
if (obj.getId() == null) {
create(obj);
return;
}
this.data.store(obj);
this.updateMapping(obj);
Long updatedTime = System.currentTimeMillis();
this.updated.store(obj.getId(), updatedTime);
obj.set("updated_time", updatedTime);
}
protected void integrateLine(
final int d, final RandomAccess<T> cursor, final T sum, final long size) {
// init sum on first pixel that is not zero
sum.set(cursor.get());
for (long i = 2; i < size; ++i) {
cursor.fwd(d);
sum.add(cursor.get());
cursor.get().set(sum);
}
}
/**
* Compute the steepest descent images of the template at the identity warp. Each steepest descent
* image comprises the partial derivatives of template intensities with respect to one parameter
* of the warp function.
*
* <p>The result is stored in the <em>n+1</em> dimensional {@link #target} image. Dimension
* <em>n</em> is used to index the partial derivative. For example, the partial derivative by the
* second parameter of the warp function is stored in slice <em>n=1</em>.
*
* @param gradients n+1 dimensional image of partial derivatives of the template. Dimension n is
* used to index the partial derivative. For example, the partial derivative by Y is stored in
* slice n=1.
* @param warpFunction The warp function to be applied to the template. The partial derivatives of
* template intensities with respect to the parameters of this warp function are computed.
* @param target Image of <em>n+1</em> dimensions to store the steepest descent Dimension
* <em>n</em> is used to index the parameters of the warp function. For example, the partial
* derivative of the template image intensity by parameter 2 of the warp function at pixel
* <em>(x,y)</em> is stored at position <em>(x,y,1)</em>.
*/
public static <T extends NumericType<T>> void computeSteepestDescents(
final RandomAccessibleInterval<T> gradients,
final WarpFunction warpFunction,
final RandomAccessibleInterval<T> target) {
final int n = gradients.numDimensions() - 1;
final int numParameters = warpFunction.numParameters();
final T tmp = Util.getTypeFromInterval(gradients).createVariable();
for (int p = 0; p < numParameters; ++p) {
for (int d = 0; d < n; ++d) {
final Cursor<T> gd =
Views.flatIterable(Views.hyperSlice(gradients, n, d)).localizingCursor();
for (final T t : Views.flatIterable(Views.hyperSlice(target, n, p))) {
tmp.set(gd.next());
tmp.mul(warpFunction.partial(gd, d, p));
t.add(tmp);
}
}
}
}
public boolean analyzePeak(final DifferenceOfGaussianPeak<T> peak) {
final int numDimensions = laPlacian.numDimensions();
// the subpixel values
final double[] subpixelLocation = new double[numDimensions];
// the current position for the quadratic fit
final long[] currentPosition = new long[numDimensions];
peak.localize(currentPosition);
// the cursor for the computation (one that cannot move out of Img)
final RandomAccess<T> cursor;
if (canMoveOutside) cursor = Views.extendPeriodic(laPlacian).randomAccess();
else cursor = laPlacian.randomAccess();
// the current hessian matrix and derivative vector
Img<DoubleType> hessianMatrix =
doubleArrayFactory.create(
new int[] {cursor.numDimensions(), cursor.numDimensions()}, new DoubleType());
Img<DoubleType> derivativeVector =
doubleArrayFactory.create(new int[] {cursor.numDimensions()}, new DoubleType());
// the inverse hessian matrix
Matrix A, B, X;
// the current value of the center
T value = peak.value.createVariable();
boolean foundStableMaxima = true, pointsValid = false;
int numMoves = 0;
// fit n-dimensional quadratic function to the extremum and
// if the extremum is shifted more than 0.5 in one or more
// directions we test wheather it is better there
// until we
// - converge (find a stable extremum)
// - move out of the Img
// - achieved the maximal number of moves
do {
++numMoves;
// move the cursor to the current positon
cursor.setPosition(currentPosition);
// store the center value
value.set(cursor.get());
// compute the n-dimensional hessian matrix [numDimensions][numDimensions]
// containing all second derivatives, e.g. for 3d:
//
// xx xy xz
// yx yy yz
// zx zy zz
hessianMatrix = getHessianMatrix(cursor, hessianMatrix);
// compute the inverse of the hessian matrix
A = invertMatrix(hessianMatrix);
if (A == null) return handleFailure(peak, "Cannot invert hessian matrix");
// compute the n-dimensional derivative vector
derivativeVector = getDerivativeVector(cursor, derivativeVector);
B = getMatrix(derivativeVector);
if (B == null) return handleFailure(peak, "Cannot compute derivative vector");
// compute the extremum of the n-dimensinal quadratic fit
X = (A.uminus()).times(B);
for (int d = 0; d < numDimensions; ++d) subpixelLocation[d] = X.get(d, 0);
// test all dimensions for their change
// if the absolute value of the subpixel location
// is bigger than 0.5 we move into that direction
foundStableMaxima = true;
for (int d = 0; d < numDimensions; ++d) {
// Normally, above an offset of 0.5 the base position
// has to be changed, e.g. a subpixel location of 4.7
// would mean that the new base location is 5 with an offset of -0.3
//
// If we allow an increasing maxima tolerance we will
// not change the base position that easily. Sometimes
// it simply jumps from left to right and back, because
// it is 4.51 (i.e. goto 5), then 4.49 (i.e. goto 4)
// Then we say, ok, lets keep the base position even if
// the subpixel location is 0.6...
final double threshold = allowMaximaTolerance ? 0.5 + numMoves * maximaTolerance : 0.5;
if (Math.abs(subpixelLocation[d]) > threshold) {
if (allowedToMoveInDim[d]) {
// move to another base location
currentPosition[d] += Math.signum(subpixelLocation[d]);
foundStableMaxima = false;
} else {
// set it to the position that is maximally away when keeping the current base position
// e.g. if (0.7) do 4 -> 4.5 (although it should be 4.7, i.e. a new base position of 5)
// or if (-0.9) do 4 -> 3.5 (although it should be 3.1, i.e. a new base position of 3)
subpixelLocation[d] = Math.signum(subpixelLocation[d]) * 0.5;
}
}
}
// check validity of the new location if there is a need to move
pointsValid = true;
if (!canMoveOutside)
if (!foundStableMaxima)
for (int d = 0; d < numDimensions; ++d)
if (currentPosition[d] <= 0 || currentPosition[d] >= laPlacian.dimension(d) - 1)
pointsValid = false;
} while (numMoves <= maxNumMoves && !foundStableMaxima && pointsValid);
if (!foundStableMaxima) return handleFailure(peak, "No stable extremum found.");
if (!pointsValid) return handleFailure(peak, "Moved outside of the Img.");
// compute the function value (intensity) of the fit
double quadrFuncValue = 0;
for (int d = 0; d < numDimensions; ++d) quadrFuncValue += X.get(d, 0) * B.get(d, 0);
quadrFuncValue /= 2.0;
// set the results if everything went well
// subpixel location
for (int d = 0; d < numDimensions; ++d)
peak.setSubPixelLocationOffset((float) subpixelLocation[d], d);
// pixel location
peak.setPixelLocation(currentPosition);
// quadratic fit value
final T quadraticFit = peak.getImgValue().createVariable();
quadraticFit.setReal(quadrFuncValue);
peak.setFitValue(quadraticFit);
// normal value
peak.setImgValue(value);
return true;
}
public static <T extends Bits<T>> T with(T t1, T t2, T t3, T t4, T t5) {
T t = with(t1, t2, t3, t4);
return t.set(t5);
}
public static <T extends Bits<T>> T with(T t1, T t2, T t3) {
T t = with(t1, t2);
return t.set(t3);
}
public static <T extends TypeWrapper, E> T wrap(T wrapper, E data) {
wrapper.set(data);
return wrapper;
}
/**
* Inserts a node as the last child of this node.
*
* @param child node to insert
*/
public T append(T child) {
return last =
((last == null) // \u2620
? (first = child.set(self(), null, null)) // \u2620
: (last.next = child.set(self(), last, null)));
}
/**
* Inserts a node as the first child of this node.
*
* @param child node to insert
*/
public T prepend(T child) {
return first =
((first == null) // \u2620
? (last = child.set(self(), null, null)) // \u2620
: (first.prev = child.set(self(), null, first)));
}
@Override
public void set(double value) {
for (T s : slices) {
s.set(value);
}
}
/**
* This method creates a gaussian kernel
*
* @param sigma Standard Derivation of the gaussian function in the desired {@link Type}
* @param normalize Normalize integral of gaussian function to 1 or not...
* @return T[] The gaussian kernel
*/
public static <T extends ExponentialMathType<T>> T[] createGaussianKernel1D(
final T sigma, final boolean normalize) {
final T[] gaussianKernel;
int kernelSize;
final T zero = sigma.createVariable();
final T two = sigma.createVariable();
final T one = sigma.createVariable();
final T minusOne = sigma.createVariable();
final T two_sq_sigma = zero.createVariable();
final T sum = sigma.createVariable();
final T value = sigma.createVariable();
final T xPos = sigma.createVariable();
final T cs = sigma.createVariable();
zero.setZero();
one.setOne();
two.setOne();
two.add(one);
minusOne.setZero();
minusOne.sub(one);
if (sigma.compareTo(zero) <= 0) {
kernelSize = 3;
// NB: Need explicit cast to T[] to satisfy javac;
// See: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6302954
gaussianKernel = (T[]) genericArray(3); // zero.createArray1D( 3 );
gaussianKernel[1].set(one);
} else {
// size = Math.max(3, (int) (2 * (int) (3 * sigma + 0.5) + 1));
cs.set(sigma);
cs.mul(3.0);
cs.round();
cs.mul(2.0);
cs.add(one);
kernelSize = Util.round(cs.getRealFloat());
// kernelsize has to be at least 3
kernelSize = Math.max(3, kernelSize);
// kernelsize has to be odd
if (kernelSize % 2 == 0) ++kernelSize;
// two_sq_sigma = 2 * sigma * sigma;
two_sq_sigma.set(two);
two_sq_sigma.mul(sigma);
two_sq_sigma.mul(sigma);
// NB: Need explicit cast to T[] to satisfy javac;
// See: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6302954
gaussianKernel = (T[]) genericArray(kernelSize); // zero.createArray1D( kernelSize );
for (int i = 0; i < gaussianKernel.length; ++i) gaussianKernel[i] = zero.createVariable();
// set the xPos to kernelSize/2
xPos.setZero();
for (int x = 1; x <= kernelSize / 2; ++x) xPos.add(one);
for (int x = kernelSize / 2; x >= 0; --x) {
// final double val = Math.exp( -(x * x) / two_sq_sigma );
value.set(xPos);
value.mul(xPos);
value.mul(minusOne);
value.div(two_sq_sigma);
value.exp();
gaussianKernel[kernelSize / 2 - x].set(value);
gaussianKernel[kernelSize / 2 + x].set(value);
xPos.sub(one);
}
}
if (normalize) {
sum.setZero();
for (final T val : gaussianKernel) sum.add(val);
for (int i = 0; i < gaussianKernel.length; ++i) gaussianKernel[i].div(sum);
}
for (int i = 0; i < gaussianKernel.length; ++i) System.out.println(gaussianKernel[i]);
return gaussianKernel;
}
protected void convolve(
final RandomAccess<T> inputIterator,
final Cursor<T> outputIterator,
final int dim,
final float[] kernel,
final long startPos,
final long loopSize) {
// move to the starting position of the current thread
outputIterator.jumpFwd(startPos);
final int filterSize = kernel.length;
final int filterSizeMinus1 = filterSize - 1;
final int filterSizeHalf = filterSize / 2;
final int filterSizeHalfMinus1 = filterSizeHalf - 1;
final int numDimensions = inputIterator.numDimensions();
final int iteratorPosition = filterSizeHalf;
final int[] to = new int[numDimensions];
final T sum = inputIterator.get().createVariable();
final T tmp = inputIterator.get().createVariable();
// do as many pixels as wanted by this thread
for (long j = 0; j < loopSize; ++j) {
outputIterator.fwd();
// set the sum to zero
sum.setZero();
//
// we move filtersize/2 of the convolved pixel in the input container
//
// get the current positon in the output container
outputIterator.localize(to);
// position in the input container is filtersize/2 to the left
to[dim] -= iteratorPosition;
// set the input cursor to this very position
inputIterator.setPosition(to);
// System.out.println( "out: " + outputIterator );
// System.out.println( "iteratorPosition: " + iteratorPosition );
// System.out.println( "in: " + inputIterator );
// System.exit ( 0 );
// iterate over the kernel length across the input container
for (int f = -filterSizeHalf; f <= filterSizeHalfMinus1; ++f) {
// get value from the input container
tmp.set(inputIterator.get());
// multiply the kernel
tmp.mul(kernel[f + filterSizeHalf]);
// add up the sum
sum.add(tmp);
// move the cursor forward for the next iteration
inputIterator.fwd(dim);
}
//
// for the last pixel we do not move forward
//
// get value from the input container
tmp.set(inputIterator.get());
// multiply the kernel
tmp.mul(kernel[filterSizeMinus1]);
// add up the sum
sum.add(tmp);
outputIterator.get().set(sum);
}
}
