Assessing Infection
Background
According to the World Health Organization, infectious disease ranks
as the leading cause of death in the world. In 1998 alone, over 17
million people died from infectious and parasitic diseases such as
acute lower respiratory infections, tuberculosis, HIV/AIDS, and
malaria. It is forecast that infectious disease will continue to kill
millions of people, especially those living in developing countries.
The medical profession and scientific community of the world are
fighting the infectious disease threat with new tools and technologies
from a variety of fields. From this effort, a new field of research has
emerged. Infectious Disease Epidemiology is the study of
the variables that influence the growth and spread of infectious
diseases. This relatively new field combines molecular biology,
immunology, genetics, and the computational sciences. A focus of this
field is the study of the factors that influence the growth of an
infectious disease within a single organism, and the factors that
influence the pattern of infection across an entire population.
Description
This assignment asks you to finish the implementation of a program
that assesses the level of infection in a tissue sample. You are given
data representing a rectangular tissue sample, overlaid with a grid.
Certain portions of the tissue are infected; others are not. Your goal
is to help assess the extent of the infection by writing a program
that, given the coordinates of a colony of infection, can determine its
size.
A typical use of the program follows. The user interacts with the
program only through command-line arguments. The user supplies to the
program a data filename and the coordinates of a cell in the grid. The
coordinates are specified by row and then column, both starting at
zero. The program calculates the extent of infection at that coordinate
and outputs a two-dimensional representation of the tissue sample.
Figure 1 depicts the execution of the program.
Output from a sample solution
For the purpose of this assessment, we consider a "colony" of
infected tissue to be a set of adjacent and infected cells. In Figure
1, we can see three separate colonies. The smallest colony consists of
two cells and is located in the lower left corner of the grid. Another
colony consisting of three infected cells exists on the far right edge
of the grid. The largest colony of eight cells resides primarily in the
middle of the grid. This colony has a small arm into the upper left
corner of the grid. Notice from this colony that cells residing in
diagonals are considered "adjacent." The plus signs next to the cells
in this largest colony indicate that they all belong to the colony that
contains the user entered coordinate.
solution :
#ifndef GRID_H
#define GRID_H
#include <string>
#include <vector>
using namespace std;
/*
* IMPORTANT NOTE:
*
* For this assignment, you might need to add state to the
* class and/or augment existing methods, and/or create private helper
* methods, but you should not delare new public methods
*/
const bool INFECTED = true;
const bool NOT_INFECTED = false;
class grid;
class grid {
private:
int rows;
int cols;
vector<bool> *area;
vector<bool> *infect;
int indexof (int row, int col) const;
bool infected(int row, int col) const;
public:
grid (string file);
~grid ();
int count (int row, int col);
friend ostream &operator<<(ostream &stream, const grid& ob);
};
#endif
============================================================================
#include <iostream>
#include <fstream>
using namespace std;
#include "grid.h"
// You do not need to alter function indexof.
int grid::indexof (int row, int col) const {
return row*cols+col;
}
// You do not need to alter function infected.
bool grid::infected(int row, int col) const {
return (area->operator[](indexof(row, col)) == INFECTED);
}
// You may need to alter the constructor
grid::grid (string file) {
ifstream grid_file;
grid_file.open (file.c_str());
grid_file >> rows;
grid_file >> cols;
area = new vector<bool>(rows*cols, NOT_INFECTED);
infect = new vector<bool>(rows*cols, NOT_INFECTED);
while (true) {
int blob_row;
int blob_col;
grid_file >> blob_row;
grid_file >> blob_col;
if (grid_file.eof()) {
break;
}
area->operator[](indexof(blob_row,blob_col)) = INFECTED;
}
grid_file.close();
}
// You may need to alter the destructor
grid::~grid () {
delete area;
delete infect;
}
// You will need to alter this function to display the
// plus signs (+) next to the cells that belong to
// a counted colony.
ostream &operator<<(ostream &stream, const grid& ob) {
for (int row=0; row < ob.rows; row++) {
for (int col=0; col < ob.cols; col++) {
stream << ob.area->operator[](ob.indexof(row, col));
if( ob.infect->operator[] ( ob.indexof(row, col) ) )
stream << "+ ";
else
stream << " ";
}
stream << endl;
}
stream << endl;
return stream;
}
// Replace the return statement in this function with your
// recursive implementation of this method */
int grid::count (int row, int col) {
if( row < 0 || col < 0 || row == rows || col == cols)
return 0;
if( area->operator[](indexof(row,col) ) == NOT_INFECTED )
return 0;
if(infect->operator[](indexof(row,col)) == INFECTED)
return 0;
infect->operator[](indexof(row,col)) = INFECTED;
// Recursive test the 8 point near the point
// which area is INEFCTED and infect is NOT_INFECTED
return count( row - 1, col - 1 ) + count ( row - 1, col )
+ count( row - 1, col + 1 ) + count( row, col - 1 )
+ count( row, col ) + 1 + count( row, col + 1 )
+ count( row + 1, col - 1 ) + count( row + 1, col )
+ count( row + 1, col + 1 );
}