Algoritma Pembuat Lingkaran

Berikut adalah coding Algoritma Pembuat Lingkaran

// 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 = 520;
int window_height = 520;

//  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(1.0, 1.0, 1.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 = 240;
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();
}

Algoritma Bresenham

Algoritma garis Bresenham merupakan algoritma yang menentukan titik-titik dalam raster n-dimensi yang diplot untuk membentuk pendekatan dengan garis lurus antara dua titik yang diberikan. Hal ini biasanya digunakan untuk menggambar garis pada layar komputer, dengan menggunakan integer penambahan, pengurangan dan pergeseran bit, dalam arsitektur komputer standar. Algoritma bresenham adalah salah satu algoritma paling awal dikembangkan di bidang komputer grafis. Sebuah ekstensi kecil dengan algoritma asli juga berhubungan dengan lingkaran gambar. Berikut Adalah contoh coding Algoritma Bresenham :

//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 = 480;
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(1.0, 1.0, 1.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();
}

Algoritma DDA (Digital Differential Analyzer)

DDA adalah algoritma pembentukan garis berdasarkan perhitungan  Δx  dan Δy, menggunakan rumus  y = m. Δ x. Garis dibuat dengan menentukan dua endpoint yaitu titik awal dan titik akhir.  Setiap koordinat titik yang membentuk garis diperoleh dari perhitungan, kemudian dikonversikan menjadi nilai integer. berikut adalah contoh codingan DDA :

// Algoritma DDA
#include <GL\freeglut.h>
#include <GL\glut.h>
#include <iostream>

using namespace std;

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

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

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

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

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();

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

void init()
{
glClearColor(0.0, 0.0, 0.0, 0.0); //set warna background
glColor3f(0.0, 1.0, 0.0); //set warna titik
glPointSize(5.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
dda(); //panggil fungsi dda
glutSwapBuffers(); //swap buffer
}

void dda(void) {
int x1, y1, x2, y2;
float x,y,dx, dy, steps, x_inc, y_inc;
//tentukan titik awal dan akhir
x1 = 1;
y1 = 1;
x2 = 500;
y2 = 400;
x = x1;
y = y1;

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

//hitung steps
if (dx > dy) {
steps = dx;
}
else steps = dy;

//hitung perubahan nilai x (x_inc) dan y (y_inc)
x_inc = dx / steps;
y_inc = dy / steps;

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

//perulangan untuk menggambar titik-titik
do {
x += x_inc; // x = x + x_inc
y += y_inc; // y = y + y_inc
glVertex2i(round(x), round(y)); //gambar titik
} while (x < x2);

glEnd();
glFlush();
}