Kreise in der Computergrafik

Teil 1

 

Teil 2

 

Wie zeichnen Computer Kreise?

Wir haben keine Kosten und Mühen gescheut und haben eines der modernsten IT-High-Tech-Anlagen gekauft, um euch zu demonstrieren, wie Computer Kreise zeichnen. Dass dafür Mathematik benötigt wird, ist klar. Computer sind ja schließlich Rechner. Dass das aber genau diejenige Mathematik ist, mit der wir uns hier im Beispielkapitel befasst haben, mag überraschen: Pythagoras und die binomischen Formeln, alles taucht wieder auf!

Der Algorithmus als Geogebra-App

Für alle Programmierer(innen) unter uns

Du beherrschst eine Programmiersprache? Vielleicht magst du den Bresenham-Algorithmus in deiner Programmiersprache umsetzen und ausprobieren? Poste hier deinen Code!

Weitere Übungen

Du möchtest ein paar Aufgaben zu Kreisen haben? Kein Problem: Übungen zu Kreisen

4 thoughts on “Kreise in der Computergrafik

  1. Rainer

    Das mat mir sehr gefallen. Wer denkt denn heute schon noch darüber nach,
    wie denn Kreise, Linien usw. auf dem Bildschirm entstehen. Ist doch erstaunlich, wo der Pythagoras und die binomischen Formeln überall drinn stecken.

  2. Irene

    Ja, hat mir auch sehr gut gefallen …
    … und ich habe etwas über Programmieren gelernt. Man muss vor jeder Zeile ein Ü tippen und dann eine 10-er Zahl wenn es eine neue Operation ist, bzw. eine aufsteigende 1-er Zahl wenn es für diese Operation Optionen gibt, die gelärt werden müssen, ehe die nächste Operation starten kann.

    Wie ist das eigentlich bei Powerpoint? Wenn ich dort einen Kreis zeichne, läuft dann im Hintergrund diese ganze Berechnung ab? Oder gibt es mittlerweile eine library von bereits vorberechneten Kreisen abhängig vom Radius?

    • cspannagel Post author

      Fast. 🙂 Das „Ü“ ist eigentlich kein „Ü“, sondern das Eingabesymbol „]“ (das leider falsch dargestellt wird wegen einer Zeichensatzproblematik).

      Die 10er- und 1-er-Schritte haben keine unterschiedliche Bedeutung. Man beginnt nur immer sicherheitshalber mit 10er-Schritten in der Nummerierung, falls man was vergisst: Dann kann man später noch eine oder mehrere Zeilen mit dem vergessenen Code dazwischen einfügen.

      Welche Algorithmen in PowerPoint zum Kreiszeichnen stecken, weiß ich tatsächlich leider nicht. Vermutlich wird das Kreiszeichnen an eine Bibliothek abgegeben, in der der Bresenham-Algorithmus benutzt wird. Das ist aber nur eine Vermutung. Wer weiß es besser?

  3. Eugen

    [a href=“http://testkapitel.mathemooc.de/wp-content/uploads/2013/07/screen.png“][img src=“http://testkapitel.mathemooc.de/wp-content/uploads/2013/07/screen-141×150.png“][/a]
    So… Ich habe ein kleines C-Programm unter Verwendung von Cairo zum Zeichnen und GTK+3 zum Anzeigen gebastelt:

    #include
    #include
    #include
    #include

    static const gint R = 150;

    static gboolean on_draw_event(GtkWidget *widget, cairo_t *cr, gpointer user_data) {
    gdouble x, y;

    cr = gdk_cairo_create (gtk_widget_get_window (widget));

    // Paint a circle
    cairo_set_source_rgb (cr, 0, 0, 0);

    for (x = 0; x <= (sqrt(2) / 2) * R; x++) {
    y = sqrt(R * R - x * x);
    // Bottom right
    cairo_move_to(cr, x + 250, y + 250);
    cairo_arc(cr, x + 250, y + 250, 1, 0, 2 * G_PI);
    // Bottom left
    cairo_move_to(cr, -x + 250, y + 250);
    cairo_arc(cr, -x + 250, y + 250, 1, 0, 2 * G_PI);

    // Right bottom
    cairo_move_to(cr, y + 250, x + 250);
    cairo_arc(cr, y + 250, x + 250, 1, 0, 2 * G_PI);
    // Left bottom
    cairo_move_to(cr, -y + 250, x + 250);
    cairo_arc(cr, -y + 250, x + 250, 1, 0, 2 * G_PI);

    // Top right
    cairo_move_to(cr, x + 250, -y + 250);
    cairo_arc(cr, x + 250, -y + 250, 1, 0, 2 * G_PI);
    // Top left
    cairo_move_to(cr, -x + 250, -y + 250);
    cairo_arc(cr, -x + 250, -y + 250, 1, 0, 2 * G_PI);

    // Left bottom
    cairo_move_to(cr, y + 250, -x + 250);
    cairo_arc(cr, y + 250, -x + 250, 1, 0, 2 * G_PI);
    // Right bottom
    cairo_move_to(cr, -y + 250, -x + 250);
    cairo_arc(cr, -y + 250, -x + 250, 1, 0, 2 * G_PI);
    }
    cairo_stroke(cr);

    // Free memory
    cairo_destroy (cr);

    return FALSE;
    }

    int main(int argc, char **argv) {
    GtkWindow *window;
    GtkDrawingArea *darea;

    gtk_init(&argc, &argv);

    // Create and configure the window and the needed areas
    window = (GtkWindow *)gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position (window, GTK_WIN_POS_CENTER);
    gtk_window_set_default_size (window, 500, 500);
    gtk_window_set_title (window, "Kreise in der Computergrafik");

    darea = (GtkDrawingArea *)gtk_drawing_area_new ();

    gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (darea));
    gtk_widget_show_all (GTK_WIDGET (window));

    g_signal_connect (G_OBJECT (darea), "draw", G_CALLBACK (on_draw_event), NULL);
    g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);

    gtk_main();

    return EXIT_SUCCESS;
    }

    Die Funktion on_draw_event macht die gesamten Berechnungen nach Bresenham-Algorithmus (mit Achtelkreisen).
    Ein interessantes Video. In der Schule (schon ein paar Jahre her) hatte ich QBasic und etwas später TurboPascal, aber ich hatte keine Ahnung, dass man noch etwas früher auf solche Weise programmiert hat, Zeile für Zeile :). Danke.

Schreibe einen Kommentar