depression _ba

//noprotect

let img, bsize;

let changeRate = 0.1;

let darknessFactor = 0.15;

​

function preload() {

  img = loadImage('IMG_9214.jpg'); 

}

​

function setup() {

  wisW = windowWidth;

  wisH = windowHeight;

  wis = min(wisW, wisH);

  createCanvas(wis, wis);

}

​

function draw() {

  img.loadPixels();

​

  // Contrôle le niveau de distorsion

  let kernelSize = lerp(5, 50, changeRate);

  let intensity = lerp(5, 50, changeRate);

​

  for (let i = 0; i < 200; i++) {

    let x = int(random(img.width));

    let y = int(random(img.height));

    if (random(1) > 0.75) {

      applyDisto(x, y, kernelSize, intensity);

    }

  }

​

  // Sous-échantillonnage aléatoire pour le flou

  for (let i = 0; i < 10; i++) {

    let x = int(random(img.width));

    let y = int(random(img.height));

    bsize = int(random(20, 50));

    applyRandomBlur(x, y, bsize);

  }

  if (random(1) > 0.89) {

    fractureImage();

  }

  if (random(1) > 0.98) {

    lightenEdges();

  }

​

  if (random(1) > 0.95) {

    darkenEdges();

  }

​

  img.updatePixels();

  image(img, 0, 0);

  changeRate += 0.025; 

  if (changeRate >= 1) {

    changeRate = 0;  

  }

}

​

function applyDisto(x, y, bsize, intensity) {

  if (x - bsize < 0 || x + bsize >= img.width || y - bsize < 0 || y + bsize >= img.height) {

    return;

  }

​

  let r = 0, g = 0, b = 0;

  let count = 0;

  for (let i = -bsize; i <= bsize; i++) {

    for (let j = -bsize; j <= bsize; j++) {

      let xloc = x + i;

      let yloc = y + j;

      let loc = (xloc + yloc * img.width) * 4;

      r += img.pixels[loc];

      g += img.pixels[loc + 1];

      b += img.pixels[loc + 2];

      count++;

    }

  }

  r = r / count / intensity;

  g = g / count / intensity;

  b = b / count / intensity;

​

  let loc = (x + y * img.width) * 4;

  img.pixels[loc] = r;

  img.pixels[loc + 1] = g;

  img.pixels[loc + 2] = b;

}

​

function applyRandomBlur(xStart, yStart, size) {

  if (xStart < 0 || xStart + size >= img.width || yStart < 0 || yStart + size >= img.height) {

    return;

  }

  let kernel = [[1 / 16, 2 / 16, 1 / 16],

                [2 / 16, 4 / 16, 2 / 16],

                [1 / 16, 2 / 16, 1 / 16]];

​

  for (let x = xStart; x < xStart + size; x++) {

    for (let y = yStart; y < yStart + size; y++) {

      let r = 0, g = 0, b = 0;

      for (let dx = -1; dx <= 1; dx++) {

        for (let dy = -1; dy <= 1; dy++) {

          let xloc = x + dx;

          let yloc = y + dy;

          if (xloc >= 0 && xloc < img.width && yloc >= 0 && yloc < img.height) {

            let loc = (xloc + yloc * img.width) * 4;

            r += img.pixels[loc] * kernel[dx + 1][dy + 1];

            g += img.pixels[loc + 1] * kernel[dx + 1][dy + 1];

            b += img.pixels[loc + 2] * kernel[dx + 1][dy + 1];

          }

        }

      }

      let newLoc = (x + y * img.width) * 4;

      img.pixels[newLoc] = r;

      img.pixels[newLoc + 1] = g;

      img.pixels[newLoc + 2] = b;

    }

  }

}

​

function fractureImage() {

  img.loadPixels();

​

  if (random(1) > 0.5) {

    // Fracturer une ligne

    let y = int(random(img.height));

    let shiftAmount = int(random(-20, 20)); 

​

    for (let x = 0; x < img.width; x++) {

      let srcX = x + shiftAmount;

      if (srcX >= 0 && srcX < img.width) {

        let srcLoc = (srcX + y * img.width) * 4;

        let destLoc = (x + y * img.width) * 4;

​

        img.pixels[destLoc] = img.pixels[srcLoc];

        img.pixels[destLoc + 1] = img.pixels[srcLoc + 1];

        img.pixels[destLoc + 2] = img.pixels[srcLoc + 2];

      }

    }

  } else {

    // Fracturer une colonne

    let x = int(random(img.width));

    let shiftAmount = int(random(-20, 20)); // Choisir un montant de décalage

​

    for (let y = 0; y < img.height; y++) {

      let srcY = y + shiftAmount;

      if (srcY >= 0 && srcY < img.height) {

        let srcLoc = (x + srcY * img.width) * 4;

        let destLoc = (x + y * img.width) * 4;

​

        img.pixels[destLoc] = img.pixels[srcLoc];

        img.pixels[destLoc + 1] = img.pixels[srcLoc + 1];

        img.pixels[destLoc + 2] = img.pixels[srcLoc + 2];

      }

    }

  }

​

  img.updatePixels();

}

​

function lightenEdges() {

  img.loadPixels();

​

  let darknessFactor = 0.15;

  for (let x = 0; x < img.width; x++) {

    for (let y = 0; y < img.height; y++) {

      let loc = (x + y * img.width) * 4;

      //let distanceToEdge = min(x, img.width - x, y, img.height - y);

      let distanceToEdge = min(x, wis - x, y, wis - y);

​

      let factor = max(1 - (distanceToEdge / (img.width / darknessFactor)), 0);

      img.pixels[loc] *= factor;

      img.pixels[loc + 1] *= factor;

      img.pixels[loc + 2] *= factor;

    }

  }

​

  img.updatePixels();

}

​

function darkenEdges() {

  img.loadPixels();

​

  let darknessFactor = 0.35; // Plus cette valeur est petite, plus l'assombrissement est important

​

  for (let x = 0; x < img.width; x++) {

    for (let y = 0; y < img.height; y++) {

      let loc = (x + y * img.width) * 4;

      let distanceToEdge = min(x, img.width - x, y, img.height - y);

​

      let factor = min(1 + (distanceToEdge / (img.width / darknessFactor)), 1);

      img.pixels[loc] *= factor;

      img.pixels[loc + 1] *= factor;

      img.pixels[loc + 2] *= factor;

    }

  }

​

  img.updatePixels();

}

​

function keyPressed() {

  if (keyCode === 83) {

    saveCanvas('depression__b-' + floor(random(100)), 'png');

  }

}

​