Mini Kabibi Habibi

Current Path : C:/Users/ITO/AppData/Local/Programs/GIMP 2/share/locale/it/LC_MESSAGES/
Upload File :
Current File : C:/Users/ITO/AppData/Local/Programs/GIMP 2/share/locale/it/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��������ͫ٫��������I!�:k�(��ϭ�������	����!�'�-�3�9�?�E�K�Q�W�]�c�i�o�u�{�,��I��������.�D�J�/N�~�4��r��.+�!Z�?|�=��A��<�E�_W���DZб�c��`��o��T���;��9�%�.�F�Z�/n�5��Զݶ9��"2�#U� y�$��!��-�.�>�qY�˸	�����E��U���4�N�S�_�l���+��	ĺκ!պ	��F�$H��m�,��-*�(X���)��)��޼Q���J�,���,����	�)�9� Y�)z�(��<Ϳ
�R�2j������
|�0��5��*�#�@�Q�m�|�������h��!�6&�]�1x�7����,���/�#L�%p�+�������� ����*�;�J�
\�j�
��
��
����������
����Z��
L�Z�x�������	��������������%�B�V�^�0p�����:����� �&�*�
H�S�i�x�����
��!������
���#�<�U�d�
p�{���������%�����;�V���B��N-�Q|�+��B��=�L�_����������/�A�S�e�n�z�3�����������,�@�L�T�
Y�d�p�}���.����.����&�� �;�G� W�
x�������c���#�*�3�<�3S�9������J��l5�����������	��
��
�
�%�<�R�"Z� }� ����������@��:�L�1_�1��$��$��
��� ���������������.�A�P�d�t���(����S��) �!J�)l���?��
��*��*�_9����Q�e�B|�#����O��G�K[������v��.������
�����*�A�_�v�����?���&�3�>@��C��=��a�Kp�����b��	G�Q�d�y�B��!��P��H�J\���/��,��y�0�����s�$��G����B�3H�|�����3��+��B�"C� f���:����0��.�7�W�o�v�	~���
��
��5������6��/�
<�J�0S�]����
��-��.$�(S�|���A������	$�.�>�[�{p�.���!�
9�G�3]�	��%����(��(�*�3�E�]�8i�F��8��&"�I�;_�:��6��8
�IF���1������-���-����M�5e�&��"���������	����A�TS�C�����Z�����5�;�P�	_�i�-u��������������$�@�h`���t�d�(l�(��
��"�
�����,�E�"V�y�+��'����	�
��7�?�Y�9m�W�����k���,��	���x�L�X�+n���-����� �0�N�R�V�c�r�~������S�sA���>�����($�#M�q�����u��)�0�@�G�>X���
��
��������.�>�[�x����������
(GMew������E�2ADINSX]bg
l-w
�
����64C
x������ $--R�&��9�d� ����)�f�# 2S	s}�6�6�"4CX^~����#�		&	A	Q	j	�	
�	�	
�	�	�	
�	�	'
9
A
X

k
y
�
��
����
�#�.�
C!
re
�

�
"�
-Lh{��
����
�1�%/7<g(����5>Z
p~!���T�0AH,����""'Em>�#��*OH2�[�w''�?�#E+@q(�C�.LN1�4�	'=Qo�4���37(D3m8���4�+He���	����-
F;b�T�z:y�E/"u��*{O��9AN,W��:�3�4Na
x�&�,��	 ( ? G a t � k� k!}!�!]�!"
+"6"-T"�"�"(�"(�"$#&#)#
,#:#%@#%f#�#�#�#�#8�#$$6$F$\$r$�$�$�$�$<�$3%pS%�%�%�%&5&;&A&	G&	Q&[&k&p(w((	�(�(�(
�(�(	�(�(	�())')6)I)\)8w)5�)�)8�)6*>*R*i*u*�*�*�*(�*�*�*+*+�J+*�+,&,@,
F,
T,b,q,�,�,�,�,�,#�,�,--3-S-c-!o-�-�-�-1�-�-
.#.6.B.T.Z.i.v.�.)�.
�.�.
�.�.�.8�.3/B/R/F[/%�/
�/�/$�/0�!0�0R�0	.1
81	C1M1i1x1�1�1�1�1�1�1�1�	2�2%�3�#5�6;7M7
`7n7r7	�7P�7�7I�7D8#V8
z8�8!�8�8	�8�8�89)9291:9l9
�9�9�9�9�9�9�9`�9	?:I: b:�:(�:�:�:�:�:
�:
�:
;
;(;8;H;X;h;x;�;�;%�;
�;
�;�;<
<'<8<V<�^<
==5=K=�d=x+>��>�e?@@%@.@:@	Q@[@u@F�@��@��A(B7BNBRBcBCvB�B�B�B�B�B�BC!Cx0C�C�C�C�C
�C�C
D/D3MD�D+�D�D�D�DE$E85EnE�E�EF�EF* FPKF$�F]�FG4GzIGs�G$8H#]H%�H%�H+�H�HIIu^I,�IDJOFJ�J�J�J�J�J'K�3K&�K-$L,RLL�L
�L
�L�L�L�L�LCM-LM3zM�M�M��M�SN�N�N%O
.O	9OCO(PO	yO	�O�O�O�O�O�O�OP.#P%RP�xP&Q@QXQ$pQ�Q"�Q�Q�Q�QR.RNRjRzsR�R�RSSP%SEvS�S	�S�S�S�S�S,Uj/U�U;�U
�U0�UV.V)7VaVV�V#�V�V�V#W$W8W
SWq^W�W�W�W
X
XX"6X.YX&�X[�XfYKrYK�Y/
Z:Z+BZnZ�Z�Z�Z�Z�Z�Z	�Z[[[4[�;[
�[B�[;\Z\a\	y\4�\�\�\�\1�\*]#=]@a]+�]5�];^n@^#�^@�^5_CJ_x�_
`%`M8`O�`O�`&a7aLa_a
qa|a�aQ�a�a�ab"b8bUbkb�b�bF�b�b�b�b	�b	cc+c/Cc1sc�c�c#�c�cZ�cEdNdbWd�d�dK�dP>eP�e�e�ef6f>fQfcfsf<�fC�fg-gCKg�g�g�g_�g
ii
$i/iHiNini�i�i�i�i�i#�ij#j2jEjUjnj�j�j
�j�j
�j�j�j
kk'1k�YkG-lul�l�l�lw�l")mLmd_m�m�m)�m0"n"Snvn,~nJ�n0�n'o7o
JoXo0wo2�o�oV�oGp!Vp#xp�p'�p��p�q)�q�q��qZr,sr�r�r�r�r�r	sss s&sN7s0�s�s	�s�s �sW
tbtt�t�t�t�t�t�t�t��t��ui�v[8wy�w�xn�x�Fy;zHNz��z.A|5p|+�|-�|*}+}B}O}o}x}�}�}�}6�}~
~W#~{~�~C�~�~�~) > _��$�'�4��1�:��	2�d<�=��߂'��9�T�@a�%��ȃ�@�
G�R�hY�-„/�/ �/P�1��1��/�1�1F��x���3����ćч@�,�<�
P�[�o�{����������Έ	T�^�f�y�
��
����<���O�[�o�����
��%���@��>6�u�>��A΋9�(J�s�)��K���
��
�)�6�#C�Bg�7�����'�6�
M�<X���������
Ώُ��C�D�
P�[�o�J��CԐ/�H�FP�
������0��ߑ��'�6�M�_�y�
������������/͒*��(�-8�)f�,����ԓ	������	���!�@�PV�����,�����t2���	•̕ӕ�����)�8�E�5M�	��9��4ǖ���$�5�B�]�u�����Ǘ�(�'�0E�,v���9˜8��5�]I���A���(��2%�,X�����O���B#�f�{����� ›'�1�'=�'e���/��hԜ=�CZ� ��!�����A�(W�)��3��8ޞ<�@T�:��<П(
�$6�[�o�\��9�(!�QJ�I��<�2#�9V�2��"â�-�2�,B�7o�$��@̣8
�@F������a������������ŧ�ҧ
��������;Ǩ� �5�H�_�v���������ک&ߩ������� �$�	(�2�
A�L�U�
^�l�q���B��	ت	�#�(�f9�����ǫګ����	��	ʬ
Ԭ
��
�
�"�&/�V�[�b�<i���®֮
������0�G�a�=��.��'��$5�&Z�i����:�W� w�7��бܱ{�>e�.�� Ӳ5�*�"=�#`�*��7��
�J��@�G�V�j�z�$������ȴܴ�	����4�I�[c���?յ*�@�W�k��� ��%Ķ�<��!<�;^�����(̷����h!���B���C�J�S�%b��������=�
P�[�v���������Ժ�G�
N�Y�mh�0ֻ �6(�e_�Nż|�#��<��&�"�#<�/`���������Ⱦ׾��	�	�$$�5I�� ����ܿ�����'�36�j�.}���	���0�T�'a�3��2����
�
�
�	(�2�9�A�0N�A���"��)��'(�$P�
u�����#���������������
�!�
.�	<�F�M�U�0b�A����"��)�'<�$d�
����#����	��	��	������ �
5�
C�7Q�
����)����
��������;�FW�%��
��	������ ���+�:�1L�~�1��)��)��W�-i�����Q��� 	�*�
<�G�N�-_�������4������
��+�>�	K�U�g�p� ��)��	��	��8��=�"[�~���#��+����	��������	"�	,�6�<�_A�_������8����Q��+G�s�M���� ��
� ��7�)�?�U�g�y���������������������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_0_2_0
Report-Msgid-Bugs-To: 
PO-Revision-Date: 2023-05-31 13:15+0200
Last-Translator: Marco Ciampa <ciampix@posteo.net>
Language-Team: italian <tp@lists.linux.it>
Language: it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Plural-Forms: nplurals=2; plural=n>1;


il parametro sconosciuto "%s" fornisce invece l'aiuto


%s non ha la proprietà %s, proprietà: %s non ha la proprietà %s.(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 per autorilevamento sul primo pezzo audio-1, 8, 16, 32 e 64 sono i valori attualmente accettati, -1 significa auto0°180°Sfocatura scatola 1DSfocatura gaussiana 1DSfocamento wavelet 1D270°3x38 e 16 sono tra i valori attualmente accettati.90°Un GeglVector che rappresenta il percorso del trattoUna veloce approssimazione di un filtro bilaterale, usando un filtro a scatola invece di uno sfocamento gaussiano.Alti valori abbassano la casualità del rumoreUn livello nel senso tradizionaleUn pre-esistente GeglBuffer su cui scrivere i dati in ingresso.Una sorgente rettangolare di dimensione fissa di colore pienoUno script lua memorizzato su disco che implementa un'operazione.ACES RRTDeformazione ASAPSe vera viene eseguita una deformazione ASAP, altrimenti viene effettuata una deformazione ARAPSopra la sogliaAssolutaColorimetrica assolutaPolitica dell'abissoSommatoria di sfocature di movimento usando un filtro kalman, da usare con quadri di videosequenze.Livelli attiviAdatta un'immagine, che può essere ad alta dinamica, ad una presentazione a dinamica ridotta. Questo è un efficiente operatore globale derivato da semplici osservazioni fisiologiche, che produce una luminanza nel campo 0.0-1.0Adatta un'immagine, che potrebbe essere ad alta dinamica, per una presentazione usando un campo di dinamica ridotto. Questo operatore attenua la magnitudo dei gradienti locali dell'immagine, producendo luminanza nel campo 0,0-1,0. Questo approccio alla mappatura di toni fu originariamente prensentata da Raanan Fattal, nella pubblicazione SIGGRAPH 2002: "Gradient Domain High Dynamic Range Compression".Adatta un'immagine che può avere ad alta dinamica, a presentazioni a bassa dinamica. Quest'operatore limita il contrasto tramite più frequenze spaziali, producendo una luminanza nel campo 0.0-1.0Adattamento alle variazioni di colore attraverso l'immagineAdattamento alle variazioni di luce attraverso l'immagineAggiungiAggiungi rumore CIE LchAggiungi rumore HSVAggiungi rumore RGBAggiunge un chiarore attorno alle aree luminoseAggiungi la somma dei valori al quadrato al risultatoAdditivoAggiungi in effetto lenti.Regolazione della tonalità LCH, crominanza e luminositàRegola la luminosità negli angoliRegola l'esposizione delle alteluciRegola l'esposizione delle ombreRegola la saturazione delle alteluciRegola la saturazione delle ombreRegola il valore di tristimolo X per l'uscitaRegola il valore del tristimolo Z per l'uscitaRegola il livello del neroRegola il contrasto di un'immagine in scala di grigi secondo una curva che specifica il contrasto per intensità.Adobe RGB compatibileAlgoritmoTipo algoritmoMappa alienaAllineaAllineamento del testo su più linee (0=sinistra, 1=Centro, 2=destra)Allinea il riquadro di ingresso al bordo dell'obiettivo composito o al riquadro di aux. Se il pad aux non è connesso l'operazione prova a capire che riquadro applicare.Permetti piastrelle rottePermette la divisione delle piastrelle negli spigoliAlfaCanale alfaLivelli alfaParametro alfa dei pesi MLSPercentile alfaSoglia alfa per l'elaborazione multilivelloPeso-alfaSempreFattore di illuminazione ambienteAmmontareQuantità per la quale scalare l'opacità di ogni immagine trasformataAmmontare del mantenimento dei bordiQuantità di conservazione del bordo. Questa quantità è inversamente proporzionale al campo di deviazione standard del nocciolo di sfocatura.Ammontare della distorsione di quarto ordineAmmontare della distorsione di secondo ordineQuantità dell'incremento di luminositàAmpiezzaAmpiezza per l'asse X (scala logaritmica)Ampiezza per l'asse Y (scala logaritmica)Ampiezza dell'ondulazioneUn pre-esistente GeglBuffer su cui scrivere i dati di buffer in ingresso, o NULL.Un filtro di ammorbidimento che conserva i bordi implementato con la tecnica ricorsiva della trasformazione di dominio. Simile ad un filtro bilaterale, ma più veloce da calcolare.Un messaggio di errore in caso di fallimentoUn nodo cache esplicito; la cache dovrebbe essere in grado di generare un aumento di velocità nel ricalcolo se ciò che viene memorizzato in essa è costoso in termini computazionali ma non varia.AngoloImpulsoangolareAngolo della sfocatura in gradiAngolo di vistaScostamento angolo per i motiviAngolo di rotazione (antiorario)Operazione di omogeizzazione anisotropicaFattore di sovracampionamento anti-aliasAntialias usando l'algoritmo di estrapolazione bordi Scale3XAntialiasingProfondità apparente dell'effetto tela; da 1 (molto piatta) a 50 (molto profonda)Dimensione apparente di ogni piastrella (in pixel)Applica un gradiente di colore.Applica un effetto vignettatura all'immagine. Simula la diminuzione di luminanza e altri effetti particolari ai bordi, un fenomeno tipico dell'esposizione delle vecchie pellicole analogiche.Applica lentiApplica una matrice di convoluzione generica 5x5Applica una tonalità seppia all'immagine in ingressoApplica una trasformazione ricorsivamente.Bilanciamento area tra i due coloriSomma aritmeticaCovariante somma aritmeticaXor aritmeticoCovariante xor aritmeticoRapporto dimensioniRapporto dimensioni da usare, -0.5 = 1:2, 0.0 = 1:1, 0.5 = 2:1, -1.0 = 1:inf 1.0 = inf:1, viene applicato dopo aver preso in considerazione la proporzione; per usare direttamente il fattore di schiacciamento come proporzione, impostare le proporzioni a 0.0.Codec audioCodifica audio da usare, o auto per usare un buon valore predefinito basato sul formato del contenitore.AutoValori di autocorrezione d per i modelli di obiettivo.Valori di autocorrezione dPad d'ingresso per il buffer immagine ausiliario.Disponibile come variabile globale "user_value" in lua.MediaDiametro medio di ogni piastrella (in pixel)Differenza media (totale)Differenza media (sbagliati)Differenza media tra tutti i pixel.Differenza media tra pixel sbagliati.Evita ritagli e quantizzazione (più lento)Angolo di separazione assiAzimutFormato bablIl formato Babl "%s" non esiste.SfondoColore di sfondoColore di sfondoTipo di sfondoLunghezza BailoutBilanciamentoSintonizzazione bandaBarnsley 1Barnsley 2Barnsley 3BaseEsposizione allargamento baseIndice baseBayerMatrice BayerMotivo BayerViene usato il motivo Bayer, 0 sembra funzionare bene per i file Nikon, 2 per i file Fuji.ComportamentoComportamento dell'operazioneSotto la sogliaBetaFiltro riquadro bilateraleFiltro bilateraleBilineareProfondità di bitNeroAngolo del neroLivello del neroNero su biancoMotivo neroPeriodo neroCompensazione del punto neroEstrazione del neroScoppioModalità fusioneFonde una catena di ingressi usando una mascheraAltezza bloccoDimensione bloccoDimensione del blocco del deinterlacciamento righe/colonneLarghezza bloccoDimensione bloccoFioreBluMoltiplicatore del canale bluRumore bluCovariante rumore bluSoglia del bluAngolo blu e gialloMotivo blu e gialloPeriodo blu e gialloAngolo bluModalità di applicazione del bluCanale del bluContorni bluFrequenza bluBlu nel canale del bluBlu nel canale del verdeBlu nel canale del rossoInversione bluLivelli bluMotivo BluPeriodo bluSpostamento di fase bluPreflash bluSpigoli bluFattore di stiramento bluSoglia del blu del colore in ingressoGamma sfocaturaLivelli sfocaturaSfoca i pixel adiacenti, ma sono in aree di basso contrastoSfoca i pixel in una direzione, simulando lo sfocamento di una macchina fotografica in movimento lineare durante l'esposizione.Raggio di sfocaturaLa sfocatura risultante dalla media dei colori vicini ad una riga.La sfocatura risultante dalla media dei colori di un quadrato di punti vicini.La sfocatura risultante dal calcolo del colore mediano nella vicinanza di ognuno.Sfoca l'immagine attorno ad un punto focaleSfoca l'immagine in base a un valore variabile usando una mascheraTipo sfocaturaFattore sfocamentoIncrementa la densità della carta per avantaggiarsi del range dinamico maggiore di uno schermo rispetto alla carta fotograficaBordoAllineamento bordoComportamento bordoEntrambiFondoIn basso a sinistraIn basso a destraSfocatura scatolaSfocatura scatolaIlluminaLuminositàContrasto luminositàLuminosità e spostamento/accrescimento di contorniBufferBuffer destinazioneBuffer sorgentePosizione del bufferMappa a sbalzoMappa a sbalzo (preserva i colori originali)CIE Lab/LchCIE YuvCMYKCiano CMYKChiave CMYKMagenta CMYKGiallo CMYKCXCX (nessun effetto in Mandelbrot e Sierpinski)CYCY (nessun effetto in Mandelbrot e Sierpinski)CacheCalcola una trasformazione di distanzaCalcola il valore b dalla focaleApparecchioApparecchio RGBAngolo di vista della telecameraCartesianaFumettoCast del formatoForza spazio coloreFa un cast dei dati tra input_format e output_format, entrambi i formati devono avere la stessa bppRumore cellulaCentraX centroY centroSpostamento del centroCentro dell'intervallo di selezione della tonalitàLo spostamento del centro attorno ad un punto specificatoCentramentoCentramento delle piastrelleCambia l'esposizione di una immagine, in velocità di otturazione in stop.Cambia la temperatura di colore dell'immagine, da una temperatura di colore originale assunta ad una intesa.Cambia in questoCambia i livelli di luce e di contrasto. Questa operazione funziona in luce lineare, il "contrasto" è un fattore di scala attorno al 50% di grigio, mentre la "luminosità" è uno scostamento costante da applicare dopo aver effettuato la scalatura di contrasto.Cambia la saturazioneMixer dei canaliCurva caratteristicaChebyshevScacchieraPrendi il mezzoCrominanzaRegolazione crominanzaAdattamento cromaticoCerchioProfondità cerchio in percentualeSfocatura di movimento circolareSfocatura di movimento circolareMorsaBlocca deformazioneClip RGBRitaglio base + nebbiaRitaglio base + nebbia per avere un valore in uscita bianco puroTaglia pixel altiTaglia pixel bassiRitaglia il risultato alla dimensione in ingressoRitaglia il risultato alla dimensione in ingressoRitaglia alla dimensione in ingressoRitaglia alla dimensione in ingressoSenso orarioCloneClona un buffer, è lo stesso di gegl:nop ma può ottenere un trattamento speciale per ottenere riferimenti più umanamente leggibili nella serializzazione/UI.Dimensione raggruppamentoColoreColore 1Colore 2Colore 3Colore 4Colore 5Griglia di assimilazione coloreAumento del coloreModello coloreRivestimento coloreRuota il coloreTemperatura coloreMedia coloreColore del testo (predefinito a "black")Modello coloreTinta da usare per il riempimento, usare 0 opacità per disabilitare il riempimentoColore tinta da usare per il riempimento.Tinta da usare per la delineaturaColore tinta da usare per la delineatura.Colore delle linee grigliaCompressione dipendente dalla saturazione del color del periodoSpazio coloreSpazio colore da usare per i dati caricatiColore ad alfaColore verso il quale sfumare le immagini trasformate, con un rapporto che dipende dal suo alfaConversione da colori a scala di grigi, usando dei contenitori formati con l'approccio STRESS per eseguire una generazione di scala di grigi mantenendo le differenze di colore locali.Da colore ai picchiColore da renderizzareColore da usare per le modalità "Solo colore" e "Colore a picchi"Colore usato per riempire lo sfondoDeformazione coloreColori con una saturazione minore di questo valore verranno trattati come grigiCombina esposizioniCombina le esposizioni di più scene in un'unica immagine ad alta dinamica.CompattezzaConfronta se i buffer di ingresso e ausiliario sono differenti. Le statistiche globali vengono salvate nelle proprietà e un'immagine di differenza visuale viene prodotta come risultato visuale.CompensaCompensa l'oscuramentoCasualizza completamente una frazione di pixelComplessitàFattore di complessitàComponenteFrequenza componente 1Spostamento fase componente 1Frequenza componente 2Spostamento fase componente 2Frequenza componente 3Spostamento fase componente 3Colore separatore componenteComponente da estrarreI componenti dell'immagine JPEG 2000 ingresso non corrispondonoOperazione composita da usareComposizioneCompressioneComprimi l'effetto sulle ombre/alteluci e preserva i mezzitoniCompressioneAlgoritmo di compressione usato per i dati immagazzinati nello swapCalcola la mappatura di uno spostamento relativo da un trattoCalcola il gradiente della magnitudo e/o la direzione del gradiente usando le differenze centraliEsegui il calcolo dell'integrale e dell'integrale al quadrato dell'immagineComponenti connessiFormato contenitoreIl formato del contenitore da usare, o auto per l'autorilevamento in base all'estensione del file.ContrastoCurva di contrastoIncremento contrastoContrasto del passa-altoControlla la quantità di rumore per ogni canale RGB separatamenteControlla il numero di iterazioniControlla il numero delle iterazioni; valori bassi danno risultati meno plasticiConverte il formatoConverte uno specifico colore in trasparenza, lavora meglio con il bianco.Converte lo spazio coloreConverte un'immagine da o per coordinate polariConversione dei dati nel formato specificatoConverte l'immagine in un insieme casuale di riquadri ruotati, che in qualche modo somiglia allo stile di pittura cubistaConverte usando la compensazione del punto nero.Converte l'ingresso da un profilo di colore ICC ad un formato babl ben definito. I dati del buffer verranno poi correttamente gestiti da GEGL per ulteriori elaborazioni.Matrice di convoluzioneCoordinate del centro dell'obiettivoCopia le immagini eseguendo una correzione ad una distorsione da lenti.Copia bufferStima corretta della temperatura della sorgente di luce in Kelvin.Corregge la distorsione lenti a barile o a cuscino.Rumore correlatoCosenoAnti-orarioCrea una immagine in scala di grigi (monocromatica)Crea un effetto simile ad un caleidoscopio.Crea un nuovo buffer GEGL per scriverci i risultati del rendering.Crea un motivo casuale tipo nuvoleCrea un risultato piastrellabileCrea immagini JPEG progressiveCrea un effetto di proiezione ombra nel buffer in ingressoCrea un effetto ombra lungaCrea un'immagine riempita con un effetto plasma.RitagliaRitaglia un buffer, se il pad ausiliario connesso al riquadro contenitore del nodo connesso viene usato. Quando l'area di ritaglio viene configurata a 0x0 in 0,0 e non c'è niente connesso su aux, viene usato il riquadro contenitore del nodo alla fine produttiva della catena d'ingresso.Linee che si incrocianoCubicoCubismoCurvaturaCurvaTipo curvaTipo curvaTaglia l'immagine in piastrelle di carta e le scambiaAngolo del cianoFiltro cianoCompensazione del filtro ciano per l'immagine negativaMotivo cianoPeriodo cianoUmiditàDimensione predefinita delle tile in GeglBuffersValore predefinito "nero"; si può usare la trasparenza per cancellare porzioni dell'immagineGradiDeinterlacciaDeinterlaccia orizzontalmente o verticalmenteRitardo in ms per l'ultimo quadro decodificatoDemosaico con l'interpolazione bimedianaDemosaico senza interpolazioneRimozione rumore DCTAlgoritmo di riduzione del rumore che usa una soglia DCT per areaIncremento densitàProfonditàProfondità primaDettaglioBanda dettaglioLarghezza di banda dettaglioLivello di dettaglioDettaglia la scala, valori negativi diminuiscono il segnale nella banda di dettaglio, quelli positivi aumentano il segnale.Deviazione da piastrelle perfettamente formateRomboDifferenze di GaussianeDifferenzialeMotivi di diffrazioneMezze tonalità digitali con modulazioni opzionali.DirezioneDirezione sorgente di luce (in gradi)Direzione dell'effettoComponente X della direzione del vettoreComponente Y della direzione del vettoreCartellaDisabilita OpenCLBit di discretizzazioneSpostamentoMoltiplicatore di spostamento per la direzione radiale XMoltiplicatore di spostamento per Y o la direzione tangente (in gradi)Sposta i pixel come indicato da una mappa di spostamentoDispone i pixel in un motivo ad ondineModalità spostamentoMoltiplicatore di scostamento per la compensazione angolareMoltiplicatore di spostamento per la direzione orizzontaleMoltiplicatore di spostamento per la direzione radialeMoltiplicatore di spostamento per la direzione verticaleFattore di spostamento (valori negativi significano spostamento negativo)SchermoMostra una stringa di testo usando pango e cairo.Mostra le informazioni di aiutoMostra sullo schermoMostra il buffer di ingresso in una finestra.Mostra il buffer in ingresso in una finestra SDL (limitata ad un solo processo di visualizzazione, a causa di problemi implementativi di SDL).Mostra il buffer in ingresso in una finestra SDL2 (limitata ad un solo processo di visualizzazione, a causa di problemi implementativi di SDL2).Trasformazione distanzaDistorce un'immagine con un effetto vortice o pizzicoDistorce i colori di quantità casualiDistorce l'immagine con delle ondeDistortoDitherMetodo ditheringDittoDivisioneDivisoreEsegue una catena di operazioni, con le coppie chiave=valore dopo ogni nome operazione per impostare le proprietà. E aux=[ filtro sorgente ] per specificare una catena con una sorgente vista come qualcosa connessa a degli appunti ausiliari.Esegue una lerp, interpolazione lineare (lerp) tra ingresso e auxFa una trasformazione stereografica/piccolo pianeta di un'immagine equirettangolare.Esegue una trasformazione usando una trasformazione sintattica SVG.Esegue una mappatura del rendering del osservatore del panorama o la sua inversa per un'immagine in ingresso equirettangolare (rapporto 2:1 contenente 360x180 gradi di panorama).Esegue la mappatura inversa, utile per ritoccare zenith, nadir o altre parti del panorama.Moltiplicatore scherma/bruciaNon sovraesporre le alteluciPuntiDisegna un labirintoProietta ombraMonotoniaEPITROCOIDEERRORE: l'opzione "%s" richiede un argomento
SpigoloBordi soggettiRilevamento bordiBanda bordoLarghezza di banda bordoComportamento bordoAlgoritmo di rilevamento bordiAmmontare rilevamento bordiComportamento rilevamento bordiRilievo bordi con controllo dello spessore bordi, basandosi sulla differenza di due sfocature gaussiane.Gestione bordoMantenimento dei bordiScala bordo, valori negativi diminuiscono il segnale nella banda di dettaglio, quelli positivi aumentano il segnale.IiiiiikScostamento in X del centro dell'effettoScostamento in Y del centro dell'effettoForza effettoAggiunge o sottrare dalla mascheraElevazioneAngolo elevazione (in gradi)RilievoTipo rilievoEmula la pittura ad olioAbilita preflashRisultati piastrelle più levigateColore di fineAngolo finale del campo colore destinazioneAngolo finale del campo colore sorgenteCoordinata x di fineCoordinata y di fineIncisioneAumenta ombreAumenta i dettagli fini.EpsilonDistorsione cancellamentoMessaggio di erroreErrore durante la lettura della riga %d del componente %dTemperatura stimata della sorgente di luce in Kelvin con cui l'immagine è stata presa.EuclideaScambio coloreScambia un colore con un altro, impostando opzionalmente una soglia di conversione tra un valore e l'altro.EspandiEspande le piastrelle di questo quantitativoEsponenteBuffer esponenteEsponente per l'elaborazione; controlla lo smussamento - può essere anche scalato per pixel con un buffer sul pad aux2.EsposizioneValori di esposizioneEspresso come deviazione standard, in pixelEstrazione componenteEstrae una componente di un modello di coloreCaricatore quadro FFmpegSalvatore quadro FFmpegImportatore quadri video FFmpeg.Ricezione uscita video FFmpegFIRFPSSfuma coloreSfuma opacitàDissolvenzaDissolvenza (lunghezza finita)Dissolvenza (frequenza fissa)Linearità cadutaFattal et al. 2002 Tone MappingProduce la dimensione per la banda di dettaglio, usata per la rimozione del rumore.Produce la dimensione per la banda del bordo, usata per compensare la perdita dei bordi nel passaggio al dettaglio.FilePercorso del file sistem ad un profilo matrice ICC da caricareColore di riempimentoPercorso riempimentoRiempie ogni cella con un colore casualeRiempimento completo area di uscitaRiempimento opacitàRegola di riempimentoRegola di riempimento.Riempie ogni regione connessa dell'ingresso, separata dal resto dell'ingresso da un dato colore, con un colore unico.FiltroSpessore filtroFinitaPrima iterazioneSistema le immagini dove ogni altra riga o colonna è mancanteDenti ingranaggio fissoRovescia XRovescia YRovescia le coordinate XRovescia le coordinate YVirgola mobileFloyd-SteinbergFocale dell'apparecchioSfocatura fuocoLimite interno regione fuocoRaggio esterno regione fuocoPunto mediano transizione fuocoFoma Fomabrom CFoma Fomabrom NFoma Fomabrom SFoma Fomabrom SpFoma Fomabrom Variant IIIFamiglia del carattereFamiglia del carattere (utf8)Dimensione carattere in pixel.ForzaForza l'affiancabilitàColore primopianoEsploratore frattaleTraccia frattaleTipo di frattaleTipo frazionamentoTipo frazionamentoQuadroNumero di quadroQuadri al secondo, permette il calcolo del tempo rapportato ai quadriQuadri/secondoDaDa 0Da 1Da 2Da 3Da 4Da 5Da 6Da 7Dal coloreFujicolor Crystal Archive Digital Pearl PaperCampo pieno ZGrafo GEGLVisualizzatore grafo GEGL.Caricatore file GIFCaricatore immagini GIF.GammaFattore gamma per la spaziatura dei livelli di fusioneFattore gamma per la spaziatura livelli di sfocaturaSpaziaturaSfocatura gaussianaDistribuzione gaussianaSorgente GdkPixbufGdkPixbuf da usareCaricatore file GeglBuffer.Scrittore file GeglBuffer.Genera un motivo a matrice BayerGenera un motivo lineare a sinusoidiGenera una mappa normale da una mappa altezzaGenera una mappa piastrellabileGenera un complesso motivo a sinusoidiGenera motivi di diffrazioneGenera un risultato più accurato e coerente (più lento)Crea un buffer riempito interamente del colore specificato, usa gegl:crop per ridurne le dimensioni.Genera un motivo a cellule.Genera un motivo a rumore pieno.Data una tri-mappa qualsiasi fornita dall'utente e un'immagine di ingresso, crea una mat. alfa di primo piano. Imposta il bianco come selezionato, nero come non selezionato, per la tri-mappa.Dati una qualsiasi tri-mappa fornita dall'utente ed una immagine in ingresso, crea una superficie alfa in primo piano. Imposta il bianco come primo piano, nero per lo sfondo della tri-mappa. Ogni altro particolare viene trattato come sconosciuto e riempito.Fattore globale di saturazione del coloreIl valore di opacità generale viene sempre usato in cima all'opzionale buffer di ingresso ausiliario.Raggio chiaroreForza chiaroreSoglia luminosità area chiaroreGradualità bordo area chiaroreGradienteMappa gradienteUniformità gradienteSoglia del gradiente per il miglioramento dei dettagliSoglia gradiente per abbassare l'aumento del dettaglioModalità grigioSoglia del grigioScala di grigiMedia scala di grigiVerdeMoltiplicatore del canale verdeSoglia del verdeAngolo verde e magentaMotivo verde e magentaPeriodo verde e magentaAngolo verdeModalità di applicazione del verdeCanale del verdeContorni verdiVerde nel canale del verdeFrequenza verdeVerde nel canale del bluVerde ne canale del rossoInversione verdeLivelli verdeMotivo verdePeriodo verdeSpostamento di fase verdePreflash verdeSpigoli verdiFattore di stiramento verdeSoglia del verde del colore in ingressoGrigliaDisegnatore di griglieDimensione grigliaAccresci areaRaggio crescitaForma crescitaFiltro provino/curva di mappatura da HDR a SDR che è un'approssimazione dell'ACES RRT (Reference Rendering Transform). Quando si forniscono immagini scena-referenziate in questa op, il risultato è adatto alla trasformazione riferita al display in sRGB o display d'uscita usando normali profili di matrice ICC come l'ODT. Si noti che per il momento si tratta di un'approssimazione della sola luminanza dell'RRT ACES; senza desaturazione delle alteluci e ombre né modifiche di tonalità rosse.HSLLuminosità HSLSaturazione HSLSaturazione HSVValore HSVMezzitoni/motivo a puntini da usareCurva caratteristica e dati colore incorporatiDurezzaDurezza del pennello, 0.0 per un pennello morbido, 1.0 per uno duroDistorce pesantemente i colori delle immagini applicando funzioni trigonometriche per mappare i valori dei colori.AltezzaMappa altezzaAltezza dell'immagine renderizzataAltezza del blocco in pixelAltezza linee griglia in pixelAltezza del buffer generatoAltezza piastrellaEsad.EsagoniFiltro passa altoIngresso altoLimite altoUscita altaAlta precisioneAlta qualitàValori elevati danno più variazione nei dettagliRilevamento bordi ad alta risoluzioneAlti valori aumentano la magnitudo dell'effettoAlti valori restringono l'effetto a poche aree dell'immagineLivello di luminanza più alta in uscitaFattore evidenziazioneSoglia evidenziazioneSoglia evidenziazione (alta)Soglia evidenziazione (bassa)AlteluciRegolazione colore alteluciDimensione istogrammaPercento foroOrizzontaleTraslazione orizzontale obiettivoSpostamento orizzontaleEstensione orizzontaleLa giustificazione orizzontale 0.0 è a sinistra, 0.5 è centrata e 1.0 è a destra.Scostamento orizzontaleScostamento orizzontale (dall'origine) per la griglia di partenzaScostamento orizzontale dei blocchi in pixelScala motivo orizzontalePosizione orizzontalePosizione orizzontale in pixelFattore di scala orizzontaleScostamento orizzontale dell'ombraQuantità dell'inclinazione orizzontaleDimensione orizzontaleRapporto dimensione orizzontale di un pixel dentro ogni bloccoQuantità di diffusione orizzontaleDimensione orizzontale motivoTraslazione orizzontaleLarghezza orizzontale delle celle di pixelCome le aree fuori dall'ingresso vengono considerate nel calcolo della distanzaQuanto si è vicini alle proporzioni dell'immagineQuanto deve essere lontano l'effetto vignettatura dalla metà della diagonale dell'immagineQuanto dista il buco dal centro dell'ingranaggio mobile. 100 significa che il buco si trova sul bordo dell'ingranaggio.Come sono gestiti i bordi dell'immagineQuanti inchiostri per usare solo nero, rg, rgb(additivo) o cmykQuanti pixel di spazio tra elementiQuanto scostamento orizzontale deve essere applicato all'incollamentoQuanta memoria usare (approssimativamente) per la cache immaginiQuanto grigio comune da estrarre dal CMYQuando scostamento verticale deve essere applicato all'incollamentoCome il nocciolo gaussiano viene discretizzatoCome allineare gli elementi, 0.0 è all'inizio, 0.5 a metà e 1.0 alla fine.Come gestire i pixel fuori dal buffer in ingressoCome determinare cosa riempire (nonzero|paridispari)Come riempire i superpixelTonalitàRegolazione tonalitàFrequenza tonalitàSpostamento di fase tonalitàCentro selezione tonalitàAmpiezza selezione tonalitàValore di tonalità sopra le impostazioni del grigioTonalità-crominanzaCaricatore file ICCCaricatore profilo ICC.Salvatore profilo ICCIIRTitolo iconaIcona da usare per la finestra di uscitaSe impostata, il motivo generato sarà affiancabileSe impostata, il motivo verrà leggermente più distortoSe si vuole centrareIgnoraIgnorato. Usa sempre il centro del buffer d'ingressoIlford Ilfobrom Galerie FB 1Ilford Ilfobrom Galerie FB 2Ilford Ilfobrom Galerie FB 3Ilford Ilfobrom Galerie FB 4Ilford Multigrade IV RC DeluxeRegolazione illuminazioneIllusioneTipo illusioneImmagineGradiente immagineIncapsulatore di ImageMagick usando l'op. pngOperazione di fusione dell'immagine "media" (<tt>c = (cA + aB)/2</tt>)Operazione di fusione dell'immagine "riflessione-fusa" (<tt>c = cB>=1.0?1.0:cA*cA / (1.0-cB)</tt>)Operazione di fusione dell'immagine "negazione" (<tt>c = 1.0 - fabs(1.0-cA-cB)</tt>)Operazione di fusione immagine "bruciatura leggera" (<tt>c = (cA+cB<1.0)?0.5*cB / (1.0 - cA):1.0-0.5*(1.0 - cA) / cB</tt>)Operazione di fusione immagine "schermatura leggera" (<tt>c = (cA+cB<1.0)?0.5*cA / (1.0 - cB):1.0-0.5*(1.0 - cB)/cA</tt>)Operazione di fusione immagine "sottrattiva" (<tt>c = cA+cB-1.0</tt>)Cartella file immagine (sottofile)Metodo di ricampionamento da usare; per buoni risultati con doppio ricampionamento nel ritocco di panorami, usare il più vicino per generare la vista, e cubica o migliore per la trasformazione inversa per tornare al panorama.Impatta ogni canale dello stesso ammontareAumenta il contrasto per carta con contrasto fisso (solitamente carta colorata)RGB indipendenteIndice del componente che segnala i pixel non etichettatiPasso indiceInfinitaRipete infinitamente l'immagine in ingresso.Buffer d'ingressoFormato in ingressoLivello di luminanza in ingresso che diventa il più bassoLivello di luminanza di ingresso che diventa biancoPad di ingresso, per il buffer immagine in ingresso.Integra l'immagineTemperatura desiderataIntensitàModalità intensitàSpaziatura inter-piastrella (in pixel)Interpola tra distanza Manhattan e Euclidea.Spazio colore interpolazioneGrafo non valido, interrotto.
Trasformazione inversaInverteInverte la mappa a sbalziInverti componenteInverti nello spazio percettivoInverti mascheraInverte le componenti (eccetto alfa) in luce lineare, il risultato è l'immagine corrispondente "negativa".Inverte le componenti (eccetto alfa) percettivamente, il risultato è l'immagine corrispondente "negativa".Inverte la componente estrattaInverte la regione separatoreInverte il componente valore, il risultato ha la luminosità invertita, mantenendo il colore.Immagine invertitaIterazioniCaricatore immagini JPEG 2000Caricatore immagini JPEG 2000 che usa jasper.Caricatore immagini JPEGSalvatore file JPEGQualità compressione JPEG (tra 1 e 100)Caricatore immagini JPEG che usa libjpegSalvatore immagini JPEG, usa libjpegJXJYColore giunteJuliaValore del seme X di Julia, posizioneValore del seme Y di Julia, posizioneGiustificazioneSegmentazione K-meansSpecchio caleidoscopicoMantieniMantiene i valori RGB dei pixel entro un campo specificoMantieni il segnoMantieni componente bluMantieni coloriMantieni componente 1Mantieni componente 2Mantieni componente 3Mantiene i campi pariMantiene i campi pari o dispariMantieni componente verdeMantieni componente tonalitàMantiene l'immagine intatta ove non influenzata dalle lenti.Mantieni componente luminositàMantieni i valori negativi nei risultati; se non abilitata, viene invece usato il valore assoluto nei risultati.Mantiene i campi dispariMantiene i dintorni originaliMantieni componente rossaMantieni componente saturazioneLAB ALAB BLAB LLCH C(ab)LCH H(ab)LCMS da profiloPropagazione etichette mediante trasformazione spartiacque. Il buffer d'uscita conterrà il formato in ingresso. I pixel non etichettati sono contrassegnati con un determinato valore segnale (per impostazione predefinita: ultimo componente con valore NULL). Il buffer aux obbligatorio è un'immagine "Y u8" che rappresenta i livelli di priorità (i valori basso hanno priorità maggiore). Se aux è assente, tutti i pixel etichettati hanno la stessa priorità e le etichette propagate hanno una priorità più bassa.LambdaLaplaceRilevamento bordi Laplaciano3x3 largoScaglionato largoLivelloAll'inizioSinistraLunghezzaLunghezza sfocatura in pixelObiettivoSfocatura lentiDistorsione lentiRiflesso lentiCentro X obiettivoCentro Y obiettivoIndice di rifrazione lentiFa in modo che il punto di origine sia il punto di mezzoLivello di enfasi sui dettagli del gradiente immagineLivello di uniformitàLivello che una piena trasparenza dovrebbe rappresentareLivelliAdattamento di luceAngolo luce (in gradi)Colore luceDirezione luceFrequenza luce (blu)Frequenza luce (verde)Frequenza luce (rossa)Illumina le ombre e scurisce le alteluciLuminositàRegolazione luminositàFrequenza luminositàSpostamento di fase luminositàCome uno sfocamento gaussiano; ma dove il contributo dei pixel adiacenti è pesato anche in base alla differenza di colore con il pixel centrale originale.Limita la deformazione nell'area immagine.Limita l'esposizioneLimita la larghezza lineaLineaProfilo lineaAltezza lineeSpessore lineaLarghezza lineeLineareGradiente lineareSfocatura movimento lineareRGB lineareSinusoidale lineareRenderizzatore di gradiente lineareMaschera lineareUscita lineareLineare-premoltiplicataLineare-premoltiplicata-se-alfaPiccolo pianetaBasso aloneCarica un file SVG usando librsvgCaricamento fallitoCaricatoRegistrazione pesatura erroriLog2 dei passi di discretizzazione della sorgenteLogaritmicoBase spirale logaritmicaSmussamento loglogOmbra lungaScaglionato lungoCicloIngresso bassoLimite bassoUscita bassaSoglia bassaLivello di luminanza più bassa in uscitaErrore LuaPesi MLSAlfa pesi MLSAngolo magentaFiltro magentaCompensazione del filtro magenta per l'immagine negativaMotivo magentaPeriodo magentaAmpiezzaMagnitude della scalatura del contrasto >1.0 illumina < 1.0 inscurisceAmpiezza variazioni casuali di colorePrincipaleRendi grigiaRendi piastrellabile con continuitàCrea un rumore a turbolenzaRende il buffer d'ingresso piastrellabile senza soluzione di continuità. L'algoritmo non verifica il contenuto, perciò potrebbe essere necessario del lavoro di post-processing.AutoreRende ogni componente RGB lineare il suo valore assoluto, fabs(valore_in_ingresso)Man O WarMandelbrotManhattanMappatura toni Mantiuk 2006Mappa assolutaMappa relativaMappa all'indietroMappa dall'altoMappa l'immagine in un cerchioMascheraRaggio mascheraRaggio mascheraBuffer raggio mascheraOperazione matematica di somma, esegue l'operazione per pixel, usando la costante fornita in "valore" o il pixel corrispondente dal buffer su aux come operando. Il risultato è la valutazione dell'espressione risultato = ingresso + valore.Operazione matematica di divisione, esegue l'operazione per pixel, usando la costante fornita in "valore" o il pixel corrispondente dal buffer su aux come operando. Il risultato è la valutazione dell'espressione risultato = valore==0.0f?0.0f:ingresso/valore.Operazione matematica di gamma, esegue l'operazione per pixel, usando la costante fornita in "valore" o il pixel corrispondente dal buffer su aux come operandi. Il risultato è la valutazione dell'espressione risultato = (ingresso >= 0.0f ? powf (ingresso, valore) : -powf (-ingresso, valore))Operazione matematica di moltiplicazione, esegue l'operazione per pixel, usando la costante fornita in "valore" o il pixel corrispondente dal buffer su aux come operando. Il risultato è la valutazione dell'espressione risultato = ingresso * valoreOperazione matematica di sottrazione, esegue l'operazione per pixel, usando la costante fornita in "valore" o il pixel corrispondente dal buffer su aux come operando. Il risultato è la valutazione dell'espressione risultato = ingresso - valoreMetodo matematico per la ricostruzione dei valori dei pixelSatinatura globaleMatting LevinMaxIterazioni max.Delta maxAmmontare massimo di punti di affinamento da usare per la mesh di interpolazioneRaggio di sfocamento massimoMassima scala punti di affinamento da usare per la mesh di interpolazioneInviluppo massimoAmmontare massimo dello spostamentoDelta massimoDifferenza massimaMassima differenza tra due pixel.Numero massimo di iterazioniLabirintoTipo algoritmo labirintoSfocatura curvatura mediaSfocatura medianaMetadatiMetricaLa metrica da usare per il calcolo della distanzaValore mediano a picchiPunto medianoPunto mediano (relativo)MinInviluppo minimoRotazione specchiSpecchiMixRapporto di mescolatura, letto come quantità dell'ausiliare, 0=ingresso 0.5=mezzo 1.0=ausiliareModalitàModalità di spostamentoModalità di propagazione valoreModelloModello - elemento base su cui si lavoraModello alfa aModello alfa bModello alfa cModello alfa dModello blu aModello blu bModello blu cModello blu dModello verde aModello verde bModello verde cModello verde dModello rosso aModello rosso bModello rosso cModello rosso dModulo '%s' errore di caricamento: %sErrore moduloMixer monoMixer canale monocromaticoPiù nero (valore minore)Più opacoPiù trasparentePiù bianco (valore maggiore)MosaicoIl mosaico è un filtro che trasforma un'immagine in quacosa di simile ad un mosaico, composto da piccoli elementi, ognuno di colore costante e di dimensione approssimata.Sposta pixelSposta i pixel attorno a casoFrequenza spostamentoDenti ingranaggio mobileFattore moltiplicativo per la rotazione desiderata dello spazio locale per il motivo, il modo in cui questo viene calcolato lo rende debole per colori desaturati e forse più forte dove c'è colore.Caricatore file multiuso; usa altri gestori nativi o, in mancanza di alternativa, usa il comando convert di ImageMagick.Salvatore file multiuso, che usa altri gestori di salvataggio nativi in base all'estensione, usa l'operazione di salvataggio caratteristica per il formato per specificare parametri aggiuntivi.NULL o un GeglBuffer contenente i risultati del rendering nella cache, questo è un buffer speciale dove gegl_buffer_list_valid_rectangles restituisce la parte valida della cache.NomeNativoVicino-zPiù vicinoCamera oscura negativiVicinanzaPercentile alfa vicinanzaPercentile colore vicinanzaRaggio vicinanza, un valore negativo calcolerà con percentili inverseVicinato preso in considerazione, per il miglioramento i valori ideali sono vicini al lunghezza maggiore dell'immagine; aumentando questo valore si aumentano i tempi di esecuzioneTenendo conto di ciò che circonda, questo è il raggio in pixel preso in considerazione nel decidere la mappa di colori corrispondente ai valori di grigioTipo vicinanzaRilevamento bordi neonMaiEffetto giornaleNessuna operazioneNessuna operazione (può essere usata come un punto di diramazione)Non c'è nessun op '%s'Nessun aloneNodoRumoreRumore a prelievoRiduzione del rumoreMacchia rumoreRumore diffusoFiltro sfocatura a riduzione del rumore e mantenimento dei bordi basato sul metodo degli elementi simmetrici più viciniDeviazione standard rumoreNon-lineareComponenti non lineariNessunaMappa normaleComposizione normaleNormalizzaNormalizza il campo dei risultati da 0,0 a 1,0.Normalizza l'uscita nel campo  [base, base + passo]Non caricatoSalvatore immagini NumPy (Numerical Python)Salvatore file NumPyNumero di livelli di fusioneNumero di livelli di sfocaturaNumero di raggruppamentiNumero di coloriNumero di computazioni per la media della scala di grigiNumero di contorni (blu)Numero di contorni (verde)Numero di contorni (rosso)Numero di punti di campionamento della curva. 0 per il calcolo esatto.Numero di pixel differenti.Numero di livelli sottocampionati da usareNumero di iterazioni del filtro. Un valore tra 2 e 4 è solitamente sufficiente.Numero di quadri nell'animazione gifNumero di quadri nel video, si aggiorna non prima che il primo quadro sia stato decodificato.Numero di intensitàNumero di iterazioniNumero di iterazioni, un alto numero di iterazioni produce un'immagine meno disturbata ad un maggiore costo computazionaleNumero di iterazioni, con un numero elevato si ottengono risultati meno rumorosi ma ad un alto costo computazionaleNumero di livelli per il canale alfaNumero di livelli per il canale bluNumero di livelli per il canale verdeNumero di livelli per il canale rossoNumero di livelli per ottenere la soluzioneNumero di specchi da usareNumero di coppie; numeri elevari preservano le caratteristiche più acuteNumero di periodi per piastrella, questa piastrellatura evita le anomalie ad alta frequenza che causa ImpulsoangolareNumero di campioni lungo ogni asse per pixelNumero di campioni mediati per effettuare l'antialias del risultato.Numero di campioni da effettuare per l'iterazione d'aspetto del campo di coloriNumero di spigoli (blu)Numero di spigoli (verde)Numero di spigoli (rosso)Numero di punteNumero di sottodivisioniNumero di denti nell'ingranaggio fisso.Numero di denti presenti nell'ingranaggio mobile. Il raggio dell'ingranaggio mobile, relativo al raggio dell'ingranaggio fisso, è determinato dalla proporzione tra il numero di denti negli ingranaggi.Oggetto che fornisce metadati immagineOggetto che deve ricevere i metadati immagineOggetto che deve fornire i metadati immagineOttagoniScostamentoScostamento XScostamento YAngolo di scostamentoScostamento per l'asse XScostamento per l'asse YPittura ad olioUno di: sRGB, Adobish, Rec2020, ProPhoto, Apple, ACEScg, ACES2065-1Uno o più componenti R, G, o B sono mancantiUno o più componenti R, G o B hanno dati con segnoSolo coloreOpacitàL'opacità del tratto, si noti, non si comporta come l'SVG dato che, al momento, la delineatura viene effettuata usando lo strumento aerografo.L'opacità del tratto, si noti, non si comporta come l'SVG dato che, al momento, la delineatura viene effettuata tramite lo strumento aerografo.Soglia opacitàApri un buffer GEGLOpera su dati colore RGB linearizzatiOperazioneOttimizzaOrientamentoPunto di origine delle coordinate polariX origineY origineTemperatura originaleRaggio sfocatura fuori-fuocoModalità di uscitaComposizione in uscitaFormato di uscitaEmetti in un fileModalità di uscitaPad di uscita per il buffer immagine generato.Luminosità complessiva dell'immagineVa sopra alle impostazioni di spazio colore impostando un puntatore ad un formato che va sopra le proprietà di stringa e impostando un pad ausiliario va sopra ad entrambi. Decodificatore pagina PDFCaricatore immagini PNGSalvatore immagini PNG.Livello di compressione PNG da 1 a 9Caricatore immagini PNG.Salvatore immagini PNG, usa libpngPPICaricatore immagini PPM.Salvatore immagini PPM.Caricatore immagini PPM.Salvatore immagini RGBE (formato radianza HDR)Punto PSSquare (o euclideo)CompattaCompatta un'immagine orizzontalmente o verticalmente vicino a ogni altra con spaziatura opzionale, aux destro di ingresso.PaginaPagina da renderizzarePagineSelezione disegnoDipinge un colore di rivestimento sopra l'ingresso, mantenendone la trasparenza.Disegna ogni pixel non seme con il colore del pixel seme più vicino.CoppieTavolozzaPanProiezione panoramaPiastrelle di cartaEqualizzatore di banda parametrico per l'accordatura delle bande di frequenza, l'operazione fornisce l'astrazione dei parametri di ingresso che controllano due differenze di gaussiane pilotate da filtri passa banda usati come regolazioni del segnale dell'immagine.Errore di analisi/compilazione, se presente.Riga di comando analizzata:
	modalità:  %s
	file:      %s
	xml:       %s
	risultato: %s
	rest:      %s
	
PasswordPassword da usare per la decodifica PDF o vuota per nessunaIncolla sottoIncolla le immagini trasformate sotto ogni altraDimensione areaPercorsoPercorso del file GeglBuffer da caricare.Percorso del file da caricarePercorso del file da caricare.Percorso del file da salvare.Percorso del file video da caricarePercorso dispositivo v4lMotivoAmpiezza motivo (scala logaritmica)Motivo di rotazioneAngolo di rotazione motivo stile svgPer buffer pixel per la modulazione del raggio della maschera, aspettandosi un fattore di scala nel campo 0.0-1.0Nero percentualeBianco percentualeNero percentualePercentilePercettivaPercettiva-premoltiplicataPercettiva-premoltiplicata-se-alfaEsegue un taglio grafico in una regione localeEsegue una correzione alteluci e ombreEsegue una demosaicizzazione da scala di grigi a colore, usando l'interpolazione bimediana.Esegue una semplice demosaicizzazione da scala di grigi a colore di un'immagine, senza interpolazione.Esegue una media dei pixel adiacenti con la distribuzione normale come pesoEsegue il rilevamento bordi usando un metodo che usa una derivata gaussianaEsegue una deformazione dell'immagine a n-puntiPeriodoPeriodo (lunghezza d'onda) dell'ondulazionePeriodo per l'asse XPeriodo per l'asse YDisturbo PerlinGeneratore di disturbi PerlinFase per l'asse XFase per l'asse YSpostamento di faseFotocopiaFusione pesataPizzicoQuantità di pizzicoPixbufPrototipaggio di scripting con lua per filtri/compositori a livello di pixel. Consultare http://pippin.gimp.org/image-processing/ per i dettagli.Effetto pixelValori pixel più alti di questo limite verranno impostati ad essoValori pixel sotto questo limite verranno impostati ad essoPlasmaPunti/Pixel per pollIcePuntatorePuntatore al valore segnale di pixel non etichettatiPolareCoordinate polariPolarizzazioneOperazione Porter Duff src-in (formula = cA * aB)Operazione pulitura Porter Duff (d = 0.0f)Operazione Porter Duff dst (d = cB)Operazione Porter Duff dst-atop (d = cB * aA + cA * (1.0f - aB))Operazione Porter Duff dst-in (d = cB * aA)Operazione Porter Duff dst-out (d = cB * (1.0f - aA))Operazione Porter Duff dst-over (d = cB + cA * (1.0f - aB))Sopra un'operazione Porter Duff (conosciuta anche come modalità normale, e src-over) (d = cA + cB * (1 - aA))Operazione Porter Duff src (d = cA)Operazione Porter Duff src-atop (d = cA * aB + cB * (1.0f - aA))Operazione Porter Duff src-out (d = cA * (1.0f - aB))Operazione Porter Duff xor (d = cA * (1.0f - aB)+ cB * (1.0f - aA))Posizione della sorgente di luce che illumina la tela: alto a destra, alto a sinistra, basso a sinistra o basso a destraPosterizzaPotenza usata per stendere la miscelaFa il preflash al negativo con luce blu per ridurre il contrasto della stampaFa il preflash al negativo con luce verde per ridurre il contrasto della stampaFa il preflash al negativo con luce rossa per ridurre il contrasto della stampaPreserva modelloPreserva luminositàBussola di PrewittAlgoritmo di PrimStampa XMLProPhoto RGBProgressivePropaga certi colori ai pixel vicini. Erode e dilata qualsiasi colore o opacità.Propaga verso il fondoPropaga a sinistraPropaga a destraPropaga verso la cimaPropagazione del canale alfaRitmo di propagazionePropagazione del canale valoreProprietà:ProporzioneMette la riga in cima nel mezzo e la riga in fondo nella parte esternaQualitàRGBBlu RGBVerde RGBRosso RGBCaricatore immagini RGBESalvatore immagini RGBECaricatore immagini RGBE (formato radianza HDR)Salvatore di immagini RGBE (formato radianza HDR)RadialeGradiente radialeRenderizzatore di gradiente radialeRaggioRaggio (1.0 è il più largo cerchio che entra nell'immagine, mentre 2.0 va sugli spigoli)Raggio 1Raggio 2Raggio del cerchio attorno al pixel, può essere anche scalato per pixel da un buffer sul pad aux.Raggio dell'effetto (in pixel)Raggio ingranaggio fissoRaggio della regione del pixel della riga (la dimensione sarà raggio*2+1).Raggio della regione di pixel quadrata (larghezza e altezza saranno raggio*2+1).Raggio della regione di pixel quadrata (larghezza e altezza saranno raggio*2+1).Raggio della supernovaRaggio finestra di trattamentoRaggio dello sfocamento waveletCasualeCovariante casualeTonalità casualeSeme casualitàCasualizzazione (%)Casualizza indipendentemente tonalità, saturazione e valoreCasualizza indipendentemente la luminosità, crominanza e tonalitàScambia pixel a casoScambia a caso alcuni pixel con i suoi viciniSposta casualmente alcuni pixel in basso (simile allo scioglimento)RangoRapportoFormato RAWCaricatore di immagini RAW, che si interfaccia con dcraw tramite pipe. Fornisce una griglia bayer grezza come scala di grigi, se il formato di file è .rawbayer, che userà questo caricatore invece del normale caricatore dcraw. Se il formato file è .rawbayerS, scambierà i numeri a 16 bit restituiti (sembra che il caricatore pnm abbia qualche baco)LetturaLettura/ScritturaRettangoloTrasformazione ricorsivaRossoMoltiplicatore del canale rossoRimozione occhi rossiSoglia del rossoAngolo del rosso e del cianoMotivo rosso e cianoPeriodo rosso e cianoAngolo del rossoModalità di applicazione del rossoCanale del rossoContorni rossiSoglia occhi rossiFrequenza rossoRosso nel canale del bluRosso nel canale del verdeRosso nel canale del rossoInversione rossoLivelli rossoMotivo rossoPeriodo rossoSpostamento di fase rossoPreflash rossoSpigoli rossiFattore di stiramento rossoSoglia del rosso del colore in ingressoRiduce il numero di colori nell'immagine, riducendo il numero di livelli per canale (colore e alfa). Diversi metodi di dithering possono essere specificati per contrastare l'effetto di quantizzazione introdotto.Riduce il numero di livelli in ogni componente di colore dell'immagine.RiferimentoScala affinamentoPassi di affinamentoRiflettiRifletti un'immagine intorno ad una linea, la cui direzione è specificata dal vettore definito dalle proprietà x e y.Rifletti il motivo orizzontalmenteDimensione regioniRegolarizza la geometria ad una velocità proporzionale al valore della media della curvatura localeMappatura toni Reinhard 2005Colorimetrica relativaCambiamento brillantezza relativa in stopBrillantezza relativa per ogni esposizione in EVIntensità evidenziazione relativaRimappaRimappa il campo di intensità dell'immagineMescola i colori; definendo i contributi relativi dai componenti sorgente.Rimuove l'effetto occhi rossi generato dai flashPercorso renderDisegna spirografoDisegna testoDisegna un motivo a scacchieraAltezza renderizzazione in pixel (sola lettura).Larghezza renderizzazione in pixel (sola lettura).Intento di renderingDisegno di diversi tipi di sistemi frattali, con opzioni di colorazione configurabili.Tipo renderingDisegna un motivo tipo spirografoRenderizza il tratto di un pennelloProduce una regione riempitaOttiene la delineatura di un vettorialeResa dei profili di luminanza per le componenti rossa, verde e blu lungo la linea specificata nel buffer di ingresso, disegnati in un buffer della dimensione specificata.RipetiRimpiazza un campo di colori con un altroColore di rimpiazzo.Riposiziona il buffer (con precisione subpixel), se le coordinate intere sono passate da una scorciatoia senza usare il ricampionamentoMetodo di ricampionaturaRiscala la dimensione generale dell'immagineReimposta origineRisoluzione in pixelRotazione risultanteMantiene la piastrellabilitàDestraRigiditàIncrespatureRobertsRuotaRuota sul centroRuota il buffer attorno al suo centro, tenendo conto di possibili scostamenti.Ruota il buffer attorno all'origine specificata.RuotatoRotazioneRotazione applicata gli specchiRotazione applicata ai risultatiAngolo di rotazione sfocatura. Un angolo grande può aumentare il tempo di elaborazioneSuperficie piastrella grezzaTondoSchermo SDLSchermo SDL2Caricatore immagini SVGRuota tonalità SVGLuminanza SVG ad alfaMatrice SVGSaturazione SVGOperazione fusione SVG bruciatura-colore (<code>if cA * aB + cB * aA <= aA * aB: d = cA * (1 - aB) + cB * (1 - aA) altrimenti: d = (cA == 0 ? 1 : (aA * (cA * aB + cB * aA - aA * aB) / cA) + cA * (1 - aB) + cB * (1 - aA))</code>)Operazione fusione SVG schermatura-colore (<code>if cA * aB + cB * aA >= aA * aB: d = aA * aB + cA * (1 - aB) + cB * (1 - aA) altrimenti: d = (cA == aA ? 1 : cB * aA / (aA == 0 ? 1 : 1 - cA / aA)) + cA * (1 - aB) + cB * (1 - aA)</code>)Operazione fusione SVG scurisci (<code>d = MIN (cA * aB, cB * aA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operazione fusione SVG differenza (<code>d = cA + cB - 2 * (MIN (cA * aB, cB * aA))</code>)Operazione di fusione SVG esclusione (<code>d = (cA * aB + cB * aA - 2 * cA * cB) + cA * (1 - aB) + cB * (1 - aA)</code>)Operazione di fusione SVG "luce dura" (<code>if 2 * cA < aA: d = 2 * cA * cB + cA * (1 - aB) + cB * (1 - aA) altrimenti: d = aA * aB - 2 * (aB - cB) * (aA - cA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operazione di fusione SVG "illumina" (<code>d = MAX (cA * aB, cB * aA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operazione di fusione SVG "rivestimento" (<code>if 2 * cB > aB: d = 2 * cA * cB + cA * (1 - aB) + cB * (1 - aA) altrimenti: d = aA * aB - 2 * (aB - cB) * (aA - cA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operazione di fusione SVG "più" (<code>d = cA + cB</code>)Operazione di fusione SVG "schermo" (<code>d = cA + cB - cA * cB</code>)Operazione di fusione SVG "luce morbida" (<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); altrimenti: d = (aA * cB + (aB == 0 ? 0 : sqrt (cB / aB) * aB - cB) * (2 * cA - aA)) + cA * (1 - aB) + cB * (1 - aA)</code>)Operazione matrice di colori SVG svg_huerotateOperazione matrice di colori SVG svg_luminancetoalphaOperazione matrice di colori SVG svg_matrixOperazione matrice di colori SVG svg_saturateDescrizione stile SVG della trasformazionePunti di campionamentoCampionatoreCampionatore usato internamenteCampioniSaturazioneRegolazione della saturazioneFrequenza saturazioneSpostamento di fase saturazioneValore di saturazione sopra le impostazioni del grigioSalvaDente di segaLivello di soglia scalare (ignorato se viene fornito un buffer di ingresso ausiliario).ScalaDimensione scala 1:1Fattore di scale per rendere la dimensione di rendering più grandeScala dell'immagineRapporto di scalaDimensione di scalaLa dimensione di scala mantiene l'aspettoScala il valore secondo l'asse xScala il valore secondo l'asse yScala, forza dell'effettoAntialiasing Scale3XScala il buffer secondo un rapporto.Scala il buffer secondo una dimensione.Scala il buffer, mantenendone il rapporto dimensioniScala i componenti del buffer affinché rimangano nel campo 0.0-1.0. Ciò migliora le immagini che fanno cattivo uso del contrasto disponibile (poco contrasto, immagine molto scura o molto chiara).Scala i componenti del buffer affinché rimangano nel campo 0.0-1.0. Ciò migliora le immagini che fanno cattivo uso del contrasto disponibile (poco contrasto, immagini molto scure o molto chiare). Questa versione differisce da "Autoampiamento contrasto" dal fatto che lavora in spazio HSV e preserva la tonalità.ScalaturaFattore di scala per le caratteristiche dell'immagine al raggio, -1 le elimina mentre 1.0 le aumentaFattore di scala di maschera di contrasto, forza dell'effettoDispersioneDispersione (velocità contro qualità)ScriptPad d'ingresso per il secondo buffer immagine ausiliario.Semina bordiSegmenta i colori usando il clustering secondo il metodo K-meansSeleziona l'n-esimo punto più vicinoSfocatura gaussiana selettivaTonalità-saturazione selettiveRegolazione della tonalità, saturazione e luminosità selettiveSeparatoreSeppiaImpostare a Nativo se in dubbio, gli spazi basati su CIE potrebbero introdurre spostamenti di tonalità.Imposta la quantità di blu per il canale bluImposta la quantità di blu per il canale verdeImposta la quantità di blu per il canale rossoImposta la quantità di verde per il canale bluImposta la quantità di verde per il canale verdeImposta la quantità di verde per il canale rossoImposta la quantità di rosso per il canale bluImposta la quantità di rosso per il canale verdeImposta la quantità di rosso per il canale rossoImposta l'altezza in pixel alla quale il testo viene giustificato verticalmente. Usare -1 per disabilitare la giustificazione verticale.Imposta la larghezza in pixel alla quale le righe di testo lunghe andranno a capo. Usare -1 per disabilitare l'a capo automatico.Diversi sempici metodi per il rilevamento dei bordiAngolo ombraColore ombraPunto mediano sfumo ombraPunto mediano sfumo ombra, dipendente dalla lunghezza dell'ombraLunghezza ombraOmbra meno immagineSolo ombraOmbra più immagineStile ombraOmbreRegolazione colore ombreOmbre-alteluciFormaAffila (maschera di contrasto)Migliora il contrasto dell'immagine, aggiungendo differenze all'immagine sfocata, una tecnica usata originariamente in camera oscura.NitidezzaInclinaInclina il buffer.SpostamentoSpostamento XSpostamento YDirezione spostamentoSposta ogni riga o colonna di pixel di una quantità casualeSposta punto di biancoSe l'estensione del risultato deve essere tagliata all'estensione dell'ingressoMostra opzioni GEGLMostra controlli illuminazioneMostra controlli preflashRiduci areaSierpinskiSemplice clustering iterativo lineareRumore sempliceSemplifica un'immagine in un insieme di riquadri di colore pienoSimula l'elaborazione in camera oscura dei negativi analogici.Emula un'antica incisioneSimula una distorsione di color prodotta da una fotocopiatriceSimula la distorsione causata da piastrelle di vetro rettangolariSimula un bagliore rendendo le alteluci intense e sfocateSimula la sfocatura di lenti fuori fuocoSimula un fumetto, i suoi risultati sono simili ad un disegno fatto con un pennarello di feltro nero al quale siano stata aggiunte delle sfumature colorate. Viene ottenuto tramite un'aumento dei bordi e un inscurimento delle aree che sono già distintamente più scure di quelle vicine.Simula l'effetto goffratura sull'immagineSimula l'effetto di distorsione ottica di una lente ellittica sull'immagineSenoSenoSinusoidaleDimensioneDimensione XDimensione YDimensione di un lato della regioneDimensione di un lato del quadrato della mesh di cui è costituitoDimensione delle aree usate per la rimozione del rumoreRapporto dimensione XRapporto dimensione YSfumatura per trasformazione di dominioDistorsione smussaturaLevigaturaFattore di levigatura da 1 a 100; 0 disabilita la levigaturaUniformitàSobelRilevamento bordi SobelBagliore tenueMorbidezzaRumore pienoSorgenteProfilo sorgentePercorso file immagine sorgente (png, jpg, raw, svg, bmp, tif, ...)Nome spazioSpaziaturaEstensione spazialeRegolarizzazione spazialeDeviazione spaziale standard del nocciolo di sfocatura, misurata in pixel.Sviluppo tipo retinex spazio temporale con campionamento stocasticoSpeciale rilevamento bordi direzione-dipendenteSfericoAngolo massimo copertura sferica, come frazione del co-angolo di vistaSfericizzaSpiderSpinRotazione angolo attorno all'asse dell'obiettivoSpiraleCoordinata X di origine spiraleCoordinata Y di origine spiraleRaggio spiraleDisegnatore di spiraliRotazione spiraleDirezione vortice spiraleTipo di spiraleSpirografoQuadratoDimensione quadratoQuadratiSpremiScaglionatoDeviazione standard (fattore di scala spaziale)Deviazione standard per l'asse orizzontaleColore d'inizioAngolo iniziale del campo colore destinazioneAngolo iniziale del campo colore sorgenteParti dalla destra invece che dalla sinistraCoordinata x di inizioCoordinata y di inizioDev. Std.PassoStop 1Stop 2Stop 3Stop 4Stop 5Salva l'immagine in un GdkPixbuf.Salva in un GdkPixbufMemorizza il profilo ICC che verrebbe incorporato se memorizzato in un'immagine.ForzaForza dell'effettoForza del miglioramento del dettaglio localeForza dell'effetto seppiaAmpliamento contrastoAmplia contrasto HSVStira la crominanza del colore per coprire il massimo campo possibile, mantenendo tonalità e luminosità invariate.Stringa da mostrare (utf8)A strisceTrattoColore delineaturaOpacità delineaturaSpessore delineaturaStileStile dell'effettoSottodivisioniSottoinsiemeSottraiSovrappone più copie diverse tra loro dell'immagine.SupernovaSuperpixel basati su clastering secondo il metodo K-meansI superpixel basati sulla trasformazione spartiacqueColore superpixelDimensione superpixelSupecampionaturaSovrainsiemeCaratteristiche superficieVortice in senso orarioVortice in senso anti-orarioPassa a senso orarioVicino più prossimo simmetricoCaricatore immagini TIFFSalvatore file TIFFCaricatore immagini TIFF che usa libtiffSalvatore immagini TIFF che usa libtiffFrequenza bit video codificato obiettivo in kb/sPercorso file su cui scrivere il GeglBuffer.Percorso e nome file obiettivoPercorso e nome file dell'obiettivo, usare "-" per stdoutNome e percorso file obiettivo, usare "-" per lo stdout.Sfocatura temporaleOperazione di test per fare una mappa 1:1 dell'ingresso sull'uscita, durante il campionamentoTestoRende l'immagine come se fosse eseguita sulla tela di un pittore.Applica telaIl GeglBuffer da caricare nella pipelineQuantità per la quale scalare i valori di altezzaL'ammontare della compressione del contrastoIl formato babl in ingressoIl formato babl del risultatoIl formato babl di GeglBuffer, NULL per usare il formato del buffer in ingressoIl colore di sfondoIl cmsHPROFILE corrispondente al profilo ICC dei dati in ingresso.Il colore a (x1, y1)Il colore a (x2, y2)Il colore della supernova.Il colore da cambiare.Il colore da rendere trasparenteIl colore da dipingere sopra l'ingressoIl colore da renderizzare (predefinito è "nero")La componente usata per le coordinate XLa componente usata per le coordinate YLa curva di contrasto.Il numero di pixel da elaborare simultaneamenteLa distanza di espansione dell'ombra prima della sfocatura; un valore negativo contrarrà invece l'ombraIl metodo dithering da usareL'f-stop di scherma/brucia per ingresso ausiliario puro bianco/neroIl riempimento opacità da usareIl riempimento opacità da usare.Il colore della prima cellaIl colore di primopianoIl primo piano contiene buchi e/o diverse parti non interconnesseIl primo piano non contiene parti opacheIl primo piano è troppo piccolo da usareIl limite sopra il quale i colori rimangono opachi.Il limite sotto il quale i colori diventano trasparenti.La posizione dove memorizzare il buffer di uscita GeglBufferLo script lua contenente l'implementazione di questa operazione.Massima differenza in valore alla quale propagare un pixelLa minima differenza in valore alla quale propagare un pixelIl numero di thread concorrenti da usareNumero di iterazioni di deformazioneNumero di divisioniNumero di ottave di rumoreIl numero di pixel attraverso una ripetizione di un motivo di base alla risoluzione di base.Le parti opache del primo piano non solo sopra lo sfondo!Orientamento della sfocatura - oriz/vertIl pixbuf d'uscita prodotto dal processo viene immagazzinato in questa proprietàLa qualità del rendering, un valore tra 0.0 (veloce) e 1.0 (riferimento)Il seme della casualità per le punte e la tonalità casualeIl seme della casualità per la funzione di rumoreIl riferimento ID usato come ingresso (per usarlo in XML)L'intento di rendering da usare nella conversione.La scala della funzione del rumoreIl colore della seconda cellaIl colore dell'ombra (predefinito è "black")Forma dei pixelLa forma a cui espandere o contrarre l'ombraLa forza con la quale propagare un pixel ai suoi viciniIl colore di sfondo delle piastrelleIl valore rappresenta il contributo al nuovo del quadro passato.Lo spessore del pennello usato per delineare un percorsoLo spessore del pennello usato per la delineatura del tracciato.C'è un problema nella sintassi o nell'applicazione dei valori delle proprietà elaborate. Comunque potrebbe funzionare ugualmente.Questo sfocamento viene usato per il filtro di decomposizione wavelet, ogni pixel viene calcolato da un'altro usando la trasformazione HATQuesta funzione simula la degradazione presente nei vecchi monitor video RGB a bassa risoluzione.Questo plug-in produce un effetto simile al lampo di una supernova. La quantità dell'effetto luce è approssimativamente proporzionale a 1/r, dove r è la distanza dal centro della stella.Questo plug-in usa l'algoritmo descritto da John Schlag, "Fast Embossing Effects on Raster Image Data" in Graphics GEMS IV (ISBN 0-12-336155-9). Prende un buffer per applicarlo come mappa a sbalzi ad un altro buffer producendo un bell'effetto rilievo.SogliaSoglia altaSoglia bassaApplica una soglia all'immagine  per produrre un'immagine bianco/nera basandosi sui valori globali impostati nelle proprietà del valore o per pixel dall'ingresso ausiliare.PiastrellaPiastrella di vetroAltezza piastrellaLarghezza piastrellaColore piastrella basato sulla media di sottosomme di pixelVariazione colore piastrellaGeometria piastrellaAltezza piastrellaRegolarità piastrellaSaturazione mattonellaDimensione mattonellaSpaziatura piastrellaPiastrellabilePiastrellatoMappa a sbalzi piastrellataTiltTitolo da dare alla finestra di uscitaAA 0A 1A 2A 3A 4A 5A 6A 7Al coloreVerso il fondoA sinistraA polareA destraVerso la cimaCimaIn cima a sinistraIn cima a destraPagine totali, fornita come una proprietà visuale in sola letturaAlla fineTrasformaTrasforma l'immagine con i frattaliStringa di trasformazione sintattica SVGLa matrice di trasformazione, usando la sintassi SVG (o matrici multiple, separate da punto e virgola)TraslaTrasla l'alto a sinistra a 0,0.Soglia trasparenzaTrasparenteTratta come questoTratta come questo: i colori grigi dal campo sorgente sopra verranno trattati come se avessero questa tonalità e saturazione
Cambia in questo: cambia i colori grigi a questa tonalità e saturazioneTriangoloTriangoliX regolazioneY regolazioneFattore di influenza trimapTurbolenzaTurbolenzaTrasforma una immagine in scala di grigi e copertura in una griglia supersatura - tramite l'assimilazione di colore che avviene nel sistema di visione umano, per alcune scale di griglia ciò produce l'illusione che le celle stesse in scala di grigi abbiano del colore.Trasforma l'immagine in scala di grigiTipoTipo 1Tipo 2Tipo di GeglSampler usato per recuperare i pixel in ingressoTipo di motivo RGB da usareTipo di un frattaleTipo di illusioneTipo di mappaURIURI del file da caricareURI per il file da caricare.URI o file da caricareURI del file da caricare.URI dell'immagine da caricare.Impossibile convertire l'immagine nello spazio di colore sRGBImpossibile creare un profilo colore di uscitaImpossibile aprire l'immagine JPEG 2000Impossibile leggere il file: %sModalità GeglOption sconosciuta: %dFormato immagine JPEG 2000 sconosciutoDepremoltiplica un buffer che contiene colori pre-moltiplicati (ma secondo il formato babl non è così).Depremoltiplica alfaColore regione non seminataFile JPEG 2000 non supportato con profondità di colore %dTipo di frattale non supportatoTipo frattale non supportato: %dFile non-RGB JPEG 2000 non supportato con %d componentiSoglia altaUsa pesi MLSUsa una distribuzione del rumore gaussiana, se non selezionata viene invece utilizzata una distribuzione del rumore lineareUsa un esistente GeglBuffer in memoria come immagine sorgente.Usa un GeglBuffer su disco come sorgente dati.Usa i valori di maschera lineareUsa un'uscita lineare invece che corretta nella gammaUsa regione localeUsa tabelle di Huffman ottimizzateUsa i valori di luminanza dei pixelUsa la gamma sRGB invece di quella lineareUsa il campo pieno [0,1] per codificare le coordinate ZValore utenteUsa il GdkPixbuf posizionato alla locazione di memoria in <em>pixbuf</em>.ValoreInverti valorePropagazione valoreValore in fondoValore in cimaEsponente valore (scala logaritmica)Scostamento valoreValoriSfocatura variabileVettoreDelinea vettoreVerticaleTraslazione verticale obiettivoSpostamento verticaleEstensione verticaleGiustificazione verticaleLa giustificazione verticale a 0.0 è in cima in alto, 0.5 a metà e 1.0 in fondo in basso.Scostamento verticaleScostamento verticale (dall'origine) per la griglia di partenzaScostamento verticale dei blocchi in pixelScala motivo verticalePosizione verticalePosizione verticale in pixelFattore di scala verticaleScostamento verticale dell'ombraQuantità dell'inclinazione verticaleDimensione verticaleRapporto dimensione verticale di un pixel dentro ogni bloccoQuantità di diffusione verticaleAllineamento verticale del testo (0=cima, 1=metà, 2=fondo)Dimensione verticale motivoTraslazione verticaleAmpiezza verticale dei pixel delle celleDegradazione videoDimbuf videoCodec videoCodifica video da usare, o auto per usare un buon valore predefinito basato sul formato del contenitore.Sorgente quadri Video4LinuxIngresso video4Linux, webcam, framegrabber e dispositivi similari.Sorgente quadri Video4Linux2Ingresso video4Linux2, webcam, framegrabber e dispositivi similari.VignettaForma vignettaVisualizza la maschera di regolazioneDiagramma VoronoiWarpDeforma i colori di un'immagine tra colori con fattori di distorsione pesati, le coppie di colori che sono nero a nero vengono ignorate durante la mappatura.Livello dell'acquaPixelacqueTrasformazione spartiacqueTipo di ondaOndeCaricatore immagini WebPSalvatore immagini WebPQualità compressione WebPCaricatore immagini WebP.Salvatore immagini WebPPeso dei contributi alla risposta della distribuzione sigma controllataPeso sigmaFusione pesataPesa l'opacità dell'ingresso sia nel valore dell'ingresso ausiliario che nella proprietà di valore globale.Il modello di colore usato per la trasformazioneForma da usare per le piastrelleSe questo valore è vero il modello non sarà liberatoSe abilitata aumenta anche le regioni d'ombra - se disabilitata si ottiene un risultato più naturaleSe abilitata i dettagli nelle ombre vengono aumentati a discapito dei disturbiSe impostata opera su valori gamma corretti invece di RGB lineari - agendo come il vecchio filtro di normalizzazione di GIMPDove GEGL memorizza la propria swapSe la funzione aggiunge il risultato all'immagine originale.Se i bordi dell'immagine sono seminatiSe propagare il colore di un pixelSe propagare l'opacità di un pixelSe deve ruotare il motivo RGB di novanta gradi.VorticeVortice e pizzicoAngolo vortice (gradi)BiancoBianco su neroRegolazione del punto di biancoRGB a gamut ampioA strisce largheLarghezzaLarghezza dell'immagine renderizzataAmpiezza dell'intervallo di selezione della tonalitàLarghezza del blocco in pixelLarghezza linee griglia in pixelLarghezza del buffer generatoLarghezza piastrellaVentoUn effetto ventoTitolo finestraBordi connessiAltezza a capoAvvolgi l'immagine attorno ad una copertura sfericaAvvolgi l'ingressoRendi i motivi frazionari contigui fra i bordiLarghezza a capoScritturaBuffer di scritturaScrivere il nome dell'apparecchio correttamente Scrive i dati di ingresso in un preesistente buffer superficie di destinazione GEGL.Scrive il marcatore lente correttamenteScrivere il modello dell'obiettivo con le maiuscoleScrive i dati immagine su un buffer già esistentePixel sbagliatiXAmpiezza XComponente XScostamento XPeriodo XFase XScala XDimensione XRapporto assi X per il centro della specchiaturaRapporto asse X per la regolazione dell'espansione dello specchioCoordinata X dell'originecoordinata X del centro del motivoCoordinata X dello spostamento del centroCoordinate X del centro della supernovaCoordinate X del centro dei riflessiSpostamento XMoltiplicatore XPosizione XSpostamento X nello spazio frattaleInizio X del buffer generatoX0X1Valore, posizione X1X2Valore, posizione X2YAmpiezza YComponente YScostamento YPeriodo YFase YScala YDimensione YRapporto assi Y per il centro della specchiaturaRapporto asse Y per la regolazione dell'espansione dello specchioCoordinata Y dell'originecoordinata Y del centro del motivoCoordinate Y dello spostamento del centroCoordinate Y del centro della supernovaCoordinate Y del centro dei riflessiSpostamento YPosizione YSpostamento Y nello spazio frattaleInizio Y del buffer generatoY'CbCr CbY'CbCr CrY'CbCr Y'Y0Y1Valore, posizione Y1Y2Valore, posizione Y2Angolo gialloFiltro gialloCompensazione del filtro giallo per l'immagine negativaMotivo gialloPeriodo gialloCoordinata Z del piano vicino al ritaglioMoltiplicatore ZScostamento ZZoomZoom nello spazio frattaleLivello di zoomSfocatura di movimento zoomSfocatura di movimento zoom[op [proprietà=valore] [proprietà=valore]] [[op] [proprietà=valore]un file GeglBuffer su disco da aprireaggiungi-alfaquantitàaudiofrequenza bit audio in kb/sfrequenza di campionamento audioaudio-codecaudio_channelsaudio_sample_ratel'autoinnesco la ricarica molte volte al secondo.formato bablfonde due immagini usando i valori alfa come pesiimpossibile creare un nuovo stream Jasperimpossibile interrogare il file JPEG 2000attuale numero di quadri, può essere cambiato per innescare la ricarica dell'immagine.impossibile aprire l'immagine JPEG 2000 da %sfile da caricaresegnalevirgola mobile -1 significa auto, 0 significa intero, 1 significa virgola mobile.quadronumero di quadro da decodificareritardo di quadroframe-rateframesqualità globalevalore globale usato se aux non contiene datiscala di peso globalegluasgop-sizehome determinare cosa riempire (nonzero|paridispari)i-quant-factori-quant-offsetkeyint-minCaricatore immagini librawelenco di <numeri>max_b_framesmax_qdiffme-subpel-qualityme_rangeriduzione del rumorenumero di livelli per componenteop '%s' non trovato, riscontri parziali: x-originey-originealtezza risultato in pixel, -1 per l'altezza in ingressolarghezza risultato in pixel, -1 per la larghezza in ingressopercorso del file su cui scrivere.caricatore pdfpipelinepuntatore ad un const * spazio Bablposizione del centro di simmetria in uscitaqblurqcompressqmaxqminaltezza-regionelarghezza-regionex-regioney-regiones RGBsRGBcampiona l'ingresso con un buffer ausiliario che contiene le coordinate assolute della sorgentecampiona l'ingresso con un buffer ausiliario che contiene le coordinate relative della sorgenteFattore di scala di piazzamento, indica a quanto dovrà corrispondere il valore di mappatura relativo 1.0 di estensione spaziale del piazzamento.soglia cambioscenaimposta lo spazio colore con cui vengono creati i successivi formati babl nella pipeline e il profilo ICC potenzialmente incorporato per la gestione del colore esterna, l'impostazione di un puntatore a un formato sovrascrive la proprietà della stringa e l'impostazione di un pad ausiliario sovrascrive entrambi.integrale al quadratostira i componenti di pixel individualmente basandosi su contenitori di luminanzastile svg descrizione della trasformazione.dimensioni mattonella da usare.compromesso tra regolarità dei superpixel ed aderenza ai bordi degli oggettitrellispercorso dati non gestito %s:%s
modalità sconosciutauri o file da caricareuso: %s [opzioni] <file | -- [op [op] ..]>

  Opzioni:
     -h, --help      queste informazioni d'aiuto

     --list-all      elenca tutte le operazioni conosciute

     --exists        restituisce 0 se la/le operazioni esistono

     --info          emette informazioni sull'operazione:
                     nome, descrizione, dettagli sulle proprietà.

     -i, --file      legge l'xml dal file col nome specificato

     -x, --xml       usa l'xml fornito dal successivo argomento

     -o, --output    emette l'immagine generata sul file col nome specificato,
                     del tipo determinato dalla sua estensione.

     -p              incrementa i contatori di quadro di vari elementi quando
                     termina l'elaborazione.

     -s scala, --scale scala  scala le dimensioni del risultato di questo fattore.

     -X              emette l'XML che ha letto

     -v, --verbose   stampa della diagnostica durante l'esecuzione

Tutti i parametri che seguono i caratteri -- sono considerati operazioni da
concatenare in piccole composizioni, in alternativa all'uso di un file xml; ciò
consente una facile verifica dei filtri. Dopo la concatenazione una nuova op
può essere impostata con coppie proprietà=valore come argomenti successivi.
usa la virgola mobilebitrate video in kb/sbitrate video maxbitrate video mintolleranza bitrate videopercorso dispositivo videovideo-codecpeso 0peso 1peso 2peso 3peso 4peso 5peso 6peso 7