Upload
regis
View
40
Download
0
Embed Size (px)
DESCRIPTION
Počítače a programování 2. Tutori ál 1 8.2.2014 Jiří Šebesta. Kompletní informace naleznete na. http://www.urel.feec.vutbr.cz/~sebestaj/KPC 2E. T ÉMA. Organizace předmětu Preprocesor Funkce main() s argumenty Souborový vstup a výstup. Organizace předmětu (1/3). Rozvrh předmětu. - PowerPoint PPT Presentation
Citation preview
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.
Úvod a klasifikace (2/4)
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í
Úvod a klasifikace (3/4)
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
Úvod a klasifikace (4/4)
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: KPC2E_Ex88.c
Funkce main() s argumentyFunkce main() s argumenty (5/6) (5/6)
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);
Funkce main() s argumentyFunkce main() s argumenty (6/6) (6/6)
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;}
Příklad: KPC2E_Ex89.c
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
Souborový vstup a výstup Souborový vstup a výstup (3/1(3/133))
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
Souborový vstup a výstup Souborový vstup a výstup (4/1(4/133))
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
Souborový vstup a výstup Souborový vstup a výstup (5/1(5/133))
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
Souborový vstup a výstup Souborový vstup a výstup (6/1(6/133))
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
Souborový vstup a výstup Souborový vstup a výstup (7/1(7/133))
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
Souborový vstup a výstup Souborový vstup a výstup (8/1(8/133))
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)
Souborový vstup a výstup Souborový vstup a výstup (9/1(9/133))
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;}
Příklad: KPC2E_Ex90.c
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;}
Příklad: KPC2E_Ex91.c
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):
PrograProgramování WAV (2/8)mování WAV (2/8)
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
PrograProgramování WAV (3/8)mování WAV (3/8)
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
PrograProgramování WAV (mování WAV (55/8)/8)
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
PrograProgramování WAV (mování WAV (66/8)/8)
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: KPC2E_Ex92.c
PrograProgramování WAV (mování WAV (77/8)/8)
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.
PrograProgramování WAV (8/8)mování WAV (8/8)
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)
PrograProgramování BMP (2/1mování BMP (2/155))
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.
PrograProgramování BMP (3/1mování BMP (3/155))
Název položkyDélka
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))
Název položkyDélka
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))
Název položkyDélka
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.
PrograProgramování BMP mování BMP ((77/1/155))
Název položkyDélka
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í.
PrograProgramování BMP mování BMP ((88/1/155))
Název položkyDélka
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
PrograProgramování BMP (mování BMP (1010/1/155))
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;
PrograProgramování BMP mování BMP ((1111/1/155))
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);
PrograProgramování BMP (mování BMP (1212/1/155))
//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;}
Příklad: KPC2E_Ex94.c
Téma následujícího tutoriálu
– Úvod do objektově orientovaného programování a C++
DĚKUJI ZA POZORNOST