Počítače a programování 2

OSNOVA:

a) Úvod a klasifikace

b) Funkce main() s argumenty

c) Souborový vstup a výstup

d) Programování WAV

e) Programování BMP

Jiří ŠebestaJiří ŠebestaÚstav radioelektroniky, FEKT VUT v BrněÚstav radioelektroniky, FEKT VUT v Brně

Počítače a programování 2 pro obor ESTKPC2E

TUTORIÁL 1

Web předmětu, kontakty

• http://www.urel.feec.vutbr.cz/~sebestaj/KPC2E/index.htm

• odkaz v eLearningu (kurz KPC2E 14/15L)

• vyučující– Doc. Ing. Jiří Šebesta, Ph.D., [email protected]

(garant předmětu, tutoriály, cvičení)

• konzultační hodiny na Portálu VUT

Úvod a klasifikace (1/4)

Tutoriály

7. 2. 2015Organizace výuky, funkce main () s argumenty, souborový vstup a výstup, práce s WAV a BMP.

21. 2. 2015

Úvod do objektového programování, C++.

7. 3. 2015 C++ pro Windows.

4. 4. 2015Úvod do Matlabu, reprezentace vektorů a matic, 2D a 3D grafy.

18. 4. 2015

Práce se soubory v Matlabu, funkce v Matlabu, model komunikačního systému.


21. 3. 2015

Formulářová aplikace ve Windows (10 b.).

2. 5. 2015

Matlab, model komunikačního systému (5 b.).

Počítačová cvičení


Klasifikace a bodové hodnocení

• Předmět je ukončen klasifikovaným zápočtem. Udělení zápočtu je přitom dáno následujícími podmínkami: – získání nejméně 50 bodů– odevzdání a obhájení zápočtového projektu v Matlabu

• Maximální bodové hodnocení jednotlivých forem výuky (celkem max. 100 bodů):– max. 15 bodů za hodnocení počítačových cvičení

během semestru (10 + 5 bodů)– max. 25 bodů za domácí úlohy (5 x 5 bodů)– max. 20 bodů za zápočtový test na konci semestru– max. 40 bodů za zápočtový projekt v Matlabu


Funkce main() s argumentyFunkce main() s argumenty ( (11/6)/6)

Definicí argumentů (parametrů) u funkce main() můžeme definovat chování programu při spuštění.

Program s parametry se spouští z příkazové řádky názvem programu (projektu) následovaný parametry oddělené mezerou, např.

Muj_program 10 input.txt output.txt -x

Hlavička funkce main() s argumenty

int main(int argc, char *argv[ ])

- proměnné argc a argv jsou lokální proměnné funkce main(), (mohou mít i libovolné jiné názvy, typ musí být zachován)

- argc udává počet zadaných parametrů při spuštění programu- argv je pole řetězců s jednotlivými zadanými argumenty

Funkce main() s argumentyFunkce main() s argumenty (2/6) (2/6)

Po spuštění programu je do proměnné argc uložena hodnota odpovídající počtu řetězců uvedených na příkazovém řádku v okamžiku spuštění programu. Tento počet zahrnuje i vlastní název programu.

Proměnná argv je dvourozměrné pole typu char (jednorozměrné pole řetězců). Do tohoto pole řetězců jsou uloženy všechny řetězce uvedené na příkazovém řádku, do argv[0] je tedy uložen název programu. Počet řetězců v poli odpovídá hodnotě uložen v proměnné argc. Délka jednotlivých řádků pole argv odpovídá délce vložených řetězců.

Pokud je potřeba jako vstup programu číselná hodnota, musí se v těle funkce main() provést konverze na požadovaný číselný formát.

Funkce main() s argumentyFunkce main() s argumenty ((33/6)/6)

Příklad programu, který vypíše počet argumentů a všechny řetězce argumentů

int main(int argc, char *argv[]){ int n;

printf("Number of arguments: %d\n\n", argc); printf("List of arguments:\n"); for(n = 0; n < argc; n++) printf("argv[%d] = %s\n", n, argv[n]); return 0;}

Příklad: KPC2E_Ex87.c

Funkce main() s argumentyFunkce main() s argumenty ( (44/6)/6)

Příklad programu, který vypíše všechny násobky vstupního argumentu do 1000 včetně

int main(int argc, char *argv[]){ int n, m;

n = atoi(argv[1]); m = n; while(n <= 1000) { printf("%3d\n", n); n += m; } return 0;}



Příklad kódovacího programu pro textové soubory, který prohodí nižší a vyšší čtveřici bytu znaku – šifra je symetrická

int main(int argc, char *argv[]){ char c, a; FILE *ptrfi; // spec. type pointer to input file FILE *ptrfo; // spec. type pointer to output file ptrfi = fopen(argv[1],"r"); // file for reading ptrfo = fopen(argv[2],"w"); // a new file for

writing

if(ptrfi!=NULL && ptrfo!=NULL) // if both files are open

{ c = fgetc(ptrfi);


while(c != EOF) { a = c; c = c & 0x0F; c = c << 4; c = c & 0xF0; a = a & 0xF0; a = a >> 4; a = a & 0x0F; c = a | c; fputc(c, ptrfo); c = fgetc(ptrfi); } fclose(ptrfi); fclose(ptrfo); } return 0;}


Souborový vstup a výstup (1/1Souborový vstup a výstup (1/133))

ANSI-C používá tzv. bufferovaný přístup k souborům pomocí proudu (stream) nebo-li ukazatele na strukturu typu FILE (definice v knihovně stdio.h)

V ANSI-C není rozdíl mezi souborem a zařízením (portem) – přistupuje se stejně

Binární vs. textový soubor

Binární soubor

- překladač neprovádí žádnou úpravu čtených a zapisovaných dat

- uspořádání dat v souboru je nezávislé a specifické pro dané využití

Souborový vstup a výstup Souborový vstup a výstup (2/1(2/133))

Textový soubor

- uspořádán po řádcích, každý zakončen znakem \n

- v některých OS se před \n vkládá \r (úpravu zajišťují funkce ze standardní knihovny stdio.h.

- lze zobrazit libovolným editorem

- přenositelnost binárních souborů mezi různými systémy může být omezena rozdílnou délkou základních typů v těchto různých systémech – nutno vždy vhodně ošetřit


Otevření souboru:

FILE *fopen(char *file_name, char *mode)

- mode reprezentuje řetězec pro režim otevření souboru (viz BPC1E), pro binární soubory je doplněn do řetězce znak b, např.:

"rb" = otevření binárního souboru pro čtení

"wb" = otevření prázdného binárního souboru pro zápis

"ab" = otevření binárního souboru pro zápis na konec stávajícího souboru


Rozšířené režimy:

"r+" = otevření existujícího souboru pro čtení a zápis, pokud soubor neexistuje vrací se NULL

"w+" = otevření nového prázdného souboru pro zápis i čtení, pokud soubor existuje, je původní obsah smazán

"a+" = otevření existujícího souboru pro zápis na konec a čtení kdekoli


Souhrnné vlastnosti režimů otevření souborů

Charakteristika/požadavekRežim otevření souboru

r r+ w w+ a a+

soubor musí existovat

existující soubor je smazán

existující soubor bude rozšiřován

neexistující soubor bude vytvořen

data lze číst odkudkoli

data lze zapisovat kamkoli

data lze zapisovat jen na konec


Uzavření souboru:

int *fclose(FILE *fptr)

- v případě správného uzavření se vrací 0

- v případě neúspěšného uzavření se vrací EOF

- podle ANSI-C se při správném ukončení programu otevřené soubory automaticky uzavřou, v případě havárie programu však není jednoznačně definováno, co se s otevřeným souborem stane


Formátované vstupy/výstupy:

int fprintf(FILE *fptr, const char *form, …)

= zápis řetězce form do souboru fptr, pokud je obsahem řetězce hodnota číselné proměnné, zapisuje se jeho vyjádření řetězcem

int fscanf(FILE *fptr, const char *form, …)

= čtení řetězce ze souboru fptr a uložení do řetězce form


Neformátované vstupy/výstupy:

int fputc(int c, FILE *fptr)

= zápis znaku c do souboru fptr

int fgetc(FILE *fptr)

= čtení znaku ze souboru fptr jako návratová hodnota

Možno použít i makra (význam stejný, jen rychlejší, ale může být větší program):

int putc(int c, FILE *fptr)

int getc(FILE *fptr)


Příklad: Kopírování binárního souboru in.bin do out.bin po bytech

int main(){ FILE *frptr, *fwptr; int ch;

frptr = fopen("in.bin", "rb"); fwptr = fopen("out.bin", "wb"); while((ch = fgetc(frptr)) != EOF) fputc(ch, fwptr); fclose(frptr); fclose(fwptr); return 0;}


Souborový vstup a výstup Souborový vstup a výstup ((1010/1/133))

Čtení/zápis celého řádku najednou (jen pro textové soubory):

char *fgets(char *str, int max, FILE *fptr)

= přečte celý řádek v textovém souboru fptr a uloží jej jako řetězec do str a to do maximálního počtu znaku max, pokud je řádek v souboru delší než max, zbytek řádku může být přečten následujícím čtením, vrací ukazatel na řetězec str, v případě dočtení posledního řádku souboru vrací NULL, do řetězce jsou ukládány i znaky \n.

int fputs(char *str, FILE *fptr)

= zápis řádku z řetězce str do souboru fptr

Souborový vstup a výstup Souborový vstup a výstup ((1111/1/133))

Příklad: Kopírování textového souboru in.txt do out.txt po řádcích #define LEN_OF_ROW 10int main(){ FILE *frptr, *fwptr; char txt[LEN_OF_ROW]; frptr = fopen("in.txt", "r"); fwptr = fopen("out.txt", "w"); while(fgets(txt, LEN_OF_ROW, frptr) != NULL) fputs(txt, fwptr); fclose(frptr); fclose(fwptr); return 0;}


Souborový vstup a výstup Souborový vstup a výstup (1(122/1/133))

Čtení/zápis celého bloku najednou (pro binární soubory):

size_t fread(void *ptr, size_t size, size_t cnt, FILE *fptr)

= přečte celý blok položek o velikosti size v souboru fptr o celkovém počtu cnt a uloží jej jako pole elementů do pole v paměti referencovaného ukazatelem ptr, vrací se počet skutečně načtených položek

Souborový vstup a výstup Souborový vstup a výstup (1(133/1/133))

size_t fwrite(const void *ptr, size_t size, size_t cnt, FILE *fptr)

= uloží celý blok položek definovaných jako pole elementů v paměti referencovaného ukazatelem ptr o velikosti size do souboru fptr o celkovém počtu cnt, vrací se počet skutečně úspěšně uložených položek

PrograProgramování WAV (1/8)mování WAV (1/8)

Soubor typu WAV – bezkompresní audio

Struktura souboru WAV

(podmnožina RIFF):


Příklad: Vygenerujte soubor typu WAV, který bude obsahovat jeden tón dané frekvence, amplitudy, doby trvání a jména cílového WAV souboru (argumenty při spouštění programu)

#define TPI 6.283int fwrite_int(int val, char len, FILE *p){ char byte; while (len-- > 0) { byte = val & 0xFF; fwrite(&byte, 1, 1, p); val >>= 8; } return 0;}

Pomocná funkce pro zápis různě dlouhých dat hlavičky do WAV souboru jako little endian


int main(int argc, char *argv[]){ double ph, deltaph, tdur, ampl, freq; int numsa, srate; unsigned char sig; FILE *ptrf;

if(argc == 5) { srate = 8000; // fixed sample rate 8 kHz freq = atof(argv[1]); // tone freq - 1. argument

in Hz ampl = atof(argv[2]); // tone amplitude

- 2. argument tdur = atof(argv[3]); // tone duration

- 3. argument in s

PrograProgramování WAV (mování WAV (44/8)/8)

numsa = tdur*srate; // overall number of samples ph = 0; // initial phase 0 rad deltaph = TPI * freq /srate; // delta phase ptrf = fopen(argv[4], "wb");

fwrite("RIFF", 4, 1, ptrf); // chunk_id RIFF fwrite_int(36 + numsa, 4, ptrf); // chunk_size fwrite("WAVE", 4, 1, ptrf); // spec. RIFF form for WAV fwrite("fmt ", 4, 1, ptrf); // subchunk1id – format fwrite_int(16, 4, ptrf); // subchunk1size 16 for

PCM fwrite_int(1, 2, ptrf); // audio_format,

1 = PCM fwrite_int(1, 2, ptrf); // channels, 1 = mono


fwrite_int(srate, 4, ptrf); // sample rate

fwrite_int(srate * 1 * 8 /8, 4, ptrf); // byte rate

fwrite_int(1 * 8/8, 2, ptrf); // block align

fwrite_int(8, 2, ptrf); // bits per sample, 8 bits

fwrite("data", 4, 1, ptrf); // subchunk2id - data

fwrite_int(numsa * 1 * 8 / 8, 4, ptrf); // subchunk2 size


while(numsa-- > 0) { sig = 128*(ampl*sin(ph)+1); fwrite(&sig, 1, 1, ptrf); ph += deltaph; } fclose(ptrf); } else printf("Wrong number of arguments!!!!\n"); return 0;}



Příklad – pro tréning: Vygenerujte soubor typu WAV, který bude měnit tón od zadané frekvence do zadané frekvence, s danou amplitudou, dobou trvání a jménem cílového WAV souboru (argumenty při spouštění programu).

Kdo pošle řešení s domácí úlohou bude mít v záloze +3 body.

Příklad: KPC2E_Ex93.c – bude zveřejněn 16.2.


1209 Hz 1336 Hz 1477 Hz 1633 Hz

697 Hz 1 2 3 A

770 Hz 4 5 6 B

852 Hz 7 8 9 C

941 Hz * 0 # D

Příklad – domácí úloha: Sestavte program, který vygeneruje soubor typu WAV, který bude obsahovat DTMF signální volbu podle zadaného kódu. Kód a cílový soubor jsou argumenty při spouštění programu. V programu proveďte rovněž korekci možných znaků DTMF kód, nepovolené znaky vylučte. Jeden dvojtón trvá 50 ms následuje mezera 50 ms.

PrograProgramování BMP (1/1mování BMP (1/155))

Soubor typu BMP – pixelový RGB obrázek

Každý korektní soubor typu BMP obsahuje několik datových struktur definovaných WinAPI:

Název struktury Význam

BITMAPFILEHEADER hlavička BMP souboru

BITMAPINFOHEADER informační hlavička o obrázku

RGBQUAD[] tabulka barev (barvová

paleta)

BITSpole bitů obsahujících vlastní

rastrová data (pixely)


Hlavička souboru typu BMP, tj. datová struktura BITMAPFILEHEADER, má délku čtrnácti bytů a obsahuje údaje o typu, velikosti a celkovém uspořádání dat v souboru.

Název položkyDélka

položkyVýznam

bfType 2 bytyIdentifikátor formátu BMP. Aktuální verze formátu BMP zde obsahuje ASCII kód znaků "BM", tj. 0×42 a 0×4d hexadecimálně.

bfSize 4 bytyCelková velikost souboru s obrazovými údaji. Některé aplikace tuto položku ignorují a dosazují zde nulu.

bfReserved1 2 bytyTento údaj je rezervovaný pro pozdější použití. V současné verzi formátu BMP zde musí být uložena nulová hodnota.



položkyVýznam

bfReserved2 2 bytyI tento údaj je rezervovaný pro pozdější použití. V současné verzi formátu BMP zde musí být uložena nulová hodnota.

bfOffBits 4 bytyPosun struktury BITMAPFILEHEADER od začátku vlastních obrazových dat.

PrograProgramování BMP mování BMP (4/1(4/155))

Datová struktura BITMAPINFOHEADER obsahuje základní metainformace o rastrovém obraze. Mezi tyto informace patří především jeho rozměry, tj. výška a šířka, dále pak identifikace použité komprimační metody a specifikace formátu rastrových dat. Celková velikost této struktury je vždy rovna 40 bytů.

Název položky

Délka položky

Význam

biSize 4 bytyTato položka specifikuje celkovou velikost datové struktury BITMAPINFOHEADER

biWidth 4 bytyTato položka udává šířku obrazu zadávanou v pixelech

biHeight 4 bytyTato položka udává výšku obrazu zadávanou taktéž v pixelech

PrograProgramování BMP mování BMP (5/1(5/155))


položkyVýznam

biPlanes 2 byty

V této položce je zadaný počet bitových rovin pro výstupní zařízení. V BMP, jakožto formátu nezávislém na zařízení, je zde vždy hodnota 1. Položka existuje z historických důvodů.

biBitCount 2 byty

V této položce je specifikovaný celkový počet bitů na pixel. Podle počtu barev zde mohou být hodnoty 1, 4, 8 nebo 24 (to odpovídá postupně 2, 16, 256ti barvám popř. plnobarevnému režimu).

biCompression 4 byty

Udává typ komprimační metody obrazových dat. Musí být nastavené na jednu z hodnot:0 (BI_RGB), 1 (BI_RLE8) nebo 2 (BI_RLE4).

PrograProgramování BMP mování BMP ((66/1/155))


položkyVýznam

biSizeImage 4 byty

Tato položka udává velikost obrazu v bytech. Pokud je bitmapa nekomprimovaná, může zde být nulová hodnota, protože ji je možno vypočítat z rozměrů obrázků a počtu bitů na pixel.

biXPelsPerMeter 4 byty

Udává horizontální rozlišení výstupního zařízení v pixelech na metr. Tato hodnota může být použita například pro výběr obrazu ze skupiny obrazů, který nejlépe odpovídá rozlišení daného výstupního zařízení. Většina aplikací však nemá potřebné informace o výstupním zařízení, a proto do této položky vkládá hodnotu 0.



položkyVýznam

biYPelsPerMeter 4 byty

Udává vertikální rozlišení výstupního zařízení v pixelech na metr. Opět, jako u předchozí položky, zde většina programů zapisuje hodnotu 0.

biClrUsed 4 byty

Udává celkový počet barev, které jsou použité v dané bitmapě. Jestliže je tato hodnota nastavena na nulu (což provádí většina aplikací), znamená to, že bitmapa používá maximální počet barev. Tento počet lze jednoduše zjistit z položky biBitCount. Nenulová hodnota může být použita například při optimalizacích zobrazování.



položkyVýznam

biClrImportant 4 byty

Udává počet barev, které jsou důležité pro vykreslení bitmapy. Pokud je tato hodnota nulová (téměř vždy), jsou všechny barvy důležité. Tento údaj je používán při zobrazování na zařízeních, které mají omezený počet současně zobrazitelných barev (například starší grafické karty se 16ti resp. 256ti barevnými režimy). Ovladač displeje může upravit systémovou paletu tak, aby zobrazil daný obrázek co nejvěrněji. Také je vhodné upravit paletu metodou seřazení jednotlivých barev podle důležitosti.

PrograProgramování BMP (mování BMP (99/1/155))

RGBQUAD[] obsahuje pole definující barevnou paletu pro omezený počet barev (jinak nemusí být definováno, pak se použije plnobarevná paleta, tj. 1,68 mil. barev ).

BITS obsahuje pole definující jednotlivé pixely, tak jak jdou za sebou, při kompresním RGB jsou to čísla jednotlivých barev, při nekompresním RGB obsahují úroveň složek R, G a B.

V knihovně windovs.h je definována struktura pro jeden pixel:

RGBTRIPLE s položkami pro jednotlivé barvy s rozsahem unsigned char (0x00 – 0xFF) rgbtRed, rgbtGreen, rgbtBlue


Příklad: Vygenerujte ze vstupního bezkompresního BMP obrázku, obrázek inverzní, obrázek stupňů šedi, obrázek jen s červenou složkou, jen se zelenou složkou, jen s modrou složkou.

#include <windows.h>#include <stdio.h>

int main(){ BITMAPFILEHEADER bmp_fh; //struct. BMP file header BITMAPINFOHEADER bmp_ih; //struct. BMP info header RGBTRIPLE bmp_rgb; //struct. triplet of one pixel unsigned char Red, Gre, Blu, Av; FILE *fRGB, *fRED, *fGRE, *fBLU, *fINV, *fBAW; size_t padd; int i, j;


fRGB = fopen("RGB.bmp", "rb"); //old BMP fRED = fopen("RED.bmp", "wb"); //new BMP red fGRE = fopen("GREEN.bmp", "wb"); //new BMP green fBLU = fopen("BLUE.bmp", "wb"); //new BMP blue fINV = fopen("INVERT.bmp", "wb");//new BMP inverted fBAW = fopen("BANDW.bmp", "wb"); //new BMP

black&white

//BITMAPFILEHEADER copy to new BMP files

fread(&bmp_fh, sizeof(bmp_fh), 1, fRGB); //old BMP fwrite(&bmp_fh, sizeof(bmp_fh), 1, fRED); fwrite(&bmp_fh, sizeof(bmp_fh), 1, fGRE); fwrite(&bmp_fh, sizeof(bmp_fh), 1, fBLU); fwrite(&bmp_fh, sizeof(bmp_fh), 1, fINV); fwrite(&bmp_fh, sizeof(bmp_fh), 1, fBAW);


//BITMAPFILEHEADER copy to new BPM files

fread(&bmp_ih, sizeof(bmp_ih), 1, fRGB); //old BMP fwrite(&bmp_ih, sizeof(bmp_ih), 1, fRED);

fwrite(&bmp_ih, sizeof(bmp_ih), 1, fGRE); fwrite(&bmp_ih, sizeof(bmp_ih), 1, fBLU); fwrite(&bmp_ih, sizeof(bmp_ih), 1, fINV); fwrite(&bmp_ih, sizeof(bmp_ih), 1, fBAW);

padd = 0; if((bmp_ih.biWidth * 3) % 4) // padding test padd = 4 - (bmp_ih.biWidth * 3) % 4;

PrograProgramování BMP mování BMP (1(133/1/155))

for(i = 0; i < bmp_ih.biHeight; i++) { for(j = 0; j < bmp_ih.biWidth; j++) { fread(&bmp_rgb, sizeof(bmp_rgb),1, fRGB); Red = bmp_rgb.rgbtRed; Gre = bmp_rgb.rgbtGreen; Blu = bmp_rgb.rgbtBlue;

bmp_rgb.rgbtRed = Red; bmp_rgb.rgbtGreen = 0x00; bmp_rgb.rgbtBlue = 0x00; fwrite(&bmp_rgb, sizeof(bmp_rgb), 1, fRED);

bmp_rgb.rgbtRed = 0x00; bmp_rgb.rgbtGreen = Gre; bmp_rgb.rgbtBlue = 0x00; fwrite(&bmp_rgb, sizeof(bmp_rgb), 1, fGRE);

PrograProgramování BMP (1mování BMP (144/1/155))

bmp_rgb.rgbtRed = 0x00; bmp_rgb.rgbtGreen = 0x00; bmp_rgb.rgbtBlue = Blu; fwrite(&bmp_rgb, sizeof(bmp_rgb), 1, fBLU);

bmp_rgb.rgbtRed = 0xFF - Red; bmp_rgb.rgbtGreen = 0xFF - Gre; bmp_rgb.rgbtBlue = 0xFF - Blu; fwrite(&bmp_rgb, sizeof(bmp_rgb), 1, fINV);

Av = (Red + Gre + Blu)/3; bmp_rgb.rgbtRed = Av; bmp_rgb.rgbtGreen = Av; bmp_rgb.rgbtBlue = Av; fwrite(&bmp_rgb, sizeof(bmp_rgb), 1, fBAW); }

PrograProgramování BMP mování BMP (1(155/1/155))

if(padd != 0) { fread(&bmp_rgb, padd, 1, fRGB); fwrite(&bmp_rgb, padd, 1, fRED); fwrite(&bmp_rgb, padd, 1, fGRE); fwrite(&bmp_rgb, padd, 1, fBLU); fwrite(&bmp_rgb, padd, 1, fINV); fwrite(&bmp_rgb, padd, 1, fBAW); } } fclose(fRGB); fclose(fRED); fclose(fGRE); fclose(fBLU); fclose(fINV); fclose(fBAW); return 0;}


Téma následujícího tutoriálu

– Úvod do objektově orientovaného programování a C++

DĚKUJI ZA POZORNOST

Date post:	13-Jan-2016
Category:	Documents
Upload:	regis
View:	40 times
Download:	0 times

Počítače a programování 2

Documents