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)

Pemrogaman bahasa C

Contoh Soal dan jawaban Pemrograman Bahasa C  

       Hay guys,... kali ini saya akan membagikan contoh suatu kasus persoalan yang dimana anda bisa latihan buat meningkatkan skill atau belajar tentang pemrogaman bahasa C disini saya menggunakan CodeBlocks sebagai perantaranya .ada beberapa contoh soal yang pertama kita disuruh untuk menghitung untung rugi penjualan suatu perusahaan dan ada lagi soal lainnya,Yuk,.. langsung cek saja soalnya