U0205 Gegensatzpaare - Leicht und Schwer

Aufgabenstellung

Visualisieren Sie in zwei nebeneinander liegenden Quadraten jeweils die Eigenschaften leicht und schwer. Ordnen Sie dazu verschiedene Punktetypen an. Es geht darum, eine aufbauende Systematik zu entwickeln, so dass mehrere Gegensatzpaare entstehen. Nutzen Sie eine 4x3 Matrix für insgesamt 12 Varianten des Gegensatzpaares.

Woraus besteht Ihre finale Systematik? Welches Gegensatzpaar gefällt Ihnen am besten/schlechtesten? Dokumentieren sie ihr Ergebnis in MKDocs.

Umsetzung

Kommentare

Meine finale Systematik basiert auf der Variation folgender Aspekte:

Punktanzahl:
„Schwere“ wurde häufig durch eine größere Punktanzahl, engere Ballung oder Überlagerung ausgedrückt, während „Leichtigkeit“ oft durch wenige, lockere oder vereinzelt angeordnete Punkte visualisiert wurde.
Abstand und Dichte:
„Schwer“ zeigt sich als konzentrierte Ansammlung, bei der die Punkte dicht beieinanderliegen oder sich sogar überschneiden. Bei „Leicht“ stehen die Punkte hingegen mit großem Abstand zueinander, wodurch mehr Freiraum und Luftigkeit entsteht.
Position im Raum:
Schwere Ansammlungen wandern eher nach unten oder in die Ecke des Quadrats, während leichte Anordnungen eher nach oben, seitlich oder „schwebend“ im Raum positioniert wurden.
Regelmäßigkeit vs. Unregelmäßigkeit:
„Schwer“ wurde oft durch geordnete, symmetrische Strukturen dargestellt, die einen stabilen und festen Eindruck machen. Bei „Leicht“ finden sich dagegen viele unregelmäßige, fast zufällig wirkende Anordnungen, was Dynamik und Unbeschwertheit verstärkt.
Formbildung:
Geschlossene Kreis- oder Blockformen bei „Schwer“ kontrastieren mit offenen Linien, Bögen oder locker verteilten Punkten bei „Leicht“.

Bewertung der Gegensatzpaare
Am besten gelungen:
Besonders gelungen finde ich das Gegensatzpaar in der zweiten Zeile, erste Spalte (Kreisbildung bei „leicht“ und dichte Matrix bei „schwer“). Hier wird mit klaren geometrischen Strukturen gearbeitet: Der lockere, offene Kreis steht für Leichtigkeit und Offenheit, während die dichte Blockstruktur ein Gefühl von Gewicht und Kompaktheit vermittelt.

Am wenigsten gelungen:
Weniger überzeugend ist für mich das Gegensatzpaar in der dritten Zeile, zweite Spalte (verstreute Punkte für „leicht“, zusammengeballte Punkte für „schwer“). Zwar wird der Unterschied sichtbar, jedoch wirken die Verteilungen zu beliebig und könnten mit etwas mehr Systematik noch klarer die Begriffe abbilden.

Code

int cols = 4;
int rows = 3;
int pairWidth = 300;
int pairHeight = 300;
int margin = 30;
void setup() {
  size(1380, 1020); // (300 + 30) * 4 = 1320, (300 + 30) * 3 = 990 + etwas Rand
  background(255);
  noLoop();
  drawMatrix();
  saveFrame("output/U0205-Gegensatzpaare.png");
  println("Matrix gespeichert.");
}
void drawMatrix() {
  for (int r = 0; r < rows; r++) {
    for (int c = 0; c < cols; c++) {
      int pairIndex = r * cols + c;
      float x0 = c * (pairWidth + margin);
      float y0 = r * (pairHeight + margin);

      drawPair(x0, y0, pairWidth, pairHeight, pairIndex);
    }
  }
}
void drawPair(float x, float y, int w, int h, int index) {
  float half = w / 2;

  stroke(0);
  noFill();
  rect(x, y, w, h);
  line(x + half, y, x + half, y + h); // Trennlinie zwischen leicht/schwer

  noStroke();
  fill(0);

  switch (index) {
    case 0:
      drawLight(x, y, half, h, "top");     drawHeavy(x + half, y, half, h, "bottom"); break;
    case 1:
      drawLight(x, y, half, h, "loose");   drawHeavy(x + half, y, half, h, "dense"); break;
    case 2:
      drawLight(x, y, half, h, "few");     drawHeavy(x + half, y, half, h, "many"); break;
    case 3:
      drawLight(x, y, half, h, "spread");  drawHeavy(x + half, y, half, h, "centered"); break;
    case 4:
      drawLight(x, y, half, h, "circle");  drawHeavy(x + half, y, half, h, "block"); break;
    case 5:
      drawLight(x, y, half, h, "random");  drawHeavy(x + half, y, half, h, "grid"); break;
    case 6:
      drawLight(x, y, half, h, "asym");    drawHeavy(x + half, y, half, h, "sym"); break;
    case 7:
      drawLight(x, y, half, h, "tiny");    drawHeavy(x + half, y, half, h, "large"); break;
    case 8:
      drawLight(x, y, half, h, "upward");  drawHeavy(x + half, y, half, h, "downward"); break;
    case 9:
      drawLight(x, y, half, h, "float");   drawHeavy(x + half, y, half, h, "drop"); break;
    case 10:
      drawLight(x, y, half, h, "dispersed"); drawHeavy(x + half, y, half, h, "cluster"); break;
    case 11:
      drawLight(x, y, half, h, "open");    drawHeavy(x + half, y, half, h, "tight"); break;
  }
}
void drawLight(float x, float y, float w, float h, String type) {
  pushMatrix();
  translate(x + w / 2, y + h / 2);
  drawPoints(type, true);
  popMatrix();
}
void drawHeavy(float x, float y, float w, float h, String type) {
  pushMatrix();
  translate(x + w / 2, y + h / 2);
  drawPoints(type, false);
  popMatrix();
}
void drawPoints(String type, boolean isLight) {
  int count = isLight ? 6 : 20;
  float r = isLight ? 8 : 12;

  if (type.equals("top")) {
    for (int i = 0; i < count; i++) ellipse(random(-40, 40), random(-100, -40), r, r);
  } else if (type.equals("bottom")) {
    for (int i = 0; i < count; i++) ellipse(random(-40, 40), random(40, 100), r, r);
  } else if (type.equals("loose") || type.equals("dispersed") || type.equals("float")) {
    for (int i = 0; i < count; i++) ellipse(random(-100, 100), random(-100, 100), r, r);
  } else if (type.equals("dense") || type.equals("cluster") || type.equals("drop")) {
    for (int i = 0; i < count; i++) ellipse(random(-30, 30), random(-30, 30), r, r);
  } else if (type.equals("few")) {
    for (int i = 0; i < 4; i++) ellipse(random(-60, 60), random(-60, 60), r, r);
  } else if (type.equals("many")) {
    for (int i = 0; i < 30; i++) ellipse(random(-70, 70), random(-70, 70), r, r);
  } else if (type.equals("spread")) {
    for (int i = 0; i < 9; i++) ellipse(random(-80, 80), random(-80, 80), r, r);
  } else if (type.equals("centered")) {
    for (int i = 0; i < 9; i++) ellipse(random(-20, 20), random(-20, 20), r, r);
  } else if (type.equals("circle")) {
    for (int i = 0; i < 9; i++) {
      float a = TWO_PI / 9 * i;
      ellipse(cos(a) * 40, sin(a) * 40, r, r);
    }
  } else if (type.equals("block") || type.equals("grid")) {
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        ellipse(-30 + i * 30, -30 + j * 30, r, r);
  } else if (type.equals("random")) {
    for (int i = 0; i < 9; i++) ellipse(random(-80, 80), random(-80, 80), r, r);
  } else if (type.equals("asym")) {
    for (int i = 0; i < 9; i++) ellipse(random(-100, 20), random(-100, 100), r, r);
  } else if (type.equals("sym")) {
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        ellipse(i * 30 - 30, j * 30 - 30, r, r);
  } else if (type.equals("tiny")) {
    for (int i = 0; i < 5; i++) ellipse(random(-50, 50), random(-50, 50), 6, 6);
  } else if (type.equals("large")) {
    for (int i = 0; i < 5; i++) ellipse(random(-30, 30), random(-30, 30), 18, 18);
  } else if (type.equals("upward")) {
    for (int i = 0; i < 6; i++) ellipse(i * 10 - 30, -i * 15 + 40, r, r);
  } else if (type.equals("downward")) {
    for (int i = 0; i < 6; i++) ellipse(i * 10 - 30, i * 15 - 40, r, r);
  } else if (type.equals("open")) {
    for (int i = 0; i < 9; i++) ellipse(cos(i) * 50, sin(i) * 30, r, r);
  } else if (type.equals("tight")) {
    for (int i = 0; i < 9; i++) ellipse(cos(i) * 10, sin(i) * 10, r, r);
  }
}