Użytkownik "Mateusz Ludwin" <n...@s...org> napisał w wiadomości
news:gpaqfn$jnr$1@inews.gazeta.pl...
> Stefan Nawrocki wrote:
> > Wydaje mi się, że różne pojęcia, które w wątku się pojawiają nie do
> > końca są dobrze interpretowane.
> > Pierwsza sprawa - to liczba bitów przypadająca na składową koloru - czy
> > to jest 8, czy 12 - co to tak naprawdę zmienia?
> > Jeśli czerń odpowiada poziomowi 0, a biel poziomowi maksymalnemu
>
> W HDRI nie ma poziomu maksymalnego - to jest jedno z podstawowych założeń
> tego typu obrazów. Dodatkowe bity idą i w rozdzielczość i w zakres, bo
> odcienie opisuje się liczbami zmiennoprzecikowymi.

Ten fragment nie byl o HDR, ale o tym, że niektórzy sądzą, że zmiana liczby
bitów (jpg - 8, RAW - 12) zmienia w istotny sposób zakres tonalny. Tak nie
jest.


> > I druga sprawa - tak sklejona skala szarości podzielona przez odpowiedni
> > współczynnik da się zobrazować na monitorze 8-bitowym, a straty będą
> > polegały na utracie liczby dostępnych poziomów.
> > Tak wygląda most na tym etapie:
> > http://www.3n.com.pl/Nikon/most_1.jpg
>
> Nieprawda, to nie jest obraz powstały przez odrzucenie nadmiarowych
> bitów HDRI. Te cienie są powyciągane przez tonemapping.

No cóż - nie lubię jak zarzuca mi się kłamstwo, więc musze się bronić :-).
Wiesz - ja od 20 lat _tworzę_ oprogramowanie graficzne (www.3n.com.pl) i
wiem jakim algorytmem przetwarzam swoje obrazy. Zwłaszcza, kiedy robię to za
pomocą programów swojego autorstwa :-).

Niżej wklejam kod, który przetwarza trzy pliki:

-------------------------------------------------

#include <windows.h>
inline long ScanBytes(int pixWidth, int bitsPixel) {
return (((long)pixWidth*bitsPixel+31)>>5 /*/32*/)<<2;;
}

BYTE* LoadBitmap(char* filename){
BITMAPFILEHEADER bfh;
HANDLE h=CreateFile(filename, GENERIC_READ, 0, 0, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, 0);
DWORD r;
ReadFile(h, &bfh, sizeof(bfh), &r, 0);
BYTE* data=new BYTE[bfh.bfSize];
ReadFile(h, data, bfh.bfSize, &r, 0);
CloseHandle(h);
return data;
}
void SaveBitmap(BYTE* f, char* filename){
BITMAPINFOHEADER* bih=(BITMAPINFOHEADER*)f;
int w=bih->biWidth;
int h=bih->biHeight;
int bpl=ScanBytes(w, 24);
BITMAPFILEHEADER bfh;
bfh.bfType='BM';
bfh.bfSize=sizeof(BITMAPINFOHEADER)+bpl;
bfh.bfReserved1=0;
bfh.bfReserved2=0;
bfh.bfOffBits=sizeof(BITMAPINFOHEADER)+sizeof(BITMAP
FILEHEADER);

DWORD wr;
HANDLE handle=CreateFile(filename, GENERIC_WRITE, 0, 0, OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL, 0);
WriteFile(handle, &bfh, sizeof(bfh), &wr, 0);
WriteFile(handle, f, bpl*h, &wr, 0);
CloseHandle(handle);
}
void ShowBitmap(BYTE* d){
BITMAPINFOHEADER* bih=(BITMAPINFOHEADER*)d;
HDC hdc=GetDC(0);
StretchDIBits(hdc, 0, 0, bih->biWidth, bih->biHeight,
0, 0, bih->biWidth, bih->biHeight,
(BITMAPINFOHEADER*)(d+sizeof(BITMAPINFOHEADER)),
(BITMAPINFO*)bih, DIB_RGB_COLORS, SRCCOPY);
ReleaseDC(0, hdc);
}
BYTE* suma(BYTE* f1, BYTE* f2, BYTE* f3){
BYTE* d1=(BYTE*)(f1+sizeof(BITMAPINFOHEADER));
BYTE* d2=(BYTE*)(f2+sizeof(BITMAPINFOHEADER));
BYTE* d3=(BYTE*)(f3+sizeof(BITMAPINFOHEADER));
BITMAPINFOHEADER* bih=(BITMAPINFOHEADER*)f1;
int w=bih->biWidth;
int h=bih->biHeight;
int bpl=ScanBytes(w, 24);
BYTE* su=new BYTE[bpl*h]+sizeof(BITMAPINFOHEADER);
BYTE* s=su+sizeof(BITMAPINFOHEADER);
MoveMemory(su, f2, sizeof(BITMAPINFOHEADER)+bpl*h);
float l1=150;
float l2=250;
double c1=0.9; <---------- Tu jest współczynnik, o którym piszę niżej
double c2=1-c1;
for(int y=0; y<h; y++){
for(int x=0; x<w; x++){
float gray=(d2[x*3+bpl*y]+d2[x*3+bpl*y+1]+d2[x*3+bpl*y+2])
/3.0;
float r1, g1, b1;
float r2, g2, b2;
{
double v2=(gray-l1)/l1;
double v1=1-v2;
r1=v1*d3[x*3+bpl*y+2]+v2*d2[x*3+bpl*y+2];
g1=v1*d3[x*3+bpl*y+1]+v2*d2[x*3+bpl*y+1];
b1=v1*d3[x*3+bpl*y]+v2*d2[x*3+bpl*y];
}
{
double v2=(gray-l2)/l2;
double v1=1-v2;
r2=v1*d1[x*3+bpl*y+2]+v2*d2[x*3+bpl*y+2];
g2=v1*d1[x*3+bpl*y+1]+v2*d2[x*3+bpl*y+1];
b2=v1*d1[x*3+bpl*y]+v2*d2[x*3+bpl*y];
}
s[x*3+bpl*y]=max(0.0, min(255.0,c1*b1+c2*b2));
s[x*3+bpl*y+1]=max(0.0, min(255.0,c1*g1+c2*g2));
s[x*3+bpl*y+2]=max(0.0, min(255.0,c1*r1+c2*r2));
}
}
return su;
}
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int){
BYTE* f1=LoadBitmap("D:\\testy\\1.bmp");
BYTE* f2=LoadBitmap("D:\\testy\\2.bmp");
BYTE* f3=LoadBitmap("D:\\testy\\3.bmp");
// ShowBitmap(f1);
// ShowBitmap(f2);
// ShowBitmap(f3);
MessageBox(0,"","",MB_OK);
BYTE* s=suma(f1, f2, f3);
ShowBitmap(s);
SaveBitmap(s, "D:\\testy\\wynik.bmp");
return 0;
}
-------------------------------

Jeśli masz kompilator C - to sam zobacz jak to działa :-).
Strzałką zaznaczyłem współczynnik "jasności". Dla wartości 0.9 - wynik jest
taki:
http://www.3n.com.pl/Nikon/wynik_09.jpg
Jak widzisz (jeśli znasz język C, jeśli nie - to wierz mi na słowo) - w
algorytmie nie ma żadnego mapowania tonów, tylko opercje na poziomach (sumy,
średnie, itp.).


Pozdrawiam
Stefan Nawrocki