HW2

class PGMImage: public array2D {
   // private:
   // ...
   // protected:
   // ...
   // public:
   // ... 
};//PGMImage 

Q3. Class construction and image synthesis (10 points)

Create a ComplexNumber class, and use it, along with the PGMImage class from Q2, to create a grayscale Mandelbrot fractal image (.pgm) file.

The ComplexNumber class would have these private members:

• double real

• double imag

It would need to implement these public methods:

• ComplexNumber(i,j)

• ComplexNumber add(ComplexNumber c2) [outputs a sum, as a new complex number]

• ComplexNumber squared() [outputs a squared value, as a new complex number]. As you might know, the real part would be real^2 - imag^2, and the imag part would be 2*real*imag. However, you can't just do 'real=(pow(real,2)-pow(imag,2)); imag=(2*real*imag);' [because real gets overwritten in the first statement, and therefore makes it incorrect for imag= in the second!].

• double abs() [outputs the magnitude of the complex number: sqrt(real*real+imag*imag)]

• void prt() [does cout in the form of 'real + imag j']

Here is an 'aside', but it's important for you to realize - INSIDE a class' public/protected/private method definitions, you CAN access an INCOMING (via an argument list) object's PRIVATE/PROTECTED members, with a '.' notation, AS LONG AS that object is of the same class that you are creating. Study this code [comment and uncomment statements, then run]:

#include 
#include 

using namespace std;

class A {
    private:
    double p = 3.14;
};

class Complex {
    private:
    double real=4, imag;

    public:
    void prt(Complex c) {
        cout << c.real << "," << c.imag << endl; // WILL work
    }

    void prt2(A x) {
        cout << x.p; // won't work (won't compile)
    }

};

int main() {
  Complex c;
  c.prt(c); // will work 
  cout << c.real << endl; won't work (won't compile)

  A a;
  c.prt2(a); // will work, but won't compile unless the cout inside prt2 is commented out
}// main()

Once you create ComplexNumber, you can do things like:

ComplexNumber c1(3,4), c2(-2,1);
ComplexNumber c3 = c1.squared(), c4 = c3.add(c2);

Next, create a 'fractal.pgm' Mandelbrot fractal image file, 640x480 resolution. Here is the pseudocode:

create a blank image
for each y (in yRes)
  for each x (in xRes)
    x,y is our pixel coordinate. TRANSFORM this to a complex number 'c' as follows:
    c.real = cxmin + x/(xRes-1)*(cxmax-cxmin) [maps x to cxmin..cxmax]
    c.imag = cymin + y/(yRes-1)*(cymax-cymin) [maps y to cymin..cymax]
    [(cxmin,cymin) and (cxmax,cymax) are diagonal endpoints of a complex-number rectangle,
    you can take them to be (-2,-1) and (1,1) respectively] 
    set z = 0
    set maxIter = 255
    set iter=0
    while (iter < maxIter and abs(z) < 2)
      z = z^2 + c [iterate!!] [use .squared() and .add() from your ComplexNumber class]
      iter++
    end_while: either iter has exceeded maxIter, or abs(z) has exceeded 2
    if abs(z)>=2 (we escaped our containing circle of radius 2!)
      set pixel value to be iter
    else (we got stuck, ie iter>maxIter but we're still inside the circle)
      set pixel value to be black
write out image

Please write the image out, as .pgm! THAT is why we went over the .pgm format, prior. Creating images as .gif, .jpg, .png, .tiff, .bmp, .rla etc [there are 100+ image file formats!] is much more difficult, because you need complex code (in the form of a compiled library plus .h, or .h, .cpp file pairs) to encode pixel data in those formats; in comparison, .pgm is trivial!

The above should produce the iconic Mandelbrot 'buddha' (zoomed out) fractal image, like so [cool!]:

Place all three class declarations in Q3.h, include it in Q3.cpp, and in Q3.cpp, provide all three class' definitions and main() [main() is where the fractal image calculation should happen].