Ein Bild mit einer Farbe multiplizieren?

[Corpsman]

Hossa Cyberstorm,

Ich Studiere Informatik, im 7. Semester mit Vetierfung VIS, und da schreibt jeder mal nen Raytracer

Im 1. Fall kommen Immer werte zwischen 0..1 raus
Du liest die RGB werte aus, dann Skalleirst du sie auf 0..1 ( Also durch 255 Teilen ) dann die Berechnung und danach wieder HochsKalieren => ex kommt wieder ein Wert zwischen 0..1 das ist mit ein rund warum OgenGL alles auf 0..1 abbilden kann.

Bei Meinem Raytracer genau wie bei anderen Kann man ,wenn dann doch Größere Werte Auftreten die Mittels Scaling oder clamping weiterverarbeiten.

Dein Faktor ist auch ganz einfach.

Stell dir For du willst dein Bild Grün Färben ( Grün = (0,255,0) )
dann willst du 50% Grün haben das ergibt dann (Farbe alt = ( x,y,z))

Delphi-Quellcode:

Prozent := 50 / 100;
Farbe_neu :=( max(0,min(255,round(0*Prozent +x))),max(0,min(255,round(255*Prozent +y))),max(0,min(255,round(0*Prozent +z))));

Wenns noch genauer sein mus , must bis zum We warten, habe einen Hauptseminarvortrag der mich aufhält.

[omata]

Hallo Cyberstorm,

da ich mich gerade mit einer 3D-Lasertriangulation beschäftigt habe und dort Bildverarbeitung eine entscheidene Rolle spielt,
habe ich meinen Verarbeitungsquellcode mal an dein Problem angespasst.

Vielleicht hilft dir das ja weiter.

Gruss
Thorsten

[Cyberstorm]

danke euch beiden!

werde ich gleich mal ausprobieren...

[Cyberstorm]

hmm also ersteinmal machen beide funktionen von euch (omata & corpsman) das selbe aber noch nicht ganz, was ich will :-).
zumindest wird bei 100% nicht komplett überblendet aber das ergebnis ist nicht wie ich will (siehe bilder).

habe dein programm mal gekürzt und das einlesen der komponente überlassen:
die scroll boxen haben als onchange ereignis FormCreate...

Delphi-Quellcode:

procedure TfrmMain.FormCreate(Sender: TObject);
begin
  Self.DoubleBuffered:=true;
  Shape.Brush.Color:=RGB(SbRot.Position, SbGruen.Position, SbBlau.Position);
  Image.Picture.LoadFromFile('ori.bmp');
  Calculate;;
end;

procedure TfrmMain.Calculate;
var
  Prozent: Real;
  x, y: Integer;
  P: PRGB;
begin
  Prozent:=SbProzent.Position / 100;
   for y:=0 to Image.Picture.Height-1 do
    begin
      P:=Image.Picture.Bitmap.ScanLine[y];
       for x:=0 to Image.Picture.Width-1 do
        begin
          p.Blue:=min(255, round(((p.Blue / 255) + ((SbBlau.Position / 255) * Prozent)) * 255));
          p.Green:=min(255, round(((p.Green / 255) + ((SbGruen.Position / 255) * Prozent)) * 255));
          p.Red:=min(255, round(((p.Red / 255) + ((SbRot.Position / 255) * Prozent)) * 255)); 
          Inc(p);
        end;
    end;
end;

damit kommen nun folgende ergebnisse bei 100% grün (0% rot und blau) und 50%, danach 100% faktor:

programm grün:255 prozent: 50%
http://cyberstorm.hopto.org/prog_half.jpg

programm grün:255 prozent: 100%
http://cyberstorm.hopto.org/prog_full.jpg

photoshop grün:255 prozent: 50%
http://cyberstorm.hopto.org/half.jpg

photoshop grün:255 prozent: 100%
http://cyberstorm.hopto.org/full.jpg

[Corpsman]

Ja was du nu gemacht hast is t das Clamping

Probier doch einfach mal das Scaling aus.

Als du Addierst die Farbanteile wie bisher

(r,g,b)
machst dann t := max(r,max(g,b));

und bei t > 255

(r/t*255,g/t*255,b/t*255)

Diese variante Behält den Farbwert, evtl ist das besser.

[Cyberstorm]

also ich habe gerade mal in der berechnung das "+" durch "*" ersetzt:

vorher:

Delphi-Quellcode:

(p.Blue / 255) + ((SbBlau.Position / 255)

nachher:

Delphi-Quellcode:

(p.Blue / 255) * ((SbBlau.Position / 255)

für Rot und Grün natürlich ebenso.

nun kommt bei grün:255 und 100% faktor das selbe ergebnis wie bei photoshop heraus (siehe letzer post).

ABER bei 50% kommt leider das bei raus :-/:

http://cyberstorm.hopto.org/dark_prog.jpg


ich guck mir ersteinmal den letzen post an und probiere das ausund melde mich dann nochmal.

[Lun]

Hi,

ich weiß ja nicht ob es hilft aber hier hast du eine Routine die ein Bitmap einfärbt den Raster kannste ja weglassen.
Weiß jetzt nicht ob es das ist was du suchst.

Unter Grafik / Icons / Farben / Cursor auf der Seite findest du
noch mehr Funktionen zum bearbeiten von Bildern.


greetz Lun

P.S: Wenn du das auf den Beispiel Foto bist, ich find Du kannst jede Farbe tragen, aber das Original gefällt mir am besten :mrgreen:

[Cyberstorm]

ich verzweifle langsam :-/.

also habe das jetzt folgendermaßen abgeändert:

Delphi-Quellcode:

procedure TfrmMain.Calculate;
var
  Prozent: Real;
  x, y, r, g, b, t: Integer;
  P: PRGB;
begin
  Prozent:=SbProzent.Position / 100;
   for y:=0 to Image.Picture.Height-1 do
    begin
      P:=Image.Picture.Bitmap.ScanLine[y];
       for x:=0 to Image.Picture.Width-1 do
        begin
          r:=round(((p.Blue / 255) + ((SbBlau.Position / 255) * Prozent)) * 255);
          g:=round(((p.Green / 255) + ((SbGruen.Position / 255) * Prozent)) * 255);
          b:=round(((p.Red / 255) + ((SbRot.Position / 255) * Prozent)) * 255);
          t:=max(r,max(g,b));
          if t>255 then
            begin
              r:=Round(r/t*255);
              g:=Round(g/t*255);
              b:=Round(b/t*255);
            end;
          p.Blue:=b;
          p.Green:=g;
          p.Red:=r;
          Inc(p);
        end;
    end;
end;

da kommt aber quatsch bei raus. wird dann blau wenn ich grün anmache und so sachen...

die sachen von der ddr ecke sind das selbe wie diealte funktion :-(

[Corpsman]

Du bringst mich noch dazu das ich hergehe und das geschwind implementiere...

Also Vergiss unsere bisherigen Codeschnipsel mahcs nochmal neu

1. Alter Farbwert Hohlen
2. Überblendfarbe Hohlen und dann Komponentenweise * Prozent
3. Alte Farbe + Neue Farbe
4. Behandlung des Überlaufes

5.1 Clamping ( d.h. die Min(max( .. Geschichte )


ODER


5.2 Scaling D.h. du schaust ob Max(r,b,g) > 255 , wenn Ja dann Skallierst du alle 3 Farbwerte so das der Max(R,G,B) = 255 wird.

6. Speichern.

[Khabarakh]

Ich glaube, ihr kommt etwas vom Weg ab.
Für den gewünschten Effekt muss doch für die originale Farbe C1, die "Multiplikator-Farbe" C2 und den Mischfaktor f (alle in [0, 1]) einfach nur folgende Formel angewendet werden:

Code:

C1 * (1 - f) + C1 * C2 * f

Und dabei ist definitiv kein Clamping/Scaling/... nötig.
Hab das mal schnell in Paint.Net nachgestellt, es kommen exakt die beiden Photoshop-Bilder aus #14 heraus.

Code:

CurrentPixel = src[x,y];
byte f = PrimaryColor.A; // der Alphakanal der Primärfarbe wird als Faktor missbraucht
CurrentPixel.R = (byte)
 ((CurrentPixel.R * (255 - f) + CurrentPixel.R * PrimaryColor.R * f / 255) / 255);
CurrentPixel.G = (byte)
 ((CurrentPixel.G * (255 - f) + CurrentPixel.G * PrimaryColor.G * f / 255) / 255);
CurrentPixel.B = (byte)
 ((CurrentPixel.B * (255 - f) + CurrentPixel.B * PrimaryColor.B * f / 255) / 255);
dst[x,y] = CurrentPixel;