Elementi di Grafica Digitale standard grafici primitive grafiche

Slides:



Advertisements
Presentazioni simili
Trieste, 26 novembre © 2005 – Renato Lukač Using OSS in Slovenian High Schools doc. dr. Renato Lukač LinuxDay Trieste.
Advertisements

CUDA & OpenMP parallel programming.
L’esperienza di un valutatore nell’ambito del VII FP Valter Sergo
Cache Memory Prof. G. Nicosia University of Catania
Teoria e Tecniche del Riconoscimento
Interfacce Java.
1 Teaching Cloud Computing and Windows Azure in Academia Domenico Talia UNIVERSITA DELLA CALABRIA & ICAR-CNR Italy Faculty Days 2010.
Luca Bianchi Windows Development Day Bologna 28 gennaio 2005 SQL Server Desktop Engine (MSDE) & SQL Server 2005 Express.
1 Processi e Thread Processi Thread Meccanismi di comunicazione fra processi (IPC) Problemi classici di IPC Scheduling Processi e thread in Unix Processi.
GLUT & OpenGL Ing. Tommaso Coviello Politecnico di Bari
Italiano Da quando siamo passati al corso di metallurgia (3^o ) abbiamo cominciato a lavorare utilizzando i maniera didattica tecnologie di tipo hardware.
Layouts and Graphics. component - container - layout Un Container contiene [0 o +] Components Il Layout specifica come i Components sono disposti nel.
1 Fac.Scienze – Università di Trento Programmazione 2 - Marco Ronchetti Java JAVA: una introduzione.
Model – View - Controller
Unified Modeling Language class C {…} class B extends C {…} Esiste una notazione grafica per mostrare le relazioni di ereditarietà. Object StringC B Tutte.
1 Fac.Scienze – Università di Trento Programmazione 2 - Marco Ronchetti Java JAVA: una introduzione.
Sezione: Costruttori Costruttori. Definizione dei costruttori Se per una classe A non scrivo nessun costruttore, il sistema automaticamente crea il costruttore.
prompt> java SumAverage
1 struct Pila { private: int size; int defaultGrowthSize; int marker; int * contenuto; void cresci(int increment); public: Pila(int initialSize) ; Pila();
Costruzione di Interfacce Lezione 10 Dal Java al C++ parte 1
Costruzione di Interfacce Lezione 20 Qt + Opengl
1 Costruzione di Interfacce Primi passi in OpenGL
TIPOLOGIA DELLE VARIABILI SPERIMENTALI: Variabili nominali Variabili quantali Variabili semi-quantitative Variabili quantitative.
1. Conoscere luso delle collezioni in Java Comprendere le principali caratteristiche nelle varie classi di Collection disponibili Saper individuare quali.
JAVA C import java.util.*; #include <stdio.h>
1 Esercitazione sui segnali Problema: creare un programma analizzatore di file testuali che prenda come argomenti il nome di un file e una sequenza di.
2000 Prentice Hall, Inc. All rights reserved. 1 Capitolo 3 - Functions Outline 3.1Introduction 3.2Program Components in C++ 3.3Math Library Functions 3.4Functions.
1 Implementazione di Linguaggi 2 PARTE 6 Implementazione di Linguaggi 2 PARTE 6 Massimo Ancona DISI Università di Genova Testo: A.V. Aho, R. Sethi, J.D.Ullman.
2000 Prentice Hall, Inc. All rights reserved. 1 Capitolo 6: Classi e astrazione dati 1.Introduzione 2.Definizione delle strutture 3.Accedere ai membri.
1 laboratorio di calcolo II AA 2003/04 ottava settimana a cura di Domizia Orestano Dipartimento di Fisica Stanza tel. ( )
Gestione File System e I/O in Windows 2000 Implementazione del File System FAT-12, FAT-16, FAT-32 NTFS API relative al File System Gestione dei dispositivi.
Il main program Ogni programma in C++, per essere eseguibile, deve contenere una funzione main() da cui l’esecuzione comincerà main() deve avere un tipo.
ATE / 31 Lezione 3 i sistemi automatici di misurazione - gli ATE.
Le regole Giocatori: da 2 a 10, anche a coppie o a squadre Scopo del gioco: scartare tutte le carte per primi Si gioca con 108 carte: 18 carte.
Players: 3 to 10, or teams. Aim of the game: find a name, starting with a specific letter, for each category. You need: internet connection laptop.
1 Gestione della Window Daniele Marini. 2 Definire una Window: GLUT o altro WM /* Standard GLUT initialization */ glutInit(&argc,argv); glutInitDisplayMode.
1 Programmazione grafica 1 Daniele Marini. 2 Linguaggio di riferimento OpenGL: libreria di procedure che realizza un API (application programmers interface)
realizzazione app per Google Android OS
Palermo, may 2010 F.Doumaz, S.Vinci (INGV-CNT- Gruppo di telerilevamento)
Il sistema operativo Sistema operativo (in breve) –È costituito dai programmi di gestione delle operazioni più elementari del computer –… gestione di vari.
Lambiente operativo. 2 Per avviare e poter utilizzare il computer è necessario un particolare programma che si chiama sistema operativo. Windows è un.
Corso di Elementi di Informatica
PRIMI DISEGNI CON CABRI Realizzato da Daniel Bulgarini e Matteo Co CLASSE 2°C LICEO PASCAL MANERBIO.
© 2008 WS (WebScience srl) – All rights reserved WS Tech workshop Software Construction.
Fare clic per modificare lo stile del titolo Fare clic per modificare stili del testo dello schema – Secondo livello Terzo livello – Quarto livello » Quinto.
Guardate le seguenti due frasi:
Motor Sizing.
L2 Elaborazione di immagini in C/C++
24 aprile 2002 Avvisi: Risultati 1 o Esonero: (entro) lunedi 27 disponibili nella pag. WEB, ma anche esposti nella bacheca fuori dal corridoio 2 o dente,
Funzioni stringhe. chr Restituisce il carattere di un valore ascii dato. Per vedere lelenco dei codici ascii clicca QQQQ uuuu iiiiEsempio
Test con JUnit. zJUnit è un ambiente di test per programmi Java ySviluppato da Kent Beck É possibile usare JUnit allinterno di Eclipse per eseguire i.
Project Review Novembrer 17th, Project Review Agenda: Project goals User stories – use cases – scenarios Project plan summary Status as of November.
Enzo anselmo ferrari By: Orazio Nahar.
Info su OpenGL Daniele Marini Marzo Librerie OpenGL Compresa in workstation SiliconGraphics Disponibile per MS Windows(98 & NT, 2000?) Disponibile.
FOR EVERY CALLOUT THAT YOU WILL SEE IN ENGLISH PROVIDE (IN WRITING) THE CORRECT ITALIAN SENTENCE OR EXPRESSION. REMEMBER TO LOOK AT THE VERBS AND PAY.
UG40 Energy Saving & Twin Cool units Functioning and Adjustment
Introduzione al linguaggio C. Cos’e’ il C? Il C e’ un linguaggio ad alto livello Un compilatore C prende in input un file contenente codice sorgente C.
Corso di Programmazione Grafica e Laboratorio Daniele Marini
Display list e scene graph Daniele Marini Dipartimento di Informatica e Comunicazione.
1 Programmazione grafica: l’Interazione Daniele Marini.
Collection & Generics in Java
Introduction to automatic ABMs documentation Keywords: Doxygen ODD protocol MASON documentation Simone Romano.
It’s a chain story created by our little pupils of pre-school and first classes of primary. It’s a scraper-book made by several materials and by their.
Sistemi di elaborazione dell’informazione Modulo 3 -Protocolli applicativi Unità didattica 4 - Protocolli del Web Ernesto Damiani Lezione 3 – Esempi HTTP.
SQL Developer Lanciare sqldeveloper (alias sul desktop) / c:\Oracle\sqldeveloper Associare tutti i tipi di file, se volete Tasto destro sulla spina “connection”
Pronomi personali di forma tonica
Passato Prossimo. What is it?  Passato Prossimo is a past tense and it is equivalent to our:  “ed” as in she studied  Or “has” + “ed” as in she has.
Italian 1 -- Capitolo 2 -- Strutture
Place Title / Heading Here
Transcript della presentazione:

Elementi di Grafica Digitale standard grafici primitive grafiche

librerie standardizzate: GKS (Graphical Kernel System) grafica raster, parte software: librerie standardizzate: GKS (Graphical Kernel System) (primo standard ISO e ANSI) GKS 3D PHIGS (Programmer's Hierarchical Interactive Graphics Standard Open GL (Open Silicon Graphics Graphical Library) Open GL 2 (vedi rete, http://www.sgi.com/products/software/opengl/ ... DirectX (proprietario MS) (ad es. http://www.deakin.edu.au/~agoodman/scc308/index.html , corso di COMPUTER GRAPHICS ... )

Core : The Core Graphics System. Created in the late 1970s by the ACM SIGGRAPH Graphics Standards Planning Committee. Designed to provide a standard set of library routines, based on (then) current device-independent graphics practice (largely vector terminals attached to mainframes, with off-line processing), it was overtaken (replaced) by the more comprehensive GKS and (later) PHIGS, as well as by developments in raster display systems, and the development of real-time processing on graphics workstations. Its significance includes the fact that many of its principles were later adopted by both GKS and PHIGS. http://www.deakin.edu.au/~agoodman/scc308/topic3.html

GKS: The Graphical Kernel System. Originally devised by a combined British and German group, GKS became the first graphics system to be fully standardised by ANSI and ISO in 1984. Originally a two-dimensional system, it has been extended to three dimensions; directly, as GKS3D, and indirectly, through PHIGS. Still vector-based, although with much greater emphasis on interactivity. It introduced the idea of a 'virtual workstation' as a way of encouraging and enforcing device-independence.

PHIGS The Programmers Hierarchical Interactive Graphics System. Fundamentally a development from both CORE and GKS, with powerful 3D functionality, reflecting the development in the late 1980s of powerful workstations capable of real time display of complex 3D objects. It also supports direct data structure creation and manipulation. Greater direct support for raster operations was added with PHIGS+ in 1986. http://www.deakin.edu.au/~agoodman/scc308/topic3.html

negli anni 80 furono studiate diverse alternative per il problema della scrittura di software adatto alla progettazione e realizzazione di disegni / immagini di vario tipo (dal disegno tecnico per meccanici al disegno a mano libera per artisti): soluzione gia' presente e che alla fine ha prevalso: librerie grafiche da usare come libreria accessibile da un linguaggio di programmazione standard (ad es. dal Fortran) la soluzione piu' elegante dei linguaggi grafici - con i linguaggi standard piu' diffusi al tempo estesi alla grafica, ad es. il Graphic Pascal, con operatori e tipi grafici predefiniti - non ha avuto successo con l'introduzione dei object-oriented languages e' rimasta la prima soluzione: linguaggio standard+libreria

Ogni libreria grafica prevede un collegamento con diversi linguaggi, “Language Binding", cosi' il GKS - libreria grafica - aveva un'interfaccia per il Fortran, una per il Pascal, una per il C ecc; cosi' PHIGS, e cosi' Open GL ad es. con la libreria PHIGS, per tracciare una spezzata di n punti e n-1 segmenti in Fortran si scrivera': CALL GPL(n, Xtab, Ytab ) in Pascal si scrivera': polyline(n,xtab,ytab); in C : gpolyline(n, points); dove points e' un array di punti, che sono a loro volta delle struct di coordinate (x,y) oppure (x,y,z) oppure (x,y,z,a) ecc (vedremo)

Introduzione alla Grafica Digitale primitive grafiche: * oggetti e attributi grafici elementari (predefiniti) disponibili al programmatore es.: punto, linea, ... 8

Introduzione alla Grafica Digitale primitive grafiche: * oggetti e attributi grafici elementari (predefiniti) disponibili al programmatore es.: punto, linea, ... * descrizione del "mondo" utente, spazio di coordinate del problema dove si costruisce l'immagine es.: limiti per x,y,z 9

Introduzione alla Grafica Digitale primitive grafiche: * oggetti e attributi grafici elementari (predefiniti) disponibili al programmatore es.: punto, linea, ... * descrizione dell' HW che produce l'immagine, per quanto interessa la visualizzazione dell'immagine su schermo e l' intera-zione con l' utente del programma, es.:finestra schermo * descrizione del "mondo" utente, spazio di coordinate del problema dove si costruisce l'immagine es.: limiti per x,y,z 10

Introduzione alla Grafica Digitale primitive grafiche: punto segmento triangolo rettangolo poligono cerchio ellisse bitmap carattere attributi: posizione, orientamento, forma, colore, trasparenza,.. descrizione dell'HW dove si produce l'immagine caratteristiche dello schermo, della finestra sullo schermo, dei colori disponibili, dispositivi di interazione ecc descrizione del mondo utente o spazio problema dove e' costruita l'immagine, quindi limiti delle coordinate, specifica del passaggio dalle coordinate "mondo alle coordinate schermo ... 11

si noti che per tracciare un'immagine sullo schermo e per memorizzare e/o trasmettere un'immagine devo utilizzare un insieme di primitive grafiche, devo specificare lo spazio del problema e le caratteristiche dello schermo e della finestra o parte dello schermo usata ("Work-station" o "Window") e anche il formato del "display file" o "meta-file" ad es. in PHIGS per costruire un'immagine si fara' : openPhigs( errFile, memSize) openWorkstation(ws, connection,type,...) ... create and display the picture ... closeWorkstation(ws) closePhigs

La libreria Open GL e' stata inizialmente definita solo per la parte delle primitive e delle operazioni disponibili, e sono le due librerie di base, la gl e la glu, mentre la parte "apri finestra" specifica dispositivo grafico ecc era legata al Sistema Operativo in uso, ed era (ed e') diversa da Unix, Windows, Apple OS 9, ecc; in seguito fu aggiunta una libreria di "interfaccia standard" per le funzioni di piu' usate e piu' semplici legate al sistema operativo, e' la libreria gl-utility library, o glut, che rende un programma sorgente eseguibile su sistemi operativi diversi (windows, unix, apple os)

per inizializzare una finestra di lavoro in OpenGL con la libr per inizializzare una finestra di lavoro in OpenGL con la libr. glut si avra' la sequenza di comandi: glutInit(&argc, argv); (vedremo) glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition( dove_sta_x0, dove_sta_y0 ); glutInitWindowSize( X_SIZE_width, Y_SIZE_height ); glutCreateWindow( " TITOLO " ); ... glut NON appartiene alla parte centrale di OpenGL, ma alla libreria estesa glut - gl utility toolkit, - NOTA: il Borland Builder usa la VCL (visual class lib), cosi' MS Win NT.. usa una sua libreria (vedi NeHe.gamedev.com) (anche la specifica del formato di un file grafico non appartiene a OpenGL) - ma per Win NT.. esiste la versione glut adattata per MS win (vedi http://www.opengl.com )

http://nehe.gamedev.net/ (NEHE Jeff Molofee univ.Hull,York,UK) openGL e' disponibile su molte piattaforme (Unix, Windows, Apple OS9, Apple OSX... su Windows piu' versioni, compresa quella che usa la libreria pubblica glut; su rete si trova una gran quantita' di materiale ! http://nehe.gamedev.net/ (NEHE Jeff Molofee univ.Hull,York,UK) --------------------------------------------------------- windows + glut version: original (#include <windows.h>) runs on Win NT etc; When creating your project, uncheck OWL, uncheck Class Library, select Static instead of Dynamic and change the target model to Console from GUI. Also link glut.lib to your project once its done.

nota: la libreria glut e' disponibile in sorgente ----------------------------------------------------------------------- nota: la libreria glut e' disponibile in sorgente su rete, dalla stessa organizzazione dell'OpenGL Racano (corso EGD05) segnala gl e glut per Borland 5.5, richiesto: Borland C++5.5, OpenGL runtime sw della MS, e GLUT da rete: scaricare OpenGL95.exe (unzip), copiare opengl32.dll in \windows\system\ (o winnt\system32\), copiare GL.H, GLU.H, GLAUX.H in <borland\include\gl\ (creare il dirett. gl), poi creare da .dll le .lib di: opengl32.dll, glu32.dll, glut32.gll, glut.dll, winmm.dll (con implib della Borland: implib <libname>.lib <libname>.dll e poi copiare le lib in \borland\libs\ ricorda: manuale OpenGL "libro rosso"

istruzioni per l'installazione di OpenGL su Windows: Istruzioni per l'installazione delle librerie OpenGL in VS 2008: nota: PVS sta per C:\Program Files\Microsoft Visual Studio 9.0 scaricare da rete quanto richiesto sotto; - copiare freeglut.h in: 'PVS\VC\include\GL\' - copiare freeglut_ext.h in: 'PVS\VC\include\GL\' - copiare freeglut_std.h in: 'PVS\VC\include\GL\' - copiare freeglut.lib in: 'PVS\VC\lib\' - copiare freeglut.dll in: 'C:\WINDOWS\system32\' - copiare glut32.dll in: 'C:\WINDOWS\system32\' - copiare glut32.lib in: 'PVS\VC\lib\' - copiare glut.h in: 'PVS\VC\include\GL\'

Create a new C++ Console project in VS. 1a. In the Create Application Wizard, select Empty Project. Add a new cpp file to the empty project. Add a bit of template code in there. For example: #include int main () { return 0; } If you try to compile, VS will fail to compile. This is because it can't see the freeglut header files. 3a. On the menu bar, go to Project -> Properties (Alt+F7).

3b. Go to Linker -> Input and copy and paste this line. opengl32 3b. Go to Linker -> Input and copy and paste this line. opengl32.lib glu32.lib glut32.lib 4. If you try to compile now, errors may still show up. You'll probably need to add directories for your header and lib files in Project/Solutions directories. 5. The program should now compile.

per cui si usa la include condizionale: le librerie OpenGL funzionano su piattaforme diverse, ma hanno bisogno di include diverse, per cui si usa la include condizionale: #if defined __APPLE__ #include ... sara' attivo se il sistema su cui sto compilando e' Apple OS #else // not apple : win or unix #include ... ... sara' attivo se il sistema su cui sto compilando non e' Apple OS, e quindi e' Windows oppure Unix ... #endif // which o.s.

// schema per include che va ok per Apple e Win #if defined __APPLE__ #include <GLUT/glut.h> /* APPLE OSX Xcode */ typedef char BYTE; #else // not apple : win or unix /* #define WIN32_LEAN_AND_MEAN */ /* evita inclusione di tutti i package ms */ #include <windows.h> /* TOGLI SE UNIX */ /* following is common to win and unix */ #include <GL/gl.h> #include <GL/glu.h> #include <GL/glut.h> #include <GL/glaux.h> #endif // which o.s. /* #include <GL/glext.h> // extensions */

vi sono anche altri punti di diversita' tra Apple OSX e Windows, (che sono emersi durante il corso EGD) ad es. random(n) su Win, random()%n su Apple e altri, come M_PI definito nella math.h in Apple OSX ma che richiede un #define _USE_MATH_DEFINES // NECESSARIO in WinMS se uso M_PI, M_PI_4 ...

interfaccia "multi uso" per esempi su Apple OSX e su Windows: /* file include.h 29/3/05 GL includes //----------------------------------------- #if defined __APPLE__ #include <GLUT/glut.h> /* includes GL/gl.h */ // #include <GL/glext.h> /* extensions ... */ #else // avoid inclusion of all (or too much) MS stuff: #define WIN32_LEAN_AND_MEAN #include <windows.h> /* and now include */ #include <GL/gl.h> #include <GL/glu.h> #include <GL/glut.h> #include <wingdi.h> #endif // nota: la libreria glut e' disponibile in sorgente // su rete, dalla stessa organizzazione dell'OpenGL,

#ifndef myINCLUDE_H /* A.Zupan 4 mar 06 */ #define myINCLUDE_H #if defined WIN32 /*Win98,NT,XP MS VS C++ */ #include <windows.h> #include <GL/gl.h> #include <GL/glu.h> #include <GL/glut.h> #elif defined __APPLE__ /*APPLEOSX Xcode */ #include <GLUT/glut.h> #else /* Linux code */ #include <string.h> #include <stdlib.h> #endif #include <GL/glext.h> /*seguono altri includ*/

un programma in C o C++ che usa penGL deve specificare l'ambiente in cui si disegna - quindi una finestra grafica; al minimo: ... includes (abbiamo visto) ... prototipi void faDisplay( void ); /*chiamare quando il gestore eventi decide di disegnare */ void myInit(); /*inizializzazioni (una tantum) per il mio programma OGL*/ void OpenWindow( int argc, char* argv[] ); /* inizializzazione della finestra */ void myGlReshape (int wi, int he); int main (int argc, char * argv[]) {

un programma in C o C++ che usa penGL deve specificare l'ambiente in cui si disegna - quindi una finestra grafica; al minimo: ... includes ... prototipi int main (int argc, char * argv[]) { OpenWindow( argc, argv ); glutDisplayFunc(faDisplay); /* NB: parametro e' una proc: */ /* avverti GLUT chi chiamare quando si disegna */ /* in faDisplay c'e' quanto necessario per fare il disegno */ glutReshapeFunc(myGlReshape); myInit(); /* tutte le cose da fare una volta glutMainLoop(); /* il programma va in letargo ... sara' OGL a attivare le procedure in risposta agli eventi previsti nel main prima di passare al mainloop */ return 0; /*non sara'mai eseguito */ } /* main */

void OpenWindow( int argc, char* argv[] ){ GLint dimx, dimy; do{ printf("dimens.x y? "); scanf("%d%d", &dimx, &dimy ); } while (dimx<100||dimx>800||dimy<100||dimy>600); glutInit(&argc, argv); /* inizializza GLUT */ /* **** chiamata per prima ***** */ glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE ); /* modalita' RGB 8 bit/color (24 bit)+AlfaChannel */ glutInitWindowPosition(60, 20); /* posizione angolo sopra a sinist su schermo zero zero = angolo in alto a sinistra ... */ glutInitWindowSize(dimx, dimy); /*dimensione della finestra, in pixel */ glutCreateWindow("OGL1A_2RIGHE"); /* crea la finestra; non disegnata, finche' non si chiama glutMainLoop */ /*e questo e' la trafila standard per creare una finestra...*/ } /* OpenWindowPlease */

void myInit() { glViewport( 0,0, /* punto in basso a sinistra */ glutGet(GLUT_WINDOW_WIDTH), /* in alto a destra */ glutGet(GLUT_WINDOW_HEIGHT) ); glMatrixMode( GL_PROJECTION); /* 4x4 projection matrix for openGL hw */ glLoadIdentity(); /* si parte da una matrice unitaria */ gluOrtho2D( 0,glutGet(GLUT_WINDOW_WIDTH), /* left right clipping planes */ 0, glutGet(GLUT_WINDOW_HEIGHT) ); /* bottom and top clipping planes */ } /* MyGLInit */ void myGlReshape (int wi, int he) { /*sara' chiamata su evento reshape (cambia forma finestra) wi,he nuove dimensioni della finestra */ myInit(); glutPostRedisplay(); } // myGlReshape ()

Introduzione alla Grafica Digitale riprendiamo le primitive grafiche: punto segmento triangolo rettangolo poligono cerchio ellisse bitmap carattere e gli attributi delle primitive grafiche, come: posizione, orientamento, forma, colore 32

per disegnare un punto specifico posizione coordinate x,y colore componenti RGB dimensione: larghezza (==altezza) il frammento seguente di programma disegna due punti (nota suffissi 2f e 3f !) glPointSize( 4.4 ); glBegin( GL_POINTS ); // NOTA INIZIO glColor3f( 0.3, 0.3, 1.0 ); // blu glVertex2f( width/2.0, height/2.0 ); glColor3f( 1.0, 0.0, 0.0 ); // rosso glVertex2f( width*0.45, height*0.45 ); glEnd(); // E FINE DI SEQUENZA

Introduzione alla Grafica Digitale procedimento standard OpenGL per disegnare piu' punti: struct Tpunto{ float x; float y; }; ... glColor3f( colR, colG, colB ); glPointSize(10.0); glBegin(GL_POINTS); // <<<<<<<<<<<< glVertex2f( Punto1.x, Punto1.y); glVertex2f( Punto2.x, Punto2.y); glVertex2f( Punto3.x, Punto3.y); glVertex2f( Punto4.x, Punto4.y); glEnd(); qui vengono disegnati quattro punti 34

tracciare o disegnare un pixel in OpenGL: approccio standard: con la funzione glVertexABC, con A,B,C che possono essere ... es: int P1[]={50,110}; // un punto dato come vettore struct TP{float x; float y;} P2={0.5, 0.5}; //pto come struct glBegin(GL_POINTS); glVertex2i( 50, 100 ); glVertex2iv( P1 ); // nota sufisso 2iv - vector di 2 elem. glVertex3f( 7.2, 10.3, 100.0 ); // suffisso 3f glVertex2f( P2.x, P2.y ); // suffisso 2f glEnd(); // si noti le varianti della glVertex, a seconda del tipo e // del numero dei parametri (Open GL non e' C++, ma C!) // glFunz4f(4 parametri float) glFunz3i(tre parametri int) 35

TRACCIA UNA LINEA SU SCHERMO Introduzione alla Grafica Digitale Passaggio da primitiva matematica (geometrica) punto, linea a primitiva grafica su schermo raster: pixel, linea di pixel un punto ha dimensione zero, spessore zero, area zero in un rettangolo astratto ("finestra" nel piano {x,y} ) vi sono infiniti punti ! un pixel ha dimensione fissa non nulla (pixel pitch), sullo schermo c'e' un insieme ben delimitato di punti (ad es. 1600x1024) linea: l'oggetto matematico linea (dimensione 1) ha spessore zero, area zero; linea: l'oggetto grafico e' una stringa di pixel con area, spessore, VEDIAMO ORA COME SI TRACCIA UNA LINEA SU SCHERMO 36

glBegin(GL_LINES); // NB: (0,0) sta in basso a sinistra void myDisplay() { //due linee: una verde in basso, blu digonale // myw,myh=limiti spazio utente, width,height = larghez,altez // prima una LINEA SOTTILE VERDE in basso glColor3f( 0.0, 1.0, 0.0 );//red,green,blue glLineWidth(2.0); a=0.02*myw; b=0.02*myh; c=0.98*myw; d=0.02*myh; glBegin(GL_LINES); // NB: (0,0) sta in basso a sinistra glVertex2f( a,b ); // coordinate punto sinistra,basso, glVertex2f( c,d ); // coordinate punto destra, basso, glEnd(); // poi una LINEA GROSSA BLU DIAGONALE glColor3f( 0.0, 0.0, 1.0 ); glLineWidth(8.0); x1=0.04*myw; y1=0.96*myh; x2=0.96*myw; y2=0.04*myh; glBegin(GL_LINES); glVertex2f(x1,y1); // punto a sinistra in alto glVertex2f(x2,y2); // punto a destra in basso

glVertex2f(x1,y1);//sin,alto glVertex2f(x2,y2);//des,basso // Open GL, disegna due linee: // myw, myh = width,height spazio utente, // LINEA SOTTILE VERDE in basso glColor3f( 0.0, 1.0, 0.0 );//red,green,blue glLineWidth(2.0); a= 0.02*myw; b=0.02*myh; // sinistra,alto c= 0.98*myw; d=0.02*myh; // destra, basso, // QUI (0,0) sta in basso a sinistra! possibili // entrambe le posizioni glBegin(GL_LINES); glVertex2f( a,b ); glVertex2f( c,d ); glEnd(); // LINEA GROSSA BLU DIAGONALE glColor3f( 0.0, 0.0, 1.0 ); glLineWidth(8.0); x1=0.04*myw; y1=0.96*myh; x2=0.96*myw; y2=0.04*myh; glBegin(GL_LINES); glVertex2f(x1,y1);//sin,alto glVertex2f(x2,y2);//des,basso

abbiamo visto due esempi di uso di punti e di linee: 0=GL_POINTS, separate points P[0],P[1],..P[k] abbiamo visto due esempi di uso di punti e di linee: glPointSize( 4.4 ); glBegin( GL_POINTS ); // NOTA procedura INIZIO diseg glColor3f( 0.3, 0.3, 1.0 ); // blu glVertex2f( width/2.0, height/2.0 ); glColor3f( 1.0, 0.0, 0.0 ); // rosso glVertex2f( width*0.45, height*0.45 ); glEnd(); // procedura FINE DI SEQUENZA 1=GL_LINES, points pairs= separate line segments a= 0.02*mywidth; b=0.02*myheight; // sinistra,alto c= 0.98*mywidth; d=0.02*myheight; // destra, basso, glColor3f( 0.0, 1.0, 0.0 ); //red,green,blue glLineWidth(2.5); glBegin( GL_LINES ); // procedura INIZIO disegna glVertex2f( a,b ); glVertex2f( c,d ); glEnd(); // procedura FINE DI SEQUENZA 39

primitive grafiche: ogni immagine e' costruita utilizzando elementi di base, detti primitive grafiche: l'Open GL definisce 10 primitive grafiche da usare come parametro di glBegin( param ); ... glEnd(); 0=GL_POINTS, separate points P[0],P[1],..P[k] 1=GL_LINES, points pairs=separate line segments 2=GL_LINE_LOOP,closed line P[0],P[1]..P[n],P[0] 3=GL_LINE_STRIP, open line P[0],P[1]..P[n] 4=GL_TRIANGLES, each vert. triplet = triangle non ripetiamo i due esempi visti di uso di punti e di linee, dopo la tabella seguente sono dati 10 es di uso; 40

primitive grafiche: Open GL 5=GL_TRIANGLE_STRIP, odd and even vert. define a triangolarized polygon 6 6=GL_TRIANGLE_FAN, vertex V[0] is common to triangles V[0]-(V[k]-V[k+1]) 7=GL_QUADS, each quadruple V[k]-V[k+3]=quadril. 8=GL_QUAD_STRIP, V[0]..V[n] = polygon mesh of quadrilaterals, odd=one side,even the other 9=GL_POLYGON V[0]..V[n] a closed polygon dopo la tabella (pagina seguente) sono dati 10 esempi di uso: 41

vediamo ora altri esempi Tutte le primitive: 0=GL_POINTS, separate points P[0],P[1],..P[k] 1=GL_LINES, points pairs=separate line segments 2=GL_LINE_LOOP,closed line P[0],P[1]..P[n],P[0] 3=GL_LINE_STRIP, open line P[0],P[1]..P[n] 4=GL_TRIANGLES, each vertex triplet = triangle 5=GL_TRIANGLE_STRIP, odd and even vertex define a triangolarized polygon 6=GL_TRIANGLE_FAN, vertex V[0] is common to all triangles V[0]-(V[k]-V[k+1]) 7=GL_QUADS, each quadruple V[k]-V[k+3]=quadril. 8=GL_QUAD_STRIP, V[0]..V[n] = polygon mesh of quadrilaterals, odd=one side,even the other 9=GL_POLYGON V[0]..V[n] a closed polygon vediamo ora altri esempi 42

primitiva zero - POINTS 0) figura di 6 punti ottenuta con la sequenza: // xx2, yy2 sono le dimensioni della finestra !! P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_POINTS ); // GL_POINTS = 0 = primitiva 0 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd(); Nota per tutte le figure "PRIMITIVE": e' aggiunta una GL_LINE_STRIP che unisce i punti, e anche su alcuni sono aggiunte le etichette dei punti P1..P6 primitiva zero - POINTS es zero: punti singoli la spezzata solo per mostrare la sequenza

es 1 : linee separate 1) figura di segmenti di retta, ottenuta con: // GL_LINES each couple Vk,Vk+1 define a line P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_LINES );// primitiva 1 // disegna un segmento di linea // per ogni coppia di punti glVertex2fv( P1 ); // 1 a sinis,basso glVertex2fv( P2 ); glVertex2fv( P3 ); // 2 a dest,basso glVertex2fv( P4 ); glVertex2fv( P5 ); // 3 in alto glVertex2fv( P6 ); glEnd(); nota che su tutti gli es. e' aggiunta la GL_LINE_STRIP in rosso, e (su alcuni) le etichette dei punti es 1 : linee separate

es 2 : linea spezzata chiusa 2) figura di una spezzata chiusa, ottenuta con la sequenza: P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_LINE_LOOP ); // == 2 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd(); es. OGL2A_PRIMITIVE) nota che su tutti gli es. e' aggiunta la GL_LINE_STRIP in rosso, es 2 : linea spezzata chiusa

es 3: linea spezzata aperta 3) figura di una spezzata aperta, ottenuta con la sequenza: P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_LINE_STRIP ); // primitiva == 3 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd(); es. OGL2A_PRIMITIVE; nota che anche qui e'aggiunta la linea spezzata rossa e i nomi dei punti primitiva 3 LINE_STRIP es 3: linea spezzata aperta

es 4: triangoli separati 4) figura con due triangoli ottenuta con : P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_TRIANGLES ); // primitiva 4 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd(); PRIMITIVA 4 = TRIANGLES es 4: triangoli separati OGNI TERNA DI PUNTI DEFINISCE UN TRIANGL. (nota che su tutti gli es. sono aggiunti la GL_LINE_STRIP in rosso, e qui anche i nomi dei punti)

un poligono = superficie con contorno dato da un poligono puo' essere pensata come formata da un mosaico di triangoli,

es 5: poligono di triangoli pieni uniti - notare l'ordine dei punti ! 5) figura di poligono pieno fatto con triangoli, ottenuta con la sequenza: P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_TRIANGLE_STRIP ); // primitiva == 5 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P6 ); glVertex2fv( P3 ); glVertex2fv( P5 ); glVertex2fv( P4 ); glEnd(); NB:i vertici dei triangoli sono alternati (pari da una parte, dispari dall'altra) PRIMITIVA 5 = TRIANGLE STRIP es 5: poligono di triangoli pieni uniti - notare l'ordine dei punti !

es 6: poligono di triangoli pieni uniti a ventaglio 6) figura a poligono pieno di triangoli, ottenuta con la sequenza: P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_TRIANGLE_FAN ); // primitiva == 6 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd(); i triangoli hanno tutti un vertice in comune !(ricorda: FAN=ventaglio) PRIMITIVA 6 = TRIANGLE FAN es 6: poligono di triangoli pieni uniti a ventaglio

es 7: rettangoli pieni non uniti notare l' ordine dei punti primitiva 7 rettangoli 7) figura di quadrilateri, ottenuta con la sequenza: Q1[0]= xx2*0.1; Q1[1]= yy2*0.7; Q2[0]= xx2*0.1; Q2[1]= yy2*0.3; Q3[0]= xx2*0.3; Q3[1]= yy2*0.3; Q4[0]= xx2*0.3; Q4[1]= yy2*0.7; Q5[0]= xx2*0.6; Q5[1]= yy2*0.8; Q6[0]= xx2*0.6; Q6[1]= yy2*0.2; Q7[0]= xx2*0.9; Q7[1]= yy2*0.2; Q8[0]= xx2*0.9; Q8[1]= yy2*0.8; ... glBegin( GL_QUAD ); // == 7 glVertex2fv( Q1 ); // uno glVertex2fv( Q2 ); // uno glVertex2fv( Q3 ); // uno glVertex2fv( Q4 ); // uno glVertex2fv( Q5 ); // due glVertex2fv( Q6 ); // due glVertex2fv( Q7 ); // due glVertex2fv( Q8 ); // due glEnd(); // ogni 4 punti definiscono // un quadrilatero es 7: rettangoli pieni non uniti notare l' ordine dei punti

8) figura di quadrilateri contigui, ottenuta con la sequenza: ... P1[0]= xx2*0.1; P1[1]= yy2*0.7; P2[0]= xx2*0.1; P2[1]= yy2*0.3; P3[0]= xx2*0.3; P3[1]= yy2*0.3; P4[0]= xx2*0.3; P4[1]= yy2*0.7; P5[0]= xx2*0.6; P5[1]= yy2*0.8; P6[0]= xx2*0.6; P6[1]= yy2*0.2; P7[0]= xx2*0.9; P7[1]= yy2*0.2; P8[0]= xx2*0.9; P8[1]= yy2*0.8; ... glBegin( GL_QUAD_STRIP ); glVertex2fv( P1 );//disp sinist glVertex2fv( P2 );// pari dest glVertex2fv( P4 );//disp sinist glVertex2fv( P3 );// pari dest glVertex2fv( P5 );//disp sinist glVertex2fv( P6 );// pari dest glVertex2fv( P8 );//disp sinist glVertex2fv( P7 );// pari dest glEnd(); //NOTA l'ordine della squenza! NOTA: i vertici dei quadrilateri sono alternati (i vertici pari da una parte, i dispari dall'altra) primitiva 8 QUAD STRIP es. 8: poligono fatto da striscia di quadrilateri uniti tra loro (ogni quadr. e' fatto da due triangoli)

primitiva 9 poligono pieno 9) ultima primitiva, il poligono pieno : figura ottenuta con la sequenza: P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_POLYGON ); // == 9 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd(); primitiva 9 = un poligono chiuso, pieno (non solo il contorno) primitiva 9 poligono pieno es. 9: poligono pieno definito dalla linea spezzata chiusa (e' fatto con triangoli)

primitiva 9 poligono pieno MA ATTENZIONE - nota: l'open GL disegna correttamente poligoni convessi, mentre un poligono concavo non viene disegnato correttamente: il frammento di programma seguente produce la fig a fianco: glBegin( GL_POLYGON ); glVertex2f(xx2*0.2, yy2*0.2); glVertex2f(xx2*0.5, yy2*0.75); glVertex2f(xx2*0.8, yy2*0.2); glVertex2f(xx2*0.8, yy2*0.8); glVertex2f(xx2*0.2, yy2*0.8); glEnd(); glLineWidth(2.5); glColor4f( 0.8, 0.8, 0.1 , 1.0 ); glBegin( GL_LINE_STRIP ); primitiva 9 poligono pieno a c a b c d b e d e Attenzione: l'OpenGL non disegna sempre corret-tamente un poligono concavo (con rientranze)

ancora un poligono concavo, ma con un ordine diverso di disegno: glBegin( GL_POLYGON ); glVertex2f(xx2*0.2, yy2*0.2); glVertex2f(xx2*0.8, yy2*0.2); glVertex2f(xx2*0.8, yy2*0.8); glVertex2f(xx2*0.5, yy2*0.25); glVertex2f(xx2*0.2, yy2*0.8); glEnd(); .. glColor4f(0.8,0.8,0.1,1.0); glBegin( GL_LINE_STRIP ); a a b b d c d e e c ==>> i poligoni pieni sono sempre triangolarizzati, ma per un poligono concavo e' meglio che lo faccia l'utente!

oltre le dieci primitive grafiche viste l' OpenGL oltre le dieci primitive grafiche viste offre alcune altre primitive grafiche : BitMap = porzioni dello schermo = insiemi di pixel,

Introduzione alla Grafica Digitale tra le primitive grafiche in Open Gl vi sono ancora elementi di immagine definiti come porzioni dello schermo, sono insiemi di pixel, o BitMap, usati ad es. per copiare caratteri (di tipo bitmap) sull'immagine grafica procedura glBitMap(...) procedura glDrawPixels(...) e altre; 57

la figura a destra e' data da : ... glWindowPos3i( x1+dd, y1+dd, 0 ); // position without transformation by // modelview or projection and without clipping glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24, (char)('A'+co+ri) ); e glColor4f( 1.0, 1.0, 1.0, 1.0 ); //MUSt call before glRasterPos glRasterPos3i( 100, 100, 0 ); glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24, '@' ); (es. OGL8_STRING)

l'area dove disegno, il "foglio di disegno" non coincide con lo schermo

Introduzione alla Grafica Digitale Posizionare un punto: lo schermo corrisponde alla memoria grafica, ma (come noto) si ricorda che la dimensione massima dell'immagine non necessariamente e' uguale alla dimensione massima del reticolo di pixel che lo schermo riesce a mostrare posso avere un'immagine piu' piccola che viene mostrata in una finestra (parte) dello schermo, come posso avere un'immagine piu' grande che viene mostrata solo in parte sullo schermo (oppure intera, ma opportunamente rimpiccolita o scalata) vedremo negli esempi concreti ... schermo 60 schermo

la memoria grafica o frame buffer corrisponde al raster dell'immagine finale, e quindi ogni pixel dell'immagine finale ha una posizione in memoria data dalle sue coordinate schermo gli esempi seguenti saranno ripresi in seguito, qui solo per dire che vi sono molte primitive ...

GLubyte bitShape[20] = { 0x1C,0x00, 0x1c, ... }; // store a bit pattern in 8-bit blocks, 10 rows, 16 bit per row glPixelStorei(GL_UNPACK_ALIGNEMENT,1); // set pixel storage mode glRasterPos2i(30,40); // raster position in world coordinates !! glBitmap( 16, 10, 0.0, 0.0, 20.0, 15.0, bitShape); // width,height, x0, y0, x0offset, y0offset altre funzioni: glDrawPixels(width,height,dataFormat,dataType,pixMap); eg: glDrawPixels(128,128, GL_RGB, GL_UINSIGNED_BYTE, colorShape); ... riprenderemo ...

cenno: un bitmap (un reticolo binario) puo' essere definito con apposite procedure, a cui per ora solo accenniamo: glBitmap( width, height, x0, y0, x0offset, y0offset, bitShapeArray); dove il bitShapeArray e' una tabella di bit compressi, come ad es: GLubyte bitShapeArray[20]={0x1c,0x00,0x1c,..0xff,..0x00}; si deve dare la posizione prima della copia del bit-map, con lal proc glRasterPos*(x,y); dove *(..) sono gli stessi che si possono usare con glVertex*(..) glDrawPixels(width,height,dataFormat,dataType, pixMapArr) copia un array di pixel su schermo, ad es: glDrawPixels(128,128, GL_RGB, GL_UNSIGNED_BYTE, MyColShap); .. glReadPixels(...) per estrarre un array di pixel da un buffer, glCopyPixels(...) per copiare una zona del buffer in un'altra..

primitive OpenGL standard fine parte primitive OpenGL standard EGD11_stnd_prmtv.ppt