Geradengleichung als Funktion

Eigentlich ist es unnötig für jedes Pixel die neue $x$-Koordinate und die neue $y$-Koordinate auszurechnen, da man ja der Reihe nach alle Pixel der Linie setzen will. Wenn man also für jedes Pixel z.B. die $x$-Koordinate um $1$ erhöht, braucht man nur noch die zugehörige $y$-Koordinate zu berechnen. Dazu muß die Geradengleichung aber in Form einer Funktion vorliegen:

$$y(x) =s \cdot x + c$$

Die Steigung $s$ errechnet sich mit dem Steigungsdreieck wie folgt:

$$s = \frac{\mbox{H\uml {o}henzuwachs}}{\mbox{Schrittweite}} = \frac{y_2 - y_1}{x_2 - x_1}$$

das gilt sowohl für das Dreieck mit $P_1$ und $P_2$ als auch für das Dreieck mit $P_1$ und dem Punkt $C$, an dem die Gerade die $y$-Achse schneidet:

$$\begin{eqnarray*} \frac{y_1 - c}{x_2 - 0} &=& \frac{y_2 - y_1}{x_2 - x_1} \\ \Leftrightarrow c &=& \frac{y_1 \cdot x_2 - y_2 \cdot x_1}{x_2 - x_1} \end{eqnarray*}$$

einsetzen in die Geradengleichung ergibt:

$$y = \frac{y_{2} - y_{1}} {x_{2} - x_{1}} \cdot x +\frac {y_{1} \cdot x_{2} - y_{2} \cdot x_{1}} {x_{2} - x_{1}}$$

Hier die draw-Methode aus der Klasse line.StraightLine:

public void draw(CGCanvas cgc) {
  int x, y;
  double s, c;

  s = (double)(y2 - y1) / (double)(x2 - x1);   // Steigung berechnen
  c = (double)(y1*x2 - y2*x1) /                // y-Achsenabschnitt
      (double)(x2 - x1); 
  
  x = x1;                                      // Koordinaten retten
  y = y1;

  if(x < x2)  {                                // Linie links -> rechts
    while(x <= x2) {                           // fuer jede x-Koordinate
      y = (int)(s*x + c + 0.5);                // berechne y-Koordinate
      cgc.setPixel(x,y);                       // setze Pixel
      x++;                                     // naechste x-Koordinate
    }
  }
  else {                                       // Linie rechts -> links
    while(x >= x2) {                           // fuer jede x-Koordinate
      y = (int)(s*x + c + 0.5);                // berechne y-Koordinate
      cgc.setPixel(x,y);                       // setze Pixel
      x--;                                     // naechste x-Koordinate
    }
  }
}

Diese Version kommt mit ungefähr halb soviel Gleitkommaarithmetik aus, wie die letzte. Allerdings brauchen wir eine zusätzliche Fallunterscheidung, um zu klären, ob die Linie von links nach rechts verläuft oder andersherum. Ein weiterer schwerer Nachteil liegt in der Tatsache, daß die Pixel für steile Geraden nicht benachbart sind.