Algoritma Pembuat Lingkaran

Untuk membuat Algoritma Pembuat lingkaran dalam pemrogaman bahasa C dibutuhkan langkah-langkah sebagai berikut ini ;

1.Tentukan titik tengah dan jari-jari
   xc , yc , R
2. Tentukan nilai pengubahan posisi
    P = I - R;
    x = 0;
    y = R = 4
3. Perulangan
    xc = y
    P Selanjutnya = P + (2 * x) + 1 jika P < 0
    P Selanjutnya = P + (2 * (x - y)) + 1
4. Translasi dan Pencerminan
    (xc + x ,yc + y )
    (xc - x ,yc + y )
    (xc + x ,yc - y )
    (xc - x ,yc - y )
    (xc + y ,yc + x )
    (xc - y ,yc + x )
    (xc + y ,yc - x )
    (xc - y ,yc - x )

          Berdasarkan rumus di atas maka dapat diimplementasikan dalam suatu bentuk program, disini pembuatan codingnya menggunakan Microsoft Visual Studio dengan bahasa C
Berikut Contoh Source codenya beserta penjelasannya ;
// Algoritma pembuat lingkaran

#include <GL\freeglut.h>
#include <GL\glut.h>
#include <iostream>

using namespace std;

//identifier fungsi
void init();
void display(void);
void lingkaran(void);

//  posisi window di layar
int window_x;
int window_y;

//  ukuran window
int window_width = 480;
int window_height = 480;

//  judul window
char *judul_window = "Algoritma Pembuat Lingkaran";

void main(int argc, char **argv)
{
//  inisialisasi GLUT (OpenGL Utility Toolkit)
glutInit(&argc, argv);
// set posisi window supaya berada di tengah
window_x = (glutGet(GLUT_SCREEN_WIDTH) - window_width) / 2;
window_y = (glutGet(GLUT_SCREEN_HEIGHT) - window_height) / 2;
glutInitWindowSize(window_width, window_height); //set ukuran window
glutInitWindowPosition(window_x, window_y); //set posisi window

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); // set display RGB dan double buffer
glutCreateWindow(judul_window);

init(); // jalankan fungsi init
glutDisplayFunc(display); // set fungsi display
glutMainLoop(); // set loop pemrosesan GLUT
}

void init()
{
glClearColor(0.0, 0.0, 0.0, 0.0); //set warna background
glColor3f(255.255, 240.240, 0.0); //set warna titik
glPointSize(3.0); //set ukuran titik
glMatrixMode(GL_PROJECTION); //set mode matriks yang digunakan
glLoadIdentity(); // load matriks identitas
gluOrtho2D(0.0, 600.0, 0.0, 600.0); // set ukuran viewing window
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT); //clear color
lingkaran(); //jalankan fungsi lingkaran
glutSwapBuffers(); //swap buffer
}

void lingkaran(void) {
//tentukan titik pusat dan jari-jari
int xc,yc,r;
r = 150;
xc = 300;
yc = 300;

//hitung p awal dan set nilai awal untuk x dan y
int p = 1-r;
int x = 0;
int y = r;

glBegin(GL_POINTS);

//perulangan untuk menggambar titik
while (x <= y) {
x++; //tambah nilai x
if (p < 0) {
p += 2 * x + 1; //hitung p selanjutnya jika p < 0
}
else {
y--; //kurangi nilai y
p += 2 * (x - y) + 1; //hitung p selanjutnya jika p > 0 atau p = 0
}

// translasi terhadap titik pusat dan cerminkan
glVertex2i(xc + x, yc + y);
glVertex2i(xc - x, yc + y);
glVertex2i(xc + x, yc - y);
glVertex2i(xc - x, yc - y);
glVertex2i(xc + y, yc + x);
glVertex2i(xc - y, yc + x);
glVertex2i(xc + y, yc - x);
glVertex2i(xc - y, yc - x);
}

glEnd();
glFlush();
}

Hasil Running Program :

Algoritma Bresenham (Komputer Grafik)

Apa itu Algoritma Bresenham ?

       Algoritma garis Bresenhem adalah algoritma konversi penambahan nilai integer.Langkah-langkah untuk membentuk garis menurut algoritma ini adalah :

1. Tentukan Titik Awal dan Akhir ;
    Titik Awal  (x1 , y1)
    Titik Akhir (x2 , y2)

2. Nilai Pengubahan posisi (P)
    P Awal = (2 * Dy) - Dx
    a. Kondisi 1 : Jika P< 0, Maka x = x + 1,Y tetap P selanjutnya adalah P = P + (2 * Dy)
    b. Kondisi 2 : Jika  P> 0 Maka x = x + 1,Y = Y + 1 P selanjutnya adalah P = P + 2* (Dy - Dx)

        Baiklah,,... Berdasarkan rumus di atas maka dapat diimplementasikan dalam suatu bentuk program, disini pembuatan codingnya menggunakan Microsoft Visual Studio dengan bahasa C
Berikut Contoh Source codenya beserta penjelasannya ;
//Algoritma Bresenham

#include <GL\freeglut.h>
#include <GL\glut.h>
#include <iostream>

using namespace std;

//identifier fungsi
void init();
void display(void);
void bresenham(void);

//  posisi window di layar
int window_x;
int window_y;

//  ukuran window
int window_width = 720;
int window_height = 480;

//  judul window
char *judul_window = "Algoritma Bresenham";

void main(int argc, char **argv)
{
//  inisialisasi GLUT (OpenGL Utility Toolkit)
glutInit(&argc, argv);
// set posisi window supaya berada di tengah
window_x = (glutGet(GLUT_SCREEN_WIDTH) - window_width) / 2;
window_y = (glutGet(GLUT_SCREEN_HEIGHT) - window_height) / 2;
glutInitWindowSize(window_width, window_height); //set ukuran window
glutInitWindowPosition(window_x, window_y); //set posisi window

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); // set display RGB dan double buffer
glutCreateWindow(judul_window); //set judul window


init(); //jalankan fungsi init
glutDisplayFunc(display); //  set fungsi display
glutMainLoop(); // set loop pemrosesan GLUT
}

void init()
{
glClearColor(0.0, 0.0, 0.0, 0.0); //set warna background
glColor3f(6.0, .0, 6.0); //set warna titik
glPointSize(2.0); //set ukuran titik
glMatrixMode(GL_PROJECTION); //set mode matriks yang digunakan
glLoadIdentity(); // load matriks identitas
gluOrtho2D(0.0, 800.0, 0.0, 600.0); // set ukuran viewing window
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT); //clear color
bresenham(); //jalankan fungsi bresenham
glutSwapBuffers(); //swap buffer
}

void bresenham(void) {
int x1, y1, x2, y2, x, y, dx, dy, xend, p, duady, duadydx;
//tentukan titik awal dan akhir
x1 = 10;
y1 = 10;
x2 = 500;
y2 = 400;
x = x1;
y = y1;

//hitung dx dan dy
dx = abs(x2 - x1);
dy = abs(y2 - y1);

//hitung p
p = 2 * dy - dx;
duady = 2 * dy;
duadydx = 2 * (dy - dx);

//tentukan titik awal dan akhir
if (x1 > x2) {
x = x2;
y = y2;
xend = x1;
}
else
{
x = x1;
y = y1;
xend = x2;
}

//gambar titik awal
glBegin(GL_POINTS);
glVertex2i(x, y);

//perulangan untuk menggambar titik-titik
while (x < xend) {
x++;
if (p < 0) {
p += duady;
}
else
{
if (y1 > y2) {
y--;
}
else y++;

p += duadydx;
}
glVertex2i(x, y);
}

glEnd();
glFlush();
}

Hasil running programnya ;

Algoritma DDA (Komputer Grafik)

Apa itu Algoritma DDA ?

        Algoritma DDA (Digital Differential Analyzer) adalah algoritma pembentukan garis berdasarkan perhitungan Dx dan Dy,yaitu pembuatan garis dengan langkah umum sebagai berikut ;

1. Tentukan Titik Awal dan Akhir
    Titik Awal    (x1,y1)
    Titik Akhir   (x2,y2)

Rekursif

PENGERTIAN REKURSIF (RECURSION)

Rekursif adalah konsep pengulangan yang penting dalam ilmu komputer. Konsep ini dapat digunakan untuk merumuskan solusi sederhana dalam sebuah permasalahan yang sulit untuk diselesaikan secara iteratif dengan menggunakan loop for, while do. Pada saat tertentu konsep ini dapat digunakan untuk mendefinisikan permasalahan dengan konsisten dan sederhana. Pada saat yang lain, rekursi dapat membantu untuk mengekspresikan algoritma dalam sebuah rumusan yang menjadikan tampilan algoritma tersebut mudah untuk dianalisa.

Rekursif berarti bahwa suatu proses bisa memanggil dirinya sendiri. Menurut definisi dalam Microsoft Bookshelf, Rekursif adalah kemampuan suatu rutin untuk memanggil dirinya sendiri. Dalam Rekursif sebenarnya terkandung pengertian prosedur dan fungsi. Perbedaannya adalah bahwa rekursif bisa memanggil ke dirinya sendiri, tetapi prosedur dan fungsi harus dipanggil lewat pemanggil prosedur dan fungsi. Rekursif merupakan teknik pemrograman yang penting dan beberapa bahasa pemrograman mendukung keberadaan proses rekursif ini. Dalam prosedur dan fungsi, pemanggilan ke dirinya sendiri bisa berarti proses berulang yang tidak bisa diketahui kapan akan berakhir.