Προγραμματισμός Γραφικών μέσω BGI / WinBGIm
Η διδασκαλία που ακολουθεί, στηρίζεται στην ύλη του μαθήματος Προγραμματισμός Γραφικών των ΙΕΚ. Ως στόχο της έχει να αποτελέσει ένα σημείο αναφοράς για τους σπουδαστές, ώστε να εμπεδώσουν καλύτερα την ύλη η οποία διδάσκεται στο εργαστήριο.

Για λόγους ευκολίας, ως γλώσσα προγραμματισμού, έχει επιλεγεί η Turbo C v.2.01, της Borland η οποία λειτουργεί κάτω από περιβάλλον DOS. Για το λόγο αυτό, στα πιό μοντέρνα συστήματα, θα πρέπει να γίνει χρήση εξομοιωτή του DOS (όπως πχ το DOSBox).

Πάραυτα, μπορούν να χρησιμοποιηθούν  και πιό σύγχρονες γλώσσες με γραφικό περιβάλλον ανάπτυξης, οι οποίες δεν απαιτούν τη χρήση εξομοιωτή, όπως για παράδειγμα η DevC++.

Οι τεχνολογίες που παρουσιάζονται στα κεφάλαια των σημειώσεων που ακολουθούν, αποτελούν κατοχυρωμένα πνευματικά δικαιώματα της Borland. Ο γράφων δηλώνει ανεπιφύλακτα ότι δεν αποσκοπεί σε κανένα οικονομικό όφελος από την παρακάτω παρουσίαση και ότι όλα όσα περιγράφονται σε αυτή τοχεύουν αποκλειστικά και μόνο στην καλύτερη εξυπηρέτηση των σπουδαστών / μαθητών και των λοιπών ενδιαφερομένων.

Ζαχαρίας Μ. Κοντοπόδης
Καθηγητής Πληροφορικής / Μηχανογραφημένης Λογιστικής
Εισαγωγή

Η γλώσσα C, προσφέρει μια πλήρη βιβλιοθήκη με συναρτήσεις γραφικών τα πρωτότυπα των οποίων, κατά κύριο λόγο βρίσκονται στο <graphics.h>. Ο προγραμματισμός γραφικών με τη γλώσσα C, είναι εύκολος και παρουσιάζει μεγάλο ενδιαφέρον, μιας και δίνει στον προγραμματιστή τη δυνατότητα να δημιουργήσει μια μεγάλη γκάμα εφαρμογών οι οποίες σχετίζονται με γραφικά (πχ παιχνίδια, animation κτλ).

Η αλήθεια είναι ότι ο προγραμματισμός μέσω του BGI (Borland Grpahics Interface) θεωρείται πλέον πεπαλαιωμένος, μιας και στην ουσία στα νεότερα συστήματα, χρησιμοποιούνται πιό εξελιγμένες βιβλιοθήκες όπως το DirectX και η OpenGL. Πάραυτα όμως, η εξοικείωση με τον προγραμματισμό σε BGI, προετοιμάζει τον προγραμματιστή για μια πιό επιτυχή μεταπήδηση σε αυτές τις μοντέρνες βιβλιοθήκες.

Οι συναρτήσεις του BGI, λειτουργούν κάτω από Console Mode και για αυτό το λόγο η γλώσσα η οποία έχει επιλεγεί για το μάθημα αυτό είναι η Turbo C 2.01 της Borland, η οποία είναι ένας C compiler για DOS.

Αντίστοιχα υπάρχουν ολοκληρωμένες βιβλιοθήκες της Borland και για compilers οι οποίοι λειτουργούν κάτω από Windows, όπως η WinBGI και η WinBGIm, οι οποίες περιλαμβάνουν τις συναρτήσεις του απλού BGI μαζί με άλλες πιό εξελιγμένες οι οποίες εκμεταλεύονται τα πλεονεκτήματα των Windows.

Εγκατάσταση του DOSBox  για λειτουργία της Turbo C v 2.01

Για την λειτουργία της Turbo C, κάτω από παλαιότερα λειτουργικά συστήματα, όπως για παράδειγμα Windows XP, δεν απαιτείται παρά να αντιγράψουμε τα αρχεία της γλώσσας (μαζί με τους φακέλους της), σε ένα κατάλογο της αρεκείας μας (συνήθως επιλέγουμε κάποιο άμεσο υποκατάλογο του root), και να εκτελέσουμε το αρχείο TC.EXE.

Στα νεότερα λειτουργικά συστήματα, όμως, ο παραπάνω compiler, δεν μπορεί να λειτουργήσει και απαιτεί την εγκατάσταη ενός εξομοιωτή του DOS, όπως είναι το DOSBox.

Το DOSBox μπορείτε να το μεταφορτώσετε από εδώ.

Αφού κατέβει και εγκατασταθεί το DOSBox, δημιουργούμε ένα κατάλογο το Root Directory του δίσκου C:,  στον οποίο δίνουμε το όνομα DOSBOX μέσα στον οποίο θα εγκαθιστούμε όλες τις DOS εφαρμογές που θέλουμε να χρησιμοποιήσουμε.

Δημιουργούμε έναν κατάλογο με όνομα TC201, ως υποκατάλογο του DOSBOX, μέσα στον οποίο αντιγράφουμε ή εγκαθιστούμε όλα τα αρχεία της γλώσσας C.

Τον compiler, μπορούμε να τον κατεβάσουμε από εδώ :

Στη συνέχεια, αφού εκτελέσουμε το DOSBox, γράφουμε τις παρακάτω εντολές με τη σειρά που φαίνονται :
Τέλος, αφού στο προτρεπτικό σήμα του λειτουργικού πληκτρολογήσουμε την εντολή TC (όπως φαίνεται στο παραπάνω σχήμα), εκτελείται η εφαρμογή και μπαίνουμε στο περιβάλλον της γλώσσας TC.
Υπενθυμίζεται, ότι ανά πάσα στιγμή, μπορούμε να πάρουμε βοήθεια πατώντας το πλήκτρο F1. Η βοήθεια περιέχει όλα τα header files με τις συναρτήσεις τους, καθώς και παραδείγματα για κάθε μια από αυτές.
Εγκατάσταση της Βιβλιοθήκης WinBGIm για την DevC++

Η DevC++, είναι ένας ισχυρός compiler της γλώσσας C++, ο οποίος λειτουργεί κάτω από όλες τις σύγχρονες εκδόσεις των Windows. Παρέχει γραφικό IDE και ως εκ τούτου, είναι αρκετά πιό φιλικός προς τον χρήστη/προγραμματιστή (σε σχέση τουλάχιστον με τις παλαιότερες εκδόσεις οι οποίες εργάζονται κάτω από DOS).

Για να λειτουργήσουν οι συναρτήσεις γραφικών οι οποίες περιλαμβάνονται στο graphics.h και οι οποίες αναλύονται στα παρακάτω παραδείγματα, θα πρέπει να έχει πρώτα εγκατασταθεί η βιβλιοθήκη WinBGIm, η οποία είναι το αντίστοιχο της BGI για περιβάλλον Windows.

Μπορείτε να κατεβάσετε την DevC++ από εδώ.

Μπορείτε να κατεβάσετε τις απαιτούμενες βιβλιοθήκες γραφικών από εδώ.

Μπορείτε να δείτε πλήρες video με αναλυτικές οδηγίες εδώ.
Αρχικοποίηση Συστήματος Γραφικών

#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;

initgraph(&gd, &gm, "C:\\TC\\BGI");

getch();
closegraph();
}

Τα πρωτότυπα των συναρτήσεων γραφικών βρίσκονται στο header file με όνομα <graphics.h>. Το αρχείο αυτό θα πρέπει να συμπεριλαμβάνεται στο πρόγραμμα για να μπορέσει να γίνει η κλήση των συναρτήσεων με επιτυχία.

Η συνάρτηση initgraph(), χρησιμοποιείται για αρχικοποίηση της κατάστασης γραφικών. Δέχεται τρεις παραμέτρους. Η gd αφορά τον οδηγό γραφικών (graphics driver), η gm αφορά την κατάσταση γραφικών (graphics mode) και η τρίτη αποτελεί τη διαδρομή προς τον εγκατεστημένο οδηγό γραφικών στο δίσκο (BGI).

Η τιμή DETECT, σημαίνει ότι ο προγραμματιστής επιτρέπει στο πρόγραμμα να εντοπίσει αυτόματα τον ενεργό οδηγό γραφικών, ενώ η τρέχουσα κατάσταση γραφικών (μετά τον αυτόματο εντοπισμό) έχει αποθηκευτεί στη μεταβλητή gm.

Το πρόγραμμα του παραπάνω παραδείγματος, απλά αρχικοποιεί την κατάσταση γραφικών (φέρνει δηλαδή την οθόνη σε κατάσταση να μπορεί να εμφανίσει γραφικά). Στην ουσία δεν δείχνει τίποτα ως αποτέλεσμα.

Η συνάρτηση closegraph(), χρησιμοποιείται για να κλείσει την κατάσταση γραφικών και να επιστρέψει στην κατάσταση κειμένου. Από τη στιγμή που θα εκτελεστεί η closegraph(), δεν μπορεί να εκτελεστεί καμία διαδικασία ή συνάρτηση γραφικών.

Η συνάρτηση getch() χρησιμοποιείται για να σταματήσει η εκτέλεση του προγράμματος και να μπορέσουμε να δούμε τα αποτελέσματα. Χρησιμοποιούμε αυτή την τεχνική διότι μόλις ένα πρόγραμμα τερματιστεί, το παράθυρο του command line (ή του dosbox) κλείνει με αποτέλεσμα ο χρήστης να χάνει την τελική οθόνη.

Εμφάνιση Pixel

#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;

initgraph(&gd, &gm, "C:\\TC\\BGI");
putpixel(25, 25, RED);

getch();
closegraph();
}
Η συνάρτηση putpixel, χρησιμοποιείται για την ενεργοποίηση (εμφάνιση) ενός πίξελ στην οθόνη γραφικών. Στην σύνταξή της, αναφέρονται οι συντεταγμένες του σημείου στο οποίο βρίσκεται το πίξελ καθώς και το χρώμα του.
Διαθέσιμα χρώματα

Τα κύρια χρώματα που μπορούν να χρησιμοποιηθούν (σε κατάσταση DOS) είναι τα παρακάτω :

BLACK, BLUE, GREEN, CYAN, RED, MAGENTA
BROWN, LIGHTGRAY, DARKGRAY, LIGHTBLUE, LIGHTGREEN,
LIGHTCYAN, LIGHTRED, LIGHTMAGENTA, YELLOW, WHITE

Επίσης, μπορεί να προστεθεί η ιδιότητα BLINK, ώστε το αντικείμενο που σχεδιάζεται να αναβοσβήνει.
Σχεδίαση Γραμμής


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;

initgraph(&gd, &gm, "C:\\TC\\BGI");
line(100, 100, 200, 200);

getch();
   closegraph();
Η συνάρτηση line(), χρησιμοποιείται για το σχεδιασμό μιας γραμμής από ένα σημείο σε ένα άλλο. Ως ορίσματα δέχεται τις συντεταγμένες των δύο σημείων που ορίζουν την ευθεία.

Μπορούμε να σχεδιάσουμε γραμμή και με τη συνάρτηση lineto(), η οποία ξεκινά τη γραμμή από το τρέχον σημείο του δρομέα.



#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 moveto(100, 100);
   lineto(200, 200); 

getch();
closegraph();
}

Παρατηρούμε, ότι η lineto(), δέχεται μόνο δύο παραμέτρους (τις συντεταγμένες του σημείου στο οποίο τελειώνει η ευθεία.

Ο δρομέας μετακινείται σε συγκεκριμένο σημείο με τη συνάρτηση moveto().
Σχεδίαση Κύκλου


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
    initgraph(&gd, &gm, "C:\\TC\\BGI");

   circle(100, 100, 50);

   getch();
   closegraph();
}






Συνάρτηση σχεδίασης κύκλου είναι η circle(). Βασικά χαρακτηριστικά του κύκλου είναι το κέντρο του και η ακτίνα του, οπότε η circle ως ορίσματα δέχεται τις συντεταγμένες του κέντρου του κύκλου (το κέντρο είναι σημείο και στο παράδειγμά μας βρίσκεται στη θέση 100, 100, ενώ η ακτίνα του παραδείγματος έχει μήκος 50 pixels).
Σχεδίαση Έλλειψης



#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
    initgraph(&gd, &gm, "C:\\TC\\BGI");

   ellipse(100, 100, 0, 360, 50, 25);

   getch();
   closegraph();
}

Η συνάρτηση ellipse(), χρησιμοποιείται για τη σχεδίαση έλλειψης, αλλά και ελλειπτικών τμημάτων. Ως παραμέτρους δέχεται το κέντρο της έλλειψης, το μήκος του ελλειπτικού τμήματος (σε μοίρες από 0 έως 360) και τα μήκη της κάθετης και οριζόντιας ακτίνας της έλλειψης.

Εάν η 3η και 4η παράμετρος είναι 0 και 360 αντίστοιχα (όπως στο παραπάνω παράδειγμα) τότε η έλλειψη σχεδιάζεται πλήρης. Στην ουσία αυτές οι παράμετροι δείχνουν από πού ξεκινά και που τελειώνει το ελλειπτικό τμήμα, ενώ οι τιμές τους εκφράζουν μοίρες. Η φορά είναι από αριστερά προς τα δεξιά.

Για παράδειγμα :







ellipse(100, 100, 0, 45, 50, 25);                               ellipse(100, 100, 90, 180, 50, 25);                            ellipse(100, 100, 0, 270, 50, 25);
Σχεδίαση Τόξου

#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
    initgraph(&gd, &gm, "C:\\TC\\BGI");

   arc(100, 100, 0, 90, 50)

   getch();
   closegraph();
}



Η συνάρτηση arc(), σχεδιάζει ένα τόξο κύκλου, με συντεταγμένες κέντρου που δίνονται από τα δύο πρώτα ορίσματα, το οποίο ξεκινά και τελειώνει στις επίκεντρες γωνίες που συμβολίζονται από το τρίτο και τέταρτο όρισμα, ενώ έχει ακτίνα η οποία δηλώνεται από το τελευταίο όρισμα.

Στο παράδειγμά μας, σχεδιάζεται ένα τόξο κύκλου, με κέντρο στο σημείο 100, 100 το οποίο ξεκινά στις 0ο , τερματίζεται στις 90ο και έχει ακτίνα 50.
90ο
0ο
100, 100
Σχεδίαση Τετραπλεύρου




#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
    initgraph(&gd, &gm, "C:\\TC\\BGI");

   rectangle(100,100,200,200);

   getch();
   closegraph();
}




Η συνάρτηση rectangle(), χρησιμοποιείται για το σχεδιασμό τετραπλεύρων. Το πρώτο ζευγάρι παραμέτρων καθορίζουν τις συντεταγμένες της πάνω αριστερής γωνίας του τετραπλεύρου, ενώ το δεύτερο της κάτω δεξιάς.
Σε περίπτωση που η διαφορά της πρώτης παραμέτρου από την τρίτη , ισούται με την διαφορά της δεύτερης από την τέταρτη, τότε έχουμε τετράγωνο (όπως στο παράδειγμά μας).


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
    initgraph(&gd, &gm, "C:\\TC\\BGI");

   rectangle(10,10,100,200);

   getch();
   closegraph();
}
Σχεδίαση Δυδιάστατης Μπάρας (Τετραπλεύρου με γέμισμα)


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
    initgraph(&gd, &gm, "C:\\TC\\BGI");

   bar(10,10,100,200);

   getch();
   closegraph();
}



Η συνάρτηση bar(), μας επιτρέπει να σχεδιάζουμε δυσδιάστατες μπάρες (δηλαδή τετράπλευρα τα οποία είναι γεμάτα με το τρέχον ή το εξορισμού χρώμα).
Η συνάρτηση αυτή συνήθως χρησιμοποιείται για το σχεδιασμό στατιστικών διαγραμμάτων, αν και αυτό δεν αποτελεί περιορισμό, με την έννοια ότι μπορεί να χρησιμοποιηθεί για το σχεδιασμό οποιουδήποτε τετραπλεύρου (ασχέτως αν αυτό αποτελεί τμήμα ενός διαγράμματος ή όχι).
Σχεδίαση Πολυγώνου




#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 int  points[]={320,150,420,300,250,300,320,150};
    initgraph(&gd, &gm, "C:\\TC\\BGI");

   drawpoly(4, points);
   getch();
   closegraph();
}



Η συνάρτηση drawpoly(), σχεδιάζει ένα πολύγωνο. Οι παράμετροι που δέχεται είναι ο αριθμός των γωνιών του σχήματος που θα σχεδιαστεί (μείον 1) και ένας πίνακας από συντεταγμένες, όπου το πρώτο σημείο, ισούται με το τελευταίο (ώστε το σχήμα να «κλείνει»).

Το πρόγραμμα του παραπάνω παραδείγματος σχεδιάζει ένα τρίγωνο, διότι ο πίνακας συντεταγμένων περιέχει 4 σημεία, εκ των οποίων το τελευταίο ισούται με το πρώτο.

Με την παραπάνω συνάρτηση μπορούμε να σχεδιάσουμε διάφορα σχήματα όπως τετράγωνα, πεντάγωνα κτλ, ανάλογα με τον αριθμό των σημείων που θα παραθέσουμε στον πίνακα συντεταγμένων.
320, 150
420, 300
250, 300
Σχεδίαση Κυκλικού Τομέα (Τμήμα Πίτας)


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

   pieslice(200, 200, 0, 45, 100);
   getch();
   closegraph();
}

Μπορούμε να σχεδιάσουμε ένα κυκλικό τομέα με χρήση της συνάρτησης pieslice(). Ο κυκλικός τομέας είναι ένα τμήμα του κύκλου, το οποίο θα μπορούσαμε να πούμε ότι μοιάζει με κομμάτι πίτας.
Τα βασικά του χαρακτηριστικά για να μπορέσουμε να το ορίσουμε είναι, οι συντεταγμένες του κύκλου, η αρχική και τελική επίκεντρη γωνία (σε μοίρες) και η ακτίνα του κύκλου. Αυτά αποτελούν και τα ορίσματα της συνάρτησης pieslice().

Στο παραπάνω παράδειγμα, σχεδιάζεται ένας κυκλικός τομέας, ο οποίος έχει κέντρο στο σημείο 200, 200, ξεκινά από τη θέση 0ο  και τερματίζεται στη θέση 45ο ενώ η ακτίνα του κύκλου είναι 100.
200, 200
45ο
0ο
Σχεδίαση Ελλειπτικού Τομέα (Τμήμα Ελλειπτικής Πίτας)




#include <graphics.h>
#include <conio.h>
main() {
   int gd = DETECT, gm;
   initgraph(&gd, &gm, "C:\\TC\\BGI");

   sector(100, 100, 0, 90, 50, 100);

   getch();
   closegraph();
}


Η συνάρτηση sector(), σχεδιάζει έναν ελλειπτικό τομέα (τμήμα ελλειπτικής πίτας). Η λειτουργία της sector(), είναι ίδια με αυτή της ellipse(), υπό την έννοια ότι η έλλειψη έχει ένα κέντρο το οποίο ορίζεται από τις συντεταγμένες του, δύο ακτίνες, μια οριζόντια και μια κάθετη, ενώ επίσης πρέπει να οριστεί η αρχή και το τέλος του ελλειπτικού τμήματος (σε μοίρες κύκλου).

Το ελλειπτικό τμήμα, είναι πλήρες, δηλαδή είναι γεμάτο με λευκό χρώμα (το οποίο κάνει αντίθεση στο εξορισμού μαύρο φόντο της οθόνης) και με αυτό τον τρόπο σχεδιάζεται το τμήμα της πίτας. Το χρώμα μπορεί να αλλάξει, με τις συναρτήσεις ορισμού χρωμάτων.
Εμφάνιση Κειμένου σε Κατάσταση Γραφικών


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

   outtext("My Name Is Zac");
   getch();
   closegraph();
}

Η συνάρτηση outtext, χρησιμοποιείται για να εμφανίσουμε κείμενο ενώ βρισκόμαστε σε κατάσταση γραφικών (έχει γίνει αρχικοποίηση του παραθύρου γραφικών και αυτό είναι ενεργό). Το κείμενο το οποίο εμφανίζεται στην ουσία είναι γραφικά και δεν έχει καμία σχέση με το κείμενο το οποίο χρησιμοποιούμε ή αποθηκεύουμε ενώ βρισκόμαστε σε κατάσταση κειμένου (ενώ είμαστε σε εργασία σε command line mode).

Για τον παραπάνω λόγο, ΔΕΝ πρέπει να χρησιμοποιούμε συναρτήσεις εξόδου όπως η printf(), puts(), putch() κτλ. εφόσον βρισκόμαστε σε κατάσταση γραφικών.

Η παραπάνω συνάρτηση εμφανίζει το κείμενο στην τρέχουσα θέση του δρομέα. Εάν θέλουμε το κείμενο να εμφανιστεί σε συγκεκριμένη θέση της οθόνης γραφικών θα πρέπει να χρησιμοποιήσουμε τη συνάρτηση outtextxy(), όπως στο παρακάτω παράδειγμα.


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");
    outtextxy(100, 100, "My Name Is Zac");
    getch();
   closegraph();
}
Μορφοποίηση Κειμένου σε Κατάσταση Γραφικών




#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

settextstyle(GOTHIC_FONT, VERT_DIR, 5);
    outtextxy(100, 100, "My Name Is Zac");

    getch();
   closegraph();
}







Η συνάρτηση settextstyle(), καθορίζει τον τύπο, και το μέγεθος της γραμματοσειράς, καθώς και την κατεύθυνση του κειμένου.

Δέχεται τρεις παραμέτρους, η πρώτη εκ των οποίων καθορίζει τη γραμματοσειρά με πιθανές τιμές τις DEFAULT_FONT (8X8), TRIPLEX_FONT (bold), SMALL_FONT, SANS_SERIF_FONT και GOTHIC_FONT, η δεύτερη καθορίζει τον προσανατολισμό του κειμένου με πιθανές τιμές τις VERT_DIR (κάθετα) και HORIΖ_DIR (οριζόντια) και η τρίτη το μέγεθος της γραμματοσειράς με πιθανές τιμές από 1 έως 10 (1 το μικρότερο).

#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

settextstyle(SANS_SERIF_FONT, HORIZ_DIR, 5);
    outtextxy(100, 100, "My Name Is Zac");

    getch();
   closegraph();
}
Γέμισμα Έλλειψης και Κύκλου


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

fillellipse(100, 100, 50, 25);
   
    getch();
   closegraph();
}

Η συνάρτηση fillellipse(), σχεδιάζει μια έλλειψη η οποία είναι γεμισμένη με λευκό χρώμα (σε αντίθεση με το εξορισμού μαύρο φόντο της οθόνης). Η σύνταξή της μοιάζει με αυτή της ellipse(), με τη διαφορά, ότι είναι κλειστή (πλήρης έλλειψη και όχι ελλειπτικό τόξο ή τμήμα). Ως εκ τούτου, οι παράμετροι που δέχεται αφορούν τις συντεταγμένες του κέντρου και τις δύο ακτίνες (οριζόντια και κάθετη).
Η παραπάνω συνάρτηση μπορεί να χρησιμοποιηθεί και για το γέμισμα κύκλου εφόσον δοθούν ίδιες τιμές στις δύο ακτίνες, όπως στο παρακάτω παράδειγμα.

#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

fillellipse(100, 100, 50, 50);
   
    getch();
   closegraph();
}

Το λευκό χρώμα, μπορεί να αλλάξει, μέσω των συναρτήσεων καθορισμού χρώματος που προσφέρει η γλώσσα.
Γέμισμα Πολυγώνου



#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 int points[]={320,150,440,340,230,340,320,150};
 initgraph(&gd, &gm, "C:\\TC\\BGI");

fillpoly(4, points);
   
    getch();
   closegraph();
}


Η συνάρτηση fillpoly(), λειτουργεί όπως ακριβώς και οι αντίστοιχες συναρτήσεις σχεδιασμού τετραπλεύρων και πολυγώνων, με τη διαφορά ότι το πολύγωνο που σχεδιάζεται είναι γεμάτο με λευκό χρώμα (σε αντίθεση με το εξορισμού μαύρο φόντο της οθόνης). Το χρώμα φυσικά μπορεί να αλλάξει μέσω των συναρτήσεων καθορισμού χρώματος που προσφέρει η γλώσσα.

Οι συντεταγμένες των σημείων που δίνονται στον πίνακα points[], περνούν ως ορίσματα στην fillpoly() και αποτελούν τις γωνίες του πολυγώνου.

Το πολύγωνο πρέπει να κλείνει.
Αλλαγή Τύπου Γραμμής


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");
 setlinestyle(DASHED_LINE, 0, 3);

line(100, 100, 200, 200);
   
    getch();
   closegraph();
}

Η συνάρτηση setlinestyle(), καθορίζει τον τρόπο με τον οποίο εμφανίζεται (σχεδιάζεται) μια γραμμή. Δέχεται τρείς παραμέτρους εκ των οποίων η πρώτη ορίζει τον τύπο της γραμμής (SOLID_LINE, DOTTED_LINE, CENTER_LINE, DASHED_LINE, USERBIT_LINE), η δεύτερη το pattern και η τρίτη το πάχος της γραμμής (τιμές από 1 για την λεπτότερη έως 3 για την παχύτερη).

Η ανωτέρω συνάρτηση καθορίζει τον τύπο γραμμής που σχεδιάζεται από τις συναρτήσεις :

arc()
circle()
drawpoly()
ellipse()
line()
lineto()
pieslice()
rectangle()
Καθορισμός Χρώματος Αντικειμένου



#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 setcolor(RED);
   circle(100,100,50);
    getch();
   closegraph();
}

Η συνάρτηση setcolor(), καθορίζει το χρώμα του σχεδιαζόμενου αντικειμένου. Τα κύρια χρώματα που μπορούν να χρησιμοποιηθούν είναι ίδια με αυτά που αναφέρθηκαν στην ενότητα καθορισμού χρώματος των pixels.

Η συνάρτηση setcolor(), αναλαμβάνει δράση από τη στιγμή που χρησιμοποιείται και μπορεί να αλλάξει χρώματα σε διαφορετικά αντικείμενα μέσα στον κώδικα ενός προγράμματος.

#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 setcolor(RED);
   circle(100,100,50);
 setcolor(GREEN);
 rectangle(50,50,150,150);

    getch();
   closegraph();
}
Καθορισμός Χρώματος Φόντου


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 setbkcolor(YELLOW);
 setcolor(RED);
   circle(100,100,50);
 setcolor(GREEN);
 rectangle(50,50,150,150);

    getch();
   closegraph();
}

Η συνάρτηση setbkcolor(), χρησιμοποιείται για τον καθορισμό του χρώματος του φόντου. Εξορισμού το χρώμα φόντου είναι μαύρο, αλλά μπορεί να αλλάξει αρκετές φορές εντός του κώδικα ενός προγράμματος, μέσω της παραπάνω συνάρτησης.

Τα κύρια χρώματα που μπορούν να χρησιμοποιηθούν είναι αυτά που ήδη έχουν αναφερθεί, τόσο για τα pixels, όσο και για τα υπόλοιπα αντικείμενα.
Καθορισμός Χρώματος και Εφέ Γεμίσματος



#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 setfillstyle(SOLID_FILL, RED);
 fillellipse(100, 100, 50, 25);

    getch();
   closegraph();
}

Η συνάρτηση setfillstyle(), καθορίζει το χρώμα και το στυλ γεμίσματος ενός κλειστού αντικειμένου (το οποίο μπορεί να γεμίσει). Τα χρώματα που χρησιμοποιούνται είναι τα γνωστά, ενώ οι συναρτήσεις που επηρεάζονται είναι οι fillellipse(), fillpoly() και floodfill().

Παρατηρούμε ότι η γραμμή σχεδίασης του αντικειμένου δεν επηρεάζεται από την συνάρτηση.

Τέλος το στυλ γεμίσματος μπορεί να είναι ένα από τα παρακάτω :










#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 setfillstyle(LTSLASH_FILL, RED);
 fillellipse(100, 100, 50, 25);

    getch();
   closegraph();
}
Χρωματισμός Κλειστού Σχήματος


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 setcolor(RED);
   circle(100,100,50);
   floodfill(100,100,RED);

    getch();
   closegraph();
}

Η συνάρτηση floodfill(), γεμίζει ένα κλειστό σχήμα το οποίο περικλείεται από ένα συγκεκριμένο χρώμα, με βάση ένα σημείο που δίνεται στα ορίσματά της. Στο παραπάνω παράδειγμα, σχεδιάζεται ένας κύκλος με κόκκινο περίγραμμα (ο κύκλος έχει κέντρο στο 100, 100). Στη συνέχεια η floodfill(), ορίζει ένα σημείο (το 100, 100 το οποίο βρίσκεται εντός τυ κύκλου διότι αποτελεί το κέντρο του) και χρωματίζει με το εξορισμού χρώμα (WHITE), όλο το τμήμα το οποίο περικλείεται από κόκκινο χρώμα (δηλαδή όλο τον κύκλο). Αν το σημείο βρισκόταν έξω από τα όρια του κύκλου, τότε θα χρωματιζόταν το κομμάτι της οθόνης που βρίσκεται έξω από τον κύκλο.

Οι παράμετροι που δέχεται η floodfill(), είναι οι συντεταγμένες του σημείου το οποίο βρίσκεται εντός του κλειστού τμήματος που πρέπει να γεμίσει και το χρώμα του περιγράμματος αυτού του τμήματος.

Η floodfill επηρεάζεται από την setfillstyle(), τόσο ως προς το χρώμα, όσο και ως προς το pattern.

Τέλος αξίζει να σημειωθεί πως η floodfill(), δεν γεμίζει μόνο καθορισμένα τμήματα (πχ κύκλους, τετράπλευρα κτλ), αλλά και ακαθόριστα σχήματα. Για παράδειγμα μπορούμε να δημιουργήσουμε ένα ακαθόριστο πολύγωνο με κόκκινο περίγραμμα και συντεταγμένες (100, 100), (100, 150), (150, 240), (240, 150), (150, 100) και (100, 100) ώστε το πολύγωνο να κλείνει.












Στη συνέχεια θα μπορούσαμε να επιλέξουμε ένα σημείο εντός του παραπάνω σχήματος, για παράδειγμα το (110, 110). Για να ελέγξουμε αν όντως το σημείο ανήκει στο σχήμα, μπορούμε να ανάψουμε το εν λόγω pixel.

Τέλος μπορούμε να το γεμίσουμε με το επιθυμητό στυλ γεμίσματος και χρώμα, μέσω της floodfill().













Ο κώδικας του προγράμματος είναι ο παρακάτω :

#include <graphics.h>
#include <conio.h>
main() {
int gd=DETECT,gm,points[]={100, 100, 100, 150, 150, 240, 240, 150, 150, 100, 100, 100};
 initgraph(&gd, &gm, "C:\\TC\\BGI");
setcolor(RED); /* Σχεδίαση πολυγώνου */
   drawpoly(6, points);
getch();
putpixel(110, 110, WHITE); /* Υπόδειξη σημείου */
    getch();
setfillstyle(LTSLASH_FILL, YELLOW); /* Γέμισμα σχήματος */
floodfill(110, 110, RED);
getch();
   closegraph();
}

Σημείο με συντεταγμένες (110, 110). Βρίσκεται εντός του σχήματος
Γέμισμα του γεωμετρικού σχήματος, το οποίο περικλείεται από κόκκινο χρώμα με συγκεκριμένο στυλ γεμίσματος και χρώμα.
Καθαρισμός Παραθύρου



Μπορούμε να καθαρίσουμε το παράθυρο γραφικών από τα περιεχόμενά του μέσω της συνάρτησης cleardevice();
Η συνάρτηση cleardevice(), καθαρίζει τα περιεχόμενα της οθόνης μετακινώντας παράλληλα την τρέχουσα θέση στις συντεταγμένες (0, 0). Στην ουσία γεμίζει το παράθυρο με το χρώμα του φόντου.




                                                           cleardevice();
Έλεγχος Ανάλυσης Παραθύρου

Μπορούμε να ελέγξουμε το μέγεθος (ανάλυση) ενός παραθύρου γραφικών με τις συναρτήσεις getmaxx() και getmaxy() αντίστοιχα. Οι συναρτήσεις αυτές επιστρέφουν τη μέγιστη τετμημένη και τη μέγιστη τεταγμένη που μπορεί να οριστεί για ένα σημείο στο παράθυρο.


Έλεγχος Τρέχουσας θέσης


Μπορούμε να ελέγξουμε την τρέχουσα θέση στην οποία βρισκόμαστε σε ένα παράθυρο γραφικών , μέσω των συναρτήσεων getx() και gety() αντίστοιχα. Οι συναρτήσεις αυτές επιστρέφουν την τετμημένη και την τεταγμένη αντίστοιχα για το τρέχον σημείο (το σημείο δηλαδή στο οποίο βρισκόμαστε αυτή τη στιγμή).
Σχεδίαση Τρισδιάστατου Παραλληλεπιπέδου (3D Μπάρα)


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 bar3d(100, 100, 200, 200, 50, 1);

    getch();
   closegraph();
}

Μπορούμε να σχεδιάσουμε ένα παραλληλεπίπεδο τριών διαστάσεων (3D), μέσω της συνάρτησης bar3d(). Ορίσματά της είναι οι συντεταγμένες της άνω αριστερής και κάτω δεξιάς γωνίας, το βάθος του παραλληλεπιπέδου (μπάρας) καθώς και μια λογική τιμή (0 ή 1), η οποία καθορίζει αν το επάνω μέρος της μπάρας θα είναι ορατό ή όχι (1=Ναι, 0=Όχι).

Η συνάρτηση επηρεάζεται από την setfillstyle(), η οποία μπορεί να της καθορίσει το χρώμα αλλά και το στυλ γεμίσματος.

Αντιγραφή Τμημάτων της Οθόνης στη Μνήμη

#include <graphics.h>
#include <conio.h>
#include <stlib.h>
main() {
int gd = DETECT, gm; void *p;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

/* Σχεδιασμός αντικειμένου στην οθόνη γραφικών*/
 setcolor(RED); circle(300, 300, 80);
setcolor(GREEN); circle(300, 300, 60);
setcolor(CYAN); circle(300, 300, 40);

 /* Αντιγραφή τμήματος οθόνης στη μνήμη*/
 p = malloc(imagesize(220, 120, 300, 200));
getimage(220, 120, 300, 200, p);

 /* Επικόλληση περιεχομένων μνήμης σε σημείο της οθόνης γραφικών*/
 putimage(420, 320, p, COPY_PUT );
    getch();
   closegraph();
}

Το παραπάνω πρόγραμμα σχεδιάζει ένα αντικείμενο στην οθόνη και στη συνέχεια χρησιμοποιεί τη συνάρτηση getimage() για να αντιγράψει ένα τμήμα της οθόνης και να το αποθηκεύσει σε μια πρόχειρη περιοχή της μνήμης.

Το μέγεθος που απαιτείται για την αποθήκευση υπολογίζεται από την imagesize(), ενώ η αποθήκευση στη μνήμη γίνεται με χρήση της malloc().

Στην ουσία τόσο η imagesize(), όσο και η getimage() αντιγράφουν τα περιεχόμενα ενός παραλληλογράμμου το οποίο ορίζεται από τις συντεταγμένες της άνω αριστερής και κάτω δεξιάς γωνίας του.

Η getimage(), δέχεται ως παραμέτρους τις συντεταγμένες του παραλληλογράμμου και τον δείκτη στο σημείο της μνήμης όπου βρίσκεται αποθηκευμένη η εικόνα.

Τέλος η επικόλληση γίνεται μέσω της putimage(), η οποία δέχεται ως παραμέτρους τις συντεταγμένες της άνω αριστερής γωνίας του σημείου όπου θα γίνει η επικόλληση, τον δείκτη μνήμης και μια παράμετρο η οποία καθορίζει τον τρόπο με τον οποίο θα γίνει η επικόλληση (COPY_PUT για κανονική αντιγραφή).
ΑΣΚΗΣΗ 1η - ΣΧΕΔΙΑΣΜΟΣ ΑΝΤΙΚΕΙΜΕΝΩΝ

#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 setcolor(4);   circle(100, 100, 50); outtextxy(200, 100, “Circle”);
setcolor(1);   line(50, 200, 150, 200); outtextxy(200, 200, “Line”);
setcolor(6);   rectangle(50, 300, 150, 400); outtextxy(200, 350, “Rectangle”);
setcolor(2);   ellipse(400, 200, 0, 360, 10, 50); outtextxy(500, 200, “Ellipse”);

    getch();
   closegraph();
}

Το παραπάνω πρόγραμμα κάνει χρήση των βασικών σχεδιαστικών συναρτήσεων της βιβλιοθήκης graphics.h και εμφανίζει ένα κύκλο, μια ευθεία γραμμή, ένα τετράγωνο και μια έλλειψη, με διαφορετικά χρώματα, ενώ παράλληλα εμφανίζει κι ένα λεκτικό (περιγραφή) για κάθε ένα από αυτά.
ΑΣΚΗΣΗ 2η - ΟΜΟΚΕΝΤΡΟΙ ΚΥΚΛΟΙ

#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 setfillstyle(SOLID_FILL, MAGENTA); fillellipse(300, 200, 80, 80);
setfillstyle(SLASH_FILL, RED); fillellipse(300, 200, 60, 60);
setfillstyle(BKSLASH_FILL, GREEN); fillellipse(300, 200, 40, 40);
setfillstyle(LINE_FILL, CYAN); fillellipse(300, 200, 20, 20);

    getch();
   closegraph();
}

Το παραπάνω πρόγραμμα, σχεδιάζει ομόκεντρους κύκλους κάνοντας χρήση όχι της συνάρτησης circle(), αλλά της fillellipse(), διότι επιθυμεί κάθε κύκλος να έχει το δικό του pattern αλλά και χρώμα.

Έτσι χρησιμοποιείται η setfillstyle(), για να καθοριστεί το pattern και το χρώμα, ενώ η fillellipse(), χρησιμοποιείται με ίσες ακτίνες (κάθετη / οριζόντια) για να ορίσει κύκλο.

Όλοι οι κύκλοι έχουν ως κέντρο το ίδιο σημείο, ώστε να είναι ομόκεντροι, ενώ οι ακτίνες τους διαφέρουν κατά 20 pixels, ώστε τα τμήματα να είναι ίσα. Τέλος ο εξωτερικός κύκλος σχεδιάζεται πρώτος και το πρόγραμμα συνεχίζει με τον αμέσως μικρότερο και ούτω καθεξής, ώστε τα γεμίσματα να μην αλληλοεπικαλύπτονται.
ΑΣΚΗΣΗ 3η - ΑΣΤΡΟ 5 ΑΚΜΩΝ


#include <graphics.h>
#include <conio.h>
main() {
int gd = DETECT, gm;
int points[] = {100, 10, 40, 198, 190, 78, 10, 78, 160, 198, 100, 10};
 initgraph(&gd, &gm, "C:\\TC\\BGI");

 drawpoly(6, points);

    getch();
   closegraph();
}


Το παραπάνω πρόγραμμα σχεδιάζει ένα αστέρι πέντε κορυφών με χρήση της εντολής drawpoly(). Παρατηρούμε, ότι το αστέρι στην ουσία αντιμετωπίζεται ως πεντάγωνο, αν και στην ουσία δεν είναι κανονικό πολύγωνο. Αντιλαμβανόμαστε εν ολίγοις ότι αν γνωρίζουμε τις συντεταγμένες που ορίζουν τις ευθείες του πολυπλεύρου τότε μπορούμε να σχεδιάσουμε σχεδόν οποιοδήποτε ακαθόριστο σχήμα.