"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

[neo4a]

Hallo Jürgen,

vielen Dank für diese Funktion, die ich so mit eingebaut habe:

Delphi-Quellcode:

procedure TForm1.sButton2Click(Sender: TObject);
var img1,img2:TBitmap32; r:TRect;
begin
  img1:=TBitmap32.Create;
  img2:=TBitmap32.Create;

  //Hole das Bild aus der TImage32-Komponente
  img2.Assign(image321.Bitmap);
  //Platz schaffen für's Überstrahlen
  img1.SetSize(img2.Width+80,img2.Height+80);
  //Zoomen mit ein wenig Platz
  img1.Draw(rect(20,20,img1.Width-20,img1.Height-20),
              rect(0,0,img2.Width,img2.Height),img2);
  //aus gr_fastfx
  ApplySaturationLut(img1,SaturationLut(680));
  GaussianBlur(img1,8);
  //intern
  FastBlur(img1,2,15);
  //aus gr_graphutils
  DrawSides(img2,img2.ClipRect,clWhite,clWhite,ALLFRAME_SIDES,200,2);
  r:=img1.BoundsRect;
  r.Right:=r.Right-1;
  r.Bottom:=r.Bottom-1;
  DrawSides(img1,r,clWhite,clWhite,ALLFRAME_SIDES,200,2);
  //Und zurück in die Komponente
  image321.Bitmap.SetSize(img1.Width+1,img1.Height+1);
  image321.Bitmap.Draw(0,0,img1);
  image321.Bitmap.Draw(40,40,img2);
end;

Die zusätzlichen Routinen kommen von einer Bibliothek gr32exv0.9 eines chinesischen Programmierers. Dort gibt es auch einen Ansatz, wie man den Background der TImage32-Komponente transparent bekommt. Leider gab es beim "mergen" mit meiner D2009-Version von Graphics32 eine Reihe von Problemen, die bis ich jetzt nicht lösen konnte.

Als Skinning-Lösung benutze ich die AlphaControl-Lib. Der erste Schritt passt (mir) schon ganz gut. Das mit der Transparenz bekomme ich auch noch hin. Vielen Dank nochmals für Deinen Ansatz.

--
Andreas

[Pfoto]

Hallo Andreas,

Das sieht ja richtig gut aus!

Unterscheidt sich der GaussianBlur eigentlich vom
Ergebnis viel vom FastBlur-Algo? Oder warum hast du
beide hintereinander eingebaut?

Wirkt denn der Effekt noch, wenn weniger farbige
Stellen im Bild sind, oder wirst du dann etwas nachhelfen?


Gruß
Jürgen

[neo4a]

Hallo Jürgen,

sie unterscheiden sich nicht wirklich im Ergebnis und ich habe FastBlur zunächst drin gelassen, damit ... weil ich damit halt angefangen habe. Allerdings musste ich später feststellen, dass die oben vorgestellte Lösung ein Performance-Problem hat. Die Ursache war die FastBlur-Routine. Ich habe sie entfernt, nun klappt's auch mit BilleniumEffects (Smooth Alphablending OnMouseEnter/Leave). Das kommt richtig gut.

Zufrieden werde ich aber erst sein, wenn das Transparenz-Problem gelöst ist und der Effekt auf "realem" Hintergrund funktioniert.

Du hast Recht: Wenn das Bild z.B. einen breiten schwarzen Rand hat, verschwindet derzeit der Glow- Effekt noch. Ich experimentiere hier damit, vor dem GaussianBlur die Kontur des Bildes mit einer Neon- Farbe dick nachzuzeichnen. Damit glüht dann immer was. Hierzu müsste ich allerdings in der Lage sein, programmtechnisch die Farben des Bild- Randbereiches gewichtet zu bestimmen. Das bin ich derzeit nicht.

--
Andreas

[Larsi]

Zitat:

Zitat von 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

Ich habe in meinem Delphi komischerweise gar kein Bitmap32. :gruebel: Ist das vielleicht erst in einer neuen Version dabei? Welche Uses Units müssen eigentlich eingebunden werden, das es keine Compiler Fehler gibt?

[Die Muhkuh]

TBitmap32 kommt von der Graphics32-Bibliothek, die brauchst Du noch.

[Meflin]

Sehr schöner Effekt, das müsste man bei Gelegenheit mal nach PHP portieren :thumb:

Leider gibts die Graphics32 nicht für PHP, sonst wärs ja einfach :(

[Larsi]

Ja aber was muss ich in den uses eintragen damit alles vom Compiler erkannt wird.

[Pfoto]

Nachdem du die GR32- Bibliothek installiert hast (zumindest die Pfade eingetragen hast),
musst du GR32 in die Uses-Klausel eintragen.


Edit:
hier ist übrigens die neueste Funktion, nochmals optimiert (gefunden im GR32-Forum):

Delphi-Quellcode:

procedure FastBlur(Dst: TBitmap32; Radius: Integer; Passes: Integer = 3);
//****************************************************************
//*  Fastblur routine (c)2005 Roy Magne Klever
//*  GR32 Conversion and further optimizations by Michael Hansen
//*  If you improve it please send a copies to:
//*  [email][e-mail][/email]
//*  [email][e-mail][/email]
//****************************************************************
type
   PARGB32 = ^TARGB32;
   TARGB32 = packed record
     B: Byte;
     G: Byte;
     R: Byte;
     A: Byte;
   end;
   TLine32 = array[0..MaxInt div SizeOf(TARGB32) - 1] of TARGB32;
   PLine32 = ^TLine32;

   PSumRecord = ^TSumRecord;
   TSumRecord = packed record
     saB, saG, saR, saA: Cardinal;
   end;

var
   J, X, Y, w, h,  ny, tx, ty: integer;
   ptrD: integer;
   s1: PLine32;
   C: TColor32;
   sa: array of TSumRecord;
   sr1, sr2: TSumRecord;
   n : Cardinal;
begin
   if Radius = 0 then Exit;

   n := Fixed(1 / ((radius * 2) + 1));
   w := Dst.Width - 1;
   h := Dst.Height - 1;

   SetLength(sa, w + 1 + (radius * 2));

   s1 := PLine32(Dst.PixelPtr[0,0]);
   ptrD := Integer(Dst.PixelPtr[0,1]) - Integer(s1);

   ny := Integer(s1);
   for Y := 0 to h do
   begin
     for J := 1 to Passes do
     begin
       X := - Radius;
       while X <= w + Radius do
       begin
         tx := X;
         if tx < 0 then tx := 0 else if tx >= w then tx := w;
         sr1 := sa[X + Radius - 1];
         C := PColor32(ny + tx shl 2)^;
         with sa[X + Radius] do
         begin
           saA := sr1.saA + C shr 24;
           saR := sr1.saR + C shr 16 and $FF;
           saG := sr1.saG + C shr 8 and $FF;
           saB := sr1.saB + C and $FF;
         end;
         inc(X);
       end;
       for X := 0 to w do
       begin
         tx  := X + Radius;
         sr1 := sa[tx + Radius];
         sr2 := sa[tx - 1 - Radius];
         PColor32(ny + X shl 2)^ := (sr1.saA - sr2.saA) * n shl 8 and 
$FF000000 or
                                    (sr1.saR - sr2.saR) * n and $FF0000 or
                                    (sr1.saG - sr2.saG) * n shr 8 and $FF00 
or
                                    (sr1.saB - sr2.saB) * n shr 16;
       end;
     end;
     inc(ny, PtrD);
   end;

   SetLength(sa, h + 1 + (Radius * 2));
   for X := 0 to w do
   begin
     for J := 1 to Passes do
     begin
       ny := Integer(s1);
       Y := - Radius;
       while Y <= h + Radius do
       begin
         if (Y > 0) and (Y < h) then inc(ny, PtrD);
         sr1 := sa[Y + Radius - 1];
         C := PColor32(ny + X shl 2)^;
         with sa[Y + Radius] do
         begin
           saA := sr1.saA + C shr 24;
           saR := sr1.saR + C shr 16 and $FF;
           saG := sr1.saG + C shr 8 and $FF;
           saB := sr1.saB + C and $FF;
         end;
         inc(Y);
       end;
       ny := Integer(s1);
       for Y := 0 to h do
       begin
         ty := Y + Radius;
         sr1 := sa[ty + Radius];
         sr2 := sa[ty - 1 - Radius];
         PColor32(ny + X shl 2)^ := (sr1.saA - sr2.saA) * n shl 8 and 
$FF000000 or
                                    (sr1.saR - sr2.saR) * n and $FF0000 or
                                    (sr1.saG - sr2.saG) * n shr 8 and $FF00 
or
                                    (sr1.saB - sr2.saB) * n shr 16;
         inc(ny, PtrD);
       end;
     end;
   end;
   SetLength(sa, 0);
end;

Edit2:

Die von neo4a benutze zusätzliche Library ist übrigens hier:
http://code.google.com/p/gr32ex/

Da müsste dann auch die andere Blur-Funktion zu finden sein.

Gruß
Jürgen

[Larsi]

Kompillieren geht jetzt ohne Fehler aber ich habe keine Komponente mit dem Namen TBitmap32.

[Pfoto]

Wenn du die Komponenten installieren möchtest, muss du dafür erst die erforderlichen Packages installiern

z.B. für Turbo Delphi 2006
GR32_BDS2006.bdsproj (für Runtime)
GR32_DSGN_BDS2006.bdsproj (für Designtime)

Gruß
Jürgen

[Larsi]

Hab ich ja doch die Komponente ist nicht da.

[DeddyH]

Und der Bibliothekspfad ist auch angepasst?

[Larsi]

Also den Code kann ich jetzt ohne Probleme kompillieren, doch in der Komponentenleiste finde ich nicht die Komponente TBitmap32 sondern nur TImage32.

[DeddyH]

Dann wird das wohl auch so stimmen.

[Pfoto]

Das ist schon richtig so, denn das herkömmliche TBitmap gibt
es ja auch nicht als Komponente, sondern zur Laufzeit z.B. innerhalb von TImage.

Du kannst innerhalb TImgView32 verschiedenen Bitmaps bzw.
Layer benutzen. Schau dir am Besten mal die Demos an.

Gruß
Jürgen

[mkinzler]

Da TBitmap32 keine Komponente ist ( wie auch TBitmap)

[neo4a]

@Meflin

Schaust Du hier: FlippingBook.


@Larsi

TBitmap32 ist ist der unit gr32 definiert, die Du mit einbinden musst.


@Jürgen

Ich habe mein Ziel erreicht und TImage32 ist transparent. In der Tat gibt es die GaussianBlur()-Funktion in der gr_fastfx. Ich musste allerdings den Alpha-Anteil in der SplitBlur32()-Funktion "nachrüsten".

Nachdem das geschafft ist, werde ich nun das Speil etwas weiter treiben und die TImage32-Komponente als Wallpaper benutzen und die Layer als "Ambilight"-Buttons verwenden, die bei Aktivierung auf den Hintergrund überstrahlen.

--
Andreas

[Larsi]

Ich führe die Prozedur jetzt so aus:

Delphi-Quellcode:

fastblur(image321.Bitmap, 10, 3);

In der Image32 Komponente befindet sich ein Bitmap doch wenn ich auf den Button drücke, der die Funktion aufruft passiert nichts. Muss ich noch irgendwas einstellen?

[Meflin]

Zitat:

Zitat von neo4a

@Meflin
Schaust Du hier: FlippingBook.

Das sieht aber nicht aus als ob das dynamisch generiert würde?!

[Larsi]

Hat sich erledigt, geht jetzt :thumb: Wär doch super für die Codelib oder?

[Pfoto]

@Andreas

Glückwunsch, Hartnäckigkeit zahl sich aus ;-)

Zitat:

Ich habe mein Ziel erreicht und TImage32 ist transparent. In der Tat gibt es die GaussianBlur()-Funktion in der gr_fastfx. Ich musste allerdings den Alpha-Anteil in der SplitBlur32()-Funktion "nachrüsten".

Ich hänge übrigens parallel an einem Problem (unabhängig von einem Effekt wie Ambilight),
ich versuche, die FastBlur-Funktion mit einem korrekten Alpha-Kanal auszustatten.
Dieser erzeugt nämlich einen leichten Grauschleicher (siehe Anhang).

Würdest du mir evtl. zeigen, wie du den korrekten Alpha-Kanal in der GaussianBlur-Funktion
implementieren konntest? Für mich sind diese mathematischen Dinge einfach
nicht nachzuvollziehen, so sehr ich es auch versuche zu kapieren.

Hoffe, es wird nicht zu sehr OT.

Jürgen

[neo4a]

@Larsi

Schau Dir bitte mein Code-Schnipsel etwas genauer an. Dort kopiere ich zunächst das Bitmap aus der Komponente, führe die Bildoperationen durch und weise sie wieder zu. Vielleicht bringt Dich dieser Ansatz weiter.

@Meflin

Hepp, Du hast Recht. Es würde mich aber stark wundern, wenn die Bildoperationen sich nicht auch mit Javascript clientseitig nachbilden ließen. Bei der serverseitigen Bereitstellung der Bilder kann man auf jeden Fall zuvor auch das Hoover-Bild dynamisch erzeugen lassen und mit ausliefern, ähnlich der Thumbview- Erstellung.

--
Andreas

[neo4a]

Hallo Jürgen,

ich hänge Dir die modifizierte Datei mit an. Es ist zwar nur eine Zeile hinzugekommen, aber es ist vielleicht so am einfachsten. Du weißt ja, dass man die gr_fastfx einfach nur in das Verzeichnis von graphics32 kopiert und die unit in das Projekt mit einbindet.

Ich habe es nicht explizit in D7 getestet, aber die Ursprungsversion ist ja von 2006. In D2009 funktioniert sie gut und etwas schneller, als die ursprünglich von Dir gepostete Variante.

--
Andreas

[Pfoto]

Hab' vielen Dank dafür Andreas! Das bringt mich endlich etwas weiter!

Edit:
Schade, diese Funktion bringt komischerweise genau das gleiche Resultat (siehe Anhang)
Bei deinem Bild (bzw. Hintergrund) scheint es aber gar nicht aufzufallen.


Gruß
Jürgen

[neo4a]

Hallo Jürgen,

der Grau-Anteil kommt m.E. von der Hintergrund-Farbe von TImage32. Da ich ja Timage32ex verwende, das Transparenz beherrscht, klappt's vielleicht etwas besser. Du kannst die angehängte Datei einfach in Dein Graphic32-Paket mit einbinden und erhälst eine weitere Komponente.

Bitte beachte, dass die Transparenz ggf. color:=clNone erfordert.

Viel Glück.

--
Andreas

[Pfoto]

Danke für Deine Hilfe, aber ich verwende z.Zt. nur das reine TBitmap32
und lasse es als Bitmap sofort speichern.

Den zusätzlich erstellen Kanal habe ich dann in Photoshop
als Alphamaske eingebunden.
Der Alphakanal ist ja auch bereits *fast* korrekt...
Ich denke halt, es ist eine korrektur in den mathematischen
Funktionen notwendig.

Würde mich mal interessieren, wie deine Ausgabe auf einem rein
schwarzen Hintergrund aussieht. Könntest du das mal testen
(falls es keine große Arbeit für dich macht)

Gruß
Jürgen

[neo4a]

Kann ich gerne machen, muss aber leider bis morgen warten.

--
Andreas

[neo4a]

Hier das für gestern versprochene Beispiel. Ich habe so erzeugt:

Delphi-Quellcode:

Image321.Bitmap.SaveToFile('.\test.bmp');

HTH.

--
Andreas