// by Sabrina Rispin
// Activity Section: 5 & 6
// Date: 13/4/15 - 24/4/15
// Description: determines how many steps it takes for a point on the
// complex plane c to escape the funciton z^2 + c upon iteration.
 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <netinet/in.h>
#include <unistd.h>
#include <math.h>
#include "mandelbrot.h"
#include "pixelColor.h"
 
// server defines
#define SIMPLE_SERVER_VERSION 2.0
#define REQUEST_BUFFER_SIZE 100
#define DEFAULT_PORT 7191
#define NUMBER_OF_PAGES_TO_SERVE 100
// after serving this many pages the server will halt
 
// defines for escapeSteps, serveBMP and extract
#define TRUE 1
#define FALSE 0
#define MAX_ITER 256
#define SIZE 512    // ie the width of the image (also the height)
#define POWER 2.0    // step = 2^-zoom
#define ESCAPE_DISTANCE 4
#define SIZE_OF_HEADER 54
#define BYTES_PER_PIXEL 10
#define SIZE_OF_BMP (SIZE * SIZE * BYTES_PER_PIXEL)
#define MAX_LEN_INPUT 50
#define OFFSET 2
#define COLOR_MODE 'R'
 
// bits8 for serveBMP and triordinate for extract
typedef unsigned char  bits8;
typedef struct _triordinate {
   double x;
   double y;
   int z;
} triordinate;
 
 
static void serveHTML (int socket);
static void serveBMP (int socket, double x, double y, int zoom);
static triordinate extract (char *message);
static int waitForConnection (int serverSocket);
static int makeServerSocket (int portno);
 
 
int main (int argc, char* argv[]) {
    // sets up the server
    printf ("************************************\n");
    printf ("Starting simple server %f\n", SIMPLE_SERVER_VERSION);
    printf ("Serving mandelbrots since 2012\n");
    printf ("Access server at http://localhost:%d/\n", DEFAULT_PORT);
    printf ("************************************\n");
 
    int serverSocket = makeServerSocket(DEFAULT_PORT);
    char request[REQUEST_BUFFER_SIZE];
    int numberServed = 0;
    while (numberServed < NUMBER_OF_PAGES_TO_SERVE) {
        printf ("*** So far served %d pages ***\n", numberServed);
 
        // STEP 1. wait for a request to be sent from a web browser, 
        // then open a new connection for this conversation
        int connectionSocket = waitForConnection(serverSocket);
 
        // STEP 2. read the first line of the request
        int bytesRead = recv (connectionSocket, request, sizeof(request) - 1, 0);
        assert (bytesRead >= 0);
        // check that we were able to read some data from the connection
 
        // echo entire request to the console for debugging
        printf (" *** Received http request ***\n %s\n", request);
 
        // Finds the start and end of the shorter, more useful request
        // from the url. Also checks there is an x, y and z.
        int startReq = 0;
        int endReq = 0;
        int valuesPresent = 0;
        while (request[endReq] != 'H') {
            if (request[endReq] == '/') {
                startReq = endReq;
            }
            if (request[endReq] == 'x' || request[endReq] == 'y' ||
                request[endReq] == 'z') {
                valuesPresent += 1;
            }
            endReq++;
        }
 
        // Gotta terminate that new string!
        request[endReq] = '\0';
        char *shortRequest = &request[startReq];
 
        printf("URL Short Request: %s\n", shortRequest);
 
        // STEP 3. send the browser stuff
        printf (" *** Sending http response ***\n");
 
        // If x y and z serve BMP, else serve html interactive version
        if (valuesPresent == 3) {
            triordinate input = extract (shortRequest);
            serveBMP (connectionSocket, input.x, input.y, input.z);
        } else {
            printf ("HTML TIME\n");
            serveHTML (connectionSocket);
        }
 
        // STEP 4. close the connection after sending the page-
        // keep aust beautiful
        close (connectionSocket);
        ++numberServed;
    }
 
    // close the server connection after we are done-keep aust beautiful
    printf ("** shutting down the server **\n");
    close (serverSocket);
  
    return EXIT_SUCCESS;
}
 
// mandelbrot functions
int escapeSteps (double x, double y) {
    int escaped = FALSE;
    double zRe = 0.0;
    double zIm = 0.0;
 
    // need the below in order to simultaneously update
    double newRe = 0.0;
    double newIm = 0.0;
 
    //printf ("Real c: %lf, Imaginary c: %lf\n", x, y);
    
    // The calcs!
    int iter = 0;
    while ((iter < MAX_ITER) && (escaped != TRUE)) {
        iter++;
        newRe = zRe * zRe - zIm * zIm + x;
        newIm = 2 * zRe * zIm + y;
 
        zRe = newRe;
        zIm = newIm;
 
        if (zRe*zRe + zIm*zIm >= ESCAPE_DISTANCE) {
            escaped = TRUE;
        }
    }
 
    //printf ("%d\n", iter);
    
    return iter;
}
 
// server functions
static void serveHTML (int socket) {
    char *message;
 
    // first send the http response header
    message =
        "HTTP/1.0 200 Found\n"
        "Content-Type: text/html\n"
        "\n";
    printf ("about to send=> %s\n", message);
    write (socket, message, strlen (message));
 
    // serves the html script for the interactive mandelbrot
    message =
        "<!DOCTYPE html>\n"
        "<script src=\"https://almondbread.cse.unsw.edu.au/tiles.js\"></script>"
        "\n";
    write (socket, message, strlen (message));
}
 
 
static void serveBMP (int socket, double x, double y, int zoom) {
    char *message;
 
    // first send the http response header
    message = "HTTP/1.0 200 OK\r\n"
              "Content-Type: image/bmp\r\n"
              "\r\n";
    printf ("about to send=> %s\n", message);
    write (socket, message, strlen (message));
 
    // serve the BMP header
    bits8 header[SIZE_OF_HEADER] = {
        0x42, 0x4D, 0x36, 0x00, // 
        0x0C, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x36, 0x00,
        0x00, 0x00, 0x28, 0x00,
        0x00, 0x00, 0x00, 0x02,
        0x00, 0x00, 0x00, 0x02,
        0x00, 0x00, 0x01, 0x00,
        0x18, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x0C, 0x00, 0x13, 0x0B,
        0x00, 0x00, 0x13, 0x0B,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00
    };
 
    write (socket, header, sizeof (header));
 
    // all the things and counters needed
    double step = pow (POWER, -zoom);
    double xStart = -step*SIZE/2 + step/2 + x;
    double xPos = xStart;
    double yPos = -step*SIZE/2 + step/2 + y;
    int xCount = 0;
    int yCount = 0;
    int arrayPos = 0;
    int iter;
 
    // the bmp array!
    bits8 bmp[SIZE_OF_BMP];
 
    while (yCount < SIZE) {
        while (xCount < SIZE) {
            // calcs number of iters to blow up then uses that to color
            iter = escapeSteps (xPos, yPos);
            bits8 blue;
            bits8 red;
            bits8 green;
            if (COLOR_MODE == 'B') {
                blue = stepsToRed (iter);
                red = stepsToGreen (iter);
                green = stepsToBlue (iter);
            } else if (COLOR_MODE == 'G') {
                green = stepsToRed (iter);
                blue = stepsToGreen (iter);
                red = stepsToBlue (iter);
            } else {
                red = stepsToRed (iter);
                green = stepsToGreen (iter);
                blue = stepsToBlue (iter);
            }
            
 
            // add the pixel
            bmp[arrayPos] = blue;
            arrayPos++;
            bmp[arrayPos] = green;
            arrayPos++;
            bmp[arrayPos] = red;
            arrayPos++;
 
            // to the next pixel! (Also keeps track of how many pixels)
            xPos += step;  
            xCount++;  
        }
 
        // at the end of a row reset xPos, add a step to yPos and inc y
        xPos = xStart;
        yPos += step;
        yCount++;
        xCount = 0;
    }
 
    write (socket, bmp, sizeof (bmp));
}
 
// extracting x y z function
triordinate extract (char *message) {
    // incase the values after x y and z are empty, set initial vals
    triordinate tri = {0, 0, 7};
 
    // set start pos at extereme end
    // (not 0, if no update then start will include the whole string!)
    int xStart = strlen (message);
    int yStart = strlen (message);
    int zStart = strlen (message);
    int zEnd = strlen (message) - 1;
    
    // the final x, y and z as strings to go into ato_
    char x[MAX_LEN_INPUT];
    char y[MAX_LEN_INPUT];
    char z[MAX_LEN_INPUT];
 
    // clears the array by filling it wil escaped 0
    memset (x, '\0', MAX_LEN_INPUT);
    memset (y, '\0', MAX_LEN_INPUT);
    memset (z, '\0', MAX_LEN_INPUT);
 
    // this loops looks for an _ the looks as the next char
    // if x y or z set correspoding Start value
    // OFFSET = 2 because _x0.4 hence start of num is i (pos of _) + 2
    int i = 0;
    while (i < strlen (message)) {
        if (message[i] == '_') {
            if (message[i+1] == 'x') {
                xStart = i + OFFSET;
            } else if (message[i+1] == 'y') {
                yStart = i + OFFSET;
            } else if (message[i+1] == 'z') {
                zStart = i + OFFSET;
            }
        }
 
        // _z5.bmp so . is the end of z
        if (message[i] == '.') {
            zEnd = i;
        }
        i++;
    }
 
    // copies the specific string i.e. -0.4 (from _x-0.4) to x etc.
    // strncpy args: copyToString, copyFromString, length
    // note: yStart - xStart = length of _x-0.4 (-OFFSET for real len)
    strncpy (x, message + xStart, yStart - xStart - OFFSET);
    strncpy (y, message + yStart, zStart - yStart - OFFSET);
    strncpy (z, message + zStart, zEnd - zStart);
    
    //printf ("%s\n", x);
    //printf ("%s\n", y);
    //printf ("%s\n", z);
 
    // eg if _x_y0.5_z6 there is no x val, strlen (x) == 0, don't update
    if (strlen (x) > 0) {
        tri.x = atof (x);
    }
    if (strlen (y) > 0) {
        tri.y = atof (y);
    }
    if (strlen (z) > 0) {
        tri.z = atol (z);
    }
 
    return tri;
}
 
// start the server listening on the specified port number
static int makeServerSocket (int portNumber) {
 
    // create socket
    int serverSocket = socket (AF_INET, SOCK_STREAM, 0);
    assert (serverSocket >= 0);
    // check there was no error in opening the socket
 
    // bind the socket to the listening port  (7191 in this case)
    struct sockaddr_in serverAddress;
    serverAddress.sin_family      = AF_INET;
    serverAddress.sin_addr.s_addr = INADDR_ANY;
    serverAddress.sin_port        = htons (portNumber);
 
    // tell the server to restart immediately after a previous shutdown
    // even if it looks like the socket is still in use
    // otherwise we might have to wait a little while before rerunning the
    // server once it has stopped
    const int optionValue = 1;
    setsockopt (serverSocket, SOL_SOCKET, SO_REUSEADDR, &optionValue, sizeof (int));
 
    int bindSuccess = bind (serverSocket, (struct sockaddr*)&serverAddress, sizeof (serverAddress));
 
    assert (bindSuccess >= 0);
    // if this assert fails wait a short while to let the operating
    // system clear the port before trying again
 
    return serverSocket;
}
 
// wait for a browser to request a connection,
// returns the socket on which the conversation will take place
static int waitForConnection (int serverSocket) {
 
    // listen for a connection
    const int serverMaxBacklog = 10;
    listen (serverSocket, serverMaxBacklog);
 
    // accept the connection
    struct sockaddr_in clientAddress;
    socklen_t clientLen = sizeof (clientAddress);
    int connectionSocket = accept (serverSocket, (struct sockaddr*)&clientAddress, &clientLen);
    assert (connectionSocket >= 0);
    // check for connection error
 
    return connectionSocket;
}

Download file: mandelbrot.c (11.4 KB)

Sabrina Rispin – edited 10 years ago – history