Mini Kabibi Habibi

Current Path : C:/Users/ITO/AppData/Local/Programs/GIMP 2/share/locale/de/LC_MESSAGES/
Upload File :
Current File : C:/Users/ITO/AppData/Local/Programs/GIMP 2/share/locale/de/LC_MESSAGES/gegl-0.4.mo

��",A�
<���2��#ԭ�����!�'�-�3�9�?�E�K�Q�W�]�c�i�o�u�{�������������+��EѮ��!�-�>�N�T�+X���0��X��/� C�;d�7��6ذ��C)�m�}�����W��
���a��T�.*�.Y�����
��
����$׵���%�E�b�������)ض)�,�YC���	����	˷շ9۷��͸$��
��)�H�)Y���������>����x�!��!��Ѻ	�(��("�K�Ic����%B��h�����
�+�#E�i���8���R�(A�j����
9�&D�%k�#��#��ٿ���)��6��L�^�0c���!��3���)�1�L�&g�(��(��������
�
*�5�F�W�g�v�	~�
��
��
������
������
��P��E�N�a�q�v���������������
������
��
#�$.�S�
`�(k���	��������
���������*�
A�L�b�
o�}�����������������
��/�!F�
h�s�7�j��"�?.�Bn�Q��#�/'�	W�a�nq��������	���)�2�:�
C�N�-b�����
������"�������	���&�2�+5�a�+d���������
����	�����Y(�
����������"��0��	��2/�ib��������
����	����
������)�0�H�]�r�x�����1������ �#�=�S�	l�v��|�����&�.�6�>�
V�d�
p�~�����(����C��"&�"I�#l���0����"���L��d����<�!Q�
s�<~���C�����
����)��
	��	&�0�F�^�t���������)���.�:�?C���6��5��B��+?�k���G���������7�!N�Ip���A���*�(J�`s�'���������3����F�.N�}�����%��"��:��"+�N�g�/����-��������	�&�
,�
7�*B�
m�x�/��������$��P��L�T�&`�"��$������6��
1�?�E�Q�X�d�u�^��%����'�4�.I�	x�&��������	��	��,�-5�8c�1��#����.�43�0h�2��O���/$�T�m�%�t��v���)�� ����	���.�4�=��E�<�GC�4�����XH���������
������%	�/�
4�B�	Q�[�
j�x�����\��
�*�\<���������*��	��4�;�G�_�r�	��(��#�������� �7�
?�
M�![�M}�	����e��J�Q�m�v�e������*�0�B�b�v���������
�����������"�6B�Qy���.��
��	
�"�7�M�	Z�
d�uo��������5�F�W�^�e�|�������
���������%�5�E�V�p�|�����������
���������2'�
Z�h�m�t�{�����������
��-����
����
��/�$5�#Z�~�
������������"�';�c�${���5��e�Z� x�����.��W�w�
���������)�2�	O�Y�	h�r�������������
#�1�@�X�h�~�����
���������"�9�
>�	L�	V�`�
l��w�:�
>�L�[�	j�t�-����A�V�b�
i�t�����������

#.:I*V�2�=�!3DXs
����
���
@`1r%����-F^2n��� �D
%O=uf�<6&s6�:�*47&l8�3�/0HL
[iy�!�
����
	!'63^��+���	/	L	k	�	
�	�	�	&�	=�	T
Hg
k�
j?����(�G�
-+

Y
d
#m
�
�
-�
%�
"�
"1	FP_5~�����
9gEd�1VM�
��$��
,Gg������
���.	ISgs������5�-[F�����		 �2���	��4	9C
S
^
lz%�+��-�$+<R^n��%�	����"$����
*5<L
_jz�
���
��� '%Bht����	�	�
�� �	
#
5C2R��	�8�$�	4vK�O�	
"	-7Q^
ky������������ ��!3�"�"
�"�"#
#I#e#Hy#�#�#
�#�#&$3$P$U$i$}$�$�$*�$�$�$�$�$�$%%$%=(%f%k%�%�%#�%
�%
�%
�%
�%�%	&&#&
0&
>&
L&
Z&h&t&�&�&�&�&
�&�&�&�&''6'�='�'�'	((�!(p�(�G)��)�*�*�*�*�*�*�*�*N�*�M+��+b,t,�,	�,�,-�,�,�,�,�,
�,-
--O(-x-
�-�-�-
�-�-	�-%�-0.
6.$A.f.w.�.�.�..�.�./,/:E/�/#�/J�/!0N-0|0�0k�0g1"{1!�1"�1 �1#2(2<A2]~2+�2@3EI3�3�3�3�3�34�-4�4 �4
5-565=5F5O5\5n5�5C�5-�52�5
,676m?6n�67.7$?7	d7n7w7&�7�7�7�7�7�7�7
	88(8&48[8�{899"9!19S9e9�9�9�9�9(�9�9�9c:f:k:z:�:B�:D�:;	;%;);
=;�H;<R;<�<8�<�<)�<
== =7=L=b=x=�=�=%�=�=�=c�=\`>
�>
�>
�>
�>
�>�>!?"8?)[?Q�?K�?U#@:y@"�@�@!�@AA$A1AHAYAjA	vA�A�A�A�A}�A(B61B5hB�B�B�B+�B�B�BC=C&RC"yC?�C*�C4D:<D]wD"�D?�D48EBmEh�E	F#FECFF�FD�FG$G8GHG	YGcGpGV|G�G�G�GHH7HHHbH
nH?yH�H�H�H	�H�H�H�H(I&*IQIXIhI�Ib�I�I�IW�IUJrJ5�JD�JEKHK\K|K�K�K
�K�K�K1�K1
L<L/TL8�L�L�L
�L�L�M
�M	NN N$N;N
KNYNlN�N	�N�N�N�N�N
�N�NOO
)O
7OBO
NOYOiOvO�O �O��OBwP	�P�P�P�Pu�P dQ�QM�Q�Q�Q#R*5R`R|R'�RH�R2�R&S2SDSPS&nS%�S�ST�S!T0TMTdT|T��T*U&1UXUzkU�U�UV V5VEVWV]VfVmVuV|VE�V.�VW
WW3W?RW�W�W�W�W�W�W�W
�WX�X��Xd�YX3Zr�Z��Ze�[�&\3�\?]�X](�^/ _%P_'v_"�_
�_�_�_�_
�_``-`(D`m`r`N{`�`�`*�`
aa
)a4aKabaya�a'�a&�a4�a�,b�b�cRd7Vd
�d�d�d(�d
�d'�de9eQe.je	�e�eL�e(�e)f'If)qf*�f(�f'�f(g&@gtggO�g*,hWhdhqh6�h
�h�h�h�h�h	ii*i=iCinZi	�i�i�i�i�i�ij5jIj7[j�j�j�j�j
�j"�j
k8k;Vk�k4�k5�k4lPl�pl'JmSrm�m�m
�m�m�m�m�m.n4nTnannn�n	�n4�n
�n�n�n�nooo"o:1o
lowoo�oB�o>�o.'p	Vp?`p�p�p�p�p�p�p�p
qq.q>qUq
aqlqsqq�q	�q)�q*�q�q*�q%%r(Krtr�r	�r�r�r�r�r�r�r�r�rD�r@sIs$\s�s�s�sZ�st8t@tGtTtctptvt�t�t�t-�t	�t'�t1u5uGu
Xufuou�u�u�u�u�u�u�uv$>v(cv�v,�v-�v
w:wIw4Nw�w(�w.�w"�wx,xIJx�xD�x�xyy2yGy!fy)�y(�y(�yz-zdFz�z=�z{{6{K{>`{,�{"�{+�{0|1L|?~|=�|=�|2:}$m}�}�}P�}@~%Y~@~H�~)	&30Z.���(��--�=[���C��.��/(�xX�pсZB�����P�	H�R�
a��o��
���
�.�F�
[�i�
u���	��������
��Dž"̅������������	#�-�5�>�G�N�R�	[�4e���	��%��/ӆW�	[�e�����
�����Y�	b�l�s�z�
��	�������������.�����%�1�5�J�`�t���+��%ˊ��(�D�gc�ˋߋ(���7�5T�����\��5�)=�g�,~�����ٍ �4�
J�EU���������Ύ"ێ���
� �
'�5�>�V�l�|�<��Џ/�#�4�K�]�y�����
��0ʐ��3�F�\�q���
����L��	�="�`�>z���’ђ�����
������	ɓӓٓ����&�<7�t���_��,��%9�Z_�C��o��n�;��'Ŗ$�&�49�n�t���������—їޗ�!���9�W�u�����������!Ș
���
�� �-�BI���,��/ԙ����+�4�=�E�M�(T�(}�����'ܚ(�!-�O�^�
k�v���������̛ϛ���������(%�(N�w���'��(՜!�� �
/�:�W�	w�	��	������������ĝ
ѝ1ߝ�
 �'.�V�c�l�q�
������=����	� �'�-�C�U�a�p�,����.��$��F.� u�����<�����
�� �-/�]�q�w�/������
Ρ١���	��'�0�@�$_�����6��4͢�
�'�0�%P�v�	|�����
����������ãNȣN�xf�ߤ����F�#I�m�J�ʦҦ���G�V�i��������ͫ٫���������!�Gǭ1�A�^�d�j�p�v�|�����������������������ĮʮЮ֮ܮ���=�Q2�����������دޯ-��2�H�IȰ!�X4�1��V����W0�������ŲmҲ
@�0N�����$�%*�P�Y�w���%��3Ϸ�&�/2�$b�%�� ��$θ ��0�L�ja�̹����
�=��N�C�'Z���
����$��Ż.ջ���0�L6������#!�#E�3i�	��2��2ڽ
�c!����,5��b�B�I�U�s��$����"�H��C�WS�(�������,��/��&(�$O�t�%����-������|#���=����*�;.�j�7w�'��'��5��85�0n�������"��������
%�3�;�
J�
U�
`�k�"q���������j��	+�5�M�j�o�����	����������������
��'�6;�
r�}�3���������������*�=�R�g�}�������
��������	��$�0�=�U�i�|�$������I���,���B��J�n\�*��@��7�N�z_�����
�����	��"�4�	F�
P�[�3o���
����	����!�����
�	��)�6�B�-E�s�-v���$��#����
��
'�2�:�K�d^�����
��
����'�0-�
^�i�5��h����0�
�
$�2�J�W�c�w���������������&�<�DW���!��.��'�3�R�q������J�Y�_�g�o�w������
����
������'�)�B2�,u�!��"����9��8�1A�s�a�����~�"��I��#�� �K1�}�C�����������0�����
�'�$B�g�$����$�����>!�&`�����K����M��:J�L��7��
�!�e1���
������G��%)�ZO���S���/#�(S�k|�%��������<���D/�<t���������,�=2�1p���!��3��!�)6�`�)l�������	����	��	��A���*�26�i�u���2��i��,�1�:=�7x�*������~�������������
��j��-V���������/����"�� �!5�!W�y�������5��@��**�*U���/��6��2��4-�Rb���7�����./��^����~�(��$�������� �%�.�6�:N�V��<����v��$(�!M�o�v���	����+��������#� 3�T�o�j�����j��������1���-�6�C�]�,v���(��)�����&�:�T�\�
u�-��M��
��
���	��#������
z���,���#����"%�H�e�i�|���
������*��N'�hv��1�
�"�//�!_���
�������/�6�C�K�:[�!��
��
�����1J"j������-	FPdu�
�
�
�
��:�/39?EKQW]	c2m�
�����+�5+ai�����"�%1=o(��@�z�*���
��e�)09'j���/�=�
/	:	
M	 X	y		�	�	�	�	�	


*
:
Q
`
v
�
�
�

�
�
�
�
%DK
]k}���
�
�
�
�
#�
3CJJ`���%#Dh��	�������"�<>E{(���!5Wd��
�!���a�]?r+���.Mk�D���#'\K&�Z��*�;�-I@K�F�G1ef�/�<.k������)5L[l�
�.�0�:�#+
O>Z����
,AJW\-s?�V�F8tm�=b���/�Q�98R
�	�#��
�7�* #G k { � � $� B� !1!N!h!t!�!�!�!i�!v;"&�"�"��"�#�#�#)�#�#�#3$#;$'_$�$�$�$�$ �$ �$�$�$%%;%[%o%�%�%�%�%�%$�%&0&PK&�&j�&&'#?'c'{'�'�'�'	�'	�'�'�'�)�)�)�)**
*+*1*8*W*`*t*�*�*�*�*)�*4�**+9=+	w+�+�+
�+
�+�+�+�+-�+
),4,I,],�|,(-)->-U-[-h-t-�-�-�-�-�-�-�-..#.#;._.n.$u.�.�.�.,�.
//,/=/L/\/e/
v/�/�/*�/
�/�/�/005#0Y0h0x0C�0'�0	�0	�011�.1
�1A�1	,2
62	A2$K2p2�2�2�2 �2�2�2�2�2347,5d6	q78{8�8
�8�8�8
�8R�8F9Cd9�9!�9�9�9+	:"5:	X:b:x:�:	�:�:1�:�:
;;,;0;C;R;Z;`b;�;�;�;�;4�;0<?<N<]<
l<
z<
�<
�<�<�<�<�<�<�<�<=&=;=G=T=m=	�=
�=�=�=y�=<>N>
j>#x>��>�[?��?��@uAzA	�A�A�A
�A&�A!�AY�A�YB��B�C�C�C
�C�C9�C D?DFDMDVDgDwD�Dq�D
E)E6EOE
UE`E
uE.�E=�E
�E:�E9FOF fF�F
�F5�F�F�FGD,G'qG8�G_�G,2H__H�H�H~�H�mI&�I%J&;J$bJ+�J"�J9�J{K3�K=�KE�K#DL$hL"�L�L�L-�L�M'�M$N')NQNZN	bN	lN
vN�N�N�NF�N.�NG.O	vO	�Ok�Ol�OcP{P)�P	�P
�P�P�P
�P
QQ+(QTQaQ
yQ�Q�Q&�Q�Q��Q�R
�R�R&�RS$S@S
DSRSeS/tS$�S�So�S@TFT[TbTOrTO�TU
U	&U0UDU�TU0=V\nV�VJ�VW07WhW{W&�W�W(�W�WX+X>X1EX
wX�Xh�XjY
pY~Y
�Y	�Y�Y�Y(�Y/�Y7$ZY\ZT�Z^[<j[(�[�[�[�[\\-\D\V\h\	{\�\�\�\�\��\	c]Km]H�]^	^^9&^`^f^x^9�^&�^"�^?	_*I_4t_:�_^�_"C`?f`4�`B�`va
�a&�aT�aUbSub�b�b�bcc!c
.ci9c�c�c�c�c�c
dd1d
@dPKd	�d�d�d	�d�d�d�d&�d*e;eBeWeue[|e�e�ef�eQf!of<�f@�f@gPg eg!�g	�g�g�g�g�gH
hKVh�h;�hJ�hDiIi
Ui[`i�j�j�j�j�j�jk#k5kIk]k
rk}k�k
�k�k�k�k�k�k

l
l
&l1l=lTlglyl#�l��l?�m�m�mnnz*n�n�ns�n%Gomo.�o*�o�o
�o.	pN8pB�p�p�p�p q-!q.Oq~q\�q�q �qr5rSr�ors.%sTs�ast#t7tRtftvt�t	�t	�t�t�t�tQ�t."uQuYu#au$�ub�u
v$v)v5v
BvPvev
v�v��v�}wgcxX�xr$y��yf]z��z2�{I�{�|&�}-�}#�}%~'B~j~v~~~�~
�~�~�~�~-�~	!	+d5
��5����0/�`�w�����<ƀ/�J3��~�^@�	��n��=�V�*_���2��Ą.ׄ$�#+�O�4k�����j���8�X�v� ����ֆ��r0�a��6�<�
K�#Y�L}�ʈو���
��#�>�T�Y��x���"�6�C�R�a�6w���QŊ�&.�(U�~�
��(��ŋ:֋M�_�-|�F��K�0=��n�_�Qx�ʎЎ
֎�	�	���8�FQ�����+ď��;�	G�Q�W�s�	������
��7��������L/�>|�2��
�B��
<�J�	Q�[�u�%}�%��ɒ֒
�!��	�
"�-�9�H�	Q�
[�2f�)��Ó*Г+��#'�K�]�o�x����������� ��ĔaߔA�I�&]��������ȕ#W�	{�������������
і	ߖ�;��	2�+<�:h�����
ϗ	ݗ��"�A�_�}�����#˜)�&�7�DN�E��ٙT�G�6L���@��/��0�L�Sh���>ћ�'�>�Y�6r���4Ĝ���3�8F�|�$��[!�)}�*��Ҟ�H�5L�4��2��4�>�8^�A��?٠,�&F�m���P��P�4C�Gx�H��=	�(G�Mp�5��!��23�f�@y�>�� ��G�4b�5���ͥ�c�y���v�,�@�L�_��s�"�
)�4�@�FM�������ʪ۪
�
��	�	��/�6�T�X�_�f�m�t�{�����
��
��
����ū	ѫ۫
��S��
K�V�%e�6��X¬�'�F�`�l����G�O�	X�	b�l�	��	�����!��������B���
�)�
:�H�P�n�����ʰ9�-$�+R�#~� ��ñ��/d���/��ܲ#��? �`�!u�R��G�?2�&r�8��Ҵ%� �#1�?U���M������
�	�$)�N�Z�`�x��������ȶݶZ�N�=a�)��ɷ����0�L�c�Bu���4͸��!1�S�i�}�|���A#�e�A��źκ���	���Ļлܻ	���
��/�N�^�Ir���̼a�3J�(~�,��xԽKM����,3�3`�7��9̿=�:D����������
��
����&�=�$]�����	�����	��.�0� B�
c�	q�{���Q��"��6�.R�
��������	��	������	��7��2�H� c� ��+��-��	��	�
�$�%=�c�f�i�{�~�������	��	������	��7��2�I� d� ��+��-��	�

��%.�	T�	^�	h�r�u�x���������2������'�+�	;�E�R�r�����C��+��)�8�?�E�
]�k�
w�
��2����>��7�-I�Rw�5���
�S�
q� |���������?��#�@�F�)O�y���
��������	��������	�E'�
m�
x�9��;��/��	)�3�<�-Z���	������
������������T��T/�����g.���I��(�� �T>���������-���,�D�V�h���������������������u�36��SP
���Y��������p������e�Q0P�Yu��J�hDEF<�.5,���L(�����6��h����j�~�S-���4J�
�s��z��'q��A��*�=H1�G:c����J���k��d�����L���$�K�$�(������HD����/��C$���O�
�`_b�e��:��xX��B�����)�+N���;
N�$���������������!6s�{�W	���?g�Zj�U7���mU�&���DQkc��f�/81s�#(�|�����4ql�`�(��0�|]��%�`��{�&t�+m[sJE��X�|�	��$��8�F���\�
�hi\/IQ�=4���]��cdm����;RmpO�������ge����,�����d�"|
��<{5S�rc���!n�])��9�+H��~���0Bk��������f��v��@�u��'�����4�����M ���AY���,�q��t�r?��[���/}5DEG��}2����h��d�������?���l�>�:�0U���y� K�����V=���:0�P#���������������. �?RB�2C�YW��[�Z�n�� �^����v�d�b�u��gk���G��-M�����:���:�A���	.�x�����K(��DP���Z,����O��{�24�����h�
^���~��r����f��6���rF���t�+y���*�3pH��89@�)��@R�%�f������Hx/�;q�o-����A�pv?a�bM�I�yZ�,���wM������*q6+�9��]F	Vz��.X
D}������ P}b7-_2&!���>��G|���S�#������]n.e�IzM��|f����������t2l*�k*���6���7���Qw�'-��=�>�b$���(�����TU"#�����z�������*�lC���zK���2X�]T�A��c_P�o�@���3����`iI������~������L�g�������o%������Qer`'Nbi��?@ABC���
Q�	���XM�#�{�'q��39�����F��2 �>��=��O�)��^�W�����,�=aZ^���#��Y[�����V���J�"��E>5a��l����{3���""r�y�18����"Cn��4�����7bV�aT�!�\���x0Us���%��&�@N������'Es�9|�
�&�>E� dC>�m����������2c_����{'��gi���~y
~��/�����j�~?�zFR	�^U��NP�)�Bjo3��@CW��z�.���%�U�wd�����S��o*�@v���5�i�����o��c�w�p�G�N
GG�XQ_��"�!�8�������a���(!&�I�vJKB�J�9�u8�i�8�<��v����YTZA[ZW�%*$_�,������I%�|���������`�O��Z	_�Rw�S��;ex
����+XV��p��f�Pr�Gt���e�����y���m^6.�3���1=n���������V D��r��L�i�,x�u�O�R\����4��[���?�u���;�KH
YN�\L���	�L��c6���Y�-�Dj��nRoO����7T
�&\!��7U)�]�1���p_�&����tv��^����hj �4S���7�����������qt�}"�y%}�jkl�f5pq��������Tb
������
��<�7[���d�+�C1N��n���g#�mkT]T=<�:��V�����;�gl����H�;�t`��SF��zj+R���O:��k.MF~�0�5���e����x���<1�"���-/��{�^�uI����g�oB)9�f!LlW0Hw���-�mw�����������#}�Mn�a)�W<�L�	3J5�K/�`���a������E�h��\i
�'�hwxa����I�;!E�Qs�����y���>$����K��Xs1��v��WA��\�(������8B9��}[�<�V

unknown argument '%s' giving you help instead


%s has no %s property, properties: %s has no %s property.(1,1)(1,2)(1,3)(1,4)(1,5)(2,1)(2,2)(2,3)(2,4)(2,5)(3,1)(3,2)(3,3)(3,4)(3,5)(4,1)(4,2)(4,3)(4,4)(4,5)(5,1)(5,2)(5,3)(5,4)(5,5)-1 means autodetect on first audio fragment-1, 8, 16, 32 and 64 are the currently accepted values, -1 means auto0°180°1D Box Blur1D Gaussian-blur1D Wavelet-blur270°3x38 and 16 are the currently accepted values.90°A GeglVector representing the path of the strokeA fast approximation of bilateral filter, using a box-filter instead of a gaussian blur.A high value lowers the randomness of the noiseA layer in the traditional senseA pre-existing GeglBuffer to write incoming buffer data to.A rectangular source of a fixed size with a solid colorA stored lua script on disk implementing an operation.ACES RRTASAP DeformationASAP deformation is performed when TRUE, ARAP deformation otherwiseAbove thresholdAbsoluteAbsolute ColorimetricAbyss policyAccumulating motion blur using a kalman filter, for use with video sequences of frames.Active levelsAdapt an image, which may have a high dynamic range, for presentation using a low dynamic range. This is an efficient global operator derived from simple physiological observations, producing luminance within the range 0.0-1.0Adapt an image, which may have a high dynamic range, for presentation using a low dynamic range. This operator attenuates the magnitudes of local image gradients, producing luminance within the range 0.0-1.0. This tonemapping approach was originally presented by Raanan Fattal, in the 2002 SIGGRAPH paper: Gradient Domain High Dynamic Range Compression.Adapt an image, which may have a high dynamic range, for presentation using a low dynamic range. This operator constrains contrasts across multiple spatial frequencies, producing luminance within the range 0.0-1.0Adaptation to color variation across the imageAdaptation to light variation across the imageAddAdd CIE Lch NoiseAdd HSV NoiseAdd RGB NoiseAdd glow around bright areasAdd squared values sum to the outputAdditiveAdds a lens flare effect.Adjust LCH Hue, Chroma, and LightnessAdjust brightness in cornersAdjust exposure of highlightsAdjust exposure of shadowsAdjust saturation of highlightsAdjust saturation of shadowsAdjust the X tristimulus value for outputAdjust the Z tristimulus value for outputAdjust the black levelAdjusts the contrast of a grayscale image with a curve specifying contrast for intensity.Adobe RGB compatibleAlgorithmAlgorithm typeAlien MapAlignAlignment for multi-line text (0=Left, 1=Center, 2=Right)Aligns box of input rectangle with border of compositing target or aux' bounding-box border, if aux pad is not connected the op tries to figure out which bounding box' border applies.Allow splitting tilesAllows splitting tiles at hard edgesAlphaAlpha channelAlpha levelsAlpha parameter of MLS weightsAlpha percentileAlpha threshold for multilevel processingAlpha-weightingAlwaysAmbient lighting factorAmountAmount by which to scale the opacity of each transformed imageAmount of edge preservationAmount of edge preservation. This quantity is inversely proportional to the range standard deviation of the blur kernel.Amount of fourth-order distortionAmount of second-order distortionAmount to increase brightnessAmplitudeAmplitude for X axis (logarithmic scale)Amplitude for Y axis (logarithmic scale)Amplitude of the rippleAn already existing GeglBuffer to write incoming buffer data to, or NULL.An edge-preserving smoothing filter implemented with the Domain Transform recursive technique. Similar to a bilateral filter, but faster to compute.An error message in case of a failureAn explicit caching node, caches results and should provide faster recomputation if what is cached by it is expensive but isn't changing.AngleAngle BoostAngle of blur in degreesAngle of viewAngle offset for patternsAngle to rotate (counter-clockwise)Anisotropic smoothing operationAnti-alias oversampling factorAntialias using the Scale3X edge-extrapolation algorithmAntialiasingApparent depth of the rendered canvas effect; from 1 (very flat) to 50 (very deep)Apparent height of each tile (in pixels)Applies a color gradient.Applies a vignette to an image. Simulates the luminance fall off at the edge of exposed film, and some other fuzzier border effects that can naturally occur with analog photographyApply LensApply a generic 5x5 convolution matrixApply a sepia tone to the input imageApply a transformation recursively.Area balance between the two colorsArithmetic addArithmetic add covariantArithmetic xorArithmetic xor covariantAspect ratioAspect ratio to use, -0.5 = 1:2, 0.0 = 1:1, 0.5 = 2:1, -1.0 = 1:inf 1.0 = inf:1, this is applied after proportion is taken into account, to directly use squeeze factor as proportions, set proportion to 0.0.Audio codecAudio codec to use, or auto to use a good default based on container format.AutoAutocorrect D values for lens correction models.Autocorrect d valuesAuxiliary image buffer input pad.Available as a global variable 'user_value' in lua.AverageAverage diameter of each tile (in pixels)Average difference (total)Average difference (wrong)Average difference between all pixels.Average difference between wrong pixels.Avoid clipping and quantization (slower)Axis separation angleAzimuthBabl FormatBablFormat "%s" does not exist.BackgroundBackground ColorBackground colorBackground typeBailout lengthBalanceBand tuneBarnsley 1Barnsley 2Barnsley 3BaseBase enlargement exposureBase indexBayerBayer MatrixBayer patternBayer pattern used, 0 seems to work for some nikon files, 2 for some Fuji files.BehaviorBehavior of the opBelow thresholdBetaBilateral Box FilterBilateral FilterBilinearBitdepthBlackBlack angleBlack levelBlack on WhiteBlack patternBlack periodBlack point compensationBlack pulloutBlastBlend ModeBlend a chain of inputs using a maskBlock heightBlock sizeBlock size of deinterlacing rows/columnsBlock widthBlocksizeBloomBlueBlue Channel MultiplierBlue NoiseBlue Noise CovariantBlue ThresholdBlue and Yellow angleBlue and Yellow patternBlue and Yellow periodBlue angleBlue application modeBlue channelBlue contoursBlue frequencyBlue in Blue channelBlue in Green channelBlue in Red channelBlue inversionBlue levelsBlue patternBlue periodBlue phase shiftBlue preflashBlue sharp edgesBlue stretching factorBlue threshold of the input colorBlur gammaBlur levelsBlur neighboring pixels, but only in low-contrast areasBlur pixels in a direction, simulates blurring caused by moving camera in a straight line during exposure.Blur radiusBlur resulting from averaging the colors of a row neighborhood.Blur resulting from averaging the colors of a square neighborhood.Blur resulting from computing the median color in the neighborhood of each pixel.Blur the image around a focal pointBlur the image by a varying amount using a maskBlur typeBlurring factorBoost paper density to take advantage of increased dynamic range of a monitor compared to a photographic paperBorderBorder AlignBorder behaviorBothBottomBottom-leftBottom-rightBox BlurBoxBlurBrightenBrightnessBrightness ContrastBrightness and shifting/fattening of contoursBufferBuffer SinkBuffer SourceBuffer locationBump MapBumpmap (preserve original colors)CIE Lab/LchCIE YuvCMYKCMYK CyanCMYK KeyCMYK MagentaCMYK YellowCXCX (No effect in Mandelbrot and Sierpinski)CYCY (No effect in Mandelbrot and Sierpinski)CacheCalculate a distance transformCalculate b value from focalCameraCamera RGBCamera angle of viewCartesianCartoonCast FormatCast color spaceCast the data between input_format and output_format, both formats must have the same bppCell NoiseCenterCenter XCenter YCenter displacementCenter of Hue selection interval  Center the displacement around a specified pointCenteringCentering of the tilesChange exposure of an image in shutter speed stopsChange the color temperature of the image, from an assumed original color temperature to an intended one.Change to thisChanges the light level and contrast. This operation operates in linear light, 'contrast' is a scale factor around 50% gray, and 'brightness' a constant offset to apply after contrast scaling.Changes the saturationChannel MixerCharacteristic curveChebyshevCheckerboardChoose middleChromaChroma adjustmentChromatic adaptationCircleCircle depth in percentCircular Motion BlurCircular motion blurClampClamp deformationClip RGBClip base + fogClip base + fog to have a pure white output valueClip high pixel valuesClip low pixel valuesClip output to the input extentsClip result to input sizeClip to input extentsClip to the input extentClockwiseCloneClone a buffer, this is the same as gegl:nop but can get special treatment to get more human readable references in serializations/UI.Cluster sizeColorColor 1Color 2Color 3Color 4Color 5Color Assimilation GridColor EnhanceColor ModelColor OverlayColor RotateColor TemperatureColor averagingColor for the text (defaults to 'black')Color modelColor of paint to use for filling, use 0 opacity to disable fillingColor of paint to use for filling.Color of paint to use for strokingColor of paint to use for stroking.Color of the grid linesColor saturation dependent compression of periodColor spaceColor space to use for loaded dataColor to AlphaColor to fade transformed images towards, with a rate depending on its alphaColor to grayscale conversion, uses envelopes formed with the STRESS approach to perform local color-difference preserving grayscale generation.Color to peaksColor to renderColor to use for the "Only color" and "Color to peaks" modesColor used to fill the backgroundColor warpColors with a saturation less than this will treated as grayCombine ExposuresCombine multiple scene exposures into one high dynamic range image.CompactnessCompares if input and aux buffers are different. Global statistics are saved in the properties and a visual difference image is produced as a visual result. CompensateCompensate for darkeningCompletely randomize a fraction of pixelsComplexityComplexity factorComponentComponent 1 frequencyComponent 1 phase shiftComponent 2 frequencyComponent 2 phase shiftComponent 3 frequencyComponent 3 phase shiftComponent separator colorComponent to extractComponents of JPEG 2000 input don't matchComposite operation to useCompositionCompressCompress the effect on shadows/highlights and preserve midtonesCompressionCompression algorithm used for data stored in the swapCompute a relative displacement mapping from a strokeCompute gradient magnitude and/or direction by central differencesCompute integral and squared integral imageConnected ComponentsContainer formatContainer format to use, or auto to autodetect based on file extension.ContrastContrast CurveContrast boostContrast of high-passControl amount of noise for each RGB channel separatelyControls the number of iterationsControls the number of iterations; lower values give less plastic resultsConvert FormatConvert a specified color to transparency, works best with white.Convert color spaceConvert image to or from polar coordinatesConvert the data to the specified formatConvert the image into randomly rotated square blobs, somehow resembling a cubist painting styleConvert using black point compensation.Converts the input from an ICC color profile to a well defined babl format. The buffer's data will then be correctly managed by GEGL for further processing.Convolution MatrixCoordinates of lens centerCopies image performing lens distortion correction.Copy BufferCorrected estimation of the temperature of the light source in Kelvin.Corrects barrel or pincushion lens distortion.Correlated noiseCosineCounter-clockwiseCreate a grayscale (monochrome) imageCreate a kaleidoscope like effect.Create a new GEGL buffer to write the resulting rendering.Create a random cloud-like textureCreate a tileable outputCreate progressive JPEG imagesCreates a dropshadow effect on the input bufferCreates a long-shadow effectCreates an image filled with a plasma effect.CropCrops a buffer, if the aux pad is connected the bounding box of the node connected is used. When the crop area is configured to 0x0 at 0,0 and nothing is connected on aux, the bounding box of the node at the producing end of the input chain is used.Crossing LinesCubicCubismCurvatureCurveCurve TypeCurve typeCut image into paper tiles, and slide themCyan angleCyan filterCyan filter compensation for the negative imageCyan patternCyan periodDampnessDefault size of tiles in GeglBuffersDefaults to 'black', you can use transparency here to erase portions of an imageDegreesDeinterlaceDeinterlace horizontally or verticallyDelay in ms for last decoded frameDemosaic With Bimedian InterpolationDemosaic Without InterpolationDenoise DCTDenoising algorithm using a per-patch DCT thresholdingDensity boostDepthDepth firstDetailDetail bandDetail bandwidthDetail levelDetail scale, negative values diminish signal in detail band, positive values increase signal.Deviation from perfectly formed tilesDiamondDifference of GaussiansDifferentialDiffraction PatternsDigital halftoning with optional modulations. DirectionDirection of light-source (in degrees)Direction of the effectDirection vector's X componentDirection vector's Y componentDirectoryDisable OpenCLDiscretization bitsDisplaceDisplace multiplier for X or radial directionDisplace multiplier for Y or tangent (degrees) directionDisplace pixels as indicated by displacement mapsDisplace pixels in a ripple patternDisplacement modeDisplacement multiplier for the angular offsetDisplacement multiplier for the horizontal directionDisplacement multiplier for the radial directionDisplacement multiplier for the vertical directionDisplacement scaling factor (negative values refer to the inverse displacement)DisplayDisplay a string of text using pango and cairo.Display help informationDisplay on screenDisplay the input buffer in a window.Displays the input buffer in an SDL window (restricted to one display op/process, due to SDL implementation issues).Displays the input buffer in an SDL2 window (restricted to one display op/process, due to SDL2 implementation issues).Distance TransformDistort an image by whirling and pinchingDistort colors by random amountsDistort the image with wavesDistortedDitherDithering methodDittoDivisionDivisorDo a chain of operations, with key=value pairs after each operation name to set properties. And aux=[ source filter ] for specifying a chain with a source as something connected to an aux pad.Do a lerp, linear interpolation (lerp) between input and auxDo a stereographic/little planet transform of an equirectangular image.Do a transformation using SVG syntax transformation.Do panorama viewer rendering mapping or its inverse for an equirectangular input image. (2:1 ratio containing 360x180 degree panorama).Do the inverse mapping, useful for touching up zenith, nadir or other parts of panorama.Dodge/burn multiplierDon't over-expose highlightsDotsDraw a labyrinthDropshadowDullingEPITROCHOIDERROR: '%s' option expected argument
EdgeEdge AffectedEdge DetectionEdge bandEdge bandwidthEdge behaviorEdge detection algorithmEdge detection amountEdge detection behaviorEdge detection with control of edge thickness, based on the difference of two gaussian blursEdge handlingEdge preservationEdge scale, negative values diminish signal in detail band, positive values increase signal.EeeeeekEffect center offset in XEffect center offset in YEffect strengthEither to add to or subtract from the maskElevationElevation angle (degrees)EmbossEmboss TypeEmulate an oil paintingEnable preflashingEnables smoother tile outputEnd ColorEnd angle of the destination color rangeEnd angle of the source color rangeEnd x coordinateEnd y coordinateEngraveEnhance ShadowsEnhances fine details.EpsilonErase warpingError messageError reading row %d component %dEstimated temperature of the light source in Kelvin the image was taken with.EuclideanExchange colorExchange one color with another, optionally setting a threshold to convert from one shade to another.ExpandExpand tiles by this amountExponentExponent bufferExponent for processing; controls smoothness - can be scaled per pixel with a buffer on the aux2 pad.ExposureExposure valuesExpressed as standard deviation, in pixelsExtract ComponentExtract a color model componentFFmpeg Frame LoaderFFmpeg Frame SaverFFmpeg video frame importer.FFmpeg video output sinkFIRFPSFade colorFade opacityFadingFading (fixed length)Fading (fixed rate)Falloff linearityFattal et al. 2002 Tone MappingFeatures size for detail band, used for noise removal.Features size for edge band, used to compensate for loss of edges in detail pass.FileFile system path to ICC matrix profile to loadFill ColorFill PathFill each cell with a random colorFill full output areaFill opacityFill ruleFill rule.Fills each connected region of the input, separated from the rest of the input by a given color, with a unique color.FilterFilter widthFiniteFirst iterationFix images where every other row or column is missingFixed Gear TeethFlip XFlip YFlip the X coordinatesFlip the Y coordinatesFloatFloyd-SteinbergFocal of the cameraFocus BlurFocus-region inner limitFocus-region outer radiusFocus-transition midpointFoma Fomabrom CFoma Fomabrom NFoma Fomabrom SFoma Fomabrom SpFoma Fomabrom Variant IIIFont familyFont family (utf8)Font size in pixels.ForceForce tilingForeground ColorFractal ExplorerFractal TraceFractal typeFractional TypeFractional typeFrameFrame numberFrames per second, permits computing time vs frameFrames/secondFromFrom 0From 1From 2From 3From 4From 5From 6From 7From ColorFujicolor Crystal Archive Digital Pearl PaperFull Z RangeGEGL graphGEGL graph visualizer.GIF File LoaderGIF image loader.GammaGamma factor for blend-level spacingGamma factor for blur-level spacingGapGaussian BlurGaussian distributionGdkPixbuf SourceGdkPixbuf to useGeglBuffer file loader.GeglBuffer file writer.Generate a Bayer matrix patternGenerate a linear sinusoid patternGenerate a normal map from a height mapGenerate a tileable mapGenerate complex sinusoidal texturesGenerate diffraction patternsGenerate more accurate and consistent output (slower)Generates a buffer entirely filled with the specified color, use gegl:crop to get smaller dimensions.Generates a cellular texture.Generates a solid noise texture.Given a sparse user supplied tri-map and an input image, create a foreground alpha mat. Set white as selected, black as unselected, for the tri-map.Given a sparse user supplied tri-map and an input image, create a foreground alpha matte. Set white as foreground, black as background for the tri-map. Everything else will be treated as unknown and filled in.Global color saturation factorGlobal opacity value that is always used on top of the optional auxiliary input buffer.Glow radiusGlow strengthGlow-area brightness thresholdGlow-area edge softnessGradientGradient MapGradient smoothnessGradient threshold for detail enhancementGradient threshold for lowering detail enhancementGray modeGray thresholdGrayscaleGrayscale AveragingGreenGreen Channel MultiplierGreen ThresholdGreen and magenta angleGreen and magenta patternGreen and magenta periodGreen angleGreen application modeGreen channelGreen contoursGreen for Green channelGreen frequencyGreen in Blue channelGreen in Red channelGreen inversionGreen levelsGreen patternGreen periodGreen phase shiftGreen preflashGreen sharp edgesGreen stretching factorGreen threshold of the input colorGridGrid rendererGrid sizeGrow areaGrow radiusGrow shapeHDR to SDR proofing filter/mapping curve that is an approximation of the ACES RRT (Reference Rendering Transform). When feeding scene-refereed imagery into this op, the result is suitable for display referred transform to sRGB or output display using regular ICC matric profiles as the ODT. Note that for the time being, this is a luminance only approximation of the ACES RRT; without desaturation of highlights and shadows nor red hue modifications.HSLHSL LightnessHSL SaturationHSV SaturationHSV ValueHalftoning/dot pattern to useHardcoded characteristic curve and color dataHardnessHardness of the brush, 0.0 for a soft brush, 1.0 for a hard brushHeavily distort images colors by applying trigonometric functions to map color values.HeightHeight MapHeight for rendered imageHeight of blocks in pixelsHeight of grid lines in pixelsHeight of the generated bufferHeight of the tileHexHexagonsHigh Pass FilterHigh inputHigh limitHigh outputHigh precisionHigh qualityHigh values give more variation in detailsHigh-resolution edge detectionHigher values increase the magnitude of the effectHigher values restrict the effect to fewer areas of the imageHighest luminance level in outputHighlight factorHighlight thresholdHighlight threshold (high)Highlight threshold (low)HighlightsHighlights color adjustmentHistogram sizeHole PercentHorizontalHorizontal camera panningHorizontal displacementHorizontal extentHorizontal justification 0.0 is left 0.5 centered and 1.0 right.Horizontal offsetHorizontal offset (from origin) for start of gridHorizontal offset of blocks in pixelsHorizontal pattern scaleHorizontal positionHorizontal position in pixelsHorizontal scale factorHorizontal shadow offsetHorizontal shear amountHorizontal sizeHorizontal size ratio of a pixel inside each blockHorizontal spread amountHorizontal texture sizeHorizontal translationHorizontal width of cells pixelsHow areas outside the input are considered when calculating distanceHow close we are to image proportionsHow far out vignetting goes as portion of half image diagonalHow far the hole is from the center of the moving gear. 100 means that the hole is at the gear's edge.How image edges are handledHow many inks to use just black, rg, rgb (additive), or cmykHow many pixels of space between itemsHow much horizontal offset should applied to the pasteHow much memory to (approximately) use for caching imageryHow much of common gray to pull out of CMYHow much vertical offset should applied to the pasteHow the gaussian kernel is discretizedHow to align items, 0.0 is start 0.5 middle and 1.0 end.How to deal with pixels outside of the input bufferHow to determine what to fill (nonzero|evenodd)How to fill superpixelsHueHue adjustmentHue frequencyHue phase shiftHue selection centerHue selection widthHue value for above gray settingsHue-ChromaICC File LoaderICC profile loader.ICC profile saverIIRIcon titleIcon to be used for output windowIf set, the pattern generated will tileIf set, the pattern will be a little more distortedIf you want centerIgnoreIgnored. Always uses center of input bufferIlford Ilfobrom Galerie FB 1Ilford Ilfobrom Galerie FB 2Ilford Ilfobrom Galerie FB 3Ilford Ilfobrom Galerie FB 4Ilford Multigrade IV RC DeluxeIlluminant adjustmentIllusionIllusion typeImageImage GradientImage Magick wrapper using the png op.Image blending operation 'average' (<tt>c = (cA + aB)/2</tt>)Image blending operation 'blend-reflect' (<tt>c = cB>=1.0?1.0:cA*cA / (1.0-cB)</tt>)Image blending operation 'negation' (<tt>c = 1.0 - fabs(1.0-cA-cB)</tt>)Image blending operation 'soft-burn' (<tt>c = (cA+cB<1.0)?0.5*cB / (1.0 - cA):1.0-0.5*(1.0 - cA) / cB</tt>)Image blending operation 'soft-dodge' (<tt>c = (cA+cB<1.0)?0.5*cA / (1.0 - cB):1.0-0.5*(1.0 - cB)/cA</tt>)Image blending operation 'subtractive' (<tt>c = cA+cB-1.0</tt>)Image file directory (subfile)Image resampling method to use, for good results with double resampling when retouching panoramas, use nearest to generate the view and cubic or better for the inverse transform back to panorama.Impact each channel with the same amountIncrease contrast for papers with fixed contrast (usually color papers)Independent RGBIndex of component flagging unlabelled pixelsIndex stepInfiniteInfinitely repeats the input image.Input bufferInput formatInput luminance level to become lowest outputInput luminance level to become whiteInput pad, for image buffer input.Integral ImageIntended temperatureIntensityIntensity ModeInter-tile spacing (in pixels)Interpolate between Manhattan and Euclidean distance.Interpolation Color SpaceInvalid graph, abort.
Inverse transformInvertInvert bumpmapInvert componentInvert in Perceptual spaceInvert maskInvert the components (except alpha) in linear light, the result is the corresponding "negative" image.Invert the components (except alpha) perceptually, the result is the corresponding "negative" image.Invert the extracted componentInvert the separator regionInvert the value component, the result has the brightness inverted, keeping the color.Inverted imageIterationsJPEG 2000 File LoaderJPEG 2000 image loader using jasper.JPEG File LoaderJPEG File SaverJPEG compression quality (between 1 and 100)JPEG image loader using libjpegJPEG image saver, using libjpegJXJYJoints colorJuliaJulia seed X value, positionJulia seed Y value, positionJustificationK-means SegmentationKaleidoscopic MirroringKeepKeep RGB pixels values inside a specific rangeKeep SignKeep blue componentKeep colorsKeep component 1Keep component 2Keep component 3Keep even fieldsKeep even or odd fieldsKeep green componentKeep hue componentKeep image unchanged, where not affected by the lens.Keep lightness componentKeep negative values in result; when off, the absolute value of the result is used instead.Keep odd fieldsKeep original surroundingsKeep red componentKeep saturation componentLAB ALAB BLAB LLCH C(ab)LCH H(ab)LCMS From ProfileLabels propagation by watershed transformation. Output buffer will keep the input format. Unlabelled pixels are marked with a given flag value (by default: last component with NULL value). The aux buffer is a "Y u8" image representing the priority levels (lower value is higher priority). If aux is absent, all labellized pixels have the same priority and propagated labels have a lower priority.LambdaLaplaceLaplacian Edge DetectionLarge 3x3Large staggeredLayerLeadingLeftLengthLength of blur in pixelsLensLens BlurLens DistortionLens FlareLens center XLens center YLens refraction indexLet origin point to be the middle oneLevel of emphasis on image gradient detailsLevel of smoothnessLevel that full transparency should representLevelsLight adaptationLight angle (degrees)Light colorLight directionLight frequency (blue)Light frequency (green)Light frequency (red)Lighten shadows and darken highlightsLightnessLightness adjustmentLightness frequencyLightness phase shiftLike a gaussian blur; but where the contribution for each neighborhood pixel is also weighted by the color difference with the original center pixel.Limit deformation in the image area.Limit exposureLimit line widthLineLine ProfileLine heightLine thicknessLine widthLinearLinear GradientLinear Motion BlurLinear RGBLinear SinusoidLinear gradient rendererLinear maskLinear outputLinear-premultipliedLinear-premultiplied-if-alphaLittle PlanetLoHaloLoad an SVG file using librsvgLoad failedLoadedLog of the error weightingLog2 of source's discretization stepsLogarithmicLogarithmic spiral baseLoglog smoothingLong ShadowLong staggeredLoopLow inputLow limitLow outputLower thresholdLowest luminance level in outputLua errorMLS WeightsMLS Weights AlphaMagenta angleMagenta filterMagenta filter compensation for the negative imageMagenta patternMagenta periodMagnitudeMagnitude of contrast scaling >1.0 brighten < 1.0 darkenMagnitude of random color variationsMainMake GrayMake Seamlessly tileableMake a turbulent noiseMake the input buffer seamlessly tileable. The algorithm is not content-aware, so the result may need post-processing.MakerMakes each linear RGB component be the absolute of its value, fabs(input_value)Man O WarMandelbrotManhattanMantiuk 2006 Tone MappingMap AbsoluteMap RelativeMap backwardsMap from topMap the image to a circleMaskMask RadiusMask radiusMask radius bufferMath operation add, performs the operation per pixel, using either the constant provided in 'value' or the corresponding pixel from the buffer on aux as operands. The result is the evaluation of the expression result = input + valueMath operation divide, performs the operation per pixel, using either the constant provided in 'value' or the corresponding pixel from the buffer on aux as operands. The result is the evaluation of the expression result = value==0.0f?0.0f:input/valueMath operation gamma, performs the operation per pixel, using either the constant provided in 'value' or the corresponding pixel from the buffer on aux as operands. The result is the evaluation of the expression result = (input >= 0.0f ? powf (input, value) : -powf (-input, value))Math operation multiply, performs the operation per pixel, using either the constant provided in 'value' or the corresponding pixel from the buffer on aux as operands. The result is the evaluation of the expression result = input * valueMath operation subtract, performs the operation per pixel, using either the constant provided in 'value' or the corresponding pixel from the buffer on aux as operands. The result is the evaluation of the expression result = input - valueMathematical method for reconstructing pixel valuesMatting GlobalMatting LevinMaxMax. IterationsMax. deltaMaximal amount of refinement points to be used for the interpolation meshMaximal blur radiusMaximal scale of refinement points to be used for the interpolation meshMaximum EnvelopeMaximum amount to shiftMaximum deltaMaximum differenceMaximum difference between two pixels.Maximum number of iterationsMazeMaze algorithm typeMean Curvature BlurMedian BlurMetadataMetricMetric to use for the distance calculationMiddle value to peaksMidpointMidpoint (relative)MinMinimum EnvelopeMirror rotationMirrorsMixMixing ratio, read as amount of aux, 0=input 0.5=half 1.0=auxModeMode of displacementMode of value propagationModelModel - basic element we operate onModel alpha aModel alpha bModel alpha cModel alpha dModel blue aModel blue bModel blue cModel blue dModel green aModel green bModel green cModel green dModel red aModel red bModel red cModel red dModule '%s' load error: %sModule errorMono MixerMonochrome channel mixerMore black (smaller value)More opaqueMore transparentMore white (larger value)MosaicMosaic is a filter which transforms an image into what appears to be a mosaic, composed of small primitives, each of constant color and of an approximate size.Move pixelsMove pixels around randomlyMove rateMoving Gear TeethMultiplication factor for desired rotation of the local space for texture, the way this is computed makes it weak for desaturated colors and possibly stronger where there is color.Multipurpose file loader, that uses other native handlers, and fallback conversion using Image Magick's convert.Multipurpose file saver, that uses other native save handlers depending on extension, use the format specific save ops to specify additional parameters.NULL or a GeglBuffer containing cached rendering results, this is a special buffer where gegl_buffer_list_valid_rectangles returns the part of the cache that is valid.NameNativeNear-zNearestNegative DarkroomNeighborhoodNeighborhood alpha percentileNeighborhood color percentileNeighborhood radius, a negative value will calculate with inverted percentilesNeighborhood taken into account, for enhancement ideal values are close to the longest side of the image, increasing this increases the runtimeNeighborhood taken into account, this is the radius in pixels taken into account when deciding which colors map to which gray valuesNeighborhood typeNeon Edge DetectionNeverNewsprintNo OperationNo operation (can be used as a routing point)No such op '%s'NoHaloNodeNoiseNoise PickNoise ReductionNoise SlurNoise SpreadNoise reducing edge preserving blur filter based on Symmetric Nearest NeighborsNoise standard deviationNon-linearNon-linear componentsNoneNormal MapNormal compositingNormalizeNormalize output to range 0.0 to 1.0.Normalize output to the range [base,base + step]Not loadedNumPy (Numerical Python) image saverNumPy File SaverNumber of blend levelsNumber of blur levelsNumber of clustersNumber of colorsNumber of computations for grayscale averagingNumber of contours (blue)Number of contours (green)Number of contours (red)Number of curve sampling points.  0 for exact calculation.Number of differing pixels.Number of downsampled levels to useNumber of filtering iterations. A value between 2 and 4 is usually enough.Number of frames in gif animationNumber of frames in video, updates at least when first frame has been decoded.Number of intensitiesNumber of iterationsNumber of iterations, a higher number of iterations provides a less noisy rendering at a computational costNumber of iterations, a higher number of iterations provides less noisy results at a computational costNumber of levels for alpha channelNumber of levels for blue channelNumber of levels for green channelNumber of levels for red channelNumber of levels to perform solvingNumber of mirrors to useNumber of pairs; higher number preserves more acute featuresNumber of periods per tile, this tiling avoids high frequency anomaly that angle boost causesNumber of samples along each axis per pixelNumber of samples that are averaged for antialiasing the result.Number of samples to do per iteration looking for the range of colorsNumber of sharp edges (blue)Number of sharp edges (green)Number of sharp edges (red)Number of spokesNumber of subdivisionsNumber of teeth in fixed gear.Number of teeth in moving gear. Radius of moving gear, relative to radius of fixed gear, is determined by the proportion between the number of teeth in gears.Object providing image metadataObject to receive image metadataObject to supply image metadataOctagonsOffsetOffset XOffset YOffset angleOffset for X axisOffset for Y axisOilifyOne of: sRGB, Adobish, Rec2020, ProPhoto, Apple, ACEScg, ACES2065-1One or more of R, G, B components are missingOne or more of R, G, B components have signed dataOnly colorOpacityOpacity of stroke, note, does not behave like SVG since at the moment stroking is done using an airbrush toolOpacity of stroke, note, does not behave like SVG since at the moment stroking is done using an airbrush tool.Opacity thresholdOpen GEGL BufferOperate on linearized RGB color dataOperationOptimizeOrientationOrigin point for the polar coordinatesOrigin-xOrigin-yOriginal temperatureOut-of-focus blur radiusOutput ModeOutput compositionOutput formatOutput in a fileOutput modeOutput pad for generated image buffer.Overall brightness of the imageOverride the specified color space setting a pointer to a format override the string property and setting an aux pad overrides both. PDF page decoderPNG File LoaderPNG File SaverPNG compression level from 1 to 9PNG image loader.PNG image saver, using libpngPPIPPM File LoaderPPM File SaverPPM image loader.PPM image saver (Portable pixmap saver.)PSSquare (or Euclidian) dotPackPacks an image horizontally or vertically next to each other with optional gap, aux right of input.PagePage to renderPagesPaint SelectPaint a color overlay over the input, preserving its transparency.Paints each non-seed pixel with the color of the nearest seed pixel.PairsPalettizePanPanorama ProjectionPaper TileParametric band equalizer for tuning frequency bands of image, the op provides abstracted input parameters that control two difference of gaussians driven band pass filters used as adjustments of the image signal.Parse/compile error, if any.Parsed commandline:
	mode:   %s
	file:   %s
	xml:    %s
	output: %s
	rest:   %s
	
PasswordPassword to use for decryption of PDF, or blank for nonePaste belowPaste transformed images below each otherPatch sizePathPath of GeglBuffer file to load.Path of file to loadPath of file to load.Path of file to save.Path of video file to loadPath to v4l devicePatternPattern amplitude (logarithmic scale)Pattern rotationPattern rotation anglePer pixel buffer for modulating the exponent parameter, expecting a scaling factor in range 0.0-1.0Per pixel buffer for modulating the mask radius, expecting a scaling factor in range 0.0-1.0Percent BlackPercent WhitePercent blackPercentilePerceptualPerceptual-premultipliedPerceptual-premultiplied-if-alphaPerform graphcut in a local regionPerform shadows and highlights correctionPerforms a grayscale2color demosaicing of an image, using bimedian interpolation.Performs a naive grayscale2color demosaicing of an image, no interpolation.Performs an averaging of neighboring pixels with the normal distribution as weightingPerforms edge detection using a Gaussian derivative methodPerforms n-point image deformationPeriodPeriod (wavelength) of the ripplePeriod for X axisPeriod for Y axisPerlin NoisePerlin noise generatorPhase for X axisPhase for Y axisPhase shiftPhotocopyPiecewise BlendPinchPinch amountPixbufPixel level filter/composer scripting prototyping with lua. See http://pippin.gimp.org/image-processing/ for further details.PixelizePixels values higher than this limit will be set to itPixels values lower than this limit will be set to itPlasmaPoint/pixels per inchPointerPointer to flag value for unlabelled pixelsPolarPolar CoordinatesPolarizationPorter Duff compositing operation src-in (formula:   cA * aB)Porter Duff operation clear (d = 0.0f)Porter Duff operation dst (d = cB)Porter Duff operation dst-atop (d = cB * aA + cA * (1.0f - aB))Porter Duff operation dst-in (d = cB * aA)Porter Duff operation dst-out (d = cB * (1.0f - aA))Porter Duff operation dst-over (d = cB + cA * (1.0f - aB))Porter Duff operation over (also known as normal mode, and src-over) (d = cA + cB * (1 - aA))Porter Duff operation src (d = cA)Porter Duff operation src-atop (d = cA * aB + cB * (1.0f - aA))Porter Duff operation src-out (d = cA * (1.0f - aB))Porter Duff operation xor (d = cA * (1.0f - aB)+ cB * (1.0f - aA))Position of the light source which lightens the canvas: Top-right, Top-left, Bottom-left or Bottom-rightPosterizePower used to stretch the blendPreflash the negative with blue light to reduce contrast of the printPreflash the negative with green light to reduce contrast of the printPreflash the negative with red light to reduce contrast of the printPreserve ModelPreserve luminosityPrewitt compassPrim's algorithmPrint XMLProPhoto RGBProgressivePropagate certain values to neighboring pixels. Erode and dilate any color or opacity.Propagate to bottomPropagate to leftPropagate to rightPropagate to topPropagating alpha channelPropagating ratePropagating value channelProperties:ProportionPut the top row in the middle and the bottom row on the outsideQualityRGBRGB BlueRGB GreenRGB RedRGBE File LoaderRGBE File SaverRGBE image loader (Radiance HDR format).RGBE image saver (Radiance HDR format)RadialRadial GradientRadial gradient rendererRadiusRadius (1.0 is the largest circle that fits in the image, and 2.0 goes all the way to the corners)Radius 1Radius 2Radius of circle around pixel, can also be scaled per pixel by a buffer on the aux pad.Radius of effect (in pixels)Radius of fixed gearRadius of row pixel region, (size will be radius*2+1)Radius of square pixel region, (width and height will be radius*2+1)Radius of square pixel region, (width and height will be radius*2+1).Radius of supernovaRadius of the processing windowRadius of the wavelet blurRandomRandom CovariantRandom hueRandom seedRandomization (%)Randomize hue, saturation and value independentlyRandomize lightness, chroma and hue independentlyRandomly Shuffle PixelsRandomly interchange some pixels with neighborsRandomly slide some pixels downward (similar to melting)RankRatioRaw formatRaw image loader, wrapping dcraw with pipes, provides the raw bayer grid as grayscale, if the fileformat is .rawbayer it will use this loader instead of the normal dcraw loader, if the fileformat is .rawbayerS it will swap the returned 16bit numbers (the pnm loader is apparently buggy)ReadRead/WriteRectangleRecursive TransformRedRed Channel MultiplierRed Eye RemovalRed ThresholdRed and cyan angleRed and cyan patternRed and cyan periodRed angleRed application modeRed channelRed contoursRed eye thresholdRed frequencyRed in Blue channelRed in Green channelRed in Red channelRed inversionRed levelsRed patternRed periodRed phase shiftRed preflashRed sharp edgesRed stretching factorRed threshold of the input colorReduce the number of colors in the image, by reducing the levels per channel (colors and alpha). Different dithering methods can be specified to counteract quantization induced banding.Reduces the number of levels in each color component of the image.ReferenceRefinement scaleRefinement stepsReflectReflect an image about a line, whose direction is specified by the vector that is defined by the x and y properties. Reflect the pattern horizontallyRegions sizeRegularize geometry at a speed proportional to the local mean curvature valueReinhard 2005 Tone MappingRelative ColorimetricRelative brightness change in stopsRelative brightness of each exposure in EVRelative highlight strengthRemapRemaps the intensity range of the imageRemix colors; by defining relative contributions from source components.Remove the red eye effect caused by camera flashesRender PathRender SpyrographRender TextRender a checkerboard patternRendered height in pixels. (read only)Rendered width in pixels. (read only)Rendering intentRendering of multiple different fractal systems, with configurable coloring options.Rendering typeRenders a Spyrograph patternRenders a brush strokeRenders a filled regionRenders a vector strokeRenders luminance profiles for red green and blue components along the specified line in the input buffer, plotted in a buffer of the specified size.RepeatReplace a range of colors with anotherReplacement color.Repositions the buffer (with subpixel precision), if integer coordinates are passed a fast-path without resampling is usedResampling methodRescale overall image sizeReset originResolution in pixelsResult rotationRetain tilebilityRightRigidityRippleRobertsRotateRotate on centerRotate the buffer around its center, taking care of possible offsets.Rotate the buffer around the specified origin.RotatedRotationRotation applied to the mirrorsRotation applied to the resultRotation blur angle. A large angle may take some time to renderRough tile surfaceRoundSDL DisplaySDL2 DisplaySVG File LoaderSVG Hue RotateSVG Luminance to AlphaSVG MatrixSVG SaturateSVG blend operation color-burn (<code>if cA * aB + cB * aA <= aA * aB: d = cA * (1 - aB) + cB * (1 - aA) otherwise: d = (cA == 0 ? 1 : (aA * (cA * aB + cB * aA - aA * aB) / cA) + cA * (1 - aB) + cB * (1 - aA))</code>)SVG blend operation color-dodge (<code>if cA * aB + cB * aA >= aA * aB: d = aA * aB + cA * (1 - aB) + cB * (1 - aA) otherwise: d = (cA == aA ? 1 : cB * aA / (aA == 0 ? 1 : 1 - cA / aA)) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG blend operation darken (<code>d = MIN (cA * aB, cB * aA) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG blend operation difference (<code>d = cA + cB - 2 * (MIN (cA * aB, cB * aA))</code>)SVG blend operation exclusion (<code>d = (cA * aB + cB * aA - 2 * cA * cB) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG blend operation hard-light (<code>if 2 * cA < aA: d = 2 * cA * cB + cA * (1 - aB) + cB * (1 - aA) otherwise: d = aA * aB - 2 * (aB - cB) * (aA - cA) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG blend operation lighten (<code>d = MAX (cA * aB, cB * aA) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG blend operation overlay (<code>if 2 * cB > aB: d = 2 * cA * cB + cA * (1 - aB) + cB * (1 - aA) otherwise: d = aA * aB - 2 * (aB - cB) * (aA - cA) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG blend operation plus (<code>d = cA + cB</code>)SVG blend operation screen (<code>d = cA + cB - cA * cB</code>)SVG blend operation soft-light (<code>if 2 * cA < aA: d = cB * (aA - (aB == 0 ? 1 : 1 - cB / aB) * (2 * cA - aA)) + cA * (1 - aB) + cB * (1 - aA); if 8 * cB <= aB: d = cB * (aA - (aB == 0 ? 1 : 1 - cB / aB) * (2 * cA - aA) * (aB == 0 ? 3 : 3 - 8 * cB / aB)) + cA * (1 - aB) + cB * (1 - aA); otherwise: d = (aA * cB + (aB == 0 ? 0 : sqrt (cB / aB) * aB - cB) * (2 * cA - aA)) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG color matrix operation svg_huerotateSVG color matrix operation svg_luminancetoalphaSVG color matrix operation svg_matrixSVG color matrix operation svg_saturateSVG style description of transformSample pointsSamplerSampler used internallySamplesSaturationSaturation adjustmentSaturation frequencySaturation phase shiftSaturation value for above gray settingsSaveSawtoothScalar threshold level (overridden if an auxiliary input buffer is provided.).ScaleScale 1:1 sizeScale factor to make rendering size biggerScale of the imageScale ratioScale sizeScale size keep aspectScale value for x axisScale value for y axisScale, strength of effectScale3X AntialiasingScales the buffer according to a ratio.Scales the buffer according to a size.Scales the buffer to a size, preserving aspect ratioScales the components of the buffer to be in the 0.0-1.0 range. This improves images that make poor use of the available contrast (little contrast, very dark, or very bright images).Scales the components of the buffer to be in the 0.0-1.0 range. This improves images that make poor use of the available contrast (little contrast, very dark, or very bright images). This version differs from Contrast Autostretch in that it works in HSV space, and preserves hue.ScalingScaling factor for image features at radius, -1 cancels them out 1.0 edge enhancesScaling factor for unsharp-mask, the strength of effectScatteringScattering (speed vs. quality)ScriptSecond auxiliary image buffer input pad.Seed edgesSegment colors using K-means clusteringSelect the n-th closest pointSelective Gaussian BlurSelective Hue-SaturationSelective adjust Hue, Saturation and LightnessSeparatorSepiaSet at Native if uncertain, the CIE based spaces might introduce hue shifts.Set the blue amount for the blue channelSet the blue amount for the green channelSet the blue amount for the red channelSet the green amount for the blue channelSet the green amount for the green channelSet the green amount for the red channelSet the red amount for the blue channelSet the red amount for the green channelSet the red amount for the red channelSets the height in pixels according to which the text is vertically justified. Use -1 for no vertical justification.Sets the width in pixels at which long lines will wrap. Use -1 for no wrapping.Several simple methods for detecting edgesShadow angleShadow colorShadow fade midpointShadow fade midpoint, as a factor of the shadow lengthShadow lengthShadow minus imageShadow onlyShadow plus imageShadow styleShadowsShadows color adjustmentShadows-HighlightsShapeSharpen (Unsharp Mask)Sharpen image, by adding difference to blurred image, a technique for sharpening originally used in darkrooms.SharpnessShearShears the buffer. ShiftShift XShift YShift directionShift each row or column of pixels by a random amountShift white pointShould the output extent be clipped to the input extentShow GEGL OptionsShow illuminant controlsShow preflash controlsShrink areaSierpinskiSimple Linear Iterative ClusteringSimplex NoiseSimplify image into an array of solid-colored rectanglesSimulate a negative film enlargement in an analog darkroom.Simulate an antique engravingSimulate color distortion produced by a copy machineSimulate distortion caused by rectangular glass tilesSimulate glow by making highlights intense and fuzzySimulate out-of-focus lens blurSimulates a cartoon, its result is similar to a black felt pen drawing subsequently shaded with color. This is achieved by enhancing edges and darkening areas that are already distinctly darker than their neighborhoodSimulates an image created by embossingSimulates the optical distortion caused by having an elliptical lens over the imageSineSinusSinusoidalSizeSize XSize YSize of a region sideSize of an edge of square the mesh consists ofSize of patches used to denoiseSize ratio XSize ratio YSmooth by Domain TransformSmooth warpingSmoothingSmoothing factor from 1 to 100; 0 disables smoothingSmoothnessSobelSobel Edge DetectionSoftglowSoftnessSolid NoiseSourceSource ProfileSource image file path (png, jpg, raw, svg, bmp, tif, ...)Space nameSpacingSpatial extentSpatial regularizationSpatial standard deviation of the blur kernel, measured in pixels.Spatio Temporal Retinex-like Envelope with Stochastic SamplingSpecialized direction-dependent edge detectionSphericalSpherical cap apex angle, as a fraction of the co-angle of viewSpherizeSpiderSpinSpin angle around camera axisSpiralSpiral origin X coordinateSpiral origin Y coordinateSpiral radiusSpiral rendererSpiral rotationSpiral swirl directionSpiral typeSpyrographSquareSquare SizeSquaresSqueezeStaggeredStandard deviation (spatial scale factor)Standard deviation for the horizontal axisStart ColorStart angle of the destination color rangeStart angle of the source color rangeStart from the right instead of the leftStart x coordinateStart y coordinateStd. Dev.StepStop 1Stop 2Stop 3Stop 4Stop 5Store image in a GdkPixbuf.Store in GdkPixbufStores the ICC profile that would be embedded if stored as an image.StrengthStrength of EffectStrength of local detail enhancementStrength of the sepia effectStretch ContrastStretch Contrast HSVStretch color chroma to cover maximum possible range, keeping hue and lightness untouched.String to display (utf8)StripedStrokeStroke ColorStroke opacityStroke widthStyleStyle of effectSubdivisionsSubsetSubtractSuperimpose many altered copies of the image.SupernovaSuperpixels based on k-means clusteringSuperpixels based on the watershed transformationSuperpixels colorSuperpixels sizeSupersamplingSupersetSurface characteristicsSwirl clockwiseSwirl counter-clockwiseSwitch to clockwiseSymmetric Nearest NeighborTIFF File LoaderTIFF File SaverTIFF image loader using libtiffTIFF image saver using libtiffTarget encoded video bitrate in kb/sTarget file path to write GeglBuffer to.Target path and filenameTarget path and filename, use '-' for stdoutTarget path and filename, use '-' for stdout.Temporal blurTest op to do a 1:1 map of input to output, while samplingTextTextures the image as if it were an artist's canvas.Texturize CanvasThe GeglBuffer to load into the pipelineThe amount by which to scale the height valuesThe amount of contrast compressionThe babl format of the inputThe babl format of the outputThe babl format of the output GeglBuffer, NULL to use input buffer formatThe background colorThe cmsHPROFILE corresponding to the ICC profile for the input data.The color at (x1, y1)The color at (x2, y2)The color of supernova.The color to change.The color to make transparent.The color to paint over the inputThe color to render (defaults to 'black')The component used for the X coordinatesThe component used for the Y coordinatesThe contrast curve.The count of pixels to compute simultaneouslyThe distance to expand the shadow before blurring; a negative value will contract the shadow insteadThe dithering method to useThe f-stop of dodge/burn for pure white/black auxiliary inputThe fill opacity to useThe fill opacity to use.The first cell colorThe foreground colorThe foreground contains holes and/or several unconnected partsThe foreground does not contain opaque partsThe foreground is too small to useThe limit above which colors remain opaque.The limit below which colors become transparent.The location where to store the output GeglBufferThe lua script containing the implementation of this operation.The maximum difference in value at which to propagate a pixelThe minimum difference in value at which to propagate a pixelThe number of concurrent processing threads to useThe number of deformation iterationsThe number of divisionsThe number of noise octaves.The number of pixels across one repetition of a base pattern at base resolution.The opaque parts of the foreground are not above the background!The orientation of the blur - hor/verThe output pixbuf produced by process is stored in this propertyThe quality of rendering, a value between 0.0 (fast) and 1.0 (reference)The random seed for spokes and random hueThe random seed for the noise functionThe reference ID used as input (for use in XML).The rendering intent to use in the conversion.The scale of the noise functionThe second cell colorThe shadow's color (defaults to 'black')The shape of pixelsThe shape to expand or contract the shadow inThe strength with which to propagate a pixel to its neighborsThe tiles' background colorThe value represents the contribution of the past to the new frame.The width of the brush used to stroke the pathThe width of the brush used to stroke the path.There is a problem in the syntax or in the application of parsed property values. Things might mostly work nevertheless.This blur is used for the wavelet decomposition filter, each pixel is computed from another by the HAT transformThis function simulates the degradation of being on an old low-dotpitch RGB video monitor.This plug-in produces an effect like a supernova burst. The amount of the light effect is approximately in proportion to 1/r, where r is the distance from the center of the star.This plug-in uses the algorithm described by John Schlag, "Fast Embossing Effects on Raster Image Data" in Graphics GEMS IV (ISBN 0-12-336155-9). It takes a buffer to be applied as a bump map to another buffer and produces a nice embossing effect.ThresholdThreshold highThreshold lowThresholds the image to white/black based on either the global value set in the value property, or per pixel from the aux input.TileTile GlassTile HeightTile WidthTile color based on average of subsumed pixelsTile color variationTile geometryTile heightTile neatnessTile saturationTile sizeTile spacingTileableTiledTiled bumpmapTiltTitle to be given to output windowToTo 0To 1To 2To 3To 4To 5To 6To 7To ColorTo bottomTo leftTo polarTo rightTo topTopTop-leftTop-rightTotal pages, provided as a visual read-only propertyTrailingTransformTransform the image with the fractalsTransformation SVG syntax transformation stringTransformation matrix, using SVG syntax (or multiple matrices, separated by semicolons)TranslateTranslate top-left to 0,0.Transparency thresholdTransparentTreat as thisTreat as this: Gray colors from above source range will be treated as if they had this hue and saturation
Change to this: Change gray colors to this hue and saturationTriangleTrianglesTrim XTrim YTrimap influence factorTurbulenceTurbulentTurn image grayscale and overlay an oversaturated grid - through color assimilation happening in the human visual system, for some grid scales this produces the illusion that the grayscale grid cells themselves also have color.Turns the image grayscaleTypeType 1Type 2Type of GeglSampler used to fetch input pixelsType of RGB pattern to useType of a fractalType of illusionType of mapURIURI for file to loadURI for file to load.URI of file to loadURI of file to load.URI of image to load.Unable to convert image to sRGB color spaceUnable to create output color profileUnable to open JPEG 2000 imageUnable to read file: %sUnknown GeglOption mode: %dUnknown JPEG 2000 image formatUnpremultiplies a buffer that contains pre-multiplied colors (but according to the babl format is not.)Unpremultiply alphaUnseeded region colorUnsupported JPEG 2000 file with depth %dUnsupported fractal typeUnsupported fractal type: %dUnsupported non-RGB JPEG 2000 file with %d componentsUpper thresholdUse MLS weightsUse a gaussian noise distribution, when unticked a linear noise distribution is used insteadUse an existing in-memory GeglBuffer as image source.Use an on-disk GeglBuffer as data source.Use linear mask valuesUse linear output instead of gamma correctedUse local regionUse optimized huffman tablesUse pixel luminance valuesUse sRGB gamma instead of linearUse the full [0,1] range to encode the Z coordinatesUser valueUses the GdkPixbuf located at the memory location in <em>pixbuf</em>.ValueValue InvertValue PropagateValue at bottomValue at topValue exponent (logarithmic scale)Value offsetValuesVariable BlurVectorVector StrokeVerticalVertical camera panningVertical displacementVertical extentVertical justificationVertical justification 0.0 is top 0.5 middle and 1.0 bottom.Vertical offsetVertical offset (from origin) for start of gridVertical offset of blocks in pixelsVertical pattern scaleVertical positionVertical position in pixelsVertical scale factorVertical shadow offsetVertical shear amountVertical sizeVertical size ratio of a pixel inside each blockVertical spread amountVertical text alignment (0=Top, 1=Middle, 2=Bottom)Vertical texture sizeVertical translationVertical width of cells pixelsVideo DegradationVideo bufsizeVideo codecVideo codec to use, or auto to use a good default based on container format.Video4Linux Frame SourceVideo4Linux input, webcams framegrabbers and similar devices.Video4Linux2 Frame SourceVideo4Linux2 input, webcams framegrabbers and similar devices.VignetteVignette shapeVisualize Adjustment MaskVoronoi DiagramWarpWarps the colors of an image between colors with weighted distortion factors, color pairs which are black to black get ignored when constructing the mapping.WaterlevelWaterpixelsWatershed TransformWave typeWavesWebP File LoaderWebP File SaverWebP compression qualityWebP image loader.WebP image saverWeight distribution sigma controlling response contributionsWeight sigmaWeighted BlendWeights the opacity of the input both the value of the aux input and the global value property.What color model used for the transformationWhat shape to use for tilesWhen TRUE the model will not be freedWhen enabled also enhances shadow regions - when disabled a more natural result is yieldedWhen enabled details in shadows are boosted at the expense of noiseWhen set operate on gamma corrected values instead of linear RGB - acting like the old normalize filter in GIMPWhere GEGL stores its swapWhether the function adds the result to the original image.Whether the image edges are also seededWhether to propagate a pixel's colorWhether to propagate a pixel's opacityWhether to rotate the RGB pattern by ninety degrees.WhirlWhirl PinchWhirl angle (degrees)WhiteWhite on BlackWhite point adjustmentWide gamut RGBWide stripedWidthWidth for rendered imageWidth of Hue selection interval  Width of blocks in pixelsWidth of grid lines in pixelsWidth of the generated bufferWidth of the tileWindWind-like bleed effectWindow titleWrap aroundWrap heightWrap image around a spherical capWrap inputWrap the fractional tilesWrap widthWriteWrite BufferWrite camera name correctlyWrite input data into an existing GEGL buffer destination surface.Write lens maker correctlyWrite your lens model with uppercase lettersWrites image data to an already existing bufferWrong pixelsXX AmplitudeX ComponentX OffsetX PeriodX PhaseX ScaleX SizeX axis ratio for the center of mirroringX axis ratio for trimming mirror expanseX coordinate of originX coordinate of pattern centerX coordinate of the displacement centerX coordinates of the center of supernovaX coordinates of the flare centerX displacementX multiplierX positionX shift in the fractal spaceX start of the generated bufferX0X1X1 value, positionX2X2 value, positionYY AmplitudeY ComponentY OffsetY PeriodY PhaseY ScaleY SizeY axis ratio for the center of mirroringY axis ratio for trimming mirror expanseY coordinate of originY coordinate of pattern centerY coordinate of the displacement centerY coordinates of the center of supernovaY coordinates of the flare centerY displacementY positionY shift in the fractal spaceY start of the generated bufferY'CbCr CbY'CbCr CrY'CbCr Y'Y0Y1Y1 value, positionY2Y2 value, positionYellow angleYellow filterYellow filter compensation for the negative imageYellow patternYellow periodZ coordinate of the near clipping planeZ multiplierZ offsetZoomZoom in the fractal spaceZoom levelZoom motion blurZooming Motion Blur[op [property=value] [property=value]] [[op] [property=value]a GeglBuffer on disk to openadd-alphaamountaudioaudio bitrate in kb/saudio sample rateaudio-codecaudio_channelsaudio_sample_rateautotrigger reload this many times a second.babl formatblend two images using alpha values as weightscould not create a new Jasper streamcould not query JPEG 2000 filecurrent frame number, can be changed to trigger a reload of the image.failed to open JPEG 2000 from %sfile to loadflagfloating point -1 means auto, 0 means integer 1 meant float.frameframe number to decodeframe-delayframe-rateframesglobal qualityglobal value used if aux doesn't contain dataglobal weight scalegluasgop-sizehow to determine what to fill (nonzero|evenodd)i-quant-factori-quant-offsetkeyint-minlibraw File Loaderlist of <number>smax_b_framesmax_qdiffme-subpel-qualityme_rangenoise reductionnumber of levels per componentop '%s' not found, partial matches: origin-xorigin-youtput/rendering height in pixels, -1 for input heightoutput/rendering width in pixels, -1 for input widthpath of file to write to.pdf loaderpipelinepointer to a const * Babl spaceposition of symmetry center in outputqblurqcompressqmaxqminregion-heightregion-widthregion-xregion-ys RGBsRGBsample input with an auxiliary buffer that contain absolute source coordinatessample input with an auxiliary buffer that contain relative source coordinatesscaling factor of displacement, indicates how large spatial displacement a relative mapping value of 1.0 corresponds to.scenechange thresholdset color space which subsequent babl-formats in the pipeline are created with, and the ICC profile potentially embedded for external color management, setting a pointer to a format overrides the string property and setting an aux pad overrides both. squared integralstretch components of pixels individually based on luminance envelopessvg style description of transform.tile size to use.trade-off between superpixel regularity and adherence to object boundariestrellisunhandled path data %s:%s
unknown modeuri of file to loadusage: %s [options] <file | -- [op [op] ..]>

  Options:
     -h, --help      this help information

     --list-all      list all known operations

     --exists        return 0 if the operation(s) exist

     --info          output information about the operation:
                     name, description, properties details.

     -i, --file      read xml from named file

     -x, --xml       use xml provided in next argument

     -o, --output    output generated image to named file, type based
                     on extension.

     -p              increment frame counters of various elements when
                     processing is done.

     -s scale, --scale scale  scale output dimensions by this factor.

     -X              output the XML that was read in

     -v, --verbose   print diagnostics while running

All parameters following -- are considered ops to be chained together
into a small composition instead of using an xml file, this allows for
easy testing of filters. After chaining a new op in properties can be set
with property=value pairs as subsequent arguments.
use floating pointvideo bitrate in kb/svideo bitrate maxvideo bitrate minvideo bitrate tolerancevideo device pathvideo-codecweight 0weight 1weight 2weight 3weight 4weight 5weight 6weight 7Project-Id-Version: gegl master
Report-Msgid-Bugs-To: https://gitlab.gnome.org/GNOME/gegl/issues
PO-Revision-Date: 2023-02-26 08:48+0100
Last-Translator: Tim Sabsch <tim@sabsch.com>
Language-Team: Deutsch <gnome-de@gnome.org>
Language: de
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Plural-Forms: nplurals=2; plural=(n != 1);
X-Generator: Poedit 3.2.2
X-Project-Style: gnome


unbekannter Parameter »%s«, stattdessen wird die Hilfe angezeigt


%s hat keine %s-Eigenschaft, Eigenschaften sind: %s hat keine %s-Eigenschaft.(1,1)(1,2)(1,3)(1,4)(1,5)(2,1)(2,2)(2,3)(2,4)(2,5)(3,1)(3,2)(3,3)(3,4)(3,5)(4,1)(4,2)(4,3)(4,4)(4,5)(5,1)(5,2)(5,3)(5,4)(5,5)-1 bedeutet automatische Erkennung beim ersten Audio-Fragment-1, 8, 16, 32 und 64 sind die derzeit akzeptierten Werte. -1 bedeutet automatisch0°180°1D Box-Weichzeichner1D Gaußscher Weichzeichner1D Wavelet-Weichzeichner270°3x38 und 16 sind die derzeit akzeptierten Werte.90°Ein GeglVector, der den Pfad des Strichs darstelltEine schnelle Näherung eines bilateralen Filters, bei dem ein Box-Filter statt eines Gaußschen Weichzeichners verwendet wird.Je höher dieser Wert ist, desto geringer der Zufallsanteil des RauschensEine Ebene im traditionellen SinnEin bereits existierender GeglBuffer, in den eingehende Daten geschrieben werden sollen.Eine rechteckige Quelle fester Größe, einfarbigEin auf einem Datenträger gespeichertes lua-Skript, das eine Operation implementiert.ACES RRTASAP-DeformationWenn WAHR, wird eine ASAP-Deformation durchgeführt, anderenfalls eine ARAP-DeformationOberhalb des SchwellenwertsAbsolutKolorimetrisch (absolut)Abyss-RegelnAufsummierte Bewegungsunschärfe mittels eines Kalman-Filters. Wird mit Sequenzen von Videobildern verwendet.Aktive EbenenAnpassen eines Bildes, das einen hohen Dynamikbereich haben kann, für die Präsentation mit einem niedrigen Dynamikbereich. Hierbei handelt es sich um einen effizienten globalen Operator, der aus einfachen physiologischen Beobachtungen abgeleitet ist und eine Leuchtdichte im Bereich von 0,0-1,0 erzeugtEin Bild, das eine hohe Dynamik enthalten kann, zur Präsentation mit einer niedrigen Dynamik anpassen. Diese Operation schwächt das Ausmaß von lokalen Bildgradienten ab, wodurch eine Leuchtkraft zwischen 0.0 und 1.0 erzeugt wird. Dieser Ansatz zur Dynamikkompression wurde ursprünglich 2002 von Raanan Fattal in folgendem SIGGRAPH-Artikel veröffentlicht: Gradient Domain High Dynamic Range Compression.Ein Bild, das eine hohe Dynamik enthalten kann, zur Präsentation mit einer niedrigen Dynamik anpassen. Diese Operation beschränkt Kontraste über mehrere räumliche Frequenzen, wodurch eine Leuchtkraft zwischen 0.0 und 1.0 erzeugt wirdAnpassung an Farbvariationen im BildAnpassung an Lichtvariationen im BildAddierenCIE lc_h Rauschen hinzufügenHSV-Rauschen hinzufügenRGB-Rauschen hinzufügenGlühen um helle Bereiche hinzufügenSumme der quadrierten Werte zur Ausgabe hinzufügenAdditivFügt einen Linsenreflex-Effekt hinzu.LCH-Farbton, -Buntheit und -Helligkeit anpassenPasst die Helligkeit in den Ecken anBelichtung von Glanzlichtern anpassenBelichtung von Schatten anpassenSättigung der Glanzlichter anpassenSättigung der Schatten anpassenTristimulus-X-Wert anpassenTristimulus-Z-Wert anpassenSchwarzwert anpassenPasst den Kontrast eines Graustufenbildes anhand einer Kurve an, die den Kontrast nach Intensität angibt.Kompatibel zu Adobe RGBAlgorithmusAlgorithmustypAlienAusrichtenAnordnung für mehrzeiligen Text (0=Links, 1=Mitte, 2=Rechts)Die Box des Eingaberechtecks am Rand des Kompositionsziels oder dem Begrenzungsrahmen des Hilfspuffers ausrichten. Wenn der Hilfspuffer nicht verbunden ist, versucht die Operation herauszufinden, welcher Begrenzungsrahmen verwendet werden soll.Kachelteilung erlaubenKachelteilung an harten Kanten erlaubenAlphaAlphakanalAlpha-StufenAlpha-Parameter der MLS-GewichtungenAlpha-PerzentilAlpha-Schwellwert für mehrstufige BearbeitungAlpha-GewichtungImmerUmgebungslichtfaktorMengeBetrag, um den die Deckkraft jedes umgewandelten Bildes skaliert werden sollMaß der KantenbewahrungAnteil der zu bewahrenden Kanten. Die Menge ist umgekehrt proportional zur Standardabweichung des Bereichs des Weichzeichnerkernels.Maß der Verzerrung vierter OrdnungMaß der Verzerrung zweiter OrdnungMenge, um welche die Helligkeit erhöht werden sollAmplitudeAmplitude für X-Achse (logarithmische Skalierung)Amplitude für Y-Achse (logarithmische Skalierung)Amplitude der WelleEin bereits existierender GeglBuffer, in den eingehende Daten geschrieben werden sollen, oder NULL.Ein kantenbewahrender Weichzeichnen-Filter, implementiert durch die rekursive Domänen-Transformation. Ähnlich zu einem bilateralen Filter, allerdings schneller zu berechnen.Eine Fehlermeldung im Falle eines ScheiternsEin expliziter Knoten zur Zwischenspeicherung, der Ergebnisse zwischenspeichert und somit eine schnellere Neuberechnung ermöglicht, sofern die zwischengespeicherten Daten aufwendig zu berechnen sind, aber konstant bleiben.WinkelWinkelschubWinkel der Unschärfe in GradBlickwinkelWinkelversatz für MusterDrehwinkel (gegen den Uhrzeigersinn)Anisotropische GlättungAntialiasing-ÜberabtastungsfaktorKantenglättung mittels Scale3X-Algorithmus zur Extrapolation von KantenKantenglättungScheinbare Tiefe des erzeugten Leinwandeffekts; von 1 (sehr flach) bis 50 (extrem tief)Sichtbare Höhe jeder Kachel (in Pixeln)Wendet einen Farbverlauf an.Legt eine Vignettierung auf ein Bild. So wird der Helligkeitsabfall in den Ecken eines belichteten Films simuliert, sowie einige unscharfe Randeffekte, die in Realität bei analoger Fotografie auftretenLinse anwendenEine generische 5×5-Faltungsmatrix anwendenEine Sepia-Tönung auf das Eingabebild anwendenEine Transformation rekursiv anwenden.Bereichsbalance zwischen zwei FarbenArithmetische AdditionArithmetische Addition der KovarianteArithmetisches Exklusives OderArithmetisches Exklusives Oder der KovarianteSeitenverhältnisZu verwendendes Seitenverhältnis. -0,5 = 1:2, 0,0 = 1:1, 0,5 = 2:1, -1,0 = 1:inf 1,0 = inf:1. Dies wird angewendet, nachdem das Verhältnis berücksichtigt wurde. Um den Quetsch-Faktor direkt als Verhältnis zu verwenden, legen Sie das Verhältnis auf 0,0 fest.Audio-CodecZu verwendender Audio-Codec, oder »auto«, um eine sinnvolle Voreinstellung basierend auf dem Containerformat zu verwenden.AutoD-Werte automatisch für Linsen-Korrekturmodelle korrigieren.D-Werte automatisch korrigierenZusätzliches Eingabe-Pad des Bildpuffers.Verfügbar als eine globale Variable »user_value« in lua.DurchschnittDurchschnittlicher Durchmesser jeder Kachel (in Pixeln)Durchschnittlicher Unterschied (gesamt)Durchschnittlicher Unterschied (falsch)Durchschnittlicher Unterschied zwischen allen Pixeln.Durchschnittlicher Unterschied zwischen falschen Pixeln.Zuschnitt und Quantisieren vermeiden (langsamer)Achsen-TrennwinkelAzimutBabl-FormatBablFormat »%s« existiert nicht.HintergrundHintergrundfarbeHintergrundfarbeHintergrundtypAusstiegswertBalanceBand-AnpassungBarnsley 1Barnsley 2Barnsley 3BasisGrundbelichtung zur VergrößerungBasis-IndexBayerBayer-MatrixBayer-MusterVerwendetes Bayer-Muster. 0 scheint für einige Nikon-Dateien zu funktionieren, 2 für einie Fuji-Dateien.VerhaltenVerhalten der OperationUnterhalb des SchwellenwertsBetaBilateraler Box-FilterBilateraler FilterBilinearBit-TiefeSchwarzSchwarz-WinkelSchwarzwertSchwarz auf WeißBlau-MusterSchwarz-PeriodeTiefenkompensationSchwarzauszugSprengenFarbübergangsmodusSerie an Eingaben mithilfe einer Maske zusammenführenBlockhöheBlockgrößeBlockgröße für Zeilen/Spalten beim DeinterlacingBlockbreiteBlockgrößeBlühenBlauBlau-Kanal-VerstärkerBlaues RauschenBlaues Rauschen der KovarianteBlau-SchwellenwertBlau-und-Gelb-WinkelBlau-und-Gelb-MusterBlau-und-Gelb-PeriodeBlau-WinkelBlauer AnwendungsmodusBlauer KanalBlaue KonturenBlau-FrequenzBlau-nach-Blau-KanalBlau-nach-Grün-KanalBlau-nach-Rot-KanalBlau-UmkehrungBlau-StufenBlau-MusterBlau-PeriodeBlau-PhasenverschiebungBlaue VorbelichtungBlaue harte KantenFaktor der Blau-DehnungBlau-Schwellenwert der EingangsfarbeWeichzeichner-GammaWeichzeichnungsstufeBenachbarte Pixel weichzeichnen, aber nur in Bereichen geringen KontrastsPixel in einer Richtung verwischen. Dies simuliert die durch die geradlinige Bewegung der Kamera während der Belichtung erzeugte Unschärfe.WeichzeichnenradiusWeichzeichnung anhand der gemittelten Farben einer Zeilenumgebung.Weichzeichnung anhand der gemittelten Farben einer quadratischen Umgebung.Unschärfe, die aus der Berechnung der durchschnittlichen Farbe der Nachbarschaft jedes Pixels ermittelt wird.Bild um den Brennpunkt herum weichzeichnenDas Bild mit einer variablen Stärke mittels Maske weichzeichnenArt des WeichzeichnersUnschärfefaktorPapierdichte verstärken, um den Vorteil eines höheren Dynamikumfangs eines Bildschirms gegenüber Fotopapier auszunutzenRandRand ausrichtenRandverhaltenBeideUntenUnten-LinksUnten-RechtsBox-WeichzeichnerBox-WeichzeichnerAufhellenHelligkeitHelligkeitskontrastHelligkeit und Verschiebung/Verdickung der KonturenPufferPufferzielPufferquellePufferortBumpmapBumpmap (Originalfarben erhalten)CIE Lab/LchCIE YuvCMYKCMYK CyanCMYK-SchlüsselCMYK MagentaCMYK YellowCXCX (kein Effekt in Mandelbrot und Sierpinski)CYCY (kein Effekt in Mandelbrot und Sierpinski)ZwischenspeicherEine Distanztransformation berechnenB-Wert aus der Brennweite berechnenKameraKamera-RGBBlickwinkel der KameraKartesischCartoonFormat umwandelnFarbraum umwandelnDaten zwischen Eingabe- und Ausgabeformat umwandeln. Beide Formate müssen die gleichen bpp besitzenZellrauschenMitteMittelpunkt-XMittelpunkt-YVersatz zentrierenZentrum des Farbton-Auswahlintervalls  Den Versatz an einem bestimmten Punkt zentrierenZentrierenZentrieren der KachelnBelichtungszeit eines Bildes in Blendenstufen ändernÄndert die Farbtemperatur des Bildes von einer angenommenen Originaltemperatur zu einer Zieltemperatur.In diese ändernÄndert die Helligkeit und den Kontrast. Diese Operation wirkt linear, wobei »Kontrast« der Skalierungsfaktor von 50% Grau ist und »Helligkeit« ein konstanter Versatz, der nach der Kontrastskalierung angewendet wird.Ändert die SättigungKanal-MischerCharakteristische KurveTschebyschewSchachbrettMittelpunkt wählenFarbsättigungFarbsättigungskorrekturChromatische AnpassungKreisKreistiefe in ProzentZirkulare BewegungsunschärfeZirkulare BewegungsunschärfeKlemmenKlemmverformungAuf RGB einschränkenGrundschleier beschränkenGrundschleier beschränken, um ein rein weißes Ergebnis zu erhaltenHohe Pixelwerte einschränkenNiedrige Pixelwerte einschränkenDie Ausgabe auf die Eingabegröße zuschneidenErgebnis auf Eingabegröße zuschneidenAuf Eingabegröße zuschneidenAuf Eingabegröße zuschneidenIm UhrzeigersinnKlonenEinen Puffer klonen. Dies ist die gleiche Operation wie gegl:nop, kann aber eine besondere Behandlung erhalten, um menschenlesbarere Referenzen in Serialisierungen/der Oberfläche zu erhalten.ClustergrößeFarbeFarbe 1Farbe 2Farbe 3Farbe 4Farbe 5Farb-Assimilation-RasterFarbverbesserungFarbmodellFarbüberlagerungFarben drehenFarbtemperaturFarbmittelwertbildungFarbe des Texts (Vorgabe ist »black«)FarbraumFür die Füllung zu verwendende Farbe, 0 deaktiviert die FüllungDie für eine Füllung zu verwendende Farbe.Zum Zeichnen zu verwendende FarbeZum Zeichnen zu verwendende Farbe.Farbe der RasterlinienVon der Farbsättigung abhängige Kompression der PeriodeFarbraumFür die geladenen Daten zu verwendender FarbraumFarbe zu AlphaFarbe, zu der transformierte Bilder verblassen, mit einer Rate, die von ihrem Alpha-Wert abhängtUmwandlung der Farben in Graustufen. Zum Erhalt von lokalen Farbunterschieden werden Hüllkurven verwendet, die durch die STRESS-Methode gebildet wurden.Farbe zu SpitzenFarbe, die dargestellt werden sollZu verwendende Farbe für die Modi »Nur Farbe« und »Farbe zu Spitzen«Farbe zum Füllen des HintergrundesFarben verzerrenFarben, deren Sättigung unter diesem Wert liegt, werden als Grau angesehenBelichtung kombinierenMehrere Szenenbelichtungen in einem Bild hoher Dynamik kombinieren.KompaktheitÜberprüft, ob sich Eingabe- und Hilfs-Puffer unterscheiden. Globale Statistiken werden in den Eigenschaften gespeichert und es wird eine visuelle Darstellung der Unterschiede angezeigt. KompensierenAbdunklung kompensierenEinen Ausschnitt von Pixeln zufällig verändernKomplexitätFaktor der KomplexitätKomponenteFrequenz für Komponente 1Phasenverschiebung für Komponente 1Frequenz für Komponente 2Phasenverschiebung für Komponente 2Frequenz für Komponente 3Phasenverschiebung für Komponente 3Farbe des KomponententrennersZu extrahierende KomponenteKomponenten des JPEG2000-Eingabebildes passen nicht zueinanderDie zu verwendende Composite-StrategieZusammensetzungKomprimierenDen Effekt bei Schatten/Glanzlichtern komprimieren und Mitteltöne bewahrenKompressionKompressionsmethode für Daten, die in der Auslagerungsdatei gespeichert sindRelative Versatzzuordnung aus einem Pinselstrich berechnenAusmaß und/oder Richtung des Verlaufs durch zentrale Unterschiede berechnenBerechnen des integralen und quadrierten IntegralbildesVerbundene KomponentenContainerformatZu verwendendes Containerformat, oder »auto«, um es anhand der Dateiendung automatisch zu erkennen.KontrastKontrastkurveKontrast-VerstärkungKontrast des HochpassfiltersRauschen-Anteil für jeden RGB-Kanal unabhängig voneinander einstellenSteuert die Anzahl der WiederholungenSteuert die Anzahl der Durchläufe. Niedrigere Werte ergeben weniger plastische ErgebnisseUmwandlungsformatWandelt eine festgelegte Farbe in Transparenz um, funktioniert am besten mit weiß.Farbraum umwandelnDas Bild in oder von Polarkoordinaten umwandelnDaten in das angegebene Format umwandelnWandelt das Bild in quadratische Kleckse zufälliger Drehung um, um ein Gemälde des Kubismus zu simulierenUmwandlung mit Schwarzpunktkorrektur.Wandelt die Eingabe von einem ICC-Profil in ein gut definiertes BABL-Format um. Die Pufferdaten werden dann von GEGL korrekt für die weitere Verarbeitung verwaltet.FaltungsmatrixKoordinaten des LinsenzentrumsKopiert das Bild mit einer Korrektur der Objektivverzerrung.Puffer kopierenKorrigierte Schätzung der Farbtemperatur der Lichtquelle in Kelvin.Korrigiert die tonnen- oder kissenfürmige Linsenverzerrung.Korreliertes RauschenCosinusGegen den UhrzeigersinnEin Graustufen-Bild erstellenErzeugt einen Kaleidoskop-ähnlichen Effekt.Erzeugt einen neuen GEGL-Puffer zum Ausgeben des Ergebnisses.Eine zufällige wolkenähnliche Struktur erzeugenKachelbare Ausgabe erzeugenProgressive JPEG-Bilder erstellenErzeugt einen Schlagschatteneffekt im EingabepufferErzeugt einen Langschatten-EffektErzeugt ein Bild mit einem Plasma-Effekt.ZuschneidenEinen Puffer zuschneiden. Wenn der Hilfspuffer verbunden ist, wird das Begrenzungsrechteck des verbundenen Knotens verwendet. Wenn der Schnittbereich auf 0x0 bei 0,0 eingestellt und der Hilfspuffer nicht verbunden ist, wird das Begrenzungsrechteck des Knotens am Ende der Eingabesequenz verwendet.Kreuzende LinienKubischKubismusKrümmungKurveKurventypKurventypDas Bild in einzelne Papierstücke zerschneiden und diese bewegenCyan-WinkelCyan-FilterKompensation des Negativ-Bilds mittels Cyan-FilterCyan-MusterCyan-PeriodeFeuchtigkeitVoreingestellte Größe von Kacheln in GeglBuffersVoreinstellung ist schwarz. Sie können hier eine Transparenz einsetzen, um Teile eines Bilds zu löschenGradDeinterlaceHorizontale oder vertikale Zeilenentflechtung durchführenVerzögerung des letzten dekodierten Einzelbildes in msDemosaicing mittels Bimedian-InterpolationDemosaicing ohne InterpolationRauschunterdrückung (DCT)Rauschunterdrückung auf Grundlage eines Ausschnitt-weisen Schwellwertverfahrens mittels Diskreter Kosinustransformation (DCT)Dichte-VerstärkungTiefeTiefe zuerstDetailDetail-BandDetail-BandbreiteDetailgradDetailskalierung. Negative Werte verringern das Signal im Detail-Band, positive Werte erhöhen das Signal.Abweichung gegenüber ideal geformten KachelnDiamantDifferenz der MittelwerteUnterschiedBeugungsmusterDigitales Rastern mit optionalen Modulationen. AusrichtungRichtung der Lichtquelle (in Grad)Richtung des EffektsX-Komponente des RichtungsvektorsY-Komponente des RichtungsvektorsOrdnerOpenCL deaktivierenDiskretisierungs-BitsErsetzenVersetzungsmultiplikator für X oder radiale RichtungVersetzungsmultiplikator für Y oder tangentiale Richtung (Grad)Pixel mittels Versatzzuordnungen versetzenPixel in ein gekräuseltes Muster umordnenVerschiebungsmodusVersetzungsmultiplikator für den WinkelversatzVersetzungsmultiplikator für die horizontale RichtungVersetzungsmultiplikator für die radiale RichtungVersetzungsmultiplikator für die vertikale RichtungSkalierungsfaktor des Versatzes (negative Werte ergeben einen umgekehrten Versatz)AnzeigeEine Textzeichenkette mittels Pango und Cairo anzeigen.Hilfeinformationen anzeigenAuf dem Bildschirm darstellenDen Eingabepuffer in einem Fenster darstellen.Zeigt den Eingabepuffer in einem SDL-Fenster an (eingeschränkt auf eine Anzeige-Operation/Prozess wegen einem SDL-Implementierungsproblem).Zeigt den Eingabepuffer in einem SDL2-Fenster an (aufgrund eines SDL2-Implementierungsproblems eingeschränkt auf eine Anzeige-Operation/Prozess).Distanz-TransformationBild durch Drehen und Drücken verzerrenFarben um zufällige Werte verzerrenBild mit Wellen verzerrenVerzerrtDithernDithering-MethodeDitoDivisionDivisorGeben Sie eine Reihe an Operationen an, wobei nach dem Namen der Operation deren Eigenschaften über die Syntax »Schlüssel=Wert« angegeben werden können. Mit »aux=[ Quellfilter ]« können Sie eine Reihe angeben, bei der die Quelle mit einem zusätzlichen Pad verbunden ist.Eine lineare Interpolation zwischen Eingabe und ZusatzwertStereographische (»Kleiner Planet«) Transformation eines äquirektanguläres Bildes.Eine Transformation mittels SVG-Syntaxumwandlung ausführen.Das g des Panorama-Viewers oder dessen Umkehrung für ein äquirektanguläres Eingangsbild ausführen. (2:1-Verhältnis mit 360x180-Grad-Panorama).Umgekehrte Zuordnung durchführen. Dies ist nützlich, um Zenit, Nadir oder andere Teile eines Panoramas auszubessern.Abwedeln/Nachbelichten-MultiplikatorGlanzlichter nicht überbelichtenPunkteEin Labyrinth zeichnenSchlagschattenDämpfungEPITROCHOIDFEHLER: '%s' Option erwartete ein Argument
KanteBetroffene KanteKantenerkennungKanten-BandKanten-BandbreiteKantenverhaltenAlgorithmus für KantenerkennungBetrag der KantenerkennungVerhalten der KantenerkennungKantenerkennung mit Steuerung der Kantendicke, basierend auf der Differenz zweier Gaußscher WeichzeichnerVerhalten an KantenKantenbewahrungKantenskalierung. Negative Werte verringern das Signal im Detail-Band, positive Werte erhöhen das Signal.HuuuuuchVersatz zur Effektmitte in XVersatz zur Effektmitte in YStärke des EffektsEntweder von der Maske addieren oder subtrahierenErhebungHöhenwinkel (Grad)PrägungPrägungstypEin Ölgemälde nachahmenVorbelichtung aktivierenErmöglicht weichere Darstellung der KachelnEndfarbeEndwinkel für die Drehung der ZielfarbeEndwinkel für die Drehung der QuellfarbeX-EndkoordinateY-EndkoordinateGravurSchatten verbessernVerbessert feine Details.EpsilonVerformung zurücknehmenFehlermeldungFehler beim Lesen von Zeile %d, Komponente %dGeschätzte Farbtemperatur der Lichtquelle in Kelvin bei Aufnahme des Bildes.EuklidischFarbe tauschenErsetzt eine Farbe durch eine andere und legt optional einen Schwellenwert für die Umwandlung einer Schattierung in eine andere fest.AusdehnenKacheln um diesen Wert vergrößernExponentExponenten-PufferExponent für die Verarbeitung, der die Glättung beeinflusst. Kann auch pro Pixel durch einen Puffer auf dem zweiten Hilfs-Pad skaliert werden.BelichtungBelichtungswerteAusgedrückt als Standardabweichung in PixelKomponente extrahierenEine Farbraumkomponente extrahierenFFmpeg-BildladerFFmpeg-BildspeichererFFmpeg-Importeur für Videobilder.Ziel der FFmpeg-VideoausgabeFIRBilder pro SekundeFarbe ausblassenDeckkraft der VerblassungVerblassenVerblassen (feste Länge)Verblassen (feste Rate)Linearität des AbfallsDynamikkompression nach Fattal et al. 2002Featuregröße für das Detail-Band, wird für Rauschunterdrückung verwendet.Featuregröße für das Kanten-Band, wird für den Ausgleich des Kantenverlusts im Detailpass verwendet.DateiDateisystempfad zum zu ladenden ICC-Matrix-ProfilFüllfarbePfad füllenJede Kachel mit einer zufälligen Farbe füllenKompletten Ausgabebereich füllenFüll-DeckkraftFüllregelFüllregel.Füllt jede verbundene Region der Eingabe, die durch eine definierte Farbe vom Rest der Eingabe getrennt ist, mit einer eigenen Farbe.FilterFilterbreiteEndlichErste IterationBilder korrigieren, wo jede andere Zeile oder Spalte fehltZähne des feststehenden ZahnradsX spiegelnY spiegelnX-Koordinaten spiegelnY-Koordinaten spiegelnGleitkommazahlFloyd-SteinbergBrennweite der KameraBrennpunkt-WeichzeichnerInnere Grenze des FokusbereichsÄußerer Radius des FokusbereichsMittelpunkt des FokusübergangsFoma Fomabrom CFoma Fomabrom NFoma Fomabrom SFoma Fomabrom SpFoma Fomabrom Variant IIISchriftfamilieSchriftfamilie (utf8)Schriftgröße in Pixel.ErzwingenKachelung erzwingenVordergrundfarbeFraktal-ExplorerFraktalumwandlungFraktaltypFraktionaltypFraktionaltypEinzelbildEinzelbildnummerEinzelbilder pro Sekunde, erlaubt Rechenzeit vs EinzelbildEinzelbilder pro SekundeVonVon 0Von 1Von 2Von 3Von 4Von 5Von 6Von 7Von Farbe»Fujicolor Crystal Archive Digital Pearl«-PapierKompletter Z-BereichGEGL-GraphGEGL Graphen-Visualierung.GIF-DateiladerGIF-Bildlader.GammaGamma-Faktor für Abstände der MischstufenGamma-Faktor für Abstände der WeichzeichnungsstufenAbstandGaußscher WeichzeichnerGaußsche VerteilungGdkPixbuf-QuelleZu verwendendes GdkPixbufGeglBuffer-Dateilader.GeglBuffer-Dateischreiber.Muster einer Bayer-Matrix erzeugenEin lineares Sinusoid-Muster erzeugenEin Normal-Mapping aus einer Höhenkarte erzeugenKachelbare Karte erzeugenKomplexe Sinuskurven-Strukturen erzeugenBeugungsmuster erzeugenEin genaueres und konsistenteres Ergebis produzieren (langsamer)Erzeugt einen vollständig mit der angegebenen Farbe gefüllten Puffer, verwenden Sie gegl:crop für kleinere Abmessungen.Erzeugt eine Zellenstruktur.Erzeugt eine gleichmäßige Rausch-Textur.Vordergrund-Alphamaske anhand einer benutzerdefinierten, dünn besetzten Trimap und einem Eingabebild. Verwenden Sie in der Trimap weiß für ausgewählt und schwarz für nicht-ausgewählt.Vordergrund-Alphamaske anhand einer benutzerdefinierten, dünn besetzten Trimap und einem Eingabebild. Verwenden Sie in der Trimap weiß für den Vordergrund und schwarz für den Hintergrund. Die verbleibenden Regionen werden als unbekannt behandelt und ausgefüllt.Globaler FarbsättigungsfaktorGlobaler Deckkraftwert, der immer zusätzlich auf den optionalen Hilfs-Eingabepuffer angewendet wird.LeuchtradiusGlühen-StärkeHelligkeit-Schwellenwert des glühenden BereichsKantenweichheit des glühenden BereichsVerlaufFarbverlaufGlättung des FarbverlaufsFarbverlauf-Schwellwert für DetailverbesserungFarbverlauf-Schwellwert zum Verringern der DetailverbesserungGrau-ModusGrau-SchwellenwertGraustufenMittelwertbildung mit GraustufenGrünGrün-Kanal-VerstärkerGrün-SchwellenwertGrün-und-Magenta-WinkelGrün-und-Magenta-MusterGrün-und-Magenta-PeriodeGrün-WinkelGrüner AnwendungsmodusGrüner KanalGrüne KonturenGrün-nach-Grün-KanalGrün-FrequenzGrün-nach-Blau-KanalGrün-nach-Rot-KanalGrün-UmkehrungGrün-StufenGrün-MusterGrün-PeriodeGrün-PhasenverschiebungGrüne VorbelichtungGrüne harte KantenFaktor der Grün-DehnungGrün-Schwellenwert der EingangsfarbeRasterRasterdarstellungRastergrößeBereich ausweitenAusweitungsradiusAusweitungsformHDR zu SDR-Proofing-Filter/Zuordnungskurve, die eine Annäherung der ACES RRT (Referenz-Rendering-Transformation) ist. Wenn diese Operation auf aufnahmebezogene Bilddaten angewandt wird, ist das Ergebnis für eine anzeigebezogene Transformation nach sRBG oder eine Anzeige mit regulären ICC-Matrix-Profilen als ODT geeignet. Beachten Sie, dass es sich aktuell um eine Nur-Leuchtkraft-Annäherung der ACES RRT handelt und weder eine Entsättigung der Glanzlichter und Schatten, noch Anpassungen von Rottönen unterstützt wird.HSLHelligkeit (HSL)HSL-SättigungHSV-SättigungHSV-WertZu verwendendes Raster-/PunktmusterFest kodierte charakteristische Kurve und FarbdatenHärteHärte des Pinsels. 0.0 bedeutet ein weicher Pinsel, 1.0 ein harter PinselStarke Bildverzerrung durch Anwendung trigonometrischer Funktionen zur Abbildung von Farbwerten.HöheHöhenkarteHöhe des gerenderten BildesDie Höhe der Blöcke in PixelDie Höhe der Rasterlinien in PixelHöhe des generierten PuffersHöhe der KachelHexSechseckeHochpass-FilterHohe EingabeObere GrenzeHohe EingabeHohe PräzisionHohe QualitätHöhere Werte ergeben mehr DetailsHochauflösende KantenerkennungJe höher dieser Wert ist, umso stärker wirkt dieser EffektHöhere Werte beschränken den Effekt auf weniger Bereiche des BildesHöchste Leuchtkraftstufe in der AusgabeHervorhebungsfaktorSchwellwert hervorhebenSchwellwert hervorheben (hoch)Schwellwert hervorheben (niedrig)GlanzlichterFarbkorrektur der GlanzlichterHistogrammgrößeLoch-ProzentHorizontalHorizontales Schwenken der KameraHorizontaler VersatzHorizontale AusdehnungHorizontale Ausrichtung 0.0 entspricht links, 0.5 entspricht zentriert und 1.0 entspricht rechts.Horizontaler VersatzHorizontaler Versatz (vom Ursprung) für den Anfang des RastersHorizontaler Versatz von Blöcken in PixelnHorizontale MusterskalierungHorizontale PositionHorizontale Position in PixelHorizontaler SkalierungsfaktorHorizontaler Schatten-VersatzHorizontaler ScherbetragHorizontale GrößeHorizontales Größenverhältnis eines Punkts innerhalb jedes BlocksHorizontale StreumengeHorizontale TexturgrößeHorizontale VerschiebungHorizontale Breite der Zellen-PixelWie Bereiche außerhalb des Eingangs bei der Distanzberechnung berücksichtigt werden sollenWie nah es an den Bildproportionen istWie weit außerhalb sich die Vignettierung erstreckt, im Bezug auf die halbe BilddiagonaleLegt fest, wie weit das Loch vom Mittelpunkt des sich bewegenden Zahnrads entfernt ist. 100% bedeutet, dass es sich am Rand des Zahnrades befindet.Umgang mit BildrändernZu verwendende Farben: Schwarz, RG, RGB (additiv) oder CMYKWie viele Pixel Abstand zwischen den ObjektenLegt fest, um welchen Wert beim Einfügen horizontal versetzt werden sollSo viel Speicher wird ungefähr zum Zwischenspeichern von Bildern verwendetLegt fest, wie viel gemeinsames Grau aus CMY herausgezogen werden sollLegt fest, um welchen Wert beim Einfügen vertikal versetzt werden sollLegt fest, wie der Gaußkernel diskretisiert wirdWie Elemente ausgerichtet werden sollen. 0 bedeutet am Anfang, 0,5 die Mitte und 1,0 bedeutet am Ende.Umgang mit Pixeln außerhalb des EingabepuffersSo wird bestimmt, was gefüllt werden soll (nonzero|evenodd)Füllungsart der SuperpixelFarbtonFarbtonkorrekturFarbton-FrequenzFarbton-PhasenverschiebungZentrum für die FarbtonauswahlBreite für die FarbtonauswahlFarbtonwert für obige Grau-EinstellungenFarbton-FarbsättigungICC-DateiladerICC-Profillader.ICC-ProfilspeichererIIRSymbolnameFür das Ausgabefenster zu verwendendes SymbolWenn gesetzt, wird das erzeugte Muster gekacheltWenn gesetzt, wird das erzeugte Muster etwas mehr verzerrtLegt fest, ob zentriert werden sollIgnorierenIgnoriert. Es wird immer die Mitte des Eingangspuffers benutztIlford Ilfobrom Galerie FB 1Ilford Ilfobrom Galerie FB 2Ilford Ilfobrom Galerie FB 3Ilford Ilfobrom Galerie FB 4Ilford Multigrade IV RC DeluxeLichtquelle anpassenIllusionIllusionstypBildFarbverlauf des BildesEin Wrapper für Image Magick mit der png-Op.Bild-Mischoperation »Durchschnitt« (<tt>c = (cA + aB)/2</tt>)Bild-Mischoperation 'Mischen reflektieren' (<tt>c = cB>=1.0?1.0:cA*cA / (1.0-cB)</tt>)Bild-Mischoperation »Negierung« (<tt>c = 1.0 - fabs(1.0-cA-cB)</tt>)Bild-Mischoperation »Weiches Nachbelichten« (<tt>c = (cA+cB<1.0)?0.5*cB / (1.0 - cA):1.0-0.5*(1.0 - cA) / cB</tt>)Bild-Mischoperation »Weiches Abwedeln« (<tt>c = (cA+cB<1.0)?0.5*cA / (1.0 - cB):1.0-0.5*(1.0 - cB)/cA</tt>)Bild-Mischoperation »Subtrahieren« (<tt>c = cA+cB-1.0</tt>)Bilddateiordner (Unterdatei)Methode zum Resampling des Bildes. Gute Ergebnisse mit doppeltem Resampling zum Retouchieren von Panoramas erzielt man mit »Nächste« zur Erstellung der Ansicht sowie »Kubisch« oder besser für die umgekehrte Transformation zurück zum Panorama.Jeden Kanal mit der gleichen Menge beeinflussenKontrast für Papiere mit festem Kontrast (für gewöhnlich Farbpapiere) erhöhenUnabhängige RGB-KanäleIndex der Komponente, die nicht markierte Pixel markiertIndex-SchrittUnendlichDas Eingabebild endlos wiederholen.Eingabe-PufferEingabeformatEingabe-Leuchtkraft, die niedrigste Ausgabe werden sollEingabe-Leuchtkraft, die weiß werden sollEingabe-Pad der Bildpuffer-Eingabe.Integrales BildBeabsichtigte TemperaturIntensitätIntensität-ModusAbstand zwischen Kacheln (in Pixeln)Interpolation zwischen Manhattan-Distanz und euklidischer Distanz.InterpolationsfarbraumUngültiger Graph, Abbruch.
Umgekehrte TransformationInvertierenBumpmap invertierenKomponente invertierenIm Wahrnehmungsraum invertierenMaske invertierenKehrt die Komponenten linear um (außer Alpha), wobei das Ergebnis das entsprechende »Negativbild« ist.Kehrt die Komponenten wahrnehmungsbasiert um (außer Alpha), wobei das Ergebnis das entsprechende »Negativbild« ist.Die extrahierte Komponente invertierenTrenner-Bereich invertierenKehrt lediglich die Wert-Komponente um, so dass das sich ergebende Bild invertierte Helligkeitswerte aufweist und die Farben beibehalten werden.Invertiertes BildIterationenJPEG2000-DateiladerJPEG2000-Bildlader, der Jasper verwendet.JPEG-DateiladerJPEG-DateispeichererQualität der JPEG-Kompression (zwischen 1 und 100)JPG-Bildlader, der libjpg verwendetJPEG-Dateispeicherer, verwendet libjpegJXJYFarbe der FugenJuliaX-Wert der Julia-Menge, PositionY-Wert der Julia-Menge, PositionAusrichtungK-Means-SegmentierungKaleidoskopBeibehaltenRGB-Pixelwerte innerhalb eines spezifischen Bereichs haltenVorzeichen behaltenBlau-Komponente erhaltenFarben erhaltenKomponente 1 erhaltenKomponente 2 erhaltenKomponente 3 erhaltenGerade Zeilen erhaltenGerade oder ungerade Zeilen erhaltenGrün-Komponente erhaltenFarbtonkomponente erhaltenDas Bild unverändert übernehmen, wo es nicht durch die Linse beeinflusst wird.Helligkeitskomponente erhaltenNegative Werte im Ergebnis behalten; wenn ausgeschaltet, wird der absolute Wert des Ergebnisses verwendet.Ungerade Zeilen erhaltenUrsprüngliche Umgebung beibehaltenRot-Komponente erhaltenSättigungskomponente erhaltenLAB ALAB BLAB LLCH C(ab)LCH H(ab)LCMS aus ProfilSegmentierung mittels Wasserscheidentransformation. Der Ausgabepuffer entspricht dem Eingabeformat. Unmarkierte Pixel werden durch einen Markierungswert einem Segment zugeordnet (Voreinstellung: die letzte Komponente mit NULL-Wert). Der Hilfspuffer ist ein »Y u8«-Bild, das die Prioritätsstufen darstellt (ein niedriger Wert entspricht einer höheren Priorität). Wenn es keinen Hilfspuffer gibt, haben alle markierten Pixel die gleiche Priorität und zugeordnete Markierungen haben eine niedrigere Priorität.LambdaLaplaceKantenerkennung nach LaplaceWeit 3x3Weit gestaffeltEbeneVorangestelltLinksLängeLänge der Unschärfe in PixelObjektivObjektiv-UnschärfeLinsenverzerrungLinsenreflexLinsenzentrum XLinsenzentrum YBrechungsindex der LinseDer Ursprungspunkt soll der mittlere seinStärke der Betonung auf Details im Bild-FarbverlaufGrad der GlättungStufe, die vollständige Transparenz repräsentieren sollFarbwerteLichtanpassungLichtwinkel (Grad)LichtfarbeLichtrichtungLichtfrequenz (blau)Lichtfrequenz (grün)Lichtfrequenz (rot)Schatten aufhellen und Glanzlichter abdunkelnHelligkeitHelligkeitskorrekturHelligkeitsfrequenzHelligkeits-PhasenverschiebungWie ein Gaußscher Weichzeichner, bei dem der Einfluss der Nachbarpixel je nach Farbunterschied vom mittleren Pixel gewichtet wird.Verformung im Bildbereich einschränken.Belichtung begrenzenLinienbreite begrenzenLinieLinienprofilLinienhöheLiniendickeLinienbreiteLinearLinearer FarbverlaufLineare BewegungsunschärfeLineares RGBLineares SinusoidLinearer Farbverlauf-RendererLinear maskierenLineare AusgabeLinear-VormultipliziertLinear-Vormultipliziert-Falls-AlphaKleiner PlanetLoHaloEine SVG-Datei mittels librsvg ladenLaden fehlgeschlagenGeladenProtokoll der FehlergewichtungLog2 der Diskretisierungsschritte der QuelleLogarithmischLogarithmische SpiralbasisLoglog-GlättungLange SchattenLängsgestreiftSchleifeNiedrige EingabeUntere GrenzeNiedrige EingabeUnterer SchwellenwertNiedrigste Leuchtkraftstufe in der AusgabeLua-FehlerMLS-GewichtungenMLS-Gewichte-AlphaMagenta-WinkelMagenta-FilterKompensation des Negativ-Bilds mittels Magenta-FilterMagenta-MusterMagenta-PeriodeGrößeAusmaß der Kontrastskalierung (>1,0 = aufhellen, <1,0 = abdunkeln)Ausmaß der zufälligen FarbvariationenHauptteilEingrauenNahtlos kachelnTurbulentes Rauschen erzeugenErmöglicht die nahtlose Kachelung des Eingabepuffers. Der Algorithmus achtet nicht auf den eigentlichen Inhalt, so dass das Ergebnis wahrscheinlich nachbearbeitet werden muss.HerstellerDer Absolutwert jeder linearen RGB-Komponente, fabs(eingabe_wert)Man O WarMandelbrotManhattanDynamikkompression nach Mantiuk 2006Absolute AbbildungRelative AbbildungUmgekehrt abbildenVon oben abbildenDas Bild in einen Kreis abbildenMaskeMaskenradiusMaskenradiusMaskenradius-PufferMathematische Addition. Wird pixelweise angewandt, wobei entweder die in »Wert« angegebene Konstante oder der entsprechende Pixel im Hilfspuffer als Operand verwendet wird. Das Ergebnis ergibt sich aus der Auswertung des Ausdrucks »Ergebnis = Eingabe + Wert«Mathematische Division. Wird pixelweise angewandt, wobei entweder die in »Wert« angegebene Konstante oder der entsprechende Pixel im Hilfspuffer als Operand verwendet wird. Das Ergebnis ergibt sich aus der Auswertung des Ausdrucks »Ergebnis = Wert==0.0f?0.0f:Eingabe/Wert«Mathematisches Gamma. Wird pixelweise angewandt, wobei entweder die in »Wert« angegebene Konstante oder der entsprechende Pixel im Hilfspuffer als Operand verwendet wird. Das Ergebnis ergibt sich aus der Auswertung des Ausdrucks »Ergebnis = (Eingabe >= 0.0f ? powf (Eingabe, Wert) : -powf (-Eingabe, Wert))«Mathematische Multiplikation. Wird pixelweise angewandt, wobei entweder die in »Wert« angegebene Konstante oder der entsprechende Pixel im Hilfspuffer als Operand verwendet wird. Das Ergebnis ergibt sich aus der Auswertung des Ausdrucks »Ergebnis = Eingabe * Wert«Mathematische Subtraktion. Wird pixelweise angewandt, wobei entweder die in »Wert« angegebene Konstante oder der entsprechende Pixel im Hilfspuffer als Operand verwendet wird. Das Ergebnis ergibt sich aus der Auswertung des Ausdrucks »Ergebnis = Eingabe - Wert«Mathematische Methode zur Rekonstruktion von PixelwertenGlobales MattingLevin-MattingMaxMax. IterationenMax. DeltaMaximale Anzahl zu verwendender Verbesserungspunkte für das Interpolations-GitterMaximaler WeichzeichnenradiusMaximalgrad der im Interpolationsnetz benutzten VerfeinerungspunkteMaximum-HüllkurveMaximaler Betrag der VerschiebungMaximaler UnterschiedMaximaler UnterschiedMaximaler Unterschied zwischen zwei Pixeln.Maximale Anzahl der WiederholungenLabyrinthLabyrinth-AlgorithmusGemittelte KrümmungsunschärfeMedian-WeichzeichnerMetadatenMetrikFür die Abstandsberechnung zu verwendende MetrikMittlere Werte zu SpitzenMittelpunktMittelpunkt (relativ)MinMinimum-HüllkurveSpiegeldrehungSpiegelMischenMischverteilung, ausgedrückt als Anteil des Zusatzwerts. 0=Eingabe, 0,5=Hälfte, 1,0=ZusatzwertModusArt des VersatzesModus der WertverteilungModellModell – das Basiselement, auf dem gearbeitet wirdModell alpha aModell alpha bModell alpha cModell alpha dModell blau aModell blau aModell blau cModell blau dModell grün aModell grün bModell grün cModell grün dModell rot aModell rot bModell rot cModell rot dFehler beim Laden von Modul »%s«: %sModulfehlerMono-MischerMonochromer KanalmischerSchwärzer (kleinerer Wert)DeckenderTransparenterWeißer (größerer Wert)MosaikFilter zur Umwandlung eines Bildes in ein Mosaik aus kleinen Primitiven, jedes einfarbig und alle ungefähr gleich groß.Pixel verschiebenPixel zufällig verschiebenBewegungsrateZähne des sich bewegenden ZahnradsMultiplikationsfaktor für die gewünschte Rotation des lokalen Raums für Texturen. Aufgrund der Berechnung schwächt es entsättigte Farben und verstärkt möglicherweise farbige Regionen.Vielzweck-Dateilader, der andere native Handler nutzt und im Ausweichfall eine Umwandlung mit »convert« von Image Magick ausführt.Vielzweck-Dateispeicherer, der andere native Handler abhängig von der Erweiterung nutzt. Formatspezifische Speicheroptionen werden zur Angabe zusätzlicher Parameter verwendet.»NULL« oder ein GeglBuffer, der die Verarbeitungsergebnisse zwischenspeichert. Es handelt sich um einen besonderen Puffer, für den »gegl_buffer_list_valid_rectangles« den gültigen Teil des Zwischenspeichers zurückgibt.NameNativVordere-ZNächsteNegativ-DunkelkammerNachbarschaftPerzentil des Nachbarschafts-AlphawertPerzentil der NachbarschaftsfarbeNachbarschaftsradius. Bei einem negativer Wert wird mit umgekehrten Perzentilen gerechnetNachbarschaft wird berücksichtigt. Für Verbesserungen sind ideale Werte nahe der längsten Seite des Bildes. Eine Erhöhung verlängert die LaufzeitDie Nachbarschaft wird berücksichtigt. Dies ist der Radius in Pixel, der berücksichtigt wird bei der Entscheidung, welche Farbe auf welchen Grauwert abgebildet wirdNachbarschaftstypNeon-KantenerkennungNiemalsZeitungsdruckKeine OperationKeine Operation (kann als Streckenpunkt verwendet werden)Operation »%s« existiert nichtNoHaloKnotenRauschenNachbar-RauschenRauschminderungLärm-BelästigungRauschverteilungRauschreduzierender und kantenerhaltender Weichzeichnenfilter, der auf dem symmetrisch nächsten Nachbarn basiertRauschen-StandardabweichungNicht-LinearNichtlineare KomponentenKeineNormal-MapNormales CompositingNormalisierenAusgabe auf Bereich 0,0 bis 1,0 normalisieren.Ausgabe auf den Bereich [Basis,Basis + Schritt] normalisierenNicht geladenNumPy-Dateispeicherer (Numerischer Python-Dateispeicherer)NumPy-DateispeichererAnzahl der MischstufenAnzahl der WeichzeichnungsstufenAnzahl der ClusterFarbanzahlAnzahl der Rechenschritte für die GraustufenmittlungAnzahl der Konturen (blau)Anzahl der Konturen (grün)Anzahl der Konturen (rot)Anzahl der Abtastpunkte einer Kurve. 0 steht für exakte Berechnung.Anzahl der sich unterscheidenden Pixel.Die Anzahl der zu verwendeten heruntergerechneten EbenenAnzahl der Durchläufe der Filterung. Ein Wert zwischen 2 und 4 sollte üblicherweise genügen.Anzahl der Einzelbilder in der GIF-AnimationAnzahl der Einzelbilder im Video. Wird aktualisiert, wenn das erste Einzelbild dekodiert wurde.Anzahl IntensitätenAnzahl der WiederholungenAnzahl der Iterationen. Eine höhere Zahl Iterationen liefert ein weniger verrauschtes Bild auf kosten von mehr RechenleistungAnzahl der Iterationen. Eine höhere Anzahl Iterationen liefert ein weniger verrauschtes Ergebnis auf Kosten von mehr RechenzeitAnzahl der Stufen für den Alpha-KanalAnzahl der Stufen für den Blau-KanalAnzahl der Stufen für den Grün-KanalAnzahl der Stufen für den Rot-KanalAnzahl der Stufen zum Errechnen der LösungAnzahl der zu verwendenden SpiegelAnzahl der Paare. Einen höhere Zahl bewahrt mehr DetailsAnzahl an Perioden je Kachel. Diese Kachelung vermeidet Anomalien von hohen Frequenzen, die durch den Winkelschub entstehenAnzahl der Messpunkte entlang jeder Achse pro PixelAnzahl der Messpunkte, die zum Antialiasing gemittelt werden.Anzahl der Messpunkte pro Iteration bei der Suche nach dem FarbumfangDie Anzahl der harten Kanten (blau)Die Anzahl der harten Kanten (grün)Die Anzahl der harten Kanten (rot)Anzahl der StrahlenDie Anzahl der SubdivisionenAnzahl der Zähne des feststehenden Zahnrads.Anzahl der Zähne im sich bewegenden Zahnrad. Der Radius des sich bewegenden Zahnrads (relativ zum Radius des feststehenden Zahnrads) wird über das Verhältnis der Zahnanzahl in den Zahnrädern bestimmt.Objekt, das Bild-Metadaten bereitstelltObjekt, das Bild-Metadaten empfängtObjekt, das Bild-Metadaten bereitstelltAchteckeVersatzX-VersatzY-VersatzVersatzwinkelVersatz der X-AchseVersatz der Y-AchseÖlgemäldeEines von: sRGB, Adobish, Rec2020, ProPhoto, Apple, ACEScg, ACES2065-1Eine oder mehrere R, G, B - Komponenten fehlenEine oder mehrere R, G, B - Komponenten haben vorzeichenbehaftete DatenNur FarbeDeckkraftDeckkraft des Strichs. Verhält sich nicht wie SVG, da derzeit dafür ein Airbrush-Werkzeug eingesetzt wirdDeckkraft des Strichs. Verhält sich nicht wie SVG, da derzeit dafür ein Airbrush-Werkzeug eingesetzt wird.Deckkraft-SchwellenwertGEGL-Puffer öffnenMit linearisierten RGB-Farbdaten arbeitenOperationOptimierenAusrichtungUrsprung der PolarkoordinatenX-UrsprungY-UrsprungUrsprüngliche TemperaturUnschärferadius, wenn ausserhalb des FokusAusgabemodusAusgabe-ZusammensetzungAusgabeformatAusgabe in eine DateiAusgabemodusAusgabe-Pad des erzeugten Bildpuffers.Gesamthelligkeit des BildsDen angegebenen Farbraum überschreiben. Wenn der Zeiger auf ein Format gesetzt wird, wird die String-Eigenschaft überschrieben; wenn ein Hilfspuffer gesetzt wird, werden beide überschrieben. PDF-SeitendecodiererPNG-BildladerPNG-BildspeichererPNG-Kompressionsstufe zwischen 1 und 9PNG-Bildlader.PNG-Bildspeicherer, verwendet libpngPPIPPM-BildladerPPM-BildspeichererPPM-Bildlader.PPM-Bildspeicher (Portabler Pixmap-Speicherer.)PS-Quadrat (oder euklidischer) PunktPackenVerpackt ein Bild horizontal oder vertikal nebeneinander mit optionalem Abstand, Zusatzwert rechts der Eingabe.SeiteDarzustellende SeiteSeitenMalende AuswahlDie Eingabe mit einer Farbe überlagern, wobei die Transparenz erhalten bleibt.Färbt jeden Nicht-Zentrumspixel mit der Farbe des nächsten Zentrumspixel ein.PaarePalettisierenSchwenkenPanorama-ProjektionPapierschnipselParametrischer Band-Equalizer zur Anpassung der Frequenzbänder eines Bildes. Die Operation stellt abstrahierte Eingabeparameter bereit, die zwei verschiedene Gauss-basierte Bandpassfilter kontrollieren, die das Bildsignal anpassen.Verarbeitungs-/Compile-Fehler, sofern vorhanden.Befehlszeile analysiert:
	Modus:   %s
	Datei:   %s
	xml:     %s
	Ausgabe: %s
	Ruhe:    %s
	
PasswortPasswort für die Entschlüsselung des PDF. Leer lassen für kein PasswortUntereinander einfügenDie umgewandelten Bilder untereinander einfügenAusschnitt-GrößePfadPfad zur zu ladenden GeglBuffer-Datei.Pfad der zu ladenden DateiPfad zur Datei, die geladen werden soll.Pfad der zu speichernden Datei.Pfad der zu ladenden VideodateiPfad zu v4l-GerätMusterAmplitude für Muster (logarithmische Skalierung)MusterdrehungDrehwinkel des MustersPuffer pro Pixel zur Modulation des Exponenten. Erwartet wird ein Skalierungsfaktor zwischen 0.0 und 1.0Puffer pro Pixel zur Modulation des Maskenradius. Erwartet wird ein Skalierungsfaktor zwischen 0.0 und 1.0SchwarzanteilWeißanteilSchwarzanteilPerzentilWahrnehmungWahrnehmung-VormultipliziertWahrnehmung-Vormultipliziert-Falls-AlphaEinen Graphen in einer lokalen Region schneidenFührt eine Korrektur der Schatten und Glanzlichter ausFührt ein grayscale2color-Demosaicing eines Bildes mittels Bimedian-Interpolation durch.Führt ein naives grayscale2color-Demosaicing eines Bildes ohne Interpolation durch.Führt eine Mittelung der benachbarten Pixel durch mittels der Normalverteilung als GewichtungFührt eine Kantenerkennung mittels Gaußscher Ableitung ausFührt eine N-Punkt-Bildverformung durchPeriodePeriode (Länge) der WellePeriode für X-AchsePeriode für Y-AchsePerlin-RauschenPerlin-RauschgeneratorPhase der X-AchsePhase der Y-AchsePhasenverschiebungFotokopieStückweise ZusammenführungDrückenDruckstärkePixbufSkript- und Prototypenerstellung von pixelbasierten Filtern/Composern mittels Lua. Weitere Informationen finden Sie unter http://pippin.gimp.org/image-processing/.VerpixelnPixelwerte, die höher als dieser Grenzwert sind, werden darauf eingestelltPixelwerte, die unter diesem Grenzwert liegen, werden darauf eingestelltPlasmaPunkte/Pixel pro ZollZeigerZeiger auf den Markierungswert für nicht markierte PixelPolarRPolarkoordinatenPolarisationPorter-Duff-Zusammenlegungsoperation src-in (d = cA * aB)Porter-Duff-Operation clear (d = 0.0f)Porter-Duff-Operation dst (d = cB)Porter-Duff-Operation dst-atop (d = cB * aA + cA * (1.0f - aB))Porter-Duff-Operation dst-in (d = cB * aA)Porter-Duff-Operation dst-out (d = cB * (1.0f - aA))Porter-Duff-Operation dst-over (d = cB + cA * (1.0f - aB))Porter-Duff-Operation (auch als Normalmodus oder src-over bekannt) (d = cA + cB * (1.0f - aA))Porter-Duff-Operation src (d = cA)Porter-Duff-Operation src-atop (d = cA * aB + cB * (1.0f - aA))Porter-Duff-Operation src-out (d = cA * (1.0f - aB))Porter-Duff-Operation xor (d = cA * (1.0f - aB)+ cB * (1.0f - aA))Position der Lichtquelle, welche die Zeichenfläche beleuchtet: Oben-Rechts, Oben-Links, Unten-Links oder Unten-RechtsPosterisierenExponent, um den Übergang zu streckenDas Negativ mit blauem Licht vorbeleuchten, um den Kontrast des Drucks zu verringernDas Negativ mit grünem Licht vorbeleuchten, um den Kontrast des Drucks zu verringernDas Negativ mit rotem Licht vorbeleuchten, um den Kontrast des Drucks zu verringernModell beibehaltenHelligkeit erhaltenPrewitt-KompassPrimzahl-AlgorithmusXML druckenProPhoto-RGBProgressivBestimmte Werte auf die benachbarten Pixel verteilen. Jede Farbe oder Deckkraft erodieren und dilatieren.Nach unten ausbreitenNach links verteilenNach rechts verteilenNach oben verteilenAlphakanal verteilenPropagier-RateWertekanal verteilenEigenschaften:ProportionDie obere Zeile in die Mitte und die untere Zeile auf die Außenseite platzierenQualitätRGBRGB BlauRGB GrünRGB RotRGBE-BildladerRGBE-DateispeichererRGBE Bild-Lader (Radiance HDR format).RGBE Bild-Speicherer (Radiance HDR format)RadialRadialer FarbverlaufRadialer Farbverlauf-RendererRadiusRadius (1.0 ist der größtmögliche Kreis, der ins Bild passt, und 2.0 berührt die Ecken)Radius 1Radius 2Radius des Kreises um Pixel, kann auch pro Pixel durch einen Puffer auf dem Hilfs-Pad skaliert werden.Radius des Effekts (in Pixel)Radius des feststehenden ZahnradsRadius der Zeilenpixelregion (Größe entspricht Radius*2+1)Radius der Quadratpixelregion (Breite und Höhe sind Radius*2+1)Radius der Quadratpixelregion (Breite und Höhe sind Radius*2+1)Radius der SupernovaRadius des VerarbeitungsfenstersRadius des Wavelet-WeichzeichnersZufälligZufällige KovarianteZufälliger FarbtonAnfangswert für ZufallszahlenZufälligkeit (%)Farbton, Sättigung und Wert unabhängig voneinander zufällig festlegenHelligkeit, Farbart und Farbton unabhängig voneinander zufällig festlegenZufällig vermischte PixelEinige Pixel zufällig mit ihren Nachbar-Pixeln vertauschenEinige Pixel zufällig nach unten verschieben (vergleichbar mit Schmelzen)RangVerhältnisRaw-FormatLader von Rohdatenbildern, der dcraw mit pipes umschließt. Stellt die rohe Bayer-Matrix als Graustufenbild zur Verfügung. Ist das Dateiformat ».rawbayer«, wird statt dem normalen dcraw-Lader dieser Lader verwendet. Ist das Dateiformat ».rawbayerS«, werden die zurückgegebenen 16-Bit-Zahlen vertauscht (der pnm-Lader ist offenbar fehlerhaft)LesenLesen/SchreibenRechteckRekursive TransformationRotRot-Kanal-VerstärkerRote Augen entfernenRot-SchwellenwertRot-und-Cyan-WinkelRot-und-Cyan-MusterRot-und-Cyan-PeriodeRot-WinkelRoter AnwendungsmodusRoter KanalRote KonturenRote-Augen-SchwellwertRot-FrequenzRot-nach-Blau-KanalRot-nach-Grün-KanalRot-nach-Rot-KanalRot-UmkehrungRot-StufenRot-MusterRot-PeriodeRot-PhasenverschiebungRote VorbelichtungRote harte KantenFaktor der Rot-DehnungRot-Schwellenwert der EingangsfarbeReduziert die Anzahl der Farben des Bildes, indem die Anzahl der Bits pro Kanal verringert wird (Farben und Alpha). Verschiedene Dithering-Methoden können angegeben werden, um der durch Quantisierung verursachten Streifenbildung entgegenzuwirken.Reduziert die Anzahl der Stufen jeder Farbkomponente des Bilds.ReferenzVerfeinerungsgradVerbesserungsschritteReflektierenEin Bild an einer Linie spiegeln, deren Richtung durch den in den Eigenschaften x und y angegebenen Vektor bestimmt wird. Das Muster horizontal spiegelnRegionsgrößeGeometry regularisieren, wobei die Geschwindigkeit proportional zu der lokalen gemittelten Krümmungsunschärfe istDynamikkompression nach Reinhard 2005Kolorimetrisch (relativ)Relative Helligkeitsänderung in BlendenzahlenRelative Helligkeit jeder Belichtung in EVRelative HervorhebungsstärkeÜbersichtBildet den Intensitätsumfang des Bilds neu abMischt durch Definition relativer Anteile aus Quellkomponenten die Farben neu.Den durch Blitzgeräte hervorgerufenen Rote-Augen-Effekt entfernenPfad darstellenSpyrograph darstellenText darstellenEin Schachbrettmuster darstellenGerenderte Höhe in Pixel (schreibgeschützt)Gerenderte Breite in Pixel (schreibgeschützt)DarstellungszielDarstellung mehrerer verschiedener Fraktalsysteme mit einstellbaren Optionen zur Farbgebung.DarstellungstypEin Spyrograph-Muster darstellenMalt einen PinselstrichRendert eine gefüllte RegionZeichnet einen VektorstrichZeichnet Leuchtkraft-Profile für rote, grüne und blaue Komponenten entlang der angegebene Linie in den Eingabepuffer. Ausgabe in einen Puffer der angegebenen Größe.WiederholungEinen Farbbereich durch einen anderen ersetzenErsatzfarbe.Repositioniert den Puffer (mit Subpixel-Genauigkeit). Wenn Ganzzahlen als Koordinaten angegeben werden, wird ein schnellere Variante ohne Resampling verwendetResampling-MethodeBildgröße insgesamt neu skalierenAuf Ursprung zurücksetzenAuflösung in PixelErgebnisdrehungKachelbarkeit beibehaltenRechtsSteifheitKräuselnRobertsDrehenUm das Zentrum drehenDen Puffer um den angegebenen Ursprung drehen und auf mögliche Versätze achten.Den Puffer um den angegebenen Ursprung drehen.GedrehtDrehungAuf die Spiegel angewendete DrehungAuf das Ergebnis angewendete DrehungWinkel der Drehungsunschärfe. Ein großer Winkel kann einige Zeit für die Darstellung benötigenRaue KacheloberflächeRundSDL-AnzeigeSDL2-AnzeigeSVG-BildladerSVG Farbton-RotationSVG-Leuchtdichte zu AlphaSVG-MatrixSVG-SättigungSVG-Mischoperation Farbe nachbelichten (<code>if cA * aB + cB * aA <= aA * aB: d = cA * (1 - aB) + cB * (1 - aA) andernfalls: d = (cA == 0 ? 1 : (aA * (cA * aB + cB * aA - aA * aB) / cA) + cA * (1 - aB) + cB * (1 - aA))</code>)SVG Mischoperation Farbe abwedeln (<code>if cA * aB + cB * aA >= aA * aB: d = aA * aB + cA * (1 - aB) + cB * (1 - aA) andernfalls: d = (cA == aA ? 1 : cB * aA / (aA == 0 ? 1 : 1 - cA / aA)) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG Mischoperation verdunkeln (<code>d = MIN (cA * aB, cB * aA) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG Mischoperation Unterschied (<code>d = cA + cB - 2 * (MIN (cA * aB, cB * aA))</code>)SVG Mischoperation Ausschluss (<code>d = (cA * aB + cB * aA - 2 * cA * cB) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG Mischoperation Farbe abwedeln (<code>if 2 * cA < aA: d = 2 * cA * cB + cA * (1 - aB) + cB * (1 - aA) andernfalls: d = aA * aB - 2 * (aB - cB) * (aA - cA) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG Mischoperation aufhellen (<code>d = MAX (cA * aB, cB * aA) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG Mischoperation Überlagern (<code>if 2 * cB > aB: d = 2 * cA * cB + cA * (1 - aB) + cB * (1 - aA) otherwise: d = aA * aB - 2 * (aB - cB) * (aA - cA) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG Mischoperation plus (<code>d = cA + cB</code>)SVG Mischoperation Bildschirm screen (<code>d = cA + cB - cA * cB</code>)SVG Mischoperation Weiche Kanten (<code>if 2 * cA < aA: d = cB * (aA - (aB == 0 ? 1 : 1 - cB / aB) * (2 * cA - aA)) + cA * (1 - aB) + cB * (1 - aA); if 8 * cB <= aB: d = cB * (aA - (aB == 0 ? 1 : 1 - cB / aB) * (2 * cA - aA) * (aB == 0 ? 3 : 3 - 8 * cB / aB)) + cA * (1 - aB) + cB * (1 - aA); otherwise: d = (aA * cB + (aB == 0 ? 0 : sqrt (cB / aB) * aB - cB) * (2 * cA - aA)) + cA * (1 - aB) + cB * (1 - aA)</code>)SVG Farbmatrix-Operation svg_huerotateSVG Farbmatrix-Operation svg_luminancetoalphaSVG Farbmatrix-Operation svg_matrixSVG Farbmatrix-Operation svg_saturateSVG-Stilbeschreibung der TransformationPrüfpunkteSamplerIntern verwendeter SamplerMusterSättigungSättigungsanpassungSättigungsfrequenzSättigungs-PhasenverschiebungSättigungswert für obige Grau-EinstellungenSpeichernSägezahnSkalare Schwellenwertstufe (wird außer Kraft gesetzt, wenn ein Hilfseingangspuffer vorgesehen ist).SkalierungGröße 1:1 skalierenSkalierungsfaktor, um die Darstellung zu vergrößernMaßstab des BildesSkalierungsverhältnisSkalierungsgrößeGrößenskalierung behält Seitenverhältnis beiSkalierung der X-AchseSkalierung der Y-AchseSkalierung, Stärke des EffektsScale3X-KantenglättungSkaliert den Puffer entsprechend eines Seitenverhältnisses.Skaliert den Puffer entsprechend einer Größe.Skaliert den Puffer auf eine Größe und behält das Seitenverhältnis beiSkaliert die Pufferkomponenten in den Bereich 0,0 - 1,0. Somit werden Bilder verbessert, die den möglichen Kontrast nur schlecht ausnutzen (wenig Kontrast, sehr dunkle oder sehr helle Bilder).Skaliert die Komponenten des Puffers in den Bereich von 0.0 bis 1.0. Dies verbessert Bilder, die den verfügbaren Kontrastraum nur unzureichend ausfüllen (kontrastarme, sehr dunkle oder sehr helle Bilder). Diese Version unterscheidet sich von der herkömmlichen Kontrastspreizung dadurch, dass sie im HSV-Raum arbeitet und dabei den Farbton erhält.SkalierenSkalierungsfaktor für Bildfeatures am Radius. Bei »-1« heben sie sich auf, bei »1.0« verstärkt die KanteSkalierungsfaktor für Unscharfmaske, die Stärke der WirkungStreuungStreuung (Geschwindigkeit gegen Qualität)SkriptZweites zusätzliches Eingabe-Pad des Bildpuffers.Kanten als ZentrenFarben mittels K-Means-Clustering segmentierenDen n-ten nächsten Punkt auswählenSelektiver Gaußscher WeichzeichnerSelektive FarbtonsättigungFarbton, Sättigung und Helligkeit selektiv anpassenTrennerSepiaStellen Sie im Zweifel »Nativ« ein. Die CIE-basierten Räume könnten Farbtonverschiebungen hervorrufen.Blauanteil für den Blau-KanalBlauanteil für den Grün-KanalBlauanteil für den Rot-KanalGrünanteil für den Blau-KanalGrünanteil für den Grün-KanalGrünanteil für den Rot-KanalRotanteil für den Blau-KanalRotanteil für den Grün-KanalRotanteil für den Rot-KanalLegt die Höhe in Pixel fest, an der der Text vertikal ausgerichtet wird, -1 bedeutet keine vertikale Ausrichtung.Legt die Breite in Pixel fest, bei der lange Zeilen umgebrochen werden, -1 bedeutet kein Umbruch.Verschiedene einfache Methoden zum Erkennen von KantenSchattenwinkelSchattenfarbeSchatten-Mittelpunkt bei VerblassenSchatten-Mittelpunkt bei Verblassen, als relativer Faktor zur SchattenlängeSchattenlängeSchatten minus BildNur SchattenSchatten plus BildSchattenstilSchattenFarbkorrektur der SchattenSchatten-GlanzlichterFormSchärfen (Unscharf maskieren)Das Bild schärfen, indem die Differenz zu einem weichgezeichneten Bild hinzugefügt wird. Diese Technik wurde ursprünglich in Dunkelkammern verwendet.SchärfeScherenSchert den Puffer. VerschiebungX-VerschiebungY-VerschiebungVerschiebungsrichtungJede Spalte oder Zeile um zufällige Werte verschiebenWeißpunkt verschiebenLegt fest, ob die Ausgabegröße auf die Eingabegröße zugeschnitten werden sollGEGL-Optionen anzeigenEinstellungen der Lichtquelle anzeigenEinstellungen zur Vorbelichtung anzeigenBereich schrumpfenSierpinskiEinfaches lineares iteratives ClusteringSimplex-RauschenDas Bild in eine Matrix einfarbiger Rechtecke vereinfachenVergrößerung eines Negativ-Films in einer analogen Dunkelkammer simulieren.Simuliert eine antike GravurFarbverschiebungen eines Kopierers simulierenSimuliert eine Verzerrung wie durch rechteckige Glaskacheln betrachtetSanftes Leuchten durch Intensivieren und Unschärfen der Lichter simulierenLinsenunschärfe außerhalb des Fokus simulierenSimuliert einen Cartoon, der mit schwarzem Filzstift gezeichnet und die Flächen nachträglich farbig ausgemalt wurden. Dies wird durch Anpassung der Kanten und dunklen Bereiche erreicht, die bereits deutlich dunkler als deren Umgebung sindSimuliert ein ReliefbildSimuliert die optische Verzerrung einer dem Bild überlagerten elliptischen LinseSinusSinusSinuskurveGrößeX-GrößeY-GrößeGröße einer RegionsseiteLänge einer Kante des Quadrats, welches das Netz bildetGröße der Ausschnitte, die zur Rauschunterdrückung verwendet werdenGrößenverhältnis XGrößenverhältnis YWeichzeichnen durch Domänen-TransformationGlatte VerformungGlättenGlättungsfaktor von 1 bis 100; 0 deaktiviert die GlättungGlattheitSobelHKantenerkennung nach SobelSanftes LeuchtenWeichheitKompaktes RauschenQuelleQuellenprofilPfad zur Quelldatei (png, jpg, raw, svg, bmp, tif, …)RaumnameAbstandRäumliche AusdehnungRäumliche RegularisationRäumliche Standardabweichung des Weichzeichnerkernels, angegeben in Pixeln.Spatio Temporal Retinex-like Envelope with Stochastic SamplingSpezialisierte richtungsabhängige KantenerkennungSphärischKugelkappenspitzenwinkel, als Bruchteil des Co-Winkels der AnsichtSphärisierenSpiderVerdrehenDrehen in der KameraachseSpiraleUrsprung der X-Koordinate der SpiraleUrsprung der Y-Koordinate der SpiraleSpiralradiusSpiraldarstellungSpiraldrehungVerwirbelungsrichtung der SpiraleSpiraltypSpyrographQuadratischQuadratgrößeQuadrateQuetschenGestaffeltStandardabweichung (räumlicher Skalierungsfaktor)Standardabweichung der horizontalen AchseAnfangsfarbeStartwinkel für die Drehung der ZielfarbeStartwinkel für die Drehung der QuellfarbeVon rechts statt von links beginnenX-StartkoordinateY-StartkoordinateStd.abw.SchrittStop 1Stop 2Stop 3Stop 4Stop 5Bild in ein GdkPixbuf speichern.In ein GdkPixbuf speichernSpeichert das ICC-Profil, das bei einer Speicherung als Bild in diesem eingebettet werden würde.StärkeStärke des EffektsStärke der lokalen DetailverbesserungStärke des Sepia-EffektsKontrastspreizungKontrastspreizung (HSV)Vergrößert die Farbsättigung, um den maximal möglichen Bereich auszunutzen, wobei Farbton und relative Helligkeit nicht verändert werden.Darzustellende Zeichenkette (UTF-8)GestreiftStrichStrichfarbeDeckkraft des PinselsPinselbreiteStilStil des EffektsSubdivisionenTeilmengeSubtrahierenEine Vielzahl veränderter Kopien eines Bildes überlagern.SupernovaSuperpixel basierend auf k-Means-ClusteringAuf der Wasserscheidentransformation basierende SuperpixelFarbe der SuperpixelGröße der SuperpixelSupersamplingObermengeOberflächencharakteristikIm Uhrzeigersinn verwirbelnGegen den Uhrzeigersinn verwirbelnAuf im Uhrzeigersinn wechselnSymmetrisch nächster NachbarTIFF-DateiladerTIFF-DateispeichererTIFF-Bild mittels libtiff ladenTIFF-Bild mittels libtiff speichernZiel-Bitrate des kodierten Videos in kB/sZielpfad zum Speichern des GeglBuffer.Zielpfad und DateinameZielpfad und Dateiname, für die Standardausgabe verwenden Sie »-«Zielpfad und Dateiname, für die Standardausgabe verwenden Sie »-«.Zeitliches WeichzeichnenTestoperation für eine 1:1-Abbildung von Eingabe zu Ausgabe, während der AbtastungTextDas Bild wird wie eine Künstlerleinwand texturisiert.Zeichenfläche texturisierenDer GeglBuffer, welcher in die Weiterleitung geladen werden sollBetrag, mit dem die Höhenwerte skaliert werdenMenge der Kontrast-KompressionDas Babl-Format der EingabeDas Babl-Format der AusgabeDas babl-Format der Ausgabe von GeglBuffer, NULL bedeutet Format des EingabepuffersDie HintergrundfarbeDas cmsHPROFILE entsprechend des ICC-Profils der Eingabedaten.Die Farbe bei (x1, y1)Die Farbe bei (x2, y2)Die Farbe einer Supernova.Die zu wechselnde Farbe.Die Farbe, die in Transparenz umgewandelt werden soll.Die zu überlagernde FarbeDie Darstellungsfarbe (Voreinstellung ist »black«)Komponente der X-KoordinatenKomponente der Y-KoordinatenDie Kontrastkurve.Anzahl der Bildpunkte, die gleichzeitig berechnet werdenDie Distanz, die sich der Schatten ausbreitet bevor er verwischt; ein negativer Wert zieht den Schatten stattdessen zusammenDie zu verwendende Dithering-MethodeDer Blendenschritt beim Abwedeln/Nachbelichten für einen rein weiß/schwarzen HilfseingangDie zu verwendende Deckkraft der FüllungDie zu verwendende Deckkraft der Füllung.Die Farbe der ersten KachelDie VordergrundfarbeDer Vordergrund enthält Löcher und/oder mehrere nicht verbundene TeileDer Vordergrund enthält keine undurchsichtigen TeileDer Vordergrund ist zu klein, um verwendet zu werdenDer Grenzwert, ab dem Farben überdeckend bleiben.Die Grenze, unterhalb der Farben transparent werden.Der Ort, wo die Ausgabe von GeglBuffer gespeichert werden sollDas lua-Skript mit der Implementierung dieser Operation.Der maximale Unterschied im Wert, bei dem ein Pixel verteilt wirdDer Mindestunterschied im Wert, bei dem ein Pixel verteilt wirdDie Anzahl gleichzeitig berechnender ThreadsAnzahl der Iterationen der DeformationDie Anzahl der DivisionenAnzahl der Rauschoktaven.Anzahl der Pixel in einer Wiederholung des Grundmusters mit der Grundauflösung.Die undurchsichtigen Bereiche des Vordergrunds sind nicht über dem Hintergrund!Ausrichtung der Weichzeichnung - horizontal/vertikalDer von dem Prozess erzeugte Pixbuf wird in diesem Attribut gespeichertDie Darstellungsqualität, zwischen 0.0 (schnell) und 1.0 (Referenzwert)Die Zufallsdatenquelle für Strahlenanzahl und ZufallsfarbtonZufallsgenerator für die RauschfunktionDie Referenz-Kennung, die als Eingabe verwendet wird (zur Verwendung in XML).Das in der Umwandlung beabsichtigte Darstellungsziel.Die Skalierung der RauschfunktionDie Farbe der zweiten KachelDie Schattenfarbe (Voreinstellung ist »schwarz«)Die Form der PixelDie Form, mit der sich der Schatten ausweitet oder zusammenziehtDie Stärke, mit der ein Pixel an seine Nachbarn verteilt wirdDie Hintergrundfarbe der KachelnDieser Wert stellt den Beitrag des vergangenen zum neuen Einzelbild ar.Die Breite des Pinsels, mit dem der Pfad gemalt wirdDie Breite des Pinsels, mit dem der Pfad gemalt wird.Es gibt ein Problem in der Syntax oder in der Anwendung der eingelesenen Eigenschaftswerte. Dies sollte dennoch in den meisten Fällen funktionieren.Dieser Weichzeichner wird für den Wavelet-Zerlegungsfilter verwendet, wobei jeder Bildpunkt aus einem anderen mittels HAT-Transformation errechnet wirdDiese Funktion simuliert die Verschlechterung der Darstellung, wie auf einem alten niedrig auflösenden RGB-Videomonitor.Dieses Plugin erzeugt den Effekt einer explodierenden Supernova. Die Stärke des Lichteffekts ist etwa umgekehrt proportional zum Radius (Abstand vom Zentrum des Sterns zum Effekt).Dieses Plugin verwendet den von John Schlag in »Fast Embossing Effects on Raster Image Data« in Graphics GEMS IV (ISBN 0-12-336155-9) beschriebenen Algorithmus. Es wendet einen Puffer als Bumpmap auf einen anderen Puffer an, um einen ansprechenden Prägeeffekt zu erzielen.SchwellwertOberer SchwellwertUnterer SchwellwertÜberführt das Bild nach schwarz/weiß mit einem Schwellwert, der entweder auf dem globalen Wert in der Wert-Eigenschaft festgelegt ist, oder pro Pixel von der Hilfseingabe.KachelGlaskachelKachelhöheKachelbreiteKachelfarbe basierend auf dem Durchschnitt der zusammengefassten PixelFarbvariation der KachelnKachelgeometrieKachelhöheKachelpräzisionKachelsättigungKachelgrößeKachelabstandKachelbarGekacheltGekachelte BumpmapNeigenTitel für das AusgabefensterBisNach 0Nach 1Nach 2Nach 3Nach 4Nach 5Nach 6Nach 7Nach FarbeNach untenNach linksIn PolarkoordinatenNach rechtsNach obenObenOben-LinksOben-RechtsAnzahl Seiten insgesamt, als visuelle schreibgeschützte Eigenschaft bereitgestelltAngehängtTransformierenBild mit den Fraktalen transformierenTransformationsstring in der Transformation-SVG-SyntaxTransformationsmatrix mit SVG-Syntax (oder mehreren Matrizen, getrennt durch Semikolons)ÜbersetzenOben links zu 0,0 übersetzen.Transparenz-SchwellenwertTransparentWie diese behandelnBehandeln wie: Graue Farben aus der obigen Ursprungsbereich werden so behandelt, als hätten sie diesen Farbton und Sättigung
Ändern zu: Graue Farben in diesen Farbton und diese Sättigung ändernDreieckDreieckeY trimmenY trimmenTrimap-EinflussfaktorTurbulenzTurbulenzBild in Graustufen umwandeln und ein übersättigtes Raster überlagern. Durch Farb-Assimilation im menschlichen visuellen System erzeugt dies bei einigen Rasterstufen die Illusion, dass die Zellen im Graustufenraster ebenfalls Farben besitzen.Wandelt das Bild in Graustufen umTypTyp 1Typ 2Typ des GeglSampler, der zum Holen der Eingabepixel verwendet wirdDas zu verwendende RGB-SchemaFraktaltypTyp der IllusionAbbildungstypAdresseAdresse der zu ladenden DateiAdresse der zu ladenden Datei.Adresse der zu ladenden DateiAdresse der zu ladenden Datei.Adresse des zu ladenden Bildes.Bild konnte nicht in den sRGB-Farbraum umgewandelt werdenFarbausgabeprofil konnte nicht erzeugt werdenJPEG2000-Bild konnte nicht geöffnet werdenDatei kann nicht gelesen werden: %sUnbekannter GeglOption-Modus: %dUnbekanntes JPEG2000-BildformatVormultiplikation eines Puffers rückgängig machen, der vormultiplizierte Farben enthält (aber gemäß dem babl-Format nicht).Vormultiplikation von Alpha rückgängig machenFarbe der Nicht-ZentrenNicht unterstützte JPEG2000-Datei mit Tiefe %dNicht unterstützter FraktaltypNicht unterstützter Fraktaltyp: %dNicht unterstützte nicht-RGB JPEG2000-Datei mit %d KomponentenOberer SchwellenwertMLS-Gewichtungen berücksichtigenEine Gaußsche Rauschverteilung verwenden, ansonsten eine lineare RauschverteilungVerwendet einen vorhandenen GeglBuffer im Hauptspeicher als Bildquelle.Einen GeglBuffer auf einem Datenträger als Datenquelle nutzen.Lineare Werte für die Maske verwendenLineare anstatt der Gamma-korrigierten Ausgabe verwendenLokale Region verwendenOptimierte Huffman-Tabellen verwendenPixel-Helligkeitswerte verwendenStatt linearem Gamma sRGB verwendenDen ganzen [0, 1]-Bereich zum Kodieren der Z-Koordinaten nutzenBenutzerwertDen GdkPixbuf verwenden, der sich im Speicherorf in <em>pixbuf</em> befindet.WertWert-UmkehrungWerte verteilenWert untenWert obenWert-Exponent (logarithmische Skala)WertversatzWerteVariabler WeichzeichnerVektorVektorstrichVertikalVertikales Schwenken der KameraVertikaler VersatzVertikale AusdehnungVertikale AusrichtungVertikale Ausrichtung 0.0 entspricht oben, 0.5 entspricht mittig und 1.0 entspricht unten.Vertikaler VersatzVertikaler Versatz (vom Ursprung) für den Anfang des RastersVertikaler Versatz von Blöcken in PixelnVertikale MusterskalierungVertikale PositionVertikale Position in PixelVertikaler SkalierungsfaktorVertikaler Schatten-VersatzVertikaler ScherbetragVertikale GrößeVertikales Größenverhältnis eines Punkts innerhalb jedes BlocksVertikale StreumengeVertikale Textausrichtung (0=oben, 1=Mitte, 2=unten)Vertikale TexturgrößeVertikale VerschiebungVertikale Breite der Zellen-PixelVideoverschlechterungVideo-PuffergrößeVideo-CodecZu verwendender Video-Codec, oder »auto«, um eine sinnvolle Voreinstellung basierend auf dem Containerformat zu verwenden.Video4Linux EinzelbildquelleVideo4Linux Eingang, Webcams, Framegrabber und ähnliche Geräte.Video4Linux2-EinzelbildquelleVideo4Linux Eingang, Webcams, Framegrabber und ähnliche Geräte.VignetteVignettierungsformAnpassungsmaske visualisierenVoronoi-DiagrammVerformenVerzerrt die Farben eines Bildes zwischen Farben mit gewichteten Verzerrungsfaktoren, Farbpaare von schwarz zu schwarz werden bei der Erstellung der Zuordnung ignoriert.WasserhöheWasserpixelWasserscheidentransformationWellentypWellenWebP-DateiladerWebP-DateispeichererQualität der WebP-KompressionWebP-Bildlader.WebP-BildspeichererSigma der Verteilung gewichten, um die Beiträge zur Antwort kontrolliertSigma gewichtenGewichtete ZusammenführungGewichtet die Deckkraft der Eingabe sowohl nach dem Wert der externen Eingabe und dem Globalwert.Der für die Transformation zu verwendende FarbraumDie für die Kacheln zu verwendende FormWenn WAHR, wird das Modell nicht freigegebenWenn aktiviert, werden auch die Schattenregionen verstärkt - wenn deaktiviert, wird ein natürlicheres Ergebnis erzieltFalls aktiviert, werden Schattendetails auf Kosten des Rauschens verbessertLegt fest, ob mit Gamma-korrigierten Werten anstelle von linearem RGB gearbeitet werden soll. Es verhält sich wie der alte Normalisierungsfilter in GIMPWo GEGL den Auslagerungsspeicher abspeichertDie Funktion addiert das Ergebnis zum Originalbild.Legt fest, ob Bildkanten ebenfalls Zentren sein könnenLegt fest, ob die Farbe eines Pixels verteilt werden sollLegt fest, ob die Deckkraft eines Pixels verteilt werden sollGibt an, ob das RGB-Muster um 90 Grad gedreht werden soll.WirbelDrehen und drückenWirbelwinkel (Grad)WeißWeiß auf SchwarzWeißabgleichWide-Gamut-RGBQuergestreiftBreiteBreite des gerenderten BildesBreite des Farbton-Auswahlintervalls  Die Breite der Blöcke in PixelDie Breite der Rasterlinien in PixelBreite des generierten PuffersBreite der KachelVerwindenWindähnlicher VerwehungseffektFenstertitelUmbrechenUmbruchhöheBild um eine kugelförmige Oberfläche wickelnEingabe umbrechenAngeschnittene Kacheln umbrechenUmbruchbreiteSchreibenSchreib-PufferKameranamen korrekt angebenEingehende Daten in eine bestehende Zielfläche für einen GEGL-Puffer schreiben.Objektivhersteller korrekt angebenNamen des Objektivmodells in Großbuchstaben schreibenSchreibt Bilddaten in einen bestehenden PufferFalsche PixelXX-AmplitudeX-KomponenteX-VersatzX-PeriodeX-PhaseX-SkalierungX-GrößeX-Achsenverhältnis für den Mittelpunkt der SpiegelungX-Achsenverhältnis zum Trimmen der SpiegelflächeX-Koordinate des UrsprungsDie X-Koordinate der MustermitteX-Koordinate des VersatzzentrumsX-Koordinate des Mittelpunkts der SupernovaX-Koordinaten des Zentrums des LinsenreflexesX-VersatzX-MultiplikatorX-PositionX-Versatz im FraktalraumX-Startposition des erzeugten PuffersX0X1X1-Wert, PositionX2X2-Wert, PositionYY-AmplitudeY-KomponenteY-VersatzY-PeriodeY-PhaseY-SkalierungY-GrößeY-Achsenverhältnis für den Mittelpunkt der SpiegelungY-Achsenverhältnis zum Trimmen der SpiegelflächeY-Koordinate des UrsprungsDie Y-Koordinate der MustermitteY-Koordinate des VersatzzentrumsY-Koordinate des Mittelpunkts der SupernovaX-Koordinaten des Zentrums des LinsenreflexesY-VersatzY-PositionY-Versatz im FraktalraumY-Startposition des erzeugten PuffersY'CbCr CbY'CbCr CrY'CbCr Y'Y0Y1Y1-Wert, PositionY2Y2-Wert, PositionGelb-WinkelGelb-FilterKompensation des Negativ-Bilds mittels Gelb-FilterGelb-MusterGelb-PeriodeZ-Koordinate der vorderen ClippingebeneZ-MultiplikatorZ-VersatzVergrößernIn den Fraktalraum hineinzoomenVergrößerungsstufeZoom-BewegungsunschärfeZoom-Bewegungsunschärfe[op [Eigenschaft=Wert] [Eigenschaft=Wert]] [[op] [Eigenschaft=Wert]Ein GeglBuffer zum Öffnen vom DatenträgerAlpha-AdditionAnteilAudioAudio-Bitrate in kbit/sAudio-BitrateAudio-CodecAudio-KanäleAudio-BitrateNeu laden so oft je Sekunde automatisch auslösen.babl-FormatZwei Bilder anhand der Alpha-Werte als Gewicht zusammenführenEin neuer Jasper-Datenstrom konnte nicht erzeugt werdenJPEG-2000-Datei konnte nicht abgefragt werdenAktuelle Einzelbildnummer, kann geändert werden, um das Bild neu laden zu lassen.JPEG2000-Bild in »%s« konnte nicht geöffnet werdenZu ladenden DateiMarkierungGleitkomma. -1 bedeutet automatisch, 0 bedeutet Ganzzahl und 1 bedeutet Gleitkomma.EinzelbildZu dekodierende EinzelbildnummerEinzelbild-VerzögerungEinzelbildrateEinzelbilderGlobale QualitätEs wird der globale Wert benutzt, wenn aux keine Daten enthältGlobales Maß der Gewichtunggluasgop-sizeBestimmung der Füllung (nonzero|evenodd)i-quant-factori-quant-offsetkeyint-minlibraw-DateiladerListe von <Zahlen>max_b_framesmax_qdiffme-subpel-qualityme_rangeRauschminderungZahl der Stufen je KomponenteOperation »%s« wurde nicht gefunden, teilweise Übereinstimmungen: X-UrsprungY-UrsprungAusgabe-/Darstellungshöhe in Pixel, -1 für EingabehöheAusgabe-/Darstellungsbreite in Pixel, -1 für EingabebreitePfad zur Datei, in die geschrieben werden soll.PDF-LaderPipelineZeiger auf const * Babl spacePosition des Symmetriezentrums in der Ausgabeqblurqcompressqmaxqminregion-heightregion-widthregion-xregion-ys RGBsRGBBeispiel-Eingabedaten mit einem Hilfspuffer, der absolute Quell-Koordinaten enthältBeispiel-Eingabedaten mit einem Hilfspuffer, der relative Quell-Koordinaten enthältSkalierungsfaktor der Verschiebung, der den Bezug der Größe der räumlichen Verschiebung zu einem relativen Abbildungswert von 1.0 darstellt.Szenenwechsel-SchwellwertFarbraum festlegen, mit dem nachfolgende babl-Formate in der Pipeline erstellt werden. Ebenfalls kann das ICC-Profil festgelegt werden, das gegebenenfalls für eine externe Farbverwaltung eingebettet wird. Wenn der Zeiger auf ein Format gesetzt wird, wird die String-Eigenschaft überschrieben; wenn ein Hilfspuffer gesetzt wird, werden beide überschrieben. quadratisches IntegralPixelkomponenten individuell strecken anhand von Leuchtdichte-HüllkurvenSVG-Stilbeschreibung der Transformation.Zu verwendende Kachelgröße.Kompromiss zwischen der Superpixel-Regularität und der Einhaltung der ObjektgrenzentrellisUnbehandelte Pfaddaten %s:%s
Unbekannter ModusAdresse der zu ladenden DateiAufruf: %s [Optionen] <Datei | -- [op [op] ..]>

  Optionen:
     -h, --help      zeigt diese Hilfe an

     --list-all      zeigt alle bekannten Operationen an

     --exists        gibt 0 zurück, wenn die Operation(en) existieren

     --info          Informationen zur Rückgabe der Operation:
                     Name, Beschreibung und Eigenschaftendetails.

     -i, --file      liest XML aus der angegebenen Datei

     -x, --xml       verwendet das vom nächsten Argument bereitgestellte XML

     -o, --output    gibt das zur angegebenen Datei erstellte Bild aus,
                     Dateityp basiert auf der Endung.

     -p              erhöht den Frame-Zähler von verschiedenen Elementen, wenn
                     die Verarbeitung abgeschlossen ist.

     -s scale, --scale
                     skaliert die Abmessungen der Ausgabe um diesen Faktor.

     -X              gibt das eingelesene XML aus

     -v, --verbose   gibt Diagnosemeldungen aus, während der Prozess läuft

Alle Parameter nach »--« werden als Operatoren angesehen, die zusammengesetzt
werden in kleine Komposita, anstatt eine XML-Datei zu verwenden. Dies erleichtert
das Testen von Filtern. Nach dem Zusammensetzen kann ein neuer Operator in den
Eigenschaften mit »Eigenschaft=Wert«-Paaren als folgendes Argument angegeben werden.
Gleitkomma verwendenVideo-Bitrate in kbit/sVideo-Bitrate maxVideo-Bitrate minToleranz der Video-BitratePfad zum VideogerätVideo-CodecGewichtung 0Gewichtung 1Gewichtung 2Gewichtung 3Gewichtung 4Gewichtung 5Gewichtung 6Gewichtung 7