Graphical editor programming challenge

I've tried to review your code, and I have the following comments.

Pro:
All in all the code is well structured and the naming is easy to understand.

The comments are helpful

The separation of user interaction and processing is good

Contra:

Missing

• helpful prompts

• error handling and messages. The processing functions should return a status value so the UI can inform the user if something went wrong.

Below I've reentered all your code with some inline comments and modifications (All begins with // HH or // HH TODO):

// graphical_editor.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream> //provides access to cout and cin 
#include <string> //Always import <string> if piping std input to a string in .net 
#include <vector>
#include <fstream>

using std::cin;
using std::cout;
using std::string;
using std::vector;
using std::ofstream;


// HH you could typedef Color to quickly change the type
typedef char Color;
// HH The black and white colors:
const Color white = '0';
const Color black = ' ';

// HH compare function is easy to change if Color changes to other type
int compare_colors(Color c1, Color c2)
{
  if (c1 == c2)
    return 0;
  if (c1 < c2)
    return -1;
  return 1;
}


//This is where we store the pixels of the image
// static vector<vector <string>> image_array; // HH: One char == one pixel so use char instead of string
vector<vector <Color>> image_array;

//our definition of an X,Y coordinate pair. 
/*typedef*/ struct point { // HH: typedef ignored because no variable is defined
  // int x_coordinate, y_coordinate; // HH unnecessarily long names
  int x, y;
};

/* You could have done it like this: 
typedef struct _point {                       
  int x, y;
} point;
*/


void initialise_image(int width, int height);
void clear_image();
void print_image(); // HH Prints the image to the console
void save_image(string file_name);
int get_image_width();
int get_image_height();
void color_pixel(int x, int y, Color color);
void color_point(point p, Color color);
void color_vertical_line(int x, int y1, int y2, Color color);
void color_horizontal_line(int x1, int x2, int y, Color color);
void color_box(int x1, int x2, int y1, int y2, Color color);
void flood_fill(point p, Color color);
void add_matching_neighbours(point p, Color original_color, Color new_color, vector<point> &points_queue);

int main()
{
  //myfile.open("example.txt");
  char command; //first letter of a given line 

  // HH: A switch() may be better here than the else if sequence
  do {
    cout << "Enter Command [ I, S, L, V, H, K, F, C, X ] ";
    cin >> command;

    // HH TODO: Change the loop so that the user can't draw on an uninitialized image

    switch (command)
    {
    case 'X':
    case 'x': // HH: Allow for lower case letters as well
      return 0;
    case 'I':
    case 'i':
      // HH Here you have the input dialog inside the function but elsewhere it's in this loop. Be consistent
      // initialise_image();
      /*read parameters height and width*/
      cout << "Initialize Image enter Width and Height: ";
      int width, height;
      cin >> width >> height;
      initialise_image(width, height);
      break;
    case 'S':
    case 's':
    {
      cout << "Enter File Name: ";
      string file_name;
      cin >> file_name;
      save_image(file_name);
    }
    break;
    case 'L':
    case 'l':
    {
      // HH TODO: User friendly prompt
      Color color;
      point p;
      cin >> p.x >> p.y >> color;
      color_point(p, color);
    }
    break;
    case 'V':
    case 'v':
    {
      // HH TODO: User friendly prompt
      Color color;
      int x, y1, y2;
      cin >> x >> y1 >> y2 >> color;
      color_vertical_line(x, y1, y2, color);
    }
    break;
    case 'H':
    case 'h':
    {
      // HH TODO: User friendly prompt
      Color color;
      int x1, x2, y;
      cin >> x1 >> x2 >> y >> color;
      color_horizontal_line(x1, x2, y, color);
    }
      break;
    case 'K':
    case 'k':
    {
      // HH TODO: User friendly prompt
      Color color;
      int x1, x2, y1, y2;
      cin >> x1 >> y1 >> x2 >> y2 >> color;
      color_box(x1, y1, x2, y2, color);
    }
      break;
    case 'F':
    case 'f':
    {
      // HH TODO: User friendly prompt
      Color color;
      point p;
      cin >> p.x >> p.y >> color;
      flood_fill(p, color);
    }
      break;
    case 'C':
    case 'c':
      // HH TODO: User friendly prompt and accept
      clear_image();
      break;
    default:
      cout << "Invalid input - try again...";
      break;
    }

    print_image(); // HH Printf the image after every command to see the result
  } while (true);

  return 0;
}

/* This function creates a blank image size width by height
where width and height are read from standard input respectively.*/
void initialise_image(int width, int height)
{
  /*first we create a vector of vectors (numRows+1)x(numColumns matrix+1). */
  image_array.clear();
  for (int i = 0; i < width + 1; i++) {
    image_array.push_back(vector<Color>());
  }

  /*then we initialize each element of it one by one*/
  for (int colNo = 0; colNo < width + 1; colNo++) {
    for (int rowNo = 0; rowNo < height + 1; rowNo++) {
      image_array[colNo].push_back(white);
    }

  }
}
/* resets all pixels of the image to color "O"*/
void clear_image() {
  /*we initialize each element of it one by one*/
  for (int y = 1; y < get_image_height() + 1; y++) {
    for (int x = 1; x < get_image_width() + 1; x++) {
      image_array[x][y] = white;
    }
  }
}

void print_image()
{
  system("cls");
  for (int y = 1; y < get_image_height() + 1; y++) {
    for (int x = 1; x < get_image_width() + 1; x++) {
      cout << image_array[x][y];
    }
    cout << "\n";
  }
}

/* saves the image in filename where filename is read from stdin*/
void save_image(string file_name) {
  cout << file_name << "\n";
  for (int y = 1; y < get_image_height() + 1; y++) {
    for (int x = 1; x < get_image_width() + 1; x++) {
      cout << image_array[x][y];
    }
    cout << "\n";
  }

}


int get_image_width() {
  return image_array.size() - 1;

}

int get_image_height() {
  return image_array[0].size() - 1;
}

//colors the pixel at point p.x, p.y in color color. 
void color_point(point p, Color color) {
  color_pixel(p.x, p.y, color);
}

void color_pixel(int x, int y, Color color) {
  image_array[x][y] = color;
}


void color_vertical_line(int x, int y1, int y2, Color color) {
  // HH TODO: Validation of input
  int y_adjustment;
  if (y1 > y2) {
    y_adjustment = -1;
  }
  else {
    y_adjustment = 1;
  }

  int y = y1;
  while (y != y2 + y_adjustment) {
    color_pixel(x, y, color);
    y += y_adjustment;
  }
}

void color_horizontal_line(int x1, int x2, int y, Color color) {
  // HH TODO: Validation of input 
  int x_adjustment;
  if (x1 > x2) {
    x_adjustment = -1;
  }
  else {
    x_adjustment = 1;
  }

  int x = x1;
  while (x != x2 + x_adjustment) {
    color_pixel(x, y, color);
    x += x_adjustment;
  }
}

//colors the box drawn between point x1, y1 and x2, y2. 
void color_box(int x1, int y1, int x2, int y2, Color color) { // HH Why not two points as arguments instead of for coordinates?
  // HH TODO: Validation of input
  int x_adjustment;
  if (x1 > x2) {
    x_adjustment = -1;
  }
  else {
    x_adjustment = 1;
  }

  int y_adjustment;
  if (y1 > y2) {
    y_adjustment = -1;
  }
  else {
    y_adjustment = 1;
  }


  int x = x1;
  int y = y1;

  while (x != x2 + x_adjustment) {
    while (y != y2 + y_adjustment) {
      color_pixel(x, y, color);
      y += y_adjustment;
    }
    x += x_adjustment;
    y = y1;
  }

}


Color get_point_color(point p) {
  return image_array[p.x][p.y];
}

//fills all pixels that share a border and color with p the color color. 
void flood_fill(point p, Color color) {
  // HH TODO: Validation of input

  //we will be using a queue to store points that have been colored but whose neighbours are yet to be. 
  vector <point> points_queue;

  //first we add the point p to our queue
  points_queue.push_back(p);
  Color original_color = get_point_color(p);
  point current_point;
  Color final_color = black;

  //if the original color of a point is the same as the new color then we return. Prevents infinite loop. 
  if (compare_colors(original_color, color) == 0) {
    return;
  }


  while (points_queue.size() > 0) {
    //get element in front of queue for processing and remove it from queue. 
    current_point = points_queue[0];
    points_queue.erase(points_queue.begin());

    //if the point shares a color with the original point then color it in the new color. 
    if (compare_colors(get_point_color(current_point), original_color) == 0) {
      color_point(current_point, color);
    }

    // add it's neighbours to the queue who's color matches original_color. 
    add_matching_neighbours(current_point, original_color, color, points_queue);

  }
}

//check if coordinates for point p lie in our image. 
bool is_valid_point(point p) {
  if (p.x >= 1 && p.x < get_image_width() + 1 && p.y >= 1 && p.y < get_image_height() + 1) {
    return true;
  }
  else {
    return false;
  }
}


//checks all direct neighbours of p(north, south, east, west) and adds
//those whose color is the original color to points_queue after coloring them. 
void add_matching_neighbours(point p, Color original_color, Color new_color, vector<point> &points_queue) {
  point left_neighbour, right_neighbour, upper_neighbour, lower_neighbour;
  left_neighbour.x = p.x - 1;
  left_neighbour.y = p.y;
  if (is_valid_point(left_neighbour) && compare_colors(get_point_color(left_neighbour), original_color) == 0) {
    points_queue.push_back(left_neighbour);
    color_point(left_neighbour, new_color);
  }

  right_neighbour.x = p.x + 1;
  right_neighbour.y = p.y;
  if (is_valid_point(right_neighbour) && compare_colors(get_point_color(right_neighbour), original_color) == 0) {
    points_queue.push_back(right_neighbour);
    color_point(right_neighbour, new_color);
  }

  upper_neighbour.x = p.x;
  upper_neighbour.y = p.y + 1;
  if (is_valid_point(upper_neighbour) && compare_colors(get_point_color(upper_neighbour), original_color) == 0) {
    points_queue.push_back(upper_neighbour);
    color_point(upper_neighbour, new_color);
  }

  lower_neighbour.x = p.x;
  lower_neighbour.y = p.y - 1;

  if (is_valid_point(lower_neighbour) && compare_colors(get_point_color(lower_neighbour), original_color) == 0) {
    points_queue.push_back(lower_neighbour);
    color_point(lower_neighbour, new_color);
  }

}