void ComputeHarrisFeatures(CFloatImage &image, FeatureSet &features)
{
//Create grayscale image used for Harris detection
CFloatImage grayImage=ConvertToGray(image);
//Create image to store Harris values
CFloatImage harrisImage(image.Shape().width,image.Shape().height,1);
//Create image to store local maximum harris values as 1, other pixels 0
CByteImage harrisMaxImage(image.Shape().width,image.Shape().height,1);
//compute Harris values puts harris values at each pixel position in harrisImage.
//You'll need to implement this function.
computeHarrisValues(grayImage, harrisImage);
// Threshold the harris image and compute local maxima. You'll need to implement this function.
computeLocalMaxima(harrisImage,harrisMaxImage);
// Prints out the harris image for debugging purposes
CByteImage tmp(harrisImage.Shape());
convertToByteImage(harrisImage, tmp);
WriteFile(tmp, "harris.tga");
// TO DO--------------------------------------------------------------------
//Loop through feature points in harrisMaxImage and fill in information needed for
//descriptor computation for each point above a threshold. We fill in id, type,
//x, y, and angle.
CFloatImage A(grayImage.Shape());
CFloatImage B(grayImage.Shape());
CFloatImage C(grayImage.Shape());
CFloatImage partialX(grayImage.Shape());
CFloatImage partialY(grayImage.Shape());
GetHarrisComponents(grayImage, A, B, C, &partialX, &partialY);
int featureCount = 0;
for (int y=0;y<harrisMaxImage.Shape().height;y++) {
for (int x=0;x<harrisMaxImage.Shape().width;x++) {
// Skip over non-maxima
if (harrisMaxImage.Pixel(x, y, 0) == 0)
continue;
//TO DO---------------------------------------------------------------------
// Fill in feature with descriptor data here.
Feature f;
f.type = 2;
f.id = featureCount++;
f.x = x;
f.y = y;
f.angleRadians = GetCanonicalOrientation(x, y, A, B, C, partialX, partialY);
//atan(partialY.Pixel(x, y, 0)/partialX.Pixel(x, y, 0));
// Add the feature to the list of features
features.push_back(f);
}
}
}
/*
* This routine is in charge of the momentum equation. Virtually all
* of the terms can be enabled or disabled by parameters read in through the
* configuration file. This equation has the form:
*
* du/dt = div(alpha BB - uu - P) + (Ra T + B^2 / beta) hat z + Pr del^2 u + F_u
*
* Since the velocity field is incompressible, the pressure term doesn't matter
* and is eliminated by taking the curl of the right-hand side. This is then
* decomposed into poloidal and toroidal components, which are then used in the
* time integration.
*/
void calcMomentum()
{
debug("Calculating momentum forces\n");
int i,j,k;
int index;
if(viscosity)
{
//First argument is the field we take the laplacian of.
//Second argument is where the result is stored.
//The 0 in the third argument means we overwrite the destination array
//Pr is the coefficient for this diffusion term.
laplacian(u->vec->x->spectral, rhs->x->spectral, 0, Pr);
laplacian(u->vec->y->spectral, rhs->y->spectral, 0, Pr);
laplacian(u->vec->z->spectral, rhs->z->spectral, 0, Pr);
}
else
{
//make sure we don't start with garbage
memset(rhs->x->spectral, 0, spectralCount * sizeof(complex PRECISION));
memset(rhs->y->spectral, 0, spectralCount * sizeof(complex PRECISION));
memset(rhs->z->spectral, 0, spectralCount * sizeof(complex PRECISION));
}
//Apply hyper diffusion to the boundaries
//This does not currently work and is disabled by default!
if(sanitize)
{
killBoundaries(u->vec->x->spatial, rhs->x->spectral, 1, 100*Pr);
killBoundaries(u->vec->y->spatial, rhs->y->spectral, 1, 100*Pr);
killBoundaries(u->vec->z->spatial, rhs->z->spectral, 1, 100*Pr);
}
//static forcing is read in from a file and currently only in the u
//direction as a function of y and z (to remove nonlinear advection)
if(momStaticForcing)
{
complex PRECISION * xfield = rhs->x->spectral;
complex PRECISION * ffield = forceField->spectral;
index = 0;
for(i = 0; i < spectralCount; i++)
{
xfield[i] += ffield[i];
}
}
//
if(momTimeForcing)
{
//Evaluate the force function at the current time.
fillTimeField(temp1, MOMENTUM);
plusEq(rhs->x->spectral, temp1->x->spectral);
plusEq(rhs->y->spectral, temp1->y->spectral);
plusEq(rhs->z->spectral, temp1->z->spectral);
}
if(momAdvection)
{
p_field tense = temp1->x;
//Note here, because I already forgot once. a 2 as the third
//parameter makes things behave as a -= operation!
multiply(u->vec->x->spatial, u->vec->x->spatial, tense->spatial);
fftForward(tense);
partialX(tense->spectral, rhs->x->spectral, 2);
multiply(u->vec->y->spatial, u->vec->y->spatial, tense->spatial);
fftForward(tense);
partialY(tense->spectral, rhs->y->spectral, 2);
multiply(u->vec->z->spatial, u->vec->z->spatial, tense->spatial);
fftForward(tense);
partialZ(tense->spectral, rhs->z->spectral, 2);
multiply(u->vec->x->spatial, u->vec->y->spatial, tense->spatial);
fftForward(tense);
partialY(tense->spectral, rhs->x->spectral, 2);
partialX(tense->spectral, rhs->y->spectral, 2);
multiply(u->vec->x->spatial, u->vec->z->spatial, tense->spatial);
fftForward(tense);
partialZ(tense->spectral, rhs->x->spectral, 2);
partialX(tense->spectral, rhs->z->spectral, 2);
multiply(u->vec->y->spatial, u->vec->z->spatial, tense->spatial);
fftForward(tense);
partialZ(tense->spectral, rhs->y->spectral, 2);
partialY(tense->spectral, rhs->z->spectral, 2);
}
if(lorentz)
{
p_field tense = temp1->x;
p_vector lor = temp2;
//The third parameter as a 0 means we overwrite the destination array.
//The third parameter as a 1 means it behaves as a += operation.
multiply(B->vec->x->spatial, B->vec->x->spatial, tense->spatial);
fftForward(tense);
partialX(tense->spectral, lor->x->spectral, 0);
multiply(B->vec->y->spatial, B->vec->y->spatial, tense->spatial);
fftForward(tense);
partialY(tense->spectral, lor->y->spectral, 0);
multiply(B->vec->z->spatial, B->vec->z->spatial, tense->spatial);
fftForward(tense);
partialZ(tense->spectral, lor->z->spectral, 0);
multiply(B->vec->x->spatial, B->vec->y->spatial, tense->spatial);
fftForward(tense);
partialY(tense->spectral, lor->x->spectral, 1);
partialX(tense->spectral, lor->y->spectral, 1);
multiply(B->vec->x->spatial, B->vec->z->spatial, tense->spatial);
fftForward(tense);
partialZ(tense->spectral, lor->x->spectral, 1);
partialX(tense->spectral, lor->z->spectral, 1);
multiply(B->vec->y->spatial, B->vec->z->spatial, tense->spatial);
fftForward(tense);
partialZ(tense->spectral, lor->y->spectral, 1);
partialY(tense->spectral, lor->z->spectral, 1);
//TODO: Find a routine to change to include this factor
complex PRECISION * px = lor->x->spectral;
complex PRECISION * py = lor->y->spectral;
complex PRECISION * pz = lor->z->spectral;
int i;
for(i = 0; i < spectralCount; i++)
{
px[i] *= alpha;
py[i] *= alpha;
pz[i] *= alpha;
}
plusEq(rhs->x->spectral, px);
plusEq(rhs->y->spectral, py);
plusEq(rhs->z->spectral, pz);
}
if(magBuoy)
{
p_field B2 = temp1->x;
dotProduct(B->vec,B->vec,B2);
fftForward(B2);
for(i = 0; i < spectralCount; i++)
{
B2->spectral[i] *= magBuoyScale;
}
plusEq(rhs->z->spectral, B2->spectral);
}
if(buoyancy)
{
complex PRECISION * zfield = rhs->z->spectral;
complex PRECISION * tfield = T->spectral;
PRECISION factor = Ra * Pr;
index = 0;
for(i = 0; i < spectralCount; i++)
{
zfield[i] += factor * tfield[i];
}
}
//curl it so we can avoid dealing with the pressure term
curl(rhs, temp1);
//The third parameter as a 1 means we store the result in the force
//arrays for u->sol.
decomposeCurlSolenoidal(u->sol, temp1, 1);
debug("Momentum forces done\n");
}
