public final double distance(F g1, F g2, LocalFeaturesMatches matches) {
distCount++;
if (matches == null || matches.size() == 0) return 1.0;
if (matches.size() / (double) g1.size() < minPercMatches) {
updateStats(0, matches.size(), 0);
return 1.0;
}
if (nHoughMatches) {
Hashtable<Long, LocalFeaturesMatches> ht = this.getLoweHoughTransforms_HT(matches);
if (ht == null || ht.size() == 0) {
updateStats(0, matches.size(), 0);
return 1.0;
}
LocalFeaturesMatches[] ordered = LoweHoughTransform.orderHT(ht);
updateStats(0, matches.size(), 0);
return 1.0 - this.getPercentage(ordered[0].size(), g1.size(), g2.size());
} else if (onlyNMatches) {
updateStats(0, matches.size(), 0);
return 1.0 - this.getPercentage(matches.size(), g1.size(), g2.size());
}
double res = 0;
if (matches.size() / (double) g1.size() < minPercMatches) {
updateStats(0, matches.size(), 0);
return 1.0;
}
ArrayList<TransformationHypothesis> trArr = getTrHypothesis(matches, g1.size());
if (trArr == null || trArr.size() == 0) {
res = 0.0;
updateStats(0, 0, matches.size());
} else {
res = this.getPercentage(trArr.get(0).getMatches().size(), g1.size(), g2.size());
updateStats(matches.size(), trArr.get(0).getMatches().size(), 0);
}
if (res > 1.0) res = 1.0;
return 1.0 - res;
}
/** {@inheritDoc} */
@Override
public int size() {
return F.size(iterator());
}
/** {@inheritDoc} */
@Override
public void onCollision(
Collection<GridCollisionJobContext> waitJobs,
Collection<GridCollisionJobContext> activeJobs) {
assert waitJobs != null;
assert activeJobs != null;
int activeSize = F.size(activeJobs, RUNNING_JOBS);
waitingCnt.set(waitJobs.size());
runningCnt.set(activeSize);
heldCnt.set(activeJobs.size() - activeSize);
int waitSize = waitJobs.size();
int activateCnt = parallelJobsNum - activeSize;
if (activateCnt > 0 && !waitJobs.isEmpty()) {
if (waitJobs.size() <= activateCnt) {
for (GridCollisionJobContext waitJob : waitJobs) {
waitJob.activate();
waitSize--;
}
} else {
List<GridCollisionJobContext> passiveList =
new ArrayList<GridCollisionJobContext>(waitJobs);
Collections.sort(
passiveList,
new Comparator<GridCollisionJobContext>() {
/** {@inheritDoc} */
@Override
public int compare(GridCollisionJobContext o1, GridCollisionJobContext o2) {
int p1 = getJobPriority(o1);
int p2 = getJobPriority(o2);
return p1 < p2 ? 1 : p1 == p2 ? 0 : -1;
}
});
if (preventStarvation) bumpPriority(waitJobs, passiveList);
for (int i = 0; i < activateCnt; i++) {
passiveList.get(i).activate();
waitSize--;
}
}
}
if (waitSize > waitJobsNum) {
List<GridCollisionJobContext> waitList = new ArrayList<GridCollisionJobContext>(waitJobs);
// Put jobs with highest priority first.
Collections.sort(
waitList,
new Comparator<GridCollisionJobContext>() {
/** {@inheritDoc} */
@Override
public int compare(GridCollisionJobContext o1, GridCollisionJobContext o2) {
int p1 = getJobPriority(o1);
int p2 = getJobPriority(o2);
return p1 < p2 ? 1 : p1 == p2 ? 0 : -1;
}
});
int skip = waitJobs.size() - waitSize;
int i = 0;
for (GridCollisionJobContext waitCtx : waitList) {
if (++i >= skip) {
waitCtx.cancel();
if (--waitSize <= waitJobsNum) break;
}
}
}
}
@Override
public boolean process() {
final long startTime = System.currentTimeMillis();
/*
if ( container.numDimensions() == 3 && Array.class.isInstance( container ) && FloatType.class.isInstance( container.createVariable() ))
{
//System.out.println( "GaussianConvolution: Input is instance of Image<Float> using an Array3D, fast forward algorithm");
computeGaussFloatArray3D();
processingTime = System.currentTimeMillis() - startTime;
return true;
}
*/
final Img<T> temp = outputFactory.create(input, input.firstElement().createVariable());
final long containerSize = input.size();
//
// Folding loop
//
for (int dim = 0; dim < numDimensions; dim++) {
final int currentDim = dim;
final AtomicInteger ai = new AtomicInteger(0);
final Thread[] threads = SimpleMultiThreading.newThreads(numThreads);
final long threadChunkSize = containerSize / threads.length;
final long threadChunkMod = containerSize % threads.length;
for (int ithread = 0; ithread < threads.length; ++ithread)
threads[ithread] =
new Thread(
new Runnable() {
public void run() {
// Thread ID
final int myNumber = ai.getAndIncrement();
// System.out.println("Thread " + myNumber + " folds in dimension " +
// currentDim);
final RandomAccess<T> inputIterator;
final Cursor<T> outputIterator;
if (numDimensions % 2 == 0) // even number of dimensions ( 2d, 4d, 6d, ... )
{
if (currentDim == 0) // first dimension convolve to the temporary container
{
inputIterator = input.randomAccess(outOfBoundsFactory1);
outputIterator = temp.localizingCursor();
} else if (currentDim % 2
== 1) // for odd dimension ids we convolve to the output container,
// because that might be the last convolution
{
inputIterator = temp.randomAccess(outOfBoundsFactory2);
outputIterator = convolved.localizingCursor();
} else // if ( currentDim % 2 == 0 ) // for even dimension ids we convolve to
// the temp container, it is not the last convolution for sure
{
inputIterator = convolved.randomAccess(outOfBoundsFactory2);
outputIterator = temp.localizingCursor();
}
} else // ( numDimensions % 2 != 0 ) // even number of dimensions ( 1d, 3d, 5d,
// ... )
{
if (currentDim
== 0) // first dimension convolve to the output container, in the 1d case
// we are done then already
{
inputIterator = input.randomAccess(outOfBoundsFactory1);
outputIterator = convolved.localizingCursor();
} else if (currentDim % 2
== 1) // for odd dimension ids we convolve to the output container,
// because that might be the last convolution
{
inputIterator = convolved.randomAccess(outOfBoundsFactory2);
outputIterator = temp.localizingCursor();
} else // if ( currentDim % 2 == 0 ) // for even dimension ids we convolve to
// the temp container, it is not the last convolution for sure
{
inputIterator = temp.randomAccess(outOfBoundsFactory2);
outputIterator = convolved.localizingCursor();
}
}
// move to the starting position of the current thread
final long startPosition = myNumber * threadChunkSize;
// the last thread may has to run longer if the number of pixels cannot be
// divided by the number of threads
final long loopSize;
if (myNumber == numThreads - 1) loopSize = threadChunkSize + threadChunkMod;
else loopSize = threadChunkSize;
// convolve the container in the current dimension using the given cursors
float[] kernelF = new float[kernel[currentDim].length];
for (int i = 0; i < kernelF.length; ++i)
kernelF[i] = (float) kernel[currentDim][i];
convolve(
inputIterator,
outputIterator,
currentDim,
kernelF,
startPosition,
loopSize);
}
});
SimpleMultiThreading.startAndJoin(threads);
}
processingTime = System.currentTimeMillis() - startTime;
return true;
}
