let video;

let detections = [];

let eyes = []; // Array zum Speichern der Augenpositionen und -größen

let eyeMinDisplayTime = 10000; // Mindestanzeigezeit für die Augen in Millisekunden

​

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(220);

​

  // Zeichne das Video und erkenne Personen

  image(video, 0, 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; // Mitte des Rechtecks

        let y = object.y; // Oberer Rand des Rechtecks

        let diameter = min(object.width, object.height); // Durchmesser basierend auf der kleineren Seite des Rechtecks

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

​

        noFill();

        stroke(255, 0, 0);

        strokeWeight(2);

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

      }

    }

    fill(255);

    textSize(20);

    text('Anzahl der Personen: ' + newEyes.length, 10, 30);

  } else {

    fill(255);

    textSize(32);

    textAlign(CENTER, CENTER);

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

  }

​

  // Aktualisiere die Augenpositionen und -anzeigen

  updateEyes(newEyes);

​

  // Zeichne die Augen

  drawEyes(newEyes);

}

​

function updateEyes(newEyes) {

  // Aktualisiere die letzten Sichtungszeiten für vorhandene Augen

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

    let newEye = newEyes[i];

    let found = false;

​

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

      let existingEye = eyes[j];

      if (dist(existingEye.x, existingEye.y, newEye.x, newEye.y) < newEye.diameter) {

        existingEye.lastSeenTime = millis();

        existingEye.diameter = newEye.diameter;

        found = true;

        break;

      }

    }

​

    // Wenn kein passendes Auge gefunden wurde, füge ein neues Auge hinzu

    if (!found) {

      placeEye(newEye);

    }

  }

​

  // Entferne Augen, die länger als die Mindestanzeigezeit nicht mehr gesehen wurden

  eyes = eyes.filter(eye => millis() - eye.lastSeenTime < eyeMinDisplayTime);

}

​

function placeEye(newEye) {

  let safeToAdd;

  let tries = 0;

  let maxTries = 100;

​

  do {

    newEye.x = random(newEye.diameter / 2, width - newEye.diameter / 2);

    newEye.y = random(newEye.diameter / 2, height - newEye.diameter / 2);

    safeToAdd = true;

​

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

      let otherEye = eyes[j];

      let distance = dist(newEye.x, newEye.y, otherEye.x, otherEye.y);

      if (distance < (newEye.diameter + otherEye.diameter) / 2) {

        safeToAdd = false;

        break;

      }

    }

    tries++;

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

​

  if (safeToAdd) {

    newEye.creationTime = millis();

    eyes.push(newEye);

  } else {

    console.log("Could not place eye without overlap after " + maxTries + " attempts");

  }

}

​

function drawEyes(newEyes) {

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

    let eye = eyes[i];

    let personFound = false;

​

    // Zeichne den äußeren schwarzen Kreis

    fill(0);

    noStroke();

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

​

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

      let person = newEyes[j];

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

        personFound = true;

​

        // Berechne die Position des inneren weißen Kreises basierend auf der Position der Person

        let innerDiameter = eye.diameter / 2;

        let maxOffset = (eye.diameter - innerDiameter) / 2;

​

        // Setze den weißen Kreis an die obere Kante des erkannten Rechtecks

        let whiteX = eye.x - (person.x - eye.x) * 0.5;

        let whiteY = eye.y - (person.y - eye.y) * 0.5 - person.diameter / 2;

​

        // Begrenze die Position des weißen Kreises, um sicherzustellen, dass er nicht über den Rand des schwarzen Kreises hinausgeht

        let distanceToEdge = dist(whiteX, whiteY, eye.x, eye.y);

        if (distanceToEdge > maxOffset) {

          let factor = maxOffset / distanceToEdge;

          whiteX = eye.x + (whiteX - eye.x) * factor;

          whiteY = eye.y + (whiteY - eye.y) * factor;

        }

​

        fill(255);

        ellipse(whiteX, whiteY, innerDiameter, innerDiameter);

​

        // Berechne die Position des inneren blauen Kreises basierend auf der Position des weißen Kreises

        let blueDiameter = innerDiameter * 0.7; // Der Durchmesser des blauen Kreises ist 70% des Durchmessers des weißen Kreises

        let blueMaxOffset = (innerDiameter - blueDiameter) / 2;

​

        let blueOffsetX = constrain(whiteX - eye.x, -blueMaxOffset, blueMaxOffset);

        let blueOffsetY = constrain(whiteY - eye.y, -blueMaxOffset, blueMaxOffset);

​

        fill(0, 0, 255);

        ellipse(whiteX + blueOffsetX, whiteY + blueOffsetY, blueDiameter, blueDiameter);

      }

    }

​

    if (!personFound) {

      let innerDiameter = eye.diameter / 2;

      fill(255);

      ellipse(eye.x, eye.y, innerDiameter, innerDiameter);

      fill(0, 0, 255);

      ellipse(eye.x, eye.y, innerDiameter * 0.7, innerDiameter * 0.7);

    }

  }

}

​

​

​

​