Farbwert zu Dezimal

[EWeiss]

Im Original VB source nicht.

gruss

[Klaus01]

.. wenn es da funktioniert, dann kann imgSpectrumData nicht nur mit Nullen gefüllt sein.

Grüße
Klaus

[EWeiss]

Zitat von Klaus01:

.. wenn es da funktioniert, dann kann imgSpectrumData nicht nur mit Nullen gefüllt sein.

Grüße
Klaus

Doch ist es

Code:

GdipCreateBitmapFromScan0(w, frmMain.ScaleHeight, w * 4, PixelFormat32bppARGB, imgSpectrumData(0, 0), imgSpectrum)

GDIP_CreateBitmapFromScan0(w, rc.Bottom, w * 4, PixelFormat32bppARGB, PByte(SpectrumData1D[0]), imgSpectrum)

erstellt ein leeres Bitmap im angegebenen Format

@Michael II Funktion liefert auch immer 0 zurück.

Delphi-Quellcode:

  case FEffect of
    0:
      begin
        d := round(Fade * 255);

        for Y := 0 to h do
        begin
          for X := 0 to w do
          begin
            a := SpectrumData2D[x, y] shr 24;
            if a >= d then
              a := a - d
            else
              a := 0;

            c := SpectrumData2D[x,y] and $00FFFFFF;

            SpectrumData2D[x,y] := (a shl 24) or c;
          end;
        end;
      end;

Die VB6 Funktion konvertiert das Byte (255) zu LONG

Code:

a = (((imgSpectrumData(x, y) And &HFF000000) \ &H1000000) And &HFF&)

Kann mir aber nicht vorstellen das es daran liegen könnte.

gruss

[Klaus01]

.. mach aus Deinem alpha: Integer mal ein alpha: Byte

Delphi-Quellcode:

     0: begin
           d := fade * 255;
           // nur für Tests 
           //d := round((random(10) /10)) *255;
           for y:= 0 to h do
             for x := 0 to w do
               begin

                 alpha := ((imgSpectrum[x,y] and $FF000000) shr 24) and $FF;
                 alpha := alpha - d;
                // Byte kann nicht < 0 sein
                // if alpha < 0 then
                //   alpha := 0;
                 c := imgSpectrum[x,y] and $FFFFFF;
                 if alpha > 127 then
                   imgSpectrum[x,y] := c or ((alpha -256) shl 24)
                 else
                   imgSpectrum[x,y] := c or (alpha shl 24);
               end;

rot, grün und blau können auch vom Type Byte sein.

Grüße
Klaus

[EWeiss]

Zitat von Klaus01:

.. mach aus Deinem alpha: Integer mal ein alpha: Byte

Delphi-Quellcode:

     0: begin
           d := fade * 255;
           // nur für Tests 
           //d := round((random(10) /10)) *255;
           for y:= 0 to h do
             for x := 0 to w do
               begin

                 alpha := ((imgSpectrum[x,y] and $FF000000) shr 24) and $FF;
                 alpha := alpha - d;
                // Byte kann nicht < 0 sein
                // if alpha < 0 then
                //   alpha := 0;
                 c := imgSpectrum[x,y] and $FFFFFF;
                 if alpha > 127 then
                   imgSpectrum[x,y] := c or ((alpha -256) shl 24)
                 else
                   imgSpectrum[x,y] := c or (alpha shl 24);
               end;

rot, grün und blau können auch vom Type Byte sein.

Grüße
Klaus

Ja das funktioniert..
Aber was ist nun mit
imgSpectrum[x,y] := c or (alpha shl 24);

Denn wenn du Byte nimmst und Fade ist unter 0.5 dann wird diese nicht mehr aufgerufen muss sie aber.
Das sind die Probleme mit denen ich mich rumschlage.

Aber es scheint ja Profis zu geben die das angeblich können nur gesehen habe ich davon noch nichts.
Können einen nur niedermachen. Grrr..

EDIT:
Hab noch nen Shot angehängt.
Du siehst VB ruft auch diese auf.. bei Fade 0,25 bei dir jedoch nie.

gruss

[Klaus01]

.. wenn für fade 0.4 nehme (geht das erstmal nicht dem Integer zuzuweisen)
Wenn ich da ein round drumpacke dann wird das auf 0 gerundet.

Damit hängt es dann vom alpha Wert von imgSpectrm[x,y] ab wie groß
der alpha - d Wert wird.

d pendelt eigentlich immer zwischen 0 und 1.
Soll das so sein?

Mit den Zufallswerten in imgSpectrum und d wird auch ab und an der else Zweig aufgerufen.
Also muss alpha (aus imgSpectrum) einen Wert von 127 und d von 1 haben um in den else Zweig zu gelangen.
Oder alpha ist generell kleiner als 127.

Grüße
Klaus

[EWeiss]

Zitat:

d pendelt eigentlich immer zwischen 0 und 1.

d pendelt nicht es ist ein festeingestellter wert.
Verstehe nicht wie sich der wert verändern kann.

d := fade = 0.36 * 255 bleibt konstant 92 da tut sich nichts.

gruss

[Klaus01]

.. der verändert sich nicht, in der Routine,

Hatte das round falsch angewendet. round(0.4) -> 0
Nun mit round(0.25 * 255) ist d dann 64

und ja, auch mit diesen Werten wird der else Zweig aufgerufen.
Wenn alpha und d entsprechende Werte haben.

Grüße
Klaus

[EWeiss]

Habe mal VB angepasst so das ich genaue werte liefern kann.

Code:

            For x = 0 To w
                a = (((imgSpectrumData(x, y) And &HFF000000) \ &H1000000) And &HFF&)
                
                f = a - d

                If f < 0 Then
                  a = 0
                Else
                  a = f
                End If
                
                c = imgSpectrumData(x, y) And &HFFFFFF

                If a > 127 Then
                    imgSpectrumData(x, y) = c Or ((a - 256) * &H1000000)
                Else
                    imgSpectrumData(x, y) = c Or (a * &H1000000)
                End If

a bekommt den wert 0

f = a - d = -92

damit ist die Bedingung erfüllt das ich in die zweite Funktion(Bedingung) springe.
Da du aber Byte verwendest wird -92 niemals bei dir auftreten..

Deshalb springt er zwischen > 127 und < 0 denn 0.36 * 255 = 92 und a -d = -92

Also Byte ist definitive in dem fall dann nicht korrekt.
Hab jetzt alles durch das wird nix.
Danke trotzdem.

gruss

[Klaus01]

.. das mit der Hilfsvariablen ist eine gute Idee:

Delphi-Quellcode:

           for y:= 0 to h do
             for x := 0 to w do
               begin

                 alpha := ((imgSpectrum[x,y] and $FF000000) shr 24) and $FF;
                 _alpha := alpha - d;
                // if alpha < 0 then
                //   alpha := 0;
                 c := imgSpectrum[x,y] and $FFFFFF;
                 if _alpha > 127 then
                   imgSpectrum[x,y] := c or ((alpha -256) shl 24)
                 else
                   imgSpectrum[x,y] := c or (alpha shl 24);
               end;

Wobei _alpha vom type smallInt ist, alpha ist weiterhin ein Byte.

Grüße
Klaus