• fullscreen
  • Sierpinski_Carpet.pde
  • /*
     *   Sierpinski Carpet 
     *   by Martin Pasko
     */
    
    // width of big block
    int blockWidth = 600;
    
    void setup()
    {
      size(blockWidth,blockWidth);  // size of screen
      background(0);
     // stroke(255);
      noLoop();
    }
    
    /* Make Sierpinski Carpet
     * params: x - screen x coordinate
     *         y - screen y coordinate
     *         sideWidth - width of  'one' chunk
     *         level - how deep carpet must be drawn
     */
    void carpet(float x, float y, float sideWidth, int level)
    {
        // 1. Divide big block by 3. This variable has width of one small rectancle in big one
        float block = sideWidth / 3 ;
         
        // go through each small block...
        if ( level > 0 && level <= 6)
        { 
          for (int i = 0; i < 3; ++i)      // rows
          {
            for (int j = 0; j < 3; ++j)    // cols
            {
              // ... is it middle block?
              if (i == 1 && j == 1)        
              {
                //     stroke(0);
                //  set color to white..
                fill(255);
                // ... and draw rectangle on middle of block
                rect(x + (block * i), y + (block *j) , block, block);
                // ... and go to the next j iteration
                continue;
              }
              // ...otherwise
              else
              {
               // stroke(255);
                // ... set color to black
                fill(0);
            
              }
              // draw the rectangle...
              rect(x + (block * i), y + (block *j) , block, block);
              // and call again carpet function, but with decremented level for drawing small rectangles 
              carpet(x + (block * i), y + (block *j), block, level-1);
            }
          }
        }    
    }
    
    void draw()
    {
      // draw carpet           level
      carpet(0, 0, blockWidth, 6);
      // and next colour carpet
      colour();
    }
    
    // Colour the carpet
    void colour()
    {
      /*
       * x - screen x coordinate
       * y - screen y coordinate
       * r - red color
       * g - green color
       * b - blue color
       * loc - is a location of pixel 
       */
      int x, y, r, g, b, loc;
      
      // loading pixels array
      loadPixels();
      for (y = 0; y < height; ++y)  // y - rows
      {
        for (x = 0; x < width; ++x)  // x - cols
        {
          // calculating the location of pixel
          // x - cols, y - rows, width - width of rows
          loc = x + y * width;
          
          // Each pixel is an 32 bit value.
          // paradigm in HEX is:
          //             0xAARRGGBB
          // where:
          //   AA - alpha channel; 00 - transparent, FF - no transparent
          //   RR - red color;   from 00 to FF   (0 - 255 in DEC)
          //   GG - green color; from 00 to FF   (0 - 255 in DEC)
          //   BB - blue color;  from 00 to FF   (0 - 255 in DEC)
          
          // if pixel is black...
          if (pixels[loc] == 0xff000000)
          {
            // calculate new color
            r = (255 * x) / (width - 1);
            g = (255 * y) / (height - 1);
            b =  255 -(255 * x * y) / (width - 1) / (height - 1);
            
            // first color scheme is:  
            //   b, g, r  for black
            //   r, b, g  for white
            // second:
            //   r, g, b  for black
            //   b, r, g  for white
              
            // ... and change the black color on new calculated color;
            pixels[loc] = (0xff << 24) | (r << 16) | (g << 8) | (b << 0);
            // if you don't understand code above you can use this:
            //   color newColor = color(r,g,b);
            //   pixels[loc] = (int)newColor;  
          }
          // .. else if color is white
          else if (pixels[loc] == 0xffffffff)
          {
            // calculate new color
            b = (255 * x) / (width - 1);
            r = (255 * y) / (height - 1);
            g = 255 -(255 * x * y) / (width - 1) / (height - 1);
            
            // ... and change the white color on new calculated color; 
            pixels[loc] = (0xff << 24) | (r << 16) | (g << 8) | (b << 0);
            // if you don't understand code above you can use this:
            //   color newColor = color(r,g,b);
            //   pixels[loc] = (int)newColor;  
          }
        }
      }
      updatePixels();  // and update pixels
      
    }
    

    code

    tweaks (0)

    about this sketch

    This sketch is running as Java applet, exported from Processing.

    license

    advertisement

    Martin Pasko

    Sierpinski_Carpet

    Add to Faves Me Likey@!
    You must login/register to add this sketch to your favorites.

    You need to login/register to comment.