bool ImageEdgeDetectionBase<T, U>::followEdges(T* edgemapptr, T *edgemagptr, short lowval,
int cols)
{
if (!edgemapptr || !edgemagptr)
return false;
T *tempmagptr;
T *tempmapptr;
int i;
//float thethresh;
int x[8] = {1,1,0,-1,-1,-1,0,1},
y[8] = {0,1,1,1,0,-1,-1,-1};
for(i=0; i<8; i++) {
tempmapptr = edgemapptr + y[i]*cols + x[i];
tempmagptr = edgemagptr + y[i]*cols + x[i];
if((*tempmapptr == kPgPOSSIBLE_EDGE) && (*tempmagptr > lowval)) {
*tempmapptr = (T) kPgEDGE;
followEdges(tempmapptr,tempmagptr, lowval, cols);
}
}
return true;
}
SsaOpnd* OSR::followEdges(SsaOpnd* iv) {
if (!LFTRHashMap.has(iv)) {
return iv;
} else {
LFTREntry & tmp2 = LFTRHashMap[iv];
SsaOpnd* reduced = tmp2.second;
return followEdges(reduced);
}
}
void OSR::performLFTR(Inst* inst) {
Opcode opcode = inst->getOpcode();
if (opcode == Op_Cmp || opcode == Op_Branch) {
U_32 num = inst->getNumSrcOperands();
if (2 == num) {
iv = 0;
rc = 0;
recordIVRC(inst);
if (iv && rc) {
SsaOpnd* reduced = 0;
SsaOpnd* newbound = 0;
SsaOpnd* src = getLeadingOperand(iv);
if (src == 0)
return;
reduced = followEdges(iv);
newbound = applyEdges(iv, rc);
if ((reduced != src) && (newbound != rc)) {
reduced = makeTmp(reduced, iv->getInst());
newbound = makeTmp(newbound, rc->getInst());
inst->setType(reduced->getType()->tag);
if ((inst->getOpcode() == Op_Cmp
|| inst->getOpcode() == Op_Branch)
&& inst->getComparisonModifier() == Cmp_GT) {
inst->setSrc(1, reduced);
inst->setSrc(0, newbound);
} else if ((inst->getOpcode() == Op_Cmp
|| inst->getOpcode() == Op_Branch)
&& inst->getComparisonModifier() == Cmp_GTE) {
inst->setSrc(0, reduced);
inst->setSrc(1, newbound);
} else {
inst->setSrc(1, reduced);
inst->setSrc(0, newbound);
}
}
}
iv = 0;
rc = 0;
}
}
}
bool ImageEdgeDetectionBase<T, U>::applyHysteresis(T *mag, T *nms, int rows, int cols,
float tlow, float thigh, U*edge)
{
int r, c, pos, numedges, /*lowcount,*/ highcount, lowthreshold, highthreshold,
//i,
hist[32768];//, rr, cc;
T maximum_mag;//, sumpix;
/****************************************************************************
* Initialize the edge map to possible edges everywhere the non-maximal
* suppression suggested there could be an edge except for the border. At
* the border we say there can not be an edge because it makes the
* followEdges algorithm more efficient to not worry about tracking an
* edge off the side of the image.
****************************************************************************/
for(r=0,pos=0; r<rows; r++) {
for(c=0; c<cols; c++,pos++) {
if(nms[pos] == kPgPOSSIBLE_EDGE) edge[pos] = kPgPOSSIBLE_EDGE;
else edge[pos] = kPgNOEDGE;
}
}
for(r=0,pos=0; r<rows; r++,pos+=cols) {
edge[pos] = kPgNOEDGE;
edge[pos+cols-1] = kPgNOEDGE;
}
pos = (rows-1) * cols;
for(c=0; c<cols; c++,pos++) {
edge[c] = kPgNOEDGE;
edge[pos] = kPgNOEDGE;
}
/****************************************************************************
* Compute the histogram of the magnitude image. Then use the histogram to
* compute hysteresis thresholds.
****************************************************************************/
for(r=0; r<32768; r++) hist[r] = 0;
for(r=0,pos=0; r<rows; r++) {
for(c=0; c<cols; c++,pos++) {
int magi = (int)(0.5f + mag[pos]);
magi = min(max(magi, 0), 32767);
if(edge[pos] == kPgPOSSIBLE_EDGE) hist[magi]++;
}
}
/****************************************************************************
* Compute the number of pixels that passed the nonmaximal suppression.
****************************************************************************/
for(r=1,numedges=0; r<32768; r++) {
if(hist[r] != 0) maximum_mag = r;
numedges += hist[r];
}
highcount = (int)(numedges * thigh + 0.5);
/****************************************************************************
* Compute the high threshold value as the (100 * thigh) percentage point
* in the magnitude of the gradient histogram of all the pixels that passes
* non-maximal suppression. Then calculate the low threshold as a fraction
* of the computed high threshold value. John Canny said in his paper
* "A Computational Approach to Edge Detection" that "The ratio of the
* high to low threshold in the implementation is in the range two or three
* to one." That means that in terms of this implementation, we should
* choose tlow ~= 0.5 or 0.33333.
****************************************************************************/
r = 1;
numedges = hist[1];
while((r<(maximum_mag-1)) && (numedges < highcount)) {
r++;
numedges += hist[r];
}
highthreshold = r;
lowthreshold = (int)(highthreshold * tlow + 0.5);
if(0) {
printf("The input low and high fractions of %f and %f computed to\n",
tlow, thigh);
printf("magnitude of the gradient threshold values of: %d %d\n",
lowthreshold, highthreshold);
}
/****************************************************************************
* This loop looks for pixels above the highthreshold to locate edges and
* then calls followEdges to continue the edge.
****************************************************************************/
for(r=0,pos=0; r<rows; r++) {
for(c=0; c<cols; c++,pos++) {
if((edge[pos] == kPgPOSSIBLE_EDGE) && (mag[pos] >= highthreshold)) {
edge[pos] = kPgEDGE;
followEdges((edge+pos), (mag+pos), lowthreshold, cols);
}
}
}
/****************************************************************************
* Set all the remaining possible edges to non-edges.
****************************************************************************/
for(r=0,pos=0; r<rows; r++) {
for(c=0; c<cols; c++,pos++) if(edge[pos] != kPgEDGE) edge[pos] = kPgNOEDGE;
}
return true;
}
