zna ktoś jakieś sumowanie do składniowych proste obliczenie aplha liczenia
np:
red=r1 i r2
green=g1 i g2
blue=b1 i b2
konkretnie jakies obliczenia wzorcowe, wazne bo zmienne mają być od zera do jednego czyli float 0<->1 bo predzej zrobiłem
float r=red/256; i żeby można było podać wartość alpa testowanie od zera do jednego
kolor_out=kolor_docelowy obliczanie od tła , widzialność ustalania od alphy
- Rejestracja:ponad rok
- Ostatnio:około 18 godzin
- Postów:376
0
edytowany 3x, ostatnio: wilkwielki
- Rejestracja:ponad rok
- Ostatnio:około 18 godzin
- Postów:376
1
mam tak
r_out=alphatest*r1 + (1 - alphatest)r2;
g_out=alphatestg1 + (1 - alphatest)g2;
b_out=alphatestb1 + (1 - alphatest)*b2;
na alphatest=1 obrazek widac w orginale a na zero obrazka nie widać a tło w tym miejscu gdzie stoi obrazek jest czarno biały , to coś źle
- Rejestracja:ponad rok
- Ostatnio:około 18 godzin
- Postów:376
0
juz mam literówka zapomniałem podac indexy właściwie , to obliczenie działa właściwie dzięki Ci obscurity
- Rejestracja:ponad rok
- Ostatnio:około 18 godzin
- Postów:376
0
a jak jest kolorW=kolorAkolorB to czy mozna jakos to rozjasnic ale bez dopiski kolorW=kolorAkolorB +S zeby nie przepalało koloru tylko własciwie rozjasnało
1
Chat GPT:
Tak, można rozjaśnić kolor wynikowy (kolorW = kolorA ⊕ kolorB) bez ryzyka przepalenia (przekroczenia wartości maksymalnej), stosując mieszanie kolorów z korekcją gamma lub normalizacją wartości. Oto kilka podejść:
1. Metoda Liniowa (Bez Przepalania)
Jeśli chcesz rozjaśnić kolorW, ale nie przekroczyć wartości maksymalnej (np. 255 dla 8-bitowych kolorów), możesz zastosować interpolację liniową:
// kolorW = kolorA ⊕ kolorB
kolorW.r = std::min(255, kolorW.r + (255 - kolorW.r) / 2);
kolorW.g = std::min(255, kolorW.g + (255 - kolorW.g) / 2);
kolorW.b = std::min(255, kolorW.b + (255 - kolorW.b) / 2);
Działanie:
Jeśli kolor jest ciemny, zwiększy się bardziej.
Jeśli kolor jest jasny, zwiększy się mniej (bez przepalenia).
Przykładowo, jeśli kolorW.r = 100, to:
100 + (255 - 100) / 2 = 177
230 + (255 - 230) / 2 = 242
2. Metoda Gamma (Naturalne Rozjaśnienie)
Światło nie jest odbierane liniowo przez ludzkie oko. Można użyć korekcji gamma:
float gamma = 2.2; // Typowa wartość gamma
float invGamma = 1.0 / gamma;
// Konwersja do liniowej przestrzeni barw
float r = pow(kolorW.r / 255.0, gamma);
float g = pow(kolorW.g / 255.0, gamma);
float b = pow(kolorW.b / 255.0, gamma);
// Rozjaśnienie (np. 20% więcej)
r *= 1.2;
g *= 1.2;
b *= 1.2;
// Ograniczenie do 1.0 i konwersja powrotna
kolorW.r = std::min(1.0f, pow(std::min(1.0f, r), invGamma));
kolorW.g = std::min(1.0f, pow(std::min(1.0f, g), invGamma));
kolorW.b = std::min(1.0f, pow(std::min(1.0f, b), invGamma));
Działanie:
Przekształca kolor do liniowej przestrzeni barw.
Rozjaśnia go proporcjonalnie.
Przekształca z powrotem do przestrzeni gamma (zapobiega przepaleniu).
Efekt: Bardziej naturalne rozjaśnienie niż dodawanie wartości.
3. Metoda HSV (Zwiększenie Jasności)
Zamiast manipulować kanałami RGB, można konwertować do przestrzeni HSV, zwiększyć V (jasność) i przekonwertować z powrotem.
struct HSV { float h, s, v; };
HSV RGBtoHSV(kolorW);
HSV hsv = RGBtoHSV(kolorW);
// Rozjaśniamy o 20%, ale max to 1.0
hsv.v = std::min(1.0f, hsv.v * 1.2);
kolorW = HSVtoRGB(hsv);
Efekt: Kolor zachowa swoją barwę i nasycenie, ale będzie jaśniejszy.
Podsumowanie
Najlepsze podejście zależy od efektu, jaki chcesz osiągnąć!
edytowany 1x, ostatnio: tBane
- Rejestracja:ponad rok
- Ostatnio:około 18 godzin
- Postów:376
0
wielkie dziękuje za tak wielką pomoc , dzięki 
- Rejestracja:ponad rok
- Ostatnio:około 18 godzin
- Postów:376
0
aj jak jest np metoda liniowa tam są wartosci podane od 0 do 256 a u mnie kolorA i kolorB są z zakresu od zera do jednego to czy to będzie działać właściwie? co oznacza min i pow ?
edytowany 1x, ostatnio: wilkwielki
0
@wilkwielki: to podziel wartości z zakresu 0-255 przez 255...
min zwraca mniejszą wartość z podanych a pow(power) to potęgowanie
// edit
już skorygowałem wartości w poprzednim poście. Myślę, że powinno działać
edytowany 3x, ostatnio: tBane