U0208 Punktübung in drei Schritten - Teil 2

Aufgabenstellung

Drei Serien mit drei quadratischen Grundflächen (Schritten) pro Zeile (3x3 Matrix). Setzen Sie die Punkte unter Verwendung eines eigenen Rasters: (Entwerfe bei Bedarf neue Werkzeuge)

Gleich große Punkte, Anzahl zunehmend, kein Anschnitt. Zwei Punktgrößen, Anzahl zunehmend, kein Anschnitt. Drei Punktgrößen, Anzahl zunehmend, kein Anschnitt.

Welche neuen Fragen ergeben sich? Wie verändert ein Raster ein Entwurf? Vorteile/Nachteile? Welche Ergebnisse gefallen Ihnen besonders? Welche nicht? Dokumentieren sie ihr Ergebnis in MKDocs.

Umsetzung

Kommentare

1. Serie: Gleich große Punkte
   Vorgehen: Die Punkte wurden regelmäßig in einem klassischen Raster platziert.
   Wirkung: Je mehr Punkte hinzugefügt werden, desto geschlossener, gleichmäßiger und fast schon „industriell“ wirkt die Fläche. Der steigende Füllgrad verstärkt die visuelle Dichte, ohne die Ordnung zu verlieren.
   Besonderheit: Das regelmäßige Raster sorgt für Harmonie und Vorhersehbarkeit. Jeder Punkt bekommt die gleiche „Bedeutung“ im Bild.
   

2. Serie: Zwei Punktgrößen
   Vorgehen: Im Raster wechseln sich kleine und große Punkte systematisch ab (z.B. Schachbrettmuster oder ein anderes, festgelegtes Verteilungsmuster).
   Wirkung: Die Fläche wirkt lebendiger und dynamischer, da die großen Punkte sofort ins Auge springen. Dennoch sorgt das Raster für Klarheit und Wiedererkennbarkeit.
   Besonderheit: Es entsteht eine subtile Hierarchie im Bild, aber durch die Rasterstruktur bleibt das Gesamtbild ruhig.
   

3. Serie: Drei Punktgrößen
   Vorgehen: Die drei Größen werden regelmäßig im Raster verteilt (z.B. in bestimmten Abständen wiederholt sich das Muster).
   Wirkung: Es entsteht eine starke visuelle Dynamik und Komplexität, aber trotzdem bleibt durch das Raster eine klare Ordnung erhalten.
   Besonderheit: Obwohl die Fläche auf den ersten Blick komplex wirkt, vermittelt sie durch das Raster immer noch Systematik und Wiederholung.
   

Vorteile eines Rasters:
Struktur & Ordnung: Das Raster gibt Halt und sorgt dafür, dass selbst bei komplexen Mustern keine Unruhe entsteht.
Vergleichbarkeit: Es wird leichter, Variationen (z.B. bei Punktgröße und Anzahl) direkt miteinander zu vergleichen.
Planbarkeit: Veränderungen und Steigerungen können gezielt und systematisch eingeführt werden.

Nachteile eines Rasters:
Weniger Lebendigkeit/Spontanität: Ein starres Raster kann die Komposition schnell starr oder langweilig machen.
Weniger Zufall/Überraschung: Es entsteht oft keine natürliche Dynamik oder Bewegung.
Begrenzte Individualität: Besonders bei vielen und/oder gleich großen Punkten geht die „Eigenart“ der einzelnen Punkte verloren.

Neue Fragen, die sich ergeben haben:
Wie kann man das Raster so variieren, dass trotzdem Spannung entsteht? (z.B. durch gezielte Abweichungen)
Was passiert, wenn man das Raster aufbricht oder verformt (z.B. Kreisbogen, Diagonale)?
Wie stark darf ein Raster „unsichtbar“ sein, bevor das Bild ins Chaotische kippt?
Welche Rolle spielt die Wahl des Rasters für das Endergebnis im Vergleich zu zufälligen Punktsetzungen?
Wie würden die gleichen Punktmuster ohne Raster wirken?

Code

void setup() {
  size(660, 660);  // (200 + 20) * 3 = 660
  background(255);
  noStroke();
  drawMatrix(200, 20);  // cellSize, spacing
  saveFrame("output/U0208-Punktuebung.png");
  println("Punktübung gespeichert.");
}

void drawMatrix(int cellSize, int spacing) {
  for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 3; col++) {
      float x0 = col * (cellSize + spacing);
      float y0 = row * (cellSize + spacing);
      drawStep(x0, y0, row, col, cellSize);
    }
  }
}

// Aufgabe 0208: 1. Zeile: gleiche Größe, 2. Zeile: zwei Größen, 3. Zeile: drei Größen; jeweils Punktemenge zunehmend
void drawStep(float x, float y, int row, int col, int cellSize) {
  fill(245);
  stroke(100);
  rect(x, y, cellSize, cellSize, 14);
  noStroke();

  int[] anzahl = {4, 6, 8};  // Für col 0, 1, 2
  int numPoints = anzahl[col] * anzahl[col];  // z.B. 4x4, 6x6, 8x8 Raster

  float[] sizes;
  if (row == 0) {
    sizes = new float[] {20};
  } else if (row == 1) {
    sizes = new float[] {14, 22};
  } else {
    sizes = new float[] {10, 16, 22};
  }

  // Abstand zwischen Mittelpunkten berechnen:
  float maxDot = max(sizes);
  float gridSpace = (cellSize - maxDot) / (anzahl[col] - 1);

  for (int i = 0; i < anzahl[col]; i++) {
    for (int j = 0; j < anzahl[col]; j++) {
      float px = x + maxDot/2 + i * gridSpace;
      float py = y + maxDot/2 + j * gridSpace;
      float sz = sizes[(i + j) % sizes.length];  // Zyklisch durch die Größen
      fill(30);
      ellipse(px, py, sz, sz);
    }
  }
}