// GUI calls this function when a user left-clicks on an image pixel while in "Region" mode
// The method computes a 'region' of pixels connected to 'seed'. The region is grown by adding
// to each pixel p (starting at 'seed') all neighbors q such that intensity difference is small,
// that is, |Ip-Iq|<T where T is some fixed threshold. Use Queue for active front.
// HINT: to compute intensity difference Ip-Iq, use function dI(RGB,RGB) defined in "Image2D.h"
void regionGrow(Point seed, double T)
{
if (!image.pointIn(seed)) return;
int counter = 0;
Queue<Point> active;
active.enqueue(seed);
// use BREADTH-FIRST_SEARCH (FIFO order) traversal - "Queue"
//..
while (!active.isEmpty())
{
Point p = active.dequeue();
region[p]=1;
counter++;
for (int i=0; i<4; i++)
{
Point q = p + shift[i];
if (image.pointIn(q) && region[q]==0 && dI(image[q], image[seed])>(T*-1) && dI(image[q], image[seed])<T)
{
active.enqueue(q);
region[q]=2;
}
}
if (view && counter%60==0) {draw(); Pause(20);}
}
cout << "grown region of volume " << counter << " pixels (threshold " << T << ")" << endl;
}
// GUI calls this function when a user right-clicks on an image pixel while in "Region" mode.
// It marks in 'region' a set of same-color pixels adjacent to the 'seed'. The neighboring pixels
// are traversed using DEPTH-FIRST-SEARCH starting at the 'seed'.
// Unlike previous function "addSquare()", the shape of the added region depends on the image.
void floodFill_DFS(Point seed)
{
int counter = 0;
Stack<Point> active_front;
active_front.push(seed);
// "mark" all adjecent pixels of the same color in 2D table "region" while traversing them
// using DEPTH-FIRST_SEARCH (LIFO order) traversal - use "Stack"
while (!active_front.isEmpty())
{
Point p = active_front.pop();
region[p]=1; // pixel p is extracted from the "active_front" and added to "region", but
counter++; // then, all "appropriate" neighbors of p are added to "active_front" (below)
for (int i=0; i<4; i++) // goes over 4 neighbors of pixel p
{ // uses overloaded operator "+" for Points (see Basics2D.h) and array of 'shifts' (see the top of file)
Point q = p + shift[i]; // to compute a "neighbor" of pixel p
if (im.pointIn(q) && region[q]==0 && im[q]==im[seed])
{ // we checked if q is inside image range and that its "color" matches "seed"
// Why do we also need condition region[q]==0 ????
active_front.push(q);
region[q]=2; // "region" value 2 is used in "draw()" to visualise pixels that are
} // inside "active_front"; note that all pixels in "active front"
} // are eventually extracted and their "region" value is set to 1.
if (view && counter%60==0) {draw(); Pause(20);} // visualization, skipped if checkbox "view" is off
}
cout << "flood filled region of size " << counter << " using DFS traversal (LIFO order, Stack)" << endl;
}
// GUI calls this function when a user middle-clicks on an image pixel while in "Region" mode
// It marks in 'region' a square-shaped subset of pixels adjecent to 'seed' (side=40)
void addSquare(Point seed)
{
// The code below marks one pixel (seed.x,seed.y) as part of the "region."
// (Note that draw() function in main.cpp displays all 'region=1' pixels in blue.)
//
// GOAL: Change the code below so that, instead of marking just one pixel,
// it marks pixels in a square around the seed.
// The square should have size 40x40 and be centered at (seed.x, seed.y).
//
region[seed]=1; // seed is a Point; there are 2 overloaded operators[] in Table2D.h
// this line is equivalent to "region[seed.x][seed.y]=1;"
for(int i = -20; i<=20; i++)
for(int j = -20; j<=20; j++)
if(region.pointIn(seed.x +i, seed.y +j))
{
region[seed.x+i][seed.y+j]=2;
}
cout << "added a square region" << endl;
}
// This function is called at the end of "addToContourLast()". Function
// "contourInterior()" returns volume of the closed contour's interior region
// (including points on the contor itself), or -1 if contour is not closed yet.
// HINT: live-wire() adds to the contour "water-tight" paths of neighboring pixels
int contourInterior()
{
if (!closedContour || image.isEmpty()) return -1;
int counter = 0;
// write your code for computing correct mask (region)
// which should have 3 for pixels OUTSIDE the contour and 0
// for pixels INSIDE of the contour
// HINT: "grow" the "exterior region" from a single exterior point (e.g. a corner of the image).
// Make sure that the region does not grow across the contour (points in list "contour")
// ...
Queue<Point> active;
Point q(1,1);
active.enqueue(q);
region.reset(0);
for (unsigned i=1; i<=contour.getLength(); i++)
region[contour.retrieve(i)]=2;
while (!active.isEmpty())
{
Point p = active.dequeue();
region[p]=3;
counter++;
for (int i=0; i<4; i++)
{
Point j = p + shift[i];
if (image.pointIn(j) && region[j]!=2 && region[j]!=3)
{
active.enqueue(j);
region[j]=3;
}
}
if (view && counter%60==0) {draw(); Pause(20);}
}
for (unsigned i=1; i<=contour.getLength(); i++)
region[contour.retrieve(i)]=0;
return region.getWidth() * region.getHeight() - counter;
}
// GUI calls this function when a user left-clicks on an image pixel while in "Region" mode.
// It marks in 'region' a set of same-color pixels adjacent to the 'seed'. The neighboring pixels
// are traversed using BREADTH-FIRST-SEARCH starting at the 'seed'.
// This function differs from floodFill_DFS() only by the order of traversal of adjecent pixels.
void floodFill_BFS(Point seed)
{
// INSTEAD OF CODE BELOW THAT MARKS ONLY ONE PIXEL IN "REGION"...
// "mark" all adjecent pixels of the same color to 2D array "region" while traversing them
// using BREADTH-FIRST_SEARCH (FIFO order) - use "Queue" instead of "Stack"
// ...
int counter = 0;
Queue<Point> active_front;
active_front.enqueue(seed);
// "mark" all adjecent pixels of the same color in 2D table "region" while traversing them
// using DEPTH-FIRST_SEARCH (LIFO order) traversal - use "Stack"
while (!active_front.isEmpty())
{
Point p = active_front.dequeue();
region[p]=1; // pixel p is extracted from the "active_front" and added to "region", but
counter++; // then, all "appropriate" neighbors of p are added to "active_front" (below)
for (int i=0; i<4; i++) // goes over 4 neighbors of pixel p
{ // uses overloaded operator "+" for Points (see Basics2D.h) and array of 'shifts' (see the top of file)
Point q = p + shift[i]; // to compute a "neighbor" of pixel p
if (im.pointIn(q) && region[q]==0 && im[q]==im[seed])
{ // we checked if q is inside image range and that its "color" matches "seed"
// Why do we also need condition region[q]==0 ????
active_front.enqueue(q);
region[q]=2; // "region" value 2 is used in "draw()" to visualise pixels that are
} // inside "active_front"; note that all pixels in "active front"
} // are eventually extracted and their "region" value is set to 1.
if (view && counter%60==0) {draw(); Pause(20);} // visualization, skipped if checkbox "view" is off
}
region[seed]=1; // equivalent to region[seed.x][seed.y]=1; (see Table2D.h)
// replace the "cout" statement below to indicate the number of "marked" pixels added into "region" using BFS.
cout << "added one pixel to region" << endl;
}
///////////////////////////////////////////////////////////////////////////////////
// computePaths() is a function for "precomputing" live-wire (shortest) paths from
// any image pixel to the given "seed". This method is called inside "addToContour"
// for each new mouse click. Optimal path from any pixel to the "seed" should accumulate
// the least amount of "penalties" along the path (each pixel p=(x,y) on a path contributes
// penalty[p] precomputed in "reset_segm()"). In this function you should use 2D tables
// "toParent" and "dist" that store for each pixel its "path-towards-seed" direction and,
// correspondingly, the sum of penalties on that path (a.k.a. "distance" to the seed).
// The function iteratively improves paths by traversing pixels from the seed until
// all nodes have direction "toParent" giving the shortest (cheapest) path to the "seed".
void computePaths(Point seed)
{
if (!image.pointIn(seed)) return;
region.reset(0); // resets 2D table "region" for visualization
// Reset 2D arrays "dist" and "toParent" (erazing all current paths)
dist.reset(INFTY);
toParent.reset(NONE);
dist[seed] = 0;
int counter = 0; // just for info printed at the bottom of the function
// THE CODE BELOW GENERATES 2d TABLE toParent WITH PATHS BASED ON !!!!!!!!
// BASIC BREDTH-FIRST_SEARCH TRAVERSAL FROM THE SEED. REPLACE THIS CODE !!!!!!!!
// SO THAT toParent CONTAINS PATHS FOLLOWING HIGH CONSTAST IMAGE BOUNDARIES !!!!!!!!
//
// Create a queue (or priority_queue) for "active" points/pixels and
// traverse pixels to improve paths stored in "toParent" (and "dist")
// .....
Queue<Point> active;
active.enqueue(seed);
while(!active.isEmpty())
{
Point p = active.dequeue();
region[p]=1;
counter++;
for (int i=0; i<4; i++)
{
Point q = p+shift[i]; //using overloaded operator+ for Points (see "Basic2D.h")
double t = dist[p] + penalty[p];
if (image.pointIn(q) && t<dist[q])
{
dist[q]=t;
toParent[q]=Reverse[i];
region[q]=2; // to visualize pixels added to the queue
active.enqueue(q);
}
}
if (view && counter%60==0) {draw(); Pause(20);} // visualization, skipped if checkbox "view" is off
}
// MY PRIORITY QUEUE METHOD WORKS IN THE SAME FASHION AS THE DEMO
// IT IS SLOWER THAN MY QUEUE METHOD, BUT I AM UNSURE IF THIS IS
// AN ISSUE WITH RELEASE MODE COMPARED TO DEBUG MODE
// COMMENT OUT THE ABOVE QUEUE METHOD AND UNCOMMENT THE BELOW METHOD
// TO TEST FUNCTIONALITY OF PRIORITY QUEUE METHOD
/*priority_queue<MyPoint> active;
MyPoint j(seed, dist[seed]);
active.push(j);
while(!active.empty())
{
Point p = active.top();
active.pop();
region[p]=1;
counter++;
for (int i=0; i<4; i++)
{
Point q = p+shift[i]; //using overloaded operator+ for Points (see "Basic2D.h")
double t = dist[p] + penalty[p];
if (image.pointIn(q) && t<dist[q])
{
dist[q]=t;
toParent[q]=Reverse[i];
region[q]=2; // to visualize pixels added to the queue
MyPoint b(q, dist[q]);
active.push(b);
}
}
if (view && counter%60==0) {draw(); Pause(20);} // visualization, skipped if checkbox "view" is off
}*/
// you can print out the number of times a point was removed from the queue
cout << "paths computed, number of 'pops' = " << counter
<< ", number of pixels = " << (region.getWidth()*region.getHeight()) << endl;
}