Include - Farbanpassungen (Helligkeit, Kontrast, Graustufen)

[STARGÅTE]

Tachchen,

möchte euch hier meine Farbanpassungsproceduren zur Verfügung stellen.

Sie ermöglichen einfache Farbveränderungen die für verschiedene Gebiete gebraucht werden: Bilder, eigene 3D-Buttons, usw.

Derzeitige Proceduren:
ColorHex, ColorDec
ColorMix
ColorBrightness
ColorIntensity
ColorContrast
ColorGamma
ColorInverse
ColorGray

Beispielbild:



Falls es Probleme mit einigen Proceduren gibt, oder eurer Meinung nach die Parameter einen anderen "Bereich" haben sollte, dann bitte ich euch das zu schreiben.

Code: Alles auswählen

; Korrigiert einen zu kleinen oder zu großen Wert für einen Farbwert
Procedure Real255(Wert)
 If Wert < 0
  ProcedureReturn 0
 ElseIf Wert > 255
  ProcedureReturn 255
 Else
  ProcedureReturn Wert
 EndIf
EndProcedure



; Gibt die (Dec-)Farbe als eine (Hex-)Farbe aus (immer 6-stellig)
Procedure.s ColorHex(Color.l)
 ProcedureReturn RSet(Hex(Color), 6, "0")
EndProcedure

; Gibt die (Hex-)Farbe als eine (Dec-)Farbe aus
Procedure ColorDec(Color$)
 Protected n, Color, Asc
 For n = 1 To Len(Color$)
  Color * 16
  Asc = Asc(Mid(UCase(Color$), n, 1))
  Select Asc
   Case '0' To '9'
    Color + (Asc-'0')
   Case 'A' To 'F'
    Color + (Asc-'A'+10)
  EndSelect  
 Next
 ProcedureReturn Color
EndProcedure



; Mischt zwei Farben 
;  MixFactor = -1.0  ->  100% Farbe1 ,   0% Farbe2
;  MixFactor = ±0.0  ->   50% Farbe1 ,  50% Farbe2
;  MixFactor = +1.0  ->    0% Farbe1 , 100% Farbe2
Procedure ColorMix(Color1, Color2, MixFactor.f=0, Flags=0)
 Protected R, G, B, P.f, P1.f, P2.f
 Select Flags
  Case 0
   P2 = (MixFactor+1)/2
   P1 = 1 - P2 
   R = Red(Color1)*P1   + Red(Color2)*P2
   G = Green(Color1)*P1 + Green(Color2)*P2
   B = Blue(Color1)*P1  + Blue(Color2)*P2
   ProcedureReturn RGB(R,G,B)
  Case 1
   If MixFactor < 0
    P = (MixFactor+1)
    R = Real255( Red(Color1)   + Red(Color2)*P   )
    G = Real255( Green(Color1) + Green(Color2)*P )
    B = Real255( Blue(Color1)  + Blue(Color2)*P  )
   Else
    P = (1-MixFactor)
    R = Real255( Red(Color2)   + Red(Color1)*P   )
    G = Real255( Green(Color2) + Green(Color1)*P )
    B = Real255( Blue(Color2)  + Blue(Color1)*P  )
   EndIf
   ProcedureReturn RGB(R,G,B)
 EndSelect
EndProcedure



; Verändert die Helligkeit einer Farbe
;  Brightness = -1.0  ->  dunkel (schwarz)
;  Brightness = ±0.0  ->  normal
;  Brightness = +1.0  ->  hell (weiß)
Procedure ColorBrightness(Color, Brightness.f, Flags=0)
 Protected R, G, B, RGB
 Select Flags
  Case 0
   R = Real255(   Red(Color) + Brightness*255 )
   G = Real255( Green(Color) + Brightness*255 )
   B = Real255(  Blue(Color) + Brightness*255 )
   ProcedureReturn RGB(R,G,B)
  Case 1
   If Brightness < 0
    R = Real255(   Red(Color) * (1+Brightness) )
    G = Real255( Green(Color) * (1+Brightness) )
    B = Real255(  Blue(Color) * (1+Brightness) )
   Else
    R = Brightness*255 +   Red(Color) * (1-Brightness)
    G = Brightness*255 + Green(Color) * (1-Brightness)
    B = Brightness*255 +  Blue(Color) * (1-Brightness)
   EndIf
   ProcedureReturn RGB(R,G,B)
  Case 2
   RGB = ColorMix(ColorBrightness(Color, Brightness, 0), ColorBrightness(Color, Brightness, 1))
   ProcedureReturn RGB
 EndSelect
EndProcedure



; Verändert die Intensität einer Farbe
;  Intensity = 0.0  ->  keine Intensität (schwarz)
;  Intensity = 1.0  ->  normale Intensität
;  Intensity = 2.0  ->  höhere Intensität
Procedure ColorIntensity(Color, Intensity.f)
 Protected R, G, B
 R = Real255(   Red(Color) * Intensity )
 G = Real255( Green(Color) * Intensity )
 B = Real255(  Blue(Color) * Intensity )
 ProcedureReturn RGB(R,G,B)
EndProcedure



; Verändert den Kontrast einer Farbe
;  Contrast = -1.0  ->  kein Kotrast (grau)
;  Contrast = ±0.0  ->  normaler Kotrast
;  Contrast = +1.0  ->  hoher Kontast
Procedure ColorContrast(Color, Contrast.f)
 Protected R, G, B
 R = Real255(   Red(Color) + (  Red(Color)-128) * Contrast )
 G = Real255( Green(Color) + (Green(Color)-128) * Contrast )
 B = Real255(  Blue(Color) + ( Blue(Color)-128) * Contrast )
 ProcedureReturn RGB(R,G,B)
EndProcedure



; Verändert den Gamma-Wert einer Farbe
;  Gamma < 1.0  ->     dunkeler
;  Gamma = 1.0  ->     keine Änderung
;  Gamma > 1.0  ->     heller
Procedure ColorGamma(Color, Gamma.f)
 Protected R, G, B
 R = Real255( Pow(   Red(Color)/255 , 1/Gamma ) * 255 )
 G = Real255( Pow( Green(Color)/255 , 1/Gamma ) * 255 )
 B = Real255( Pow(  Blue(Color)/255 , 1/Gamma ) * 255 )
 ProcedureReturn RGB(R,G,B)
EndProcedure



; Gibt die Graufarbe einer Farbe zurück
;  Intensity = 0.0  ->  Farbig
;  Intensity = 1.0  ->  Grau
;  GrayColor :   Graufarbe die erreich werden soll (RGB-Farbe)      
Procedure ColorGray(Color, Intensity.f, GrayColor=$FFFFFF)
 Protected R, G, B, Gray.f
 #GrayColorFactorRed   = 0.299 
 #GrayColorFactorGreen = 0.587
 #GrayColorFactorBlue  = 0.114 
 Gray = #GrayColorFactorRed*Red(Color) + #GrayColorFactorGreen*Green(Color) + #GrayColorFactorBlue*Blue(Color)
 R =   Red(GrayColor) * Gray/255*Intensity +   Red(Color) * (1-Intensity)
 G = Green(GrayColor) * Gray/255*Intensity + Green(Color) * (1-Intensity)
 B =  Blue(GrayColor) * Gray/255*Intensity +  Blue(Color) * (1-Intensity)
 ProcedureReturn RGB(R,G,B)
EndProcedure



; Invertierung einer Farbe
;  Factor = 0.0  ->     normal Farben
;  Factor = 1.0  ->     inverse Farben
Procedure ColorInverse(Color, Factor.f=1)
 Protected R, G, B
 If Factor = 1
  ProcedureReturn Color ! $FFFFFF
 Else
  ProcedureReturn ColorMix(Color, Color ! $FFFFFF, Factor*2-1)
 EndIf
EndProcedure

[Andreas_S]

Thx for sharing

Kann man immerwieder gebrauchen...

[Jilocasin]

Ein Jahr früher und ich hätte sie in Pixtix eingebaut
Trotzdem danke.. sowas such ich schon länger

[ts-soft]

Hab ich jetzt zufällig entdeckt, da ich bei meinem letztem Projekt mit Filtern gearbeitet habe.

Wie wäre es mit einer Aktualisierung mit Anpassung an die neue ImageLib von PB, also mit
Filtercallbacks usw., ich könnte es jedenfalls gebrauchen

Gruß
Thomas

[STARGÅTE]

In der Tat, habe ich schon mal an einer neuen Include gearbeitet.
Jedoch konnte ich mich dabei nicht entscheiden was ich machen will.

Ich hatte zwei mögliche "Ideen":

• Direkte manipulation der Images. Also:
  ImageIntensity(#Image, Intensity.f)
  ImageBrightness(#Image, Brightness.f)
  ImageGamma(#Image, Gamma.f)
  usw.
  Das heißt, Images können direkt verändert werden (um Farbverluste zu verhinden, sollte immer mit Kopien gearbeitet werden)
• DrawingFilter für StartDrawing() : StopDrawing(). Also:
  DrawingFilter(#DrawingFilter_Brightness)
  DrawingFilter(#DrawingFilter_Intensity)
  Das heißt, man kann Filter anlegen, die dann bei nachfolgenden Box()- o.a. Befehlen angewendet werden.

Beides hat vor und nachteile ...
Bei DrawingFilter() kann man mit Masken arbeiten, was ja ein riesen Vorteil ist.
Bei den direkten veränderungen an dem Bildern mit ImageBrightness() spart man n menge Code.

Da du nun schon Filtercallbacks() angesprochen hast, würde ich mich nun an DrawingFilter() setzen.

[ts-soft]

Da du nun schon Filtercallbacks() angesprochen hast, würde ich mich nun an DrawingFilter() setzen.

edel und ich haben sich an sowas bereits versucht um den 4-State-ImageGenerator Crossplattform zu machen (include liegt dem Archiv bei).
Wir haben allerdings bisher nur Grau, Kontrast und Helligkeit umgesetzt, wir sind eben keine Grafik Experten, wie Du
Blending, Glue usw. wären natürlich noch intessant.

Wäre schön, wenn es Crossplattform bleibt.

Gruß
Thomas

[ts-soft]

Schon Fortschritte?

[STARGÅTE]

Die Algorithmen an sich sind nicht das Problem, viel mehr Probleme macht da die Optimieren auf Geschwindigkeit.
Man sollte schließlich nicht mehrere Sekunden warten müssen.

Und gerade beim Glüh-Effekt, bei dem u.a. ein Gaußscher-Weichzeicher zum einsatz kommt, (der im übrigen auch schon fertig ist), kann es schon mehrere Sekunden dauern ... (bei "normal" großen Bildern).

ich kann aber zum Wochenende hin schon mal ein paar sachen hier posten ...

[STARGÅTE]

Ich habe mich nun erst mal dazu entschlossen Prozeduren ohne Masken zu schreiben.

Zur Zeit gibt es folgende Image-Filter:

• Helligkeit
  ImageBrightness(Image.i, Brightness.i) ; Helligkeit = [-255, 255]
• Intensität
  ImageIntensity(Image.i, Intensity.f) ; Intensität = [0, Inf[
• Entsättigen
  ImageDesaturation(Image.i, Mode.i) ; Modus = {Leuchtstärke, Helligkeit, Durchschnitt}
• Farbrotation
  ImageColorRotation(Image.i, Angle.f) ; Winkel = [0, 360]
• Einfärben
  ImageColorisation(Image.i, Hue.f, Saturation.f, Brightness.f) ; Farbton = [0, 360] , Sättigung = [0, 100] , Helligkeit = [-100, 100]
• Warmes Leuchten
  ImageGlow(Image.i, Brightness.f, Radius.f) ; Helligkeit = [0, 200] , Radius = [0, 20] (% zum Bild)

Der Code sollte ohne Debugger ausgeführt werden, da die Filder sonst erheblich mehr Zeit brauchen.



Einfach starten, über Datei-> Öffnen... ein Bild auswählen (32Bit-Support) und die Filter ausprobieren ...

Speichern gibs noch nicht, denn es sollte ja kein Grafikprogramm werden ^^, sondern nur eine Demo für die ImageFilter.

Code: Alles auswählen

Structure DrawingFilter
	Brightness.i
	Intensity.f
	Mode.i
	Angle.f
	Hue.f
	Saturation.f
	Value.f
EndStructure

#DrawingFilter_GrayFactorRed   = 0.299 
#DrawingFilter_GrayFactorGreen = 0.587
#DrawingFilter_GrayFactorBlue  = 0.114 

#ImageDesaturation_Luminosity = 1
#ImageDesaturation_Average = 2
#ImageDesaturation_Brightness = 3

Global DrawingFilter.DrawingFilter

;-

Procedure MaxColorValue(Value1=0, Value2=0, Value3=0, Value4=0)
	Protected MaxValue = 0
	If Value1 > MaxValue : MaxValue = Value1 : EndIf
	If Value2 > MaxValue : MaxValue = Value2 : EndIf
	If Value3 > MaxValue : MaxValue = Value3 : EndIf
	If Value4 > MaxValue : MaxValue = Value4 : EndIf 
	ProcedureReturn MaxValue
EndProcedure

Procedure MinColorValue(Value1=255, Value2=255, Value3=255, Value4=255)
	Protected MinValue = 255
	If Value1 < MinValue : MinValue = Value1 : EndIf
	If Value2 < MinValue : MinValue = Value2 : EndIf
	If Value3 < MinValue : MinValue = Value3 : EndIf
	If Value4 < MinValue : MinValue = Value4 : EndIf 
	ProcedureReturn MinValue
EndProcedure

Procedure.l DrawingFilter_HSV(Hue.f, Saturation.f, Value.f) ; [0,6], [0,1], [0,255]
	Protected H.i = Int(Hue)
	Protected f.f = (Hue-H)
	Protected p = Value * (1-Saturation)
	Protected q = Value * (1-Saturation*f)
	Protected t = Value * (1-Saturation*(1-f))
	Select H
		Case 1 : ProcedureReturn RGB(q,Value,p)
		Case 2 : ProcedureReturn RGB(p,Value,t)
		Case 3 : ProcedureReturn RGB(p,q,Value)  
		Case 4 : ProcedureReturn RGB(t,p,Value)
		Case 5 : ProcedureReturn RGB(Value,p,q)  
		Default : ProcedureReturn RGB(Value,t,p)
	EndSelect
EndProcedure 

;-

Procedure DrawingFilter_Brightness(X.i, Y.i, Mask.l, Object.l)
	Protected Red.i = Object&$FF + DrawingFilter\Brightness
	If Red > $FF : Red = $FF : ElseIf Red < $00 : Red = $00 : EndIf
	Protected Green.i = Object&$FF00 + DrawingFilter\Brightness<<8
	If Green > $FF00 : Green = $FF00 : ElseIf Green < $0000 : Green = $0000 : EndIf
	Protected Blue.i = Object&$FF0000 + DrawingFilter\Brightness<<16
	If Blue > $FF0000 : Blue = $FF0000 : ElseIf Blue < $000000 : Blue = $000000 : EndIf
	ProcedureReturn Object&$FF000000 | Red | Green | Blue
EndProcedure

Procedure DrawingFilter_Intensity(X.i, Y.i, Mask.l, Object.l)
	Protected Red.i = Red(Object)*DrawingFilter\Intensity
	If Red > $FF : Red = $FF : EndIf
	Protected Green.i = Green(Object)*DrawingFilter\Intensity
	If Green > $FF : Green = $FF : EndIf
	Protected Blue.i = Blue(Object)*DrawingFilter\Intensity
	If Blue > $FF : Blue = $FF : EndIf
	ProcedureReturn Object&$FF000000 | Red | Green<<8 | Blue<<16
EndProcedure

Procedure DrawingFilter_Desaturation_Luminosity(X.i, Y.i, Mask.l, Object.l)
	Protected Gray.i = #DrawingFilter_GrayFactorRed*Red(Object) + #DrawingFilter_GrayFactorGreen*Green(Object) + #DrawingFilter_GrayFactorBlue*Blue(Object)
	ProcedureReturn Object&$FF000000 | Gray | Gray<<8 | Gray<<16
EndProcedure

Procedure DrawingFilter_Desaturation_Average(X.i, Y.i, Mask.l, Object.l)
	Protected Gray.i = (Red(Object)+Green(Object)+Blue(Object))/3
	ProcedureReturn Object&$FF000000 | Gray | Gray<<8 | Gray<<16
EndProcedure

Procedure DrawingFilter_Desaturation_Brightness(X.i, Y.i, Mask.l, Object.l)
	Protected Max = MaxColorValue(Red(Object), Green(Object), Blue(Object))
	Protected Min = MinColorValue(Red(Object), Green(Object), Blue(Object))
	Protected Gray.i = (Min+Max)/2
	ProcedureReturn Object&$FF000000 | Gray | Gray<<8 | Gray<<16
EndProcedure

Procedure DrawingFilter_ColorRotation(X.i, Y.i, Mask.l, Object.l)
	Protected Red.i   = Red(Object)
	Protected Green.i = Green(Object)
	Protected Blue.i  = Blue(Object)
	Protected Max.i = MaxColorValue(Red,Green,Blue)
	Protected Min.i = MinColorValue(Red,Green,Blue)
	Protected Hue.f, Saturation.f = 0
	If Max : Saturation.f = 1.0*(Max-Min)/Max : EndIf
	If Max = Min
		Hue = 0
	ElseIf Max = Red
		Hue = 1.0*(Green-Blue)/(Max-Min)
	ElseIf Max = Green
		Hue = 1.0*(Blue-Red)/(Max-Min)+2
	Else  
		Hue = 1.0*(Red-Green)/(Max-Min)+4
	EndIf
	ProcedureReturn Object&$FF000000|DrawingFilter_HSV(Mod(6+Hue+DrawingFilter\Angle/60,6), Saturation, Max)
EndProcedure

Procedure DrawingFilter_Colorisation(X.i, Y.i, Mask.l, Object.l)
	Protected Gray.i = #DrawingFilter_GrayFactorRed*Red(Object) + #DrawingFilter_GrayFactorGreen*Green(Object) + #DrawingFilter_GrayFactorBlue*Blue(Object)
	Protected Hue.f = DrawingFilter\Hue
	Protected Saturation.f = DrawingFilter\Saturation
	Protected Value
	If DrawingFilter\Value > 0 :
		Gray = 255*DrawingFilter\Value + Gray*(1-DrawingFilter\Value)
	Else
		Gray = Gray*(1+DrawingFilter\Value)
	EndIf
	If Gray < 128
		Saturation = DrawingFilter\Saturation
		Value = Gray + DrawingFilter\Saturation*Gray
	Else
		Saturation = (255-Gray)/128 * DrawingFilter\Saturation
		Value = 255*DrawingFilter\Saturation + Gray*(1-DrawingFilter\Saturation)
	EndIf
	ProcedureReturn Object&$FF000000|DrawingFilter_HSV(Hue, Saturation, Value)
EndProcedure

;-

Procedure ImageBrightness(Image.i, Brightness.i)
	DrawingFilter\Brightness = Brightness
	StartDrawing(ImageOutput(Image))
	DrawingMode(#PB_2DDrawing_CustomFilter)
	CustomFilterCallback(@DrawingFilter_Brightness())
	Box(0, 0, ImageWidth(Image), ImageHeight(Image), $FF)
	StopDrawing()
EndProcedure

Procedure ImageIntensity(Image.i, Intensity.f)
	DrawingFilter\Intensity = Intensity
	StartDrawing(ImageOutput(Image))
	DrawingMode(#PB_2DDrawing_CustomFilter)
	CustomFilterCallback(@DrawingFilter_Intensity())
	Box(0, 0, ImageWidth(Image), ImageHeight(Image), $FF)
	StopDrawing()
EndProcedure

Procedure ImageDesaturation(Image.i, Mode.i=#ImageDesaturation_Luminosity)
	StartDrawing(ImageOutput(Image))
	DrawingMode(#PB_2DDrawing_CustomFilter)
	Select Mode
		Case #ImageDesaturation_Luminosity
			CustomFilterCallback(@DrawingFilter_Desaturation_Luminosity())
		Case #ImageDesaturation_Average
			CustomFilterCallback(@DrawingFilter_Desaturation_Average())
		Case #ImageDesaturation_Brightness
			CustomFilterCallback(@DrawingFilter_Desaturation_Brightness())
	EndSelect
	Box(0, 0, ImageWidth(Image), ImageHeight(Image), $FF)
	StopDrawing()
EndProcedure

Procedure ImageColorRotation(Image.i, Angle.f)
	DrawingFilter\Angle = Angle
	StartDrawing(ImageOutput(Image))
	DrawingMode(#PB_2DDrawing_CustomFilter)
	CustomFilterCallback(@DrawingFilter_ColorRotation())
	Box(0, 0, ImageWidth(Image), ImageHeight(Image), $FF)
	StopDrawing()
EndProcedure

Procedure ImageColorisation(Image.i, Hue.f, Saturation.f=50.0, Brightness.f=0.0)
	DrawingFilter\Saturation = Pow(Saturation/100,0.65)
	DrawingFilter\Hue = Hue/60
	DrawingFilter\Value = Brightness/100
	StartDrawing(ImageOutput(Image))
	DrawingMode(#PB_2DDrawing_CustomFilter)
	CustomFilterCallback(@DrawingFilter_Colorisation())
	Box(0, 0, ImageWidth(Image), ImageHeight(Image), $FF)
	StopDrawing()
EndProcedure

Procedure ImageGlow(Image.i, Brightness.f, Radius.f)
	Protected SizeX.i = ImageWidth(Image)-1, SizeY.i = ImageHeight(Image)-1
	Protected X.i, Y.i, XX.i, YY.i 
	Protected Dim Source.l(SizeX,SizeY)
	Protected Factor.f, Color.l, D.i, Div.f
	Protected Red.f, Green.f, Blue.f
	Radius * (ImageWidth(Image)+ImageHeight(Image))*Brightness/200/200
	StartDrawing(ImageOutput(Image))
	DrawingMode(#PB_2DDrawing_AllChannels)
	For Y = 0 To SizeY
		For X = 0 To SizeX
			Source(X,Y) = Point(X,Y)
		Next
	Next
	For Y = 0 To SizeY
		For X = 0 To SizeX
			Color = Source(X,Y)
			Factor = (#DrawingFilter_GrayFactorRed*Red(Color) + #DrawingFilter_GrayFactorGreen*Green(Color) + #DrawingFilter_GrayFactorBlue*Blue(Color))/255
			D = Factor*Radius
			X1 = X-D : If X1 < 0 : X1 = 0 : EndIf
			X2 = X+D : If X2 > SizeX : X2 = SizeX : EndIf
			Y1 = Y-D : If Y1 < 0 : Y1 = 0 : EndIf
			Y2 = Y+D : If Y2 > SizeY : Y2 = SizeY : EndIf
			Red = 0 : Green = 0 : Blue = 0 : Div = 0
			For YY = Y1 To Y2
				For XX = X1 To X2
					Color = Source(XX,YY)
					Div + 1
					Red + Red(Color)
					Green + Green(Color)
					Blue + Blue(Color)
				Next
			Next
			Red = Red/Div + Brightness*Factor
			If Red > 255 : Red = 255 : EndIf
			Green = Green/Div + Brightness*Factor
			If Green > 255 : Green = 255 : EndIf
			Blue = Blue/Div + Brightness*Factor
			If Blue > 255 : Blue = 255 : EndIf
			Plot(X, Y, RGBA(Red, Green, Blue, Source(X,Y)>>24))
		Next
	Next
	StopDrawing()
EndProcedure






;-
;- Beispiel
;-





Enumeration
	
	#Window 
	#ChildWindow
	
	#Menu
	#MenuItem_Open
	#MenuItem_Brightness
	#MenuItem_Intensity
	#MenuItem_Desaturation
	#MenuItem_ColorRotation
	#MenuItem_Colorisation
	#MenuItem_Glow
	
	#Gadget_Area
	#Gadget_Image
	#Gadget_SmallImage
	#Gadget_Accept
	#Gadget_TrackBar1
	#Gadget_TrackBar2
	#Gadget_TrackBar3
	
	#Image
	#SmallImage : #SmallImage2
	
EndEnumeration



UseJPEG2000ImageDecoder()
UseJPEG2000ImageEncoder()
UseJPEGImageDecoder()
UseJPEGImageEncoder()
UsePNGImageDecoder()
UsePNGImageEncoder()
UseTGAImageDecoder()
UseTIFFImageDecoder()

OpenWindow(#Window, 0, 0, 800, 600, "Image", #PB_Window_MinimizeGadget|#PB_Window_ScreenCentered|#PB_Window_MaximizeGadget|#PB_Window_SizeGadget)
CreateMenu(#Menu, WindowID(#Window))
MenuTitle("Datei")
MenuItem(#MenuItem_Open, "Öffnen...")
MenuTitle("Filter")
MenuItem(#MenuItem_Brightness, "Helligkeit")
MenuItem(#MenuItem_Intensity, "Intensität")
MenuItem(#MenuItem_Desaturation, "Entsättigen")
MenuItem(#MenuItem_ColorRotation, "Farbrotation")
MenuItem(#MenuItem_Colorisation, "Einfärben")
MenuItem(#MenuItem_Glow, "Warmes Leuchten")
ScrollAreaGadget(#Gadget_Area, 0, 0, WindowWidth(#Window), WindowHeight(#Window), 0, 0, 128, #PB_ScrollArea_BorderLess|#PB_ScrollArea_Center)
ImageGadget(#Gadget_Image, 0, 0, 0, 0, 0)

Global ChildWindowType

Procedure ChildWindow(Type, Name.s)
	ChildWindowType = Type
	CopyImage(#Image, #SmallImage) : ResizeImage(#SmallImage, 200, 200)
	OpenWindow(#ChildWindow, 0, 0, 560, 240, Name, #PB_Window_SystemMenu|#PB_Window_Tool|#PB_Window_WindowCentered, WindowID(#Window))
	Frame3DGadget(#PB_Any, 5, 5, 220, 230, "Vorschau")
	ImageGadget(#Gadget_SmallImage, 15, 25, 200, 200, ImageID(#SmallImage))
	Frame3DGadget(#PB_Any, 235, 5, 320, 200, "Parameter")
	ButtonGadget(#Gadget_Accept, 400, 215, 155, 20, "Übernehmen")
EndProcedure

Procedure Filter(Type, Image)
	If Image <> #Image
		CopyImage(#SmallImage, #SmallImage2)
		Gadget = #Gadget_SmallImage
	Else
		Gadget = #Gadget_Image
	EndIf
	Select Type
		Case #MenuItem_Brightness
			ImageBrightness(Image, GetGadgetState(#Gadget_TrackBar1)-255)
		Case #MenuItem_Intensity
			ImageIntensity(Image, GetGadgetState(#Gadget_TrackBar1)/100)
		Case #MenuItem_Desaturation
			ImageDesaturation(Image.i, GetGadgetState(#Gadget_TrackBar1))
		Case #MenuItem_ColorRotation
			ImageColorRotation(Image, GetGadgetState(#Gadget_TrackBar1))
		Case #MenuItem_Colorisation
			ImageColorisation(Image, GetGadgetState(#Gadget_TrackBar1), GetGadgetState(#Gadget_TrackBar2), GetGadgetState(#Gadget_TrackBar3)-100)
		Case #MenuItem_Glow
			ImageGlow(Image, GetGadgetState(#Gadget_TrackBar1), GetGadgetState(#Gadget_TrackBar2)/10)
	EndSelect
	SetGadgetState(Gadget, ImageID(Image))
EndProcedure

Define Event.i, FileName.s 

Repeat
	Event = WaitWindowEvent()
	Select Event
		Case #PB_Event_CloseWindow
			Select EventWindow()
				Case #Window
					End
				Case #ChildWindow
					CloseWindow(#ChildWindow)
			EndSelect
		Case #PB_Event_Menu
			Select EventMenu()
				Case #MenuItem_Open
					FileName = OpenFileRequester("Öffnen...", "", "Bilddatei (*.png;*.jpg;*.jpeg;*.bmp;*.tga;*.tiff)|*.png;*.jpg;*.jpeg;*.bmp;*.tga;*.tiff", 0)
					If FileName
						LoadImage(#Image, FileName)
						SetGadgetState(#Gadget_Image, ImageID(#Image))
						SetGadgetAttribute(#Gadget_Area, #PB_ScrollArea_InnerWidth, ImageWidth(#Image))
						SetGadgetAttribute(#Gadget_Area, #PB_ScrollArea_InnerHeight, ImageHeight(#Image))
						ResizeWindow(#Window, #PB_Ignore, #PB_Ignore, ImageWidth(#Image), ImageHeight(#Image)+MenuHeight())
					EndIf
				Case #MenuItem_Brightness
					ChildWindow(#MenuItem_Brightness, "Helligkeit")
					TextGadget(#PB_Any, 245, 25, 90, 20, "Helligkeit")
					TrackBarGadget(#Gadget_TrackBar1, 345, 25, 180, 20, 0, 510)
					SetGadgetState(#Gadget_TrackBar1, 255)
					Filter(#MenuItem_Brightness, #SmallImage2)
				Case #MenuItem_Intensity
					ChildWindow(#MenuItem_Intensity, "Intensität")
					TextGadget(#PB_Any, 245, 25, 90, 20, "Faktor")
					TrackBarGadget(#Gadget_TrackBar1, 345, 25, 180, 20, 0, 500)
					SetGadgetState(#Gadget_TrackBar1, 100)
					Filter(#MenuItem_Intensity, #SmallImage2)
				Case #MenuItem_Desaturation
					ChildWindow(#MenuItem_Desaturation, "Entsättigen")
					TextGadget(#PB_Any, 245, 25, 90, 20, "Modus")
					TrackBarGadget(#Gadget_TrackBar1, 345, 25, 180, 20, 1, 3)
					SetGadgetState(#Gadget_TrackBar1, 1)
					Filter(#MenuItem_Desaturation, #SmallImage2)
				Case #MenuItem_ColorRotation
					ChildWindow(#MenuItem_ColorRotation, "Farbrotation")
					TextGadget(#PB_Any, 245, 25, 90, 20, "Farbton")
					TrackBarGadget(#Gadget_TrackBar1, 345, 25, 180, 20, 0, 360)
					SetGadgetState(#Gadget_TrackBar1, 0)
					Filter(#MenuItem_ColorRotation, #SmallImage2)
				Case #MenuItem_Colorisation
					ChildWindow(#MenuItem_Colorisation, "Einfärben")
					TextGadget(#PB_Any, 245, 25, 90, 20, "Farbton")
					TrackBarGadget(#Gadget_TrackBar1, 345, 25, 180, 20, 0, 360)
					TextGadget(#PB_Any, 245, 55, 90, 20, "Sättigung")
					TrackBarGadget(#Gadget_TrackBar2, 345, 55, 180, 20, 0, 100)
					TextGadget(#PB_Any, 245, 85, 90, 20, "Helligkeit")
					TrackBarGadget(#Gadget_TrackBar3, 345, 85, 180, 20, 0, 200)
					SetGadgetState(#Gadget_TrackBar1, 0)
					SetGadgetState(#Gadget_TrackBar2, 50)
					SetGadgetState(#Gadget_TrackBar3, 100)
					Filter(#MenuItem_Colorisation, #SmallImage2)
				Case #MenuItem_Glow
					ChildWindow(#MenuItem_Glow, "Warmes Leuchten")
					TextGadget(#PB_Any, 245, 25, 90, 20, "Helligkeit")
					TrackBarGadget(#Gadget_TrackBar1, 345, 25, 180, 20, 0, 200)
					TextGadget(#PB_Any, 245, 55, 90, 20, "Radius")
					TrackBarGadget(#Gadget_TrackBar2, 345, 55, 180, 20, 0, 200)
					SetGadgetState(#Gadget_TrackBar1, 150)
					SetGadgetState(#Gadget_TrackBar2, 30)
					Filter(#MenuItem_Glow, #SmallImage2)
			EndSelect
		Case #PB_Event_SizeWindow
			ResizeGadget(#Gadget_Area, 0, 0, WindowWidth(#Window), WindowHeight(#Window)-MenuHeight())
		Case #PB_Event_Gadget
			Select EventGadget()
				Case #Gadget_Accept
					Filter(ChildWindowType, #Image)
					CloseWindow(#ChildWindow)
				Case #Gadget_TrackBar1, #Gadget_TrackBar2, #Gadget_TrackBar3
					Filter(ChildWindowType, #SmallImage2)
			EndSelect
			
	EndSelect
ForEver

Leider dauert das ImageGlow noch zu lange ... daran werde ich aber noch arbeiten!

[NicTheQuick]

Lustig, wenn ich den Code ausführe und auf Datei -> Öffnen... gehe, dann kommt dieser Fehler:

Code: Alles auswählen

FileName = OpenFileRequester("Öffnen...", "", "Bilddatei (*.png;*.jpg;*.jpeg;*.bmp;*.tga;*.tiff)|*.png;*.jpg;*.jpeg;*.bmp;*.tga;*.tiff", 0)

[03:28:42] [ERROR] Ungültiger Speicherzugriff.

///Edit:
Wenn ich die betroffene Zeile alleine ausführe, dann gibt es keine Probleme. Komisch.