﻿ Sample Code

### A worldType Class to Implement World Coordinates on a Graphics Window

```class worldType
{
private:
double a, b;  // screenX = a * worldX + b
double c, d;  // screenY = c * worldY + d
int myID;     // window identifier

//-----------------------------------------------------
// init
//
// Initialize the graphics window using the specified
// properties.
//
// In Parameters:
//     width and height of window in pixels
//     title of the window
//     location on screen of upper-left corner (x, y)
//-----------------------------------------------------
void init(int width, int height, string title, int x, int y)
{
}

//-----------------------------------------------------
// mapx
//
// Given the specified  world x-coordinate, return the
// corresponding graphics window coordinate.
//
// In parameter: x
//-----------------------------------------------------
int mapx(const double& x)
{
}

//-----------------------------------------------------
// mapy
//
// Given the specified  world y-coordinate, return the
// corresponding graphics window coordinate.
//
// In parameter: y
//-----------------------------------------------------
int mapy(const double& y)
{
}

public:
//-----------------------------------------------------
// Construct a world that is centered in the middle of a
// 601 x 601 graphics window. The lower-left corner
// corresponds to (-1.0, -1.0) and the upper-right
// corner corresponds to (1.0, 1.0).
//
// The title of the default graphics window is "World
// Coordinate System" and it will be located in the
// middle of the screen.
//-----------------------------------------------------
worldType()
{
int x = getmaxwidth()/2  - 300;
int y = getmaxheight()/2 - 300;

// Calculate coefficients of x mapping function.

a = 300.0;
b = 300.5;

// Calculate coefficients of y mapping function.

c = -300.0;
d =  300.5;

// Initialize graphics window

init(601, 601, "World Coordinate System", x, y);
}

//-----------------------------------------------------
// Construct a world based on the specified values.
//
// In Parameters:
//      width and height of graphics window
//      location of upper-left corner of graphics window (locx, locy)
//      lower-left corner of window corresponds to (x1, y1)
//      upper-right corner of window corresponds to (x2, y2)
//      title of graphics window
//
// In general the aspect ratio of the graphics window
// and the world should be the same:
//
//      width/height = (x2 - x1)/(y2 - y1)
//-----------------------------------------------------
worldType(int width, int height,
int locx, int locy,
double x1, double y1,
double x2, double y2,
string title)
{
}

//-----------------------------------------------------
// reset
//
// Reset the coordinates of the lower-left corner to
// (x1, y1) and the upper-right corner to (x2, y2).
//
// In parameters: x1, y1, x2, y2
//-----------------------------------------------------
void reset(double x1, double y1,
double x2, double y2)
{
}

//-----------------------------------------------------
// setActive
//
// Set this window as the active window.
//-----------------------------------------------------
void setActive()
{
setcurrentwindow(myID);
}

//-----------------------------------------------------
// close
//
// Close this world's graphic window.
//-----------------------------------------------------
void close()
{
closegraph(myID);
}

//-----------------------------------------------------
// moveTo
//
// Move the current position to the specificed point.
//
// In Parameters: x, y
//-----------------------------------------------------
void moveTo(double x, double y)
{
}

//-----------------------------------------------------
// lineTo
//
// Draw a line from the current point to the specificed
// point and set the specified point as the current
// point.
//
// In Parameters: x, y
//-----------------------------------------------------
void lineTo(double x, double y)
{
}

//-----------------------------------------------------
// drawLine
//
// Draw a line from (x1,y1) to (x2,y2) and set the
// current point to (x2,y2).
//
// In Parameters: x1, y1, x2, y2
//-----------------------------------------------------
void drawLine(double x1, double y1, double x2, double y2)
{
}

//-----------------------------------------------------
// floodFill
//
// Starting at the specified point flood the region
// bounded by the specified color using the current
// flood fill color and style.
//
// In parameters: x, y, bordercolor
//-----------------------------------------------------
void floodFill(double x, double y, int bordercolor)
{
}

//-----------------------------------------------------
// outStreamxy
//
// Display the contents of the bgiout stream at the
// specified location.
//
// In parameters: x, y
//-----------------------------------------------------
void outStreamxy(double x, double y)
{
}
};```

### Draw a Hexagon in World Coordinates

```//---------------------------------------------------------
// Hexagon2
//
// Draw a regular hexagon using world coordinates.
//---------------------------------------------------------

#include "worldType.h"
#include <graphics.h>
#include <cmath>
#include <iostream>
using namespace std;

const double PI = 3.14159265358979;

//----------------------------------------------
// drawHexagon
//
// This function draws a regular hexagon using
// the specified color. It will have the
// specified (circumscribed) radius and be
// centered on the specified point. The line
// from the center to the first vertex will
// make the specified angle (in radians)
// relative to the positive x-direction.
//
// In parameters: w, color, cx, cy, r, angle
//----------------------------------------------
void drawHexagon(worldType w,
int color,
double cx, double cy,
double r,
double angle)
{
double theta;
double centralAngle = PI / 3.0;
int oldColor = getcolor();

w.moveTo(cx, cy);
setcolor(WHITE);

theta = angle;
w.lineTo(cx + r * cos(theta), cy + r * sin(theta));

setcolor(color);
for (int vertex = 1; vertex < 6; vertex++)
{
theta = double(vertex) * centralAngle + angle;
w.lineTo(cx + r * cos(theta), cy + r * sin(theta));
}
theta = angle;
w.lineTo(cx + r * cos(theta), cy + r * sin(theta));

setcolor(oldColor);
}

int main()
{
// Create a graphics window that is 320 pixels wide and 240 pixels high.
// The upper-left corner of the window will be at 10 pixels from the left
// edge of the screen and 20 pixels from the top of the screen. The
// lower-left corner of the graphics window corresponds to coordinates
// (-4.0, -3.0) and the upper-right corner corresponds to (4.0, 3.0). The
// graphics window title is "Hexagon".

worldType myWorld(320, 240, 10, 20, -4.0, -3.0, 4.0, 3.0, "Hexagon");

// Draw grid on graphics windows corresponding to integer values of
// x and y.

for (int x = -4; x <= 4; x++) // vertical grid lines
{
if (x == 0)
{
setcolor(LIGHTRED);
}
else
{
setcolor(RED);
}
myWorld.drawLine(x, -3.0, x, 3.0);
}

for (int y = -3; y <= 3; y++) // horizontal grid lines
{
if (y == 0)
{
setcolor(LIGHTRED);
}
else
{
setcolor(RED);
}
myWorld.drawLine(-4.0, y, 4.0, y);
}

// Draw a light green hexagon centered at (1.0, -1.0) with a radius
// of 1.9 rotated 0 degrees.

drawHexagon(myWorld, LIGHTGREEN, 1.0, -1.0, 1.9, 0.0);
getch();

// Draw a cyan hexagon centered at (2.0, 2.0) with a radius of 0.9 and
// rotated 22.5 degrees counter-clockwise.

drawHexagon(myWorld, CYAN, 2.0, 2.0, 0.9, PI/8.0);
getch();

// Draw a blue hexagon centered at (-1.5, 2.5) with a radius of 1.1 and
// rotated 10 degrees clockwise.

drawHexagon(myWorld, BROWN, -1.5, 2.5, 1.1, -PI/18.0);
getch();

closegraph();

return 0;
}```