Berechnung mit Konstante versagt mit Int/Long-Typ (geä.)

[Omi]

Grüße Euch.

Hat jemand eine Erklärung warum folgendes Macro mit einer Konstanten als Parameter funktioniert und übergeben in ein
Int oder Long einen Fehler auswirft.

Line 13: Can't use any of the following operands with floats: <<, >>, &, |, !, %.

Code: Alles auswählen

#CSS_Yellow= $FF00FFFF
Define color.i; color.l

Macro Darken(color)
	Color & $ff000000 + (Color & $ff0000) * 0.8 + (Color & $ff00) * 0.8 + (Color & $ff) * 0.8
	;Int(Color & $ff000000 + Int((Color & $ff0000) * 0.8) + Int((Color & $ff00) * 0.8) + Int((Color & $ff) * 0.8))
EndMacro


Debug Darken(#CSS_Yellow); funktioniert mit Konstante!

color= #CSS_Yellow
Debug Darken(color);       funktioniert nicht als Integer oder Long!

Danke Euch, Charly

PS:
Sorry, die zusätzliche Macro-Fehlermeldung hat mich reingelegt
Der Fehler geschieht auch in einer Funktion und als reine Berechnung mit Int oder Long:

Code: Alles auswählen

color1= #CSS_Yellow & $ff000000 + (#CSS_Yellow & $ff0000) * 0.8 + (#CSS_Yellow & $ff00) * 0.8 + (#CSS_Yellow & $ff) * 0.8

funktioniert!

Code: Alles auswählen

Color1= Color & $ff000000 + (Color & $ff0000) * 0.8 + (Color & $ff00) * 0.8 + (Color & $ff) * 0.8

bringt o.g. Fehler ???

[man-in-black]

Hi,

das hängt mMn damit zusammen, wie PB intern bei den Berechnungen Variablentypen zuweist.
Wenn du zB das "0.8" ausklammerst, gehts. Achte aber auf die Typgrößen :

Code: Alles auswählen

#CSS_Yellow= $FF00FFFF
Define color.i

color= #CSS_Yellow
Debug color                      ;-16711681
Debug #CSS_Yellow           ;4.278.255.615
Debug Hex(#CSS_Yellow)    ;FF00FFFF
Debug Hex(color)               ;FFFFFFFFFF00FFFF

Int geht bis "+2.147.483.647" ...


MFG
MIB

[Omi]

Danke für die Rückmeldung (Agent 'J' / 'K' ?) .
Tatsächlich dürfe die interne PB-Berechnung schuld sein. Wird die Berechung schrittweise auf einzelne Zeilen aufgeteilt funktioniert sie.

Code: Alles auswählen

ColorRet= Color & $ff000000
ColorRet+ (Color & $ff0000) * Fact
ColorRet+ (Color & $ff00) * Fact
ColorRet+ (Color & $ff) * Fact

Das Produkt mit 0.8 wird intern float sein und landet bei der weiteren Abarbeitung der Zeile innerhalb der Klammer (evtl. auf Color) mit der Bitmaske per '&' und führt zum Fehler.
Da Color auf int oder long definiert und die verknüpften Werte ganzzahlige Literale sind, bleibt es allerdings ein Rätsel.
Die Verwendung der Konstante anstelle der Variable verhindert dies scheinbar bei der Abarbeitung ?

Zum Variablen-Typ-Problem:
Du hast es scheinbar auf PB-x32 versucht. Auf PB-x64 und Color.i passt die Ausgabe:

Code: Alles auswählen

Debug color               ;4.278.255.615
Debug #CSS_Yellow         ;4.278.255.615
Debug Hex(#CSS_Yellow)    ;FF00FFFF
Debug Hex(color)          ;FF00FFFF

Das
Debug color ;-16711681
ist ein Wert bei int- oder long-Color auf x32 oder long-Color bei x64 und gilt nur für die Ausgabe. Intern wird ja korrekt weiterverarbeitet, sonst würde keine komplett intransparente Alpha-Farbe auf 32-Bit-System funktionieren.

Kopfzerbrechen macht mir allerdings das Debug Hex(color);FFFFFFFFFF00FFFF bei 32-Bit-Verarbeitung.
Ist bei Color das Negativ-Bit (31) gesetzt, füllt Hex() den Quad anscheinend komplett auf. Der Wert wird dann tatsächlich als 'signed' interpretiert und ist auf 32- u- 64-Bit unterschiedlich.

Gruß, Charly

[mk-soft]

Bei PB gibt es leider noch nicht Unsigned long und quads.

Kleiner Hinweis:
Wenn du mit Helligkeiten rechnen möchtest, muss du Wertigkeit von RGB beachten. Sonst stimmt der Farbton nicht

Grob gerechnet mit

l = r * 0.30 + g * 0.59 + b * 0.11

[man-in-black]

Hi,

das mit 4/8 byte war mir durchaus bewusst, aber da Int und Long als 32b
ein gleiches Verhalten an den Tag legen, habe ich mich auf ein "..." beschränkt
Mit anderen Worten, spätestens bei Long wäre dir deine große Zahl auf die Füße gefallen.
(egal ob intern richtig verarbeitet - sofern ich jetzt nicht nen großen Denkfehler habe)

Bezüglich Konstante lehne ich mich jetzt mal weit aus dem Fenster und behaupte einfach, dass
die Berechnung bereits beim Kompilieren erfolgt. Die Werte sind ja alle bekannt.

LG
Agent 'H'

edit:
Mein Denkfehler lag einfach nur in der weiteren Verarbeitung. Mit BitOperationen und Summen mags gehen,
aber bei Produkten musst du aufpassen...

[Omi]

l = r * 0.30 + g * 0.59 + b * 0.11

Danke Michael, dass Du's erwähnst.
Hätt' ich durchaus mal gelernt ...

Leuchtdichtesignal Uy= 0.3 * Ur + 0.59 * Ug + 0.11 * Ub
-> U'b-y= 0,49 * Ub-y ...

Leider bin ich mit der Formel schon vorher auf die Nase gefallen
Diese 'Präzision' war meinerseits allerdings auch nicht gefordert. Allerdings ist mir nicht bewusst, dass dies auch bei interen Weiterverarbeitung erneut angewendet wird. Zur Monitor- TV-Ausgabe sind diese Faktoren entsprechend der Augenempfindlichkeit ja bereits berücksichtigt ?

@Agent 'H'

Bezüglich Konstante lehne ich mich ... dass die Berechnung bereits beim Compilieren erfolgt.

Da wirst Du wohl Recht haben. Gut dass wenigstens bei Variablenverwendung eine ordentliche Fehlerausgabe das Ganze stoppt und man gezwungenermaßen umkonstruiert.
Als eigenliche Tücke am Objekt sehe ich tatsächlich Dein gepostetes Um- und Rück-'Hex'en von Werten. Das kann einem je nach Compiler und Wert nach Manipulationen wirklich spontan mal um die Ohren fliegen und womöglich lauert auch in meinen bisherigen Codes diesbzgl. der eine oder andere Heckenschütze.
Danke für's Nase drauf stoßen

Viele Grüße
Charly