Mini Kabibi Habibi

Current Path : C:/Users/ITO/AppData/Local/Programs/GIMP 2/share/locale/pt/LC_MESSAGES/
Upload File :
Current File : C:/Users/ITO/AppData/Local/Programs/GIMP 2/share/locale/pt/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��������ͫ٫���������!�3
�*A�l���������������������ĮʮЮ֮ܮ�����������B�Oa�������ү���*�7�/<�ml�-ڰ!�D*�9o�@����\�b�r�{���n����&�~����2��2��	���!�*6�0a���(��(÷�#�*�#J�n�.��.���q�u�	����
����G���	��3��3�
8�C�S�s�-����Ż̻
�H��?��Y�&�&�/�	M�-W�-����KŽ��1����Ŀ̿����1�(O�&x�I���`��,Z������
m�.{�*��+��"�$�5�Q�a�|����{�k����K�O�.g�>����-��
�$�)@�(j�+�������� ����'�
4�B�Y�
b�
p�
{�
����"��������
��n��
Y�g���������������
�����
�-�<�
Y�	g�q�2������3��	��+�8�=�Y�e������������
����,�?�S�j�|���
����������%�(�;�@Q�g����?
�?M�O��,��?
�J�]��q��
� �:�@�F�[�n���������2������
��6�-E�s����
��
��������*����*���*�/I�y�����
��������P��A�S�Z�c�l�*��<������S�bY������������	������������''� O� p�����
����?���4�%T�*z�����
�������������������������
����/�
B�%P�
v�V��+��#�%+�Q�8j���3��
��_���T���
�5� T�u�G����R��:��F�	��1*�\�i�
���$����$���$(�M�m�<��%����	��F��C�=O�;��H��,�?�U�_j�	��������B�!Y�R{���O��0�/I�.y�i��.��A����1#�
U�>c�:��������5�"A�>d�'����8��6!�X�3w�������8���	�%�
+�
9�1G�
y���4��
������/��X�x�~�*��3��,���7�DO��������������p�,����������-��	$�$.�S�%g�%����������8��E �8f�&����9��9�5O�7��V���1#�U�s�(��z��(���/��*��!�
>�	I�S�i�o�x����Cn�^��B��T�_�2k���������+��)�0�?�S�c�~� ��!��$�p��o���q����0�M�&c�
����������3��	*�)4�(^��������������%�M1�
�
��a������'�s:�����(���&
�4�T�*q�$�������
��!	�+�F�#b�E��k�8�IA�����-�� ���3�rK������8�,
G
R]w����!��#>N^n� �$��'>M]l	{�:�������-J
\j���1�4�	(2G`q#�!� �"�2C$^�:�t�P#m���H"-^P��-�2		I	S	e	+|	6�	
�	�	

,
2
O
_
w
�

�
�
�
�
�
.FY
jx����&�
+
=K]�pmq��	�'�/�CpO����'9Qc
gr�����6�(11?c)����3?[q
����M�*2<'o�� �� !BCU%���(�I.f`���f|;�!5ABw/�:�#%AI0�6��
&;Yv5����
&*)<-f6���7�;Xu������(�GcgT�� �J')r��%�R� 7 J [ )d � � C� 6� 4.!c!s!�!�!&�!4�! "'"G"_"h"�"�"�"l�"i1#�#�#g�#A$R$^$.~$�$�$-�$)%(=%f%i%l%{%#�%#�%�%�%�%&?&O&\&s&�&�&�&�&�&�&'<#'!`'a�'�'%�'!( <(](c(i(	o(	y(�(�(�*�*�*
�*�*�*�*�*�*%+(+.+C+X+j+|+�+-�+5�+,5%,[,c,v,
�,�,�,�,�,'�,$-1-F-$b-��-($.M.a.|.�.�.�.�.,�.�./
#/./ @/a/
q//�/�//�/'�/0	50 ?0,`0�0�0�0�0�0�0
11"1/1*?1j1	s1}1�1�16�1�1�1	2;2-L2	z2�2�2�2��2
m3\x3	�3
�3	�3�3
4
 4.4C4R4o4x4�4�4��4�5"�6��7��87�9�9
:
::
):W7:�:V�:;";
5;C;&V;};	�;�;�;�;	�;�;/<8<
P<^<w<|<�<�<�<Q�<=
====)D=
n=
|=
�=
�=
�=
�=
�=
�=�=�=�=>>,>>>P>(b>�>�>"�>�>
�>�>?(?�0?
�?%�?@@�:@~�@�wA�#B�B�B
�B:�B%C=C ICjCO�C��Cy{D�D	E#E)E9E2HE{EJ�E�E�E�EFF,FtCF�F�F�F�F�FG
"G0-G8^G�G,�G�G�G H-HDH6UH�H�H�HK�H1I'QISyI'�Ia�IWJoJp�Jm�J$eK$�K%�K(�K*�K)LPHLo�L4	ML>MK�M"�M#�M&NENVN%nN��N&MO'tO(�O
�O�O�O�O�O�OP%PB+P)nP8�P�P	�P�P�cQ�Q�Q*
R
8RCRLR+YR�R�R�R�R�R�R�RSS/*SZS�qS#TAT]T#wT�T&�T�T�T�TU60UgU�Uq�UVVV&VR:VI�V�V	�V�V�VWW+XoGX
�XI�XY2YOYeY*mY�Y�Y�Y(�YZ>Z*FZqZ�Zi�Zf[w[�[�[	�[	�[�["�[&	\0\fO\]�\U]Fj]*�]�]&�]^#^
:^H^a^t^�^
�^�^�^�^�^��^	~_K�_L�_!`(`E`:N`�`�`
�`I�`/�`)+aFUa1�a;�aA
beLb)�bF�b;#cI_ct�c
d")dSLdT�dW�dMe^eue�e�e�e�e[�ef2fKfcfvf�f�f
�f�f;�f	g%g)g	2g<gIgfg1�g/�g�g�g �ghU!hwh~hn�h�hiF(iKoiK�ijj9j
Vjajwj�j�jA�jB�j0k4Pk<�k	�k�k�k?�k$m
(m
3m>mXmam�m�m�m�m�m�mn.n=nQnln�n�n�n�n�n�n	oo9oMoho)�o��o?�p�p�p�p�pqq sq�qW�qr r+6r)br"�r�r-�rM�rQ4s�s�s�s-�s/�s0 tQtSnt�t$�t�tu/u�Ju�u*�uv�5v�v%�v�vww+2w^wfwnwvw~w�wF�w/�wx	xx<xY\x�x�x
�x�x�xy y
:yEy�Uy�NzsL{d�{~%|��|qv}��}?�~K�~�E-��4#�*X�,��,��݁
����!�-�A�#\�;����ĂSӂ'�.�6D�{�����)��ރ���8�.P�)�9����$��ΆTֆC+�
o�$z���6��݇/�)�F�d�4�	����fň.,�/[�2��/��0�3�2S�3��6����q�-��)�
;�)I�Ps�Čڌ
���� �(�@�V�&\�����
��)�
2�
=�H�=b���=���
�(�E�
T�#_���?��]ҏ0�:K�=��JĐ(��8�$
�P/�����
����	��	����6̒7�
;�
I�(W�����;��	ߓ��	�	�%�4�;�HL�������ŔCޔ?"�9b�	��N��	����	�0�A�!I�!k�������̖���	��	#�-�
6�)A�%k���+��*ɗ-�"�7�L�[�	a�	k�	u�	�	������P˘�(�'>�f�����h�� �4�=�
D�R�f�z���������.��	�4�6"�Y�n���
������՛� �� �=�)W�(��.��5ٜ �80�<i���S���A�T� q�5��(Ȟ��^*���D��ݟ���� $�E�+d�(��(���)��_"�.��f��'�(@�i���<��&آ.��2.�9a�5��9ѣA�>M�C��(Ф���S0�9��4��J�O>�2��.��9�8*�c���(��ħ3ا8�E�Fa�0��1٨�����c0�����E�>�E�Q�w^�֬ެ��+�@�_�t�������ǭ�
����!�>�C�J�Q�X�_�f�m�t�{�����
����	��Ȯͮ�K�:�@�$L�Iq�h��$�$-�R�k�x����
U�`�l�u�~���
����'Ȳ�����7�;�Z�m�}�������ų���@�2W�+��%�� ܴ!��k�����<����"�==�{���q��C�5T���/��ڷ#�)�#;�;_���G�������&�
5�'C�k�{�����������Թ���E�[�0k�%��ºݺ��(�B�a�Ar�#��9ػ�.�%B�h����k���i7���j��,�4�E�e�y���� �0�A�_�l�r�����ȿ�K��
I�W�ci�1�!��0!�qR�O��� ��2��/��#�)B�'l�������������"�(�7�?�+]���(����������'�8�'G�o��������&��F��2@�3s�0�����������
���	'�31�8e���!��&��$��-#�Q�`�p�!|��������������������
�� �	)�33�8g���!��&��$�-%�S�b�!n���	��	��	��������������
�6�P�`�)q�����������'��'�F@�!����
���������
�!�38�l�;y�.��1��W�'n���	��T��		�#�7�K�
^�i�-z�������6����
"�-�L�_�	l�v�����!��9���
�8�:L�#������%��(���	�%�*�/�>�	N�	X�b�h�Um�U������ ����U��-C�q�V����(���*��E��3�R�n� �������������������
�u�36��SP
���Y��������p������e�Q0P�Yu��J�hDEF<�.5,���L(�����6��h����j�~�S-���4J�
�s��z��'q��A��*�=H1�G:c����J���k��d�����L���$�K�$�(������HD����/��C$���O�
�`_b�e��:��xX��B�����)�+N���;
N�$���������������!6s�{�W	���?g�Zj�U7���mU�&���DQkc��f�/81s�#(�|�����4ql�`�(��0�|]��%�`��{�&t�+m[sJE��X�|�	��$��8�F���\�
�hi\/IQ�=4���]��cdm����;RmpO�������ge����,�����d�"|
��<{5S�rc���!n�])��9�+H��~���0Bk��������f��v��@�u��'�����4�����M ���AY���,�q��t�r?��[���/}5DEG��}2����h��d�������?���l�>�:�0U���y� K�����V=���:0�P#���������������. �?RB�2C�YW��[�Z�n�� �^����v�d�b�u��gk���G��-M�����:���:�A���	.�x�����K(��DP���Z,����O��{�24�����h�
^���~��r����f��6���rF���t�+y���*�3pH��89@�)��@R�%�f������Hx/�;q�o-����A�pv?a�bM�I�yZ�,���wM������*q6+�9��]F	Vz��.X
D}������ P}b7-_2&!���>��G|���S�#������]n.e�IzM��|f����������t2l*�k*���6���7���Qw�'-��=�>�b$���(�����TU"#�����z�������*�lC���zK���2X�]T�A��c_P�o�@���3����`iI������~������L�g�������o%������Qer`'Nbi��?@ABC���
Q�	���XM�#�{�'q��39�����F��2 �>��=��O�)��^�W�����,�=aZ^���#��Y[�����V���J�"��E>5a��l����{3���""r�y�18����"Cn��4�����7bV�aT�!�\���x0Us���%��&�@N������'Es�9|�
�&�>E� dC>�m����������2c_����{'��gi���~y
~��/�����j�~?�zFR	�^U��NP�)�Bjo3��@CW��z�.���%�U�wd�����S��o*�@v���5�i�����o��c�w�p�G�N
GG�XQ_��"�!�8�������a���(!&�I�vJKB�J�9�u8�i�8�<��v����YTZA[ZW�%*$_�,������I%�|���������`�O��Z	_�Rw�S��;ex
����+XV��p��f�Pr�Gt���e�����y���m^6.�3���1=n���������V D��r��L�i�,x�u�O�R\����4��[���?�u���;�KH
YN�\L���	�L��c6���Y�-�Dj��nRoO����7T
�&\!��7U)�]�1���p_�&����tv��^����hj �4S���7�����������qt�}"�y%}�jkl�f5pq��������Tb
������
��<�7[���d�+�C1N��n���g#�mkT]T=<�:��V�����;�gl����H�;�t`��SF��zj+R���O:��k.MF~�0�5���e����x���<1�"���-/��{�^�uI����g�oB)9�f!LlW0Hw���-�mw�����������#}�Mn�a)�W<�L�	3J5�K/�`���a������E�h��\i
�'�hwxa����I�;!E�Qs�����y���>$����K��Xs1��v��WA��\�(������8B9��}[�<�V

unknown argument '%s' giving you help instead


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

  Options:
     -h, --help      this help information

     --list-all      list all known operations

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

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

     -i, --file      read xml from named file

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

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

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

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

     -X              output the XML that was read in

     -v, --verbose   print diagnostics while running

All parameters following -- are considered ops to be chained together
into a small composition instead of using an xml file, this allows for
easy testing of filters. After chaining a new op in properties can be set
with property=value pairs as subsequent arguments.
use floating pointvideo bitrate in kb/svideo bitrate maxvideo bitrate minvideo bitrate tolerancevideo device pathvideo-codecweight 0weight 1weight 2weight 3weight 4weight 5weight 6weight 7Project-Id-Version: Gegl-master
Report-Msgid-Bugs-To: https://gitlab.gnome.org/GNOME/gegl/issues
PO-Revision-Date: 2022-07-07 12:18+0100
Last-Translator: Hugo Carvalho <hugokarvalho@hotmail.com>
Language-Team: Português <https://l10n.gnome.org/teams/pt/>
Language: pt
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Plural-Forms: nplurals=2; plural=(n != 1);\n;
X-Generator: Poedit 3.1
X-Project-Style: gnome
X-Language: pt_PT
X-Source-Language: C


parâmetro "%s" desconhecido, a fornecer ajuda


%s não tem %s propriedade, propriedades: %s não tem %s propriedade.(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 significa deteção automática no primeiro fragmento de áudio-1, 8, 16, 32 e 64 são os valores aceites atualmente, -1 significa automático0°180°Desfocagem em caixa 1DDesfocagem gaussiana 1DDesfocagem por ondas 1D270°3x38 e 16 são valores aceites neste momento.90°Um GeglVector representando o caminho do traçoUma aproximação rápida do filtro bilateral, usando uma caixa de filtro em vez de uma desfocagem gaussiana.Um valor alto reduz a aleatoriedade do ruídoUma camada no sentido tradicionalUm GeglBuffer pré-existente onde gravar dados do buffer de entrada.Uma origem retangular de tamanho fixo com uma cor sólidaUm script Lua armazenado no disco que implementa uma operação.ACES RRTDeformação ASAPQuando VERDADEIRO, é realizada a deformação ASAP, senão é realizada a deformação ARAPLimiar superiorAbsolutoColorimetria absolutaTratamento nas margensAcumulação de movimento desfocado usando um filtro Kalman, para usar em sequências de fotogramas de vídeo.Níveis ativosAdaptar uma imagem, que pode ter um alto intervalo dinâmico, para apresentação usando um baixo intervalo dinâmico. Este é um eficiente operador derivado de simples observações fisiológicas, produzindo luminância no intervalo 0,0-1,0Adaptar uma imagem, que pode ter um alto intervalo dinâmico, para apresentação usando um baixo intervalo dinâmico. Este operador atenua as magnitudes de gradientes de imagem locais, produzindo luminância no intervalo 0,0-1,0. Esta abordagem de mapa de tons foi originalmente apresentada por Raanan Fattal na SIGGRAPH 2002, papel: Gradient Domain High Dynamic Range Compression.Adaptar uma imagem, que pode ter um alto intervalo dinâmico, para apresentação usando um baixo intervalo dinâmico. Este operador restringe contrastes em múltiplas frequências espaciais, produzindo luminância no intervalo 0,0-1,0Adaptação à variação de cor por toda a imagemAdaptação à variação de luz por toda a imagemAdicionarAdicionar ruído CIE LchAdicionar ruído HSVAdicionar ruído RGBAdiciona brilho em torno das áreas clarasAdicionar a soma dos valores quadrados à saídaAditivoAdiciona um efeito de reflexos da lente.Ajustar matiz LCH, chroma e luminosidadeAjustar brilho nos cantosAjustar exposição das altas luzesAjustar exposição das sombrasAjustar saturação das altas luzesAjustar saturação das sombrasAjustar o valor do tristimulus X para a saídaAjustar o valor do tristimulus Z para a saídaAjustar o nível pretoAjusta o contraste de uma imagem em tons de cinzento com uma curva que especifica o contraste para a intensidade.Compatível com Adobe RGBAlgoritmoTipo de algoritmoMapa estranhoAlinharAlinhamento de texto multilinha (0 - esquerda, 1 - centro, 2 - direita)Alinha a caixa do retângulo de entrada com a margem do alvo de composição ou margem da caixa delimitadora aux, se o aux pad não estiver conetado, o op tenta descobrir a qual a margem da caixa delimitadora se aplica.Permitir dividir mosaicosPermitir a divisão de mosaicos em margens rígidasAlfaCanal alfaNíveis de alfaO parâmetro alfa dos pesos MLSPercentil de alfaLimiar do alfa para processamento multinívelPonderação alfaSempreFator de iluminação ambienteQuantidadeQuantidade pela qual dimensionar a opacidade de cada imagem transformadaQuanto preservar a margemQuantidade de preservação da margem. Esta quantidade é inversamente proporcional ao desvio padrão da faixa do kernel da desfocagem.Quantidade de distorção de 4ª ordemQuantidade de distorção de 2ª ordemValor a incrementar no brilhoAmplitudeAmplitude para o eixo X (escala logarítmica)Amplitude para o eixo Y (escala logarítmica)Amplitude da ondaUm GeglBuffer já existente para gravar dados do buffer de entrada ou NULL.Um filtro de suavização que preserva as margens implementado com a técnica recursiva “Domain Transform”. Semelhante a um filtro bilateral, mas mais rápido de calcular.Uma mensagem de erro no caso de ocorrer uma falhaUm nó de armazenamento em cache explícito armazena os resultados em cache e deve fornecer recomputação mais rápida se o que é armazenado em cache por ele for exigente computacionalmente, mas não mudar.ÂnguloReforço do ânguloÂngulo da desfocagem em grausÂngulo de visãoDesvio do ângulo para texturasÂngulo a rodar (à esquerda)Operação de suavização anisotrópicaFator de sobreamostragem de anti-aliasAntisserilhamento usando o algoritmo de extrapolação de margens Scale3XAntisserrilhadoProfundidade aparente do efeito de tela renderizada; de 1 (muito plano) até 50 (muito profundo)Altura aparente de cada mosaico (em píxeis)Aplica um gradiente de cor.Aplica uma vinheta a uma imagem. Simula a diminuição da luminosidade nas margens do filme exposto e alguns outros efeitos confusos de contorno que podem ocorrer naturalmente com fotografia analógicaAplicar lenteAplicar uma matriz de convulsão genérica 5x5Aplicar um tom sépia na imagem de entradaAplicar uma transformação recursivamente.Balanço de área entre duas coresSoma aritméticaSoma aritmética covarianteXOR aritméticoXOR aritmético covarianteProporçãoProporção a ser usada, -0.5 = 1:2, 0.0 = 1:1, 0.5 = 2:1, -1.0 = 1:inf 1.0 = inf:1, isto é aplicado após a proporção ser levada em consideração, para usar diretamente o fator de compressão como proporções, aplique a proporção 0.0.Codec de áudioCodec de áudio a utilizar ou automático para utilizar uma predefinição baseada no formato do contentor.AutomáticoCorrigir automaticamente os valores D para modelos de correção de lentes.Auto-corrigir valores dBloco auxiliar de entrada do buffer de imagem.Disponível como uma variável global ‘user_value’ em Lua.MédiaDiâmetro médio de cada mosaico (em píxeis)Diferença média (total)Diferença média (errados)Diferença média entre todos os píxeis.Diferença média entre píxeis errados.Evitar recorte e quantização (mais lento)Ângulo de separação do eixoAzimuteFormato bablBablFormat “%s” não existe.FundoCor de fundoCor de fundoTipo de fundoComprimento do resgateBalançoAjustar bandaBarnsley 1Barnsley 2Barnsley 3BaseExposição de ampliação da baseÍndice de baseBayerMatriz BayerPadrão BayerPadrão Bayer usado, “0” parece funcionar para alguns ficheiros Nikon, “2” para alguns ficheiros Fuji.ComportamentoComportamento da opçãoLimiar inferiorBetaFiltro de caixa bilateralFiltro bilateralBilinearProfundidade de corPíxeis a pretoÂngulo pretoNíveis de pretoPreto sobre brancoPadrão pretoPeríodo pretoCompensação de ponto negroExtrair pretoExplosãoModo de misturaMistura uma cadeia de entradas usando uma máscaraAltura do blocoTamanho do blocoTamanho do bloco de linhas/colunas a desentrelaçarLargura do blocoTamanho do blocoResplandecerAzulMultiplicador do canal azulRuído azulCovariante do ruído azulLimiar do azulÂngulo azul e amareloPadrão azul e amareloPeríodo azul e amareloÂngulo azulModo de aplicação do azulCanal azulContornos azuisFrequência de azulAzul no canal azulAzul no canal verdeAzul no canal vermelhoInversão de azulNíveis de azulPadrão azulPeríodo azulDeslocação da fase azulPré-flash azulMargens nítidas azuisFator para esticar o azulTolerância de azul da cor de entradaGama da desfocagemNíveis de desfocagemDesfocar píxeis vizinhos, mas só em áreas com pouco contrasteDesfocar píxeis numa direção, simula uma câmara em movimento numa linha reta durante a exposição.Raio onde desfocarDesfocar usando a média das cores de uma vizinhança de linha.Desfocar usando a média das cores de uma vizinhança quadrada.Desfocagem resultante do cálculo da cor mediana na vizinhança de cada píxel.Desfoca a imagem à volta de um ponto focadoDesfocar a imagem numa quantidade variável usando uma máscaraTipo de desfocagemFator de desfocagemAumentar a densidade do papel para aproveitar as vantagens da faixa dinâmica aumentada de um monitor em comparação com um papel fotográficoContornoAlinhamento da margemComportamento do contornoAmbosFundoEm baixo à esquerdaEm cima à direitaDesfocagem em caixaDesfocagem em caixaClarearBrilhoContraste de luminosidadeBrilho e deslocação / espessamento dos contornosBufferDepósito do bufferOrigem do bufferLocalização do bufferMapa de relevoMapa de relevo (preservar as cores originais)CIE Lab/LchCIE YuvCMYKCiano CMYKPreto CMYKMagenta CMYKAmarelo CMYKCXCX (sem efeito em Mandelbrot e Sierpinski)CYCY (sem efeito em Mandelbrot e Sierpinski)CacheCalcular uma transformação de distânciaCalcular o valor b a partir da distância focalCâmaraCâmara RGBÂngulo de visão da câmaraCartesianoDesenho animadoFormato de moldagemEspaço de cor fundidaMoldar dados entre input_format e output_format, ambos têm de ter os mesmos bppRuído da célulaCentroCentro XCentro YDeslocamento centralIntervalo de seleção do centro de matiz Centralizar o deslocamento em torno de um ponto especificadoCentrarCentrar os mosaicosAltera a exposição de uma imagem com base na relação focal (número f / f-stop)Alterar a temperatura da cor da imagem, da temperatura de cor original assumida para uma desejada.Alterar para istoAltera o nível e o contraste da luz. Isto opera em luz linear, "contraste" é um fator de escala à volta de 50% cinzento e "brilho" é um desvio constante a aplicar após escalar o contraste.Altera a saturaçãoMisturador de canaisCurva característicaChebyshevXadrezEscolher o meioChromaAjustar chromaAdaptação cromáticaCírculoProfundidade do círculo em percentagemDesfocagem de movimento circularDesfocagem de movimento circularEsticar margemPrender deformaçãoCortar RGBClip base + nevoeiroClip base + nevoeiro para ter um valor de saída de branco puroCortar valores de píxel altosCortar valores de píxel baixosCortar a saída no tamanho da entradaCortar resultado para o tamanho da entradaCortar no tamanho da entradaCortar ao tamanho da entradaÀ direitaClonarClonar um buffer, é o mesmo que “gegl:nop”, mas pode receber tratamento especial para obter referências mais legíveis por humanos em serializações / IU.Tamanho do aglomeradoCorCor 1Cor 2Cor 3Cor 4Cor 5Grelha de assimilação de corMelhoria de corModelo de corSobreposição de corRotação de corTemperatura da corMédia de corCor do texto (predefinido como preto)Modelo de corCor da tinta a utilizar para preencher, use opacidade 0 para desativar o preenchimentoCor da tinta a utilizar para preenchimento.Cor da tinta a utilizar nos traçosCor da tinta a utilizar para traçar.Cor das linhas de grelhaCompressão dependente da saturação da cor do períodoEspaço de corEspaço de cor a ser usado para os dados carregadosCor para alfaCor para o desvanecimento das imagens transformadas, com uma proporção dependendo do seu alfaConversão de cor para tons de cinzento, usa envelopes formados com aproximação STRESS para realizar diferença local de cor, mantendo a geração de tons de cinzento.Cor para picosCor a renderizarCor a utilizar nos modos "Só cor" e "Cor para picos"Cor usada para preencher o fundoDeformação de corCores com uma saturação inferior a esta serão tratadas como cinzentoCombinar exposiçõesCombinar exposições de múltiplas cenas numa imagem de alto intervalo dinâmico.CompacidadeCompara se os buffers de entrada e auxiliar são diferentes. As estatísticas globais são guardadas nas propriedades e é produzida uma imagem de diferença visual como um resultado visual. CompensarCompensar o escurecimentoAleatorizar completamente uma fração de píxeisComplexidadeFator de complexidadeComponenteFrequência do componente 1Deslocação de fase do componente 1Frequência do componente 2Deslocação de fase do componente 2Frequência do componente 3Deslocação de fase do componente 3Cor do separador de componentesComponente a extrairOs componentes da imagem de entrada JPEG 2000 não coincidemOperação de composição a utilizarComposiçãoComprimirComprimir o efeito das sombras / altas luzes e preservar os meios tonsCompressãoAlgoritmo de compressão usado para dados armazenados no swapCalcula um mapeamento de deslocamento relativo de um traçoCalcule a magnitude e/ou direção do gradiente por diferenças centraisCalcular imagem integral e integral quadradaComponentes conetadosFormato do contentorFormato do contentor a utilizar ou automático para deteção baseada na extensão do ficheiro.ContrasteCurva de contrasteReforçar contrasteContraste de passagem altaControlar a quantidade de ruído para cada canal RGB separadamenteControla o número de iteraçõesControla o número de iterações; valores baixos dão resultados menos plásticosConverter formatoConverter uma cor especificada para transparência, funciona melhor com branco.Converter espaço de corConverter imagem de ou para coordenadas polaresConverter os dados para o formato especificadoConverte a imagem em blobs rodados aleatoriamente, parecendo de alguma forma um estilo de pintura cubistaConverter usando compensação de ponto negro.Converte a entrada de um perfil de cor ICC para um formato babl bem definido. Os dados do buffer serão então corretamente geridos pelo GEGL para posterior processamento.Matriz de convoluçãoCoordenadas do centro da lenteCopia a imagem corrigindo a distorção da lente.Copiar bufferEstimativa corrigida da temperatura da fonte de luz em Kelvin.Corrige a distorção de lente do tipo barril ou almofada.Ruído correlacionadoCossenoPara a esquerdaCriar uma imagem (monocromática) em tons de cinzentoCriar um efeito de caleidoscópio.Criar um novo buffer do Gegl para gravar o desenho resultante.Criar uma textura aleatória tipo nuvemCriar uma saída em mosaicosEsta opção só é útil caso a imagem JPEG seja muito grande e se destine a ser apresentada uma página web. Permite ver a imagem progressivamente com cada vez mais qualidade à medida que é descarregada e visualizada num navegador da Internet. Tem o inconveniente de ocupar ligeiramente mais espaço em discoCria um efeito de sombra pendente no buffer de entradaCria um efeito de sombra longaCria uma imagem preenchida com um efeito de plasma.CortarCorta um buffer, se o aux pad estiver conetado, é usada a caixa delimitadora do nó conectado. Quando a área de cultivo está configurada para 0x0 em 0,0 e nada está conectado no aux, é usada a caixa delimitadora do nó na extremidade de produção da cadeia de entrada.Linhas que se cruzamCúbico (qualidade alta, muito lento, bom para aumentos)CubismoCurvaturaCurvaTipo de curvaTipo de curvaCortar imagem em mosaicos de papel e deslizá-losÂngulo cianoFiltro cianoCompensação do filtro ciano para a imagem negativaPadrão cianoPeríodo cianoHumidadeTamanho predefinido de mosaicos nos GeglBuffersPredefinida como 'preto', pode utilizar transparência aqui para apagar partes da imagemGrausDesentrelaçarDesentrelaçar horizontal ou verticalmenteAtraso em ms para o último fotograma descodificadoRemover mosaico com interpolação bimedianaDesmosaico sem interpolaçãoRedução de ruído DCTAlgoritmo de redução de ruído a usar um limiar DCT por correçãoReforço de densidadeProfundidadeProfundidade primeiroDetalheBanda de detalheLargura de banda detalhadaNível de detalheEscala de detalhes, valores negativos diminuem o sinal na banda de detalhes, valores positivos aumentam o sinal.Desvio da perfeição dos mosaicos perfeitosDiamanteDiferença de gaussianosDiferencialPadrões de difraçãoMeio-tom digital com modulações opcionais. DireçãoDireção da fonte de luz (em graus)Direção do efeitoComponente X dos vetores de direçãoComponente Y dos vetores de direçãoPastaDesativar OpenCLBits de discriçãoDeslocarMultiplicador de deslocamento para X ou direção radialMultiplicador de deslocamento para Y ou direção da tangente (graus)Deslocar píxeis como indicado por mapas de deslocamentoDeslocar píxeis numa textura onduladaModo de deslocamentoMultiplicador de deslocamento para o deslocamento angularMultiplicador de deslocamento para a direção horizontalMultiplicador de deslocamento para a direção radialMultiplicador de deslocamento para a direção verticalFator de escala de deslocamento (valores negativos referem-se ao deslocamento inverso)VisualizaçãoMostrar uma cadeia de texto usando Pango e Cairo.Mostrar informação de ajudaMostrar no ecrãMostrar o buffer de entrada numa janela.Mostra o buffer de entrada numa janela SDL (restrito a um processo/operação, devido a problemas de implementação SDL).Mostra o buffer de entrada numa janela SDL2 (restrito a um processo/operação, devido a problemas de implementação do SDL2).Transformação de distânciaDistorcer uma imagem com remoinhos e beliscõesDistorcer cores em quantidades aleatóriasDistorcer a imagem com ondasDistorcidoPontilharMétodo de pontilhadoDittoDivisãoDivisorFaça uma cadeia de operações, com pares de chave=valor depois de cada nome de operação para definir as propriedades. E aux=[ filtro de entrada ] para especificar uma cadeia com uma fonte como algo conetado a um controlador auxiliar.Fazer um lerp, interpolação linear (lerp) entre a entrada e o auxFaz uma projeção estereográfica/em pequeno planeta de uma imagem de entrada equiretangular.Fazer uma transformação usando a transformação de sintaxe SVG.Fazer o mapeamento de renderização do visualizador de panorama ou seu inverso para uma imagem de entrada equirretangular. (Proporção 2: 1 contendo o panorama de 360 x 180 graus).Fazer o mapeamento inverso, útil para retocar o zênite, o nadir ou outras partes do panorama.Multiplicador de subexposição / sobreexposiçãoNão sobreexpôr altas luzesPontosDesenhar um labirintoSombra projetadaNubladoEPITROCHOIDERRO: a opção "%s" esperava um argumento
MargemMargem afetadaDeteção de margemBanda da margemLargura de banda de margemComportamento da margemAlgoritmo de deteção de margemQuantidade de deteção de margemComportamento da deteção de margemDeteção de margem com controlo de espessura de margem, baseado na diferença entre duas desfocagens gaussianasGestão da margemPreservação de margemEscala de margem, valores negativos diminuem o sinal na banda de detalhes, os valores positivos aumentam o sinal.EeeeeekDesvio X do centro do efeitoDesvio Y do centro do efeitoIntensidade do efeitoPara adicionar ou subtrair da máscaraElevaçãoÂngulo de elevação (graus)RelevoTipo de relevoEmular uma pintura a óleoAtivar pré-flashAtiva saída suave dos mosaicos (antiserrilhamento)Cor finalÂngulo final do intervalo de cor destinoÂngulo final do intervalo de cor origemCoordenada x finalCoordenada y finalGravuraMelhorar sombrasMelhora detalhes finos.EpsilonApagar deformaçãoMensagem de erroErro ao ler a linha %d, componente %dTemperatura estimada da fonte de luz (em Kelvin) em que a imagem foi captada.EuclidianoTrocar corTrocar uma cor por outra, definindo opcionalmente um limiar, para converter de um tom para outro.ExpandirExpandir mosaicos neste valorExpoenteBuffer de expoenteExpoente para processamento; controla suavidade - pode ser dimensionado por píxel com um buffer no “pad aux2”.ExposiçãoValores de exposiçãoExpresso como desvio padrão, em píxeisExtrair componenteExtrair um componente de modelo de corCarregador de fotogramas ffmpegGravador de fotograma FFmpegImportador de fotogramas de vídeo ffmpeg.Depósito de saída de vídeo FFmpegFIRFPSCor do desvanecimentoOpacidade do desvanecimentoEsvanecimentoDesvanecimento (comprimento fixo)Desvanecimento (taxa fixa)Linearidade da diminuiçãoMapeamento tonal Fattal et al. 2002Tamanho de recursos para banda de detalhe, usado para remover ruído.Tamanho dos recursos para banda da margem, usado para compensar a perda de margens na passagem de detalhes.FicheiroCaminho do sistema de ficheiros para o perfil da matriz ICC para carregarCor de preenchimentoPreencher caminhoPreencher cada célula com uma cor aleatóriaPreencher toda a área de saídaOpacidade do preenchimentoRegra de preenchimentoRegra de preenchimento.Preenche cada região conetada da entrada, separada do resto da entrada por uma cor fornecida, com uma cor única.FiltroLargura do filtroFinitoPrimeira interaçãoReparar imagens onde falte uma linha ou coluna alternadaDentes de engrenagem fixosInverter XInverter YInverter as coordenadas XInverter as coordenadas YFlutuarFloyd-SteinbergDistância focal da câmaraDesfocagem de focoLimite interno da região de focoRaio externo da região de focoPonto médio de transição de focoFoma Fomabrom CFoma Fomabrom NFoma Fomabrom SFoma Fomabrom SpFoma Fomabrom Variant IIIFamília do tipo de letraFamília do tipo de letra (utf8)Tamanho do tipo de letra em píxeis.IntensidadeForçar mosaicosCor de 1º planoExplorador de fractaisTraço fractalTipo de fractalTipo fracionalTipo fracionalFotogramaNúmero do fotogramaFotogramas por segundo, permite calcular tempo vs. molduraFotogramas / segundoDeDe 0De 1De 2De 3De 4De 5De 6De 7Da corFujicolor Crystal Archive Digital Pearl PaperIntervalo Z totalGráfico GEGLVisualizador gráfico GEGL.Carregador de ficheiros GIFCarregador de imagem GIF.GamaFator gama para espaçamento de nível de misturaFator gama para espaçamento de nível de desfocagemIntervaloDesfocagem gaussianaDistribuição gaussianaOrigem GdkPixbufGdkPixbuf a utilizarCarregador de ficheiros GeglBuffer.Gravador de ficheiros GeglBuffer.Gerar um padrão de matriz BayerGerar um textura sinusoidal linearGerar um mapa normal a partir de um mapa de alturaGerar uma mapa de mosaicosGerar complexas texturas sinusoidaisGerar padrões de difraçãoGerar resultados mais precisos e consistentes (mais lento)Gera um buffer inteiramente preenchido com a cor especificada, usando” gegl:crop” para obter dimensões menores.Gera uma textura de célula.Gera uma textura de ruído sólido.Dado um trimapa esparso fornecido pelo utilizador e uma imagem de entrada, criar um 1º plano alfa mate. Definir branco como selecionado e preto como não selecionado para o trimapa.Dados um trimapa esparso fornecido pelo utilizador e uma imagem de entrada, cria um 1º plano alfa mate. Definir branco como 1º plano e preto como fundo para o trimapa. Tudo o resto será tratado como desconhecido e preenchido.Fator global de saturação de corValor de opacidade global que é sempre usado por cima do buffer auxiliar opcional de entrada.Raio da resplandecênciaIntensidade da resplandecênciaLimiar do brilho da área de resplandecênciaSuavidade das margens da área de resplandecênciaGradienteMapa de gradienteSuavidade do gradienteLimiar do gradiente para realce de detalhesLimiar do gradiente para reduzir o realce dos detalhesModo cinzentoLimiar do cinzentoTons de cinzentoMédia de tons de cinzentoVerdeMultiplicador do canal verdeLimiar do verdeÂngulo verde e magentaTextura verde e magentaPeríodo verde e magentaÂngulo verdeModo de aplicação do verdeCanal verdeContornos verdesVerde no canal verdeFrequência de verdeVerde no canal azulVerde no canal vermelhoInversão de verdeNíveis de verdePadrão verdePeríodo verdeDeslocação da fase verdePré-flash verdeMargens nítidas verdesFator para esticar o verdeTolerância de verde da cor de entradaGrelhaRenderizador de grelhaTamanho da grelhaAlargar áreaRaio da expansãoForma da expansãoCurva de mapeamento / filtro de prova de HDR para SDR que é uma aproximação do ACES RRT (Reference Rendering Transform). Ao alimentar imagens de referência de cena nesta operação, o resultado é adequado para visualização de transformação referida em sRGB ou visualização de saída usando perfis matriciais ICC regulares como ODT. Note que, por enquanto, esta é uma aproximação apenas da luminância do ACES RRT; sem dessaturação de realces e sombras nem alterações de tonalidade vermelha.HSLLuminosidade HSLSaturação HSLSaturação HSVValor HSVPadrão de meio-tom / ponto a ser usadoCurva característica codificada e dados de corDurezaDureza do pincel, 0,0 para um pincel macio, 1,0 para um pincel duroCores de imagens altamente distorcidas por aplicação de funções trigonométricas aos valores de cor do mapa.AlturaMapa de alturaAltura da imagem renderizadaAltura dos blocos, em píxeisAltura das linhas de grelha, em píxeisAltura do buffer geradoAltura do mosaicoHexHexágonosFiltro de passagem altaEntrada altaLimite superiorSaída altaAlta precisãoAlta qualidadeValores altos resultam em mais variação nos detalhesDeteção de margem de alta resolulçãoValores mais altos aumentam a magnitude do efeitoValores mais altos restringem o efeito a menos áreas da imagemNível mais alto de luminância na saídaFator de altas luzesLimiar de altas luzesLimiar de altas luzes (alto)Limiar de altas luzes (baixo)Altas luzesAjustar cor das altas luzesTamanho do histogramaPercentagem de furoHorizontalPanorama horizontal da câmaraDeslocamento horizontalExtensão horizontalA justificação horizontal 0,0 é à esquerda 0,5 centrada e 1,0 à direita.Desvio horizontalDesvio horizontal (da origem) do início da grelhaDesvio horizontal dos blocos em píxeisEscala da textura horizontalPosição horizontalPosição horizontal, em píxeisFator de escala horizontalDesvio horizontal da sombraQuantidade horizontal a inclinarTamanho horizontalProporção do tamanho horizontal de um píxel dentro de cada blocoQuantidade de propagação horizontalTamanho da textura horizontalTradução horizontalLargura horizontal de píxeis de célulaComo as áreas fora da entrada são consideradas ao calcular a distânciaQuão perto estamos das proporções da imagemQuão longe vai a degradação da imagem (vinhetagem) como parte da metade da imagem na diagonalA que distância o orifício está do centro da engrenagem em movimento. 100 significa que o orifício está na margem da engrenagem.Como é aplicado o efeito nas margens da imagem, em que muitas vezes não existem píxeis além destasQuantas tintas usar apenas preto, RG, RGB (aditivo) ou CMYKEspaço em píxeis entre os itensQuanto desvio horizontal deve ser aplicado à colagemQuanta memória utilizar para a cache de imagens (aproximadamente)Quanto de cinza comum deve ser extraído do CMYQuantidade de desvio vertical deve ser aplicado à colagemComo o kernel gaussiano é separadoComo alinhar itens, 0.0 é o início, 0.5 o meio e o 1.0 o final.Como lidar com píxeis fora do buffer de entradaComo determinar o que preencher (não zero|par-ímpar)Como preencher os superpíxeisMatizAjustar matizFrequência do matizDeslocação da fase do matizCentro de seleção de matizLargura da seleção do matizValor de matiz para as definições de cinzento acimaMatiz-chromaCarregador de ficheiros ICCCarregador de perfil ICC.Gravador de ficheiro ICCIIRTítulo do íconeÍcone a utilizar para a janela de saídaSe ativado, o padrão será gerado em mosaicoSe ativado, o padrão estará um pouco mais distorcidoSe quiser o centroIgnorarIgnorado. Utilizar sempre o centro do buffer de entradaIlford Ilfobrom Galerie FB 1Ilford Ilfobrom Galerie FB 2Ilford Ilfobrom Galerie FB 3Ilford Ilfobrom Galerie FB 4Ilford Multigrade IV RC DeluxeAjuste iluminanteIlusãoTipo de ilusãoImagemGradiente de imagemInvólucro Image Magick com opção png.Operação de mistura de imagem “média” (<tt>c = (cA + aB)/2</tt>)Operação de mistura de imagem “misturar-refletir” (<tt>c = cB>=1.0?1.0:cA*cA / (1.0-cB)</tt>)Operação de mistura de imagem “negação” (<tt>c = 1.0 - fabs(1.0-cA-cB)</tt>)Operação de mistura de imagem “sobreexposição suave”” (<tt>c = (cA+cB<1.0)?0.5*cB / (1.0 - cA):1.0-0.5*(1.0 - cA) / cB</tt>)Operação de mistura de imagem “subexposição suave” (<tt>c = (cA+cB<1.0)?0.5*cA / (1.0 - cB):1.0-0.5*(1.0 - cB)/cA</tt>)Operação de mistura de imagem “subtração” (<tt>c = cA+cB-1.0</tt>)Pasta do ficheiro de imagem (subficheiro)Método de reamostragem de imagem a ser usado, para bons resultados com reamostragem dupla ao retocar panoramas, usa o mais próximo para gerar a visualização e cúbico ou melhor para a transformação inversa de volta para panorama.Impacto em cada canal com igual valorAumenta o contraste para papéis com contraste fixo (geralmente papéis coloridos)RGB independenteÍndice de componente sinalizando píxeis não marcadosEtapa do índiceInfinitoRepete infinitamente a imagem de entrada.Buffer de entradaFormato de entradaNível de luminância de entrada para se tornar a saída mais baixaNível de luminância de entrada para se tornar brancoBloco de entrada para o buffer de imagem de entrada.Imagem integralTemperatura pretendidaIntensidadeModo de intensidadeEspaço entre os mosaicos (em píxeis)Interpolar entre a distância Manhatta e euclidiana.Espaço de cor de interpolaçãoGráfico inválido, a abortar.
Transformação inversaInverterInverter mapa de relevoInverter componenteInverter no espaço percetualInverter máscaraInverte os componentes (exceto o alfa) em luz linear, o resultado é a correspondente imagem “negativa”.Inverte os componentes (exceto o alfa) percetualmente, o resultado é a correspondente imagem "negativa".Inverter o componente extraídoInverter a região separadoraInverte só o componente valor, o resultado é a correspondente luminosidade invertida, mantendo a cor.Imagem invertidaIteraçõesCarregador de imagens JPEG 2000Carregador de imagens JPEG 2000 usando jasper.Carregador de ficheiros JPEGGravador de ficheiros JPEGQualidade da compressão JPEG (entre 1 e 100)Carregador de imagens JPEG usando libjpegGravador de imagens JPEG, usando libjpegJXJYCor das juntasJuliaValor X de semente Julia, posiçãoValor Y de semente Julia, posiçãoAlinhamentoSegmentação K-meansEspelhamento caleidoscópicoManterManter valores de píxel RGB dentro de um intervalo específicoManter sinalManter componente azulManter coresManter componente 1Manter componente 2Manter componente 3Manter campos paresManter campos pares ou ímparesManter componente verdeManter componente do matizManter a imagem inalterada onde não for afetada pela lente.Manter componente de luminosidadeManter valores negativos no resultado; quando desativado, é usado o valor absoluto do resultado.Manter campos ímparesManter o ambiente envolvente originalManter componente vermelhoManter componente da saturaçãoLAB ALAB BLAB LLCH C(ab)LCH H(ab)LCMS do perfilPropagação de etiquetas por transformação de bacias hidrográficas. O buffer de saída manterá o formato de entrada. Píxeis não etiquetados são marcados com um determinado valor de sinalização (por padrão: último componente com valor NULL). O buffer auxiliar é uma imagem “Y u8” que representa os níveis de prioridade (menor valor significa maior prioridade). Se aux estiver ausente, todos os píxeis etiquetados terão a mesma prioridade e as etiquetas propagadas terão uma prioridade inferior.LambdaLaplaceDeteção de margens Laplace3x3 grandeZiguezague grandeCamadaInicialEsquerdaComprimentoComprimento da desfocagem, em píxeisLenteDesfocagem de lentesDistorção de lenteReflexos da lenteCentro X da lenteCentro Y da lenteÍndice de refração da lentePermitir que o ponto de origem seja o do meioNível de ênfase nos detalhes de gradiente de imagemNível de suavidadeNível que a transparência total deveria representarNíveisAdaptação à luzÂngulo da luz (graus)Cor da luzDireção da luzFrequência de luz (azul)Frequência de luz (verde)Frequência de luz (vermelho)Clarear sombras e escurecer altas luzesLuminosidadeAjustar luminosidadeFrequência da luminosidadeDeslocação de fase da luminosidadeComo uma desfocagem gaussiana; mas onde a contribuição para cada píxel vizinho é também ponderada pela diferença de cor com o píxel central original.Limitar deformação na área da imagem.Limitar exposiçãoLimitar espessura da linhaLinhaPerfil da linhaAltura da linhaEspessura da linhaLargura da linhaLinear (qualidade média, velocidade média)Gradiente linearDesfocagem de movimento linearRGB linearSinusóide linearRenderizador de gradiente linearMáscara linearSaída linearLinear-prémultiplicadoLinear-prémultiplicado-se-alfaPequeno planetaLoHalo (qualidade alta, para redução pequena)Carregar um ficheiro SVG usando librsvgO carregamento falhouCarregadoRegisto da ponderação de errosRegisto2 dos passos de discrição da origemLogarítmicoBase de espiral logarítmicaSuavização LoglogSombra longaZiguezague longoContinuar na margem opostaEntrada baixaLimite inferiorSaída baixaLimiar inferiorNível mais baixo de luminância na saídaErro LuaPesos MLSAlfa de pesos MLSÂngulo magentaFiltro magentaCompensação do filtro magenta para a imagem negativaPadrão magentaPeríodo magentaMagnitudeMagnitude do contraste, > 1,0 mais claro, < 1,0 mais escuroMagnitude de variações aleatórias de coresPrincipalTornar cinzentoTornar em mosaicos perfeitosFazer um ruído turbulentoTornar o buffer de entrada em mosaicos perfeitos. O algoritmo não tem consciência do conteúdo, pelo que o resultado pode precisar de processamento posterior.FabricanteFaz com que cada componente RGB linear seja o valor absoluto do seu valor, fabs(input_value)Man O WarMandelbrotManhattanMapeamento tonal Mantiuk 2006Mapa absolutoMapa relativoMapear ao contrárioMapear do topoMapear a imagem num círculoMáscaraRaio da máscaraRaio da máscaraBuffer do raio da máscaraOperação matemática “adicionar”, realiza a operação por píxel usando ou a constante fornecida em "valor" ou o correspondente píxel do buffer em aux como operandos. O resultado é a avaliação da expressão resultado = entrada + valorOperação matemática “dividir”, realiza a operação por píxel usando ou a constante fornecida em "valor" ou o correspondente píxel do buffer em aux como operandos. O resultado é a avaliação da expressão resultado = valor==0.0f?0.0f:entrada/valorOperação matemática “gama”, realiza a operação por píxel usando ou a constante fornecida em "valor" ou o correspondente píxel do buffer em aux como operandos. O resultado é a avaliação da expressão resultado = (entrada> = 0.0f? Powf (entrada, valor): -powf (-entrada, valor))Operação matemática “multiplicar”, realiza a operação por píxel usando ou a constante fornecida em "valor" ou o correspondente píxel do buffer em aux como operandos. O resultado é a avaliação da expressão resultado = entrada * valorOperação matemática “subtrair”, realiza a operação por píxel usando ou a constante fornecida em "valor" ou o correspondente píxel do buffer em aux como operandos. O resultado é a avaliação da expressão resultado = entrada - valorMétodo matemático para reconstruir valores de píxeisMate globalLevin mateMáxMáximo de iteraçõesDelta máximoNúmero máximo de pontos de refinação a serem usados para a união de interpolaçãoRaio máximo de desfocagemEscala máxima de pontos de refinação a serem usados para a união de interpolaçãoEnvelope máximoQuantidade máxima de deslocaçãoDelta máximoDiferença máximaDiferença máxima entre dois píxeis.Número máximo de iteraçõesLabirintoTipo de algoritmo de labirintoDesfocagem de curvatura médiaDesfocar medianoMetadadosMétricaMétrica a utilizar para cálculo da distânciaValor médio para picosPonto do meioPonto do meio (relativo)MínEnvelope mínimoRotação de espelhoEspelhosMisturaProporção de mistura, lida como quantidade de aux, 0=entrada 0,5=metade 1,0=auxModoModo de deslocamentoModo da propagação do valorModeloModelo - elemento básico em que operamosModelo alfa aModelo alfa bModelo alfa cModelo alfa dModelo azul aModelo azul bModelo azul cModelo azul dModelo verde aModelo verde bModelo verde cModelo verde dModelo vermelho aModelo vermelho bModelo vermelho cModelo vermelho dErro no carregamento do módulo "%s": %sErro do móduloMisturador monocromáticoMisturador de canal monocromáticoMais preto (valor menor)Mais opacoMais transparenteMais branco (valor maior)MosaicoMosaico é um filtro que transforma uma imagem no que parece ser um mosaico, composto de pequenos originais, cada um com uma cor constante e de um tamanho aproximado.Mover píxeisMover píxeis à volta aleatoriamenteTaxa de movimentoMovendo dentes de engrenagemFator de multiplicação para rotação desejada do espaço local para textura, a forma como isso é calculado torna-o fraco para cores dessaturadas e possivelmente mais forte onde há cor.Carregador de ficheiro multifunções, que usa outros gestores nativos e conversão de recurso usando o conversor Image Magik.Gravador de ficheiros multifunções, que usa outros gestores nativos dependendo da extensão, use as opções específicas de formatos para passar parâmetros adicionais.NULL ou um GeglBuffer contendo os resultados de desenho em cache; este é um buffer especial onde gegl_buffer_list_valid_rectangles devolve a parte da cache que é válida.NomeNativoPróximo de zMais próximo (qualidade baixa, rápido, sem suavização)Câmara escura negativaVizinhançaPercentil de alfa da vizinhançaPercentil de cor da vizinhançaRaio da vizinhança, um valor negativo será calculado com percentis invertidosVizinhança levada em conta, para melhoria, os valores ideais estão mais próximos do lado mais comprido da imagem, aumentar isto aumenta o tempo de execuçãoVizinhança tida em conta, este é o raio em píxeis considerado ao decidir que cores mapear para que valores de cinzentoTipo de vizinhançaDeteção de margem néonNuncaPapel de jornalSem operaçãoSem operação (pode ser usado como ponto de rota)Não existe tal op “%s”NoHalo (qualidade alta, para redução até metade do tamanho ou aumentos)NóRuídoSeleção de ruídoRedução de ruídoDeficiência de ruídoPropagação de ruídoFiltro de desfocagem com redução de ruído e preservação da margem, baseado em vizinhos simetricamente próximosDesvio padrão do ruídoNão linearComponentes não linearesNenhumMapa de normaisComposição normalNormalizarNormalizar saída para o intervalo 0,0 até 1,0.Normalizar a saída para o intervalo [base,base + etapa]Não carregadoGravador de imagens NumPy (Python numérico)Gravador de ficheiro NumPyNúmero de níveis misturadosNúmero de níveis de desfocagemNúmero de aglomeradosNúmero de coresNúmero de cálculos para a média de tons de cinzentoNúmero de contornos (azul)Número de contornos (verde)Número de contornos (vermelho)Número de pontos na curva de amostragem. Usar “0” para cálculo exato.Número de píxeis divergentes.Número de níveis reduzidos a utilizarNúmero de iterações de filtragem. Um valor entre 2 e 4 é geralmente suficiente.Número de fotogramas na animação gifNúmero de fotogramas no vídeo, atualiza no mínimo, quando a primeira moldura é descodificada.Número de intensidadesNúmero de iteraçõesNúmero de iterações, um número mais alto fornece um desenho com menos ruído, mas com um custo computacionalNúmero de iterações, um número mais alto fornece resultados com menos ruído, mas demora mais a processarNúmero de níveis para o canal alfaNúmero de níveis para o canal azulNúmero de níveis para o canal verdeNúmero de níveis para o canal vermelhoNúmero de níveis onde procurar soluçãoNúmero de espelhos a utilizarNúmero de pares; números mais elevados preservam funcionalidades mais precisasNúmero de períodos por bloco, este mosaico evita anomalias de alta frequência que o aumento do ângulo causaNúmero de amostras ao longo de cada eixo por píxelNúmero de amostras cuja média é calculada para antiserrilhar o resultado.Número de amostras a fazer por iteração, procurando o intervalo de coresNúmero de margens nítidas (azul)Número de margens nítidas (verde)Número de margens nítidas (vermelho)Número de picosNúmero de subdivisõesNúmero de dentes na engrenagem fixa.Número de dentes na engrenagem móvel. O raio da engrenagem móvel, em relação ao raio da engrenagem fixa, é determinado pela proporção entre o número de dentes nas engrenagens.Objeto que fornece metadados de imagemObjeto a receber os metadados da imagemObjeto para fornecer metadados de imagemOctógonosDesvioDesvio XDesvio YÂngulo do desvioDesvio para o eixo XDesvio para o eixo YOlearUm de: sRGB, Adobish, Rec2020, ProPhoto, Apple, ACEScg, ACES2065-1Falta um ou mais dos componentes R, G e BUm ou mais dos componentes R, G e B têm dados assinadosSó corOpacidadeOpacidade do traço, note que não se comporta como SVG, uma vez que, de momento, o traço é feito com a ferramenta AerógrafoOpacidade do traço, note que não se comporta como SVG, uma vez que, de momento, o traço é feito usando a ferramenta Aerógrafo.Limiar da opacidadeAbrir buffer GEGLTrabalhar com dados de cor RGB linearizadoOperaçãoOtimizarOrientaçãoPonto de origem para as coordenadas polaresOrigem XOrigem YTemperatura originalRaio de desfocagem fora de focoModo de saídaComposição de saídaFormato de saídaResultado num ficheiroModo de saídaBloco de saída para o buffer de imagem gerado.Brilho geral da imagemSubstituir o espaço de cor especificado, definindo um ponteiro para um formato, substitui a propriedade da cadeia de texto e a definição de um “aux pad” substitui ambos. Descodificador de página PDFCarregador de ficheiros PNGGravador de ficheiros PNGNível de compressão PNG, de 1 a 9Carregador de imagem PNG.Gravador de imagens PNG, usando libpngPPPCarregador de ficheiros PPMGravador de ficheiros PPMCarregador de imagem PPM.Gravador de imagem PPM (gravador de pixmap portátil).Ponto PSSquare (ou euclidiano)AgruparAgrupa uma imagem na horizontal ou vertical uma ao lado da outra com espaço opcional, aux à direita de entrada.PáginaPágina a renderizarPáginasSelecionar pintandoPinta uma sobreposição de cor sobre a entrada, preservando a sua transparência.Pinta cada píxel não semeado com a cor do píxel semeado mais próximo.ParesPaletizarPanoramaProjeção em panoramaMosaico de papelEqualizador de banda paramétrica para sintonizar bandas de frequência de imagem, o op fornece parâmetros de entrada abstraídos que controlam duas diferenças de filtros de passagem de banda acionados por gaussianos usados como ajustes do sinal de imagem.Erro de análise / compilação, se houver.Linha de comando processada:
	modo:       %s
	ficheiro:   %s
	xml:        %s
	resultado:  %s
	resto:      %s
	
Palavra-passePalavra-passe a ser usada para desencriptar PDF ou em branco para nenhumaColar abaixoColar as imagens transformadas uma abaixo da outraTamanho da correçãoCaminhoCaminho do ficheiro GeglBuffer a carregar.Caminho do ficheiro a carregarCaminho do ficheiro a carregar.Caminho do ficheiro a guardar.Caminho do ficheiro de vídeo a carregarCaminho para o dispositivo v4lPadrãoAmplitude da textura (escala logarítmica)Rotação de texturaÂngulo de rotação da texturaPor buffer de píxel para modular o parâmetro expoente, esperando um fator de escala na faixa de 0,0-1,0Por buffer de píxel para modular o raio da máscara, esperando um fator de escala na faixa de 0,0-1,0Percentagem de pretoPercentagem de brancoPercentagem de pretoPercentilPercetualPercetual-prémultiplicadoPercetual-prémultiplicado-se-alfaExecutar o graphcut numa região localCorrigir sombras e altas luzesRealiza uma remoção de mosaicos passando de tons de cinzento a cor, usando interpolação bimediana.Realiza um “demosaicing” ingénuo passando tons de cinzento para cor, sem interpolação.Realiza uma média dos píxeis vizinhos com a distribuição normal como ponderaçãoExecuta a deteção de margens usando um método derivado de gaussianoRealiza uma deformação de imagem ponto-nPeríodoPeríodo (comprimento de onda) da ondaPeríodo para o eixo XPeríodo para o eixo YRuído PerlinGerador de ruído PerlinFase para o eixo XFase para o eixo YDeslocação da faseFotocópiaMistura por partesBeliscarQuantidade do beliscãoPixbufPrototipagem de script de filtro / compositor em nível de píxel com Lua. Consulte http://pippin.gimp.org/image-processing/ para obter mais informações.PixelizarValores de píxel acima deste limite serão definidos como iguais ao limiteValores de píxel abaixo deste limite serão definidos como iguais ao limitePlasmaPonto / píxeis por polegadaPonteiroPonteiro para sinalizar o valor para píxeis não marcadosPolarCoordenadas polaresPolarizaçãoOperação de composição Porter Duff “src-in” (fórmula:   cA * aB)Operação Porter Duff “limpeza” (d = 0.0f)Operação Porter Duff “dst” (d = cB)Operação Porter Duff “dst-atop” (d = cB * aA + cA * (1.0f - aB))Operação Porter Duff “dst-in” (d = cB * aA)Operação Porter Duff “dst-out” (d = cB * (1.0f - aA))Operação Porter Duff “dst-over” (d = cB + cA * (1.0f - aB))Operação sobre Porter Duff (também conhecida como modo normal e src-over) (d = cA + cB * (1 - aA))Operação Porter Duff “src” (d = cA)Operação Porter Duff “src-atop” (d = cA * aB + cB * (1.0f - aA))Operação Porter Duff “src-out” (d = cA * (1.0f - aB))Operação Porter Duff “xor” (d = cA * (1.0f - aB)+ cB * (1.0f - aA))Posição da fonte de luz que ilumina a tela: em cima à direita ou à esquerda e em baixo à esquerda ou à direitaPosterizarPoder usado para esticar a misturaFazer um pré-flash do negativo com luz azul para reduzir o contraste da impressãoFazer um pré-flash do negativo com luz verde para reduzir o contraste da impressãoFazer um pré-flash do negativo com luz vermelha para reduzir o contraste da impressãoPreservar modeloPreservar luminosidadeBússola de PrewittAlgoritmo de PrimMostrar XMLProPhoto RGBProgressivoPropagar certos valores para píxeis vizinhos. Desgasta e dilata qualquer cor ou opacidade.Propagar para o fundoPropagar para a esquerdaPropagar para a direitaPropagar para cimaCanal de propagação alfaTaxa de propagaçãoCanal de propagação de valorPropriedades:ProporçãoPôr a linha de topo no meio e a linha de baixo no exteriorQualidadeRGBRGB azulRGB verdeRGB vermelhoCarregador de ficheiros RGBEGravador de ficheiros RGBECarregador de imagem RGBE (formato Radiance HDR).Gravador de imagem RGBE (formato Radiance HDR).RadialGradiente radialRenderizador de gradiente radialRaioRaio (1,0 é o maior círculo que caiba na imagem e 2,0 percorre tudo até aos cantosRaio 1Raio 2O raio do círculo ao redor do píxel também pode ser dimensionado por píxel por um buffer no “aux pad”.Raio do efeito (em píxeis)Raio da engrenagem fixaRaio de uma região de píxeis da linha (o tamanho será raio * 2 + 1)Raio de uma região de píxeis quadrada (largura e altura serão raio*2+1).Raio de uma região de píxeis quadrada (largura e altura serão raio*2+1).Raio da supernovaRaio da janela de processamentoRaio da desfocagem por ondasAleatórioAleatório covarianteMatiz aleatórioSemente aleatóriaAleatorizar (%)Matiz, saturação e valor aleatórios de forma independentementeLuminosidade, croma e matiz aleatórios de forma independentementeBaralhar píxeis aleatoriamenteTrocar aleatoriamente alguns píxeis com os vizinhosDeslizar píxeis abaixo aleatoriamente (parecido a derreter)PosiçãoProporçãoFormato rawCarregador de imagem raw, envolvendo dcraw em canais, fornece a grelha raw bayer como tons de cinzento. Se o formato de ficheiro for .rawbayer, usa este carregador em vez do carregador normal dcraw. Se o formato do ficheiro for .rawbayerS, troca os números 16 bit devolvidos (o carregador ppm aparenta estar com erros)LerLer/GravarRetânguloTransformação recursivaVermelhoMultiplicador do canal vermelhoRemoção de olhos vermelhosLimiar do vermelhoÂngulo vermelho e cianoPadrão vermelho e cianoPeríodo vermelho e cianoÂngulo vermelhoModo de aplicação do vermelhoCanal vermelhoContornos vermelhosLimiar dos olhos vermelhosFrequência de vermelhoVermelho no canal azulVermelho no canal verdeVermelho no canal vermelhoInversão de vermelhoNíveis de vermelhoPadrão vermelhoPeríodo vermelhoDeslocação da fase vermelhaPré-flash vermelhoMargens nítidas vermelhasFator para esticar o vermelhoTolerância de vermelho da cor de entradaReduz o número de cores numa imagem, reduzindo os níveis por canal (cores e alfa). Podem ser especificados diferentes métodos de pontilhado (dithering) para contrariar a efeito de bandas da quantização.Reduz o número de níveis em cada componente de cor da imagem.ReferênciaEscala de refinaçãoPassos de refinaçãoRefletirReflete uma imagem sobre uma linha, cuja direção é especificada pelo vetor definido pelas propriedades x e y. Refletir a textura na horizontalTamanho das regiõesRegulariza a geometria a uma velocidade proporcional ao valor da curvatura média localMapeamento tonal Reinhard 2005Colorimetria relativaAlteração de brilho relativo nas paragensBrilho relativo de cada exposição em EVIntensidade de desfocagem relativaRemapearRemapeia o intervalo de intensidade da imagemMisturar cores definindo as contribuições relativas das componentes origem.Remover o efeito de olhos vermelhos causado pelo flash das câmaras fotográficasCaminho de desenhoRenderizar espirógrafoRenderizar textoRenderizar uma textura de tabuleiro de xadrezAltura renderizada, em píxeis (só de leitura)Largura renderizada, em píxeis (só de leitura)Intenção de visualizaçãoRenderização de múltiplos sistemas fractais, com opções de cor configuráveis.Tipo de renderizaçãoRenderiza um padrão de espirógrafoDesenha um traço de pincelPreenche uma regiãoDesenha um traço vetorialRenderiza perfis de luminância para componentes vermelho, verde e azul ao longo da linha especificada no buffer de entrada, num buffer do tamanho especificado.RepetirSubstituir um intervalo de cores por outroCor de substituição.Reposiciona o buffer (com precisão subpíxel), se forem passadas coordenadas inteiras é usado um caminho rápido sem reamostragemMétodo de reamostragemRedimensionar tamanho geral da imagemRepor origemResolução em píxeisRotação do resultadoManter possibilidade de dividir em mosaicosDireitaRigidezOndularRobertsRodarRodar no centroRodar o buffer à volta do seu centro, a cuidar de possíveis desvios.Rodar o buffer à volta da origem especificada.RodadoRotaçãoRotação aplicada aos espelhosRotação aplicada ao resultadoÂngulo da desfocagem de rotação. Um ângulo grande pode levar algum tempo a renderizarSuperfície áspera do mosaicoRedondoJanela SDLJanela SDL2Carregador de ficheiros SVGRodar matiz SVGLuminância para alfa SVGMatriz SVGSaturação SVGOperação de mistura SVG “sobreexposição de cor” (<code>if cA * aB + cB * aA <= aA * aB: d = cA * (1 - aB) + cB * (1 - aA) caso contrário: d = (cA == 0 ? 1 : (aA * (cA * aB + cB * aA - aA * aB) / cA) + cA * (1 - aB) + cB * (1 - aA))</code>)Operação de mistura SVG “subexposição de cor” (<code>if cA * aB + cB * aA >= aA * aB: d = aA * aB + cA * (1 - aB) + cB * (1 - aA) caso contrário: d = (cA == aA ? 1 : cB * aA / (aA == 0 ? 1 : 1 - cA / aA)) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG “escurecer” (<code>d = MIN (cA * aB, cB * aA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG “diferença” (<code>d = cA + cB - 2 * (MIN (cA * aB, cB * aA))</code>)Operação de mistura SVG “exclusão” (<code>d = (cA * aB + cB * aA - 2 * cA * cB) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG “luz forte” (<code>if 2 * cA < aA: d = 2 * cA * cB + cA * (1 - aB) + cB * (1 - aA) caso contrário: d = aA * aB - 2 * (aB - cB) * (aA - cA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG “clarear” (<code>d = MAX (cA * aB, cB * aA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG “sobrepor” (<code>if 2 * cB > aB: d = 2 * cA * cB + cA * (1 - aB) + cB * (1 - aA) caso contrário: d = aA * aB - 2 * (aB - cB) * (aA - cA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG “mais” (<code>d = cA + cB</code>)Operação de mistura SVG “crivar” (<code>d = cA + cB - cA * cB</code>)Operação de mistura SVG “luz suave” (<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); caso contrário: d = (aA * cB + (aB == 0 ? 0 : sqrt (cB / aB) * aB - cB) * (2 * cA - aA)) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação SVG de matriz de cor svg_huerotateOperação SVG de matriz de cor svg_luminancetoalphaOperação SVG de matriz de cor svg_matrixOperação SVG de matriz de cor svg_saturateDescrição de estilo SVG da transformaçãoPontos de amostraAmostragemAmostragem usada internamenteAmostrasSaturaçãoAjustar saturaçãoFrequência da saturaçãoDeslocação da fase de saturaçãoValor de saturação para as definições de cinzento acimaGuardarDente de serraNível de limite escalar (ignorado se for fornecido um buffer de entrada auxiliar).EscalaTamanho da escala 1:1Fator de escala para tornar o tamanho do desenho maiorEscala da imagemProporção da escalaTamanho da escalaO tamanho da escala mantém a proporçãoValor de escala para o eixo xValor de escala para o eixo yEscala, intensidade do efeitoAntisserrilhado Scale3XEscala o buffer de acordo com uma proporção.Escala o buffer de acordo com um tamanho.Escala o buffer para um tamanho, mantendo as proporçõesEscala os componentes do buffer para estarem no intervalo 0,0-1,0. Isto melhora imagens que fazem pouco uso dos contrastes disponíveis (imagens com pouco contraste, muito escuras ou muito claras).Escala os componentes do buffer para estarem no intervalo 0,0-1,0. Isto melhora imagens que fazem pouco uso dos contrastes disponíveis (imagens com pouco contraste, muito escuras ou muito claras). Esta versão difere do Contrast AutoStretch por trabalhar no espaço HSV, preservando o matiz.EscalarFator de escala para recursos de imagem no raio, -1 cancela-os, 1.0 melhora a margemFator de escala para a máscara de nitidez, a intensidade do efeitoDispersãoDispersão (velocidade vs qualidade)ScriptSegundo bloco auxiliar de entrada do buffer de imagem.Semear margensSegmentar cores utilizando o aglomerado K-meansSelecionar o n-ésimo ponto mais próximoDesfocagem gaussiana seletivaMatiz-saturação seletivoAjuste seletivo de matiz, saturação e luminosidadeSeparadorSépiaUtilizar “Nativo” se for incerto, os espaços baseados em CIE podem introduzir mudanças no matiz.Definir a quantidade de azul para o canal azulDefinir a quantidade de azul para o canal verdeDefinir a quantidade de azul para o canal vermelhoDefinir a quantidade de verde para o canal azulDefinir a quantidade de verde para o canal verdeDefinir a quantidade de verde para o canal vermelhoDefinir a quantidade de vermelho para o canal azulDefinir a quantidade de vermelho para o canal verdeDefinir a quantidade de vermelho para o canal vermelhoDefine a altura em píxeis de acordo com a qual o texto é justificado verticalmente. Usar -1 para não justificar na vertical.Define a largura a que as linhas longas de texto são quebradas (mudança de linha), em píxeis. Usar -1 para não usar quebras de linha.Vários métodos simples para detetar margensÂngulo da sombraCor da sombraPonto do meio de desvanecimento da sombraPonto do meio de desvanecimento da sombra, como o fator do comprimento da sombraComprimento da sombraSombra menos imagemApenas sombraSombra mais imagemEstilo da sombraSombrasAjustar cor das sombrasSombras / altas luzesFormaAumentar nitidez (máscara de nitidez)Aumentar nitidez da imagem adicionando diferença à imagem desfocada, uma técnica originalmente usada em fotografia analógica.NitidezInclinarInclina o buffer. DeslocarDeslocar XDeslocar YDireção do deslocamentoDeslocar cada linha ou coluna de píxeis num valor aleatórioDeslocar ponto brancoSe o tamanho da saída deve ser cortado ao tamanho da entradaMostrar opções GEGLMostrar controlos iluminantesMostrar controlos pré-flashEncolher áreaSierpinskiAglomerado iterativo linear simplesRuído simplexSimplificar imagem numa matriz de retângulos de cores sólidasSimula uma ampliação de película numa sala escura de revelação de fotografia analógica.Simular uma gravura antigaSimular distorção de cor produzida por uma fotocopiadoraSimula distorção causada por mosaicos de vidro retangularesSimular resplandecência tornando os realces brilhantes intensos e difusosSimular desfocagem de lente fora de focoSimula um desenho animado, semelhante a um desenho a caneta de feltro preta posteriormente sombreado a cor. É obtido melhorando as margens e escurecendo áreas já claramente mais escuras que os seus vizinhosSimula uma imagem criada por relevosSimula a distorção ótica causada por ter uma lente elíptica sobre uma imagemSenoSenoSinusoidalTamanhoTamanho XTamanho YTamanho do lado da regiãoTamanho da margem do quadrado em que a união consisteTamanho das correções usadas para redução de ruídoProporção XProporção YSuavizar por transformação de domínioSuavizar deformaçãoSuavizaçãoFator de suavização de 1 a 100; 0 desativa a suavizaçãoSuavidadeSobelDeteção de margem SobelResplandescênciaSuavidadeRuído sólidoOrigemPerfil da origemCaminho de ficheiro da imagem original (png, jpg, raw, svg, bmp, tif...)Nome do espaçoEspaçamentoExtensão espacialRegularização espacialDesvio padrão espacial do kernel da desfocagem, medido em píxeis.Envelope tipo Spatio Temporal Retinex com amostragem StochasticDeteção de margem especializada dependente da direçãoEsféricoÂngulo de ápice da capa esférica, como uma fração do co-ângulo de visãoEsferizarAranhaRotaçãoÂngulo de rotação à volta do eixo da câmaraEspiralCoordenada X da origem da espiralCoordenada Y da origem da espiralRaio da espiralRenderização da espiralRotação da espiralDireção do redemoinho espiralTipo de espiralEspirógrafoQuadradoTamanho quadradoQuadradosEspremerZiguezagueDesvio padrão (fator de escala espacial)Desvio padrão para o eixo horizontalCor inicialÂngulo inicial do intervalo de cor destinoÂngulo inicial do intervalo de cor origemComeçar pela direita em vez de pela esquerdaCoordenada x inicialCoordenada y inicialDesvio padrãoEtapaParagem 1Paragem 2Paragem 3Paragem 4Paragem 5Armazenar imagem num GdkPixbuf.Armazenar num GdkPixbufArmazena o perfil ICC que seria incorporado se fosse armazenado como uma imagem.IntensidadeIntensidade do efeitoIntensidade do realce local de detalhesIntensidade do feito sépiaEsticar contrasteEsticar contraste HSVEsticar o cromatismo da cor ao máximo intervalo possível, mantendo a matiz e a luminosidade intocados.Cadeia de texto a mostrar (utf8)ListradoTraçoCor do traçoOpacidade do traçoEspessura do traçoEstiloEstilo do efeitoSubdivisõesSubconjuntoSubtrairSuperimpor muitas cópias alteradas da imagem.SupernovaSuperpíxeis baseados na aglomeração “k-means”Superpíxeis baseados na transformação hidrográficaCor dos superpíxeisTamanho dos superpíxeisSuperamostragemSuperconjuntoCaracterísticas do mosaicoRemoinho à direitaRemoinho à esquerdaMudar para a direitaVizinho simétrico mais próximoCarregador de ficheiros TIFFGravador de ficheiro TIFFCarregador de imagens TIFF usando libtiffGravador de imagens TIFF, usando libtiffTaxa de bits do vídeo alvo codificado em kb/sCaminho do ficheiro destino onde gravar o GeglBuffer.Ficheiro alvo e nome do ficheiroCaminho e nome de ficheiro destino, usar "-" para stdoutCaminho e nome do ficheiro de destino, usar "-" para stdout.Desfocar no tempoTestar opção para fazer um mapa 1:1 da entrada para a saída durante a amostragemTextoTexturiza a imagem como se fosse a tela de pintura de um artista.Texturizar a tela de pinturaO Geglbuffer a carregar no canalA quantidade pela qual escalonar os valores de alturaA quantidade de compressão de contrasteO formato “babl” da entradaO formato babl da saídaO formato “babl” do GeglBuffe de saída, NULL para utilizar o formato do buffer de entradaA cor de fundoO cmsHPROFILE correspondente ao perfil ICC para os dados de entrada.A cor em (x1,y1)A cor em (x2,y2)A cor da supernova.A cor a alterar.A cor para fazer transparência.A cor a pintar sobre a entradaA cor a renderizar (predefinida como preto)A componente usada para as coordenadas XA componente usada para as coordenadas YA curva de contraste.O total de bits a calcular em simultâneoA distância para expandir a sombra antes de desfocar; um valor negativo irá contrair a sombraO método de pontilhado (dithering) a utilizarO número f (f-stop) de subexposição / sobreexposição para entrada auxiliar de branco / preto puroA opacidade a utilizar no preenchimentoA opacidade do preenchimento a utilizar.A cor da primeira célulaA cor do primeiro planoO 1º plano contém buracos e/ou várias partes não ligadasO 1º plano não contém partes opacasO 1º plano é demasiado pequeno para utilizarO limite acima do qual as cores permanecem opacas.O limite abaixo do qual as cores se tornam transparentes.A localização onde armazenar o GeglBuffer de saídaO script Lua contendo a implementação desta operação.A diferença máxima de valor em que um píxel deve ser propagadoA diferença mínima de valor para a propagação de um píxelO número de linhas de execução (threads) simultâneas a utilizarO número de iterações de deformaçãoO número de divisõesO número de oitavas de ruído.O número de píxeis numa repetição de um padrão de base na resolução de base.As partes opacas do 1º plano não estão acima do fundo!A orientação para desfocar - horizontal / verticalO pixbuf de saída produzido pelo processo é armazenado nesta propriedadeA qualidade da renderização, um valor entre 0,0 (rápido) e 1,0 (referência)A semente aleatória para picos e matiz aleatórioA semente aleatória para a função de ruídoA ID de referência usada como entrada (para uso em XML).A intenção de visualização a utilizar na conversão.A escala da função de ruídoA cor da segunda célulaA cor da sombra (predefinida como preto)A forma dos píxeisA forma para expandir ou contrair a sombra a entrarA força com a qual propaga um píxel para seus vizinhosA cor de fundo dos mosaicosO valor representa a contribuição do passado para um novo fotograma.A largura do pincel usado para traçar o caminhoA largura do pincel usado para traçar o caminho.Existe um problema na sintaxe ou nos valores das propriedades reconhecidas da aplicação. Mesmo assim as coisas provavelmente vão funcional na sua maioria.Esta desfocagem é usada para o filtro “Decomposição por ondas”, cada pixel é calculado a partir de outro pela transformada HATEsta função simula a degradação de estar num antigo monitor de vídeo RGB de baixa resolução.Este complemento produz um efeito de explosão de supernova. A quantidade de efeito de luz é aproximadamente em proporção a 1/r, onde r é a distância do centro da estrela.Este complemento usa o algoritmo descrito por John Schlag, "Fast Embossing Effects on Raster Image Data" em Graphics GEMS IV (ISBN 0-12-336155-9). Pega num buffer a ser aplicado como mapa de relevo noutro buffer e produz um bonito efeito de relevo.LimiarLimiar altoLimiar baixoLimita a imagem a branco/preto baseado no valor global definido na propriedade valor ou por píxel da entrada auxiliar.MosaicoVidro do mosaicoAltura do mosaicoLargura do mosaicoCor do mosaico baseada na média de píxeisVariação de cor dos mosaicosGeometria do mosaicoAltura do mosaicoPerfeição do mosaicoSaturação do mosaicoTamanho do masaicoEspaçamento dos mosaicosMosaicosEm mosaicoMapa de relevo em mosaicoInclinaçãoTítulo a dar à janela de saídaAtéAté 0Até 1Até 2Até 3Até 4Até 5Até 6Até 7Até à corPara o fundoPara a esquerdaPara polarPara a direitaPara cimaCimoEm cima à esquerdaTopo-direitoTotal de páginas, fornecidas como uma propriedade visual apenas de leituraFinalTransformarTransformar a imagem com os fractaisTransformação da cadeia de caracteres de transformação de sintaxe SVGMatriz de transformação, usando a sintaxe SVG (ou matrizes múltiplas, separadas por ponto-e-vírgula)TraduzirTraduz o superior esquerdo para 0,0.Limiar da transparênciaTransparenteTratar como istoTratar como isto: cores cinzentas acima do intervalo de origem serão tratadas como se tivessem este matiz e esta saturação
Alterar para isto: alterar cores cinzentas para este matiz e esta saturaçãoTriânguloTriângulosAparar XAparar YFator de influência do trimapaTurbulênciaTurbulentoTransforma a imagem em tons de cinza e sobrepõe uma grade sobre-saturada, por meio da assimilação de cores que ocorre no sistema visual humano, para algumas escalas de grelha isto produz a ilusão de que as próprias células da grelha em tons de cinza também têm cor.Transforma a imagem em tons de cinzentoTipoTipo 1Tipo 2Tipo de GeglSampler usado para obter píxeis de entradaTipo de padrão RGB a utilizarTipo de um fractalTipo de ilusãoTipo de mapaURIURI do ficheiro a carregarURI do ficheiro a carregar.URI do ficheiro a carregarURI do ficheiro a carregar.URI da imagem a carregar.Não foi possível converter a imagem para o espaço de cor sRGBNão foi possível criar o perfil de cor de saídaNão foi possível abrir a imagem JPEG 2000Não foi possível ler o ficheiro: %sModo GeglOption desconhecido: %dFormato de JPEG 2000 desconhecidoDespremultiplica um buffer que contém cores pré-multiplicadas (mas de acordo com o formato babl não é).Despremultiplicar alfaCor da região não semeadaFicheiro JPEG 2000 com profundidade de cor %d não suportadoTipo de fractal não suportadoTipo de fractal não suportado: %dFicheiro JPEG 2000 não RGB com %d componentes não suportadoLimiar superiorUtilizar pesos MLSUtilizar uma distribuição gaussiana de ruído; quando desativado é utilizada a distribuição linear de ruídoUtilizar um Geglbuffer existente em memória como origem de imagem.Utilizar um GeglBuffer em disco como origem de dados.Usar valores de máscara linearUtilizar saída linear em vez de gama corrigidaUsar região localUtilizar tabelas Huffman otimizadasUtilizar valores de luminância do píxelUtilizar gama sRGB em vez de linearUsar todo o intervalo [0,1] para codificar as coordenadas ZValor do utilizadorUsa o GdkPixbuf localizado na posição de memória em <em>pixbuf</em>.ValorInversão de valorPropagação do valorValor no fundoValor no topoExpoente do valor (escala logarítmica)Valor do desvioValoresDesfocagem variávelVetorTraço vetorialVerticalPanorama vertical da câmaraDeslocamento verticalExtensão verticalJustificação verticalA justificação vertical 0,0 é 0,5 superior central e 1,0 inferior.Desvio verticalDesvio vertical (da origem) do início da grelhaDesvio vertical dos blocos em píxeisEscala da textura verticalPosição verticalPosição vertical, em píxeisFator de escala verticalDesvio vertical da sombraQuantidade vertical a inclinarTamanho verticalProporção do tamanho vertical de um píxel dentro de cada blocoQuantidade de propagação verticalO alinhamento vertical de texto (0=topo, 1=meio, 2=fundo)Tamanho da textura verticalTradução verticalAltura vertical de píxeis de célulaDegradação de vídeoTamanho de buffer de vídeoCodec de vídeoCodec de vídeo a utilizar ou automático para utilizar uma predefinição baseada no formato do contentor.Origem do fotograma Video4LinuxEntrada Video4Linux, câmaras web, digitalizadores de vídeo (frame grabbers) e dispositivos semelhantes.Origem do fotograma Video4LinuxEntrada Video4Linux2, câmaras web, digitalizadores de vídeo (frame grabbers) e dispositivos semelhantes.VinhetaForma da vinhetaVisualizar a máscara de ajusteDiagrama de VoronoiDeformarDeforma as cores de uma imagem entre cores com fatores de distorção ponderados, pares de cor que são preto ao preto são ignorados ao construir-se o mapa.Nível de águaPíxeis de águaTransformação hidrográficaTipo de ondaOndasCarregador de ficheiros WebPGravador de ficheiros WebPQualidade da compressão WebPCarregador de imagens WebP.Gravador de imagens WebPSigma de distribuição de peso, controlando as contribuições de respostaSigma de pesoMistura ponderadaPondera a opacidade da entrada com os valores da entrada auxiliar e da propriedade de valor global.Qual o modelo de cor usado para a transformaçãoQue forma utilizar para o mosaicoQuando VERDADEIRO, o modelo não será libertadoQuando ativado, também melhora as regiões de sombra - quando desativado, é produzido um resultado mais naturalQuando ativado, os detalhes nas sombras são aumentados em detrimento do ruídoQuando definido, opera em valores com correção de gama em vez de RGB linear - agindo como o antigo filtro de normalização no GIMPOnde o Gegl armazena a sua trocaSe a função soma o resultado à imagem original.Se as margens da imagem também são propagadasSe deve propagar a cor de um píxelSe deve propagar a opacidade de um píxelSe roda o padrão RGB em noventa graus.RemoinhoBeliscão remoinhoÂngulo de remoinho (graus)Píxeis a brancoBranco sobre pretoAjustar ponto brancoRGB de gama ampla (Wide gamut RGB)Listrado largoLarguraLargura da imagem renderizadaLargura do intervalo de seleção de matiz Largura dos blocos, em píxeisLargura das linhas de grelha, em píxeisLargura do buffer geradoLargura do mosaicoVentoEfeito tipo ventoTítulo da janelaAjustar à voltaAjustar alturaAjustar a imagem à volta de uma esferaAjustar entradaAjustar os mosaicos fracionaisLargura de quebra de linhaEscreverEscrever bufferEscreva o nome da câmara corretamenteEscrever dados de entrada na superfície de um buffer GEGL de destino.Escreva o nome do fabricante da lente corretamenteEscreva o modelo da sua lente em letras maiúsculasEscreve dados da imagem num buffer já existentePíxeis erradosXAmplitude XComponente XDesvio XPeríodo XFase XEscala XTamanho XProporção do eixo X para o centro do espelhamentoProporção do eixo X para aparar a extensão do espelhoCoordenada X da origemCoordenada X do centro da texturaCoordenada X do deslocamento do centroCoordenadas X do centro da supernovaCoordenadas X do centro dos reflexos da lenteDeslocamento XMultiplicador XPosição XDeslocação X no espaço fractalInício X do buffer geradoX0X1Valor X1, posiçãoX2Valor X2, posiçãoYAmplitude YComponente YDesvio YPeríodo YFase YEscala YTamanho YProporção do eixo Y para o centro do espelhamentoProporção do eixo Y para aparar a extensão do espelhoCoordenada Y da origemCoordenada Y do centro da texturaCoordenada Y do deslocamento do centroCoordenadas Y do centro da supernovaCoordenadas Y do centro dos reflexos da lenteDeslocamento YPosição YDeslocação Y no espaço fractalInício Y do buffer geradoY'CbCr CbY'CbCr CrY'CbCr Y'Y0Y1Valor Y1, posiçãoY2Valor Y2, posiçãoÂngulo amareloFiltro amareloCompensação do filtro amarelo para a imagem negativaPadrão amareloPeríodo amareloCoordenada Z do plano de recorte próximoMultiplicador ZDesvio ZAmpliaçãoAmpliar o espaço fractalNível de ampliaçãoDesfocagem de movimento por ampliaçãoDesfocagem de movimento por ampliação[op [propriedade=valor] [propriedade=valor]] [[op] [propriedade=valor]um GeglBuffer em disco para abriradicionar-alfaquantidadeáudiotaxa de bits do áudio em kb/staxa de amostragem áudiocodec de áudiocanais_áudiotaxa_amostragem_áudiorecarregamento automático estas vezes por segundo.formato bablmisturar duas imagens usando valores alfa como ponderaçãonão foi possível criar um novo stream Jaspernão foi possível consultar o ficheiro JPEG 2000número de fotograma atual, pode ser alterado para acionar um recarregamento da imagem.falha ao abrir a imagem JPEG 2000 de %sficheiro a carregarsinalizarponto flutuante -1 significa automático, 0 significa inteiro 1 significa flutuante.fotogramanúmero do fotograma a descodificaratraso do fotogramataxa de fotogramasfotogramasqualidade globalvalor global usado se aux não contiver dadosescala de peso globalgluasgop-sizecomo determinar o que preencher (não zero|par-ímpar)i-quant-factori-quant-offsetkeyint-minCarregador de ficheiros librawlista de <number>smax_b_framesmax_qdiffme-subpel-qualityme_rangeredução de ruídonúmero de níveis por componenteop “%s” não encontrado, correspondências parciais: origem xorigem yaltura de saída em píxeis, -1 para a altura da entradalargura de saída em píxeis, -1 para a largura da entradacaminho do ficheiro no qual gravar.carregador de pdfpipelineponteiro para um espaço const * Bablposição do centro simétrico na saídaqblurqcompressqmaxqminregião-alturaregião-larguraregião-xregião-ys RGBsRGBamostra de entrada com um buffer auxiliar que contém coordenadas absolutas de origemamostra de entrada com um buffer auxiliar que contém coordenadas relativas de origemfator de escala de deslocamento, indica a quão grande o deslocamento espacial corresponde um valor de mapeamento relativo de 1,0.limiar de alteração de cenadefine o espaço de cores com os quais os formatos babl subsequentes no pipeline são criados, e o perfil ICC potencialmente incorporado para gerir as cores externamente, definir um ponteiro para um formato substitui a propriedade da cadeia de texto e definir um aux pad substitui ambos. integral quadradaesticar os componentes de píxeis individualmente baseado em envelopes de luminânciadescrição de estilo SVG da transformação.tamanho do mosaico a utilizar.compensação entre a regularidade do superpíxel e a aderência aos limites do objetotrellisdados de caminho não manipulados %s:%s
modo desconhecidouri do ficheiro a carregaruso: %s [opções] <ficheiro | — [op [op] ..]>

  Opções:
     -h, --help      esta informação de ajuda

     --list-all      lista todas as operações conhecidas

     --exists    devolve 0 se as operações existirem

     —info          informações de saída sobre a operação:
                     nome, descrição, detalhes das propriedades.

     -i, --file      ler xml do ficheiro indicado

     -x, --xml       utilizar xml indicado pelo argumento seguinte

     -o, --output    saída da imagem gerada para o arquivo nomeado, tipo
                     baseado na extensão.

     -p              incrementar contadores de fotogramas de vários elementos quando
                     o processamento terminar.

     -s scale, --scale scale  escala as dimensões da saída por este fator.

     -X              mostrar o XML que foi lido

     -v, --verbose   imprimir diagnósticos durante a execução

Todos os parâmetros a seguir a -- são considerados opções a ser encadeadas
numa pequena composição em vez de utilizar um ficheiro xml, o que permite
o teste fácil de filtros. Depois de encadear, uma nova operação nas propriedades
pode ser definida com pares propriedade=valor como argumentos subsequentes.
usar ponto flutuantetaxa de bits do vídeo em kb/staxa de bits vídeo máximataxa de bits vídeo mínimalimiar da taxa de bits de vídeocaminho do dispositivo vídeocodec de vídeopeso 0peso 1peso 2peso 3peso 4peso 5peso 6peso 7