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
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.
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?
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?
[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.