Bresenham Linie zeichnen | Bitte um Hilfe..

[AktivPassiv]

Hallo liebe Community,

leider ist das fach "Computergrafik" aktuell sehr schwer für mich. Ich versteh das Prinzip von Bresenham, aber kann die Aufgabe dennoch nicht lösen. Verzweifle langsam.

Ich bitte euch um HILFE...

Vielen Dank im Voraus!

 

[M.L.]

Auch hallo,

und woran scheitert es ? Aber vielleicht hilft dieses Programm (mit Einfügen des Codes der Aufgabe) schon weiter: http://www.tutego.de/blog/javainsel...rastergrafik-1-linien-zeichnen-mit-bresenham/

 

[AktivPassiv]

Leider nein.. finde überhaupt keinen Ansatz.

 

[mihe7]

Naja, für 1.1 musst Du ja nur durchrechnen.

P1=(5,3) und P2=(1,1)

deltaX = |5-1| = 4
deltaY = |3-1| = 2
Q = 2*deltaY - deltaX = 0
Qinc_a = 2*(deltaY - deltaX) = 2*(-2) = -4
Qinc_b = 2*deltaY = 4

y = y1 = 3
Schleife: Initialisierung x = x1 = 5
5 > 1: 
  setzePixel(5,3)
  Q == 0 (else-Zweig): Q += QInc_a ---> Q = -4, y++ ---> y = 4
  x = x - 1 = 4 // Schleifenzähler
4 > 1:
  setzePixel(4,4)
  Q == -4 < 0 (then-Zweig): Q += Qinc_b --> Q = -4 + 4 = 0
  x = x - 1 = 3 
3 > 1:
  setzePixel(3,4)
  Q == 0 (wie oben): Q = -4, y = 5
  x = 2
2 > 1:
  setzePixel(2,5)
  Q = -4: Q = 0
  x = 1
1 == 1 -> Ende

Wenn Du die Punkte einzeichnest (Antwort 1.1), sollten Dir zwei Dinge auffallen. Was muss also geändert werden? --> Antwort 1.2

1.3: deltaX > 0 und deltaY > 0 gilt ja schon mal dann nicht, wenn die Punkte auf einer senkrechten oder waagerechten Linie liegen, also gleiche x- bzw. y-Koordinaten haben. Für den Rest soll deltaY > deltaX gelten. Der y-Abstand muss also größer als der x-Abstand sein. Hier mal eine Zeichnung für einen Quadranten. Der schwarze "Punkt" hat die Koordinaten (x0, y0). Die Antwort sollte jetzt nicht mehr allzu schwer fallen.

 

[uuu3uuu]

Hier ist mal der korrekte Code für den Bresenham-Algorithmus für den ersten Oktanten:

import cern.colt.Arrays;

import java.awt.*;

public class Bresenham {
    public static boolean[][] bresenham(int n, Point a, Point b) {
        boolean[][] toReturn = new boolean[n][n];
        double dx = b.x - a.x;
        double dy = b.y - a.y;

        int x = a.x;
        int y = a.y;
        toReturn[n - 1 - y][x] = true;
        double fehler = dx / 2;

        while (x < b.x) {
            x++;
            fehler -= dy;
            if (fehler < 0) {
                y++;
                fehler += dx;
            }
            toReturn[n - 1 - y][x] = true;
        }

        return toReturn;
    }

    public static void print(boolean[][] a) {
        for (boolean[] x : a) {
            System.out.println(Arrays.toString(x).replace("true", "x").replace("false", " "));
        }
    }

    public static void main(String[] args) {
        print(bresenham(10, new Point(1, 1), new Point(9, 3)));
    }
}

Nun kannst du diesen mit deiner Vorgabe vergleichen um zu sehen was dabei falsch sein könnte. So kompliziert ist der Bresenham-Algorithmus nicht.

Oder du könntest den Code an deine Vorgabe anpassen (und starten) um zu sehen wie es gezeichnet wird.

Hier im Forum gab es übrigens schon mal eine Frage zum Bresenham-Algorithmus.