"Ambilight"- Glow- Effekt um Image

[neo4a]

Ich würde gern in einem meiner Privat-Projekte Bilder mit einem Glow- Effekt hinterlegen, wie man es von der Ambilight- Funktion von Philips- TV vielleicht bereits kennt. Dort wird der überwiegende Farbbereich des (TV-)Inhalts über die Ränder dynamisch überstrahlt.

Ich freue mich über Denkanstöße, die mir die 2 Probleme lösen:

Wie erzeuge ich den Überstrahl- Effekt zur Laufzeit erst einmal monochrom, wobei die Dimension und die Form (abgerundete Ecken) der Image- Komponente wechselt?

Wie erhalte ich den letzendlichen Ambilight- Effekt?

Mein Ansatz wäre es, die originale Grafik auf den Überstrahlbereich zu vergrößern, dann mit einem Blur-Effekt zu "verwässen" und anschließend mit einem Alpha-Blend ein Fading-Out zu erzeugen.

Klar, dass alles transparent auf beliebiger Textur erfolgen soll, weil der Hintergrund "geskinnt" ist ;)

Graphics32 mit TImage32 liefert mir bereits alle Funktionen (so weit ich weiß), doch leider habe ich diese Komponente bislang noch nicht mit transparentem Canvas hinbekommen.

--
Andreas

[Larsi]

Vielleicht könnte man auch per Scanline berechnen welcher Farbton am Meißten auf dem Bild zu sehen ist und dann diesen an den Rand zeichnen. Ob das so aussieht wie du es haben willst kann ich dir nicht sagen.

[Sherlock]

Ambilight zeigt in seiner aktullsten Form nicht die überwiegende Farbe, sondern das was halt am Rand gerade angezeigt wird:
http://www.hitec-handel.de/hitec-08/..._Ambilight.jpg

Und falls das irgendwann mal verschwindet, hier die passende Bildersuche:
http://images.google.de/images?hl=de...G=Bilder-Suche

Sherlock

[neo4a]

@Sherlock

Ob nun der Randbereich oder der überwiegende Farbinhalt den Farbverlauf bestimmt, kann man ja später immer noch parametrisieren. Meine Limitation betrifft den Umgang mit den Grafikfunktionen bzw. den Einsatz geeigneter Komponenten.

--
Andreas

[Pfoto]

Hallo,

ich kenne die Graphics32-Komponenten zwar nicht sehr gut, weiß aber in etwas wie sie aufgebaut sind.

Eine Art Ambilight-Funktion würde ich folgendermaßen umsetzen.

Bild kopieren für leuchtenden Bereich,
in Alpha-Kanal ein weißes Rectangle mit den gleichen Maßen auf schwarzem Grund.
Blur-Filter auf Bild sowie Alpha-Kanal

Nun das eigentliche Bild draufsetzen.

Ich habe das eben mal mit Photoshop simuliert (siehe Anhang)

Damit die Farben im Hintergrund auch wirklich leuchten und
die dunklen Farbtöne etwas in den Hintergrund treten, habe ich
die Ambilight-Ebene verdoppelt und mit 2 Ebenen-Modi
berechnen lassen ("Farbe" und darüber "hartes Licht").

Die meisten der Photoshop-Ebenen-Modi gibt es ja auch in Graphics32
wie ich gesehen habe. Für die perfekte Ambilight-Funktion müsste
man aber sicher noch mehr herumexperimentieren.


Gruß
Jürgen

[Pfoto]

Ich habe noch ein paar Expermimente gemacht und
bin zu einem wie ich finde besseren Ergebnis gekommen als eben,
diesmal auf dunklem Untergrund (siehe Anhang)

Meine Vorgehensweise:

Bild dublizieren und um ca. 101% vergrößeren,
Gaußcher Weichzeichner drauf (im Beispiel Radius 20)
Ebenenmodus: Normal
Ebene dublizieren (darüber) und auf "Hartes Licht" stellen
zur Verstärkung habe ich diese Eben nochmals dubliziert.

Damit sich das Hauptbild etwas abhebt habe ich einen minimalen
Schatten erstellt.

Gruß
Jürgen

[neo4a]

@Jürgen,

wie ich an den Downloadzahlen sehen kann, bin ich nicht der einzige, der sich für Deine Arbeit interessiert. Das gelungene Ergebnis muss ja jetzt "nur noch" in Delphi-Routinen abgebildet werden. Mal sehen, wie man das insbesondere auf beliebigen und nicht einfarbigen Hintergrund hinbekommt.

Danke für Deine Mühe.

--
Andreas

[Pfoto]

Wie erwähnt, dadurch, dass du gleichzeitig den Alphakanal
in Graphics32 mit Blur belegst, erzeugst du ja automatisch auch
die semi-transparenten Stellen.
Somit kannst du auch einen mehrfarbigen Hintergrund einziehen.

Ich muss noch anmerken, dass sich nicht jedes Bild gleich gut
eignet, um mit der genannten Vorgehensweise schöne Ergebnisse
zu erzielen. Aber ich denke bei Philips ist es prinzipbedingt
wohl auch so, dass bei dunklen Filmszenen eben so gut wie
kein Ambilight entsteht.

Gruß
Jürgen

[neo4a]

@Jürgen,

genau die Überlegung, dass das Bild z.B. einen dicken schwarzen Rand haben kann, hat mich auf den überwiegenden Farbinhalt des Bildes gebracht. Ansonsten sähe das Überstrahlen lediglich der (halt schwarzen) Randbereiche irgendwie nur öde aus ;)

--
Andreas

[Pfoto]

Schaumal, diesen FastBlur-Algo. hatte ich noch bei mir gefunden
(wahrscheinlich aus dem Forum von GR32).

Damit wird, so wie es aussieht, sogar der Alphakanal direkt mit
entsprechend aufbereitet.

Delphi-Quellcode:

procedure FastBlur(aBitmap32: TBitmap32; aRadius: Integer; aPasses: Integer = 3);
// Quick box blur algoritm

// aPasses:
// 1: Blur quality too low
// 2: Best speed / quality compromise
// 3: Good quality but impossible to have a small blur radius. Even
// radius 1 gives a large blur.

var
  iPass:        integer;
  lBoxSize:     cardinal;
  lColor32:     TColor32;
  lHeight1:     integer;
  lSumArray:    array of TSumRecord;
  lWidth1:      integer;
  x:            integer;
  xBitmap:      integer;
  y:            integer;
  yBitmap:      integer;

begin
  if aRadius <= 0 then
  begin
    Exit;
  end;
  lBoxSize := (aRadius * 2) + 1;
  lWidth1  := aBitmap32.Width  - 1;
  lHeight1 := aBitmap32.Height - 1;
  // Process horizontally
  SetLength(lSumArray, aBitmap32.Width + 2 * aRadius + 1);
  for yBitmap := 0 to lHeight1 do
  begin
    for iPass := 1 to aPasses do
    begin
      // First element is zero
      lSumArray[0].A := 0;
      lSumArray[0].R := 0;
      lSumArray[0].G := 0;
      lSumArray[0].B := 0;
      for x := Low(lSumArray) + 1 to High(lSumArray) do
      begin
        xBitmap := x - aRadius - 1;
        if xBitmap < 0 then
        begin
          xBitmap := 0;
        end else
          if xBitmap > lWidth1 then
          begin
            xBitmap := lWidth1;
          end;
        lColor32 := PColor32(aBitmap32.PixelPtr[xBitmap, yBitmap])^;
        lSumArray[x].A := lSumArray[x - 1].A + lColor32 shr 24;
        lSumArray[x].R := lSumArray[x - 1].R + lColor32 shr 16 and $FF;
        lSumArray[x].G := lSumArray[x - 1].G + lColor32 shr 8  and $FF;
        lSumArray[x].B := lSumArray[x - 1].B + lColor32        and $FF;
      end;
      for xBitmap := 0 to lWidth1 do
      begin
        x := xBitmap + aRadius + 1;
        PColor32(aBitmap32.PixelPtr[xBitmap, yBitmap])^ :=
          ((lSumArray[x + aRadius].A - lSumArray[x - aRadius - 1].A)
        div lBoxSize) shl 24 or
          ((lSumArray[x + aRadius].R - lSumArray[x - aRadius - 1].R)
        div lBoxSize) shl 16 or
          ((lSumArray[x + aRadius].G - lSumArray[x - aRadius - 1].G)
        div lBoxSize) shl 8 or
           (lSumArray[x + aRadius].B - lSumArray[x - aRadius - 1].B)
        div lBoxSize;
      end;
    end;
  end;

  // Process vertically
  SetLength(lSumArray, aBitmap32.Height + 2 * aRadius + 1);
  for xBitmap := 0 to lWidth1 do
  begin
    for iPass := 1 to aPasses do
    begin
      // First element is zero
      lSumArray[0].A := 0;
      lSumArray[0].R := 0;
      lSumArray[0].G := 0;
      lSumArray[0].B := 0;
      for y := Low(lSumArray) + 1 to High(lSumArray) do
      begin
        yBitmap := y - aRadius - 1;
        if yBitmap < 0 then
        begin
          yBitmap := 0;
        end
        else if yBitmap > lHeight1 then
        begin
          yBitmap := lHeight1;
        end;
        lColor32 := PColor32(aBitmap32.PixelPtr[xBitmap, yBitmap])^;
        lSumArray[y].A := lSumArray[y - 1].A + lColor32 shr 24;
        lSumArray[y].R := lSumArray[y - 1].R + lColor32 shr 16 and $FF;
        lSumArray[y].G := lSumArray[y - 1].G + lColor32 shr 8  and $FF;
        lSumArray[y].B := lSumArray[y - 1].B + lColor32        and $FF;
      end;
      for yBitmap := 0 to lHeight1 do
      begin
        y := yBitmap + aRadius + 1;
        PColor32(aBitmap32.PixelPtr[xBitmap, yBitmap])^ :=
          ((lSumArray[y + aRadius].A - lSumArray[y - aRadius - 1].A)
        div lBoxSize) shl 24 or
          ((lSumArray[y + aRadius].R - lSumArray[y - aRadius - 1].R)
        div lBoxSize) shl 16 or
          ((lSumArray[y + aRadius].G - lSumArray[y - aRadius - 1].G)
        div lBoxSize) shl 8  or
           (lSumArray[y + aRadius].B - lSumArray[y - aRadius - 1].B)
        div lBoxSize;
      end;
    end;
  end;
end;

Gruß
Jürgen