Beispiel #1
0
//----Writes a Single Pixel----//
void writePixel (int socket, int iterations, bits8 byte){

    if (iterations == ITERATION_MAX){

        byte = stepsToRed(iterations);
        write (socket, &byte, sizeof(byte));

        byte = stepsToBlue(iterations);
        write (socket, &byte, sizeof(byte));

        byte = stepsToGreen(iterations);
        write (socket, &byte, sizeof(byte));

    } else {

        byte = stepsToRed(iterations);
        write (socket, &byte, sizeof(byte));

        byte = stepsToBlue(iterations);
        write (socket, &byte, sizeof(byte));

        byte = stepsToGreen(iterations);
        write (socket, &byte, sizeof(byte));

    }
}
Beispiel #2
0
	void serveBMP (int socket, double x, double y, int zoom) {
	   char* message;
		zoom = zoom +4;
	   // first send the http response header

	   // (if you write strings one after another like this on separate
	   // lines the c compiler kindly joins them togther for you into
	   // one long string)
	   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));
		writeHeader (socket);

	   int totalBytes = (SIZE * SIZE * BYTES_PER_PIXEL);
	   int position = 0;



	   while (position < totalBytes) {
	      int steps = blackOrWhite(position, x, y, zoom);
		unsigned char red = stepsToRed (steps);
			unsigned char blue = stepsToBlue (steps);
			unsigned char green = stepsToGreen (steps);
	      write (socket, &red, 1);
			write (socket, &blue, 1);
			write (socket, &green, 1);
			position++;

	   }
	}
Beispiel #3
0
void serveBMP (int socket, dim theDim) {
    char* message;
    double x,y;
    int steps;
    
    // first send the http response header
    
    // (if you write strings one after another like this on separate
    // lines the c compiler kindly joins them togther for you into
    // one long string)
    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));
    
    // now send the contents of the web page to be displayed
    unsigned char bmpHead [] = {
       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,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
    };
    // This is the bmp header, that goes at the start of the image
    printf ("about to send=> bmp Header\n");
    write (socket, bmpHead, sizeof (bmpHead));   
    
    printf ("about to send=> bmp main\n");
    for (y=theDim.ystart; y<theDim.yend; y+=theDim.distance) {
        for (x=theDim.xstart; x<theDim.xend; x+=theDim.distance) {
                steps = noOfSteps(x,y);
                unsigned char color[] = {stepsToBlue(steps),
                    stepsToGreen(steps),stepsToRed(steps)};
                write (socket, color, sizeof (color));
            }
            //     printf("%d", noOfSteps(x,y));
        }
    }
Beispiel #4
0
void mandelBitmap(char *image, double x, double y, int zoom) {
    double pixelDistance = pow(2, -zoom);
    double bottom = y - pixelDistance * (IMAGE_HEIGHT / 2);
    double left = x - pixelDistance * (IMAGE_WIDTH / 2);

    bitmapHeader(image);
    int offset = BMP_HEADER_SIZE;

    int row = 0;
    while (row < IMAGE_HEIGHT) {
        int col = 0;
        while (col < IMAGE_WIDTH) {
            int steps = escapeSteps(
                left + pixelDistance * col,
                bottom + pixelDistance * row);

            image[offset] = stepsToBlue(steps);
            image[offset + 1] = stepsToGreen(steps);
            image[offset + 2] = stepsToRed(steps);

            offset += 3;
            col += 1;
        }

        row += 1;
    }
}
void serveBMP (int socket, char * request) {
 
   char* message;
   // 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));
   
   int numBytes = (SIZE * SIZE * BYTES_PER_PIXEL);
   unsigned char bmp[(SIZE * BYTES_PER_PIXEL * SIZE)] = {0,};

   writeHeader (socket);
   triordinate input;
   input = extract (request);
//   printf("centre: %lf, %lf. zoom %d\n", input.x, input.y, input.z);

//   unsigned char byte = 0; 
   int height = 0;
   int width = 0;
   double increment;
   increment = 1.0 / (positivePower(2.0, input.z));
//   printf("zoom: %d\n", input.z);
//   printf("increment: %lf\n", increment);

   double x = input.x - 256 * increment; // far left side
   double y = input.y - 256 * increment; // bottom level
//   printf("lower left corner: %lf, %lf\n", x, y);
   int steps = 0;
   double xCounter = x;
   int counter = 0;
   while (height < SIZE) {
      width = 0;
      xCounter = x;
      while (width < SIZE) {
         steps = escapeSteps(xCounter, y);
         bmp[counter] = stepsToBlue(steps);
         counter ++;
         bmp[counter] = stepsToGreen(steps);
         counter ++;
         bmp[counter] = stepsToRed(steps);
         counter ++;
         width ++;
         xCounter = xCounter + increment;
      }
   y = y + increment;  
   height ++;
   }

   assert (sizeof(bmp) == numBytes);
   write (socket, bmp, sizeof(bmp));
}
Beispiel #6
0
void generateBitmapImage(unsigned char bmpData[],
                         double centreX, double centreY, int zoom) {
    int drawingX;
    int drawingY;

    // The index of the desired row
    int bitmapRow;
    // The index of the desired column
    int bitmapColumn;

    double scaledX, scaledY;
    double scale;

    int iterations;

    scale = 1 / power(2, zoom);

    drawingY = 0;
    while (drawingY < BITMAP_HEIGHT) {
        drawingX = 0;
        while (drawingX < BITMAP_WIDTH) {
            // centering
            scaledX = centreX -(BITMAP_WIDTH / 2) * scale;
            scaledY = centreY -(BITMAP_HEIGHT / 2) * scale;

            // calculate current point
            scaledX += drawingX * scale;
            scaledY += drawingY * scale;

            bitmapRow = drawingY *
                            (BITMAP_WIDTH * BITMAP_BYTES_PER_PIXEL);
            bitmapColumn = drawingX * BITMAP_BYTES_PER_PIXEL;
            iterations = escapeSteps(scaledX, scaledY);
            bmpData[bitmapRow + bitmapColumn] = stepsToBlue(iterations);
            bmpData[bitmapRow + bitmapColumn + 1] = stepsToGreen(iterations);;
            bmpData[bitmapRow + bitmapColumn + 2] = stepsToRed(iterations);;

            drawingX++;
        }
        drawingY++;
    }
}
static void serveBMP (int socket, triordinate dat) {
    char* message;
    
    // first send the http response header
    // (if you write stings one after another like this on separate
    // lines the c compiler kindly joins them togther for you into
    // one long string)
    message = "HTTP/1.0 200 OK\r\n"
    "Content-Type: image/bmp\r\n"
    "\r\n";
    printf ("about to send=> %s\n", message);
    if(write(socket, message, strlen (message)) == 1){};
    
    writeHeader(socket);
    
    int counterX = 0;
    int counterY = -1;
    unsigned char byte[1];
    int steps = 0;
    double dBetweenPixels = pow(2, (-1*dat.z));
    double currentX = dat.x - 0.5*dBetweenPixels*(SIZE+1);
    double currentY = dat.y - 0.5*dBetweenPixels*(SIZE+1);
    
    while (counterY < SIZE) {
        currentX = dat.x - 0.5*dBetweenPixels*(SIZE+1);
        while (counterX < SIZE){
            steps = escapeSteps(currentX, currentY);
            byte[0] = stepsToBlue(steps);
            if(write(socket, byte, sizeof byte) == 1){};
            byte[0] = stepsToGreen(steps);
            if(write(socket, byte, sizeof byte) == 1){};
            byte[0] = stepsToRed(steps);
            if(write(socket, byte, sizeof byte) == 1){};
            
            currentX += dBetweenPixels;
            counterX++;
        }
        counterX = 0;
        currentY += dBetweenPixels;
        counterY++;
    }
}
int main (int argc, char *argv[]) {

    assert (sizeof(bits8)  == 1);
    assert (sizeof(bits16) == 2);
    assert (sizeof(bits32) == 4);

    FILE *outputFile;
    outputFile = fopen(BMP_FILE, "wb");
    assert ((outputFile!=NULL) && "Cannot open file");
    writeHeader(outputFile);

    printf ("generating mandelbrot picture");

    int numBytes = (SIZE * SIZE * BYTES_PER_PIXEL);
    int pos = 0;
    bits8 byte;
    byte = BLACK;

    int xcoord = -256;
    int ycoord = -256;
    double zre;
    double zim;
    int escape;
    int red = 0;
    int green = 0;
    int blue = 0;

    while (pos < numBytes) {
        int printno;

        zre = xcoord/256.000000000000000 - 0.5;
        zim = ycoord/256.000000000000000;
        escape = escapeSteps(zre, zim);

        if(escape < BOUNDED) {
            red = BLACK;
            green = BLACK;
            blue = BLACK;
        } else {
            red = stepsToRed(escape);
            green = stepsToGreen(escape);
            blue = stepsToBlue(escape);
        }

        for (printno = 0; printno < BYTES_PER_PIXEL; printno++) {
            if (printno == 0) {
                byte = red;
            } else if (printno == 1){
                byte = green;
            } else if (printno == 2){
                byte = blue;
            }
            fwrite (&byte, sizeof byte, 1, outputFile);
            pos++;
        }

        xcoord = xcoord + 1;
        if (pos%SIZE == 0) {
             xcoord = -256;
            ycoord = ycoord + 1;
        }
    }

    fclose(outputFile);


    return EXIT_SUCCESS;
}
void serveBMP (int socket) {
   char* message;

   // first send the http response header

   // (if you write stings one after another like this on separate
   // lines the c compiler kindly joins them togther for you into
   // one long string)
   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));

   // now send the BMP
   unsigned char bmp[FILE_SIZE] = {
     0x42,0x4d,0x63,0x00,0x0c,0x00,0x00,0x00,
     0x00,0x00,0x36,0x00,0x00,0x00,0x28,0x00,
     0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02,
     0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,
     0x00,0x00,0x00,0x00,0x0c,0x00,0xc3,0x0e,
     0x00,0x00,0xc3,0x0e,0x00,0x00,0x00,0x00,
     0x00,0x00,0x00,0x00,0x00,0x00};

    int numBytes = (SIZE * SIZE * BYTES_PER_PIXEL);
    int pos = 0;

    int xcoord = -256;
    int ycoord = -256;
    double zre;
    double zim;
    int escape;
    int bmpcount = 54;
    int zoom = 1;

    while (zurl != 0) {
      zoom = 2*zoom;
      zurl = zurl - 1;
    }
    zoom = zoom*256.000000000000000;

    while (pos < numBytes) {

        zre = xcoord/zoom + xurl;
        zim = ycoord/zoom + yurl;
        escape = escapeSteps(zre, zim);

        if(escape == BOUNDED) {
           bmp[bmpcount] = BLACK;
           bmp[bmpcount + 1] = BLACK;
           bmp[bmpcount + 2] = BLACK;
        } else {
           bmp[bmpcount] = stepsToRed(escape);
           bmp[bmpcount + 1] = stepsToGreen(escape);
           bmp[bmpcount + 2] = stepsToBlue(escape);
        }

        pos +=3;
        bmpcount +=3;

        xcoord = xcoord + 1;
        if (pos%SIZE == 0) {
             xcoord = -256;
            ycoord = ycoord + 1;
        }
    }
    write (socket, bmp, sizeof(bmp));
}
// Serving HTML/Content function
static void serveHTML (int socket) {
   
   // Initalizing message string.
   char *message;
   
   // first send the http response header
   // (if you write stings one after another like this on separate
   // lines the c compiler kindly joins them togther for you into
   // one long string)
   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));
   
   

   // Initalizing variables.
   double i,j,x,y,x0,y0,xTemp;
   int iteration;
   
   // Creating loader pixel struct to serve pixel colors to BMP array
   pixel loaderPixel;
   
   // Creating and filling out array of BMP data. 
   unsigned char bmp[BMP_ARRAY_SIZE] = {
   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,0x00,0x00,
   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   0x00,0x00,0x00,0x00,0x00,0x00};
   
   // After the header (54th byte) we include the pixel data.
   int start = BMP_Header_BYTE;
   
   // Row Loop.
   for(i=0.0;i<ROWS;i++){
      
      // Column Loop.
      for(j=0.0;j<COLUMNS;j++){
      
         // Reseting x,y to zero.
         y = 0;
         x = 0;
      
         // Scale X,Y points to within the Mandelbrot Set. 
         x0 = scaleX(j);
         y0 = scaleY(i);
      
         // Reset iteration counter.
         iteration = 0;
         
         // Calculation code paraphrased from Mandelbrot Wikipedia website.
         while ((x*x + y*y) < 4.0 && iteration<MAX_ITERATION)
         {
            xTemp = x*x - y*y + x0;
            y = 2.0*x*y + y0;

            x = xTemp;

            iteration++;
         }
         
         // Printing out color pixels corresponding to pixel color functions.
         loaderPixel.red = stepsToRed(iteration);
         loaderPixel.green = stepsToGreen(iteration); 
         loaderPixel.blue = stepsToBlue(iteration);
            
         // Increment through Bytes & include numbers for all BGR. 
         start++;
         bmp[start] = loaderPixel.blue;
         start++;
         bmp[start] = loaderPixel.green;
         start++;
         bmp[start] = loaderPixel.red;
 
      }
        
   } 
 
   // Now send the contents of the web page to be displayed  
   printf ("about to send=> %s\n", message);         
   write (socket, bmp, sizeof(bmp));
   
}