fabrizio augusto poltronieri

bézier 0685

bézier 0512

float espessuraLinha, corR, corG, corB, x1, y1, x2, y2, x3, y3, x4, y4;
boolean pausa=false;

void setup() {
  size (1680, 1680);
  background (255, 255, 255);
  smooth();
  noFill();
  frameRate(5);
}

void draw() {
  if (!pausa) desenhaBezier();
}

void keyPressed() {
  if (key == ' ') pausa = !pausa;
  if (key == 'b' || key == 'B') blur(1);
  if (key == 's' || key == 'S') saveFrame("####.tif");
}

void desenhaBezier() {
  //valores randomicos
  espessuraLinha = random(1, 5);
  corR = random(0, 255);
  corG = random(0, 255);
  corB = random(0, 255);

  x1 = 0;
  y1 = random(0, 1680);

  x2 = random(0, 1680);
  y2 = random(334, 434);

  x3 = random(0, 1680);
  y2 = random(334, 434);

  x4 = 1680;
  y4 = random(334, 434);

  //espessura da linha
  strokeWeight(espessuraLinha);

  //cor do bezier
  stroke(corR, corG, corB);

  //desenha bezier
  bezier(x1, y1, x2, y2, x3, y3, x4, y4);
}

void blur(int blurDiam) {
  int gaussWidth = (blurDiam * 2)+1;
  float[] kernel = new float[gaussWidth];
  float sourceR, sourceG, sourceB;
  float destR, destG, destB;
  int shift, dest, source;
  float gaussSum = 0;

  //kernel
  // Set the maximum value of the Gaussian curve
  float sd = 255;   

  // Set the width of the Gaussian curve
  float range = gaussWidth;  

  // Set the average value of the Gaussian curve
  float mean = (range / sd);  

  // Set first half of Gaussian curve in kernel
  for (int pos = 0; pos < blurDiam+1; pos++){  

    // Distribute Gaussian curve across kernel[array]
    kernel[pos] = sq(sin((((pos+1)*HALF_PI) - mean) / range))*sd;  

    // Mirror the kernel values
    kernel[gaussWidth-1-pos] = kernel[pos];
  } 

  //blur
  for (int n=0; n < gaussWidth; n++){
    gaussSum += kernel[n];
  };

  // Copy the current Canvas to the pixels[array]
  loadPixels();  

  // Create an X & Y pass buffer
  color[] gaussPassX = new color[pixels.length];
  color[] gaussPassY = new color[pixels.length]; 

  // Do Horizontal Pass
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      dest = y*width+x;  

      // Iterate through kernel
      for (int k=0; k < gaussWidth; k++){  

        // Get pixel-shift (pixel dist between dest and source)
        shift = k - blurDiam;      

        // Basic edge clamp
        source = dest + shift;
        if (x+shift <= 0 || x+shift >= width) {
          source = dest;
        }  

        // Read source pixel through kernel matrix from pixels[array]
        sourceR = red  (pixels[ source ]);
        sourceG = green(pixels[ source ]);
        sourceB = blue (pixels[ source ]);          

        // Combine source and destination pixels with Gaussian Weight
        destR = red  (gaussPassX[dest]) + (sourceR * kernel[k]) /gaussSum;
        destG = green(gaussPassX[dest]) + (sourceG * kernel[k]) /gaussSum;
        destB = blue (gaussPassX[dest]) + (sourceB * kernel[k]) /gaussSum;  

        // Store color in X pass array
        gaussPassX[dest] = color(destR, destG, destB);
      }
    }
  }

  // Do Vertical Pass
  for (int x = 0; x < height; x++){
    for (int y = 0; y < width; y++){
      dest = y*width+x;  

      // Iterate through kernel
      for (int k=0; k < gaussWidth; k++){  

        // Get pixel-shift (pixel dist between dest and source)
        shift = k - blurDiam;          

        // Basic edge clamp
        source = dest + (shift*height);
        if (y+shift <= 0 || y+shift >= height) {
          source = dest;
        }  

        // Read source pixel through kernel matrix from pass X
        sourceR = red  (gaussPassX[ source ]);
        sourceG = green(gaussPassX[ source ]);
        sourceB = blue (gaussPassX[ source ]);          

        // Combine source and destination pixels with Gaussian Weight
        destR = red  (gaussPassY[dest]) + (sourceR * kernel[k]) /gaussSum;
        destG = green(gaussPassY[dest]) + (sourceG * kernel[k]) /gaussSum;
        destB = blue (gaussPassY[dest]) + (sourceB * kernel[k]) /gaussSum;  

        // Store color in Y pass array
        gaussPassY[dest] = color(destR, destG, destB);
      }
    }
  }  

  // Copy Gaussian Y buffer to pixels[array]
  for (int pixel = 0; pixel < pixels.length; pixel++){
    pixels[pixel] = color( gaussPassY[pixel] );
  }  

  // Update the Canvas with the pixel[array]
  updatePixels();
}