mandelbrot 0.1 → 0.1.2

data/ext/mandelbrot/bmp.c

@@ -0,0 +1,63 @@
+#include "bmp.h"
+
+void new_bmp_header(int width, int height, char* header)
+{
+    header[0] = 'B';
+    header[1] = 'M';
+    
+    // file size
+    *(uint32_t*)&(header[2]) = 54 + (((24 * width + 31)/32) * 4) * height;
+    
+    // reserved
+    *(uint32_t*)&(header[6]) = 0;
+    
+    // offset
+    *(uint32_t*)&(header[10]) = 54;
+    
+    // dib header size
+    *(uint32_t*)&(header[14]) = 40;
+    
+    // width
+    *(uint32_t*)&(header[18]) = width;
+    
+    // height
+    *(uint32_t*)&(header[22]) = height;
+    
+    // planes
+    *(uint16_t*)&(header[26]) = 1;
+    
+    // depth
+    *(uint16_t*)&(header[28]) = 24;
+    
+    // compression
+    *(uint32_t*)&(header[30]) = 0;
+    
+    // image size
+    *(uint32_t*)&(header[34]) = (((24 * width + 31)/32) * 4) * height;
+    
+    // horiz resolution
+    *(uint32_t*)&(header[38]) = 72;
+    
+    // vert resolution
+    *(uint32_t*)&(header[42]) = 72;
+    
+    // colour palette
+    *(uint32_t*)&(header[46]) = 0;
+    
+    // important colours
+    *(uint32_t*)&(header[50]) = 0;
+    
+    /*
+    header->file_header.magic[0] = 'B';
+    header->file_header.magic[1] = 'M';
+    header->file_header.file_size = (uint32_t)sizeof(bmp_header_t) + (((24 * width + 31)/32) * 4) * height;
+    header->file_header.reserved = 0;
+    header->file_header.offset = sizeof(bmp_header_t);
+    
+    header->dib_header.header_size = sizeof(bmp_dib_header_t);
+    header->dib_header.image_width = width;
+    header->dib_header.image_height = height;
+    header->dib_header.color_planes = 1;
+    header->dib_header.color_depth = 24;    
+    */
+}

data/ext/mandelbrot/bmp.h

@@ -0,0 +1,26 @@
+#include <stdlib.h>
+#include <stdint.h>
+
+/*
+typedef struct {
+    char magic[2];
+    uint32_t file_size;
+    uint32_t reserved;
+    uint32_t offset;
+} __attribute__((packed)) bmp_file_header_t;
+
+typedef struct {
+    uint32_t header_size;
+    uint16_t image_width;
+    uint16_t image_height;
+    uint16_t color_planes; // must be 1
+    uint16_t color_depth;
+} __attribute__((packed)) bmp_dib_header_t;
+
+typedef struct {
+    bmp_file_header_t file_header;
+    bmp_dib_header_t dib_header;
+} __attribute__((packed)) bmp_header_t;
+*/
+
+void new_bmp_header(int width, int height, char* header);

data/ext/mandelbrot/mandelbrot.c

@@ -1,17 +1,9 @@
-#include <stdlib.h>
-#include <stdbool.h>
-#include <complex.h>
-#include "ruby.h"
+#include "mandelbrot.h"
 
 static ID i_Complex = Qundef;
 static ID i_to_f = Qundef;
 static ID i_INFINITY = Qundef;
 
-static VALUE Float_INFINITY = Qundef;
-static VALUE Mandelbrot = Qundef;
-static VALUE Mandelbrot_initialize(int argc, VALUE* argv, VALUE self);
-static VALUE Mandelbrot_compute(VALUE self, VALUE _width, VALUE _height);
-
 static double rb_complex_re(VALUE cplx)
 {
     _Complex ret;
@@ -42,6 +34,7 @@ void Init_mandelbrot()
     Mandelbrot = rb_define_class("Mandelbrot", rb_cObject);
     rb_define_method(Mandelbrot, "initialize", Mandelbrot_initialize, -1);
     rb_define_method(Mandelbrot, "compute", Mandelbrot_compute, 2);
+    rb_define_method(Mandelbrot, "bmp", Mandelbrot_bmp, 2);
     rb_define_attr(Mandelbrot, "min", true, false);
     rb_define_attr(Mandelbrot, "max", true, false);
     rb_define_attr(Mandelbrot, "max_iters", true, true);
@@ -64,7 +57,7 @@ static VALUE Mandelbrot_initialize(int argc, VALUE* argv, VALUE self)
     
     rb_iv_set(self, "@min", min);
     rb_iv_set(self, "@max", max);
-    rb_iv_set(self, "@max_iters", INT2NUM(128));
+    rb_iv_set(self, "@max_iters", INT2NUM(256));
     
     return Qnil;
 }
@@ -76,6 +69,7 @@ static VALUE Mandelbrot_compute(VALUE self, VALUE _width, VALUE _height)
     int width, height;
     int max_iters;
     int x, y, iter;
+    int* grid;
     VALUE ary, col, tmp;
     VALUE r_min;
     VALUE r_max;
@@ -96,10 +90,10 @@ static VALUE Mandelbrot_compute(VALUE self, VALUE _width, VALUE _height)
     
     ary = rb_ary_new();
     for(x = 0; x < width; x++) {
+        x0 = (max_re - min_re) * ((double)x / (double)width) + min_re;
         col = rb_ary_new();
         rb_ary_push(ary, col);
         for(y = 0; y < height; y++) {
-            x0 = (max_re - min_re) * ((double)x / (double)width) + min_re;
             y0 = (max_im - min_im) * ((double)y / (double)height) + min_im;
             re = 0;
             im = 0;
@@ -108,13 +102,110 @@ static VALUE Mandelbrot_compute(VALUE self, VALUE _width, VALUE _height)
                 im = 2*re*im + y0;
                 re = retemp;
             }
-            if(x*x + y*y < 2*2) {
-                rb_ary_push(col, Float_INFINITY);
+            rb_ary_push(col, INT2NUM(x*x + y*y < 2*2 ? -1 : iter));
+        }
+    }
+    
+    return ary;
+}
+
+static inline void hsv_to_rgb(double h, double s, double v, char* r, char* g, char* b)
+{
+    double chroma = v * s;
+    double h_dash = h / 60.0;
+    double x = chroma * (1 - fabs(fmod(h_dash, 2.0) - 1));
+    if(h_dash < 1) {
+        *r = (char)(255 * chroma);
+        *g = (char)(255 * x);
+        *b = 0;
+    } else if(h_dash < 2) {    
+        *r = (char)(255 * x);
+        *g = (char)(255 * chroma);
+        *b = 0;
+    } else if(h_dash < 3) {
+        *r = 0;
+        *g = (char)(255 * chroma);
+        *b = (char)(255 * x);
+    } else if(h_dash < 4) {    
+        *r = 0;
+        *g = (char)(255 * x);
+        *b = (char)(255 * chroma);
+    } else if(h_dash < 5) {
+        *r = (char)(255 * x);
+        *g = 0;
+        *b = (char)(255 * chroma);
+    } else if(h_dash < 5) {    
+        *r = (char)(255 * chroma);
+        *g = 0;
+        *b = (char)(255 * x);
+    } else {
+        *r = 0;
+        *g = 0;
+        *b = 0;
+    }
+}
+
+static VALUE Mandelbrot_bmp(VALUE self, VALUE _width, VALUE _height)
+{
+    char* bmp = NULL;
+    char* bmp_image_data = NULL;
+    
+    double min_re, min_im, max_re, max_im;
+    double x0, y0, re, im, retemp;
+    int width, height;
+    int max_iters;
+    int x, y, iter;
+    int offset;
+    int* grid;
+    VALUE ary, col, tmp;
+    VALUE r_min;
+    VALUE r_max;
+    
+    rb_check_type(_width, T_FIXNUM);
+    rb_check_type(_height, T_FIXNUM);
+    width = NUM2INT(_width);
+    height = NUM2INT(_height);
+    
+    r_min = rb_iv_get(self, "@min");
+    r_max = rb_iv_get(self, "@max");
+    min_re = rb_complex_re(r_min);
+    min_im = rb_complex_im(r_min);
+    max_re = rb_complex_re(r_max);
+    max_im = rb_complex_im(r_max);
+    
+    max_iters = NUM2INT(rb_iv_get(self, "@max_iters"));
+    
+    
+    bmp = malloc(54 + (((24 * width + 31)/32) * 4) * height);
+    new_bmp_header(width, height, bmp);
+    bmp_image_data = bmp + 54;
+    
+    for(x = 0; x < width; x++) {
+        x0 = (max_re - min_re) * ((double)x / (double)width) + min_re;
+        for(y = 0; y < height; y++) {
+            y0 = (max_im - min_im) * ((double)y / (double)height) + min_im;
+            offset = (((24 * width + 31)/32) * 4) * y + x * 3;
+            re = 0;
+            im = 0;
+            for(iter = 0; iter < max_iters && (re*re + im*im < 2*2); iter++) {
+                retemp = re*re - im*im + x0;
+                im = 2*re*im + y0;
+                re = retemp;
+            }
+            if(re*re + im*im < 2*2) {
+                bmp_image_data[offset + 0] = 0;
+                bmp_image_data[offset + 1] = 0;
+                bmp_image_data[offset + 2] = 0;
             } else {
-                rb_ary_push(col, INT2NUM(iter));
+                hsv_to_rgb((iter / (double)max_iters) * 360, 1, /*1 - (iter / (double)max_iters),*/ 1 - (iter / (double)max_iters), &bmp_image_data[offset + 2], &bmp_image_data[offset + 1], &bmp_image_data[offset + 0]);
+                /*
+                bmp_image_data[offset + 0] = 255 - iter % 256;
+                bmp_image_data[offset + 1] = 255 - iter % 128;
+                bmp_image_data[offset + 2] = 255 - iter % 64;
+                */
             }
         }
     }
     
-    return ary;
+    return rb_str_new(bmp, 54 + (((24 * width + 31)/32) * 4) * height);
 }

data/ext/mandelbrot/mandelbrot.h

@@ -0,0 +1,13 @@
+#include <stdlib.h>
+#include <stdbool.h>
+#include <math.h>
+#include "bmp.h"
+#include "ruby.h"
+
+static VALUE Float_INFINITY = Qundef;
+static VALUE Mandelbrot = Qundef;
+static VALUE Mandelbrot_initialize(int argc, VALUE* argv, VALUE self);
+static VALUE Mandelbrot_compute(VALUE self, VALUE _width, VALUE _height);
+static VALUE Mandelbrot_bmp(VALUE self, VALUE _width, VALUE _height);
+
+int* mandelbrot_compute(int w, int h, double min_re, double min_im, double max_re, double max_im, int max_iter);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mandelbrot
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -18,7 +18,10 @@ extensions:
 - ext/mandelbrot/extconf.rb
 extra_rdoc_files: []
 files:
+- ext/mandelbrot/bmp.c
 - ext/mandelbrot/mandelbrot.c
+- ext/mandelbrot/bmp.h
+- ext/mandelbrot/mandelbrot.h
 - ext/mandelbrot/extconf.rb
 - lib/mandelbrot.rb
 homepage: https://github.com/charliesome/mandelbrot