in C$++$: You will use this code as a basis for your modifications for the addition of the Grid mode and Scale mode.

Mandelbrot Program Specifications

The structs

You will use the following struct definitions and declaration in your program to create and manipulate your image:

pixel$\_$t

struct pixel$\_$t $\{$

unsigned short red;

unsigned short green;

unsigned short blue;

$\}$;

Members:

Pixel RGB color triplet

image$\_$t

struct image$\_$t $\{$

static const unsigned short MAX$\_$PIX$\_$GRAD $=160$;

static const unsigned short MAX$\_$DIMENSION $=1024$;

unsigned short width;

unsigned short height;

gradient$\_$t map$[$MAX$\_$PIX$\_$GRAD$]$;

pixel$\_$t data$[$MAX$\_$DIMENSION$][$MAX$\_$DIMENSION$]$;

$\}$;

Members:

MAX$\_$PIX$\_$GRAD: maximum size of array that holds the RGB colors from the file color$\_$gradient.txt$.$ There are $160$ colors in the file.

MAX$\_$DIMENSION: Sets the maximum size of an image to display.

width and height: Dimensions of the image entered by the user in the command line.

MAP$[]$: Array of type gradient$\_$t that stores the values of the gradient color palette read in from the file color$\_$gradient.txt$.$

data$[][]$: Array of type pixel$\_$t that holds the pixel color map for the image.

gradient$\_$t

struct gradient$\_$t $\{$

unsigned short red$\_$grad;

unsigned short green$\_$grad;

unsigned short blue$\_$grad;

$\}$;

Members:

RGB color triplet for the gradient color palette.

scale$\_$t

struct scale$\_$t $\{$

double xmin;

double xmax;

double ymin;

double ymax;

$\}$;

Members:

x and y coordinates for the grid pattern.

Declaring a struct data type.

The statement below declares the new struct identifier image of type image$\_$t

image$\_$t image; $//$ Image file struct declaration.

Included Functions:

Function $1-$ generate$\_$mandelbrot$()$

This function is responsible for populating the image pixel array. It sets up and calls the mandelbrot$()$ function and is returned the number of iterations for the point in the complex plane being calculated. This is also a pixel location in the image. It calls the get$\_$color$()$ function to assign an RGB triplet for that pixel and that is based on the number of colors entered in the command line. The maximum number of colors is $160.$ This color triplet is then stored in the image map. This continues for every pixel location in the image. There is a fair amount of explanation in the code comments, so make sure you read them.

void generate$\_$mandelbrot$($image$\_$t& image, const bool GRID$\_$SELECT$)$

Function $2-$ mandelbrot$()$

This function is called and receives the complex number c from generate$\_$mandelbrot$()$ and returns the number of iterations for that point.

unsigned short mandelbrot$($const complex& c$)$;

Function $3-$ get$\_$color

This function is called by generate$\_$mandelbrot$()$ and is passed the number of iterations for a point and calculates and sets the RGB colors for that pixel based on the number of iterations and the number of colors selected, from the available palette$($file$),$ for that image.

void get$\_$color$($unsigned short iterations, unsigned short& red, unsigned short& green,

unsigned short& blue, image$\_$t& image$)$

Function $4-$ read$\_$gradient$\_$file$()$

Stores the RGB triples for the color gradient file. This is currently $160$ RGB colors.

void read$\_$gradient$\_$file$($image$\_$t& image$)$;

Function $5-$ get$\_$xy$()$

Deterimines the real and imaginary axis $($x and y$)$ range. This is where the scaling logic resides. Your objective is to add this logic to the program. The scaling is set to the default in the sample $($full Mandelbrot image$)$ program.

void get$\_$xy$($scale$\_$t& scale, const bool SCALE$\_$SEL$)$

Default parameters in the sample run:

The sample program sets the coordinate size for the Mandelbrot calculations as constants. You will need to change these to variables when you add the scaling feature. There is a table of scaling values provided in the file scale.txt$.$ You will use this for the scaling feature.

Sample program values:

xmin $=-2\mathrm{.}0$

xmax $=1\mathrm{.}0$

ymin $=-1\mathrm{.}5$

ymax $=1\mathrm{.}5$

The max iterations of the Mandelbrot function is set to $160$ to match the maximum number of colors in the color gradient file. You can add more if you want later.

Inputs:

Command Line Arguments are used.

Included in the sample program.

argc $-$ An integer that represents the number of arguments to be passed.

argv$[]-$ An array of string arguments. $($Actually$,$ an array of pointers that point to the character arrays that hold the strings redirected from the command line$).$

Color gradient palette file.

Included in the sample program.

Contains $160$ colors that are used to represent the value of iterations within the Mandelbrot image. The first number is used as an index to read the set into an array of type gradient$\_$t

Copy this from:

$/$home$/$shared$/$cs$135/$jpristas$/$pa$09$b$/$color$\_$gradient.txt

$160$

$486127$

$7810204$

$1036204$

$10110204$

$101492$