Mini Kabibi Habibi

Current Path : C:/Users/ITO/AppData/Local/Programs/GIMP 2/share/locale/pt_BR/LC_MESSAGES/
Upload File :
Current File : C:/Users/ITO/AppData/Local/Programs/GIMP 2/share/locale/pt_BR/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��������ͫ٫���������!�?̭*�7�S�Y�_�e�k�q�w�}�����������������������ŮˮѮ׮ݮ�9�S#�w�{���������Ư*ʯ��1��i,�1��!Ȱ=�8(�?a�����L��	��"�:�PN����������6�3+�3_�	������˶+�.�;�'C�!k���"�� ʷ#��+/�+[���_���	�$�6�G�JO����r�3��ź
ʺպ��*�@�R�Y�
o�Fz�$����)l�*����	�-�-�G�?`����%F��l����
�*�!<�/^�(����C׿�V(�,�����
��/��,�*��%'�M�^�}����������V���;"�^�,t�8����-���)�*H�4s�(�� ������$�,�;�H�
^�l�����
��
��
����"��������
	�^�
v�����������������
��
��
*�8�G�d�	v���4������3���+�<�H�M�
i�t�������������
�� �4�G�[�r�����
���������� 
�
+�9�CM�}���= �D^�K��,��B�_�p�x������-�3�9�I�X�j�|�����'�����������,%�R�^�f�
k�v�������-����-����*�0�H�P�\�
y�
������O��	��"�+�4�+I�1u�����E��q������k�����	��������������'�/�N�m�u�
����>����
�),�,V� ��"���������r���������������
����������%�E�YU�,�� ��'��%�8=�v�2��
��I����
����3��)�:�?M���I��
�����	����0���
�
#�.�$J�o�$����$����
�2"�#U�y���D����A��1%�FW�+������X��	P�Z�m���A��!��T��S�Ni���0��*�-�-���������=��
�<�3L�����
��3��#��A��*A�l���7����3��1�8�R�d�l�	t�~�
��
��3��
����4��
$�2�A�,I�]v�����/��8�%R�x���M������2�:�K�g�ny�-����8�D�.[�	��$����"��"��
��1�I�8R�B��7��'�.�3C�9w�5��7��V�v�/~�����)�������/�(F�*o���
���������������B��V�@b����Y8��������������)�>�
D�R�f�u��� ����$��h�t���l���"�":�]�)n�
���������&
�	1�,;�*h�������������"�J<�
����d���&
�4�=�nM����,��'�G�c�}� �����������,�%A�Xg�h��)�?1�q���-��&����s)���������:� �-�5�=�T�	k�u��������$���'�7�H�b�h�u�����
�����������=*�h�x�������������������-��
�
���3M+R-~�����!'"Gj)�� ��7lF�#�����"�]�!0"A(d���1�<�
,7GWqw����
��/DYm��
�����
!%GMcs
����
�
�
�
	�
#�
/5C<o���%#?c{�
�������/�(&
1O
B�
&�
�
�
0	MWs�
����O�?;W+����'+%SyB�%��)+KU.�I�u*�=�(�>":a)�<�(@,/m6����;X*v������,/;4k��2��,If�����)�C�_<P�x�rfE�,�L, SM�:���-5GAZ;�1�
/;(O8x ���	*>]fol�CbU����- B \ -u (� "� � � � !
!)!E!T!o!�!?�!�!�!�!""."B"V"v"�":�"!�"h#o#�#�# �#�#�#�#	�#	�#$�$�%�%&
&*&:&A&H&Q&!]&&�&�&�&�&�&�&-'44'i'@}'�'�'�'
�'�'(&(A()_(�(�(�($�(��())�)�)�)�)�)�)*!*(*8*
U*`*o*�*
�*�*�*�*�**�*&+	8+!B+,d+�+�+�+�+�+�+
�+�+
,,&-,T,	],g,z,�,6�,�,�,	�,?�,.;-	j-
t--�-��-].Xe.	�.
�.	�.�.�.
//// >/_/h/y/�/��/��0�1��2��3:v4�4
�4�4�4
�4\�4T5Wm5�5 �5
�56*6C6	b6l6�6�6	�6�64�677)7A7E7V7
j7u7Q}7�7�7�78*8
98
G8
U8
c8
q8
8
�8
�8�8�8�8�8�8�8	99!-9O9
_91j9�9
�9�9�9�9��9�:#�:�:�:��:��;�@<��<n=s=
z=
�=�=�= �=�=K�=�D>�>S?g?�?�?�?;�?�?�?@@
@@1@B@sR@�@�@�@A
AA
-A$8A4]A�A,�A�A�AB&B8B3IB}B�B�B@�B C28CQkC'�C\�CBD]D}wDs�D'iE'�E(�E+�E.F&=FIdFq�F4 GLUGK�G"�G#H&5H\HnH/�H��H#{I*�I&�I
�I�I	JJ-JEJ`J	{JE�J2�J7�J
6K	AKoKK�K;LOL(aL
�L�L�L+�L�L�L�L�LM*MAMSMjM.yM�M��MeN�N�N"�N�N%�NOO2OIO4cO�O	�Ow�O9PAPYPbPKuPJ�PQ	Q	Q&Q=QOQ)RR`|R�RE�R)S/6SfS|S0�S �S!�S�S*TCTbT*jT�T�Tg�Td2U�U�U�U	�U
�U�U#V0&V)WVj�Vf�VKSWD�W*�WX-XFX]X
tX�X�X�X�X
�X�X�XYY�"Y	�Y?�YA�Y6Z=ZYZ8bZ�Z�Z
�Z+�Z+�Z#[@?[+�[5�[;�[f\#�\@�\5�\C ]nd]
�]&�]P^QV^O�^�^	_ _1_C_P_]_Vi_�_�_�_``8`M`
l`z`D�`	�`�`�`	�`�`�`a2,a/_a�a�a�a�aZ�a&b-bi4b�b�b;�bFcF[c�c�c�c
�c�cd"d5d8Id9�d�d0�dI
eTe[egeAe�f�f
�f�f�fg'gDgTgmg�g�g�g�g�g�gh#h:hRhmh�h�h�h �h�h�hi$%i�Ji?$jdjpj�j�jw�j"k@kWSk �k�k)�k)l8lTl-]lN�lB�lm7mVmim.�m/�m�mKnOn#fn�n �n�n��n�o'�o�o��oap%yp�p�p�p�p�p�p�pq
qqM3q3�q�q	�q!�q�q[
rir�r
�r�r�r�r�r
�rs�s�ttuauu{�u�Svrw��w@dxF�x��x,�z3�z)�z+"{,N{{{�{�{�{�{�{�{#�{0|O|V|Le|�|�|.�|�|} }%0}V}t}�}�}'�}(�}?~�Q~+�T;�9��ʀ&׀��:�
@�/N�)~���ā.�	��\"�-�.��1܂.�/=�2m�1��2҃5�t;�[��1�>�
P�(^�L��ԅ���
� �1�9�R�d�j�w������'�
4�
?�J�Dd���E���!�;�X�
g�$r���=��K�0�AK�4��7‰$����1�M�d�i�n�v�	~�	����*��3ۋ�&�%=�c�r�=�	��nj͌�	���
��@%�f�v�����:��B��.9�	h�?r�	����Î!Ȏ��
�"�2�J�\�q�
������	����)ˏ%���.'�,V�(����Đ
ܐ�������� �;�CR�����!��Б���e�x�����������Ғْ����-�	:�/D�1t�����Γ
ޓ��'�G� c�����(��&ߔ&�7-�!e�@��:ȕ�V�l�@r���$Ŗ3�&�E�_�Ux�Η>�%�7�I�[�j���'��,˘,��%�2;�dn�/әJ�&N�'u�����C͚+�4=�0r�3��+כ9�8=�6v�<��)��)�WG�K��"�?�ON�5��,Ԟ6�98�r���&��Ο+�/
�"=�B`�-��3Ѡx�l~�G��3�D�2�9�E�zR�
ͤؤ���6�H�f�|�������ϥ�
����&"�I�N�U�\�c�j�q�x��
������
��
����æȦ
צH�.�7�$C�?h�c��� �:�S�`��q�
�'�	3�	=�G�c�
p�
{�&��������;�����.�>�K�O�l�����ū<�0�)P�$z�#��(ìl�Y�p�4�����A�B�
R�h`�5ɮ(��(�.G�v�!��%��ѯ=�.�C@�������
��
��'��
��#�3�<�W�j�}�@��ױ9�)'�Q�l����%��#۲��@�#Q�9u���˳'�	� �<�VL���Q���P0���������˵�ҵ{�������˶Ѷ��"�=�JU�
����Y��1�$L�(q�o��O
��Z� ݹ2��/1�!a�'��4���
�����)�@�O�^�f�+����$ͻ���!%�G�	Y�c�(y��� ��ռ��&�C-�&q�8��.ѽ��� �-�
<�G�N�	W�.a�9��ʾ�&�#(�!L�n�}���!����ֿٿܿ���	��"�
1�<�C�	L�.V�9�����&��#�!A�c�r�!~���	��	�	�������
��6)�`�p� ������������$��$$�FI�!����
����������"�=4�r�4�-��(��U�'a���	��Y���#
�.�
=�H�P�,a�������6������
��0�C�	P�Z�l�u�!��.������D��F1�x�����%��)���		����/�	B�	L�V�\�Va�U����������P��-#�Q�Ll���(�������������)�@� ^������������������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-09-09 22:42-0300
Last-Translator: Enrico Nicoletto <hiko@duck.com>
Language-Team: Brazilian Portuguese <gnome-pt_br-list@gnome.org>
Language: pt_BR
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Plural-Forms: nplurals=2; plural=(n > 1);
X-Generator: Poedit 3.0.1


argumento "%s" desconhecido, exibindo a ajuda em vez disso


%s não tem propriedade %s, propriedades: %s não tem propriedade %s.(1,1)(1,2)(1,3)(1,4)(1,5)(2,1)(2,2)(2,3)(2,4)(2,5)(3,1)(3,2)(3,3)(3,4)(3,5)(4,1)(4,2)(4,3)(4,4)(4,5)(5,1)(5,2)(5,3)(5,4)(5,5)-1 significa autodetectar no primeiro fragmento de áudio-1, 8, 16, 32 e 64 são os valores atualmente aceitos, -1 significa automaticamente0°180°Caixa de desfoque 1DDesfoque Gaussiano 1DDesfoque de onda 1D270°3x38 e 16 são os valores atualmente aceitos.90°Um GeglVector representando o caminho do contornoUma aproximação rápida de filtro bilateral, usando um filtro de caixa em vez de um desfoque gaussiano.Valores mais altos aumentam a magnitude do efeitoUma camada no sentido tradicionalUm buffer Gegl pré-existente onde escrever dados de entrada.Uma fonte retangular de tamanho fixo com uma cor sólidaUm script lua armazenado em disco implementando uma operação.ACES RRTDeformação ASAPDeformação ASAP é executada quando TRUE; do contrário, deformação ARAPLimiar superiorAbsolutoColorimétrico absolutoPolítica de abismoDesfoque de movimento cumulativo, para uso com sequências de vídeos em frames.Níveis ativosAdapta uma imagem, que pode ter um alto intervalo dinâmico, para apresentação usando um baixo intervalo dinâmico. Este é um operador global eficiente derivado de observações fisiológicas simples, produzindo luminância no intervalo 0.0-1.0Adapta uma imagem, que pode ter um alto intervalo dinâmico, para apresentação usando um baixo intervalo dinâmico. Este operador atenua a magnitude dos degradês das imagens locais produzindo luminância dentro do intervalo 0.0-1.0. Esta abordagem de mapeamento de tons foi originalmente apresentada por Raanan Fatta, no artigo de 2002 na SIGGRAPH: Gradient Domain High Dynamic Range Compression.Adapta uma imagem, que pode ter um alto intervalo dinâmico, para apresentação usando um baixo intervalo dinâmico. Este operador restringe os contrastes em múltiplas frequências espaciais, produzindo luminosidade dentro da faixa de 0.0-1.0Adaptação à variação de cor ao longo da imagemAdaptação à variação de luz ao longo da imagemAdicionarAdicionar ruído CIE LchAdicionar ruído HSVAdicionar ruído RGBAdicionar brilho em torno das áreas clarasAdiciona somas dos valores quadrados à saídaAditivoAdiciona um efeito de clarão de lente.Ajustar Matiz, Croma e Brilho LCHAjustar brilho nos cantosAjusta a exposição dos destaquesAjusta a exposição das sombrasAjustar a saturação dos destaquesAjustar saturação das sombrasAjustar o valor do tristimulo X para saídaAjustar o valor do tristimulo Z para saídaAjusta o nível de pretoAjusta o contraste de uma imagem em escala de cinza com uma curva de contraste por intensidade.Compatível com Adobe RGBAlgoritmoTipo de algoritmoMapeamento alienAlinharAlinhamento para texto de várias linhas (0=Esquerda, 1=Centro, 2=Direita)Alinha a caixa retangular de entrada com borda de composição alvo ou uma borda de caixa delimitada auxiliar, se o pad auxiliar não está conectado o op tentará entender em qual borda de caixa delimitada aplicar.Permitir divisão de ladrilhosPermite a divisão de ladrilhos em bordas difíceisAlfaCanal alfaNíveis de alfaParâmetro alfa dos pesos MLSPercentil de alfaLimiar alfa para processamento multinívelPonderação alfaSempreFator de luz ambienteQuantidadeQuantidade pela qual escalonar a opacidade de cada imagem transformadaQuantidade de preservação da bordaQuantidade de preservação de borda. Esta quantidade é inversamente proporcional ao desvio padrão de faixa do núcleo de desfoque.Quantidade de distorção de quarta ordemQuantidade de distorção de segunda ordemQuantidade de aumento do brilhoAmplitudeAmplitude para o eixo X (escala logarítmica)Amplitude para o eixo Y (escala logarítmica)Amplitude da ondulaçãoUm GeglBuffer existente para escrever dados recebidos, ou NULL.Um filtro de suavização que preserva as bordas, implementado com a técnica recursiva Transformação de Domínio. Similar a um filtro bilateral, mas mais rápido.Uma mensagem de erro em caso de falhaUm modo de memória explícito, guarda resultados e deve dar recálculo mais rápido se o que estiver guardado é caro mas não muda.ÂnguloImpulso em ânguloÂngulo do desfoque em grausÂngulo de visãoMudança no ângulo para padrõesÂngulo para rotacionar (sentido anti-horário)Operação de suavização anisotrópicaFator sobreamostragem antialiasRemove alias usando o algoritmo de extrapolação de bordas Scale3XSuavizaçãoProfundidade aparente do efeito de tela renderizado; de 1 (lixo) a 50 (muito profundo)Altura aparente de cada ladrilho (em pixels)Aplica um degradê de cor.Aplica uma vinheta a uma imagem. Simula a queda de luminância na borda de um filme exposto, e alguns outros efeitos de borda mais indefinidos que podem ocorrer naturalmente com fotografias analógicasAplicar lenteAplica uma matriz de convolução 5x5 genéricaAplica um tom de sépia à imagem de entradaAplica uma transformação recursivamente.Balanço de área entre as duas coresSoma aritméticaCovariante de soma aritméticaXOR aritméticoCovariante de XOR aritméticoTaxa de proporçãoRelação de aspecto para usar, -0.5 = 1:2, 0.0 = 1:1, 0.5 = 2:1, -1.0 = 1:inf 1.0 = inf:1, isto é aplicado após tomadas as proporções na conta, para utilizar diretamente o fator de compressão como proporções, defina proporções para 0.0.Codec de áudioCodec de áudio a usar, ou auto para usar um padrão baseado no formato do contêiner.AutoAutocorrige valores D para modelos de lentes de correção.Autocorrige valores dImagem auxiliar de buffer de pad de entrada.Disponível como a variável global "user_value" no LUA.MédiaDiâmetro médio de cada ladrilho (em pixels)Diferença média (total)Diferença média (incorretos)A média de diferença entre todos pixels.A média de diferença entre dois pixels incorretos.Evita corte e quantização (mais lento)Ângulo de separação dos eixosAzimuteFormato BablO formato Babl “%s” não existe.Plano de fundoCor de fundoCor do plano de fundoTipo de fundoComprimento de resgateBalançoMúsica de faixaBarnsley 1Barnsley 2Barnsley 3BaseExposição da base de ampliaçãoÍndice baseBayerMatriz de BayerPadrão BayerPadrão Bayer usado, 0 parece funcionar com alguns arquivos nikon, 2 com alguns arquivos Fuji.ComportamentoComportamento do opLimiar inferiorBetaFiltro de caixa bilateralFiltro bilateralBilinearProfundidade de bitsPretoÂngulo pretoNível de pretoPreto no brancoPadrão pretoPeríodo pretoCompensação de ponto negroRetirada de pretoExplosãoModo de misturaCombinar uma cadeia de entradas utilizando máscarasAltura de blocoTamanho do blocoTamanho do bloco de linhas/colunas desentrelaçadasLargura de blocoTamanho do blocoDesabrocharAzulMultiplicador do canal azulRuido azulCovariante de ruido azulLimiar azulÂngulo azul e amareloPadrão azul e amareloPeríodo azul e amareloÂngulo azulModo de aplicação azulCanal azulContornos azuisFrequência do azulAzul no canal azulAzul no canal verdeAzul no canal vermelhoInversão azulNíveis de azulPadrão azulPeríodo azulDeslocamento de fase do azulPré-flash azulBordas aguçadas azuisFator de alongamento azulLimiar de azul da cor de entradaDesfocar gamaNíveis de desfoqueDesfoca os pixels vizinhos, mas apenas em áreas de baixo contrasteDesfoca os pixels em uma direção, simula desfoque causado por uma câmera em movimento em linha reta durante a exposição.Raio de desfoqueDesfoque resultante da média das cores de uma linha vizinha.Desfoque resultante da média das cores de uma vizinhança quadrada.Desfoque resultante do cálculo da cor média na vizinhança de cada pixel.Desfocar a imagem em torno de um ponto focalDesfocar a imagem por uma grande variedade utilizando uma máscaraTipo de desfoqueFator de desfoqueAumento de densidade do papel para obter vantagem do aumento de faixa de um monitor comparado para um papel fotográficoBordaAlinhamento de bordaComportamento da bordaAmbosBaixoEsquerda abaixoDireita abaixoDesfoque em caixaCaixa de desfoqueClarearBrilhoContraste de brilhoBrilho e mudança de peso dos contornosBufferLocalização do bufferLocalização do bufferLocalização do bufferMapa de relevoMapa de relevo (preserva as cores originais)CIE Lab/LchCIE YuvCMYKCiano CMYKÍndice CMYKMagenta CMYKAmarelo CMYKCXCX (Nenhum efeito em Mandelbrot e Sierpinski)CYCY (Nenhum efeito em Mandelbrot e Sierpinski)CacheCalcular uma transformação de distânciaCalcula valor b do focoCâmeraCâmera RGBÂngulo de visão da câmeraCartesianoCaricaturaFormato de moldeRealce de espaço de corModela os dados entre input_format e output_format, ambos devem ter o mesmo bppRuído da célulaCentroCentro XCentro YDeslocamento centralCentro de intervalo de seleção de matiz  Centraliza o deslocamento em um ponto específicoCentralizaçãoCentro dos ladrilhosAltera exposição de uma imagem em passos de velocidade do obturadorAlterar a temperatura da cor da imagem, a partir de uma temperatura de cor original suposta para uma intencional.Alterar para istoMuda o nível de luz e o contraste. Esta operação opera em luz linear, 'contraste' é um fator de escala próximo de 50% cinza, e "brilho" é um offset constante para aplicar após o escalonamento do contraste.Altera a saturaçãoMisturador de canaisCurva caracteristicaChebyshevQuadriculadoEscolher centroCromaAjuste de cromaAdaptação cromáticaCírculoProfundidade de círculo em porcentagemDesfoque de movimento circularDesfoque de movimento circularSegurarDeformação de braçadeiraCortar RGBClipe base + névoaBase de clipe + névoa para ter um valor branco puro de saídaCortar valores de pixel altosCortar valores de pixel baixosCortar saída para a extensão de entradaRecortar resultado para o tamanho da entradaCortar para extensão de entradaCortar para a extensão da entradaSentido horárioCloneClona um buffer, é o mesmo que gegl:nop mas pode ter tratamento especial para obter referências mais legíveis por humanos em serializações/UI.Tamanho do grupoCorCor 1Cor 2Cor 3Cor 4Cor 5Assimilação cor do GridRealce de corModelo de coresSobreposição de corRotacionar corTemperatura da corMédia de coresCor do texto (padrão: "black")Modelo de coresCor de tinta para usar para preenchimento, use opacidade 0 para desabilitar preenchimentoCor de pintura para usar para preenchimento.Cor de tinta para usar o riscadoCor de pintura para usar para contorno.Cor das linhas de gradeCompressão do período dependente da saturação de corEspaço de corEspaço de cor para utilizar para dados carregadosCor para alfaCor a esmaecer nas imagens transformadas, com uma taxa dependendo do alfaCor para conversão em escala de cinza, usa envelopes formados com a abordagem STRESS para realizar a diferença de cor local preservando a geração da escala de cinza.Cor nos picosCor para renderizarCor a usar nos modos "Cor única" e "Cor nos picos"Cor usada para preencher o plano de fundoDistorção de corCores com saturação menor que isto serão tratadas como cinzaCombinar exposiçõesCombina exposições de múltiplas cenas em um buffer de faixa dinâmica.CompactaçãoCompara se buffers de entrada e auxiliar são diferentes. Estatísticas globais são salvas nas propriedades e uma imagem de diferença visual é produzida como resultado visual. CompensarCompensa a escuridãoAleatorizar completamente uma fração de pixelsComplexidadeFator de complexidadeComponenteFrequência do componente 1Deslocamento de fase do componente 1Frequência do componente 2Deslocamento de fase do componente 2Frequência do componente 3Deslocamento de fase do componente 3Componente separador de corComponente a extrairComponentes da entrada JPEG 2000 não correspondemOperação de composição para usoComposiçãoCompressãoComprime o efeito nas sombras e destaques e preserva os tons médiosCompressãoAlgoritmo de compressão utilizado para dados armazenados na SWAPCalcula um mapeamento de deslocamento de um riscoComputa magnitude do gradiente e/ou direção por diferenças centraisCalcula integral e imagem integral quadradaComponentes conectadosFormato do contêinerFormato de contêiner a usar, ou auto para autodetectar baseado na extensão do arquivo.ContrasteCurva de contrasteAumento de contrasteContraste de passa-altaControla a quantidade de ruído para cada canal RGB separadamenteControla o número de iteraçõesControla o número de iterações; valores menores geram resultados menos plásticosFormato de conversãoConverte uma cor especificada para transparência. Funciona melhor com branco.Converter espaço de corConverte a imagem para ou de coordenadas polaresConverte o dado para o formato específicoConverte a imagem em bolhas quadradas aleatoriamente rotacionadas, de alguma forma assemelhando-se ao estilo de pintura cubistaConverte usando compensação de ponto negro.Converte a entrada de um perfil de cores ICC para um formato babl bem definido. Os dados do buffer serão então gerenciados corretamente pelo GEGL para processamento posterior.Matriz de convoluçãoCoordenadas do centro da lenteCopia a imagem executando correção da distorção de lente.Copiar bufferEstimativa correta da temperatura da fonte de luz em Kelvin.Corrige distorção de lentes em barril e almofada.Ruído correlatoCossenoAnti-horárioCria uma imagem em escala de cinza (monocromático)Cria um efeito tipo caleidoscópio.Cria um novo buffer GEGL para gravar a renderização resultante.Cria uma textura aleatória tipo uma nuvemCria uma saída em padrãoCria imagens JPEG progressivasCria um efeito de sombra projetada no buffer de entradaCria um efeito de sombra-longaCria uma imagem preenchida por um efeito de plasma.ApararCorta o buffer, se o pad auxiliar é conectado na caixa delimitada de um nó conectado é utilizada. Quando uma área recortada é configurada para 0x0 em 0.0 é nenhuma é conectada no auxiliar, a caixa delimitada do nó no fim de produção de uma cadeia de entrada é utilizada.Linhas ortogonaisCúbicoCubismoCurvaturaCurvaTipo de curvaTipo de curvaCorta a imagem em ladrilhos de papel e os movimentaÂngulo cianoFiltro cianoCompensação de filtro ciano para a imagem negativaPadrão cianoPeríodo cianoUmidadeTamanho padrão dos ladrilhos no GeglBuffersPadrão para "black", você pode usar transparência aqui para apagar porções de uma imagemGrausDesentrelaçarDesentrelaçar horizontalmente ou verticalmenteAtraso em milisegundos para o último frame decodificadoDemosaic com interpolação bimedianaDemosaic sem interpolaçãoRedução de ruído DCTAlgoritmo de redução de ruído a ser usado em um limiar DCT por correção.Aumento de densidadeProfundidadeProfundidade primeiroDetalheDetalhe de faixaDetalhe de largura de bandaNível de detalheDetalhar escala, valores negativos diminuem o sinal em faixa de detalhes, valores positivos aumentam o sinal. Desvio entre ladrilhos formados perfeitamenteDiamanteDiferença de GaussianasDiferencialPadrões de difraçãoMeios-tons digitais com modulação opcional. DireçãoDireção da fonte de luz (em graus)Direção do efeitoComponente X do vetor de direçãoComponente Y do vetor de direçãoDiretórioDesabilitar OpenCLBits de discretizaçãoDeslocarMultiplicador de deslocamento para X ou direção radialMultiplicador de deslocamento para X ou direção tangente (graus)Deslocar pixels como indicado pelo mapa de deslocamentoDeslocar pixels em um padrão ondulanteModo de deslocamentoMultiplicador de deslocamento para o offset angularMultiplicador de deslocamento para a direção horizontalMultiplicador de deslocamento para a direção radialMultiplicador de deslocamento para a direção verticalFator de escala do deslocamento (valores negativos se referem ao deslocamento inverso)MostrarExibe uma string de texto usando pango e cairo.Exibe informação de ajudaExibir na telaMostra o buffer de entrada em uma janela.Exibe o buffer de entrada em uma janela SDL (restringida a uma exibição de operação por processo, devido a questões de implementação do SDL).Exibe o buffer de entrada em uma janela SDL2 (restringida a uma exibição de operação por processo, devido a questões de implementação do SDL2).Transformar distânciaDistorcer uma imagem girando e pinçandoCores distorcidas por amostras randômicasDistorcer a imagem com ondasDestorcidoTremerMétodo de estremecimentoIdemDivisãoDivisorExecuta uma cadeia de operações, com pares chave=valor depois de cada operação para definir propriedades. E aux=[ filtro fonte ] para especificar a cadeia com uma fonte como algo conectado a um pad aux.Faz uma lerp, interpolação linear (lerp) entre a entrada e o auxFaz uma transformação estereográfica/pequeno planeta de uma imagem equirretangular.Faz uma transformação usando a sintaxe de transformação SVG.Faz o mapeamento da renderização ou sua inversa para uma imagem de entrada equirretangular. (razão de 2:1 contendo um panorama de 360x180 graus).Faz o mapeamento inverso, útil para retocar zênite, nadir ou outras partes do panorama.Desviar/queimar multiplicadorNão superexpor pontos altosPontosDesenha um labirintoSombra projetadaEmbaçamentoEPITROCÓIDEERRO: opção "%s" esperava um argumento
BordaBorda afetadaDetecção de bordaFaixa de bordaLargura de banda de bordaComportamento da bordaAlgoritmo de detecção de bordaTamanho da detecção de bordaComportamento da detecção de bordaDetecção de borda com controle da largura da borda, baseada na diferença de dois desfoques gaussianosManipulação da bordaPreservação da bordaEscala de borda, valores negativos diminuem o sinal no detalhe de faixa, valores positivos aumentam o sinal.EeeeeekPosição do centro de efeito em XPosição do centro de efeito em YForça do efeitoSe para adicionar ou subtrair da máscaraElevaçãoÂngulo de elevação (graus)RelevoTipo de relevoEmular uma pintura a óleoHabilitar pré-flashingHabilita saída mais suave de ladrilhoCor finalÂngulo final para a faixa de cor de destinoÂngulo final para a faixa de cor originalFim da coordenada xFim da coordenada yGravarRealçar sombrasAprimora detalhes refinados.EpsilonApagar torçãoMensagem de erroErro ao ler linha %d componente %dTemperatura estimada da fonte de luz em Kelvin em que a imagem foi tirada.EuclideanoCor de trocaTroca uma cor por outra, opcionalmente usando um limiar para converter de uma tonalidade para outra.ExpandirExpandir ladrilhos por esta quantidadeExpoenteBuffer expoenteExponenciação para processamento; controla suavidade - pode ser escalada por pixel com o buffer no pad aux2.ExposiçãoValores de exposiçãoExpressada como um desvio padrão, em pixelsExtrair componenteExtrai um componente de modelo de coresCarregador de quadro FFmpegGravador de quadro FFmpegImportador de quadro FFmpeg.Canal de saída de vídeo FFmpegFIRFPSEsmaecer corOpacidade do esmaecimentoDesfoqueDesvanecimento (tamanho fixo)Desvanecimento (taxa fixa)Queda de linearidadeMapeamento de tons Fattal et al. 2002Tamanho de características para faixa de detalhes, utilizada para remoção de ruídos.Tamanho de recursos para faixa de borda, utilizado para compensar a perda de bordas no passe de detalhe.ArquivoCaminho de sistema de arquivo para perfil matrix ICC a carregarCor de preenchimentoPreencher caminhoPreencher cada célula com uma cor randômicaPreencher totalmente a área de saídaPreencher opacidadePreencher regraRegra de preenchimento.Preenche cada região conectada por uma entrada, separada do resto de entrada por uma dada cor, com uma cor única.FiltroLargura do filtroFinitoPrimeira iteraçãoCorrige imagens onde faltam linhas ou colunas intercaladasDentes de engrenagens corrigidosVirar XVirar YVirar as coordenadas XVirar as coordenadas YFlutuanteFloyd-SteinbergFocal da câmeraFoco de desfoqueFocar região interno ao limiteFocar região fora do raioFocar na transição do ponto médioFoma Fomabrom CFoma Fomabrom NFoma Fomabrom SFoma Fomabrom SpFoma Fomabrom Variant IIIFonteFonte (utf8)Tamanho da fonte em pixels.ForçarForçar ladrilhoCor de frenteExplorador de fractaisTraço fractalTipo de fractalTipo de fraçãoTipo de fraçãoQuadroNúmero de quadrosQuadros por segundo, permite tempo de computação vs quadrosQuadros/segundoA partir deDe 0De 1De 2De 3De 4De 5De 6De 7Da corPapel Fujicolor Crystal Archive Digital PearlFaixa Z totalGráfico GEGLVisualizador gráfico GEGL.Carregador de arquivo GIFCarregador de imagem GIF.GamaFator gama para nível de espaço combinadoFator gama para nível de espaço de desfoqueBrechaDesfoco GaussianoDistribuição GaussianaFonte do GdkPixbufGdkPixbuf para usarCarregador do arquivo GeglBuffer.Gravador do arquivo GeglBuffer.Gera um padrão de matriz de BayerGera um padrão senoide linearGerar um mapa normal de um mapa de alturaGerar um mapa em quadriculadoGera texturas senoides complexasGera padrões de difraçãoGerar saídas mais acuradas e consistentes (mais lento)Gera um buffer inteiramente preenchido com a cor especificada, use gegl:corte para obter dimensões menores.Cria uma textura celular.Gera uma textura de ruído sólido.Dado um tri-map esparso fornecido pelo usuário e uma imagem de entrada, cria-se um primeiro plano alfa embaraçado. Define-se branco como marcado, preto como desmarcado, para o trimap.Dados um tri-map e uma imagem de entrada fornecidos pelo usuário, cria matte alfa no primeiro plano. Defina branco como primeiro plano e preto como plano de fundo para o tri-map. Todo o resto será tratado como desconhecido e será preenchido.Fator de saturação de cor globalValor de opacidade global que é sempre usado no topo do buffer de entrada auxiliar opcional.Raio de brilhoForça de brilhoLimiar de área de brilho luminosaÁrea de brilho com suavidade nas bordasDegradêMapa de degradêSuavidade do degradêLimite de degradê para aprimoramento de detalhesLimite de degradê para diminuir o aprimoramento de detalhesModo cinzaLimiar de cinzaEscala de cinzaMédia de escala de cinzaVerdeMultiplicador do canal verdeLimiar verdeÂngulo verde e magentaPadrão verde e magentaPeríodo verde e magentaÂngulo verdeModo de aplicação verdeCanal verdeContornos verdesVerde no canal verdeFrequência do verdeVerde no canal azulVerde no canal vermelhoInversão verdeNíveis de verdePadrão verdePeríodo verdeDeslocamento de fase do verdePré-flash verdeBordas aguçadas verdesFator de alongamento verdeLimiar de verde da cor de entradaGradeRenderizador de gradeTamanho do gridAumentar áreaAumentar raioAumentar formaFiltro/mapeamento de curva de correção HDR para SDR é uma aproximação do RRT ACES (Referência de Transformação de Renderização). Quando alimentar a imagem de cena-referenciada neste op, o resultado é adequado para mostrar transformações referidas por sRGB ou mostrar a saída utilizando o perfil matric ICC regular como um ODT. Note que para o tempo sendo, este apenas uma aproximação de luminância do RRT ACES; sem desaturação dos pontos altos e sombras sem modificações hue vermelhas também.HSLLuminosidade HSLSaturação HSLSaturação HSVValor HSVPadrão de meios-tons/pontos a usarCurva característica codificada e dados de corDurezaDureza do pincel, 0.0 para um pincel suave, 1.0 para um pincel duroDistorce intensamente as cores de uma imagem aplicando funções trigonométricas aos valores do mapa de cores.AlturaMapa de alturaAltura para imagem renderizadaAltura de bloco em pixelsAltura de linhas de grade em pixelsAltura do buffer geradoAltura do ladrilhoHexHexágonosFiltro passa-altaEntrada altaLimite superiorSaída altaAlta precisãoQualidade altaValores altos dão mais variação aos detalhesDetecção de bordas de alta resoluçãoValores mais altos aumentam a magnitude do efeitoValores mais altos restringem o efeito para menos áreas da imagemMaior nível de luminosidade na saídaFator de ponto altoLimiar de ponto altoLimiar de ponto alto (alto)Limiar de ponto alto (baixo)DestaquesAjuste de cor dos destaquesTamanho do histogramaToda porcentagemHorizontalPosição central horizontalDeslocamento horizontalExtensão horizontalJustificação horizontal 0.0 é deixada para 0.5 centralizada e 1.0 a direita.Deslocamento horizontalDeslocamento horizontal (da origem) para o início da gradeDeslocamento horizontal de blocos em pixeisEscala de padrão horizontalPosição horizontalPosição horizontal em pixelsFator de escala horizontalDeslocamento do sombreamento horizontalQuantidade de cisalhamento horizontalTamanho horizontalA relação horizontal do tamanho de um pixel dentro de cada blocoQuantidade de propagação horizontalTamanho horizontal da texturaTranslação horizontalLargura horizontal das células em pixelsComo áreas fora da entrada são considerados quando calcula-se distânciasQuão perto estamos das proporções da imagemO quão distante a vinheta vai como porção da metade da imagem diagonalQuão longe o buraco é do centro da engrenagem em movimento. 100 significa que o buraco esta na borda da engrenagem.Como as bordas das imagens são manuseadasQuantas tintas usar: somente preto, rg, rgb (aditivo) ou cmykQuantos pixeis de um espaço entre itensQuanto deslocamento horizontal deverá ser aplicado à colagemQuantidade de memória (aproximada) disponível para cacheQual a quantidade de cinza retirar do CMYQuanto deslocamento vertical deverá ser aplicado à colagemComo o núcleo gaussiano é discretizadoComo alinhar itens, 0.0 é o começo, 0.5 é o meio e 1.0 o fim.Como lidar com pixels fora do buffer de entradaComo determinar o que preencher (não nulo|par-ímpar)Como preencher os superpixelsMatizAjuste de matizFrequência do matizDeslocamento de fase do matizCentro de seleção de matizLargura de seleção de matizValor de matiz para ajustes acima do cinzaMatiz-CromaCarregador de arquivo ICCCarregador de perfil ICC.Salvador de perfil ICCIIRTítulo do íconeÍcone a ser utilizado para janela de saídaSe marcado, o padrão gerado será ladrilhávelSe marcado, o padrão será um pouco mais distorcidoSe você quer o centroIgnorarIgnorado. Sempre uso 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 de iluminaçãoIlusãoTipo de ilusãoImagemDegradê de imagemWrapper do Image Magick usando a op. png.Operação de mistura de imagem "médio" (<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 "queimadura-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 "rodeo-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 "subtrativa" (<tt>c = cA+cB-1.0</tt>)Diretório do arquivo de imagem (subarquivo)Método de reamostragem de imagem, para bons resultados com reamostragem dupla ao retocar panoramas use o mais próximo para gerar a vista e cúbico ou melhor para a transformação inversa de volta ao panorama.Impacta em cada canal com a mesma quantidadeIncremento de contraste para papéis com contraste fixo (usualmente cor de papéis)RGB independenteÍndice de um componente sinalizando pixeis não-rotuladosÍndice de passoInfinitoRepete de forma infinita a imagem de entrada.Buffer de entradaFormato de entradaEntre com o nível de luminosidade que se tornará a menor saídaEntre com o nível de luminosidade que se tornará o brancoPad de entrada, para entrada de buffer de imagem.Imagem integralTemperatura previstaIntensidadeModo de intensidadeEspaçamento entre ladrilhos (em pixels)Interpolação entre distâncias Manhattan e Euclideana.Interpolação de espaço de corGráfico inválido, anulando.
Transformação inversaInverterInverter mapa de relevoInverter componenteInverter no espaço PerceptivoInverter máscaraInverte os componentes (exceto alfa) em luz linear, o resultado é a imagem "negativa" correspondente.Inverte os componentes (exceto alfa) de forma perceptiva, o resultado é a imagem "negativa" correspondente.Inverte o componente extraídoInverter o separador de regiãoInverte o componente do valor, o resultado tem o brilho invertido mas mantendo a cor.Imagem invertidaIteraçõesCarregador de imagem JPEG 2000Carregador de imagem JPEG 2000 usando Jasper.Carregador de imagem JPEGGravador de arquivo JPEGQualidade de compressão JPEG (entre 1 e 100)Carregador de imagem JPEG usando libjpegGrava arquivo JPEG, usando libjpegJXJYCor das junçõesJuliaSemente Júlia X, posiçãoSemente Júlia Y, posiçãoJustificaçãoSegmentação de médias-KEspelhamento CaleidoscópicoManterManter os valores de pixel RBG dentro de uma faixa especificadaManter o sinalManter componente azulManter coresManter componente 1Manter componente 2Manter componente 3Manter campos paresManter campos pares ou ímparesManter componente verdeManter componente do matizMantém a imagem inalterada, onde não afetada pela lente.Manter componente da luminosidadeMantém resultados negativos no resultado; quando desligado, o valor absoluto do resultado é utilizado.Manter campos ímparesManter ambiente originalManter componente vermelhoManter componente da saturaçãoA LABB LABL LABC(ab) LCHH(ab) LCHLCMS do perfilPropagação de etiquetas por uma transformação de bacia hidrográfica. O buffer de saída manterá o formato de entrada. Pixeis não rotulados são marcados com uma valor de etiqueta dado (por padrão: o último componente com valor NULL). O buffer auxiliar é uma imagem "u8 Y" representando os níveis de prioridade (valor baixo é prioridade alta). Se o auxiliar é ausente, todos os pixeis etiquetados tem a mesma prioridade e etiquetas propagadas tem uma prioridade baixa.LambdaLaplaceDetecção de borda de Laplace3x3 grandeNíveis grandesCamadaFrenteEsquerdaComprimentoComprimento do desfoque em pixelsLenteDesfoque de lenteDistorção de lenteClarão de lenteX do centro da lenteY do centro da lenteÍndice de refração da lenteDeixe o ponto de origem ser o ponto do centroNível de ênfase nos detalhes do degradê da imagemNível de suavidadeNível pelo qual a transparência completa deve ser representadaNíveisAdaptação de luzÂngulo de luz (graus)Cor da luzDireção da luzFrequência da luz (azul)Frequência da luz (verde)Frequência da luz (vermelho)Alivia as sombras e reforça os destaquesLuminosidadeAjuste de luminosidadeFrequência da luminosidadeDeslocamento de fase da luminosidadeComo um desfoque gaussiano; mas no qual a contribuição de cada pixel vizinho é ponderada pela diferença de cor com o pixel central original.Limita a deformação à área da imagem.Limite de exposiçãoLargura da linha limiteLinhaPerfil de linhaAltura da linhaEspessura de linhaLargura da linhaLinearDegradê linearDesfoque de movimento linearRGB linearSenoide linearRenderizador de degradê linearMáscara linearSaída linearLinear-prémultiplicadoLinear-premultiplicado-se-alfaPequeno planetaLoHaloCarregar um arquivo SVG utilizando librsvgFalha ao carregarCarregadoLogaritmo de ponderação de erroLog2 dos passos de discretização da origemLogarítmicoBase logarítmica da espiralSuavização loglogSombra longaNíveis longosLaçoEntrada baixaLimite inferiorEntrada baixaLimiar inferiorMenor nível de luminosidade na saídaErro LUAPesos MLSAlfa dos pesos MLSÂngulo magentaFiltro magentaCompensação de filtro magenta para a imagem negativaPadrão magentaPeríodo magentaMagnitudeMagnitude da escala de contraste >1.0 esclarecer <1.0 escurecerMagnitude das variações aleatórias de coresPrincipalAcinzentarCriar padrão sem emendaCria um ruído turbulentoTransforma a entrada do buffer em um padrão sem emenda. O algoritmo não possui reconhecimento de conteúdo, por isso o resultado poderá precisar de pós-processamento.CriadorFaz com que cada componente RGB linear seja o absoluto de seu valor, fabs(valor_entrada)Man O WarMandelbrotManhattanMapeamento de tons Mantiuk 2006Mapear absolutoMapear relativoMapear para trásMapear do topoMapear a imagem para um círculoMáscaraRaio da máscaraRaio da máscaraBuffer de raio da máscaraOperação matemática de soma, executa a operação por pixel, usando a constante fornecida em "valor" ou o pixel correspondente do buffer aux como operandos. O a saída é o resultado da operação resultado = entrada + valorOperação matemática de divisão, executa a operação por pixel, usando a constante fornecida em "valor" ou o pixel correspondente do buffer aux como operandos. O a saída é o resultado da operação resultado = (valor==0.0f?0.0f:entrada/valor)Operação matemática gama, executa a operação por pixel, usando a constante fornecida em 'valor' ou o pixel correspondente do buffer no aux como operandos. O resultado é a evaluação do resultado da expressão = (entrada >= 0.0f ? powf (entrada, valor) : -powf (-entrada, valor))Operação matemática de multiplicação, executa a operação por pixel, usando a constante fornecida em "valor" ou o pixel correspondente do buffer aux como operandos. O a saída é o resultado da operação resultado = entrada*valorOperação matemática de subtração, executa a operação por pixel, usando a constante fornecida em "valor" ou o pixel correspondente do buffer aux como operandos. O a saída é o resultado da operação resultado = entrada-valorMétodo matemático para reconstruir os valores dos pixelsMatting GlobalMatting LevinMaxMáximo de iteraçõesDelta máximoQuantidade máxima de pontos de refinamento para serem usados para a malha de interpolaçãoRaio de desfoque máximoScala máxima de pontos de refinamento para serem usados para a malha de interpolaçãoEnvelope máximoQuantidade máxima para deslocarDelta máximoDiferença máximaO máximo de diferença entre dois pixels.Número máximo de iteraçõesLabirintoTipo de algoritmo de labirintoDesfoque de curvatura médiaDesfoque médioMetadadosMétricaMétrica a ser utilizada para cálculo de distânciaValor do meio para os picosPonto médioPonto médio (relativo)MinEnvelope mínimoRotação espelhadaReflexõesMisturaProporção de mistura, lido como quantidade de aux, 0=entrada 0.5=metade 1.0=auxModoModo de deslocamentoModo de propagação de valorModeloModelo - elemento básico no qual 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 ao carregar módulo "%s": %sErro de móduloMixer MonoMisturador de canal monocromático monocromáticaMais preto (valor menor)Mais opacoMais transparenteMais branco (valor maior)MosaicoO Mosaico é um filtro que transforma uma imagem naquilo que parece ser um mosaico, composto de pequenos primitivos, cada qual de cor constante e de tamanho aproximado.Mover pixelsMove pixels ao redor aleatoriamenteTava de movimentoMovendo dentes de engrenagensFator multiplicativo para a rotação desejada do espaço local para a textura, a maneira como isto é calculado fica fraca para cores dessaturadas e possivelmente mais forte onde há cor.Carregador de arquivo multi-funções, que usa outros manipuladores nativos, e retorna a conversão usando o conversor Image Magick.Carregador de arquivo multi-funções, que usa outros manipuladores nativos, e retorna a conversão usando o conversor Image Magick.NULL ou um GeglBuffer contendo os resultados da renderização, este é um buffer especial onde gegl_buffer_valid_rectangles retorna a parte da memória que é válida.NomeNativoZ-próximoMais próximoCâmara escura negativaVizinhançaPercentil do alfa da vizinhançaPercentil de cor da vizinhançaRaio vizinho, um valor negativo será calculado com porcentagens invertidasVizinhança levada em conta, para o realce os valores ideais estão perto do maior lado da imagem, aumentar isto aumenta o tempo de execuçãoVizinhança levada em conta, este é o raio em pixels levado em conta ao decidir quais cores mapear para quais valores de cinzaTipo de vizinhançaDetecção de bordas NeonNuncaPapel de jornalSem operaçãoSem operação (pode ser usada como um ponto de roteamento)Não há op chamada "%s"NoHaloNóRuídoEscolher ruídoRedução de ruídoRuído escorridoFaixa de ruídoFiltro de desfoque com redução de ruído e preservação de borda baseado nos vizinhos simétricos mais próximosDesvio padrão de ruídosNão-linearComponentes não linearesNenhumMapa normalComposição normalNormalizarNormalizar a saída entre 0.0 e 1.0.Normalizar a saída para a faixa [base, base + step]Não carregadoGravador de imagens NumPy (Numerical Python)Gravador de arquivo NumPyNúmero de níveis de amostrasNúmero de níveis de desfoqueNúmero de gruposNúmero de coresNúmero de cálculos para média de escala de cinzaNúmero de contornos (azul)Número de contornos (verde)Número de contornos (vermelho)Número de pontos de amostragem da curva. 0 para cálculo exato.Quantidade de pixels diferentes.Número de níveis de amostras reduzidas para usarNúmero de iterações de filtro. Um valor entre 2 e 4 é normalmente suficiente.Número de frames em uma animação gifNúmero de quadros no vídeo, atualiza pelo menos quando o primeiro quadro for decodificado.Quantidade de intensidadesQuantidade de iteraçõesNúmero de iterações, um número maior de iterações fornece uma menor renderização de ruídos em um custo computacionalNúmero de iterações, um maior número de iterações fornece resultados menos ruidosos, a um custo computacionalQuantidade de níveis para o canal alfaQuantidade de níveis para o canal azulQuantidade de níveis para o canal verdeQuantidade de níveis para o canal vermelhoNúmero de níveis para executar a resoluçãoQuantidade de reflexões para utilizarNúmero de pares; números maiores preservam características mais agudasNúmero de períodos por unidade, este arranjo evita anomalia de alta frequência causada pelo impulso em ânguloNúmero de amostras ao longo de cada eixo, por pixelNúmero de amostras que são em média para anti-serrilhamento do resultado.Número de amostras a fazer por iteração ao procurar o intervalo de coresNúmero de bordas aguçadas (azul)Número de bordas aguçadas (verde)Número de bordas aguçadas (vermelho)Número de fachosNúmero de subdivisõesQuantidade de dentes no equipamento consertado.Número de dentes na engrenagem em movimento. Raio da engrenagem de movimento, relativo ao raio da engrenagem corrigida, é determinada por uma proporção entre o número de dentes na engrenagem.Objeto provendo metadados de imagemObjeto para receber os metadados de imagemObjeto para suprir metadados de imagemOctágonosDeslocamentoDeslocamento em XDeslocamento em YÂngulo de deslocamentoDeslocamento para o eixo XDeslocamento para o eixo YOleificarUm deles: sRGB, Adobish, Rec2020, ProPhoto, Apple, ACEScg, ACES2065-1Um ou mais dos componentes R, G, B estão faltandoUm ou mais dos componentes R, G, B têm dados assinadosCor únicaOpacidadeOpacidade do risco, note, não se comporta como SVG pois no momento do risco é usada uma ferramenta aerógrafaOpacidade do contorno, note, não comporta-se como SVG já que no momento o contorno é feito usando uma ferramenta aerógrafa.Limiar de opacidadeAbrir buffer GEGLOpera em dados de cores RGB linearizadosOperaçãoOtimizaOrientaçãoPonto de origem para as coordenadas polaresX-OrigemY-OrigemTemperatura originalRaio de desfoque fora de focoModo de saídaComposição de saídaFormato de saídaSaída para um arquivoModo de saídaPad de saída para um buffer de imagem gerado.Brilho geral da imagemSobrescreve o espaço de cor especifico definindo um ponteiro para uma propriedade de string formatada sobrescrita e definindo um pad auxiliar que sobrescreve ambos.Decodificador de página PDFCarregador de imagem PNGGravador de imagem PNGNível de compressão PNG de 1 a 9Carregador de imagem PNG.Gravador de imagem PNG, usando libpngPPICarregador de imagem PPMGravador de imagem PPMCarregador de imagem PPM.Gravador de imagens PPM (gravador pixmap portátil.)Ponto PSSquare (ou Euclidiano)EmpacotarEmpacotar um imagem horizontalmente ou verticalmente próxima entre si com brecha opcional, auxiliar direito e entrada.PáginaPágina para renderizarPáginasSelecionar pinturaPinta uma sobreposição de cor na entrada, preservando sua transparência.Pinta cada pixel não-semeado com a cor de um pixel semeado mais próximo.ParesPaletizarPosiçãoProjeção do panoramaLadrilho de papelEqualizador de faixa paramétrica para tunar faixas de frequências de imagem, o op provém parâmetros de entradas abstratas que controlam duas diferenças de faixas guiadas por gaussianos passam filtros utilizados como aprimoramentos de um sinal de imagem.Erro de análise/compilação, se houver.Linha de comando analisada:
	modo:    %s
	arquivo: %s
	xml:     %s
	saída:   %s
	resto:   %s
	
SenhaSenha para utilizar para decodificação de PDF, ou vazio para nenhumColar abaixoColar imagens transformadas abaixo uma da outraTamanho da correçãoCaminhoCaminho do arquivo GeglBuffer para carregamento.Caminho do arquivo para carregarCaminho do arquivo para carregar.Caminho do arquivo para salvar.Caminho do arquivo de vídeo para carregarCaminho para o dispositivo v4lPadrãoAmplitude do padrão (escala logarítmica)Rotação do padrãoÂngulo de rotação do padrãoBuffer por pixel para modularizar o paramento exponente, esperando o fator de escala no alcance 0.0-1.0Buffer por pixel para modularizar a máscara do raio, esperando o fator de escala no alcance 0.0-1.0Percentagem negroPercentagem brancoPorcentagem de negroPercentilPerceptivoPercentual-prémultiplicadoPercentual-prémultiplicado-se-alfaPerformar corte de gráfico em uma região localExecuta correção de sombras e destaquesExecuta uma remoção do mosaico de escala de cinza para cor de uma imagem, usando interpolação mediana.Executa uma remoção do mosaico de escala de cinza escuro para cor de uma imagem, sem interpolação.Executa uma média de pixels vizinhos com a distribuição normal como pesoExecuta a detecção de borda usando um método Gaussiano derivativoExecuta deformação de imagem de n-pontosPeríodoPeríodo (comprimento de onda) da ondulaçãoPeríodo para o eixo XPeríodo para o eixo YRuído PerlinGeração de ruído PerlinFase para o eixo XFase para o eixo YDeslocamento de faseFotocópiaCombinação por partesPinçaQuantidade de marteladasPixbufPrototipação de script filtro/compositor de nível de pixel com LUA. Ver http://pippin.gimp.org/image-processing/ para mais detalhes.PixelizarValores de pixel acima deste valor serão normalizados para eleValores de pixel abaixo deste limite serão normalizados para elePlasmaPonteiro/Pixel por polegadaPonteiroPonteiro para sinalizar valores de pixeis não-rotuladosPolarCoordenadas polaresPolarizaçãoOperação Porter Duff src-in (d = cA * aB)Operação Porter Duff de Limpar (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: direita acima, esquerda acima, esquerda abaixo ou direita abaixoPosterizarPotência usada para esticar a misturaPré-flash o negativo de uma luz azul para reduzir o contraste de uma impressãoPré-flash o negativo de uma luz verde para reduzir o contraste de uma impressãoPré-flash o negativo com luz vermelha para reduzir contraste de uma impressãoPreservar modeloPreservar luminosidadeBússola PrewittAlgoritmo de PrimImprimir XMLRGB ProPhotoProgressivoPropaga certos valores para pixels vizinhos. Erode e dilata qualquer cor ou opacidade.Propagar para baixoPropagar para a esquerdaPropagar para a direitaPropagar para o topoCanal do alfa de propagaçãoTaxa de propagaçãoCanal do valor de propagaçãoPropriedades:ProporçãoColocar a linha do topo no centro e a linha de baixo no lado de foraQualidadeRGBAzul RGBVerde RGBVermelho RGBCarregador de imagem RGBEGravador de imagens RGBECarregador de imagens RGBE (formato Radiance HDR).Gravador de imagens RGBE (formato Radiance HDR)RadialDegradê radialRenderizador de degradê radialRaioRaio (1.0 é o maior círculo que cabe na imagem, e 2.0 vai todo o caminho até os cantos)Raio 1Raio 2Raio de um círculo em torno do pixel, pode também ser escalado por pixel por um buffer no pad auxiliar.Raio de efeito (em pixels)Raio do equipamento consertadoRaio da região quadrada de pixeis (tamanho será raio*2+1)Raio da região quadrada de pixels (largura e altura serão raio*2 +1)Raio da região quadrada de pixels (largura e altura serão raio*2+1).Raio da supernovaRaio da janela de processamentoRaio do desfoque de ondaAleatórioCovariante de aleatórioMatiz aleatórioSemente aleatóriaAleatorização (%)Aleatorizar matiz, saturação e valor independentementeAleatorizar luminosidade, croma e matiz independentementeTrocar pixels randomicamenteTrocar aleatoriamente alguns pixels com vizinhosDeslizar aleatoriamente alguns pixels para baixo (similar a derretimento)NívelProporçãoFormato não processadoCarregador de imagem bruta, envolve tubos dcraw, fornece o grid de bayer bruto como escala de cinza, se o formato do arquivo é .rawbayer usará o carregador em vez do carregador dcraw normal, se o formato do arquivo é .rawbayerS trocará os números de 16 bits retornados (o carregador pnm está aparentemente com bugs)LeituraLeitura/EscritaRetânguloTransformação recursivaVermelhoMultiplicador do canal vermelhoRemoção de olhos vermelhosLimiar vermelhoÂngulo vermelho e cianoPadrão vermelho e cianoPeríodo vermelho e cianoÂngulo vermelhoModo de aplicação vermelhaCanal vermelhoContornos vermelhosLimiar de olhos vermelhosFrequência do vermelhoVermelho no canal azulVermelho no canal verdeVermelho no canal vermelhoInversão vermelhaNíveis de vermelhoPadrão vermelhoPeríodo vermelhoDeslocamento de fase do vermelhoPré-flash vermelhoBordas aguçadas vermelhasFator de alongamento vermelhoLimiar de vermelho da cor de entradaReduz o número de cores na imagem, reduzindo a quantidade de níveis por canal (cores e alfa). Diferentes métodos de estremecimento podem ser especificados para compensar a aglomeração induzida pela quantização.Reduz o número de níveis em cada componente de cor da imagem.ReferênciaEscala de refinamentoPassos de refinamentoRefletirReflete uma imagem em torno de uma linha, cuja direção é especificada pelo vetor definido pelas propriedades x e y. Refletir o padrão horizontalmenteTamanho da regiãoRegulariza a geometria a uma velocidade proporcional ao valor médio da curvatura localMapeamento de tons Reinhard 2005Colorimétrico relativoAlteração do brilho relativo em paradasBrilho relativo de cada exposição em EVForça relativa de destaqueRemapearRemapeia o intervalo de intensidade da imagemRemistura cores, definindo contribuições relativas das componentes da fonte.Remove o efeito de olhos vermelhos causado pelo flash das câmerasCaminho de renderizaçãoEspirografia de renderizaçãoTexto a renderizarCriar um padrão quadriculadoAltura renderizada em pixels. (apenas leitura)Largura renderizada em pixels. (apenas leitura)Intenção de renderizaçãoRenderiza múltiplos sistemas fractais, com opções configuráveis de cor.Tipo de renderizaçãoRenderiza um padrão espirográficoRenderiza um contorno de pincelRenderiza uma região preenchidaRenderiza um contorno vetorialRenderiza perfis de luminosidade para componentes vermelhos, verdes e azuis junto com a linha especificada no buffer de entrada, plotado em um buffer de tamanho especificado.RepetirSubstituir uma faixa de cores por outraCor a inserir.Reposiciona o buffer (com precisão de subpixel), se as coordenadas inteiras são passadas, um caminho-rápido sem reamostragem é usadoMétodo de reamostragemRedimensionar tamanho geral da imagemRedefine a origemResolução em pixelsRotação resultanteManter ladrilhagemDireitaRigidezOndulaçãoRobertsRotacionarRotacionar no centroRotaciona o buffer ao redor do centro, cuidando dos possíveis deslocamentos.Rotaciona o buffer ao redor da origem especificada.RotacionadoRotaçãoRotação aplicada às reflexõesRotação aplicada ao resultadoÂngulo de rotação de desfoque. Um ângulo largo pode demorar certo tempo para renderizarSuperfície áspera de ladrilhoCircularMostrador SDLMostrador SDL2Carregador de imagem SVGRotação do matiz SVGLuminância para AlphaMatriz SVGSaturação SVGOperação de mistura SVG de super-exposição de cor (<code>if cA * aB + cB * aA <= aA * aB: d = cA * (1 - aB) + cB * (1 - aA) do 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 de sub-exposição de cor (<code>if cA * aB + cB * aA >= aA * aB: d = aA * aB + cA * (1 - aB) + cB * (1 - aA) do 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 de escurecimento (<code>d = MIN (cA * aB, cB * aA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG de diferença (<code>d = cA + cB - 2 * (MIN (cA * aB, cB * aA))</code>)Operação de mistura SVG de exclusão (<code>d = (cA * aB + cB * aA - 2 * cA * cB) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG de luz dura (<code>if 2 * cA < aA: d = 2 * cA * cB + cA * (1 - aB) + cB * (1 - aA) do contrário: d = aA * aB - 2 * (aB - cB) * (aA - cA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG de clareamento (<code>d = MAX (cA * aB, cB * aA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG de sobreposição (<code>if 2 * cB > aB: d = 2 * cA * cB + cA * (1 - aB) + cB * (1 - aA) do contrário: d = aA * aB - 2 * (aB - cB) * (aA - cA) + cA * (1 - aB) + cB * (1 - aA)</code>)Operação de mistura SVG de adição (<code>d = cA + cB</code>)Operação de mistura SVG de tela (<code>d = cA + cB - cA * cB</code>)Operação de mistura SVG de 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); do 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 matriz SVG colorida svg_huerotateOperação matriz SVG colorida svg_luminancetoalphaOperação matriz SVG colorida svg_matrixOperação matriz SVG colorida svg_saturateDescrição do estilo SVG de transformaçãoPontos de amostraAmostrasAmostrador usado internamenteAmostrasSaturaçãoAjuste da saturaçãoFrequência da saturaçãoDeslocamento de fase da saturaçãoValor de saturação para ajustes acima do cinzaSalvarDente de serraLimiar escalar global (usado quando não existe buffer de entrada auxiliar).EscalaTamanho de escala 1:1Fator de escala para aumentar a renderizaçãoEscala da imagemRazão de escalaAlterar tamanhoManter aspecto na mudança de tamanhoValor de escala para o eixo xValor de escala para o eixo yEscala, força de efeitoAntialiasing Scale3XEscala o buffer de acordo com a razão.Escala o buffer de acordo com o tamanho.Escala o buffer a um tamanho, de acordo com a razão de aspectoEscala o componente do buffer para estar no range de 0.0-1.0. Isto melhora as imagens que fazem mau uso do contraste disponível (pouco contraste, muito escuro, ou imagens muito brilhantes).Escala o componente do buffer para estar no range de 0.0-1.0. Isto melhora as imagens que fazem mau uso do contraste disponível (pouco contraste, muito escuro, ou imagens muito brilhantes). Esta versão difere do Contraste esticado, pois funciona no espaço HSV e preserva o matiz.DimensionamentoFator de escala para recursos de imagem no raio, -1 os cancela, 1.0 aprimora a bordaEscala, fator para máscara desfocada, a força de efeitoEspalhamentoEspalhamento (velocidade vs qualidade)ScriptImagem auxiliar secundária para buffer de pad de entrada.Semear bordasSegmentar cores usando agrupamento de médias-KSelecionar o n-ésimo ponto mais próximoDesfoque Gaussiano seletivoSaturação de matiz seletivaAjuste seletivo de matiz, saturação e brilhoSeparadorSépiaDefinir no Nativo se não-certo, os espaços baseados em CIE podem introduzir mudanças hue.Define a quantidade de azul para o canal azulDefine a quantidade de azul para o canal verdeDefine a quantidade de azul para o canal vermelhoDefine a quantidade de verde para o canal azulDefine a quantidade de verde para o canal verdeDefine a quantidade de verde para o canal vermelhoDefine a quantidade de vermelho para o canal azulDefine a quantidade de vermelho para o canal verdeDefine a quantidade de vermelho para o canal vermelhoDefine a altura em pixels de acordo com a qual o texto será justificado verticalmente. Use -1 para não justificar.Define a largura em pixels em que linhas longas irão ajustar-se. Use -1 para não ajustar.Vários métodos simples para detecção de bordaÂngulo da sombraCor da sombraDesvanecimento de sombra do ponto médioDesvanecimento de sombra do ponto médio, como um fator do tamanho de sombraComprimento da sombraSombra menos imagemSomente sombraSombra mais imagemEstilo da sombraSombrasAjuste de cor de sombrasSombras-DestaquesFormaAguçar (Máscara desfocada)Aguça a imagem, somando diferenças à imagem borrada, uma técnica para nitidez originalmente usada em salas escuras.NitidezCisalhamentoCisalha o buffer. DeslocamentoDeslocar XDeslocar YDireção do deslocamentoDesloca cada linha ou coluna de pixels por uma quantidade aleatóriaMuda o ponto brancoA extensão da saída deveria ser cortada para a extensão da entradaMostrar opções GEGLMostrar controles de iluminaçãoMostrar controles pré-flashDiminuir áreaSierpinskiAgrupamento iterativo linear simplesRuído simplexSimplificar imagem em uma matriz com pontos de cores sólidasSimular uma ampliação de filme negativo em uma câmara escura analógica.Simula uma pintura a óleoSimular a distorção de cor produzida por uma máquina copiadoraSimular a distorção causada por ladrilhos de vidroSimular brilho ao fazer o destaque intenso e indefinidoSimular lente desfocada fora-de-focoSimula uma caricatura, com resultado similar a uma caneta preta de ponta macia seguida de cor. Isso é conseguido ao realçar as bordas e escurecer áreas que são mais escuras que sua vizinhançaSimula uma imagem criada por gravação em relevoSimula a distorção óptica produzida por uma lente elíptica sobre a imagemSenoSenoSenoideTamanhoTamanho XTamanho YTamanho de um lado da regiãoTamanho de um lado de um quadrado da malhaTamanho das correções usadas para reduzir ruídosRelação de tamanho XRelação de tamanho XSuave por Transformação de domínioTorção suaveSuavizaçãoFator de suavização de 1 a 100; 0 desabilita a suavizaçãoSuavidadeSovelDetecção de borda SobelBrilho suaveSuavidadeRuído sólidoOrigemPerfil de origemCaminho do arquivo de origem (png, jpg, raw, svg, bmp, tif, ...)Nome do espaçoEspaçamento do ladrilhoExtensão espacialRegularização espacialDesvio padrão espacial do núcleo de desfoque, em pixels.Envelope espaço-temporal tipo Retinex com amostragem estocásticaDetecção especializada de bordas direcionadaEsféricoÂngulo do ápice esférico, como fração do ângulo de visãoEsferizarAranhaGiroGira o ângulo no eixo da câmeraEspiralComeço da coordenada XComeço da coordenada YRaio da espiralRenderizador de espiralRotação espiralDireção da espiralTipo de espiralEsfirográfiaQuadradoTamanho do quadradoQuadradosCompressãoNiveladoDesvio padrão (fator de escala espacial)Desvio padrão para o eixo horizontalCor inicialÂngulo inicial para a faixa de cor de destinoÂngulo inicial para a faixa de cor originalIniciar da direita ao invés da esquerdaComeço da coordenada xComeço da coordenada YDesv. Pad.PassoParada 1Parada 2Parada 3Parada 4Parada 5Armazena imagem em um GdkPixbuf.Armazenar em GdkPixbufGuardar o perfil ICC que será embutido se guardado com uma imagem.ForçaForça de efeitoForça de realce de detalhe localForça do efeito sépiaContraste esticadoContraste esticado HSVEstica o croma de cor para cobrir a maior região possível, mantendo o matiz e o brilho inalterados.String para exibir (utf8)ListradoRiscoCor do riscoOpacidade do riscoLargura do riscoEstiloEstilo do efeitoSubdivisõesSubconjuntoSubtrairSobrepõe várias cópias alteradas da image.SupernovaAgrupamento de médias k baseado em superpixelsSuperpixels baseados na transformação WatershedCor do superpixelTamanho do superpixelSuperamostragemSuperconjuntoCaracterísticas da superfícieTorcer no sentido horárioTorcer no sentido anti-horárioMudar para sentido horárioVizinho simétrico mais próximoCarregador de imagem TIFFGravador de imagem TIFFCarregador de imagem TIFF usando libtiffGravador de imagem TIFF usando libtiffTaxa-alvo de vídeo codificado em kb/sCaminho do arquivo de destino para gravar o GeglBuffer.Caminho destino e nome do arquivoCaminho destino e nome do arquivo, use "-" para a saída padrãoCaminho de destino e nome do arquivo, use "-" para stdout.Desfoque temporalTesta op para fazer um mapa 1:1 de entrada para saída, enquanto realizando amostragemTextoTexturiza a imagem como se ela estivesse em uma tela de pintura.Texturizar a telaGeglBuffer para carregar no pipelineQuantidade pela qual escalonar os valores de alturaQuantidade de compressão do contrasteO formato babl da entradaO formato babl da saídaO formato babl da saída do GeglBuffer, NULL para usar o formato do buffer de entradaA cor de plano de fundoO cmsHPROFILE correspondente ao perfil ICC do dado de entrada.A cor em (x1, y1)A cor em (x2, y2)Cor da supernova.A cor a mudar.A cor a tornar transparente.A cor para pintar a entradaA cor para renderizar (padrão "preto")O componente utilizado para as coordenadas XO componente utilizado para as coordenadas YA curva de contraste.Quantidade de pixels para calcular simultaneamenteA distancia para expandir a sombra antes do desfoque; o valor negativo contrairá a sombra ao invésA estratégia de estremecimento a ser utilizadaO f-stop de um desviar/queimar para uma entrada auxiliar pura branca/pretaA opacidade de preenchimento para usarA opacidade de preenchimento para usar.Cor da primeira célulaA cor de primeiro planoO primeiro plano contém buracos e/ou diversas partes desconectadasO primeiro plano não contém partes opacasO primeiro plano é muito pequeno para ser utilizadoLimite acima do qual as cores permanecem opacas.Limite abaixo do qual as cores ficam transparentes.Local onde armazenar a saída do GeglBufferO script lua contendo a implementação desta operação.O máximo de diferença no valor em que propagar o pixelA diferença mínima em valores em que propaga o pixelQuantidade de threads de processamento simultâneos para usoQuantidade de iterações de deformaçãoNúmero de divisõesNúmero de oitavas de ruído.O número de pixels ao longo de uma repetição de um padrão base na resolução base.As partes opacas do primeiro plano não estão na frente do plano de fundo!Orientação do desfoque - hor/verA saída pixbuf produzida pelo processo guardado na propriedadeA qualidade de renderização, um valor entre 0.0 (rápido) e 1.0 (referência)A semente aleatória para os fachos e azul randômicoSemente randômica para a função de ruídoO ID referência usado como entrada (para uso em XML).A intenção de renderização a ser usada na conversão.Tamanho da função de ruídoCor da segunda célulaA cor da sombra (por padrão, "black")A forma dos pixelsA forma de expandir ou contrair a sombra emA força para propagar o pixel para os vizinhosA cor de plano de fundo do azulejoO valor representa a contribuição do passado para o novo quadro.Largura do pincel usado para riscar o caminhoA largura do pincel usado para contornar o caminho.Há um problema na sintaxe ou na aplicação dos valores de propriedades obtidos. As coisas podem funcionar assim mesmo.Este desfoque é usado no filtro de decomposição de onda, cada pixel é calculado pela transformação HATEsta função simula a degradação de ser um monitor de vídeo antigo.Este plug-in produz um efeito como uma explosão de supernova. A quantidade do efeito de luz é aproximadamente proporcional a 1/r, onde r é a distância a partir do centro da estrela.Este plug-in utiliza o algoritmo descrito por John Schlag, em "Fast Embossing Effects on Raster Image Data" (Efeitos rápidos de relevo em dados de imagens rasterizadas) em Graphics GEMS IV (ISBN 0-12-336155-9). Ele usa um buffer a ser aplicado como um mapa de relevo em outro buffer e produz um agradável efeito de relevo.LimiarLimiar altoLimiar baixoLimita a imagem para branco/preto baseada em cada valor global definido na propriedade valor, ou por pixel da entrada aux.LadrilhadoLadrilho de vidroAltura do ladrilhoLargura do ladrilhoCor do ladrilho baseado na média de pixels incluídosVariação de cor do ladrilhoGeometria do ladrilhoAltura do ladrilhoNitidez dos ladrilhosSaturação do azulejoTamanho do azulejoEspaçamento do ladrilhoPadrãoLadrilhadoMapa de relevo ladrilhadoInclinaçãoTítulo a ser dado à janela de saídaParaPara 0Para 1Para 2Para 3Para 4Para 5Para 6Para 7Para a corEmbaixoNa esquerdaPara polarNa direitaNo topoTopoEsquerda acimaDireita acimaPáginas totais, providas para uma propriedade visual somente de leituraTraseiroTransformarTransformar a imagem com os fractaisExpressão de transformação em sintaxe de transformação SVGMatriz de transformação, usando sintaxe SVG (múltiplas matrizes, separadas por ponto e vírgula)TranslaçãoTraduzir topo-esquerdo para 0.0.Limiar de transparênciaTransparenteTratar como istoTratar assim: Cores cinza da faixa de origem acima serão tratadas como se tivessem esse matiz e saturação
Mudar para: Alterar cores cinza para este matiz e saturaçãoTriânguloTriângulosAjustar XAjustar YFator de influência TrimapTurbulênciaTurbulentoTornar a escala de cinza de uma imagem e sobrepor um grid supersaturado - atráves da assimilação de cor acontecendo no sistema visual humano, para algumas escalas de grid isso produz a ilusão que a escala de cinza da célula do grid também possuem cor própria.Transforma a imagem em escala de cinzaTipoTipo 1Tipo 2Tipo de amostragem GEGL usado para buscar pixels de entradaTipo de padrão RGB a utilizarTipo de um fractalTipo de ilusãoTipo de mapaURIURI do arquivo para carregarURI do arquivo para carregar.URI do arquivo para carregarURI do arquivo para carregar.URI da imagem para carregar.Não foi possível converter imagem para espaço de cor sRGBNão foi possível criar perfil de cor de saídaNão foi possível abrir imagem JPEG 2000Não foi possível ler o arquivo: %sModo de GeglOption desconhecido: %dFormato de imagem JPEG 2000 desconhecidoDespremultiplica um buffer que contém cores premultiplicadas (que não o são de acordo com o formato babl)Despremultiplicar alfaRegião de cor sem sementesArquivo JPEG 2000 não suportado com profundidade %dTipo de fractal não suportadoSem suporte ao tipo fractal: %dNão há suporte a arquivos não-RGB JPEG 2000 com %d componentesLimiar superiorUsa pesos MLSUtiliza uma distribuição de ruído Gaussiana, quando desmarcado uma distribuição linear é utilizadaUsar um GeglBuffer da memória como origem da imagem.Uma fonte que usa o GeglBuffer em disco.Usa valores de máscara linearUsa saída linear em vez de correção de gamaUsar região localUsa tabelas de huffman otimizadasUsa valores de luminosidade de pixelsUsa gama sRGB em vez de linearUtilizar a faixa [0, 1] total para codificar as coordenadas ZValor do usuárioUsa o GdkPixbuf localizado no local de memória em <em>pixbuf</em>.ValorInverter valorPropagar valorValor da baseValor do topoExpoente do valor (escala logarítmica)Deslocamento do valorValoresDesfoque variávelVetorTraço vetorialVerticalPosição central verticalExtensão verticalExtensão verticalJustificar verticalmenteJustificação vertical 0.0 é topo, 0.5 no meio e 1.0 no final.Deslocamento verticalDeslocamento vertical (da origem) para o início da gradeDeslocamento vertical de blocos em pixeisEscala de padrão verticalPosição verticalPosição vertical em pixelsFator de escala verticalDeslocamento do sombreamento verticalQuantidade de cisalhamento verticalTamanho verticalA relação vertical do tamanho de um pixel dentro de cada blocoQuantidade de propagação verticalAlinhamento vertical do texto (0=acima, 1=meio, 2=abaixo)Tamanho vertical da texturaTranslação verticalLargura vertical das células em pixelsDegradação de vídeoTamanho do buffer de vídeoCodec de vídeoCodec de vídeo a usar, ou auto para usar um padrão baseado no formato do contêiner.Fonte de quadros Video4LinuxEntrada Video4Linux, capturadores de quadros, webcams e dispositivos semelhantes.Fonte de quadros Video4Linux2Entrada Video4Linux2, capturadores de quadros, webcams e dispositivos similares.VinhetaForma de vinhetaVisualizar a máscara de ajusteDiagrama VoronoiTorcerDistorce as cores de uma imagem entre cores com fatores de distorção ponderados, pares de cores que são do preto para o preto são ignoradas na construção do mapa.Nível de águaPixels aquáticosTransformação WatershedTipo de ondulaçãoOndasCarregador de imagem WebPGravador de arquivo WebPQualidade de compressão WebPCarregador de imagem WebP.Gravador de imagem WebPSigma da distribuição de peso controlando as contribuições da respostaSigma do pesoMistura ponderadaPesa a opacidade da entrada pelo valor da entrada aux e pela propriedade do valor global.Qual o modelo de cor usado para a transformaçãoQual forma a ser usada nos ladrilhosQuando TRUE o modelo não será liberadoQuando habilitado também realça as regiões de sombra - quando desabilitado um resulto mais natural é obtidoQuando habilitado, os detalhes das sombras são aumentados às custas do ruídoQuando definido, opera em valores corrigidos por gama em vez de RGB linear - agindo como o filtro antigo de normalização no GIMPOnde o GEGL armazena suas trocasSe a função soma o resultado à imagem original.Caso as bordas da imagem também sejam semeadasCaso para propagar a cor do pixelCaso para propagar a opacidade do pixelSe o padrão RGB será rotacionado em noventa graus.OndulaçãoGiro e pinçaÂngulo de giro (graus)BrancoBranco no pretoAjuste de ponto brancoAmpla gama RGBListras largasLarguraLargura para imagem renderizadaLargura do intervalo de matiz selecionado  Largura de bloco em pixelsLargura de linhas de grade em pixelsLargura do buffer geradoLargura do ladrilhoVentoEfeito de mistura similar a ventoTítulo da janelaEmbrulharAltura de envoltórioEmbrulhar imagem em um formato esféricoEmbrulhar entradaCobre os ladrilhos fracionáriosLargura de envoltórioEscritaBuffer de escritaEscreve o nome da câmera corretamenteEscreve dados de entrada em uma superfície de destino buffer GEGL.Escreve criador de lentes corretamenteEscreve o modelo da sua câmera com letras em maiúsculoEscreve dados da imagem em um buffer existentePixels incorretosXAmplitude XComponente XDeslocamento XPeríodo XFase XEscala XTamanho XRelação de eixo X para o centro da reflexãoRelação de eixo X para ajustar a expansão da reflexãoCoordenada X da origemCoordenada X do padrão centralCoordenada X do centro de deslocamentoCoordenada X do centro da supernovaCoordenada X do centro do clarãoDeslocamento XMultiplicador XPosição XDeslocamento X no espaço fractalInício X do buffer geradoX0X1Valor X1, posiçãoX2Valor X2, posiçãoYAmplitude YComponente YDeslocamento YPeríodo YFase YEscala YTamanho YRelação de eixo Y para o centro da reflexãoRelação de eixo Y para ajustar a expansão da reflexãoCoordenada Y da origemCoordenada Y do padrão centralCoordenada Y do centro de deslocamentoCoordenada Y do centro da supernovaCoordenada Y do centro do clarãoDeslocamento YPosição YDeslocamento Y no espaço fractalInício Y do buffer geradoCb Y'CbCrCr Y'CbCrY' Y'CbCrY0Y1Valor Y1, posiçãoY2Valor Y2, posiçãoÂngulo amareloFiltro amareloCompensação de filtro amarelo para a imagem negativaPadrão amareloPeríodo amareloCoordenada X do centro das ondasMultiplicador ZDeslocamento ZMagnificaçãoAmpliação no espaço fractalNíveis de zoomDesfoque de movimento de ampliaçãoDesfoque de movimento de ampliação[op [propriedade=valor] [propriedade=valor]] [[op] [propriedade=valor]um GeglBuffer em disco para abriradicionar-alfaquantidadeáudiotaxa de áudio em kb/staxa de amostragem do áudioaudio-codecaudio_channelsaudio_sample_rategatilho automático recarrega isto várias vezes por segundo.formato bablmisturar duas imagens usando valores alfa como pesosnão foi possível criar um novo fluxo Jaspernão foi possível ler arquivo JPEG 2000número do quadro atual, pode ser alterado para disparar um recarregamento da imagem.falha ao abrir imagem JPEG 2000 em "%s"arquivo a se carregarsinalizarpontos flutuantes -1 significam automático, 0 significa inteiro e 1 significa flutuante.quadronúmero de quadros a se decodificardelay do frameframe-ratequadrosqualidade globalvalor global usado se aux não contém dadosescala de peso globalgluasgop-sizecomo determinar o que preencher (não nulo|par-ímpar)i-quant-factori-quant-offsetkeyint-minCarregador de arquivo librawlista de <number>smax_b_framesmax_qdiffme-subpel-qualityme_rangeredução de ruídonúmero de níveis por componenteop "%s" não encontrada, resultados parciais: x-origemy-origemaltura de saída/renderização em pixels, -1 para altura da entradalargura de saída/renderização em pixels, -1 para largura da entradacaminho do arquivo para salvar.carregador de PDFpipelineponteiro para um espaço const * Bablposição do centro de simetria na saídaqblurqcompressqmaxqminaltura da regiãolargura da regiãoregião-xregião-ys RGBsRGBamostra de entrada com um buffer auxiliar que contém a fonte absoluta das coordenadasamostra de entrada com um buffer auxiliar que contém coordenadas de origem relativasfator de dimensionamento do deslocamento, indica o tamanho correspondente a um mapeamento relativo de 1,0. correspondente a 1.0.limiar de mudança de cenadefinir espaço de cor em que formatos-babl subsequentes em um pipeline são criados com, e o perfil ICC potencialmente embutido para gestão externa de cor, definindo um ponteiro para um formato sobrescreve a propriedade do string e define o pad auxiliar sobrescrevendo ambos.integral quadradaalonga componentes de pixels individualmente baseado em envelopes de luminânciadescrição em estilo SVG da transformação.tamanho do azulejo a usar.troca entre regularidade de superpixel e aderência às fronteiras do objetotrellisdados de caminho não manipulados %s:%s
modo desconhecidouri do arquivo para carregaruso: %s [opções] <arquivo | -- [op [op] ..]>

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

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

     --exists        retorna 0 se existir uma ou mais operações

     --info          imprime informações sobre a operação:
                     nome, descrição, detalhes das propriedades

     -i, --file      lê o xml do arquivo informado

     -x, --xml       usa o xml fornecido no argumento seguinte

     -o, --output    imprime imagem gerada para o arquivo informado, com
                     tipo baseado na extensão

     -p              incrementa os contadores de quadros de vários
                     elementos ao terminar o processamento

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

     -X              imprime o XML que foi lido

     -v, --verbose   exibe diagnósticos enquanto está em execução

Todos os parâmetros após -- são considerados ops a serem encadeadas em
composições menores ao invés de usar um arquivo xml, facilitando assim os
testes dos filtros. Depois de encadear uma nova op as propriedades podem
ser definidas com pares propriedade=valor como argumentos posteriores.
utilize pontos flutuantestaxa de vídeo em kb/staxa máxima de vídeotaxa mínima de vídeotolerância da taxa de vídeocaminho do dispositivo de vídeovideo-codecpeso 0peso 1peso 2peso 3peso 4peso 5peso 6peso 7