let video;

let detections = [];

let eyes = [];

let lastPersonCount = 0;

let eyeMinDisplayTime = 10000;

​

function modelReady() {

  console.log('Model is ready!!!');

  mobilenet.detect(gotResults);

}

​

function gotResults(error, results) {

  if (error) {

    console.error(error);

  } else {

    detections = results;

    mobilenet.detect(gotResults);

  }

}

​

function setup() {

  createCanvas(800, 600);

  video = createCapture(VIDEO);

  video.size(800, 600);

  video.hide();

  mobilenet = ml5.objectDetector('cocossd', video, modelReady);

}

​

function draw() {

  background(0);

​

  let currentPersonCount = 0;

  let newEyes = [];

​

  if (detections) {

    for (let i = 0; i < detections.length; i++) {

      let object = detections[i];

      if (object.label === 'person') {

        let x = object.x + object.width / 2;

        let y = object.y;

        let diameter = min(object.width, object.height);

        newEyes.push({ x: x, y: y, diameter: diameter });

        noFill();

        stroke(255, 0, 0);

        strokeWeight(2);

        rect(object.x, object.y, object.width, object.height);

​

        currentPersonCount++;

      }

    }

    fill(255);

    textSize(20);

    text('Anzahl der Personen: ' + currentPersonCount, 10, 30);

  } else {

    fill(255);

    textSize(32);

    textAlign(CENTER, CENTER);

    text('Lade...', width / 2, height / 2);

  }

​

  if (currentPersonCount !== lastPersonCount) {

    eyes = updateEyes(currentPersonCount, newEyes, eyes);

    lastPersonCount = currentPersonCount;

  }

​

  eyes = smoothEyes(newEyes, eyes);

​

  drawEyes(eyes);

}

​

function updateEyes(personCount, newEyes, existingEyes) {

  let updatedEyes = [];

​

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

    let eye = newEyes[i];

    let found = false;

​

    for (let j = 0; j < existingEyes.length; j++) {

      let existingEye = existingEyes[j];

      if (dist(existingEye.x, existingEye.y, eye.x, eye.y) < eye.diameter / 2) {

        updatedEyes.push(existingEye);

        found = true;

        break;

      }

    }

​

    if (!found) {

      let newCircle;

      let safeToAdd;

      let tries = 0;

      let maxTries = 100;

​

      do {

        let offsetX = random(-eye.diameter / 2, eye.diameter / 2);

        let offsetY = random(-eye.diameter / 2, eye.diameter / 2);

        newCircle = {

          x: eye.x + offsetX,

          y: eye.y + offsetY,

          diameter: eye.diameter,

          creationTime: millis()

        };

        safeToAdd = true;

​

        for (let j = 0; j < updatedEyes.length; j++) {

          let otherCircle = updatedEyes[j];

          let distance = dist(newCircle.x, newCircle.y, otherCircle.x, otherCircle.y);

          if (distance < (newCircle.diameter / 2 + otherCircle.diameter / 2)) {

            safeToAdd = false;

            break;

          }

        }

        tries++;

      } while (!safeToAdd && tries < maxTries);

​

      if (safeToAdd) {

        updatedEyes.push(newCircle);

      }

    }

  }

​

  updatedEyes = updatedEyes.filter(eye => millis() - eye.creationTime < eyeMinDisplayTime);

​

  return updatedEyes;

}

​

function smoothEyes(newEyes, existingEyes) {

  return newEyes.map((newEye, index) => {

    let existingEye = existingEyes[index] || newEye;

​

    return {

      x: lerp(existingEye.x, newEye.x, 0.2),

      y: lerp(existingEye.y, newEye.y, 0.2),

      diameter: newEye.diameter,

      creationTime: existingEye.creationTime

    };

  });

}

​

function drawEyes(eyes) {

  for (let i = 0; i < eyes.length; i++) {

    let eye = eyes[i];

​

    let circle1 = { x: eye.x, y: eye.y, diameter: eye.diameter };

    let circle2 = { x: eye.x, y: eye.y, diameter: eye.diameter * 0.8 };

    let circle3 = { x: eye.x, y: eye.y, diameter: eye.diameter * 0.6 };

    let circle4 = { x: eye.x, y: eye.y, diameter: eye.diameter * 0.4 };

    let circle5 = { x: eye.x, y: eye.y, diameter: eye.diameter * 0.2 };

​

    let targetX = eye.x;

    let targetY = eye.y;

​

    let speed1 = 0.08;

    let speed2 = 0.06;

    let speed3 = 0.04;

    let speed4 = 0.02;

    let speed5 = 0.01;

​

    circle1.x += (targetX - circle1.x) * speed1;

    circle1.y += (targetY - circle1.y) * speed1;

​

    circle2.x += (targetX - circle2.x) * speed2;

    circle2.y += (targetY - circle2.y) * speed2;

​

    circle3.x += (targetX - circle3.x) * speed3;

    circle3.y += (targetY - circle3.y) * speed3;

​

    circle4.x += (targetX - circle4.x) * speed4;

    circle4.y += (targetY - circle4.y) * speed4;

​

    circle5.x += (targetX - circle5.x) * speed5;

    circle5.y += (targetY - circle5.y) * speed5;

​

    limitWithinCircle(circle1, circle2);

    limitWithinCircle(circle1, circle3);

    limitWithinCircle(circle1, circle4);

    limitWithinCircle(circle1, circle5);

​

    fill(0);

    ellipse(circle1.x, circle1.y, circle1.diameter, circle1.diameter);

​

    fill(255);

    ellipse(circle2.x, circle2.y, circle2.diameter, circle2.diameter);

​

    fill(0, 0, 255, 150);

    ellipse(circle3.x, circle3.y, circle3.diameter, circle3.diameter);

​

    fill(0, 0, 255);

    ellipse(circle4.x, circle4.y, circle4.diameter, circle4.diameter);

​

    fill(0);

    ellipse(circle5.x, circle5.y, circle5.diameter, circle5.diameter);

  }

}

​

function limitWithinCircle(outerCircle, innerCircle) {

  let dx = innerCircle.x - outerCircle.x;

  let dy = innerCircle.y - outerCircle.y;

  let distance = sqrt(dx * dx + dy * dy);

  let maxDistance = (outerCircle.diameter - innerCircle.diameter) / 2;

​

  if (distance > maxDistance) {

    let angle = atan2(dy, dx);

    innerCircle.x = outerCircle.x + cos(angle) * maxDistance;

    innerCircle.y = outerCircle.y + sin(angle) * maxDistance;

  }

}

​