Question

Your will write a class named Gasket that can be used to build Gasket objects (that represent Sierpinski gaskets) that you can display graphically.  Your Gasket class is defined in the provided file Gasket.h.   DO NOT CHANGE the file Gasket.h.  The attributes and methods defined for class Gasket are described below.    

·sideLength            an int that holds the length of each side of the Gasket.  The length of the side is measured as a number of pixels

·xLocation              an int that holds the x coordinate (in pixels) of the upper left hand corner of the Gasket (left end of the base of the largest triangle in the Gasket)

·yLocation              an int that holds the y coordinate (in pixels) of the upper left hand corner of the Gasket (right end of the base of the largest triangle in the Gasket)

·iterations              The number of iterations.  One iteration consists of dividing each triangle in the list of triangles in the gasket into parts using TriangleDivide.

·gasketColour        an object of type Colour (the Colour class is provided for you) that holds the colour that the plotted Triangles in the Gasket will have

·lenSubTriList         an int that holds the number of triangles in the array of Triangles that are contained in the gasket.

·listOfSubTriangles         a pointer to a Triangle (to be used for dynamically allocation the array of Triangles of length lenSubTriLIst)   

In addition your class should have the following constructors and public member functions. The prototypes for all the following functions are given in the class definition provided for you in file Gasket.h. You must use the file Gasket.h as part of your class. DO NOT CHANGE the file Gasket.h.

§ Default constructor (sets private member sideLength to 100, members xLocation and  yLocation and iterations to 0, members lenSubTriList to 1 and allocates the dynamic memory for an array containing 1 triangle.   The default constructor sets gasketColour to black (0, 0, 0.255)

§ Constructor that initializes iterations, sideLength, xLocation,  yLocation and gasketColour to the provided values of the corresponding actual arguments in the constructor call. This constructer calculates the length of the list of Triangles needed and allocates an array large enough to hold all triangles at the iteration given by the value of the iterations member.  The constructor builds the gasket by calling private member function GasketDIvide once for each iteration.

§ Copy constructor

§ Destructor

§ Accessor functions to access private members xLocation, yLocation, iterations, sideLength and gasketColour

§ Mutator functions to access private members xLocation, yLocation, iterations, sideLength and gasketColour  (mostly provided)

§ An overloaded print function which prints the values of each private member in the Gasket Class.  (use same format as you did for the Rectangle class).  This function also prints each Triangle in the Gasket.

§ Member function GasketDisplay.  You can create this function without directly calling the bitmap library.  You need to print each triangle in the Gasket using the TriangleDisplay function

§ Boolean private member function GasketDivide (provided).  GasketDivide creates a Sierpinski Gasket.  The results expected are shown below for some values of the number of iterations.  Member function GasketDivide takes the list of triangles for iteration n-1 and divides each of them into 3 triangles using TriangleDIvide.  This makes a new list of Triangles for iteration n

The array of triangles passed to the GasketDivide function must be at least 3 times longer than the list of triangles to be divided. When GasketDivide  has completed the array of Triangles will hold a list of triangles containing 3 times as many triangles.

// Each Gasket has the a length (x extent)
// a width (y extent), a location used for graphic
// display (xlocation, ylocation), and a color
// for grapic display.All distances and
// locations are integers (number of pixels)
// The upper right hand corner is (0,0)
// y coordinate increased downward
// Author: Janice Regan March 2006

//#pragma warning(disable: 4996)

#ifndef GasketFlag
#define GasketFlag

#include <iostream>
#include <cstdlib>
#include <string>
#include <cmath>
#include <iomanip>
#include "Colour.h"
#include "Triangle.h"
using namespace std;

class Gasket
{
public:
//default constructor: no arguments, no return type
//define if class has any other constructors, or if class
//includes deep memory (pointers) or static counters
Gasket();
//other intializing constructors
Gasket( int iterationsValue, int xLocationValue, int yLocationValue,
int sideLengthValue, Colour gasketColourValue);
   Gasket(const Gasket& toBeCopied);
~Gasket();

//accessor functions
   int GetIterations() const;
   int GetXLocation() const;
int GetYLocation() const;
   int GetSideLength() const;
Colour GetGasketColour() const;

//mutator functions,
void SetIterations(const int iterationsValue);
void SetXLocation(const int xLocationValue);
void SetYLocation(const int yLocationValue);
   void SetSideLength(const int sideLengthValue);
void SetGasketColour(const Colour gasketColorValue);

//member function to plot a Gasket to a bitmap
//myImageValue is a bitmap
void GasketDisplay(BMP& myImageValue, int thisIter, string theOutputFile);
void GasketPrint();

private:
   // helper functions
   void GasketDivide(Triangle* listOfSubTriangles, int numTriangleToDivide);
// Members expressing properties of a Gasket
   int xLocation;
   int yLocation;
   int iterations;
   int sideLength;
   Colour gasketColour;
   Triangle* listOfSubTriangles;
   int lenSubTriList;
};

#endif

Answer 1

#include "Gasket.h"
#include "Colour.h"

double GASKET_SIDE_TO_HEIGHT = 0.86666666;

void Gasket::GasketDivide(Triangle* listOfSubTriangles, int trianglesIn)
{
   if(trianglesIn <= 0 || trianglesIn >= static_cast<int>(pow(3,iterations) ) )
   {
       cerr << " illegal number of triangle in Gasket Divide";
       exit(1);
   }
   else
   {
       for (int k = trianglesIn-1; k >= 0; k--)
       {
           listOfSubTriangles[k].TriangleDivide(&listOfSubTriangles[k*3] );
       }
   }
}

// Requested Get of accessors (Get functions)
// to Get the values of each of the
// variable members of the class Gasket

// Requested Set functions to Set each of the variable members
// of class Gasket from outside of class Gasket.
// There is interaction between the members length width and area
// so Setting the variable member itself is not always adequate
// other calculations may be needded to maintain the consistancy
// of the instance of the class (the object)

void Gasket::SetIterations( const int iterationsValue)
{
    iterations = iterationsValue;
   lenSubTriList = static_cast<int> ( pow( 3.0, iterations ) );
   delete [] listOfSubTriangles;
   listOfSubTriangles = NULL;
   listOfSubTriangles = new Triangle[lenSubTriList];
   listOfSubTriangles[0]= Triangle(xLocation, yLocation, sideLength, gasketColour);
   for (int k=1; k <= iterations; k++)
   {
       GasketDivide(listOfSubTriangles, lenSubTriList / 3 );
   }
}

void Gasket::SetYLocation(const int yLocationValue)
{
   int height = 0;
    yLocation = yLocationValue;
   //If yLocation is off the page move to 0,0
   if( yLocation >= pageLength || yLocation < 0 )
   {
       xLocation = 0;
       yLocation = 0;
   }
   height = static_cast<int>(sideLength * GASKET_SIDE_TO_HEIGHT);
   if( yLocation + height > pageLength )
   {
       sideLength = static_cast<int>( (pageLength - yLocation) / GASKET_SIDE_TO_HEIGHT );
   }
   listOfSubTriangles[0]= Triangle(xLocation, yLocation, sideLength, gasketColour);
   for (int k=1; k <= iterations; k++)
   {
       GasketDivide(listOfSubTriangles, lenSubTriList / 3 );
   }
}

void Gasket::SetSideLength(const int sideLengthValue)
{
   int height = 0;
    sideLength = sideLengthValue;
   //Check if the change in sideLiength makes the
   //Triangle extend beyond any edge of the page
   if(sideLength < 1) sideLength = 1;
   if( xLocation + sideLength > pageWidth )
   {
       sideLength = pageWidth - xLocation;
   }
   height = static_cast<int> (sideLength * GASKET_SIDE_TO_HEIGHT);
   if( yLocation + height > pageLength )
   {
       sideLength = static_cast<int>( (pageLength - yLocation) / GASKET_SIDE_TO_HEIGHT );
   }
   listOfSubTriangles[0]= Triangle(xLocation, yLocation, sideLength, gasketColour);
   for (int k=1; k <= iterations; k++)
   {
       GasketDivide(listOfSubTriangles, lenSubTriList / 3 );
   }
}