Merge lp:~myro-cpp-dev/myro-c++/smart_pointers into lp:myro-c++

[John Hoare]

[lp:~myro-cpp-dev/myro-c++/smart_pointers]

93. By John Hoare on 2011-07-22

Set the MyroSmartPointer.h to install in the CMakeLists.txt file.

=== modified file 'headers/CMakeLists.txt'
--- headers/CMakeLists.txt	2011-05-02 05:46:27 +0000
+++ headers/CMakeLists.txt	2011-07-22 02:32:35 +0000
@@ -1,5 +1,5 @@
 
 
-INSTALL_FILES(/include/Myro-Cpp FILES ColorPicture.h  Filter.h  GrayPicture.h MyroIO.h Myro.h MyroForwardDec.h Picture.h  Robot.h  Scribbler.h  VideoStream.h MyroCImg.h Graphics.h)
+INSTALL_FILES(/include/Myro-Cpp FILES Filter.h MyroSmartPointer.h MyroIO.h Myro.h MyroForwardDec.h Picture.h  Robot.h  Scribbler.h  VideoStream.h MyroCImg.h Graphics.h)
 
 add_subdirectory(CImg)

=== removed file 'headers/ColorPicture.h'
--- headers/ColorPicture.h	2011-04-17 13:57:45 +0000
+++ headers/ColorPicture.h	1970-01-01 00:00:00 +0000
@@ -1,38 +0,0 @@
-#ifndef __COLOR_PICTURE_H__
-#define __COLOR_PICTURE_H__
-
-#include <Picture.h>
-
-/** @addtogroup picture
- * @{
- */
-
-/// Object Representing a Color Picture (also used for Blob Pictures)
-class ColorPicture: public Picture {
-
-    public: 
-        //functions for students to use, if they need to create a picture.
-        ColorPicture();
-        ColorPicture(int width, int height);
-        ColorPicture(ColorPicture& pic);
-
-        //functions for scribbler code to use
-        ColorPicture(unsigned char * data, int width, int height);
-        ~ColorPicture();
-
-        virtual Pixel getPixel(int x, int y);
-        virtual void setPixel(int x, int y, Pixel pix);
-        virtual void show(std::string windowname);
-        virtual void show();
-        virtual Picture* clone();
-        virtual bool loadPicture(const char* filename);
-        virtual void savePicture(const char* filename);
-    private:
-        void loadInterlacedImage(unsigned char* img);
-        //myro_img image_data;
-};
-
-
-///@}
-
-#endif

=== modified file 'headers/Filter.h'
--- headers/Filter.h	2011-01-27 22:54:33 +0000
+++ headers/Filter.h	2011-07-22 02:32:35 +0000
@@ -40,7 +40,7 @@
      * is extended to allow for a filter to yield data from its
      * application. 
      */
-    void applyFilter(Picture*);
+    void applyFilter(PicturePtr);
 
     /**
      * The function used by applyFilter to actually process
@@ -48,7 +48,7 @@
      * if you do not overwrite this function, then the filter's
      * default behavior is to do nothing.
      */
-    virtual void filter(Picture*);
+    virtual void filter(PicturePtr);
 
 };
 

=== modified file 'headers/Graphics.h'
--- headers/Graphics.h	2011-06-23 02:35:48 +0000
+++ headers/Graphics.h	2011-07-22 02:32:35 +0000
@@ -9,15 +9,35 @@
  */
 
 
+/// Pixel from Picture.h and Color are the same.
+typedef Pixel Color;
+
 // Forward declartions
 class CImg_display;
 class GraphicsObject;
 class Point;
-
-typedef std::list<GraphicsObject*> GraphicsObjectList;
-typedef std::list<GraphicsObject*>::iterator GOL_reg;
-/// Pixel from Picture.h and Color are the same.
-typedef Pixel Color;
+class GraphWin;
+class DrawMessage;
+
+struct draw_message_common;
+struct point_draw_msg;
+struct bb_draw_msg;
+struct circle_draw_msg;
+struct line_draw_msg;
+struct polygon_draw_msg;
+struct text_draw_msg;
+struct base_msg;
+
+struct DrawMessage{
+    draw_message_common* common;
+    base_msg* data;
+    base_msg* extra;
+};
+
+typedef std::list<DrawMessage*> GraphicsObjectList;
+typedef std::list<DrawMessage*>::iterator GOL_reg;
+
+
 
 /**
  * Create a color "object" with the given r,g,b values
@@ -37,6 +57,7 @@
  */
 Color string_to_color(std::string color);
 
+
 /**
  * A GraphWin object represents a window on the screen where graphical images 
  * may be drawn. A program may define any number of GraphWins. Each GraphWin 
@@ -127,6 +148,7 @@
         // TODO: This should be private, but I'm getting errors here...
         void check_and_update();
     private: 
+        static bool draw_message(DrawMessage* msg, myro_img& canvas);
         GOL_reg draw(GraphicsObject* obj);
         void undraw(GOL_reg reg);
         void init();
@@ -146,6 +168,7 @@
  * class which can be drawn onto a GraphWin.
  */
 class GraphicsObject{
+
     public:
         GraphicsObject();
         GraphicsObject(Color fill, Color outline, int width);
@@ -154,12 +177,18 @@
         void setFill(Color color);
         /// Set the Fill of the shape
         void setFill(std::string color);
+        /// Get the Fill of the shape
+        Color getFill();
         /// Set the outline of the shape
         void setOutline(Color color);
         /// Set the outline of the shape
         void setOutline(std::string color);
+        /// Get the Outline of the shape
+        Color getOutline();
         /// Set the width of the outline around the shape
         void setWidth(int width);
+        /// Get the width of the outline around the shape
+        int getWidth();
         /// Draw the object to a given GraphWin
         void draw(GraphWin* canvas);
         /// Draw the object to a given GraphWin
@@ -178,12 +207,9 @@
         /// This function gets implemented by child classes to implement
         /// how to draw itself, the GraphWin calls this on all of its 
         /// registered GraphicObjects.
-        virtual void draw_command(myro_img& canvas)=0;
-        GraphWin* canvas;
-        GOL_reg registration;
-        Color fill;
-        Color outline;
-        int width;
+        //virtual void draw_command(myro_img& canvas)=0;
+        DrawMessage* drawData;
+//        boost::shared_ptr<GraphicsObject::DrawPair> drawdata;
     friend class GraphWin;
 };
 
@@ -208,10 +234,9 @@
         Point operator-(const Point &rhs);
         virtual void move(int dx, int dy);
     protected:
-        virtual void draw_command(myro_img& canvas);
+        //virtual void draw_command(myro_img& canvas);
     private:
-        int x;
-        int y;
+        point_draw_msg* data;
 };
 
 /**
@@ -226,8 +251,7 @@
         Point getP2();
         Point getCenter();
     protected:
-        Point p1;
-        Point p2;
+        bb_draw_msg* data;
 };
 
 /**
@@ -239,7 +263,7 @@
         Oval(Point p1, Point p2);
         Oval* clone();
     protected:
-        virtual void draw_command(myro_img& canvas);
+        //virtual void draw_command(myro_img& canvas);
 };
 
 /**
@@ -251,9 +275,8 @@
         Circle(Point center, int radius);
         int getRadius();
 //        virtual void draw_command(myro_img& canvas);
-    private:
-        Point centerPoint;
-        int radius;
+    protected:
+        circle_draw_msg* extra;
 };
 
 /// Represents a Rectangle
@@ -262,20 +285,19 @@
         /// Creates a Rectangle formed with the points p1 and p2.
         Rectangle(Point p1, Point p2);
     protected:
-        virtual void draw_command(myro_img& canvas);
+        //virtual void draw_command(myro_img& canvas);
 };
 
 /// Represents a Line, or Arrow
 class Line : public _BBox{
     public:
         /// Creates a Line (or Arrow) from p1 to p2
-        Line(Point p1, Point p2);
+        Line(Point p1, Point p2, std::string arrow_type="none");
         /// str can be "first", "last", "both", or none. Default is "none"
         void setArrow(std::string type);
     protected:
-        virtual void draw_command(myro_img& canvas);
-    private:
-        std::string arrow_type;
+        //virtual void draw_command(myro_img& canvas);
+        line_draw_msg* extra;
     friend class Polygon;
 };
 
@@ -288,12 +310,10 @@
         std::vector<Point> getPoints();
         virtual void move(int dx, int dy);
     protected:
-        virtual void draw_command(myro_img& canvas);
+        //virtual void draw_command(myro_img& canvas);
     private:
         std::vector<Point> update_points();
-        cil::CImg<int> pts;
-        std::vector<Point> points;
-        std::vector<Line> outline_lines;
+        polygon_draw_msg * data;
 };
 
 /// Used for displaying text on the GraphWin
@@ -333,15 +353,67 @@
         ///(default false)
         void drawBackground(bool background);
     protected:
-        virtual void draw_command(myro_img& canvas);
+        //virtual void draw_command(myro_img& canvas);
         virtual void move(int dx, int dy);
     private:
-        std::string text;
-        std::string font;
-        int size;
-        bool background;
-        std::string style;
-        Point anchor;
-};
+        text_draw_msg* data;
+};
+
+// Declaration of "draw messages"
+enum graphics_object_type{
+    GRAPHICS_OBJECT_POINT,
+    GRAPHICS_OBJECT_OVAL,
+    GRAPHICS_OBJECT_CIRCLE,
+    GRAPHICS_OBJECT_RECTANGLE,
+    GRAPHICS_OBJECT_LINE,
+    GRAPHICS_OBJECT_POLYGON,
+    GRAPHICS_OBJECT_TEXT
+};
+struct draw_message_common{
+    int refCount;
+    graphics_object_type type;
+    GOL_reg registration;
+    Color fill;
+    Color outline;
+    int width;
+    GraphWin* canvas;
+};
+
+struct base_msg{};
+
+struct point_draw_msg : public base_msg{
+    int x;
+    int y;
+};
+
+struct bb_draw_msg : public base_msg{
+    Point pt1;
+    Point pt2;
+};
+
+struct circle_draw_msg : public base_msg{
+    Point centerPoint;
+    int radius;
+};
+
+struct line_draw_msg : public base_msg{
+    std::string arrow_type;
+};
+
+struct polygon_draw_msg : public base_msg{
+    cil::CImg<int> pts;
+    std::vector<Point> points;
+    std::vector<Line> outline_lines;
+};
+
+struct text_draw_msg : public base_msg{
+    std::string text;
+    std::string font;
+    int size;
+    bool background;
+    std::string style;
+    Point anchor;
+};
+
 
 ///@}

=== removed file 'headers/GrayPicture.h'
--- headers/GrayPicture.h	2011-04-17 13:57:45 +0000
+++ headers/GrayPicture.h	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-#ifndef __GRAY_PICTURE_H__
-#define __GRAY_PICTURE_H__
-
-#include <Picture.h>
-
-/** @addtogroup picture
- * @{
- */
-
-/// Object Representing a Gray Picture 
-class GrayPicture: public Picture {
-
-    public: 
-
-        GrayPicture();
-        GrayPicture(int width, int height);
-        ~GrayPicture();
-
-        GrayPicture(unsigned char * data, int width, int height);
-        GrayPicture(GrayPicture& pic);
-
-        virtual Pixel getPixel(int x, int y);
-        virtual void  setPixel(int x, int y, Pixel pix);
-        virtual void  show(std::string windowname);
-        virtual void  show();
-        virtual Picture* clone();
-        virtual bool loadPicture(const char* filename);
-        virtual void savePicture(const char* filename);
-
-    private:
-        //myro_img image_data;
-};
-
-///@}
-
-#endif

=== added file 'headers/MyroSmartPointer.h'
--- headers/MyroSmartPointer.h	1970-01-01 00:00:00 +0000
+++ headers/MyroSmartPointer.h	2011-07-22 02:32:35 +0000
@@ -0,0 +1,58 @@
+#pragma once
+
+template <class T>
+class MyroSmartPointer {
+  private:
+    T* ptr;        // pointer to the value
+    long* count;   // shared number of owners
+
+  public:
+    // initialize pointer with existing pointer
+    // - requires that the pointer p is a return value of new
+    explicit MyroSmartPointer (T* p=0)
+     : ptr(p), count(new long(1)) {
+    }
+
+    // copy pointer (one more owner)
+    MyroSmartPointer (const MyroSmartPointer<T>& p) throw()
+     : ptr(p.ptr), count(p.count) {
+        ++*count;
+    }
+
+    // destructor (delete value if this was the last owner)
+    ~MyroSmartPointer () throw() {
+        dispose();
+    }
+
+    // assignment (unshare old and share new value)
+    MyroSmartPointer<T>& operator= (const MyroSmartPointer<T>& p) throw() {
+        if (this != &p) {
+            dispose();
+            ptr = p.ptr;
+            count = p.count;
+            ++*count;
+        }
+        return *this;
+    }
+
+    // access the value to which the pointer refers
+    T& operator*() const throw() {
+        return *ptr;
+    }
+    T* operator->() const throw() {
+        return ptr;
+    }
+
+    T* get() const{
+        return ptr;
+    }
+
+  private:
+    void dispose() {
+        if (--*count == 0) {
+             delete count;
+             delete ptr;
+        }
+    }
+    
+};

=== modified file 'headers/Picture.h'
--- headers/Picture.h	2011-04-17 13:57:45 +0000
+++ headers/Picture.h	2011-07-22 02:32:35 +0000
@@ -4,10 +4,13 @@
 #include<exception>
 #include<string>
 #include<MyroCImg.h>
+#include<MyroSmartPointer.h>
 /** @defgroup picture Picture Operations
  * The collection of all Picture Related commands and operations
  * @{
  */
+class Picture;
+typedef MyroSmartPointer<Picture> PicturePtr;
 
 /**
  * A pixel structure that respesents a single pixel of an Image. 
@@ -77,16 +80,18 @@
 
         Picture();
         Picture(int width, int height);
+        Picture(unsigned char * data, int channels, int width, int height);
+        Picture(Picture& pic);
         ~Picture();
 
         /**
          * @return A pixel struct representing the pixel at x,y
          */
-        virtual Pixel getPixel(int x, int y)=0;
+        virtual Pixel getPixel(int x, int y);
         /**
          * Set the value of a pixel at x,y to be the given pixel pix.
          */
-        virtual void  setPixel(int x, int y, Pixel pix)=0;
+        virtual void  setPixel(int x, int y, Pixel pix);
         /**
          * Display the picture on the screen.
          * 
@@ -98,7 +103,7 @@
          *      a new window, if it already exists, it will draw the image
          *      into that window. 
          */
-        virtual void  show(std::string windowname)=0;
+        virtual void show(std::string windowname);
         /**
          * Display the picture on the screen.
          *
@@ -106,7 +111,7 @@
          * window, before the program continues running.
          *
          */
-        virtual void show()=0;
+        virtual void show();
         /**
          * Get a pointer to the underlying memory representing the 
          * image.
@@ -127,7 +132,7 @@
          *
          * @return A clone of this picture
          */
-        virtual Picture* clone() = 0;
+        virtual PicturePtr clone();
 
         int getHeight();
         int getWidth();
@@ -140,7 +145,7 @@
          * @return True if load sucessful, false if fails (for wrong
          * colorspace, etc.)
          */
-        virtual bool loadPicture(const char* filename)=0;
+        virtual bool loadPicture(const char* filename);
 
         /**
          * Save an image to a file, only jpeg files are supported. 
@@ -149,7 +154,7 @@
          * @param filename The name of the file you save (without the .jpg 
          *  file extention)
          */
-        virtual void savePicture(const char* filename)=0;
+        virtual void savePicture(const char* filename);
 
         /**
          * Static method to print out an error message when a user has 
@@ -158,6 +163,8 @@
         static void out_of_bounds_error(int width, int height, 
                             int given_width, int given_height);
 
+    private:
+        void loadInterlacedImage(unsigned char* img);
     protected:
 
         //unsigned char * image_data;
@@ -165,24 +172,25 @@
         myro_img image_data;
         int width;
         int height;
+        int channels;
 };
 // functions added for lab 6 by Nick
-int getWidth(Picture *p);
-int getHeight(Picture *p);
-void show(Picture *p, std::string windowname);
-void show(Picture *p);
-Pixel getPixel(Picture *p, int x, int y);
-int getPixelValue_grey(Picture *p, int x, int y);
-void setPixel(Picture* p, int x, int y, Pixel pix);
-void setPixelColor(Picture *p, int x, int y, int R, int G, int B);
-Picture* clone(Picture* p);
+int getWidth(PicturePtr p);
+int getHeight(PicturePtr p);
+void show(PicturePtr p, std::string windowname);
+void show(PicturePtr p);
+Pixel getPixel(PicturePtr p, int x, int y);
+int getPixelValue_grey(PicturePtr p, int x, int y);
+void setPixel(PicturePtr p, int x, int y, Pixel pix);
+void setPixelColor(PicturePtr p, int x, int y, int R, int G, int B);
+PicturePtr clone(PicturePtr p);
 
 /// Create a picture object from a saved image
-Picture* loadPicture(const char* filename);
+PicturePtr loadPicture(const char* filename);
 /// Load an image into the given Picture object
-void loadPicture(Picture * p, const char* filename);
+void loadPicture(PicturePtr p, const char* filename);
 /// Save the Image to a file
-void savePicture(Picture * p, const char* filename);
+void savePicture(PicturePtr p, const char* filename);
 
 ///@}
 

=== modified file 'headers/Scribbler.h'
--- headers/Scribbler.h	2011-06-28 01:17:27 +0000
+++ headers/Scribbler.h	2011-07-22 02:32:35 +0000
@@ -470,7 +470,7 @@
 	 * @param type - Valid values, "color", "gray", and "blob"
 	 * @return unsigned char array containing the image information.
 	 */
-	Picture * takePicture(std::string type =  "color");
+	PicturePtr takePicture(std::string type =  "color");
 	
 	/*
 	 * Not yet functional. This version is intended to be used for

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2011-05-02 05:46:27 +0000
+++ src/CMakeLists.txt	2011-07-22 02:32:35 +0000
@@ -4,7 +4,7 @@
 
 GET_DIRECTORY_PROPERTY(myrocpp_jpeg_SRCS DIRECTORY ${PROJECT_SOURCE_DIR}/jpeg DEFINITION myrocpp_jpeg_SRCS)
 
-ADD_LIBRARY(myro-cpp SHARED Myro.cpp MyroInternals.cpp Scribbler.cpp serial.cpp Robot.cpp ColorPicture.cpp GrayPicture.cpp Picture.cpp VideoStream.cpp Filter.cpp Graphics.cpp xcolors.cpp jmemsrc.c)
+ADD_LIBRARY(myro-cpp SHARED Myro.cpp MyroInternals.cpp Scribbler.cpp serial.cpp Robot.cpp Picture.cpp VideoStream.cpp Filter.cpp Graphics.cpp xcolors.cpp jmemsrc.c)
 
 TARGET_LINK_LIBRARIES(myro-cpp ${GUI_LIBRARIES} ${PROJECT_BINARY_DIR}/jpeg/libmyrocpp_jpeg.a)
 

=== removed file 'src/ColorPicture.cpp'
--- src/ColorPicture.cpp	2011-05-09 21:30:54 +0000
+++ src/ColorPicture.cpp	1970-01-01 00:00:00 +0000
@@ -1,82 +0,0 @@
-#define cimg_use_jpeg
-#include "ColorPicture.h"
-#include <cstdio>
-#include "MyroInternals.h"
-
-using namespace std;
-
-ColorPicture::ColorPicture(): Picture() {};
-
-ColorPicture::ColorPicture(unsigned char * data, int width, int height)
-    : Picture(width, height){
-  
-    image_data.assign(width,height,1,3);
-    loadInterlacedImage(data);
-    this->width = width;
-    this->height = height;
-}
-
-ColorPicture::ColorPicture(int width, int height): 
-    Picture(width, height)
-{
-    image_data.assign(width,height,1,3,0);
-    this->width = width;
-    this->height = height;
-}
-
-ColorPicture::ColorPicture(ColorPicture& pic):
-    Picture(pic.width, pic.height){
-        image_data.assign(pic.image_data);
-}
-
-Pixel ColorPicture::getPixel(int x, int y) {
-    if ( x >= width || y >= height )
-        Picture::out_of_bounds_error(width,height,x,y);
-    Pixel result;
-    result.R = image_data(x,y,0,0);
-    result.G = image_data(x,y,0,1);
-    result.B = image_data(x,y,0,2);
-    return result;
-}
-
-void ColorPicture::setPixel(int x, int y, Pixel pix) {
-    if ( x >= width || y >= height )
-        Picture::out_of_bounds_error(width,height,x,y);
-    image_data(x,y,0,0) = pix.R;  
-    image_data(x,y,0,1) = pix.G;    
-    image_data(x,y,0,2) = pix.B;    
-}
-
-void ColorPicture::show(std::string windowname){
-    displayMan.set_picture_window(image_data, windowname.c_str());
-}
-
-void ColorPicture::show(){
-    const std::string windowname = "Color Picture";
-    displayMan.set_picture_window(image_data, windowname.c_str());
-    displayMan.block_on(windowname.c_str());
-}
-
-Picture* ColorPicture::clone(){
-    Picture* newpic = new ColorPicture(*this);
-    return newpic;
-}
-
-bool ColorPicture::loadPicture(const char* filename){
-  /* And we're done! */
-  image_data.load_jpeg(filename);
-  return true;
-}
-
-void ColorPicture::savePicture(const char* filename){
-  /* And we're done! */
-  image_data.save_jpeg(filename);
-}
-
-void ColorPicture::loadInterlacedImage(unsigned char* img){
-    cimg_forXY(image_data,x,y){
-        image_data(x,y,0,0) = img[y*width*3+x*3];
-        image_data(x,y,0,1) = img[y*width*3+x*3+1];
-        image_data(x,y,0,2) = img[y*width*3+x*3+2];
-    }
-}

=== modified file 'src/Filter.cpp'
--- src/Filter.cpp	2010-12-22 22:39:12 +0000
+++ src/Filter.cpp	2011-07-22 02:32:35 +0000
@@ -6,10 +6,10 @@
 Filter::~Filter() {
 }
 
-void Filter::applyFilter(Picture * image) {
+void Filter::applyFilter(PicturePtr image) {
 	this->filter(image);
 }
 
-void Filter::filter(Picture* image) {
+void Filter::filter(PicturePtr image) {
 	return;
 }

=== modified file 'src/Graphics.cpp'
--- src/Graphics.cpp	2011-06-21 13:38:57 +0000
+++ src/Graphics.cpp	2011-07-22 02:32:35 +0000
@@ -3,6 +3,7 @@
 #include <iostream>
 #include <assert.h>
 #include <cmath>
+#include <cstdlib>
 
 static unsigned char red[] = {255,0,0};
 
@@ -81,6 +82,8 @@
         thread = NULL;
         //delete thread;
     }
+    //while (!drawlist.empty())
+    //    undraw(drawlist.front()+1);
 }
 
 void GraphWin::init(){
@@ -147,14 +150,25 @@
 }
 
 GOL_reg GraphWin::draw(GraphicsObject* obj){
-    drawlist.push_back(obj);
+    drawlist.push_back(obj->drawData);
+    obj->drawData->common->refCount++;
     GOL_reg registration = --drawlist.end();
     this->check_and_update();
     return registration;
 }
 
 void GraphWin::undraw(GOL_reg reg){
+    DrawMessage* msg = *reg;
+    msg->common->refCount--;
     drawlist.erase(reg);
+    if ( msg->common->refCount <= 0 ){
+        std::cerr << "Cleaning up Object" << std::endl;
+        // Then we have to clean it up, because the object has gone away
+        if ( msg->extra  ) free( msg->extra );
+        if ( msg->data   ) free( msg->data );
+        if ( msg->common ) free( msg->common );
+        if ( msg         ) free( msg );
+    }
     this->check_and_update();
 }
 
@@ -170,7 +184,7 @@
         result = background;
     }
     for(GOL_reg it = drawlist.begin(); it != drawlist.end(); it++)
-        (*it)->draw_command(result);
+        assert(GraphWin::draw_message((*it), result));
 
     if ( thread )
         thread->change_image(result);
@@ -181,32 +195,204 @@
         update();
 }
 
+void draw_line(Point p1, Point p2, std::string arrow_type, int width, 
+        unsigned char* outlinecolor, myro_img& canvas){
+    if ( arrow_type == "first" ){
+        canvas.draw_arrow(p2.getX(), p2.getY(), p1.getX(), p1.getY(), outlinecolor);
+    }
+    else if ( arrow_type == "last" ){
+        canvas.draw_arrow(p1.getX(), p1.getY(), p2.getX(), p2.getY(), outlinecolor);
+    }
+    else if ( arrow_type == "both" ){
+        canvas.draw_arrow(p2.getX(), p2.getY(), p1.getX(), p1.getY(), outlinecolor);
+        canvas.draw_arrow(p1.getX(), p1.getY(), p2.getX(), p2.getY(), outlinecolor);
+    }
+    if ( width > 1 ){
+        int x0=p1.getX(),x1=p2.getX(),y0=p1.getY(),y1=p2.getY();
+        bool steep = abs(y0-y1) > abs(x0-x1);
+        if ( steep ){
+            swap(x0,y0);
+            swap(x1,y1);
+        }
+        if ( x0 > x1 ){
+            swap(x0,x1);
+            swap(y0,y1);
+        }
+        int deltax = x1-x0;
+        int deltay = abs(y1-y0);
+        float error = 0;
+        float deltaerr = (float)(deltay) / (deltax);
+        int ystep = y0 < y1 ? 1 : -1;
+        int y = y0;
+        // This is a sort of weird bresenhams thing where I sweep the end
+        // points so i can draw a "thick" line
+        for (int x = x0; x <= x1; x++){
+            if ( steep )
+                canvas.draw_circle(y,x,ceil(width/2.0),outlinecolor);
+            else
+                canvas.draw_circle(x,y,ceil(width/2.0),outlinecolor);
+            error += deltaerr;
+            if ( error >= 0.5 ){
+                y += ystep;
+                error -= 1.0;
+            }
+        }
+    }
+    else if (width == 1){
+        canvas.draw_line(p1.getX(), p1.getY(), p2.getX(), p2.getY(), outlinecolor);
+    }
+}
+
+std::vector<Point> update_points(polygon_draw_msg* msg, Color lineColor, int width){
+    Point p;
+    std::vector<Point> ret;
+    msg->outline_lines.clear();
+    msg->outline_lines.push_back(Line(msg->points[msg->points.size()-1],msg->points[0]));
+
+    for (int i = 0; i < (int)msg->points.size(); i++){
+        if (i+1 < (int)msg->points.size())
+            msg->outline_lines.push_back(Line(msg->points[i],msg->points[i+1]));
+        ret.push_back(msg->points[i]);
+        p = msg->points[i];
+        msg->pts(i,0) = p.getX();
+        msg->pts(i,1) = p.getY();
+    }
+    for (int i = 0; i < (int)msg->outline_lines.size(); i++){
+        msg->outline_lines[i].setWidth(width);
+        msg->outline_lines[i].setOutline(lineColor);
+    }
+    return ret;
+}
+
+bool GraphWin::draw_message(DrawMessage* msg, myro_img& canvas){
+    unsigned char color[] = {msg->common->fill.R, msg->common->fill.G, msg->common->fill.B};
+    unsigned char outlinecolor[] = {msg->common->outline.R, msg->common->outline.G, msg->common->outline.B};
+    int width = msg->common->width;
+    switch(msg->common->type){
+    case GRAPHICS_OBJECT_POINT:
+    {
+        point_draw_msg* data = (point_draw_msg*)data;
+        int x = data->x, y = data->y;
+        canvas(x,y,0,0) = msg->common->outline.R;
+        canvas(x,y,0,1) = msg->common->outline.G;
+        canvas(x,y,0,2) = msg->common->outline.B;
+    }
+    break;
+    case GRAPHICS_OBJECT_OVAL:
+    case GRAPHICS_OBJECT_CIRCLE:
+    {
+        bb_draw_msg* data = (bb_draw_msg*)msg->data;
+        Point center = Point((data->pt1.getX()+data->pt2.getX())/2, 
+                             (data->pt1.getY()+data->pt2.getY())/2);
+        int r0 = abs(center.getX() - data->pt2.getX());
+        int r1 = abs(center.getY() - data->pt2.getY());
+        if ( width ){
+            canvas.draw_ellipse(center.getX(),center.getY(), r0, r1, 0, outlinecolor);
+            canvas.draw_ellipse(center.getX(), center.getY(), r0-width, r1-width, 0, color);
+        }
+        else{
+            canvas.draw_ellipse(center.getX(),center.getY(), r0, r1, 0, color);
+        }
+    }
+    break;
+    case GRAPHICS_OBJECT_RECTANGLE:
+    {
+        bb_draw_msg* data = (bb_draw_msg*)msg->data;
+        if ( width ){
+            bb_draw_msg* data = (bb_draw_msg*)msg->data;
+            int leftx = std::min(data->pt1.getX(),data->pt2.getX())+width;;
+            int rightx = std::max(data->pt1.getX(), data->pt2.getX())-width;
+            int topy = std::min(data->pt1.getY(), data->pt2.getY())+width;
+            int bottomy = std::max(data->pt1.getY(), data->pt2.getY())-width;
+            canvas.draw_rectangle(data->pt1.getX(), data->pt1.getY(), 
+                                  data->pt2.getX(), data->pt2.getY(), outlinecolor);
+            canvas.draw_rectangle(leftx,topy,rightx,bottomy, color);
+        }
+        else{
+            canvas.draw_rectangle(data->pt1.getX(), data->pt1.getY(), 
+                                  data->pt2.getX(), data->pt2.getY(), color);
+        }
+    }
+    break;
+    case GRAPHICS_OBJECT_LINE:
+    {
+        std::string arrow_type = ((line_draw_msg*)(msg->extra))->arrow_type;
+        bb_draw_msg* data = (bb_draw_msg*)msg->data;
+        Point p1 = data->pt1;
+        Point p2 = data->pt2;
+        draw_line(p1, p2, arrow_type, width, outlinecolor, canvas);
+    }
+    break;
+    case GRAPHICS_OBJECT_POLYGON:
+    {
+        polygon_draw_msg* data = (polygon_draw_msg*)msg->data; 
+        std::vector<Point> debug = update_points(data,msg->common->outline,width);
+        canvas.draw_polygon(data->pts, color);
+        if ( width == 1 ){
+            canvas.draw_polygon(data->pts, outlinecolor, 1, ~0U);
+        } else if ( width > 1 ){
+            for (int i = 0; i < (int)data->outline_lines.size(); i++)
+                draw_line(data->outline_lines[i].getP1(), data->outline_lines[i].getP2(), 
+                          "none", width, outlinecolor, canvas);
+        }
+    }
+    break;
+    case GRAPHICS_OBJECT_TEXT:
+    {
+        text_draw_msg* data = (text_draw_msg*)msg->data;
+        if ( data->background ){
+            canvas.draw_text(data->anchor.getX(), data->anchor.getY(), data->text.c_str(), 
+                             outlinecolor, color, 1, data->size);
+        }
+        else{
+            canvas.draw_text(data->anchor.getX(), data->anchor.getY(), data->text.c_str(), 
+                             outlinecolor, 0, 1, data->size);
+        }
+    }
+    break;
+    default:
+    return false;
+    break;
+    }
+    return true;
+}
+
 // ====================
 // GraphicsObject
 // ====================
 GraphicsObject::GraphicsObject()
-: canvas(NULL),
-  fill(color_rgb(255,255,255)),
-  outline(color_rgb(0,0,0)),
-  width(1)
-{}
+{
+  drawData = new DrawMessage();
+  drawData->common = new draw_message_common();
+  //drawData = (DrawMessage*)malloc(sizeof(DrawMessage));
+  //drawData->common = (draw_message_common*)malloc(sizeof(draw_message_common));
+  drawData->common->refCount = 1;
+  drawData->common->canvas  = NULL;
+  drawData->common->fill    = color_rgb(255,255,255);
+  drawData->common->outline = color_rgb(0,0,0);
+  drawData->common->width   = 1;
+  drawData->data = drawData->extra = NULL;
+}
 
 GraphicsObject::GraphicsObject(Color fill, Color outline, int width)
-: canvas(NULL),
-  fill(fill),
-  outline(outline),
-  width(width)
-{}
+{
+  drawData = new DrawMessage();
+  drawData->common = new draw_message_common();
+  drawData->common->refCount = 1;
+  drawData->common->canvas  = NULL;
+  drawData->common->fill    = fill;
+  drawData->common->outline = outline;
+  drawData->common->width   = width;
+  drawData->data = drawData->extra = NULL;
+}
 
 GraphicsObject::~GraphicsObject(){
-    if (this->canvas)
-        this->undraw();
 }
 
 void GraphicsObject::setFill(Color color){
-    fill=color;
-    if ( this->canvas )
-        this->canvas->check_and_update();
+    drawData->common->fill=color;
+    if ( drawData->common->canvas )
+        drawData->common->canvas->check_and_update();
 }
 
 void GraphicsObject::setFill(std::string color){
@@ -214,10 +400,14 @@
     this->setFill(c);
 }
 
+Color GraphicsObject::getFill(){
+    return drawData->common->fill;
+}
+
 void GraphicsObject::setOutline(Color color){
-    outline=color;
-    if ( this->canvas )
-        this->canvas->check_and_update();
+    drawData->common->outline=color;
+    if ( drawData->common->canvas )
+        drawData->common->canvas->check_and_update();
 }
 
 void GraphicsObject::setOutline(std::string color){
@@ -225,17 +415,25 @@
     this->setOutline(c);
 }
 
+Color GraphicsObject::getOutline(){
+    return drawData->common->outline;
+}
+
 void GraphicsObject::setWidth(int width){
-    this->width = width;
-    if ( this->canvas )
-        this->canvas->check_and_update();
+    drawData->common->width = width;
+    if ( drawData->common->canvas )
+        drawData->common->canvas->check_and_update();
+}
+
+int GraphicsObject::getWidth(){
+    return drawData->common->width;
 }
 
 void GraphicsObject::draw(GraphWin* canvas){
-    if ( !this->canvas ){
-        this->canvas = canvas;
-        this->registration = this->canvas->draw(this);
-        assert( *registration == this );
+    if ( !drawData->common->canvas ){
+        drawData->common->canvas = canvas;
+        drawData->common->registration = drawData->common->canvas->draw(this);
+        //assert( *(drawData->common->registration) == this );
     }
     else {
         // Throw an exception or something
@@ -247,9 +445,9 @@
 }
 
 void GraphicsObject::undraw(){
-    if ( this->canvas ){
-        this->canvas->undraw(this->registration);
-        canvas = NULL;
+    if ( drawData->common->canvas ){
+        drawData->common->canvas->undraw(drawData->common->registration);
+        drawData->common->canvas = NULL;
     }
     else{
         // Throw an exception
@@ -259,28 +457,41 @@
 // ====================
 // Point
 // ====================
-Point::Point(): x(0),y(0){}
+Point::Point()
+{
+    drawData->common->type = GRAPHICS_OBJECT_POINT;
+    //data = (point_draw_msg*)malloc(sizeof(point_draw_msg));
+    data = new point_draw_msg();
+    drawData->data = data;
+    data->x = 0;
+    data->y = 0;
+}
 Point::Point(int x, int y)
-: x(x), y(y)
-{}
+{
+    drawData->common->type = GRAPHICS_OBJECT_POINT;
+    data = new point_draw_msg();
+    drawData->data = data;
+    data->x = x;
+    data->y = y;
+}
 /*
 Point::Point(const Point& p){
     this->x = p.x;
     this->y = p.y;
 }
 */
-Point* Point::clone(){ return new Point(x,y); }
-int Point::getX(){ return x; }
-int Point::getY(){ return y; }
+Point* Point::clone(){ return new Point(data->x,data->y); }
+int Point::getX(){ return data->x; }
+int Point::getY(){ return data->y; }
 void Point::move(int dx, int dy){
-    x += dx;
-    y += dy;
-    if ( this->canvas )
-        this->canvas->check_and_update();
+    data->x += dx;
+    data->y += dy;
+    if ( drawData->common->canvas )
+        drawData->common->canvas->check_and_update();
 }
 Point& Point::operator+=(const Point& rhs){
-    x += rhs.x;
-    y += rhs.y;
+    data->x += rhs.data->x;
+    data->y += rhs.data->y;
     return *this;
 }
 Point Point::operator+(const Point& other){
@@ -289,8 +500,8 @@
     return result;
 }
 Point& Point::operator-=(const Point& rhs){
-    x -= rhs.x;
-    y -= rhs.y;
+    data->x -= rhs.data->x;
+    data->y -= rhs.data->y;
     return *this;
 }
 Point Point::operator-(const Point& other){
@@ -298,32 +509,35 @@
     result -= other;
     return result;
 }
+/*
 void Point::draw_command(myro_img& canvas){
-    canvas(x,y,0,0) = outline.R;
-    canvas(x,y,0,1) = outline.G;
-    canvas(x,y,0,2) = outline.B;
 }
+*/
 
 // ====================
 // _BBox
 // ====================
-_BBox::_BBox(Point p1, Point p2)
-: p1(p1), p2(p2)
-{}
+_BBox::_BBox(Point p1, Point p2){
+    //data = (bb_draw_msg*)malloc(sizeof(bb_draw_msg));
+    data = new bb_draw_msg();
+    drawData->data = data;
+    data->pt1 = p1;
+    data->pt2 = p2;
+}
 
 void _BBox::move(int dx, int dy){
     Point d(dx,dy);
-    this->p1 += d;
-    this->p2 += d;
-    if ( this->canvas ) 
-        this->canvas->check_and_update();
+    data->pt1 += d;
+    data->pt2 += d;
+    if ( drawData->common->canvas ) 
+        drawData->common->canvas->check_and_update();
 }
 
-Point _BBox::getP1(){ return p1; };
-Point _BBox::getP2(){ return p2; };
+Point _BBox::getP1(){ return data->pt1; };
+Point _BBox::getP2(){ return data->pt2; };
 Point _BBox::getCenter(){ 
-    return Point((p1.getX()+p2.getX())/2, 
-                 (p1.getY()+p2.getY())/2);
+    return Point((data->pt1.getX()+data->pt2.getX())/2, 
+                 (data->pt1.getY()+data->pt2.getY())/2);
 }
 
 // ====================
@@ -332,37 +546,28 @@
 Oval::Oval(Point p1, Point p2)
 : _BBox(p1,p2)
 {
+    drawData->common->type = GRAPHICS_OBJECT_OVAL;
 }
 
 Oval* Oval::clone(){
-    return new Oval(this->p1, this->p2);
-}
-
-void Oval::draw_command(myro_img& canvas){
-    Point center = this->getCenter();
-    unsigned char color[] = {fill.R, fill.G, fill.B};
-    unsigned char outlinecolor[] = {outline.R, outline.G, outline.B};
-    int r0 = abs(center.getX() - this->getP2().getX());
-    int r1 = abs(center.getY() - this->getP2().getY());
-    if ( this->width ){
-        canvas.draw_ellipse(center.getX(),center.getY(), r0, r1, 0, outlinecolor);
-        canvas.draw_ellipse(center.getX(), center.getY(), r0-width, r1-width, 0, color);
-    }
-    else
-        canvas.draw_ellipse(center.getX(),center.getY(), r0, r1, 0, color);
+    return new Oval(data->pt1, data->pt2);
 }
 
 // ====================
 // Circle
 // ====================
 Circle::Circle(Point center, int radius)
-: Oval(Point(center.getX()-radius,center.getY()-radius),Point(center.getX()+radius,center.getY()+radius)), 
-  centerPoint(center),
-  radius(radius)
-{}
+: Oval(Point(center.getX()-radius,center.getY()-radius),Point(center.getX()+radius,center.getY()+radius))
+{
+    drawData->common->type = GRAPHICS_OBJECT_CIRCLE;
+    extra = new circle_draw_msg();
+    drawData->extra = extra;
+    extra->centerPoint = center;
+    extra->radius = radius;
+}
 
 int Circle::getRadius(){
-    return radius;
+    return extra->radius;
 }
 /*
 void Circle::draw_command(myro_img& canvas){
@@ -375,183 +580,86 @@
 // ====================
 Rectangle::Rectangle(Point p1, Point p2)
 : _BBox(p1,p2)
-{}
-
-void Rectangle::draw_command(myro_img& canvas){
-    unsigned char color[] = {fill.R, fill.G, fill.B};
-    if ( this->width ){
-        unsigned char outlinecolor[] = {outline.R, outline.G, outline.B};
-        int leftx = std::min(p1.getX(),p2.getX())+width;;
-        int rightx = std::max(p1.getX(), p2.getX())-width;
-        int topy = std::min(p1.getY(), p2.getY())+width;
-        int bottomy = std::max(p1.getY(), p2.getY())-width;
-        canvas.draw_rectangle(p1.getX(), p1.getY(), p2.getX(), p2.getY(), outlinecolor);
-        canvas.draw_rectangle(leftx,topy,rightx,bottomy, color);
-    }
-    else{
-        canvas.draw_rectangle(p1.getX(), p1.getY(), p2.getX(), p2.getY(), color);
-    }
+{
+    drawData->common->type = GRAPHICS_OBJECT_RECTANGLE;
 }
 
 // ====================
 // Line
 // ====================
-Line::Line(Point p1, Point p2)
-: _BBox(p1,p2),
-  arrow_type("none")
-{}
+Line::Line(Point p1, Point p2, std::string arrow_type)
+: _BBox(p1,p2)
+{
+    drawData->common->type = GRAPHICS_OBJECT_LINE;
+    extra = new line_draw_msg();
+    drawData->extra = extra;
+    extra->arrow_type = arrow_type;
+}
 
 void Line::setArrow(std::string type){
     if ( type == "first" ||
          type == "last"  ||
          type == "both"  ||
          type == "none" )
-        this->arrow_type = type;
+        extra->arrow_type = type;
     else{
         std::cerr << "Line::setArrow(): Bad Type: " << type << std::endl;
         // TODO: Throw Exception
     }
 }
 
-void Line::draw_command(myro_img& canvas){
-    unsigned char color[] = {outline.R, outline.G, outline.B};
-    //std::cerr<< "color.R: " << (int)color[0] << "color.G: " << (int)color[1] << "color.B: " << (int)color[2] << std::endl;
-    if ( arrow_type == "first" ){
-        canvas.draw_arrow(p2.getX(), p2.getY(), p1.getX(), p1.getY(), color);
-    }
-    else if ( arrow_type == "last" ){
-        canvas.draw_arrow(p1.getX(), p1.getY(), p2.getX(), p2.getY(), color);
-    }
-    else if ( arrow_type == "both" ){
-        canvas.draw_arrow(p2.getX(), p2.getY(), p1.getX(), p1.getY(), color);
-        canvas.draw_arrow(p1.getX(), p1.getY(), p2.getX(), p2.getY(), color);
-    }
-    if ( this->width > 1 ){
-        int x0=p1.getX(),x1=p2.getX(),y0=p1.getY(),y1=p2.getY();
-        bool steep = abs(y0-y1) > abs(x0-x1);
-        if ( steep ){
-            swap(x0,y0);
-            swap(x1,y1);
-        }
-        if ( x0 > x1 ){
-            swap(x0,x1);
-            swap(y0,y1);
-        }
-        int deltax = x1-x0;
-        int deltay = abs(y1-y0);
-        float error = 0;
-        float deltaerr = (float)(deltay) / (deltax);
-        int ystep = y0 < y1 ? 1 : -1;
-        int y = y0;
-        // This is a sort of weird bresenhams thing where I sweep the end
-        // points so i can draw a "thick" line
-        for (int x = x0; x <= x1; x++){
-            if ( steep )
-                canvas.draw_circle(y,x,ceil(this->width/2.0),color);
-            else
-                canvas.draw_circle(x,y,ceil(this->width/2.0),color);
-            error += deltaerr;
-            if ( error >= 0.5 ){
-                y += ystep;
-                error -= 1.0;
-            }
-        }
-    }
-    else if (this->width == 1){
-        canvas.draw_line(p1.getX(), p1.getY(), p2.getX(), p2.getY(), color);
-    }
-}
-
 // ====================
 // Polygon
 // ====================
 Polygon::Polygon(std::vector<Point> points)
-:  pts(points.size(),2), points(points)
 {
+    drawData->common->type = GRAPHICS_OBJECT_POLYGON;
+    data = new polygon_draw_msg();
+    drawData->data = data;
+    data->pts.assign(points.size(),2);
+    data->points = points;
 }
 
 std::vector<Point> Polygon::getPoints(){
-    return points;
-}
-
-std::vector<Point> Polygon::update_points(){
-    Point p;
-    std::vector<Point> ret;
-    outline_lines.clear();
-    outline_lines.push_back(Line(points[points.size()-1],points[0]));
-
-    for (int i = 0; i < (int)points.size(); i++){
-        if (i+1 < (int)points.size())
-            outline_lines.push_back(Line(points[i],points[i+1]));
-        ret.push_back(points[i]);
-        p = this->points[i];
-        pts(i,0) = p.getX();
-        pts(i,1) = p.getY();
-    }
-    for (int i = 0; i < (int)outline_lines.size(); i++)
-        outline_lines[i].setWidth(this->width);
-    return ret;
-}
-
-void Polygon::draw_command(myro_img& canvas){
-    unsigned char color[] = {fill.R, fill.G, fill.B};
-    unsigned char border[] = {outline.R, outline.G, outline.B};
-    
-    // TODO: I feel like this is somewhat of an expensive operation O(N) for
-    // the number of points, this should probably only be done when the points
-    // actually need to be updated when they've changed.
-    std::vector<Point> debug = update_points();
-
-    //canvas.draw_polygon(pts_bdr, border, 1, ~0U);
-    //canvas.draw_polygon(pts_bdr, border, 1, ~0U);
-    //canvas.draw_polygon(pts, color);
-    canvas.draw_polygon(pts, color);
-    if ( this->width == 1 ){
-        canvas.draw_polygon(pts, border, 1, ~0U);
-    } else if ( this->width > 1 ){
-        for (int i = 0; i < (int)outline_lines.size(); i++)
-            outline_lines[i].draw_command(canvas);
-    }
-    /*
-    std::cerr << debug.size() << " debug points" << std::endl;
-    for (int i = 0; i < (int)debug.size(); i++){
-        canvas.draw_rectangle(debug[i].getX()-2,debug[i].getY()-2,debug[i].getX()+2,debug[i].getY()+2, red);
-    }
-    */
+    return data->points;
 }
 
 void Polygon::move(int dx, int dy){
     Point d(dx,dy);
-    for (int i = 0; i < (int)points.size(); i++){
-        points[i] += d;
+    for (int i = 0; i < (int)data->points.size(); i++){
+        data->points[i] += d;
     }
-    if ( this->canvas ) 
-        this->canvas->check_and_update();
+    if ( drawData->common->canvas ) 
+        drawData->common->canvas->check_and_update();
 }
 
 // ====================
 // Text
 // ====================
 Text::Text(Point anchor, std::string text)
-: GraphicsObject(color_rgb(0,0,0), color_rgb(0,0,0), 0),
-  text(text),
-  font("helvetica"),
-  size(13),
-  background(false),
-  style("normal"),
-  anchor(anchor)
-{}
+: GraphicsObject(color_rgb(0,0,0), color_rgb(0,0,0), 0)
+{
+    drawData->common->type = GRAPHICS_OBJECT_TEXT;
+    data = new text_draw_msg();
+    drawData->data = data;
+    data->text = text;
+    data->font = "helvetica";
+    data->size = 13;
+    data->background = false;
+    data->style = "normal";
+    data->anchor = anchor;
+}
 
-std::string Text::getText(){ return text; }
-void Text::setText(std::string text){ this->text = text; }
-Point Text::getAnchor(){ return anchor; }
-void Text::setAnchor(Point anchor){ this->anchor=anchor; }
+std::string Text::getText(){ return data->text; }
+void Text::setText(std::string text){ data->text = text; }
+Point Text::getAnchor(){ return data->anchor; }
+void Text::setAnchor(Point anchor){ data->anchor=anchor; }
 void Text::setFace(std::string font){
     // TODO
     //Joke's On you because I don't support any font other than the default!
 }
 void Text::setSize(int size){
-    this->size = size;
+    data->size = size;
 }
 
 void Text::setStyle(std::string style){
@@ -562,24 +670,11 @@
 void Text::setTextColor(std::string color){ this->setOutline(color); }
 
 void Text::drawBackground(bool background){
-    this->background = background;
-}
-
-void Text::draw_command(myro_img& canvas){
-    unsigned char background[] = {fill.R, fill.G, fill.B};
-    unsigned char text_color[] = {outline.R, outline.G, outline.B};
-    if ( this->background ){
-        canvas.draw_text(anchor.getX(), anchor.getY(), text.c_str(), 
-                         text_color, background, 1, size);
-    }
-    else{
-        canvas.draw_text(anchor.getX(), anchor.getY(), text.c_str(), 
-                         text_color, 0, 1, size);
-    }
+    data->background = background;
 }
 
 void Text::move(int dx, int dy){
-    anchor += Point(dx,dy);
-    if ( this->canvas )
-        this->canvas->check_and_update();
+    data->anchor += Point(dx,dy);
+    if ( drawData->common->canvas )
+        drawData->common->canvas->check_and_update();
 }

=== removed file 'src/GrayPicture.cpp'
--- src/GrayPicture.cpp	2011-05-09 21:30:54 +0000
+++ src/GrayPicture.cpp	1970-01-01 00:00:00 +0000
@@ -1,73 +0,0 @@
-#define cimg_use_jpeg
-#include "GrayPicture.h"
-#include <cstdio>
-#include "MyroInternals.h"
-
-using namespace std;
-
-GrayPicture::GrayPicture() : Picture() {};
-
-GrayPicture::GrayPicture(int width, int height) 
-:Picture(width, height){
-    image_data.assign(width,height,1,1,0) ;
-    this->width = width;
-    this->height = height;
-}
-
-GrayPicture::GrayPicture(unsigned char * data, int width, int height)
-:Picture(width, height){
-    image_data.assign(data,width,height,1,1) ;
-    this->width = width;
-    this->height = height;
-}
-
-GrayPicture::GrayPicture(GrayPicture& pic)
-:Picture(pic.width, pic.height){
-    image_data.assign(pic.image_data);
-    this->width = pic.width;
-    this->height = pic.height;
-
-    image_data.assign(pic.image_data);
-}
-
-Pixel GrayPicture::getPixel(int x, int y) {
-    if ( x >= width || y >= height )
-        Picture::out_of_bounds_error(width,height,x,y);
-    Pixel result;
-    result.R = image_data(x,y,0,0);
-    result.G = result.R;
-    result.B = result.R;
-    return result;
-}
-
-void GrayPicture::setPixel(int x, int y, Pixel pix) {
-    if ( x >= width || y >= height )
-        Picture::out_of_bounds_error(width,height,x,y);
-    image_data(x,y,0,0) = pix.R;
-}
-
-Picture* GrayPicture::clone(){
-    Picture* newpic = new GrayPicture(*this);
-    return newpic;
-}
-
-void GrayPicture::show(std::string windowname){
-    displayMan.set_picture_window(image_data, windowname.c_str());
-}
-
-void GrayPicture::show(){
-    const std::string windowname("Gray Picture");
-    displayMan.set_picture_window(image_data, windowname.c_str());
-    displayMan.block_on(windowname.c_str());
-}
-
-bool GrayPicture::loadPicture(const char* filename){
-  image_data.load_jpeg(filename);
-  /* And we're done! */
-  return true;
-}
-
-void GrayPicture::savePicture(const char* filename){
-  image_data.save_jpeg(filename);
-  /* And we're done! */
-}

=== modified file 'src/Picture.cpp'
--- src/Picture.cpp	2011-04-17 13:57:45 +0000
+++ src/Picture.cpp	2011-07-22 02:32:35 +0000
@@ -1,6 +1,5 @@
 #include "Picture.h"
-#include "ColorPicture.h"
-#include "GrayPicture.h"
+#include "MyroInternals.h"
 #include <iostream>
 #include <sstream>
 #include <cstdlib>
@@ -12,11 +11,97 @@
 Picture::Picture(int width, int height) {
     this->width =  width;
     this->height = height;
+    this->channels = 3;
+}
+
+Picture::Picture(unsigned char * data, int channels, int width, int height){
+    this->width = width;
+    this->height = height;
+    this->channels = channels;
+  
+    if ( channels == 3 ){
+        image_data.assign(width,height,1,channels);
+        loadInterlacedImage(data);
+    } else {
+        image_data.assign(data,width,height,1,channels);
+    }
+}
+
+Picture::Picture(Picture& pic)
+{
+    image_data.assign(pic.image_data);
+    this->width = pic.width;
+    this->height = pic.height;
+    this->channels = pic.channels;
 }
 
 Picture::~Picture() {
 }
 
+Pixel Picture::getPixel(int x, int y) {
+    if ( x >= width || y >= height )
+        Picture::out_of_bounds_error(width,height,x,y);
+    Pixel result;
+    if ( channels == 3 ){
+        result.R = image_data(x,y,0,0);
+        result.G = image_data(x,y,0,1);
+        result.B = image_data(x,y,0,2);
+    }
+    else{
+        result.R = result.G = result.B = image_data(x,y,0,0);
+    }
+    return result;
+}
+
+void Picture::setPixel(int x, int y, Pixel pix) {
+    if ( x >= width || y >= height )
+        Picture::out_of_bounds_error(width,height,x,y);
+    if ( channels == 3 ){
+        image_data(x,y,0,0) = pix.R;  
+        image_data(x,y,0,1) = pix.G;    
+        image_data(x,y,0,2) = pix.B;    
+    } else {
+        image_data(x,y,0,0) = pix.R;  
+    }
+}
+
+void Picture::show(std::string windowname){
+    displayMan.set_picture_window(image_data, windowname.c_str());
+}
+
+void Picture::show(){
+    const std::string windowname = "Picture";
+    displayMan.set_picture_window(image_data, windowname.c_str());
+    displayMan.block_on(windowname.c_str());
+}
+
+// TODO: Implement this!
+PicturePtr Picture::clone(){
+    PicturePtr p(new Picture(*this));
+    //Picture* newpic = new ColorPicture(*this);
+    //return newpic;
+    return p;
+}
+
+bool Picture::loadPicture(const char* filename){
+  /* And we're done! */
+  image_data.load_jpeg(filename);
+  return true;
+}
+
+void Picture::savePicture(const char* filename){
+  /* And we're done! */
+  image_data.save_jpeg(filename);
+}
+
+void Picture::loadInterlacedImage(unsigned char* img){
+    cimg_forXY(image_data,x,y){
+        image_data(x,y,0,0) = img[y*width*3+x*3];
+        image_data(x,y,0,1) = img[y*width*3+x*3+1];
+        image_data(x,y,0,2) = img[y*width*3+x*3+2];
+    }
+}
+
 int Picture::getHeight() {
     return height;
 }
@@ -64,43 +149,43 @@
 */
 
 // Below are the C-style Wrappers for the objects...
-int getWidth(Picture *p)
+int getWidth(PicturePtr p)
 {
         return p->getWidth();
 }
 
-int getHeight(Picture *p)
+int getHeight(PicturePtr p)
 {
         return p->getHeight();
 }
 
-void show(Picture *p, std::string windowname)
+void show(PicturePtr p, std::string windowname)
 {
     p->show(windowname);
 }
 
-void show(Picture *p)
+void show(PicturePtr p)
 {
     p->show();
 }
 
-Pixel getPixel(Picture *p, int x, int y)
+Pixel getPixel(PicturePtr p, int x, int y)
 {
         return p->getPixel(x, y);
 }
 
-int getPixelValue_grey(Picture *p, int x, int y)
+int getPixelValue_grey(PicturePtr p, int x, int y)
 {
         Pixel P=p->getPixel(x,y);
         return P.R;
 }
 
-void setPixel(Picture* p, int x, int y, Pixel pix)
+void setPixel(PicturePtr p, int x, int y, Pixel pix)
 {
         p->setPixel(x, y, pix);
 }
 
-void setPixelColor(Picture *p, int x, int y, int R, int G, int B)
+void setPixelColor(PicturePtr p, int x, int y, int R, int G, int B)
 {
         Pixel P=p->getPixel(x,y);
         P.R=R;
@@ -109,26 +194,22 @@
         p->setPixel(x, y, P);
 }
 
-Picture* loadPicture(const char* filename){
-    Picture* ret = new ColorPicture();
-    if ( ret->loadPicture(filename) )
-        return ret;
-    delete ret;
-    ret = new GrayPicture();
-    if ( ret->loadPicture(filename) )
-        return ret;
-    
-    return NULL;
+PicturePtr loadPicture(const char* filename){
+    PicturePtr ret(new Picture());
+    if ( ret->loadPicture(filename) )
+        return ret;
+    // TODO: return NULL;
+    return ret;
 }
 
-void loadPicture(Picture * p, const char* filename){
+void loadPicture(PicturePtr p, const char* filename){
     p->loadPicture(filename);
 }
-void savePicture(Picture * p, const char* filename){
+void savePicture(PicturePtr p, const char* filename){
     p->savePicture(filename);
 }
 
-Picture* clone(Picture* p){
+PicturePtr clone(PicturePtr p){
     return p->clone();
 }
 // END C-style Wrappers for the objects...

=== modified file 'src/Scribbler.cpp'
--- src/Scribbler.cpp	2011-03-26 19:06:15 +0000
+++ src/Scribbler.cpp	2011-07-22 02:32:35 +0000
@@ -8,8 +8,6 @@
 #include <iostream>
 #include <cstring>
 #include <cstdio>
-#include "ColorPicture.h"
-#include "GrayPicture.h"
 #include "VideoStream.h"
 #include <boost/thread/mutex.hpp>
 
@@ -1224,7 +1222,9 @@
                 retval = (void*)ptr_bright;
             }
             else if( sensor == "picture" ) {
-                retval = (void*)this->takePicture(position.at(0));
+                retval = NULL;
+                std::cerr << "Use takePicture() instead, don't use get(\"picture\")" << std::endl;
+                //retval = (void*)this->takePicture(position.at(0));
             }
             else 
                 std::cout << "invalid sensor name: " << sensor << std::endl;
@@ -1784,47 +1784,47 @@
     return dataV;
 }
 
-Picture * Scribbler::takePicture(std::string type) {
+PicturePtr Scribbler::takePicture(std::string type) {
     unsigned char * imageBuffer = NULL;
     int size;
 
-    Picture * image = NULL;
+    PicturePtr image;
 
     // Don't take a picture if we're not connected.
     if ( con == NULL )
-        return NULL;
+        return image;
 
     //pthread_mutex_lock(this->image_lock);
     boost::mutex::scoped_lock l(*(this->image_lock));
     if(type == "color") {
         imageBuffer = grab_array_rgb();
-        image = new ColorPicture(imageBuffer, 256, 192);
+        image = PicturePtr(new Picture(imageBuffer, 3, 256, 192));
     }
     else if( type == "gray" || type == "grey") {
         conf_window(0, 1, 0, 255, 191, 2, 2);
         imageBuffer = grab_gray_array();
         conf_gray_window(0, 2, 0, 128, 191, 1, 1);
-        image = new GrayPicture(imageBuffer, 256, 192);
+        image = PicturePtr(new Picture(imageBuffer, 1, 256, 192));
     }
     else if( type == "blob" ) {
         imageBuffer = grab_blob_array();
-        image = new ColorPicture(imageBuffer, 256, 192);
+        image = PicturePtr(new Picture(imageBuffer, 3, 256, 192));
     }
     else if( type == "jpeg" ) {
         imageBuffer = grab_jpeg_color(1,size);
-        image = new ColorPicture(imageBuffer, 256, 192);
+        image = PicturePtr(new Picture(imageBuffer, 3, 256, 192));
     }
     else if( type == "jpeg-fast") {
         imageBuffer = grab_jpeg_color(0,size);
-        image = new ColorPicture(imageBuffer, 256, 192);
+        image = PicturePtr(new Picture(imageBuffer, 3, 256, 192));
     }
     else if( type == "grayjpeg") {
         imageBuffer = grab_jpeg_gray(1,size);
-        image = new GrayPicture(imageBuffer, 256, 192);
+        image = PicturePtr(new Picture(imageBuffer, 1, 256, 192));
     }
     else if( type == "grayjpeg-fast" ) {
         imageBuffer = grab_jpeg_gray(0,size);
-        image = new GrayPicture(imageBuffer, 256, 192);
+        image = PicturePtr(new Picture(imageBuffer, 1, 256, 192));
     }
     else { 
         std::cerr << "Scribbler::takePicture(): Warning: Unknown picture type: " << type << std::endl;

=== modified file 'src/VideoStream.cpp'
--- src/VideoStream.cpp	2011-05-09 21:30:54 +0000
+++ src/VideoStream.cpp	2011-07-22 02:32:35 +0000
@@ -62,8 +62,8 @@
 }
 
 void DisplayThread::run() {
-    Picture* img_cur=NULL;
-    Picture* img_new=NULL;
+    PicturePtr img_cur;
+    PicturePtr img_new;
 
     while(!this->stopRequested){
         //std::cerr << "DisplayThread::run()" << std::endl;
@@ -84,7 +84,7 @@
             }
         }
         // If we got a NULL picture, shut down thread
-        if ( img_new == NULL )
+        if ( img_new.get() == NULL )
             this->stopRequested = true;
 
         if ( this->stopRequested ) break;
@@ -100,9 +100,10 @@
 
         show(img_new, "Video Stream");
 
+        /*
         if ( img_cur != NULL ){
             delete img_cur;
-        }
+        }*/
         img_cur = img_new;
 
         //boost::thread::yield();

=== modified file 'test/graphics/circles.cpp'
--- test/graphics/circles.cpp	2011-05-02 05:46:27 +0000
+++ test/graphics/circles.cpp	2011-07-22 02:32:35 +0000
@@ -1,26 +1,35 @@
 #include <Myro.h>
 
-static const int num_of_circles = 1000;
-static const int width=500;
-static const int height=500;
 static const int max_circle_radius=50;
 
+Color makeColor(){
+    //creates a new color using random RGB values
+    int red   = rand()%256;
+    int green = rand()%256;
+    int blue  = rand()%256;
+    return color_rgb(red, green,blue);
+}
+
 int main(){
-    GraphWin win("Circles", width,height);
-    Circle* c[num_of_circles];
-    for (int i = 0; i < num_of_circles; i++){
-        int x=rand()%width;
-        int y=rand()%height;
-        int r=rand()%max_circle_radius;
-        int R=rand()%255;
-        int G=rand()%255;
-        int B=rand()%255;
-        c[i] = new Circle(Point(x,y),r);
-        c[i]->setFill(color_rgb(R,G,B));
-        c[i]->draw(win);
-        wait(0.01);
+    const int width=500;
+    const int height=500;
+    GraphWin myCanvas("Circles",width,height);
+    myCanvas.setBackground("white");
+    // draw a bunch of random 
+    // circles with random 
+    // colors.
+    int N = 500;
+    for (int i = 0; i < N; i++) {
+        // pick random center 
+        // point and radius 
+        // in the window
+        int x = rand()%width;
+        int y = rand()%height;
+        int r = rand()%20 + 5;//randrange(5, 25);
+        Circle c(Point(x, y), r);
+        // select a random color
+        c.setFill(makeColor());
+        c.draw(myCanvas);
     }
-    wait(5);
-    win.close();
-    win.waitWinClosed();
+    myCanvas.waitWinClosed();
 }

=== modified file 'test/take_snapshot.cpp'
--- test/take_snapshot.cpp	2011-04-09 20:14:25 +0000
+++ test/take_snapshot.cpp	2011-07-22 02:32:35 +0000
@@ -43,7 +43,7 @@
         if(quit == "E" || quit == "Exit" || quit == "e" || quit == "exit")
             close = 1;
     }
-    Picture* pic = robot.takePicture( argv[1] );
+    PicturePtr pic = robot.takePicture( argv[1] );
     pic->savePicture("snapshot.jpg");
     video.endStream();
     //sleep(5);

=== modified file 'test/test_blob.cpp'
--- test/test_blob.cpp	2010-12-22 23:55:57 +0000
+++ test/test_blob.cpp	2011-07-22 02:32:35 +0000
@@ -17,7 +17,7 @@
         ~PictureInPicture(){}
 
         virtual void filter(Picture* image) {
-            Picture* colorImage = rob.takePicture("jpeg");
+            PicturePtr colorImage = rob.takePicture("jpeg");
 
             int height = image->getHeight();
             int width = image->getWidth();
@@ -34,7 +34,6 @@
                 }
             }
 
-            delete colorImage;
         }
 
     protected:
@@ -142,8 +141,8 @@
     int train = 0;
     string toTrain;
 
-    Picture* showpic = robot.takePicture();
-    Picture* trainpic = showpic->clone();
+    PicturePtr showpic = robot.takePicture();
+    PicturePtr trainpic = showpic->clone();
     while(!train) {
         for(int h = y1; h < y2; h++) {
             for(int w = x1; w < x2; w++) {
@@ -158,9 +157,6 @@
         cin >> toTrain;
         if(toTrain == "y" || toTrain == "yes")
             train = 1;
-        else {
-            delete showpic;
-        }
     }
     robot.conf_rle_range(trainpic->getRawImage(), x1, y1, x2, y2);
 

=== modified file 'test/test_camera.cpp'
--- test/test_camera.cpp	2010-12-12 15:56:34 +0000
+++ test/test_camera.cpp	2011-07-22 02:32:35 +0000
@@ -15,24 +15,20 @@
 	cout << "Testing Color, if image looks correct close display" << endl;
 	cout << "If not, try restarting robot, and rerunning test" << endl;
 
-    Picture* img = robot.takePicture("color");
+    PicturePtr img = robot.takePicture("color");
     img->show();
-    delete img;
 
 	cout << "Testing Grayscale" << endl;
     img = robot.takePicture("gray");
     img->show();
-    delete img;
 
 	cout << "Testing Jpeg Color" << endl;
     img = robot.takePicture("jpeg");
     img->show();
-    delete img;
 
 	cout << "Testing Jpeg Gray" << endl;
     img = robot.takePicture("grayjpeg");
     img->show();
-    delete img;
 
 	cout << "All Camera Test Completed\n";
 

=== modified file 'test/test_camera_fourwindow.cpp'
--- test/test_camera_fourwindow.cpp	2011-04-17 12:51:20 +0000
+++ test/test_camera_fourwindow.cpp	2011-07-22 02:32:35 +0000
@@ -15,24 +15,20 @@
     cout << "Testing Color, if image looks correct close display" << endl;
     cout << "If not, try restarting robot, and rerunning test" << endl;
 
-    Picture* color = robot.takePicture("color");
+    PicturePtr color = robot.takePicture("color");
     color->show("Color");
-    //delete color;
 
     cout << "Testing Grayscale" << endl;
-    Picture* gray = robot.takePicture("gray");
+    PicturePtr gray = robot.takePicture("gray");
     gray->show("Gray");
-    //delete gray;
 
     cout << "Testing Jpeg Color" << endl;
-    Picture* jpeg = robot.takePicture("jpeg");
+    PicturePtr jpeg = robot.takePicture("jpeg");
     jpeg->show("Color JPEG");
-    //delete jpeg;
 
     cout << "Testing Jpeg Gray" << endl;
-    Picture* grayjpeg = robot.takePicture("grayjpeg");
+    PicturePtr grayjpeg = robot.takePicture("grayjpeg");
     grayjpeg->show("Gray JPEG");
-    //delete grayjpeg;
 
     cout << "All Camera Test Completed\n";
     cout << "Waiting 10 seconds" << endl;

=== modified file 'test/test_camera_nonblocking.cpp'
--- test/test_camera_nonblocking.cpp	2011-04-17 12:51:20 +0000
+++ test/test_camera_nonblocking.cpp	2011-07-22 02:32:35 +0000
@@ -15,17 +15,17 @@
     cout << "Testing Color, if image looks correct close display" << endl;
     cout << "If not, try restarting robot, and rerunning test" << endl;
 
-    Picture* color = robot.takePicture("color");
+    PicturePtr color = robot.takePicture("color");
     show(color, "Image");
     wait(0.5);
 
     cout << "Testing Grayscale" << endl;
-    Picture* gray = robot.takePicture("gray");
+    PicturePtr gray = robot.takePicture("gray");
     gray->show("Image");
     wait(0.5);
 
     cout << "Testing Jpeg Color" << endl;
-    Picture* img = robot.takePicture("jpeg");
+    PicturePtr img = robot.takePicture("jpeg");
     show(img,"Image");
     wait(0.5);