TDE
/
libkdcraw
6
0
Fork 1
Code Issues 1 Pull Requests 1 Releases Wiki Activity

Added abandoned KDE3 version of libkdcraw

Browse Source 
git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/libraries/libkdcraw@1076409 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
v3.5.13-sru
tpearson 14 years ago
commit a470f3e5f2
89 changed files with 43012 additions and 0 deletions
Show Stats Download Patch File Download Diff File

11
AUTHORS
Unescape View File

@ -0,0 +1,11 @@
AUTHORS AND MAINTAINERS :
Caulier Gilles <caulier dot gilles at gmail dot com>
Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
CONTRIBUTORS:
Angelo Naselli <anaselli at linux dot it>
Gerhard Kulzer <gerhard at kulzer dot net>
Achim Bohnet <ach at mpe dot mpg dot de>
Guillaume Castagnino <casta at xwing dot info>

340
COPYING
Unescape View File

@ -0,0 +1,340 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

1661
ChangeLog
View File

File diff suppressed because it is too large Load Diff

181
INSTALL
Unescape View File

@ -0,0 +1,181 @@
Basic Installation
==================
These are generic installation instructions.
The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation. It uses
those values to create a `Makefile' in each directory of the package.
It may also create one or more `.h' files containing system-dependent
definitions. Finally, it creates a shell script `config.status' that
you can run in the future to recreate the current configuration, a file
`config.cache' that saves the results of its tests to speed up
reconfiguring, and a file `config.log' containing compiler output
(useful mainly for debugging `configure').
If you need to do unusual things to compile the package, please try
to figure out how `configure' could check whether to do them, and mail
diffs or instructions to the address given in the `README' so they can
be considered for the next release. If at some point `config.cache'
contains results you don't want to keep, you may remove or edit it.
The file `configure.in' is used to create `configure' by a program
called `autoconf'. You only need `configure.in' if you want to change
it or regenerate `configure' using a newer version of `autoconf'.
The simplest way to compile this package is:
1. `cd' to the directory containing the package's source code and type
`./configure' to configure the package for your system. If you're
using `csh' on an old version of System V, you might need to type
`sh ./configure' instead to prevent `csh' from trying to execute
`configure' itself.
Running `configure' takes awhile. While running, it prints some
messages telling which features it is checking for.
2. Type `make' to compile the package.
3. Optionally, type `make check' to run any self-tests that come with
the package.
4. Type `make install' to install the programs and any data files and
documentation.
5. You can remove the program binaries and object files from the
source code directory by typing `make clean'. To also remove the
files that `configure' created (so you can compile the package for
a different kind of computer), type `make distclean'. There is
also a `make maintainer-clean' target, but that is intended mainly
for the package's developers. If you use it, you may have to get
all sorts of other programs in order to regenerate files that came
with the distribution.
Compilers and Options
=====================
Some systems require unusual options for compilation or linking that
the `configure' script does not know about. You can give `configure'
initial values for variables by setting them in the environment. Using
a Bourne-compatible shell, you can do that on the command line like
this:
CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
Or on systems that have the `env' program, you can do it like this:
env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
Compiling For Multiple Architectures
====================================
You can compile the package for more than one kind of computer at the
same time, by placing the object files for each architecture in their
own directory. To do this, you must use a version of `make' that
supports the `VPATH' variable, such as GNU `make'. `cd' to the
directory where you want the object files and executables to go and run
the `configure' script. `configure' automatically checks for the
source code in the directory that `configure' is in and in `..'.
If you have to use a `make' that does not supports the `VPATH'
variable, you have to compile the package for one architecture at a time
in the source code directory. After you have installed the package for
one architecture, use `make distclean' before reconfiguring for another
architecture.
Installation Names
==================
By default, `make install' will install the package's files in
`/usr/local/bin', `/usr/local/man', etc. You can specify an
installation prefix other than `/usr/local' by giving `configure' the
option `--prefix=PATH'.
You can specify separate installation prefixes for
architecture-specific files and architecture-independent files. If you
give `configure' the option `--exec-prefix=PATH', the package will use
PATH as the prefix for installing programs and libraries.
Documentation and other data files will still use the regular prefix.
In addition, if you use an unusual directory layout you can give
options like `--bindir=PATH' to specify different values for particular
kinds of files. Run `configure --help' for a list of the directories
you can set and what kinds of files go in them.
If the package supports it, you can cause programs to be installed
with an extra prefix or suffix on their names by giving `configure' the
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
Optional Features
=================
Some packages pay attention to `--enable-FEATURE' options to
`configure', where FEATURE indicates an optional part of the package.
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
is something like `gnu-as' or `x' (for the X Window System). The
`README' should mention any `--enable-' and `--with-' options that the
package recognizes.
For packages that use the X Window System, `configure' can usually
find the X include and library files automatically, but if it doesn't,
you can use the `configure' options `--x-includes=DIR' and
`--x-libraries=DIR' to specify their locations.
Specifying the System Type
==========================
There may be some features `configure' can not figure out
automatically, but needs to determine by the type of host the package
will run on. Usually `configure' can figure that out, but if it prints
a message saying it can not guess the host type, give it the
`--host=TYPE' option. TYPE can either be a short name for the system
type, such as `sun4', or a canonical name with three fields:
CPU-COMPANY-SYSTEM
See the file `config.sub' for the possible values of each field. If
`config.sub' isn't included in this package, then this package doesn't
need to know the host type.
If you are building compiler tools for cross-compiling, you can also
use the `--target=TYPE' option to select the type of system they will
produce code for and the `--build=TYPE' option to select the type of
system on which you are compiling the package.
Sharing Defaults
================
If you want to set default values for `configure' scripts to share,
you can create a site shell script called `config.site' that gives
default values for variables like `CC', `cache_file', and `prefix'.
`configure' looks for `PREFIX/share/config.site' if it exists, then
`PREFIX/etc/config.site' if it exists. Or, you can set the
`CONFIG_SITE' environment variable to the location of the site script.
A warning: not all `configure' scripts look for a site script.
Operation Controls
==================
`configure' recognizes the following options to control how it
operates.
`--cache-file=FILE'
Use and save the results of the tests in FILE instead of
`./config.cache'. Set FILE to `/dev/null' to disable caching, for
debugging `configure'.
`--help'
Print a summary of the options to `configure', and exit.
`--quiet'
`--silent'
`-q'
Do not print messages saying which checks are being made.
`--srcdir=DIR'
Look for the package's source code in directory DIR. Usually
`configure' can determine that directory automatically.
`--version'
Print the version of Autoconf used to generate the `configure'
script, and exit.
`configure' also accepts some other, not widely useful, options.

7
Mainpage.dox
Unescape View File

@ -0,0 +1,7 @@
/** @mainpage KDE Extragear Libraries
*
* The extragear-libs module collects libraries that are shared by
* more than one extragear application, or which are useful in their
* own right.
*
*/

7
Makefile.am
Unescape View File

@ -0,0 +1,7 @@
AUTOMAKE_OPTIONS = foreign 1.6.1
include admin/deps.am
include admin/Doxyfile.am
COMPILE_FIRST = libkexiv2 libkipi libkdcraw
SUBDIRS=$(TOPSUBDIRS)

6
Makefile.am.in
Unescape View File

@ -0,0 +1,6 @@
AUTOMAKE_OPTIONS = foreign 1.6.1
include admin/deps.am
include admin/Doxyfile.am
COMPILE_FIRST = libkexiv2 libkipi libkdcraw

14
Makefile.cvs
Unescape View File

@ -0,0 +1,14 @@
all:
@echo "This Makefile is only for the CVS repository"
@echo "This will be deleted before making the distribution"
@echo ""
@if test ! -d admin; then \
echo "Please recheckout this module!" ;\
echo "for cvs: use checkout once and after that update again" ;\
echo "for cvsup: checkout kde-common from cvsup and" ;\
echo " link kde-common/admin to ./admin" ;\
exit 1 ;\
fi
$(MAKE) -f admin/Makefile.common cvs
.SILENT:

53
NEWS
Unescape View File

@ -0,0 +1,53 @@
0.1.4
------------------------------------------------------------------------
- updated dcraw to 8.83
new cameras: Apple QuickTake 200, Fuji IS-1, Sony DSLR-A350, Pentax K20D,
Nokia N95, Canon PowerShots A460, Canon PowerShots A530,
Canon PowerShots A650.
no new options introduced.
- updated dcraw to 8.82
new cameras: Sony DSLR-A200, Sony DSLR-A700, Sony XCD-SX910CR, STV680 VGA
no new options introduced.
Bugs fixed from B.K.O (http://bugs.kde.org):
001 ==> 142055 : Which whitebalance is used.
0.1.3
------------------------------------------------------------------------
- updated dcraw to 8.81
new cameras: Canon G7, Fuji FinePix S9100/S9600, Olympus SP560UZ, Panasonic DMC-L10
- updated dcraw to 8.80
new cameras: Hasselblad H3D, Olympus E-3, Canon EOS 40D, Canon PowerShot G9,
Canon EOS-1Ds Mark III, AVT F-080C, Nikon D3, Nikon D300,
Nikon Coolpix S6, Panasonic DMC-FZ18, Sony DSLR-A700
-m number_of_passes
After interpolation, clean up color artifacts by repeatedly applying a 3x3
median filter to the R-G and B-G channels.
- Licence : is GPL compatible again == less wories)
0.1.2
------------------------------------------------------------------------
New features
- updated internal dcraw from 8.60 to 8.77. API changed.
- add new chromatic aberration reduction options (patch from Guillaume Castagnino).
0.1.1
------------------------------------------------------------------------
New features
- API changed: * KDcraw destructor is now virtual.
* Added DcrawSettingsContainer destructor.
* Separate embedded JPEG preview extraction and half decoding methods
to get a preview of RAW pictures.
Bugs fixed from B.K.O (http://bugs.kde.org):
001 ==> 145482 : libkdraw compile fails on Cygwin.
0.1.0
------------------------------------------------------------------------
First implementation
For details and info about previous versions, see ChangeLog.

205
PACKAGING
Unescape View File

@ -0,0 +1,205 @@
How to release kipi & co.
----------------------------------------
1. Before the final release
2. Release libkipi
3. Release libkexiv2
4. Release kipi-plugins
5. Notes on svn2cl
----------------------------------------
1. Before the final release
----------------------------------------
Some days before releasing the final, remember to announce
the translations commit deadline to kde-i18-doc@kde.org.
----------------------------------------
2. Release libkipi
----------------------------------------
a) Update release info
libkipi/libkipi.lsm
libkipi/libkipi/version.h
libkipi/libkipi.pc.in
To do that you can use the "prepare_libkipi.rb" script, change the
release version ("version" and "version_n" fields) and run it.
Don't forget to commit your changes :)
b) Update Changelog
- to do that use the "release_kipi_changelog.sh" script
release_kipi_changelog.sh libkipi oldest-revision-or-date new-release-version
- edit Changelog and modify the wrong lines (if any)
- Commit your changes
c) Build the source tarball
- use the "release_libkipi.rb"
edit the script and change the "version" field
if you're releasing an svn snapshot set "usesvnver" to "yes"
run it and get libkipiXXX.tar.bz2
d) Uncompress and test the tarball
- check if all the files are right in
- check if the file RELEASE.rev is in and with the right revision number
- check if it builds correctly.
- diff headerfiles installed in <incdir>/kde/libkipi/ with last release
and check for binary compatibility (see e.g.,
http://developer.kde.org/documentation/other/binarycompatibility.html)
Every API change should be refleced in a changed version-info in
libkipi/libkipi/Makefile.am (see e.g.,
http://www.gnu.org/software/libtool/manual.html#Versioning)
e) Upload tarball for testing
Before an official release upload the tarball for testing used sites are
digikam3rdparty.free.fr or www.linux.it/~anaselli/kipi-plugins - depends
on who is releasing :)
Send a mail to kde-imaging@kde.org and digikam-devel@kde.org to have a
feedback from pakagers before posting an offical release annoucement.
f) Upload tarbal on SF and update kipi site
official site for uploading the release is http://sourceforge.net/projects/kipi
web page to be update is http://extragear.kde.org/apps/kipi/
to update this last you have to get, change and commit it from
XXX@svn.kde.org/home/kde/trunk/www/areas/extragear/apps/kipi
Send a mail to announce the official release.
----------------------------------------
3. Release libkexiv2
----------------------------------------
a) Update release info
libkexiv2/libkexiv2.lsm
libkexiv2/version.h
libkexiv2/libkexiv2.pc.in
libkexiv2/Makefile.am
libkexiv2/ChangeLog
To do that you can use the "prepare_libkexiv2.rb" script, change the
release version ("version", "version_n", "version_info" and "chlog_rev" fields)
and run it.
Don't forget to fix Changelog and commit your changes :)
c) Build the source tarball
- use the "release_libkexiv2.rb"
edit the script and change the "version" field
if you're releasing an svn snapshot set "usesvnver" to "yes"
run it and get libkexiv2XXX.tar.bz2
d) Uncompress and test the tarball
- check if all the files are right in
- check if the file RELEASE.rev is in and with the right revision number
- check if it builds correctly.
- diff headerfiles installed in <incdir>/kde/libkexiv2/ with last release
and check for binary compatibility (see e.g.,
http://developer.kde.org/documentation/other/binarycompatibility.html)
Every API change should be refleced in a changed version-info in
libkexiv2/Makefile.am (see e.g.,
http://www.gnu.org/software/libtool/manual.html#Versioning)
e) Upload tarball for testing
Before an official release upload the tarball for testing used sites are
digikam3rdparty.free.fr or www.linux.it/~anaselli/kipi-plugins - depends
on who is releasing :)
Send a mail to kde-imaging@kde.org and digikam-devel@kde.org to have a
feedback from pakagers before posting an offical release annoucement.
f) Upload tarbal on SF and update kipi site
official site for uploading the release is http://sourceforge.net/projects/kipi
web page to be update is http://extragear.kde.org/apps/kipi/
to update this last you have to get, change and commit it from
XXX@svn.kde.org/home/kde/trunk/www/areas/extragear/apps/kipi
Send a mail to announce the official release.
----------------------------------------
4. Release kipi-plugins
----------------------------------------
a) Update release info
kipi-plugins/kipi-plugins.lsm
kipi-plugins/common/include/pluginsversion.h
(kipi-plugins/ChangeLog)
To do that you can use the "prepare_kipiplugins.rb" script, change the
release version ("version" field) and run it.
Using svn2cl (http://ch.tudelft.nl/~arthur/svn2cl/) you can
add ChangeLog info with this script as well, to do that
follow the instructions:
- set usesv2cl to "yes"
- set svn2cl, svnbase, svnroot according to your account
- set chlog_rev to the last revision (+1) of the last release
(look at ChangeLog file, last commit)
- use the script as usual and skip step b)
- edit ChangeLog and modify the wrong lines (if any)
Don't forget to commit your changes.
b) Update ChangeLog
- if you're using svn2cl you can do that at step a)
- to do that use the "release_kipi_changelog.sh" script
release_kipi_changelog.sh kipi-plugins oldest-revision-or-date new-release-version
- edit Changelog and modify the wrong lines (if any)
- Commit your changes
c) Build the source tarball
- use the "release_kipi-plugins.rb"
edit the script and change the "version" field and check the "addPo" one for po files
if you're releasing an svn snapshot set "usesvnver" to "yes"
run it and get kipi-pluginsXXX.tar.bz2
d) Uncompress and test the tarball
- check if all the files are right in
- check if the file RELEASE.rev is in and with the right revision number
- check if it builds correctly.
e) Upload tarball for testing
Before an official release upload the tarball for testing used sites are
digikam3rdparty.free.fr or www.linux.it/~anaselli/kipi-plugins - depends
on who is releasing :)
Send a mail to kde-imaging@kde.org and digikam-devel@kde.org to have a
feedback from pakagers before posting an offical release annoucement.
f) Upload tarbal on SF and update kipi site
official site for uploading the release is http://sourceforge.net/projects/kipi
web page to be update is http://extragear.kde.org/apps/kipi/
to update this last you have to get, change and commit it from
XXX@svn.kde.org/home/kde/trunk/www/areas/extragear/apps/kipi
Send a mail to announce the official release at least to:
- kde-extra-gear@kde.org
- kde-announce@kde.org
- kde-imaging@kde.org
- digikam-devel@kde.org
- gwenview-general@lists.sourceforge.net
----------------------------------------
5. Notes on svn2cl
----------------------------------------
Latest versions (>= 0.9) of svn2cl offer the --ignore-message-starting option
and --ignore-message-starting=SVN_SILENT should work.
Programmers often write SVN_SILENT or CVS_SILENT (obsolete) everywhere
in the commit comment, that means such an option could not work.
Moreover it can be used only once, so just to skip SVN_SILENT or CVS_SILENT
not both.
The easiest way was to to hack into svn2cl.xsl (mine is /usr/share/svn2cl/svn2cl.xsl).
Add the following lines:
<!-- skip entries where the message contains SVN_SILENT -->
<xsl:template match="logentry[contains(msg,'SVN_SILENT')]">
</xsl:template>
<!-- skip entries where the message contains SILENT -->
<xsl:template match="logentry[contains(msg,'SILENT')]">
</xsl:template>
just before the template:
<!-- format one entry from the log -->
<xsl:template match="logentry">
...

27
README
Unescape View File

@ -0,0 +1,27 @@
DCRAW program interface for KDE
This library is a part of Kipi-Plugins project (http://www.kipi-plugins.org)
-- AUTHORS -----------------------------------------------------------
See AUTHORS file for details.
-- ABOUT -------------------------------------------------------------
Libkdcraw is a C++ interface around dcraw binary program used to decode RAW
picture files. The library documentation is available on header files.
This library is used by kipi-plugins, digiKam and others kipi host programs.
-- DEPENDENCIES -------------------------------------------------------
AutoConf >= 2.5.x http://www.gnu.org/software/autoconf
AutoMake >= 1.7.x http://www.gnu.org/software/automake
libqt >= 3.3.x http://www.trolltech.com
libkde >= 3.4.x (>=3.5.x recommended) http://www.kde.org
liblcms >= 1.14.x (used by dcraw.c) http://www.littlecms.com
libjpeg >= 6b (used by dcraw.c) http://www.ijg.org

2
RELEASE.rev
Unescape View File

@ -0,0 +1,2 @@
Last Changed Rev: 783789
Last Changed Date: 2008-03-09 16:29:11 +0100 (Sun, 09 Mar 2008)

11945
acinclude.m4
View File

File diff suppressed because it is too large Load Diff

909
aclocal.m4 vendored
Unescape View File

@ -0,0 +1,909 @@
# generated automatically by aclocal 1.10 -*- Autoconf -*-
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
# 2005, 2006 Free Software Foundation, Inc.
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
m4_if(m4_PACKAGE_VERSION, [2.61],,
[m4_fatal([this file was generated for autoconf 2.61.
You have another version of autoconf. If you want to use that,
you should regenerate the build system entirely.], [63])])
# Copyright (C) 2002, 2003, 2005, 2006 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_AUTOMAKE_VERSION(VERSION)
# ----------------------------
# Automake X.Y traces this macro to ensure aclocal.m4 has been
# generated from the m4 files accompanying Automake X.Y.
# (This private macro should not be called outside this file.)
AC_DEFUN([AM_AUTOMAKE_VERSION],
[am__api_version='1.10'
dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
dnl require some minimum version. Point them to the right macro.
m4_if([$1], [1.10], [],
[AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
])
# _AM_AUTOCONF_VERSION(VERSION)
# -----------------------------
# aclocal traces this macro to find the Autoconf version.
# This is a private macro too. Using m4_define simplifies
# the logic in aclocal, which can simply ignore this definition.
m4_define([_AM_AUTOCONF_VERSION], [])
# AM_SET_CURRENT_AUTOMAKE_VERSION
# -------------------------------
# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
# This function is AC_REQUIREd by AC_INIT_AUTOMAKE.
AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
[AM_AUTOMAKE_VERSION([1.10])dnl
_AM_AUTOCONF_VERSION(m4_PACKAGE_VERSION)])
# AM_AUX_DIR_EXPAND -*- Autoconf -*-
# Copyright (C) 2001, 2003, 2005 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
# $ac_aux_dir to `$srcdir/foo'. In other projects, it is set to
# `$srcdir', `$srcdir/..', or `$srcdir/../..'.
#
# Of course, Automake must honor this variable whenever it calls a
# tool from the auxiliary directory. The problem is that $srcdir (and
# therefore $ac_aux_dir as well) can be either absolute or relative,
# depending on how configure is run. This is pretty annoying, since
# it makes $ac_aux_dir quite unusable in subdirectories: in the top
# source directory, any form will work fine, but in subdirectories a
# relative path needs to be adjusted first.
#
# $ac_aux_dir/missing
# fails when called from a subdirectory if $ac_aux_dir is relative
# $top_srcdir/$ac_aux_dir/missing
# fails if $ac_aux_dir is absolute,
# fails when called from a subdirectory in a VPATH build with
# a relative $ac_aux_dir
#
# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
# are both prefixed by $srcdir. In an in-source build this is usually
# harmless because $srcdir is `.', but things will broke when you
# start a VPATH build or use an absolute $srcdir.
#
# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
# iff we strip the leading $srcdir from $ac_aux_dir. That would be:
# am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
# and then we would define $MISSING as
# MISSING="\${SHELL} $am_aux_dir/missing"
# This will work as long as MISSING is not called from configure, because
# unfortunately $(top_srcdir) has no meaning in configure.
# However there are other variables, like CC, which are often used in
# configure, and could therefore not use this "fixed" $ac_aux_dir.
#
# Another solution, used here, is to always expand $ac_aux_dir to an
# absolute PATH. The drawback is that using absolute paths prevent a
# configured tree to be moved without reconfiguration.
AC_DEFUN([AM_AUX_DIR_EXPAND],
[dnl Rely on autoconf to set up CDPATH properly.
AC_PREREQ([2.50])dnl
# expand $ac_aux_dir to an absolute path
am_aux_dir=`cd $ac_aux_dir && pwd`
])
# AM_CONDITIONAL -*- Autoconf -*-
# Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005, 2006
# Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 8
# AM_CONDITIONAL(NAME, SHELL-CONDITION)
# -------------------------------------
# Define a conditional.
AC_DEFUN([AM_CONDITIONAL],
[AC_PREREQ(2.52)dnl
ifelse([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])],
[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
AC_SUBST([$1_TRUE])dnl
AC_SUBST([$1_FALSE])dnl
_AM_SUBST_NOTMAKE([$1_TRUE])dnl
_AM_SUBST_NOTMAKE([$1_FALSE])dnl
if $2; then
$1_TRUE=
$1_FALSE='#'
else
$1_TRUE='#'
$1_FALSE=
fi
AC_CONFIG_COMMANDS_PRE(
[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
AC_MSG_ERROR([[conditional "$1" was never defined.
Usually this means the macro was only invoked conditionally.]])
fi])])
# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
# Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 9
# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be
# written in clear, in which case automake, when reading aclocal.m4,
# will think it sees a *use*, and therefore will trigger all it's
# C support machinery. Also note that it means that autoscan, seeing
# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
# _AM_DEPENDENCIES(NAME)
# ----------------------
# See how the compiler implements dependency checking.
# NAME is "CC", "CXX", "GCJ", or "OBJC".
# We try a few techniques and use that to set a single cache variable.
#
# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
# dependency, and given that the user is not expected to run this macro,
# just rely on AC_PROG_CC.
AC_DEFUN([_AM_DEPENDENCIES],
[AC_REQUIRE([AM_SET_DEPDIR])dnl
AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
AC_REQUIRE([AM_MAKE_INCLUDE])dnl
AC_REQUIRE([AM_DEP_TRACK])dnl
ifelse([$1], CC, [depcc="$CC" am_compiler_list=],
[$1], CXX, [depcc="$CXX" am_compiler_list=],
[$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
[$1], UPC, [depcc="$UPC" am_compiler_list=],
[$1], GCJ, [depcc="$GCJ" am_compiler_list='gcc3 gcc'],
[depcc="$$1" am_compiler_list=])
AC_CACHE_CHECK([dependency style of $depcc],
[am_cv_$1_dependencies_compiler_type],
[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
# We make a subdir and do the tests there. Otherwise we can end up
# making bogus files that we don't know about and never remove. For
# instance it was reported that on HP-UX the gcc test will end up
# making a dummy file named `D' -- because `-MD' means `put the output
# in D'.
mkdir conftest.dir
# Copy depcomp to subdir because otherwise we won't find it if we're
# using a relative directory.
cp "$am_depcomp" conftest.dir
cd conftest.dir
# We will build objects and dependencies in a subdirectory because
# it helps to detect inapplicable dependency modes. For instance
# both Tru64's cc and ICC support -MD to output dependencies as a
# side effect of compilation, but ICC will put the dependencies in
# the current directory while Tru64 will put them in the object
# directory.
mkdir sub
am_cv_$1_dependencies_compiler_type=none
if test "$am_compiler_list" = ""; then
am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
fi
for depmode in $am_compiler_list; do
# Setup a source with many dependencies, because some compilers
# like to wrap large dependency lists on column 80 (with \), and
# we should not choose a depcomp mode which is confused by this.
#
# We need to recreate these files for each test, as the compiler may
# overwrite some of them when testing with obscure command lines.
# This happens at least with the AIX C compiler.
: > sub/conftest.c
for i in 1 2 3 4 5 6; do
echo '#include "conftst'$i'.h"' >> sub/conftest.c
# Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
# Solaris 8's {/usr,}/bin/sh.
touch sub/conftst$i.h
done
echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
case $depmode in
nosideeffect)
# after this tag, mechanisms are not by side-effect, so they'll
# only be used when explicitly requested
if test "x$enable_dependency_tracking" = xyes; then
continue
else
break
fi
;;
none) break ;;
esac
# We check with `-c' and `-o' for the sake of the "dashmstdout"
# mode. It turns out that the SunPro C++ compiler does not properly
# handle `-M -o', and we need to detect this.
if depmode=$depmode \
source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
$SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
>/dev/null 2>conftest.err &&
grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
${MAKE-make} -s -f confmf > /dev/null 2>&1; then
# icc doesn't choke on unknown options, it will just issue warnings
# or remarks (even with -Werror). So we grep stderr for any message
# that says an option was ignored or not supported.
# When given -MP, icc 7.0 and 7.1 complain thusly:
# icc: Command line warning: ignoring option '-M'; no argument required
# The diagnosis changed in icc 8.0:
# icc: Command line remark: option '-MP' not supported
if (grep 'ignoring option' conftest.err ||
grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
am_cv_$1_dependencies_compiler_type=$depmode
break
fi
fi
done
cd ..
rm -rf conftest.dir
else
am_cv_$1_dependencies_compiler_type=none
fi
])
AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
AM_CONDITIONAL([am__fastdep$1], [
test "x$enable_dependency_tracking" != xno \
&& test "$am_cv_$1_dependencies_compiler_type" = gcc3])
])
# AM_SET_DEPDIR
# -------------
# Choose a directory name for dependency files.
# This macro is AC_REQUIREd in _AM_DEPENDENCIES
AC_DEFUN([AM_SET_DEPDIR],
[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
])
# AM_DEP_TRACK
# ------------
AC_DEFUN([AM_DEP_TRACK],
[AC_ARG_ENABLE(dependency-tracking,
[ --disable-dependency-tracking speeds up one-time build
--enable-dependency-tracking do not reject slow dependency extractors])
if test "x$enable_dependency_tracking" != xno; then
am_depcomp="$ac_aux_dir/depcomp"
AMDEPBACKSLASH='\'
fi
AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
AC_SUBST([AMDEPBACKSLASH])dnl
_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
])
# Generate code to set up dependency tracking. -*- Autoconf -*-
# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
# Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
#serial 3
# _AM_OUTPUT_DEPENDENCY_COMMANDS
# ------------------------------
AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
[for mf in $CONFIG_FILES; do
# Strip MF so we end up with the name of the file.
mf=`echo "$mf" | sed -e 's/:.*$//'`
# Check whether this is an Automake generated Makefile or not.
# We used to match only the files named `Makefile.in', but
# some people rename them; so instead we look at the file content.
# Grep'ing the first line is not enough: some people post-process
# each Makefile.in and add a new line on top of each file to say so.
# Grep'ing the whole file is not good either: AIX grep has a line
# limit of 2048, but all sed's we know have understand at least 4000.
if sed 10q "$mf" | grep '^#.*generated by automake' > /dev/null 2>&1; then
dirpart=`AS_DIRNAME("$mf")`
else
continue
fi
# Extract the definition of DEPDIR, am__include, and am__quote
# from the Makefile without running `make'.
DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
test -z "$DEPDIR" && continue
am__include=`sed -n 's/^am__include = //p' < "$mf"`
test -z "am__include" && continue
am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
# When using ansi2knr, U may be empty or an underscore; expand it
U=`sed -n 's/^U = //p' < "$mf"`
# Find all dependency output files, they are included files with
# $(DEPDIR) in their names. We invoke sed twice because it is the
# simplest approach to changing $(DEPDIR) to its actual value in the
# expansion.
for file in `sed -n "
s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
# Make sure the directory exists.
test -f "$dirpart/$file" && continue
fdir=`AS_DIRNAME(["$file"])`
AS_MKDIR_P([$dirpart/$fdir])
# echo "creating $dirpart/$file"
echo '# dummy' > "$dirpart/$file"
done
done
])# _AM_OUTPUT_DEPENDENCY_COMMANDS
# AM_OUTPUT_DEPENDENCY_COMMANDS
# -----------------------------
# This macro should only be invoked once -- use via AC_REQUIRE.
#
# This code is only required when automatic dependency tracking
# is enabled. FIXME. This creates each `.P' file that we will
# need in order to bootstrap the dependency handling code.
AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
[AC_CONFIG_COMMANDS([depfiles],
[test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
[AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
])
# Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005
# Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 8
# AM_CONFIG_HEADER is obsolete. It has been replaced by AC_CONFIG_HEADERS.
AU_DEFUN([AM_CONFIG_HEADER], [AC_CONFIG_HEADERS($@)])
# Do all the work for Automake. -*- Autoconf -*-
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
# 2005, 2006 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 12
# This macro actually does too much. Some checks are only needed if
# your package does certain things. But this isn't really a big deal.
# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
# AM_INIT_AUTOMAKE([OPTIONS])
# -----------------------------------------------
# The call with PACKAGE and VERSION arguments is the old style
# call (pre autoconf-2.50), which is being phased out. PACKAGE
# and VERSION should now be passed to AC_INIT and removed from
# the call to AM_INIT_AUTOMAKE.
# We support both call styles for the transition. After
# the next Automake release, Autoconf can make the AC_INIT
# arguments mandatory, and then we can depend on a new Autoconf
# release and drop the old call support.
AC_DEFUN([AM_INIT_AUTOMAKE],
[AC_PREREQ([2.60])dnl
dnl Autoconf wants to disallow AM_ names. We explicitly allow
dnl the ones we care about.
m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
AC_REQUIRE([AC_PROG_INSTALL])dnl
if test "`cd $srcdir && pwd`" != "`pwd`"; then
# Use -I$(srcdir) only when $(srcdir) != ., so that make's output
# is not polluted with repeated "-I."
AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
# test to see if srcdir already configured
if test -f $srcdir/config.status; then
AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
fi
fi
# test whether we have cygpath
if test -z "$CYGPATH_W"; then
if (cygpath --version) >/dev/null 2>/dev/null; then
CYGPATH_W='cygpath -w'
else
CYGPATH_W=echo
fi
fi
AC_SUBST([CYGPATH_W])
# Define the identity of the package.
dnl Distinguish between old-style and new-style calls.
m4_ifval([$2],
[m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
AC_SUBST([PACKAGE], [$1])dnl
AC_SUBST([VERSION], [$2])],
[_AM_SET_OPTIONS([$1])dnl
dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
m4_if(m4_ifdef([AC_PACKAGE_NAME], 1)m4_ifdef([AC_PACKAGE_VERSION], 1), 11,,
[m4_fatal([AC_INIT should be called with package and version arguments])])dnl
AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
_AM_IF_OPTION([no-define],,
[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl
# Some tools Automake needs.
AC_REQUIRE([AM_SANITY_CHECK])dnl
AC_REQUIRE([AC_ARG_PROGRAM])dnl
AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})
AM_MISSING_PROG(AUTOCONF, autoconf)
AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})
AM_MISSING_PROG(AUTOHEADER, autoheader)
AM_MISSING_PROG(MAKEINFO, makeinfo)
AM_PROG_INSTALL_SH
AM_PROG_INSTALL_STRIP
AC_REQUIRE([AM_PROG_MKDIR_P])dnl
# We need awk for the "check" target. The system "awk" is bad on
# some platforms.
AC_REQUIRE([AC_PROG_AWK])dnl
AC_REQUIRE([AC_PROG_MAKE_SET])dnl
AC_REQUIRE([AM_SET_LEADING_DOT])dnl
_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
[_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
[_AM_PROG_TAR([v7])])])
_AM_IF_OPTION([no-dependencies],,
[AC_PROVIDE_IFELSE([AC_PROG_CC],
[_AM_DEPENDENCIES(CC)],
[define([AC_PROG_CC],
defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl
AC_PROVIDE_IFELSE([AC_PROG_CXX],
[_AM_DEPENDENCIES(CXX)],
[define([AC_PROG_CXX],
defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl
AC_PROVIDE_IFELSE([AC_PROG_OBJC],
[_AM_DEPENDENCIES(OBJC)],
[define([AC_PROG_OBJC],
defn([AC_PROG_OBJC])[_AM_DEPENDENCIES(OBJC)])])dnl
])
])
# When config.status generates a header, we must update the stamp-h file.
# This file resides in the same directory as the config header
# that is generated. The stamp files are numbered to have different names.
# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
# loop where config.status creates the headers, so we can generate
# our stamp files there.
AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
[# Compute $1's index in $config_headers.
_am_stamp_count=1
for _am_header in $config_headers :; do
case $_am_header in
$1 | $1:* )
break ;;
* )
_am_stamp_count=`expr $_am_stamp_count + 1` ;;
esac
done
echo "timestamp for $1" >`AS_DIRNAME([$1])`/stamp-h[]$_am_stamp_count])
# Copyright (C) 2001, 2003, 2005 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_PROG_INSTALL_SH
# ------------------
# Define $install_sh.
AC_DEFUN([AM_PROG_INSTALL_SH],
[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
install_sh=${install_sh-"\$(SHELL) $am_aux_dir/install-sh"}
AC_SUBST(install_sh)])
# Copyright (C) 2003, 2005 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 2
# Check whether the underlying file-system supports filenames
# with a leading dot. For instance MS-DOS doesn't.
AC_DEFUN([AM_SET_LEADING_DOT],
[rm -rf .tst 2>/dev/null
mkdir .tst 2>/dev/null
if test -d .tst; then
am__leading_dot=.
else
am__leading_dot=_
fi
rmdir .tst 2>/dev/null
AC_SUBST([am__leading_dot])])
# Check to see how 'make' treats includes. -*- Autoconf -*-
# Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 3
# AM_MAKE_INCLUDE()
# -----------------
# Check to see how make treats includes.
AC_DEFUN([AM_MAKE_INCLUDE],
[am_make=${MAKE-make}
cat > confinc << 'END'
am__doit:
@echo done
.PHONY: am__doit
END
# If we don't find an include directive, just comment out the code.
AC_MSG_CHECKING([for style of include used by $am_make])
am__include="#"
am__quote=
_am_result=none
# First try GNU make style include.
echo "include confinc" > confmf
# We grep out `Entering directory' and `Leaving directory'
# messages which can occur if `w' ends up in MAKEFLAGS.
# In particular we don't look at `^make:' because GNU make might
# be invoked under some other name (usually "gmake"), in which
# case it prints its new name instead of `make'.
if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
am__include=include
am__quote=
_am_result=GNU
fi
# Now try BSD make style include.
if test "$am__include" = "#"; then
echo '.include "confinc"' > confmf
if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
am__include=.include
am__quote="\""
_am_result=BSD
fi
fi
AC_SUBST([am__include])
AC_SUBST([am__quote])
AC_MSG_RESULT([$_am_result])
rm -f confinc confmf
])
# Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005
# Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 5
# AM_PROG_CC_C_O
# --------------
# Like AC_PROG_CC_C_O, but changed for automake.
AC_DEFUN([AM_PROG_CC_C_O],
[AC_REQUIRE([AC_PROG_CC_C_O])dnl
AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
AC_REQUIRE_AUX_FILE([compile])dnl
# FIXME: we rely on the cache variable name because
# there is no other way.
set dummy $CC
ac_cc=`echo $[2] | sed ['s/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/']`
if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" != yes"; then
# Losing compiler, so override with the script.
# FIXME: It is wrong to rewrite CC.
# But if we don't then we get into trouble of one sort or another.
# A longer-term fix would be to have automake use am__CC in this case,
# and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
CC="$am_aux_dir/compile $CC"
fi
dnl Make sure AC_PROG_CC is never called again, or it will override our
dnl setting of CC.
m4_define([AC_PROG_CC],
[m4_fatal([AC_PROG_CC cannot be called after AM_PROG_CC_C_O])])
])
# Fake the existence of programs that GNU maintainers use. -*- Autoconf -*-
# Copyright (C) 1997, 1999, 2000, 2001, 2003, 2004, 2005
# Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 5
# AM_MISSING_PROG(NAME, PROGRAM)
# ------------------------------
AC_DEFUN([AM_MISSING_PROG],
[AC_REQUIRE([AM_MISSING_HAS_RUN])
$1=${$1-"${am_missing_run}$2"}
AC_SUBST($1)])
# AM_MISSING_HAS_RUN
# ------------------
# Define MISSING if not defined so far and test if it supports --run.
# If it does, set am_missing_run to use it, otherwise, to nothing.
AC_DEFUN([AM_MISSING_HAS_RUN],
[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
AC_REQUIRE_AUX_FILE([missing])dnl
test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"
# Use eval to expand $SHELL
if eval "$MISSING --run true"; then
am_missing_run="$MISSING --run "
else
am_missing_run=
AC_MSG_WARN([`missing' script is too old or missing])
fi
])
# Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_PROG_MKDIR_P
# ---------------
# Check for `mkdir -p'.
AC_DEFUN([AM_PROG_MKDIR_P],
[AC_PREREQ([2.60])dnl
AC_REQUIRE([AC_PROG_MKDIR_P])dnl
dnl Automake 1.8 to 1.9.6 used to define mkdir_p. We now use MKDIR_P,
dnl while keeping a definition of mkdir_p for backward compatibility.
dnl @MKDIR_P@ is magic: AC_OUTPUT adjusts its value for each Makefile.
dnl However we cannot define mkdir_p as $(MKDIR_P) for the sake of
dnl Makefile.ins that do not define MKDIR_P, so we do our own
dnl adjustment using top_builddir (which is defined more often than
dnl MKDIR_P).
AC_SUBST([mkdir_p], ["$MKDIR_P"])dnl
case $mkdir_p in
[[\\/$]]* | ?:[[\\/]]*) ;;
*/*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
esac
])
# Helper functions for option handling. -*- Autoconf -*-
# Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 3
# _AM_MANGLE_OPTION(NAME)
# -----------------------
AC_DEFUN([_AM_MANGLE_OPTION],
[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
# _AM_SET_OPTION(NAME)
# ------------------------------
# Set option NAME. Presently that only means defining a flag for this option.
AC_DEFUN([_AM_SET_OPTION],
[m4_define(_AM_MANGLE_OPTION([$1]), 1)])
# _AM_SET_OPTIONS(OPTIONS)
# ----------------------------------
# OPTIONS is a space-separated list of Automake options.
AC_DEFUN([_AM_SET_OPTIONS],
[AC_FOREACH([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
# -------------------------------------------
# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
AC_DEFUN([_AM_IF_OPTION],
[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
# Check to make sure that the build environment is sane. -*- Autoconf -*-
# Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005
# Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 4
# AM_SANITY_CHECK
# ---------------
AC_DEFUN([AM_SANITY_CHECK],
[AC_MSG_CHECKING([whether build environment is sane])
# Just in case
sleep 1
echo timestamp > conftest.file
# Do `set' in a subshell so we don't clobber the current shell's
# arguments. Must try -L first in case configure is actually a
# symlink; some systems play weird games with the mod time of symlinks
# (eg FreeBSD returns the mod time of the symlink's containing
# directory).
if (
set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`
if test "$[*]" = "X"; then
# -L didn't work.
set X `ls -t $srcdir/configure conftest.file`
fi
rm -f conftest.file
if test "$[*]" != "X $srcdir/configure conftest.file" \
&& test "$[*]" != "X conftest.file $srcdir/configure"; then
# If neither matched, then we have a broken ls. This can happen
# if, for instance, CONFIG_SHELL is bash and it inherits a
# broken ls alias from the environment. This has actually
# happened. Such a system could not be considered "sane".
AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken
alias in your environment])
fi
test "$[2]" = conftest.file
)
then
# Ok.
:
else
AC_MSG_ERROR([newly created file is older than distributed files!
Check your system clock])
fi
AC_MSG_RESULT(yes)])
# Copyright (C) 2001, 2003, 2005 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_PROG_INSTALL_STRIP
# ---------------------
# One issue with vendor `install' (even GNU) is that you can't
# specify the program used to strip binaries. This is especially
# annoying in cross-compiling environments, where the build's strip
# is unlikely to handle the host's binaries.
# Fortunately install-sh will honor a STRIPPROG variable, so we
# always use install-sh in `make install-strip', and initialize
# STRIPPROG with the value of the STRIP variable (set by the user).
AC_DEFUN([AM_PROG_INSTALL_STRIP],
[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
# Installed binaries are usually stripped using `strip' when the user
# run `make install-strip'. However `strip' might not be the right
# tool to use in cross-compilation environments, therefore Automake
# will honor the `STRIP' environment variable to overrule this program.
dnl Don't test for $cross_compiling = yes, because it might be `maybe'.
if test "$cross_compiling" != no; then
AC_CHECK_TOOL([STRIP], [strip], :)
fi
INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
AC_SUBST([INSTALL_STRIP_PROGRAM])])
# Copyright (C) 2006 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# _AM_SUBST_NOTMAKE(VARIABLE)
# ---------------------------
# Prevent Automake from outputing VARIABLE = @VARIABLE@ in Makefile.in.
# This macro is traced by Automake.
AC_DEFUN([_AM_SUBST_NOTMAKE])
# Check how to create a tarball. -*- Autoconf -*-
# Copyright (C) 2004, 2005 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# serial 2
# _AM_PROG_TAR(FORMAT)
# --------------------
# Check how to create a tarball in format FORMAT.
# FORMAT should be one of `v7', `ustar', or `pax'.
#
# Substitute a variable $(am__tar) that is a command
# writing to stdout a FORMAT-tarball containing the directory
# $tardir.
# tardir=directory && $(am__tar) > result.tar
#
# Substitute a variable $(am__untar) that extract such
# a tarball read from stdin.
# $(am__untar) < result.tar
AC_DEFUN([_AM_PROG_TAR],
[# Always define AMTAR for backward compatibility.
AM_MISSING_PROG([AMTAR], [tar])
m4_if([$1], [v7],
[am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'],
[m4_case([$1], [ustar],, [pax],,
[m4_fatal([Unknown tar format])])
AC_MSG_CHECKING([how to create a $1 tar archive])
# Loop over all known methods to create a tar archive until one works.
_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
_am_tools=${am_cv_prog_tar_$1-$_am_tools}
# Do not fold the above two line into one, because Tru64 sh and
# Solaris sh will not grok spaces in the rhs of `-'.
for _am_tool in $_am_tools
do
case $_am_tool in
gnutar)
for _am_tar in tar gnutar gtar;
do
AM_RUN_LOG([$_am_tar --version]) && break
done
am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
am__untar="$_am_tar -xf -"
;;
plaintar)
# Must skip GNU tar: if it does not support --format= it doesn't create
# ustar tarball either.
(tar --version) >/dev/null 2>&1 && continue
am__tar='tar chf - "$$tardir"'
am__tar_='tar chf - "$tardir"'
am__untar='tar xf -'
;;
pax)
am__tar='pax -L -x $1 -w "$$tardir"'
am__tar_='pax -L -x $1 -w "$tardir"'
am__untar='pax -r'
;;
cpio)
am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
am__untar='cpio -i -H $1 -d'
;;
none)
am__tar=false
am__tar_=false
am__untar=false
;;
esac
# If the value was cached, stop now. We just wanted to have am__tar
# and am__untar set.
test -n "${am_cv_prog_tar_$1}" && break
# tar/untar a dummy directory, and stop if the command works
rm -rf conftest.dir
mkdir conftest.dir
echo GrepMe > conftest.dir/file
AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
rm -rf conftest.dir
if test -s conftest.tar; then
AM_RUN_LOG([$am__untar <conftest.tar])
grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
fi
done
rm -rf conftest.dir
AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
AC_MSG_RESULT([$am_cv_prog_tar_$1])])
AC_SUBST([am__tar])
AC_SUBST([am__untar])
]) # _AM_PROG_TAR
m4_include([acinclude.m4])

4
bootstrap
Unescape View File

@ -0,0 +1,4 @@
#!/bin/sh
make -f Makefile.cvs
./configure --enable-debug=full

249
config.h.in
Unescape View File

@ -0,0 +1,249 @@
/* config.h.in. Generated from configure.in by autoheader. */
/* Define to 1 if you have the <Carbon/Carbon.h> header file. */
#undef HAVE_CARBON_CARBON_H
/* Define if you have the CoreAudio API */
#undef HAVE_COREAUDIO
/* Define to 1 if you have the <crt_externs.h> header file. */
#undef HAVE_CRT_EXTERNS_H
/* Defines if your system has the crypt function */
#undef HAVE_CRYPT
/* Define to 1 if you have the <dlfcn.h> header file. */
#undef HAVE_DLFCN_H
/* Define to 1 if you have the <inttypes.h> header file. */
#undef HAVE_INTTYPES_H
/* Define if you have libjpeg */
#undef HAVE_LIBJPEG
/* Define if you have libpng */
#undef HAVE_LIBPNG
/* Define if you have a working libpthread (will enable threaded code) */
#undef HAVE_LIBPTHREAD
/* Define if you have libz */
#undef HAVE_LIBZ
/* Define to 1 if you have the <memory.h> header file. */
#undef HAVE_MEMORY_H
/* Define if your system needs _NSGetEnviron to set up the environment */
#undef HAVE_NSGETENVIRON
/* Define if you have res_init */
#undef HAVE_RES_INIT
/* Define if you have the res_init prototype */
#undef HAVE_RES_INIT_PROTO
/* Define if you have a STL implementation by SGI */
#undef HAVE_SGI_STL
/* Define to 1 if you have the `snprintf' function. */
#undef HAVE_SNPRINTF
/* Define to 1 if you have the <stdint.h> header file. */
#undef HAVE_STDINT_H
/* Define to 1 if you have the <stdlib.h> header file. */
#undef HAVE_STDLIB_H
/* Define to 1 if you have the <strings.h> header file. */
#undef HAVE_STRINGS_H
/* Define to 1 if you have the <string.h> header file. */
#undef HAVE_STRING_H
/* Define if you have strlcat */
#undef HAVE_STRLCAT
/* Define if you have the strlcat prototype */
#undef HAVE_STRLCAT_PROTO
/* Define if you have strlcpy */
#undef HAVE_STRLCPY
/* Define if you have the strlcpy prototype */
#undef HAVE_STRLCPY_PROTO
/* Define to 1 if you have the <sys/bitypes.h> header file. */
#undef HAVE_SYS_BITYPES_H
/* Define to 1 if you have the <sys/stat.h> header file. */
#undef HAVE_SYS_STAT_H
/* Define to 1 if you have the <sys/types.h> header file. */
#undef HAVE_SYS_TYPES_H
/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
/* Define to 1 if you have the `vsnprintf' function. */
#undef HAVE_VSNPRINTF
/* Suffix for lib directories */
#undef KDELIBSUFF
/* kdemacros.h usable */
#undef KDEMACROS_USABLE
/* The correct header */
#undef LCMS_HEADER
/* Define to 1 if your C compiler doesn't accept -c and -o together. */
#undef NO_MINUS_C_MINUS_O
/* Name of package */
#undef PACKAGE
/* Define to the address where bug reports for this package should be sent. */
#undef PACKAGE_BUGREPORT
/* Define to the full name of this package. */
#undef PACKAGE_NAME
/* Define to the full name and version of this package. */
#undef PACKAGE_STRING
/* Define to the one symbol short name of this package. */
#undef PACKAGE_TARNAME
/* Define to the version of this package. */
#undef PACKAGE_VERSION
/* The size of `char *', as computed by sizeof. */
#undef SIZEOF_CHAR_P
/* The size of `int', as computed by sizeof. */
#undef SIZEOF_INT
/* The size of `long', as computed by sizeof. */
#undef SIZEOF_LONG
/* The size of `short', as computed by sizeof. */
#undef SIZEOF_SHORT
/* The size of `size_t', as computed by sizeof. */
#undef SIZEOF_SIZE_T
/* The size of `unsigned long', as computed by sizeof. */
#undef SIZEOF_UNSIGNED_LONG
/* Define to 1 if you have the ANSI C header files. */
#undef STDC_HEADERS
/* Version number of package */
#undef VERSION
/* Defined if compiling without arts */
#undef WITHOUT_ARTS
/*
* jpeg.h needs HAVE_BOOLEAN, when the system uses boolean in system
* headers and I'm too lazy to write a configure test as long as only
* unixware is related
*/
#ifdef _UNIXWARE
#define HAVE_BOOLEAN
#endif
/*
* AIX defines FD_SET in terms of bzero, but fails to include <strings.h>
* that defines bzero.
*/
#if defined(_AIX)
#include <strings.h>
#endif
#if defined(HAVE_NSGETENVIRON) && defined(HAVE_CRT_EXTERNS_H)
# include <sys/time.h>
# include <crt_externs.h>
# define environ (*_NSGetEnviron())
#endif
#if !defined(HAVE_RES_INIT_PROTO)
#ifdef __cplusplus
extern "C" {
#endif
int res_init(void);
#ifdef __cplusplus
}
#endif
#endif
#if !defined(HAVE_STRLCAT_PROTO)
#ifdef __cplusplus
extern "C" {
#endif
unsigned long strlcat(char*, const char*, unsigned long);
#ifdef __cplusplus
}
#endif
#endif
#if !defined(HAVE_STRLCPY_PROTO)
#ifdef __cplusplus
extern "C" {
#endif
unsigned long strlcpy(char*, const char*, unsigned long);
#ifdef __cplusplus
}
#endif
#endif
/*
* On HP-UX, the declaration of vsnprintf() is needed every time !
*/
#if !defined(HAVE_VSNPRINTF) || defined(hpux)
#if __STDC__
#include <stdarg.h>
#include <stdlib.h>
#else
#include <varargs.h>
#endif
#ifdef __cplusplus
extern "C"
#endif
int vsnprintf(char *str, size_t n, char const *fmt, va_list ap);
#ifdef __cplusplus
extern "C"
#endif
int snprintf(char *str, size_t n, char const *fmt, ...);
#endif
/* define to 1 if -fvisibility is supported */
#undef __KDE_HAVE_GCC_VISIBILITY
#if defined(__SVR4) && !defined(__svr4__)
#define __svr4__ 1
#endif
/* type to use in place of socklen_t if not defined */
#undef kde_socklen_t
/* type to use in place of socklen_t if not defined (deprecated, use
kde_socklen_t) */
#undef ksize_t

4
configure.files
Unescape View File

@ -0,0 +1,4 @@
./admin/configure.in.min
configure.in.in
./libkdcraw/configure.in.bot
./libkdcraw/configure.in.in

270
configure.in
Unescape View File

@ -0,0 +1,270 @@
dnl =======================================================
dnl FILE: ./admin/configure.in.min
dnl =======================================================
dnl This file is part of the KDE libraries/packages
dnl Copyright (C) 2001 Stephan Kulow (coolo@kde.org)
dnl This file is free software; you can redistribute it and/or
dnl modify it under the terms of the GNU Library General Public
dnl License as published by the Free Software Foundation; either
dnl version 2 of the License, or (at your option) any later version.
dnl This library is distributed in the hope that it will be useful,
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
dnl Library General Public License for more details.
dnl You should have received a copy of the GNU Library General Public License
dnl along with this library; see the file COPYING.LIB. If not, write to
dnl the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
dnl Boston, MA 02110-1301, USA.
# Original Author was Kalle@kde.org
# I lifted it in some mater. (Stephan Kulow)
# I used much code from Janos Farkas
dnl Process this file with autoconf to produce a configure script.
AC_INIT(acinclude.m4) dnl a source file from your sub dir
dnl This is so we can use kde-common
AC_CONFIG_AUX_DIR(admin)
dnl This ksh/zsh feature conflicts with `cd blah ; pwd`
unset CDPATH
dnl Checking host/target/build systems, for make, install etc.
AC_CANONICAL_SYSTEM
dnl Perform program name transformation
AC_ARG_PROGRAM
dnl Automake doc recommends to do this only here. (Janos)
AM_INIT_AUTOMAKE(libkdcraw-0.1.4, "3.5.9") dnl searches for some needed programs
KDE_SET_PREFIX
dnl generate the config header
AM_CONFIG_HEADER(config.h) dnl at the distribution this done
dnl Checks for programs.
AC_CHECK_COMPILERS
AC_ENABLE_SHARED(yes)
AC_ENABLE_STATIC(no)
KDE_PROG_LIBTOOL
dnl for NLS support. Call them in this order!
dnl WITH_NLS is for the po files
AM_KDE_WITH_NLS
KDE_USE_QT(3.2)
AC_PATH_KDE
dnl =======================================================
dnl FILE: configure.in.in
dnl =======================================================
#MIN_CONFIG(3.2)
CXXFLAGS="$CXXFLAGS $KDE_DEFAULT_CXXFLAGS"
KDE_ENABLE_HIDDEN_VISIBILITY
KDE_INIT_DOXYGEN([KEG Libraries API Reference], [Version $VERSION])
dnl =======================================================
dnl FILE: ./libkdcraw/configure.in.in
dnl =======================================================
AC_ARG_VAR(PKGCONFIGFOUND, [Path to pkg-config])
AC_CHECK_PROG(PKGCONFIGFOUND, pkg-config,[yes])
#-----------------------------------------------------------------
# Library API version
# -----------------------------------------------------------------
ABI_MAJOR=3
VERSION_INFO="3:0:0"
AC_SUBST(ABI_MAJOR)
AC_SUBST(VERSION_INFO)
KDCRAW_DIR="\$(libdir)/libkdcraw\$(ABI_MAJOR)"
AC_SUBST(KDCRAW_DIR)
# AM_PROG_CC_C_O to avoid that automake complains for it
AM_PROG_CC_C_O
# -----------------------------------------------------------------
# lcms check
# -----------------------------------------------------------------
have_lcms_header='no'
KDE_CHECK_HEADER(lcms/lcms.h,have_lcms_header='yes',,)
if test "$have_lcms_header" = 'yes'
then
AC_DEFINE(LCMS_HEADER, <lcms/lcms.h>, [The correct header])
else
# Alternative! Debian does it this way...
KDE_CHECK_HEADER(lcms.h,have_lcms_header='yes',,)
if test "$have_lcms_header" = 'yes'
then
AC_DEFINE(LCMS_HEADER, <lcms.h>, [The correct header])
fi
fi
LCMS_LIBS=''
have_lcms='no'
if test "$have_lcms_header" = 'yes'
then
saved_cflags="$CFLAGS"
saved_ldflags="$LDFLAGS"
saved_libs=$LIBS
LIBS="$LIBS -llcms"
CFLAGS="$CFLAGS $all_includes"
LDFLAGS="$LDFLAGS $all_libraries"
AC_TRY_LINK([
#define inline __inline /* gcc is in ansi mode */
#include LCMS_HEADER
#if LCMS_VERSION < 112
choke!
#endif
], [
cmsOpenProfileFromFile("foo", "r");
],
[LCMS_LIBS='-llcms'; have_lcms='yes'])
LIBS=$saved_libs
CFLAGS=$saved_cflags
LDFLAGS=$saved_ldflags
fi
if test -z "$LCMS_LIBS"; then
DO_NOT_COMPILE="$DO_NOT_COMPILE libkdcraw"
fi
AC_SUBST(LCMS_LIBS)
#AM_CONDITIONAL(compile_LIBKDCRAW, [test x$have_lcms != xyes])
AC_OUTPUT([ libkdcraw/libkdcraw.pc ])
# -----------------------------------------------------------------
# enable hidden visibility only if kde >= 3.3.2 and kdelibs has
# been compiled with visibility enabled
# -----------------------------------------------------------------
AC_LANG_PUSH(C++)
libkdcraw_kdemacros_cppflags=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $all_includes"
AC_MSG_CHECKING([if kdemacros.h is usable])
AC_COMPILE_IFELSE(
[
#include <kdemacros.h>
#include <string>
int other_func( void ) KDE_EXPORT;
int other_func( void )
{
std::string s("KDE_EXPORT");
return 0;
}
],
[ AC_MSG_RESULT([yes])
AC_DEFINE(KDEMACROS_USABLE, 1, [kdemacros.h usable]) ],
[ AC_MSG_RESULT([no]) ]
)
CPPFLAGS=$libkdcraw_kdemacros_cppflags
AC_LANG_POP(C++)
KDE_CREATE_SUBDIRSLIST
AM_CONDITIONAL(libkexiv2_SUBDIR_included, test "x$libkexiv2_SUBDIR_included" = xyes)
AM_CONDITIONAL(libkipi_SUBDIR_included, test "x$libkipi_SUBDIR_included" = xyes)
AM_CONDITIONAL(libkdcraw_SUBDIR_included, test "x$libkdcraw_SUBDIR_included" = xyes)
AM_CONDITIONAL(po_SUBDIR_included, test "x$po_SUBDIR_included" = xyes)
AC_CONFIG_FILES([ Makefile ])
AC_CONFIG_FILES([ libkdcraw/Makefile ])
AC_CONFIG_FILES([ libkdcraw/dcraw/Makefile ])
AC_CONFIG_FILES([ libkdcraw/icons/Makefile ])
AC_CONFIG_FILES([ libkdcraw/libkdcraw/Makefile ])
AC_CONFIG_FILES([ po/Makefile ])
AC_CONFIG_FILES([ po/ca/Makefile ])
AC_CONFIG_FILES([ po/da/Makefile ])
AC_CONFIG_FILES([ po/de/Makefile ])
AC_CONFIG_FILES([ po/el/Makefile ])
AC_CONFIG_FILES([ po/es/Makefile ])
AC_CONFIG_FILES([ po/et/Makefile ])
AC_CONFIG_FILES([ po/is/Makefile ])
AC_CONFIG_FILES([ po/it/Makefile ])
AC_CONFIG_FILES([ po/ja/Makefile ])
AC_CONFIG_FILES([ po/ms/Makefile ])
AC_CONFIG_FILES([ po/nds/Makefile ])
AC_CONFIG_FILES([ po/nl/Makefile ])
AC_CONFIG_FILES([ po/pa/Makefile ])
AC_CONFIG_FILES([ po/pt/Makefile ])
AC_CONFIG_FILES([ po/sk/Makefile ])
AC_CONFIG_FILES([ po/sr/Makefile ])
AC_CONFIG_FILES([ po/sr@Latn/Makefile ])
AC_CONFIG_FILES([ po/sv/Makefile ])
AC_CONFIG_FILES([ po/th/Makefile ])
AC_CONFIG_FILES([ po/uk/Makefile ])
AC_OUTPUT
dnl Put here things to be done at the very end - telling users
dnl about additional packages to install.
echo ""
echo "-- libkdcraw configure results -------------------"
if test "x$have_lcms" != "xyes"; then
echo "-- lcms found..................... NO"
echo ""
echo "libkdcraw needs Lcms library. You need to install the lcms development package."
echo "Lcms website is at http://www.littlecms.com"
echo ""
all_tests=bad
else
echo "-- lcms found..................... YES"
fi
# Check if KDE_SET_PREFIX was called, and --prefix was passed to configure
if test -n "$kde_libs_prefix" -a -n "$given_prefix"; then
# And if so, warn when they don't match
if test "$kde_libs_prefix" != "$given_prefix"; then
# And if kde doesn't know about the prefix yet
echo ":"`kde-config --path exe`":" | grep ":$given_prefix/bin/:" 2>&1 >/dev/null
if test $? -ne 0; then
echo ""
echo "Warning: you chose to install this package in $given_prefix,"
echo "but KDE was found in $kde_libs_prefix."
echo "For this to work, you will need to tell KDE about the new prefix, by ensuring"
echo "that KDEDIRS contains it, e.g. export KDEDIRS=$given_prefix:$kde_libs_prefix"
echo "Then restart KDE."
echo ""
fi
fi
fi
if test x$GXX = "xyes" -a x$kde_have_gcc_visibility = "xyes" -a x$kde_cv_val_qt_gcc_visibility_patched = "xno"; then
echo ""
echo "Your GCC supports symbol visibility, but the patch for Qt supporting visibility"
echo "was not included. Therefore, GCC symbol visibility support remains disabled."
echo ""
echo "For better performance, consider including the Qt visibility supporting patch"
echo "located at:"
echo ""
echo "http://bugs.kde.org/show_bug.cgi?id=109386"
echo ""
echo "and recompile all of Qt and KDE. Note, this is entirely optional and"
echo "everything will continue to work just fine without it."
echo ""
fi
if test "$all_tests" = "bad"; then
if test ! "$cache_file" = "/dev/null"; then
echo ""
echo "Please remove the file $cache_file after changing your setup"
echo "so that configure will find the changes next time."
echo ""
fi
else
echo ""
echo "Good - your configure finished. Start make now"
echo ""
fi

7
configure.in.in
Unescape View File

@ -0,0 +1,7 @@
#MIN_CONFIG(3.2)
CXXFLAGS="$CXXFLAGS $KDE_DEFAULT_CXXFLAGS"
KDE_ENABLE_HIDDEN_VISIBILITY
KDE_INIT_DOXYGEN([KEG Libraries API Reference], [Version $VERSION])

15
libkdcraw.lsm
Unescape View File

@ -0,0 +1,15 @@
Begin4
Title: libkdcraw
Version: 0.1.4
Entered-date: 2008-03-09
Description: An library to decode RAW picture files using dcraw command line program
Keywords: kde image raw decode dcraw digikam kipi-plugins
Author: caulier dot gilles at gmail dot com (Gilles Caulier)
marcel dot wiesweg at gmx dot de (Marcel Wiesweg)
Maintained-by:
Primary-site: http://www.kipi-plugins.org
Alternate-site:
Original-site:
Platforms:
Copying-policy: GPL
End

12
libkdcraw/Makefile.am
Unescape View File

@ -0,0 +1,12 @@
SUBDIRS = dcraw icons libkdcraw
libkdcrawpkgconfigdir = $(libdir)/pkgconfig
libkdcrawpkgconfig_DATA = libkdcraw.pc
EXTRA_DIST = libkdcraw.pc.in
# i18n translation messages
messages:
LIST=`find . -name \*.h -o -name \*.hh -o -name \*.H -o -name \*.hxx -o -name \*.hpp -o -name \*.cpp -o -name \*.cc -o -name \*.cxx -o -name \*.ecpp -o -name \*.C`; \
if test -n "$$LIST"; then \
$(XGETTEXT) $$LIST -o $(podir)/libkdcraw.pot; \
fi

19
libkdcraw/configure.in.bot
Unescape View File

@ -0,0 +1,19 @@
dnl Put here things to be done at the very end - telling users
dnl about additional packages to install.
echo ""
echo "-- libkdcraw configure results -------------------"
if test "x$have_lcms" != "xyes"; then
echo "-- lcms found..................... NO"
echo ""
echo "libkdcraw needs Lcms library. You need to install the lcms development package."
echo "Lcms website is at http://www.littlecms.com"
echo ""
all_tests=bad
else
echo "-- lcms found..................... YES"
fi

98
libkdcraw/configure.in.in
Unescape View File

@ -0,0 +1,98 @@
AC_ARG_VAR(PKGCONFIGFOUND, [Path to pkg-config])
AC_CHECK_PROG(PKGCONFIGFOUND, pkg-config,[yes])
#-----------------------------------------------------------------
# Library API version
# -----------------------------------------------------------------
ABI_MAJOR=3
VERSION_INFO="3:0:0"
AC_SUBST(ABI_MAJOR)
AC_SUBST(VERSION_INFO)
KDCRAW_DIR="\$(libdir)/libkdcraw\$(ABI_MAJOR)"
AC_SUBST(KDCRAW_DIR)
# AM_PROG_CC_C_O to avoid that automake complains for it
AM_PROG_CC_C_O
# -----------------------------------------------------------------
# lcms check
# -----------------------------------------------------------------
have_lcms_header='no'
KDE_CHECK_HEADER(lcms/lcms.h,have_lcms_header='yes',,)
if test "$have_lcms_header" = 'yes'
then
AC_DEFINE(LCMS_HEADER, <lcms/lcms.h>, [The correct header])
else
# Alternative! Debian does it this way...
KDE_CHECK_HEADER(lcms.h,have_lcms_header='yes',,)
if test "$have_lcms_header" = 'yes'
then
AC_DEFINE(LCMS_HEADER, <lcms.h>, [The correct header])
fi
fi
LCMS_LIBS=''
have_lcms='no'
if test "$have_lcms_header" = 'yes'
then
saved_cflags="$CFLAGS"
saved_ldflags="$LDFLAGS"
saved_libs=$LIBS
LIBS="$LIBS -llcms"
CFLAGS="$CFLAGS $all_includes"
LDFLAGS="$LDFLAGS $all_libraries"
AC_TRY_LINK([
#define inline __inline /* gcc is in ansi mode */
#include LCMS_HEADER
#if LCMS_VERSION < 112
choke!
#endif
], [
cmsOpenProfileFromFile("foo", "r");
],
[LCMS_LIBS='-llcms'; have_lcms='yes'])
LIBS=$saved_libs
CFLAGS=$saved_cflags
LDFLAGS=$saved_ldflags
fi
if test -z "$LCMS_LIBS"; then
DO_NOT_COMPILE="$DO_NOT_COMPILE libkdcraw"
fi
AC_SUBST(LCMS_LIBS)
#AM_CONDITIONAL(compile_LIBKDCRAW, [test x$have_lcms != xyes])
AC_OUTPUT([ libkdcraw/libkdcraw.pc ])
# -----------------------------------------------------------------
# enable hidden visibility only if kde >= 3.3.2 and kdelibs has
# been compiled with visibility enabled
# -----------------------------------------------------------------
AC_LANG_PUSH(C++)
libkdcraw_kdemacros_cppflags=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $all_includes"
AC_MSG_CHECKING([if kdemacros.h is usable])
AC_COMPILE_IFELSE(
[
#include <kdemacros.h>
#include <string>
int other_func( void ) KDE_EXPORT;
int other_func( void )
{
std::string s("KDE_EXPORT");
return 0;
}
],
[ AC_MSG_RESULT([yes])
AC_DEFINE(KDEMACROS_USABLE, 1, [kdemacros.h usable]) ],
[ AC_MSG_RESULT([no]) ]
)
CPPFLAGS=$libkdcraw_kdemacros_cppflags
AC_LANG_POP(C++)

296
libkdcraw/dcraw/CAMERALIST
Unescape View File

@ -0,0 +1,296 @@
Adobe Digital Negative (DNG)
Apple QuickTake 100
Apple QuickTake 150
Apple QuickTake 200
AVT F-080C
AVT F-145C
AVT F-201C
AVT F-510C
AVT F-810C
Canon PowerShot 600
Canon PowerShot A5
Canon PowerShot A5 Zoom
Canon PowerShot A50
Canon PowerShot A460 (CHDK hack)
Canon PowerShot A530 (CHDK hack)
Canon PowerShot A610 (CHDK hack)
Canon PowerShot A620 (CHDK hack)
Canon PowerShot A630 (CHDK hack)
Canon PowerShot A640 (CHDK hack)
Canon PowerShot A650 (CHDK hack)
Canon PowerShot A710 IS (CHDK hack)
Canon PowerShot A720 IS (CHDK hack)
Canon PowerShot Pro70
Canon PowerShot Pro90 IS
Canon PowerShot G1
Canon PowerShot G2
Canon PowerShot G3
Canon PowerShot G5
Canon PowerShot G6
Canon PowerShot G7 (CHDK hack)
Canon PowerShot G9
Canon PowerShot S2 IS (CHDK hack)
Canon PowerShot S3 IS (CHDK hack)
Canon PowerShot S5 IS (CHDK hack)
Canon PowerShot S30
Canon PowerShot S40
Canon PowerShot S45
Canon PowerShot S50
Canon PowerShot S60
Canon PowerShot S70
Canon PowerShot Pro1
Canon EOS D30
Canon EOS D60
Canon EOS 5D
Canon EOS 10D
Canon EOS 20D
Canon EOS 30D
Canon EOS 40D
Canon EOS 300D / Digital Rebel / Kiss Digital
Canon EOS 350D / Digital Rebel XT / Kiss Digital N
Canon EOS 400D / Digital Rebel XTi / Kiss Digital X
Canon EOS D2000C
Canon EOS-1D
Canon EOS-1DS
Canon EOS-1D Mark II
Canon EOS-1D Mark III
Canon EOS-1D Mark II N
Canon EOS-1Ds Mark II
Canon EOS-1Ds Mark III
Casio QV-2000UX
Casio QV-3000EX
Casio QV-3500EX
Casio QV-4000
Casio QV-5700
Casio QV-R41
Casio QV-R51
Casio QV-R61
Casio EX-S100
Casio EX-Z4
Casio EX-Z50
Casio EX-Z55
Casio Exlim Pro 505
Casio Exlim Pro 600
Casio Exlim Pro 700
Contax N Digital
Creative PC-CAM 600
Epson R-D1
Foculus 531C
Fuji FinePix E550
Fuji FinePix E900
Fuji FinePix F700
Fuji FinePix F710
Fuji FinePix F800
Fuji FinePix F810
Fuji FinePix S2Pro
Fuji FinePix S3Pro
Fuji FinePix S5Pro
Fuji FinePix S20Pro
Fuji FinePix S5000
Fuji FinePix S5100/S5500
Fuji FinePix S5200/S5600
Fuji FinePix S6000fd
Fuji FinePix S7000
Fuji FinePix S9000/S9500
Fuji FinePix S9100/S9600
Fuji IS-1
Hasselblad CFV
Hasselblad H3D
Imacon Ixpress 16-megapixel
Imacon Ixpress 22-megapixel
Imacon Ixpress 39-megapixel
ISG 2020x1520
Kodak DC20 (see Oliver Hartman's page)
Kodak DC25 (see Jun-ichiro Itoh's page)
Kodak DC40
Kodak DC50
Kodak DC120 (also try kdc2tiff)
Kodak DCS200
Kodak DCS315C
Kodak DCS330C
Kodak DCS420
Kodak DCS460
Kodak DCS460A
Kodak DCS520C
Kodak DCS560C
Kodak DCS620C
Kodak DCS620X
Kodak DCS660C
Kodak DCS660M
Kodak DCS720X
Kodak DCS760C
Kodak DCS760M
Kodak EOSDCS1
Kodak EOSDCS3B
Kodak NC2000F
Kodak ProBack
Kodak PB645C
Kodak PB645H
Kodak PB645M
Kodak DCS Pro 14n
Kodak DCS Pro 14nx
Kodak DCS Pro SLR/c
Kodak DCS Pro SLR/n
Kodak C330
Kodak P850
Kodak P880
Kodak KAI-0340
Konica KD-400Z
Konica KD-510Z
Leaf Aptus 17
Leaf Aptus 22
Leaf Aptus 54S
Leaf Aptus 65
Leaf Aptus 75
Leaf Aptus 75S
Leaf Cantare
Leaf CatchLight
Leaf CMost
Leaf DCB2
Leaf Valeo 6
Leaf Valeo 11
Leaf Valeo 17
Leaf Valeo 22
Leaf Volare
Leica Digilux 2
Leica Digilux 3
Leica D-LUX2
Leica D-LUX3
Leica V-LUX1
Logitech Fotoman Pixtura
Mamiya ZD
Micron 2010
Minolta RD175
Minolta DiMAGE 5
Minolta DiMAGE 7
Minolta DiMAGE 7i
Minolta DiMAGE 7Hi
Minolta DiMAGE A1
Minolta DiMAGE A2
Minolta DiMAGE A200
Minolta DiMAGE G400
Minolta DiMAGE G500
Minolta DiMAGE G530
Minolta DiMAGE G600
Minolta DiMAGE Z2
Minolta Alpha/Dynax/Maxxum 5D
Minolta Alpha/Dynax/Maxxum 7D
Nikon D1
Nikon D1H
Nikon D1X
Nikon D2H
Nikon D2Hs
Nikon D2X
Nikon D2Xs
Nikon D3
Nikon D40
Nikon D40X
Nikon D50
Nikon D70
Nikon D70s
Nikon D80
Nikon D100
Nikon D200
Nikon D300
Nikon E700 ("DIAG RAW" hack)
Nikon E800 ("DIAG RAW" hack)
Nikon E880 ("DIAG RAW" hack)
Nikon E900 ("DIAG RAW" hack)
Nikon E950 ("DIAG RAW" hack)
Nikon E990 ("DIAG RAW" hack)
Nikon E995 ("DIAG RAW" hack)
Nikon E2100 ("DIAG RAW" hack)
Nikon E2500 ("DIAG RAW" hack)
Nikon E3200 ("DIAG RAW" hack)
Nikon E3700 ("DIAG RAW" hack)
Nikon E4300 ("DIAG RAW" hack)
Nikon E4500 ("DIAG RAW" hack)
Nikon E5000
Nikon E5400
Nikon E5700
Nikon E8400
Nikon E8700
Nikon E8800
Nikon Coolpix S6 ("DIAG RAW" hack)
Nokia N95
Olympus C3030Z
Olympus C5050Z
Olympus C5060WZ
Olympus C7070WZ
Olympus C70Z,C7000Z
Olympus C740UZ
Olympus C770UZ
Olympus C8080WZ
Olympus E-1
Olympus E-3
Olympus E-10
Olympus E-20
Olympus E-300
Olympus E-330
Olympus E-400
Olympus E-410
Olympus E-500
Olympus E-510
Olympus SP310
Olympus SP320
Olympus SP350
Olympus SP500UZ
Olympus SP510UZ
Olympus SP550UZ
Olympus SP560UZ
Panasonic DMC-FZ8
Panasonic DMC-FZ18
Panasonic DMC-FZ30
Panasonic DMC-FZ50
Panasonic DMC-L1
Panasonic DMC-L10
Panasonic DMC-LC1
Panasonic DMC-LX1
Panasonic DMC-LX2
Pentax *ist D
Pentax *ist DL
Pentax *ist DL2
Pentax *ist DS
Pentax *ist DS2
Pentax K10D
Pentax K20D
Pentax K100D
Pentax K100D Super
Pentax Optio S
Pentax Optio S4
Pentax Optio 33WR
Pentax Optio 750Z
Phase One LightPhase
Phase One H 10
Phase One H 20
Phase One H 25
Phase One P 20
Phase One P 25
Phase One P 30
Phase One P 45
Pixelink A782
Polaroid x530
Rollei d530flex
RoverShot 3320af
Samsung GX-1S
Samsung GX-10
Sarnoff 4096x5440
Sigma SD9
Sigma SD10
Sigma SD14
Sinar 3072x2048
Sinar 4080x4080
Sinar 4080x5440
Sinar STI format
SMaL Ultra-Pocket 3
SMaL Ultra-Pocket 4
SMaL Ultra-Pocket 5
Sony DSC-F828
Sony DSC-R1
Sony DSC-V3
Sony DSLR-A100
Sony DSLR-A200
Sony DSLR-A350
Sony DSLR-A700
Sony XCD-SX910CR
STV680 VGA

38
libkdcraw/dcraw/Makefile.am
Unescape View File

@ -0,0 +1,38 @@
# Requires by dcraw.c implementation.
KDE_OPTIONS = nofinal
METASOURCES = AUTO
#-- dcraw binary -------------------------------------------------
# libkdcraw use a dedicaced dcraw binary program to run. This is mandatory
# since dcraw author have broken the command line options
# compatibility with the 8.x serie.
# Also, dcraw is not available like a library.
# The dcraw.c source code is just a copy of official implementation, but
# this one have been completly tested with libkdcraw core.
# Note: dcraw project page is http://cybercom.net/~dcoffin
bin_PROGRAMS = kdcraw
bindir = $(KDCRAW_DIR)
# The manual page of binary program. (Don't install manpage of a library
# internal helper app
#man_MANS = kdcraw.1
# This line is require to prevent broken compilation with -std=iso9899:1990 gcc option.
# In fact, dcraw.c use lcms.h witch use the "inline" keyword witch do not exist in pure C
# implementation. The -Dinline option please compiler to see inline with this option.
# Note : using -std-c99 instead -std=iso9899:1990 is not possible because some compiler
# do not support it.
# Thanks to Andras Mantia for this tip.
kdcraw_CFLAGS = -Dinline= -w $(all_includes)
kdcraw_SOURCES = dcraw.c
kdcraw_LDFLAGS = $(all_libraries) $(LIBJPEG) $(LCMS_LIBS)
# Install Camera list supported by dcraw.
cameralistdir = $(KDCRAW_DIR)
cameralist_DATA = CAMERALIST

64
libkdcraw/dcraw/README
Unescape View File

@ -0,0 +1,64 @@
DCRAW BACKPORT GUIDELINE.
-----------------------------
1/ Backport "dcraw.c" source code.
The dcraw.c file must be updated periodically to support new RAW files format.
The current implementation can be found at this url:
http://cybercom.net/~dcoffin/dcraw/dcraw.c
Following lines need to be changed in dcraw.c :
==> With "-i -v" options to report Make and Model identification properly using separate lines
on the console a printf need to be added like this:
int CLASS main (int argc, char **argv)
{
...
/* NOTE: digiKam Fix : separate output of "make" and "model" information.
printf (_("Camera: %s %s\n"), make, model); */
printf (_("Camera: %s\n"), make);
printf (_("Model: %s\n"), model);
...
}
These information are used by KDcraw class to give some metadata with Exiv2 unsupported RAW file formats.
No others part in dcraw.c source must be changed. This is not the goal to libkdcraw to re-implement RAW file decoding algorithms.
Rename the old "dcraw.c" from svn to "dcraw-old.c" before to update it.
2/ Backport "dcraw.1" man page.
wget http://www.cybercom.net/~dcoffin/dcraw/dcraw.1
Just copying the new dcraw man page from Dave Coffin web site. Renaming it to "kdcraw.1". Nothing must be changed in this file.
3/ Check new options.
Look into "int CLASS main (int argc, char **argv)" method from new "dcraw.c".
Compare it to "dcraw-old.c", about:
-the new options provided to decoding RAW file pictures. The option list is given on the console when kdcraw is invoked from command line without arguments. Look into the detailed description of all options using man page. The DcrawSettingsWidget, RawDecodingSettings, and KDcraw class need to be updated accordingly, especially the KDcraw::loadFromDcraw() method.
-the new information provided by -i -v command line options. The KDcraw::rawFileIdentify() method and the DcrawInfoContainer need to be updated accordingly.
4/ Regression tests.
Recompile libkdcraw, Raw Converter kipi-plugin, and digiKam. All must work fine to use RAW file decoding into digiKam image editor and RAW Converter tool.
5/ Clean up.
Remove the "dcraw-old.c" file. Not need to archive it in svn.
6/ Update the internal dcraw version number returned by KDcraw::DcrawBinary::InternalVersion() method
(Check the "#define VERSION ..." string from dcraw.c).
7/ On DCRaw project page (http://cybercom.net/~dcoffin/dcraw), extract the current camera list
supported and update the file "CAMERALIST".

8482
libkdcraw/dcraw/dcraw.c
View File

File diff suppressed because it is too large Load Diff

267
libkdcraw/dcraw/kdcraw.1
Unescape View File

@ -0,0 +1,267 @@
.\"
.\" Man page for dcraw
.\"
.\" Copyright (c) 2008 by David Coffin
.\"
.\" You may distribute without restriction.
.\"
.\" David Coffin
.\" dcoffin a cybercom o net
.\" http://www.cybercom.net/~dcoffin
.\"
.TH dcraw 1 "February 6, 2008"
.LO 1
.SH NAME
dcraw - command-line decoder for raw digital photos
.SH SYNOPSIS
.B dcraw
[\fIOPTION\fR]... [\fIFILE\fR]...
.SH DESCRIPTION
.B dcraw
decodes raw photos, displays metadata, and extracts thumbnails.
.SH GENERAL OPTIONS
.TP
.B -v
Print verbose messages, not just warnings and errors.
.TP
.B -c
Write decoded images or thumbnails to standard output.
.TP
.B -e
Extract the camera-generated thumbnail, not the raw image.
You'll get either a JPEG or a PPM file, depending on the camera.
.TP
.B -z
Change the access and modification times of an AVI, JPEG, TIFF or raw
file to when the photo was taken, assuming that the camera clock
was set to Universal Time.
.TP
.B -i
Identify files but don't decode them.
Exit status is 0 if
.B dcraw
can decode the last file, 1 if it can't.
.B -i -v
shows metadata.
.TP
.B ""
.B dcraw
cannot decode JPEG files!!
.SH REPAIR OPTIONS
.TP
.B -P deadpixels.txt
Read the dead pixel list from this file instead of ".badpixels".
See
.B FILES
for a description of the format.
.TP
.B -K darkframe.pgm
Subtract a dark frame from the raw data. To generate a
dark frame, shoot a raw photo with no light and do
.BR dcraw\ -D\ -4\ -j\ -t\ 0 .
.TP
.B -k darkness
When shadows appear foggy, you need to raise the darkness level.
To measure this, apply
.B pamsumm -mean
to the dark frame generated above.
.TP
.B -S saturation
When highlights appear pink, you need to lower the saturation level.
To measure this, take a picture of something shiny and do
.B dcraw -D -4 -j -c
photo.raw
.B | pamsumm -max
.TP
.B ""
The default darkness and saturation are usually correct.
.TP
.B -n noise_threshold
Use wavelets to erase noise while preserving real detail.
The best threshold should be somewhere between 100 and 1000.
.TP
.B -C red_mag blue_mag
Enlarge the raw red and blue layers by the given factors,
typically 0.999 to 1.001, to correct chromatic aberration.
.TP
.B -H 0
Clip all highlights to solid white (default).
.TP
.B -H 1
Leave highlights unclipped in various shades of pink.
.TP
.B -H 2
Blend clipped and unclipped values together for a gradual fade
to white.
.TP
.B -H 3+
Reconstruct highlights. Low numbers favor whites; high numbers
favor colors. Try
.B -H 5
as a compromise. If that's not good enough, do
.BR -H\ 9 ,
cut out the non-white highlights, and paste them into an image
generated with
.BR -H\ 3 .
.SH COLOR OPTIONS
By default,
.B dcraw
uses a fixed white balance based on a color chart illuminated
with a standard D65 lamp.
.TP
.B -w
Use the white balance specified by the camera.
If this is not found, print a warning and use another method.
.TP
.B -a
Calculate the white balance by averaging the entire image.
.TP
.B -A left top width height
Calculate the white balance by averaging a rectangular area.
First do
.B dcraw\ -j\ -t\ 0
and select an area of neutral grey color.
.TP
.B -r mul0 mul1 mul2 mul3
Specify your own raw white balance.
These multipliers can be cut and pasted from the output of
.BR dcraw\ -v .
.TP
.BR +M " or " -M
Use (or don't use) any color matrix from the camera metadata.
The default is
.B +M
if
.B -w
is set,
.B -M
otherwise.
This option only affects Olympus, Leaf, and Phase One cameras.
.TP
.B -o [0-5]
Select the output colorspace when the
.B -p
option is not used:
.B \t0
\ \ Raw color (unique to each camera)
.br
.B \t1
\ \ sRGB D65 (default)
.br
.B \t2
\ \ Adobe RGB (1998) D65
.br
.B \t3
\ \ Wide Gamut RGB D65
.br
.B \t4
\ \ Kodak ProPhoto RGB D65
.br
.B \t5
\ \ XYZ
.TP
.BR -p\ camera.icm \ [\ -o\ output.icm \ ]
Use ICC profiles to define the camera's raw colorspace and the
desired output colorspace (sRGB by default).
.TP
.B -p embed
Use the ICC profile embedded in the raw photo.
.SH INTERPOLATION OPTIONS
.TP
.B -d
Show the raw data as a grayscale image with no interpolation.
Good for photographing black-and-white documents.
.TP
.B -D
Same as
.BR -d ,
but totally raw (no color scaling).
.TP
.B -h
Output a half-size color image. Twice as fast as
.BR -q\ 0 .
.TP
.B -q 0
Use high-speed, low-quality bilinear interpolation.
.TP
.B -q 1
Use Variable Number of Gradients (VNG) interpolation.
.TP
.B -q 2
Use Patterned Pixel Grouping (PPG) interpolation.
.TP
.B -q 3
Use Adaptive Homogeneity-Directed (AHD) interpolation.
.TP
.B -f
Interpolate RGB as four colors. Use this if the output shows
false 2x2 meshes with VNG or mazes with AHD.
.TP
.B -m number_of_passes
After interpolation, clean up color artifacts by repeatedly
applying a 3x3 median filter to the R-G and B-G channels.
.SH OUTPUT OPTIONS
By default,
.B dcraw
writes PGM/PPM/PAM with 8-bit samples, a BT.709 gamma curve,
a histogram-based white level, and no metadata.
.TP
.B -W
Use a fixed white level, ignoring the image histogram.
.TP
.B -b brightness
Divide the white level by this number, 1.0 by default.
.TP
.B -4
Write 16-bit linear samples (fixed white level, no gamma).
.TP
.B -T
Write TIFF with metadata instead of PGM/PPM/PAM.
.TP
.B -t [0-7,90,180,270]
Flip the output image. By default,
.B dcraw
applies the flip specified by the camera.
.B -t 0
disables all flipping.
.TP
.B -j
For Fuji\ Super\ CCD cameras, show the image tilted 45 degrees.
For cameras with non-square pixels, do not stretch the image to
its correct aspect ratio. In any case, this option guarantees
that each output pixel corresponds to one raw pixel.
.TP
.BR "-s [0..N-1]" " or " "-s all"
If a file contains N raw images, choose one or "all" to decode.
For example, Fuji\ Super\ CCD\ SR cameras generate a second image
underexposed four stops to show detail in the highlights.
.SH FILES
.TP
\:./.badpixels, ../.badpixels, ../../.badpixels, ...
List of your camera's dead pixels, so that
.B dcraw
can interpolate around them. Each line specifies the column,
row, and UNIX time of death for one pixel. For example:
.sp 1
.nf
962 91 1028350000 # died between August 1 and 4, 2002
1285 1067 0 # don't know when this pixel died
.fi
.sp 1
These coordinates are before any cropping or rotation, so use
.B dcraw -j -t 0
to locate dead pixels.
.SH "SEE ALSO"
.BR pgm (5),
.BR ppm (5),
.BR pam (5),
.BR pamsumm (1),
.BR pnmgamma (1),
.BR pnmtotiff (1),
.BR pnmtopng (1),
.BR gphoto2 (1),
.BR cjpeg (1),
.BR djpeg (1)
.SH AUTHOR
Written by David Coffin, dcoffin a cybercom o net

1
libkdcraw/icons/Makefile.am
Unescape View File

@ -0,0 +1 @@
KDE_ICON = kdcraw

BIN
libkdcraw/icons/hi128-app-kdcraw.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 15 KiB

BIN
libkdcraw/icons/hi32-app-kdcraw.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.4 KiB

BIN
libkdcraw/icons/hi48-app-kdcraw.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.2 KiB

BIN
libkdcraw/icons/hi64-app-kdcraw.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.7 KiB

213
libkdcraw/libkdcraw.kdevelop
Unescape View File

@ -0,0 +1,213 @@
<?xml version = '1.0'?>
<kdevelop>
<general>
<author>Caulier Gilles</author>
<email>caulier dot gilles at kdemail dot net</email>
<version>$VERSION$</version>
<projectmanagement>KDevAutoProject</projectmanagement>
<primarylanguage>C</primarylanguage>
<ignoreparts/>
<projectdirectory>.</projectdirectory>
<absoluteprojectpath>false</absoluteprojectpath>
<description></description>
<versioncontrol></versioncontrol>
</general>
<kdevautoproject>
<general>
<activetarget>src/libkdcraw</activetarget>
<useconfiguration>default</useconfiguration>
</general>
<run>
<mainprogram>/home/gilles/Documents/Devel/SVN/trunk/extragear/libs/libkdcraw/dcraw/kdcraw</mainprogram>
<directoryradio>custom</directoryradio>
<customdirectory>/home/gilles/Documents/Devel/SVN/trunk/extragear/libs/libkdcraw/dcraw/</customdirectory>
<programargs>-v -5 ./photo.mrw</programargs>
<terminal>false</terminal>
<autocompile>true</autocompile>
<envvars/>
</run>
<configurations>
<optimized>
<builddir>optimized</builddir>
<ccompiler>GccOptions</ccompiler>
<cxxcompiler>GppOptions</cxxcompiler>
<f77compiler>G77Options</f77compiler>
<cflags>-O2 -g0</cflags>
</optimized>
<debug>
<configargs>--enable-debug=full</configargs>
<builddir/>
<ccompiler>kdevgccoptions</ccompiler>
<cxxcompiler>kdevgppoptions</cxxcompiler>
<f77compiler>kdevpgf77options</f77compiler>
<cflags>-O0 -g3</cflags>
<envvars/>
<topsourcedir>../</topsourcedir>
<cppflags/>
<ldflags/>
<ccompilerbinary/>
<cxxcompilerbinary/>
<f77compilerbinary/>
<cxxflags/>
<f77flags/>
</debug>
<default>
<envvars/>
<configargs>--enable-debug=full</configargs>
<builddir></builddir>
<topsourcedir>../</topsourcedir>
<cppflags></cppflags>
<ldflags></ldflags>
<ccompiler>kdevgccoptions</ccompiler>
<cxxcompiler>kdevgppoptions</cxxcompiler>
<f77compiler>kdevpgf77options</f77compiler>
<ccompilerbinary></ccompilerbinary>
<cxxcompilerbinary></cxxcompilerbinary>
<f77compilerbinary></f77compilerbinary>
<cflags></cflags>
<cxxflags></cxxflags>
<f77flags></f77flags>
</default>
</configurations>
<make>
<envvars>
<envvar value="1" name="WANT_AUTOCONF_2_5" />
<envvar value="1" name="WANT_AUTOMAKE_1_6" />
</envvars>
<abortonerror>true</abortonerror>
<runmultiplejobs>false</runmultiplejobs>
<numberofjobs>1</numberofjobs>
<dontact>false</dontact>
<makebin></makebin>
<prio>0</prio>
</make>
</kdevautoproject>
<kdevdebugger>
<general>
<dbgshell>libtool</dbgshell>
<programargs>-v -5 ./photo.mrw</programargs>
<gdbpath></gdbpath>
<configGdbScript></configGdbScript>
<runShellScript></runShellScript>
<runGdbScript></runGdbScript>
<breakonloadinglibs>true</breakonloadinglibs>
<separatetty>false</separatetty>
<floatingtoolbar>false</floatingtoolbar>
</general>
<display>
<staticmembers>false</staticmembers>
<demanglenames>true</demanglenames>
<outputradix>10</outputradix>
</display>
</kdevdebugger>
<kdevdoctreeview>
<ignoretocs>
<toc>ada</toc>
<toc>ada_bugs_gcc</toc>
<toc>bash</toc>
<toc>bash_bugs</toc>
<toc>clanlib</toc>
<toc>fortran_bugs_gcc</toc>
<toc>gnome1</toc>
<toc>gnustep</toc>
<toc>gtk</toc>
<toc>gtk_bugs</toc>
<toc>haskell</toc>
<toc>haskell_bugs_ghc</toc>
<toc>java_bugs_gcc</toc>
<toc>java_bugs_sun</toc>
<toc>kde2book</toc>
<toc>libstdc++</toc>
<toc>opengl</toc>
<toc>pascal_bugs_fp</toc>
<toc>php</toc>
<toc>php_bugs</toc>
<toc>perl</toc>
<toc>perl_bugs</toc>
<toc>python</toc>
<toc>python_bugs</toc>
<toc>qt-kdev3</toc>
<toc>ruby</toc>
<toc>ruby_bugs</toc>
<toc>sdl</toc>
<toc>stl</toc>
<toc>sw</toc>
<toc>w3c-dom-level2-html</toc>
<toc>w3c-svg</toc>
<toc>w3c-uaag10</toc>
<toc>wxwidgets_bugs</toc>
</ignoretocs>
<ignoreqt_xml>
<toc>Guide to the Qt Translation Tools</toc>
<toc>Qt Assistant Manual</toc>
<toc>Qt Designer Manual</toc>
<toc>Qt Reference Documentation</toc>
<toc>qmake User Guide</toc>
</ignoreqt_xml>
<ignoredoxygen>
<toc>KDE Libraries (Doxygen)</toc>
</ignoredoxygen>
</kdevdoctreeview>
<kdevfilecreate>
<filetypes/>
<useglobaltypes>
<type ext="c" />
<type ext="h" />
</useglobaltypes>
</kdevfilecreate>
<kdevcppsupport>
<references/>
<codecompletion>
<includeGlobalFunctions>true</includeGlobalFunctions>
<includeTypes>true</includeTypes>
<includeEnums>true</includeEnums>
<includeTypedefs>false</includeTypedefs>
<automaticCodeCompletion>true</automaticCodeCompletion>
<automaticArgumentsHint>true</automaticArgumentsHint>
<automaticHeaderCompletion>true</automaticHeaderCompletion>
<codeCompletionDelay>250</codeCompletionDelay>
<argumentsHintDelay>400</argumentsHintDelay>
<headerCompletionDelay>250</headerCompletionDelay>
</codecompletion>
<qt>
<used>false</used>
<version>3</version>
<root>/usr/lib/qt3/</root>
</qt>
<creategettersetter>
<prefixGet></prefixGet>
<prefixSet>set</prefixSet>
<prefixVariable>m_,_</prefixVariable>
<parameterName>theValue</parameterName>
<inlineGet>true</inlineGet>
<inlineSet>true</inlineSet>
</creategettersetter>
</kdevcppsupport>
<kdevfileview>
<groups>
<hidenonprojectfiles>false</hidenonprojectfiles>
<hidenonlocation>false</hidenonlocation>
</groups>
<tree>
<hidepatterns>*.o,*.lo,CVS</hidepatterns>
<hidenonprojectfiles>false</hidenonprojectfiles>
</tree>
</kdevfileview>
<cppsupportpart>
<filetemplates>
<interfacesuffix>.h</interfacesuffix>
<implementationsuffix>.cpp</implementationsuffix>
</filetemplates>
</cppsupportpart>
<kdevdocumentation>
<projectdoc>
<docsystem></docsystem>
<docurl></docurl>
<usermanualurl></usermanualurl>
</projectdoc>
</kdevdocumentation>
<ctagspart>
<customArguments></customArguments>
<customTagfilePath></customTagfilePath>
</ctagspart>
</kdevelop>

12
libkdcraw/libkdcraw.pc.in
Unescape View File

@ -0,0 +1,12 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: libkdcraw
Description: KDE interface library for dcraw command line program to decode RAW picture files
URL: http://www.kipi-plugins.org
Requires:
Version: 0.1.4
Libs: -L${libdir} -lkdcraw
Cflags: -I${includedir}

18
libkdcraw/libkdcraw/Makefile.am
Unescape View File

@ -0,0 +1,18 @@
METASOURCES = AUTO
KDE_CXXFLAGS = -DKDCRAW_DIR='"$(KDCRAW_DIR)"'
INCLUDES= $(all_includes)
lib_LTLIBRARIES = libkdcraw.la
libkdcraw_la_SOURCES = dcrawbinary.cpp kdcraw.cpp dcrawsettingswidget.cpp
libkdcraw_la_LDFLAGS = $(all_libraries) $(KDE_RPATH) -version-info $(VERSION_INFO) -no-undefined
libkdcraw_la_LIBADD = $(LIB_KDEUI) $(LIB_KDECORE) $(LIB_QT)
libkdcrawinclude_HEADERS = rawdecodingsettings.h kdcraw.h dcrawbinary.h dcrawsettingswidget.h \
dcrawinfocontainer.h rawfiles.h libkdcraw_export.h version.h
libkdcrawincludedir = $(includedir)/libkdcraw

208
libkdcraw/libkdcraw/dcrawbinary.cpp
Unescape View File

@ -0,0 +1,208 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2006-04-13
* Description : detection of dcraw binary program
*
* Copyright (C) 2006-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
* Copyright (C) 2006-2008 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
// Qt includes.
#include <qfileinfo.h>
// KDE includes
#include <kprocess.h>
#include <kmessagebox.h>
#include <kapplication.h>
#include <klocale.h>
#include <kglobal.h>
#include <kaboutdata.h>
// Local includes
#include "rawfiles.h"
#include "dcrawbinary.h"
#include "dcrawbinary.moc"
namespace KDcrawIface
{
class DcrawBinaryPriv
{
public:
DcrawBinaryPriv()
{
available = false;
version = QString::null;
}
bool available;
QString version;
};
DcrawBinary *DcrawBinary::m_instance = 0;
DcrawBinary::DcrawBinary()
: QObject()
{
d = new DcrawBinaryPriv;
}
DcrawBinary::~DcrawBinary()
{
m_instance = 0;
delete d;
}
DcrawBinary *DcrawBinary::instance()
{
if (!m_instance)
m_instance = new DcrawBinary;
return m_instance;
}
void DcrawBinary::cleanUp()
{
delete m_instance;
}
void DcrawBinary::checkSystem()
{
KProcess process;
process.clearArguments();
process << path();
connect(&process, SIGNAL(receivedStdout(KProcess *, char*, int)),
this, SLOT(slotReadStdoutFromDcraw(KProcess*, char*, int)));
d->available = process.start(KProcess::Block, KProcess::Stdout);
}
void DcrawBinary::slotReadStdoutFromDcraw(KProcess*, char* buffer, int buflen)
{
// The dcraw output looks like this : Raw photo decoder "dcraw" v8.54...
QString dcrawHeader("Raw photo decoder \"dcraw\" v");
QString dcrawOut = QString::fromLocal8Bit(buffer, buflen);
QString firstLine = dcrawOut.section('\n', 1, 1);
if (firstLine.startsWith(dcrawHeader))
{
d->version = firstLine.remove(0, dcrawHeader.length());
qDebug("Found dcraw version: %s", version().ascii());
}
}
const char *DcrawBinary::path()
{
return KDCRAW_DIR "/kdcraw";
}
const char *DcrawBinary::rawFiles()
{
return raw_file_extentions;
}
bool DcrawBinary::isAvailable() const
{
return d->available;
}
QString DcrawBinary::version() const
{
return d->version;
}
QString DcrawBinary::internalVersion()
{
// The version of dcraw include with this library.
// Look into dcraw/dcraw.c implementation.
return QString("8.83");
}
bool DcrawBinary::versionIsRight() const
{
if (d->version.isNull() || !isAvailable())
return false;
if (d->version.toFloat() >= internalVersion().toFloat())
return true;
return false;
}
void DcrawBinary::checkReport()
{
QString appName = KGlobal::instance()->aboutData()->programName();
if (!isAvailable())
{
KMessageBox::information(
kapp->activeWindow(),
i18n("<qt><p>Unable to find the <b>%1</b> executable:<br>"
"This binary program is required to support Raw file formats. "
"You can continue, but you will not be able "
"to handle any Raw images. "
"Please check the installation of libkdcraw package on your computer.")
.arg(path()),
QString(),
i18n("Do not show this message again"),
KMessageBox::Notify | KMessageBox::AllowLink);
return;
}
if (!versionIsRight())
{
KMessageBox::information(
kapp->activeWindow(),
i18n("<qt><p><b>%1</b> executable is not up to date:<br> "
"The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. "
"You can continue, but you will not be able "
"to handle any Raw images. "
"Please check the installation of libkdcraw package on your computer.")
.arg(path())
.arg(version()),
QString(),
i18n("Do not show this message again"),
KMessageBox::Notify | KMessageBox::AllowLink);
}
}
QStringList DcrawBinary::supportedCamera()
{
QFileInfo fi(path());
QFile file(fi.dirPath() + QString("/CAMERALIST"));
if ( !file.open(IO_ReadOnly) )
return QStringList();
QByteArray data;
data.resize(file.size());
QDataStream stream( &file );
stream.readRawBytes(data.data(), data.size());
file.close();
QString tmp(data);
QStringList list = QStringList::split('\n', tmp);
return list;
}
} // namespace KDcrawIface

99
libkdcraw/libkdcraw/dcrawbinary.h
Unescape View File

@ -0,0 +1,99 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2006-04-13
* Description : detection of dcraw binary program
*
* Copyright (C) 2006-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
* Copyright (C) 2006-2008 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
#ifndef DCRAW_BINARY_H
#define DCRAW_BINARY_H
// Qt includes.
#include <qstring.h>
#include <qobject.h>
// Local Includes.
#include "libkdcraw_export.h"
class KProcess;
namespace KDcrawIface
{
class DcrawBinaryPriv;
class LIBKDCRAW_EXPORT DcrawBinary : public QObject
{
Q_OBJECT
public:
static DcrawBinary *instance();
static void cleanUp();
/** Return the RAW decoding program name. */
static const char *path();
/** Return the string of all RAW file type mime supported. */
static const char *rawFiles();
/** Return the RAW decoding program version included in this library. */
static QString internalVersion();
/** Return 'true' if RAW decoding program have be found in your system. */
bool isAvailable() const;
/** Return the RAW decoding program version found in your system. */
QString version() const;
/** Return 'true' if RAW decoding program version found in your system is
the same than the version provided by this library. */
bool versionIsRight() const;
/** Check your system to see if RAW decoding program is available. */
void checkSystem();
/** Report any errors on a message box if RAW decoding program detection
on your system failed. */
void checkReport();
/** Provide a list of supported RAW Camera name. */
QStringList supportedCamera();
private slots:
void slotReadStdoutFromDcraw(KProcess*, char*, int);
private:
DcrawBinary();
~DcrawBinary();
private:
static DcrawBinary *m_instance;
DcrawBinaryPriv *d;
};
} // namespace KDcrawIface
#endif // DCRAW_BINARY_H

135
libkdcraw/libkdcraw/dcrawinfocontainer.h
Unescape View File

@ -0,0 +1,135 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2007-05-02
* Description : RAW file identification information container
*
* Copyright (C) 2007-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
#ifndef DCRAW_INFO_CONTAINER_H
#define DCRAW_INFO_CONTAINER_H
// QT includes.
#include <qstring.h>
#include <qdatetime.h>
#include <qsize.h>
// Local Includes.
#include "libkdcraw_export.h"
namespace KDcrawIface
{
class LIBKDCRAW_EXPORT DcrawInfoContainer
{
public:
/** Standard constructor */
DcrawInfoContainer()
{
sensitivity = -1;
exposureTime = -1.0;
aperture = -1.0;
focalLength = -1.0;
pixelAspectRatio = 1.0; // Default value. This can be unavailable (depending of camera model).
rawColors = -1;
hasIccProfile = false;
isDecodable = false;
hasSecondaryPixel = false;
daylightMult[0] = 0.0;
daylightMult[1] = 0.0;
daylightMult[2] = 0.0;
cameraMult[0] = 0.0;
cameraMult[1] = 0.0;
cameraMult[2] = 0.0;
cameraMult[3] = 0.0;
};
/** Standard destructor */
virtual ~DcrawInfoContainer(){}
/** return 'true' if container is empty, else 'false' */
bool isEmpty()
{
if ( make.isEmpty() &&
model.isEmpty() &&
filterPattern.isEmpty() &&
DNGVersion.isEmpty() &&
exposureTime == -1.0 &&
aperture == -1.0 &&
focalLength == -1.0 &&
pixelAspectRatio == 1.0 &&
sensitivity == -1 &&
rawColors == -1 &&
!dateTime.isValid() &&
!imageSize.isValid() )
return true;
else
return false;
};
/** True if camera sensor use a secondary pixel. */
bool hasSecondaryPixel;
/** True if RAW file include an ICC color profile. */
bool hasIccProfile;
/** True is RAW file is decodable by dcraw. */
bool isDecodable;
/** The number of RAW colors. */
int rawColors;
/** The sensitivity in ISO used by camera to take the picture. */
long sensitivity;
/** ==> 1/exposureTime = exposure time in seconds. */
float exposureTime;
/** ==> Aperture value in APEX. */
float aperture;
/** ==> Focal Length value in mm. */
float focalLength;
/** The pixel Aspect Ratio if != 1.0. NOTE: if == 1.0, dcraw do not show this value. */
float pixelAspectRatio;
/** White color balance settings. */
double daylightMult[3];
/** Camera multipliers used for White Balance adjustements */
double cameraMult[4];
/** The camera maker. */
QString make;
/** The camera model. */
QString model;
/** The artist name who have picture owner. */
QString owner;
/** The demosaising filter pattern. */
QString filterPattern;
/** The DNG version. NOTE: its only show with DNG RAW files. */
QString DNGVersion;
/** Date & time when have been taken the picture. */
QDateTime dateTime;
/** The image dimensions in pixels. */
QSize imageSize;
};
} // namespace KDcrawIface
#endif /* DCRAW_INFO_CONTAINER_H */

835
libkdcraw/libkdcraw/dcrawsettingswidget.cpp
Unescape View File

@ -0,0 +1,835 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2006-09-13
* Description : dcraw settings widgets
*
* Copyright (C) 2006-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
* Copyright (C) 2006-2008 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
* Copyright (C) 2007-2008 by Guillaume Castagnino <casta at xwing dot info>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
// Qt includes.
#include <qcheckbox.h>
#include <qcombobox.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qwhatsthis.h>
#include <qstring.h>
#include <qtooltip.h>
#include <qtabbar.h>
// KDE includes.
#include <kapplication.h>
#include <kdialog.h>
#include <klocale.h>
#include <knuminput.h>
#include <kurllabel.h>
// Local includes.
#include "dcrawbinary.h"
#include "dcrawsettingswidget.h"
#include "dcrawsettingswidget.moc"
namespace KDcrawIface
{
class DcrawSettingsWidgetPriv
{
public:
DcrawSettingsWidgetPriv()
{
sixteenBitsImage = 0;
fourColorCheckBox = 0;
brightnessLabel = 0;
brightnessSpinBox = 0;
blackPointCheckBox = 0;
blackPointSpinBox = 0;
whiteBalanceComboBox = 0;
whiteBalanceLabel = 0;
customWhiteBalanceSpinBox = 0;
customWhiteBalanceLabel = 0;
customWhiteBalanceGreenSpinBox = 0;
customWhiteBalanceGreenLabel = 0;
unclipColorLabel = 0;
dontStretchPixelsCheckBox = 0;
RAWQualityComboBox = 0;
RAWQualityLabel = 0;
enableNoiseReduction = 0;
NRThresholdSpinBox = 0;
NRThresholdLabel = 0;
enableCACorrection = 0;
caRedMultSpinBox = 0;
caBlueMultSpinBox = 0;
caRedMultLabel = 0;
caBlueMultLabel = 0;
unclipColorComboBox = 0;
reconstructLabel = 0;
reconstructSpinBox = 0;
outputColorSpaceLabel = 0;
outputColorSpaceComboBox = 0;
stdSettings = 0;
advSettings = 0;
}
QWidget *stdSettings;
QWidget *advSettings;
QLabel *whiteBalanceLabel;
QLabel *customWhiteBalanceLabel;
QLabel *customWhiteBalanceGreenLabel;
QLabel *brightnessLabel;
QLabel *RAWQualityLabel;
QLabel *NRThresholdLabel;
QLabel *caRedMultLabel;
QLabel *caBlueMultLabel;
QLabel *unclipColorLabel;
QLabel *reconstructLabel;
QLabel *outputColorSpaceLabel;
QComboBox *whiteBalanceComboBox;
QComboBox *RAWQualityComboBox;
QComboBox *unclipColorComboBox;
QComboBox *outputColorSpaceComboBox;
QCheckBox *blackPointCheckBox;
QCheckBox *sixteenBitsImage;
QCheckBox *fourColorCheckBox;
QCheckBox *customWhiteBalanceCheckBox;
QCheckBox *dontStretchPixelsCheckBox;
QCheckBox *enableNoiseReduction;
QCheckBox *enableCACorrection;
KIntNumInput *customWhiteBalanceSpinBox;
KIntNumInput *reconstructSpinBox;
KIntNumInput *blackPointSpinBox;
KIntNumInput *NRThresholdSpinBox;
KDoubleNumInput *customWhiteBalanceGreenSpinBox;
KDoubleNumInput *caRedMultSpinBox;
KDoubleNumInput *caBlueMultSpinBox;
KDoubleNumInput *brightnessSpinBox;
};
DcrawSettingsWidget::DcrawSettingsWidget(QWidget *parent, bool sixteenBitsOption,
bool outputColorSpaceOption, bool showAdvancedOptions)
: KTabWidget(parent)
{
d = new DcrawSettingsWidgetPriv;
setMargin(0);
d->stdSettings = new QWidget(this);
QGridLayout* settingsBoxLayout = new QGridLayout(d->stdSettings, 11, 2, KDialog::spacingHint());
// ---------------------------------------------------------------
int line = 0;
d->sixteenBitsImage = new QCheckBox(i18n("16 bits color depth"), d->stdSettings);
QWhatsThis::add( d->sixteenBitsImage, i18n("<p>If enabled, all RAW files will be decoded in 16-bit "
"color depth using a linear gamma curve. To prevent dark "
"picture rendering in the editor, it is recommended to use "
"Color Management in this mode.<p>"
"If disabled, all RAW files will be decoded in 8-bit "
"color depth with a BT.709 gamma curve and a 99th-percentile "
"white point. This mode is faster than 16-bit decoding."));
settingsBoxLayout->addMultiCellWidget(d->sixteenBitsImage, 0, 0, 0, 0);
if (sixteenBitsOption)
{
d->sixteenBitsImage->show();
line = 1;
}
else
{
d->sixteenBitsImage->hide();
}
// ---------------------------------------------------------------
d->fourColorCheckBox = new QCheckBox(i18n("Interpolate RGB as four colors"), d->stdSettings);
QWhatsThis::add(d->fourColorCheckBox, i18n("<p><b>Interpolate RGB as four colors</b><p>"
"The default is to assume that all green "
"pixels are the same. If even-row green "
"pixels are more sensitive to ultraviolet light "
"than odd-row this difference causes a mesh "
"pattern in the output; using this option solves "
"this problem with minimal loss of detail.<p>"
"To resume, this option blurs the image "
"a little, but it eliminates false 2x2 mesh patterns "
"with VNG quality method or mazes with AHD quality method."));
settingsBoxLayout->addMultiCellWidget(d->fourColorCheckBox, line, line, 0, 0);
line++;
// ---------------------------------------------------------------
KURLLabel *dcrawVersion = new KURLLabel("http://cybercom.net/~dcoffin/dcraw", i18n("dcraw %1")
.arg(DcrawBinary::internalVersion()), d->stdSettings);
dcrawVersion->setAlignment(Qt::AlignRight);
QToolTip::add(dcrawVersion, i18n("Visit dcraw project website"));
settingsBoxLayout->addMultiCellWidget(dcrawVersion, 0, 0, 2, 2);
// ---------------------------------------------------------------
d->whiteBalanceLabel = new QLabel(i18n("White Balance:"), d->stdSettings);
d->whiteBalanceComboBox = new QComboBox( false, d->stdSettings );
d->whiteBalanceComboBox->insertItem( i18n("Default D65 White Balance"), 0 );
d->whiteBalanceComboBox->insertItem( i18n("Camera White Balance"), 1 );
d->whiteBalanceComboBox->insertItem( i18n("Automatic White Balance"), 2 );
d->whiteBalanceComboBox->insertItem( i18n("Manual White balance"), 3 );
QWhatsThis::add( d->whiteBalanceComboBox, i18n("<p><b>White Balance</b><p>"
"Configure the raw white balance :<p>"
"<b>Default D65 White Balance</b>: Use a standard daylight D65 white balance (dcraw defaults)<p>"
"<b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance<p>"
"<b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image<p>"
"<b>Manual White balance</b>: Set a custom temperature and green level values"));
settingsBoxLayout->addMultiCellWidget(d->whiteBalanceLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->whiteBalanceComboBox, line, line, 1, 2);
line++;
d->customWhiteBalanceSpinBox = new KIntNumInput(d->stdSettings);
d->customWhiteBalanceSpinBox->setRange(2000, 12000, 10, true);
d->customWhiteBalanceLabel = new QLabel(i18n("Temperature (K):"), d->stdSettings);
QWhatsThis::add( d->customWhiteBalanceSpinBox, i18n("<p><b>Temperature</b><p>"
"Set here the color temperature."));
settingsBoxLayout->addMultiCellWidget(d->customWhiteBalanceLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->customWhiteBalanceSpinBox, line, line, 1, 2);
line++;
d->customWhiteBalanceGreenSpinBox = new KDoubleNumInput(d->stdSettings);
d->customWhiteBalanceGreenSpinBox->setPrecision(2);
d->customWhiteBalanceGreenSpinBox->setRange(0.2, 2.5, 0.01, true);
d->customWhiteBalanceGreenLabel = new QLabel(i18n("Green:"), d->stdSettings);
QWhatsThis::add( d->customWhiteBalanceGreenSpinBox, i18n("<p>Set here the green component to set magenta color "
"cast removal level."));
settingsBoxLayout->addMultiCellWidget(d->customWhiteBalanceGreenLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->customWhiteBalanceGreenSpinBox, line, line, 1, 2);
line++;
// ---------------------------------------------------------------
d->unclipColorLabel = new QLabel(i18n("Highlights:"), d->stdSettings);
d->unclipColorComboBox = new QComboBox( false, d->stdSettings );
d->unclipColorComboBox->insertItem( i18n("Solid white"), 0 );
d->unclipColorComboBox->insertItem( i18n("Unclip"), 1 );
d->unclipColorComboBox->insertItem( i18n("Blend"), 2 );
d->unclipColorComboBox->insertItem( i18n("Rebuild"), 3 );
QWhatsThis::add( d->unclipColorComboBox, i18n("<p><b>Highlights</b><p>"
"Select here the highlight clipping method:<p>"
"<b>Solid white</b>: clip all highlights to solid white<p>"
"<b>Unclip</b>: leave highlights unclipped in various "
"shades of pink<p>"
"<b>Blend</b>:Blend clipped and unclipped values together for a gradual fade to white<p>"
"<b>Rebuild</b>: reconstruct highlights using a "
"level value"));
settingsBoxLayout->addMultiCellWidget(d->unclipColorLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->unclipColorComboBox, line, line, 1, 2);
line++;
d->reconstructLabel = new QLabel(i18n("Level:"), d->stdSettings);
d->reconstructSpinBox = new KIntNumInput(d->stdSettings);
d->reconstructSpinBox->setRange(0, 6, 1, true);
QWhatsThis::add(d->reconstructSpinBox, i18n("<p><b>Level</b><p>"
"Specify the reconstruct highlight level. "
"Low values favor whites and high values favor colors."));
settingsBoxLayout->addMultiCellWidget(d->reconstructLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->reconstructSpinBox, line, line, 1, 2);
line++;
// ---------------------------------------------------------------
d->brightnessLabel = new QLabel(i18n("Brightness:"), d->stdSettings);
d->brightnessSpinBox = new KDoubleNumInput(d->stdSettings);
d->brightnessSpinBox->setPrecision(2);
d->brightnessSpinBox->setRange(0.0, 10.0, 0.01, true);
QWhatsThis::add(d->brightnessSpinBox, i18n("<p><b>Brighness</b><p>"
"Specify the brightness level of output image."
"The default value is 1.0 (works in 8-bit mode only).<p>"));
settingsBoxLayout->addMultiCellWidget(d->brightnessLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->brightnessSpinBox, line, line, 1, 2);
line++;
// ---------------------------------------------------------------
d->RAWQualityLabel = new QLabel(i18n("Quality (interpolation):"), d->stdSettings);
d->RAWQualityComboBox = new QComboBox( false, d->stdSettings );
d->RAWQualityComboBox->insertItem( i18n("Bilinear"), 0 );
d->RAWQualityComboBox->insertItem( i18n("VNG"), 1 );
d->RAWQualityComboBox->insertItem( i18n("PPG"), 2 );
d->RAWQualityComboBox->insertItem( i18n("AHD"), 3 );
QWhatsThis::add( d->RAWQualityComboBox, i18n("<p><b>Quality</b><p>"
"Select here the demosaicing RAW images decoding "
"interpolation method. A demosaicing algorithm is a digital image process used to "
"interpolate a complete image from the partial raw data received from the color-filtered "
"image sensor internal to many digital cameras in form of a matrix of colored pixels. "
"Also known as CFA interpolation or color reconstruction, another common spelling "
"is demosaicing. There are 3 methods to demosaicing RAW images:<p>"
"<b>Bilinear</b>: use high-speed but low-quality bilinear "
"interpolation (default - for slow computer). In this method, "
"the red value of a non-red pixel is computed as the average of "
"the adjacent red pixels, and similar for blue and green.<p>"
"<b>VNG</b>: use Variable Number of Gradients interpolation. "
"This method computes gradients near the pixel of interest and uses "
"the lower gradients (representing smoother and more similar parts "
"of the image) to make an estimate.<p>"
"<b>PPG</b>: use Patterned Pixel Grouping interpolation. "
"Pixel Grouping uses assumptions about natural scenery in making estimates. "
"It has fewer color artifacts on natural images than the Variable Number of "
"Gradients method.<p>"
"<b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. "
"This method selects the direction of interpolation so as to "
"maximize a homogeneity metric, thus typically minimizing color artifacts.<p>"));
settingsBoxLayout->addMultiCellWidget(d->RAWQualityLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->RAWQualityComboBox, line, line, 1, 2);
line++;
// ---------------------------------------------------------------
d->enableNoiseReduction = new QCheckBox(i18n("Enable noise reduction"), d->stdSettings);
QWhatsThis::add( d->enableNoiseReduction, i18n("<p><b>Enable Noise Reduction</b><p>"
"Use wavelets to erase noise while preserving real detail.<p>"));
settingsBoxLayout->addMultiCellWidget(d->enableNoiseReduction, line, line, 0, 2);
line++;
d->NRThresholdSpinBox = new KIntNumInput(d->stdSettings);
d->NRThresholdSpinBox->setRange(10, 1000, 1, true);
d->NRThresholdLabel = new QLabel(i18n("Threshold:"), d->stdSettings);
QWhatsThis::add( d->NRThresholdSpinBox, i18n("<p><b>Threshold</b><p>"
"Set here the noise reduction threshold value to use."));
settingsBoxLayout->addMultiCellWidget(d->NRThresholdLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->NRThresholdSpinBox, line, line, 1, 2);
line++;
// ---------------------------------------------------------------
d->enableCACorrection = new QCheckBox(i18n("Enable Chromatic Aberration correction"), d->stdSettings);
QWhatsThis::add( d->enableCACorrection, i18n("<p><b>Enable Chromatic Aberration correction</b><p>"
"Enlarge the raw red and blue layers by the given factors, "
"typically 0.999 to 1.001, to correct chromatic aberration.<p>"));
settingsBoxLayout->addMultiCellWidget(d->enableCACorrection, line, line, 0, 2);
line++;
d->caRedMultLabel = new QLabel(i18n("Red multiplier:"), d->stdSettings);
d->caRedMultSpinBox = new KDoubleNumInput(d->stdSettings);
d->caRedMultSpinBox->setPrecision(5);
d->caRedMultSpinBox->setRange(0.00001, 2.0, 0.001, true);
QWhatsThis::add( d->caRedMultSpinBox, i18n("<p><b>Red multiplier</b><p>"
"Set here the magnification factor of the red layer"));
d->caBlueMultLabel = new QLabel(i18n("Blue multiplier:"), d->stdSettings);
d->caBlueMultSpinBox = new KDoubleNumInput(d->stdSettings);
d->caBlueMultSpinBox->setPrecision(5);
d->caBlueMultSpinBox->setRange(0.00001, 2.0, 0.001, true);
QWhatsThis::add( d->caBlueMultSpinBox, i18n("<p><b>Blue multiplier</b><p>"
"Set here the magnification factor of the blue layer"));
settingsBoxLayout->addMultiCellWidget(d->caRedMultLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->caRedMultSpinBox, line, line, 1, 2);
line++;
settingsBoxLayout->addMultiCellWidget(d->caBlueMultLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->caBlueMultSpinBox, line, line, 1, 2);
line++;
// ---------------------------------------------------------------
d->outputColorSpaceLabel = new QLabel(i18n("Color space:"), d->stdSettings);
d->outputColorSpaceComboBox = new QComboBox( false, d->stdSettings );
d->outputColorSpaceComboBox->insertItem( i18n("Raw (linear)"), 0 );
d->outputColorSpaceComboBox->insertItem( i18n("sRGB"), 1 );
d->outputColorSpaceComboBox->insertItem( i18n("Adobe RGB"), 2 );
d->outputColorSpaceComboBox->insertItem( i18n("Wide Gamut"), 3 );
d->outputColorSpaceComboBox->insertItem( i18n("Pro-Photo"), 4 );
QWhatsThis::add( d->outputColorSpaceComboBox, i18n("<p><b>Color space</b><p>"
"Select here the output color space used to decode RAW data.<p>"
"<b>Raw (linear)</b>: in this mode, no output color space is used "
"during RAW decoding.<p>"
"<b>sRGB</b>: this is a RGB color space, created "
"cooperatively by Hewlett-Packard and Microsoft. It is the "
"best choice for images destined for the Web and portrait photography.<p>"
"<b>Adobe RGB</b>: this color space is an extended RGB color space, developed by "
"Adobe. It is used for photography applications such as advertising "
"and fine art.<p>"
"<b>Wide Gamut</b>: this color space is an expanded version of the "
"Adobe RGB color space.<p>"
"<b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with "
"photographic outputs in mind."));
settingsBoxLayout->addMultiCellWidget(d->outputColorSpaceLabel, line, line, 0, 0);
settingsBoxLayout->addMultiCellWidget(d->outputColorSpaceComboBox, line, line, 1, 2);
if (outputColorSpaceOption)
{
d->outputColorSpaceLabel->show();
d->outputColorSpaceComboBox->show();
}
else
{
d->outputColorSpaceLabel->hide();
d->outputColorSpaceComboBox->hide();
}
insertTab(d->stdSettings, i18n("Standard"));
// ---------------------------------------------------------------
d->advSettings = new QWidget(this);
QGridLayout* settingsBoxLayout2 = new QGridLayout(d->advSettings, 7, 2, KDialog::spacingHint());
d->dontStretchPixelsCheckBox = new QCheckBox(i18n("Do not stretch or rotate pixels"), d->advSettings);
QWhatsThis::add( d->dontStretchPixelsCheckBox, i18n("<p><b>Do not stretch or rotate pixels</b><p>"
"For Fuji Super CCD cameras, show the image tilted 45 "
"degrees. For cameras with non-square pixels, do not "
"stretch the image to its correct aspect ratio. In any "
"case, this option guarantees that each output pixel "
"corresponds to one RAW pixel.<p>"));
settingsBoxLayout2->addMultiCellWidget(d->dontStretchPixelsCheckBox, 0, 0, 0, 2);
// ---------------------------------------------------------------
d->blackPointCheckBox = new QCheckBox(i18n("Black point"), d->advSettings);
QWhatsThis::add( d->blackPointCheckBox, i18n("<p><b>Black point</b><p>"
"Use a specific black point value to decode RAW pictures. "
"If you set this option to off, the Black Point value will be "
"automatically computed.<p>"));
d->blackPointSpinBox = new KIntNumInput(d->advSettings);
d->blackPointSpinBox->setRange(0, 1000, 1, true);
QWhatsThis::add(d->blackPointSpinBox, i18n("<p><b>Black point value</b><p>"
"Specify specific black point value of the output image.<p>"));
settingsBoxLayout2->addMultiCellWidget(d->blackPointCheckBox, 1, 1, 0, 0);
settingsBoxLayout2->addMultiCellWidget(d->blackPointSpinBox, 1, 1, 1, 2);
// ---------------------------------------------------------------
settingsBoxLayout2->setRowStretch(7, 10);
insertTab(d->advSettings, i18n("Advanced"));
if (!showAdvancedOptions)
{
removePage(d->advSettings);
setTabBarHidden(true);
}
// ---------------------------------------------------------------
connect(d->unclipColorComboBox, SIGNAL(activated(int)),
this, SLOT(slotUnclipColorActivated(int)));
connect(d->whiteBalanceComboBox, SIGNAL(activated(int)),
this, SLOT(slotWhiteBalanceToggled(int)));
connect(d->enableNoiseReduction, SIGNAL(toggled(bool)),
this, SLOT(slotNoiseReductionToggled(bool)));
connect(d->enableCACorrection, SIGNAL(toggled(bool)),
this, SLOT(slotCACorrectionToggled(bool)));
connect(d->blackPointCheckBox, SIGNAL(toggled(bool)),
d->blackPointSpinBox, SLOT(setEnabled(bool)));
connect(d->sixteenBitsImage, SIGNAL(toggled(bool)),
this, SLOT(slotsixteenBitsImageToggled(bool)));
connect(dcrawVersion, SIGNAL(leftClickedURL(const QString&)),
this, SLOT(processDcrawURL(const QString&)));
}
DcrawSettingsWidget::~DcrawSettingsWidget()
{
delete d;
}
void DcrawSettingsWidget::processDcrawURL(const QString& url)
{
KApplication::kApplication()->invokeBrowser(url);
}
void DcrawSettingsWidget::setDefaultSettings()
{
setWhiteBalance(RawDecodingSettings::CAMERA);
setCustomWhiteBalance(6500);
setCustomWhiteBalanceGreen(1.0);
setFourColor(false);
setUnclipColor(0);
setDontStretchPixels(false);
setNoiseReduction(false);
setUseCACorrection(false);
setcaRedMultiplier(1.0);
setcaBlueMultiplier(1.0);
setBrightness(1.0);
setUseBlackPoint(false);
setBlackPoint(0);
setNRThreshold(100);
setQuality(RawDecodingSettings::BILINEAR);
setOutputColorSpace(RawDecodingSettings::SRGB);
}
void DcrawSettingsWidget::slotsixteenBitsImageToggled(bool b)
{
d->brightnessLabel->setDisabled(b);
d->brightnessSpinBox->setDisabled(b);
emit signalSixteenBitsImageToggled(d->sixteenBitsImage->isChecked());
}
void DcrawSettingsWidget::slotWhiteBalanceToggled(int v)
{
if (v == 3)
{
d->customWhiteBalanceSpinBox->setEnabled(true);
d->customWhiteBalanceGreenSpinBox->setEnabled(true);
d->customWhiteBalanceLabel->setEnabled(true);
d->customWhiteBalanceGreenLabel->setEnabled(true);
}
else
{
d->customWhiteBalanceSpinBox->setEnabled(false);
d->customWhiteBalanceGreenSpinBox->setEnabled(false);
d->customWhiteBalanceLabel->setEnabled(false);
d->customWhiteBalanceGreenLabel->setEnabled(false);
}
}
void DcrawSettingsWidget::slotUnclipColorActivated(int v)
{
if (v == 3) // Reconstruct Highlight method
{
d->reconstructLabel->setEnabled(true);
d->reconstructSpinBox->setEnabled(true);
}
else
{
d->reconstructLabel->setEnabled(false);
d->reconstructSpinBox->setEnabled(false);
}
}
void DcrawSettingsWidget::slotNoiseReductionToggled(bool b)
{
d->NRThresholdSpinBox->setEnabled(b);
d->NRThresholdLabel->setEnabled(b);
}
void DcrawSettingsWidget::slotCACorrectionToggled(bool b)
{
d->caRedMultSpinBox->setEnabled(b);
d->caBlueMultSpinBox->setEnabled(b);
d->caRedMultLabel->setEnabled(b);
d->caBlueMultLabel->setEnabled(b);
}
// ---------------------------------------------------------------
bool DcrawSettingsWidget::sixteenBits()
{
return d->sixteenBitsImage->isChecked();
}
void DcrawSettingsWidget::setSixteenBits(bool b)
{
d->sixteenBitsImage->setChecked(b);
}
// ---------------------------------------------------------------
RawDecodingSettings::WhiteBalance DcrawSettingsWidget::whiteBalance()
{
switch(d->whiteBalanceComboBox->currentItem())
{
case 1:
return RawDecodingSettings::CAMERA;
break;
case 2:
return RawDecodingSettings::AUTO;
break;
case 3:
return RawDecodingSettings::CUSTOM;
break;
default:
return RawDecodingSettings::NONE;
break;
}
}
void DcrawSettingsWidget::setWhiteBalance(RawDecodingSettings::WhiteBalance v)
{
switch(v)
{
case RawDecodingSettings::CAMERA:
d->whiteBalanceComboBox->setCurrentItem(1);
break;
case RawDecodingSettings::AUTO:
d->whiteBalanceComboBox->setCurrentItem(2);
break;
case RawDecodingSettings::CUSTOM:
d->whiteBalanceComboBox->setCurrentItem(3);
break;
default:
d->whiteBalanceComboBox->setCurrentItem(0);
break;
}
slotWhiteBalanceToggled(d->whiteBalanceComboBox->currentItem());
}
// ---------------------------------------------------------------
int DcrawSettingsWidget::customWhiteBalance()
{
return d->customWhiteBalanceSpinBox->value();
}
void DcrawSettingsWidget::setCustomWhiteBalance(int v)
{
d->customWhiteBalanceSpinBox->setValue(v);
}
// ---------------------------------------------------------------
double DcrawSettingsWidget::customWhiteBalanceGreen()
{
return d->customWhiteBalanceGreenSpinBox->value();
}
void DcrawSettingsWidget::setCustomWhiteBalanceGreen(double v)
{
d->customWhiteBalanceGreenSpinBox->setValue(v);
}
// ---------------------------------------------------------------
bool DcrawSettingsWidget::useFourColor()
{
return d->fourColorCheckBox->isChecked();
}
void DcrawSettingsWidget::setFourColor(bool b)
{
d->fourColorCheckBox->setChecked(b);
}
// ---------------------------------------------------------------
int DcrawSettingsWidget::unclipColor()
{
switch(d->unclipColorComboBox->currentItem())
{
case 0:
return 0;
break;
case 1:
return 1;
break;
case 2:
return 2;
break;
default: // Reconstruct Highlight method
return d->reconstructSpinBox->value()+3;
break;
}
}
void DcrawSettingsWidget::setUnclipColor(int v)
{
switch(v)
{
case 0:
d->unclipColorComboBox->setCurrentItem(0);
break;
case 1:
d->unclipColorComboBox->setCurrentItem(1);
break;
case 2:
d->unclipColorComboBox->setCurrentItem(2);
break;
default: // Reconstruct Highlight method
d->unclipColorComboBox->setCurrentItem(3);
d->reconstructSpinBox->setValue(v-3);
break;
}
slotUnclipColorActivated(d->unclipColorComboBox->currentItem());
}
// ---------------------------------------------------------------
bool DcrawSettingsWidget::useDontStretchPixels()
{
return d->dontStretchPixelsCheckBox->isChecked();
}
void DcrawSettingsWidget::setDontStretchPixels(bool b)
{
d->dontStretchPixelsCheckBox->setChecked(b);
}
// ---------------------------------------------------------------
double DcrawSettingsWidget::brightness()
{
return d->brightnessSpinBox->value();
}
void DcrawSettingsWidget::setBrightness(double b)
{
d->brightnessSpinBox->setValue(b);
}
// ---------------------------------------------------------------
bool DcrawSettingsWidget::useBlackPoint()
{
return d->blackPointCheckBox->isChecked();
}
void DcrawSettingsWidget::setUseBlackPoint(bool b)
{
d->blackPointCheckBox->setChecked(b);
d->blackPointSpinBox->setEnabled(b);
}
// ---------------------------------------------------------------
int DcrawSettingsWidget::blackPoint()
{
return d->blackPointSpinBox->value();
}
void DcrawSettingsWidget::setBlackPoint(int b)
{
d->blackPointSpinBox->setValue(b);
}
// ---------------------------------------------------------------
RawDecodingSettings::DecodingQuality DcrawSettingsWidget::quality()
{
switch(d->RAWQualityComboBox->currentItem())
{
case 1:
return RawDecodingSettings::VNG;
break;
case 2:
return RawDecodingSettings::PPG;
break;
case 3:
return RawDecodingSettings::AHD;
break;
default:
return RawDecodingSettings::BILINEAR;
break;
}
}
void DcrawSettingsWidget::setQuality(RawDecodingSettings::DecodingQuality q)
{
switch(q)
{
case RawDecodingSettings::VNG:
d->RAWQualityComboBox->setCurrentItem(1);
break;
case RawDecodingSettings::PPG:
d->RAWQualityComboBox->setCurrentItem(2);
break;
case RawDecodingSettings::AHD:
d->RAWQualityComboBox->setCurrentItem(3);
break;
default:
d->RAWQualityComboBox->setCurrentItem(0);
break;
}
}
// ---------------------------------------------------------------
RawDecodingSettings::OutputColorSpace DcrawSettingsWidget::outputColorSpace()
{
return (RawDecodingSettings::OutputColorSpace)(d->outputColorSpaceComboBox->currentItem());
}
void DcrawSettingsWidget::setOutputColorSpace(RawDecodingSettings::OutputColorSpace c)
{
d->outputColorSpaceComboBox->setCurrentItem((int)c);
}
// ---------------------------------------------------------------
bool DcrawSettingsWidget::useNoiseReduction()
{
return d->enableNoiseReduction->isChecked();
}
void DcrawSettingsWidget::setNoiseReduction(bool b)
{
d->enableNoiseReduction->setChecked(b);
slotNoiseReductionToggled(b);
}
// ---------------------------------------------------------------
int DcrawSettingsWidget::NRThreshold()
{
return d->NRThresholdSpinBox->value();
}
void DcrawSettingsWidget::setNRThreshold(int b)
{
d->NRThresholdSpinBox->setValue(b);
}
// ---------------------------------------------------------------
bool DcrawSettingsWidget::useCACorrection()
{
return d->enableCACorrection->isChecked();
}
void DcrawSettingsWidget::setUseCACorrection(bool b)
{
d->enableCACorrection->setChecked(b);
slotCACorrectionToggled(b);
}
// ---------------------------------------------------------------
double DcrawSettingsWidget::caRedMultiplier()
{
return d->caRedMultSpinBox->value();
}
void DcrawSettingsWidget::setcaRedMultiplier(double b)
{
d->caRedMultSpinBox->setValue(b);
}
// ---------------------------------------------------------------
double DcrawSettingsWidget::caBlueMultiplier()
{
return d->caBlueMultSpinBox->value();
}
void DcrawSettingsWidget::setcaBlueMultiplier(double b)
{
d->caBlueMultSpinBox->setValue(b);
}
} // NameSpace KDcrawIface

114
libkdcraw/libkdcraw/dcrawsettingswidget.h
Unescape View File

@ -0,0 +1,114 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2006-09-13
* Description : dcraw settings widgets
*
* Copyright (C) 2006-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
* Copyright (C) 2006-2008 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
* Copyright (C) 2007-2008 by Guillaume Castagnino <casta at xwing dot info>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
#ifndef DCRAW_SETTINGS_WIDGET_H
#define DCRAW_SETTINGS_WIDGET_H
// KDE includes.
#include <ktabwidget.h>
// Local Includes.
#include "libkdcraw_export.h"
#include "rawdecodingsettings.h"
namespace KDcrawIface
{
class DcrawSettingsWidgetPriv;
class LIBKDCRAW_EXPORT DcrawSettingsWidget : public KTabWidget
{
Q_OBJECT
public:
DcrawSettingsWidget(QWidget *parent,
bool sixteenBitsOption=false,
bool outputColorSpaceOption=true,
bool showAdvancedOptions=false);
virtual ~DcrawSettingsWidget();
bool sixteenBits();
int customWhiteBalance();
double customWhiteBalanceGreen();
bool useFourColor();
bool useDontStretchPixels();
bool useNoiseReduction();
bool useCACorrection();
bool useBlackPoint();
int unclipColor();
double brightness();
int blackPoint();
int NRThreshold();
double caRedMultiplier();
double caBlueMultiplier();
RawDecodingSettings::WhiteBalance whiteBalance();
RawDecodingSettings::DecodingQuality quality();
RawDecodingSettings::OutputColorSpace outputColorSpace();
void setSixteenBits(bool b);
void setCameraWB(bool b);
void setWhiteBalance(RawDecodingSettings::WhiteBalance v);
void setCustomWhiteBalance(int v);
void setCustomWhiteBalanceGreen(double v);
void setFourColor(bool b);
void setDontStretchPixels(bool b);
void setNoiseReduction(bool b);
void setUseCACorrection(bool b);
void setUseBlackPoint(bool b);
void setUnclipColor(int v);
void setBrightness(double b);
void setBlackPoint(int b);
void setNRThreshold(int b);
void setcaRedMultiplier(double b);
void setcaBlueMultiplier(double b);
void setQuality(RawDecodingSettings::DecodingQuality q);
void setOutputColorSpace(RawDecodingSettings::OutputColorSpace c);
void setDefaultSettings();
signals:
void signalSixteenBitsImageToggled(bool);
private slots:
void slotWhiteBalanceToggled(int);
void slotsixteenBitsImageToggled(bool);
void slotUnclipColorActivated(int);
void slotNoiseReductionToggled(bool);
void slotCACorrectionToggled(bool);
void processDcrawURL(const QString&);
private:
DcrawSettingsWidgetPriv* d;
};
} // NameSpace KDcrawIface
#endif /* DCRAW_SETTINGS_WIDGET_H */

965
libkdcraw/libkdcraw/kdcraw.cpp
Unescape View File

@ -0,0 +1,965 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2006-12-09
* Description : a tread-safe dcraw program interface
*
* Copyright (C) 2006-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
* Copyright (C) 2006-2008 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
* Copyright (C) 2007-2008 by Guillaume Castagnino <casta at xwing dot info>
*
* NOTE: Do not use kdDebug() in this implementation because
* it will be multithreaded. Use qDebug() instead.
* See B.K.O #133026 for details.
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
extern "C"
{
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
}
// C++ includes.
#include <cstdlib>
#include <cstdio>
#include <cmath>
// Qt Includes.
#include <qfile.h>
#include <qtimer.h>
#include <qcstring.h>
#include <qfileinfo.h>
#include <qapplication.h>
#include <qmutex.h>
#include <qwaitcondition.h>
// KDE includes.
#include <kprocess.h>
#include <kstandarddirs.h>
// Local includes.
#include "version.h"
#include "dcrawbinary.h"
#include "kdcraw.h"
#include "kdcraw.moc"
namespace KDcrawIface
{
class KDcrawPriv
{
public:
KDcrawPriv()
{
running = false;
normalExit = false;
process = 0;
queryTimer = 0;
data = 0;
width = 0;
height = 0;
rgbmax = 0;
dataPos = 0;
}
bool running;
bool normalExit;
uchar *data;
int dataPos;
int width;
int height;
int rgbmax;
QString filePath;
QMutex mutex;
QWaitCondition condVar;
QTimer *queryTimer;
KProcess *process;
};
KDcraw::KDcraw()
{
d = new KDcrawPriv;
m_cancel = false;
}
KDcraw::~KDcraw()
{
cancel();
delete d;
}
QString KDcraw::version()
{
return QString(kdcraw_version);
}
void KDcraw::cancel()
{
m_cancel = true;
}
bool KDcraw::loadDcrawPreview(QImage& image, const QString& path)
{
// In first, try to extrcat the embedded JPEG preview. Very fast.
bool ret = loadEmbeddedPreview(image, path);
if (ret) return true;
// In second, decode and half size of RAW picture. More slow.
return (loadHalfPreview(image, path));
}
bool KDcraw::loadEmbeddedPreview(QImage& image, const QString& path)
{
FILE *f=NULL;
QByteArray imgData;
const int MAX_IPC_SIZE = (1024*32);
char buffer[MAX_IPC_SIZE];
QFile file;
Q_LONG len;
QCString command;
QFileInfo fileInfo(path);
QString rawFilesExt(KDcrawIface::DcrawBinary::instance()->rawFiles());
QString ext = fileInfo.extension(false).upper();
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.upper().contains(ext))
return false;
// Try to extract embedded thumbnail using dcraw with options:
// -c : write to stdout
// -e : Extract the camera-generated thumbnail, not the raw image (JPEG or a PPM file).
// Note : this code require at least dcraw version 8.x
command = DcrawBinary::path();
command += " -c -e ";
command += QFile::encodeName( KProcess::quote( path ) );
qDebug("Running RAW decoding command: %s", (const char*)command);
f = popen( command.data(), "r" );
if ( f == NULL )
return false;
file.open( IO_ReadOnly, f );
while ((len = file.readBlock(buffer, MAX_IPC_SIZE)) != 0)
{
if ( len == -1 )
{
file.close();
return false;
}
else
{
int oldSize = imgData.size();
imgData.resize( imgData.size() + len );
memcpy(imgData.data()+oldSize, buffer, len);
}
}
file.close();
pclose( f );
if ( !imgData.isEmpty() )
{
if (image.loadFromData( imgData ))
{
qDebug("Using embedded RAW preview extraction");
return true;
}
}
return false;
}
bool KDcraw::loadHalfPreview(QImage& image, const QString& path)
{
FILE *f=NULL;
QByteArray imgData;
const int MAX_IPC_SIZE = (1024*32);
char buffer[MAX_IPC_SIZE];
QFile file;
Q_LONG len;
QCString command;
QFileInfo fileInfo(path);
QString rawFilesExt(KDcrawIface::DcrawBinary::instance()->rawFiles());
QString ext = fileInfo.extension(false).upper();
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.upper().contains(ext))
return false;
// Try to use simple RAW extraction method in 8 bits ppm output.
// -c : write to stdout
// -h : Half-size color image (3x faster than -q)
// -a : Use automatic white balance
// -w : Use camera white balance, if possible
f=NULL;
command = DcrawBinary::path();
command += " -c -h -w -a ";
command += QFile::encodeName( KProcess::quote( path ) );
qDebug("Running RAW decoding command: %s", (const char*)command);
f = popen( command.data(), "r" );
if ( f == NULL )
return false;
file.open( IO_ReadOnly, f );
while ((len = file.readBlock(buffer, MAX_IPC_SIZE)) != 0)
{
if ( len == -1 )
{
file.close();
return false;
}
else
{
int oldSize = imgData.size();
imgData.resize( imgData.size() + len );
memcpy(imgData.data()+oldSize, buffer, len);
}
}
file.close();
pclose( f );
if ( !imgData.isEmpty() )
{
if (image.loadFromData( imgData ))
{
qDebug("Using reduced RAW picture extraction");
return true;
}
}
return false;
}
bool KDcraw::rawFileIdentify(DcrawInfoContainer& identify, const QString& path)
{
FILE *f=NULL;
QByteArray txtData;
const int MAX_IPC_SIZE = (1024*32);
char buffer[MAX_IPC_SIZE];
QFile file;
Q_LONG len;
QCString command;
QFileInfo fileInfo(path);
QString rawFilesExt(KDcrawIface::DcrawBinary::instance()->rawFiles());
QString ext = fileInfo.extension(false).upper();
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.upper().contains(ext))
return false;
// Try to get camera maker/model using dcraw with options:
// -i : identify files without decoding them.
// -v : verbose mode.
command = DcrawBinary::path();
command += " -i -v ";
command += QFile::encodeName( KProcess::quote( path ) );
qDebug("Running RAW decoding command: %s", (const char*)command);
f = popen( command.data(), "r" );
if ( f == NULL )
{
identify = DcrawInfoContainer();
return false;
}
file.open( IO_ReadOnly, f );
while ((len = file.readBlock(buffer, MAX_IPC_SIZE)) != 0)
{
if ( len == -1 )
{
identify = DcrawInfoContainer();
return false;
}
else
{
int oldSize = txtData.size();
txtData.resize( txtData.size() + len );
memcpy(txtData.data()+oldSize, buffer, len);
}
}
file.close();
pclose( f );
QString dcrawInfo(txtData);
if ( dcrawInfo.isEmpty() )
{
identify = DcrawInfoContainer();
return false;
}
int pos;
// Extract Time Stamp.
QString timeStampHeader("Timestamp: ");
pos = dcrawInfo.find(timeStampHeader);
if (pos != -1)
{
QString timeStamp = dcrawInfo.mid(pos).section('\n', 0, 0);
timeStamp.remove(0, timeStampHeader.length());
identify.dateTime = QDateTime::fromString(timeStamp);
}
// Extract Camera Maker.
QString makeHeader("Camera: ");
pos = dcrawInfo.find(makeHeader);
if (pos != -1)
{
QString make = dcrawInfo.mid(pos).section('\n', 0, 0);
make.remove(0, makeHeader.length());
identify.make = make;
}
// Extract Camera Model.
QString modelHeader("Model: ");
pos = dcrawInfo.find(modelHeader);
if (pos != -1)
{
QString model = dcrawInfo.mid(pos).section('\n', 0, 0);
model.remove(0, modelHeader.length());
identify.model = model;
}
// Extract Picture Owner.
QString ownerHeader("Owner: ");
pos = dcrawInfo.find(ownerHeader);
if (pos != -1)
{
QString owner = dcrawInfo.mid(pos).section('\n', 0, 0);
owner.remove(0, ownerHeader.length());
identify.owner = owner;
}
// Extract DNG Version.
QString DNGVersionHeader("DNG Version: ");
pos = dcrawInfo.find(DNGVersionHeader);
if (pos != -1)
{
QString DNGVersion = dcrawInfo.mid(pos).section('\n', 0, 0);
DNGVersion.remove(0, DNGVersionHeader.length());
identify.DNGVersion = DNGVersion;
}
// Extract ISO Speed.
QString isoSpeedHeader("ISO speed: ");
pos = dcrawInfo.find(isoSpeedHeader);
if (pos != -1)
{
QString isoSpeed = dcrawInfo.mid(pos).section('\n', 0, 0);
isoSpeed.remove(0, isoSpeedHeader.length());
identify.sensitivity = isoSpeed.toLong();
}
// Extract Shutter Speed.
QString shutterSpeedHeader("Shutter: ");
pos = dcrawInfo.find(shutterSpeedHeader);
if (pos != -1)
{
QString shutterSpeed = dcrawInfo.mid(pos).section('\n', 0, 0);
shutterSpeed.remove(0, shutterSpeedHeader.length());
if (shutterSpeed.startsWith("1/"))
shutterSpeed.remove(0, 2); // remove "1/" at start of string.
shutterSpeed.remove(shutterSpeed.length()-4, 4); // remove " sec" at end of string.
identify.exposureTime = shutterSpeed.toFloat();
}
// Extract Aperture.
QString apertureHeader("Aperture: f/");
pos = dcrawInfo.find(apertureHeader);
if (pos != -1)
{
QString aperture = dcrawInfo.mid(pos).section('\n', 0, 0);
aperture.remove(0, apertureHeader.length());
identify.aperture = aperture.toFloat();
}
// Extract Focal Length.
QString focalLengthHeader("Focal Length: ");
pos = dcrawInfo.find(focalLengthHeader);
if (pos != -1)
{
QString focalLength = dcrawInfo.mid(pos).section('\n', 0, 0);
focalLength.remove(0, focalLengthHeader.length());
focalLength.remove(focalLength.length()-3, 3); // remove " mm" at end of string.
identify.focalLength = focalLength.toFloat();
}
// Extract Image Size.
QString imageSizeHeader("Image size: ");
pos = dcrawInfo.find(imageSizeHeader);
if (pos != -1)
{
QString imageSize = dcrawInfo.mid(pos).section('\n', 0, 0);
imageSize.remove(0, imageSizeHeader.length());
int width = imageSize.section(" x ", 0, 0).toInt();
int height = imageSize.section(" x ", 1, 1).toInt();
identify.imageSize = QSize(width, height);
}
// Extract "Has an embedded ICC profile" flag.
QString hasIccProfileHeader("Embedded ICC profile: ");
pos = dcrawInfo.find(hasIccProfileHeader);
if (pos != -1)
{
QString hasIccProfile = dcrawInfo.mid(pos).section('\n', 0, 0);
hasIccProfile.remove(0, hasIccProfileHeader.length());
if (hasIccProfile.contains("yes"))
identify.hasIccProfile = true;
else
identify.hasIccProfile = false;
}
// Check if picture is decodable.
identify.isDecodable = true;
pos = dcrawInfo.find("Cannot decode file");
if (pos != -1)
identify.isDecodable = false;
// Extract "Has Secondary Pixel" flag.
QString hasSecondaryPixelHeader("Secondary pixels: ");
pos = dcrawInfo.find(hasSecondaryPixelHeader);
if (pos != -1)
{
QString hasSecondaryPixel = dcrawInfo.mid(pos).section('\n', 0, 0);
hasSecondaryPixel.remove(0, hasSecondaryPixelHeader.length());
if (hasSecondaryPixel.contains("yes"))
identify.hasSecondaryPixel = true;
else
identify.hasSecondaryPixel = false;
}
// Extract Pixel Aspect Ratio.
QString aspectRatioHeader("Pixel Aspect Ratio: ");
pos = dcrawInfo.find(aspectRatioHeader);
if (pos != -1)
{
QString aspectRatio = dcrawInfo.mid(pos).section('\n', 0, 0);
aspectRatio.remove(0, aspectRatioHeader.length());
identify.pixelAspectRatio = aspectRatio.toFloat();
}
// Extract Raw Colors.
QString rawColorsHeader("Raw colors: ");
pos = dcrawInfo.find(rawColorsHeader);
if (pos != -1)
{
QString rawColors = dcrawInfo.mid(pos).section('\n', 0, 0);
rawColors.remove(0, rawColorsHeader.length());
identify.rawColors = rawColors.toInt();
}
// Extract Filter Pattern.
QString filterHeader("Filter pattern: ");
pos = dcrawInfo.find(filterHeader);
if (pos != -1)
{
QString filter = dcrawInfo.mid(pos).section('\n', 0, 0);
filter.remove(0, filterHeader.length());
identify.filterPattern = filter;
}
// Extract Daylight Multipliers.
QString daylightMultHeader("Daylight multipliers: ");
pos = dcrawInfo.find(daylightMultHeader);
if (pos != -1)
{
QString daylightMult = dcrawInfo.mid(pos).section('\n', 0, 0);
daylightMult.remove(0, daylightMultHeader.length());
identify.daylightMult[0] = daylightMult.section(" ", 0, 0).toDouble();
identify.daylightMult[1] = daylightMult.section(" ", 1, 1).toDouble();
identify.daylightMult[2] = daylightMult.section(" ", 2, 2).toDouble();
}
// Extract Camera Multipliers.
QString cameraMultHeader("Camera multipliers: ");
pos = dcrawInfo.find(cameraMultHeader);
if (pos != -1)
{
QString cameraMult = dcrawInfo.mid(pos).section('\n', 0, 0);
cameraMult.remove(0, cameraMultHeader.length());
identify.cameraMult[0] = cameraMult.section(" ", 0, 0).toDouble();
identify.cameraMult[1] = cameraMult.section(" ", 1, 1).toDouble();
identify.cameraMult[2] = cameraMult.section(" ", 2, 2).toDouble();
identify.cameraMult[3] = cameraMult.section(" ", 3, 3).toDouble();
}
return true;
}
// ----------------------------------------------------------------------------------
bool KDcraw::decodeHalfRAWImage(const QString& filePath, RawDecodingSettings rawDecodingSettings,
QByteArray &imageData, int &width, int &height, int &rgbmax)
{
m_rawDecodingSettings = rawDecodingSettings;
m_rawDecodingSettings.halfSizeColorImage = true;
return (loadFromDcraw(filePath, imageData, width, height, rgbmax));
}
bool KDcraw::decodeRAWImage(const QString& filePath, RawDecodingSettings rawDecodingSettings,
QByteArray &imageData, int &width, int &height, int &rgbmax)
{
m_rawDecodingSettings = rawDecodingSettings;
return (loadFromDcraw(filePath, imageData, width, height, rgbmax));
}
bool KDcraw::checkToCancelWaitingData()
{
return m_cancel;
}
bool KDcraw::checkToCancelRecievingData()
{
return m_cancel;
}
void KDcraw::setWaitingDataProgress(double)
{
}
void KDcraw::setRecievingDataProgress(double)
{
}
bool KDcraw::loadFromDcraw(const QString& filePath, QByteArray &imageData,
int &width, int &height, int &rgbmax)
{
m_cancel = false;
d->dataPos = 0;
d->filePath = filePath;
d->running = true;
d->normalExit = false;
d->process = 0;
d->data = 0;
d->width = 0;
d->height = 0;
d->rgbmax = 0;
// trigger startProcess and loop to wait dcraw decoding
QApplication::postEvent(this, new QCustomEvent(QEvent::User));
// The time from starting dcraw to when it first outputs something takes
// much longer than the time while it outputs the data and the time while
// we process the data.
// We do not have progress information for this, but it is much more promising to the user
// if there is progress which does not stay at a fixed value.
// So we make up some progress (0% - 40%), using the file size as an indicator how long it might take.
QTime dcrawStartTime = QTime::currentTime();
int fileSize = QFileInfo(filePath).size();
// This is the magic number that describes how fast the function grows
// It _should_ be dependent on how fast the computer is, but we do not have this piece of information
// So this is a number that works well on my computer.
double K50 = 3000.0*fileSize;
double part = 0;
int checkpointTime = 0;
int checkpoint = 0;
// The shuttingDown is a hack needed to prevent hanging when this KProcess-based loader
// is waiting for the process to finish, but the main thread is waiting
// for the thread to finish and no KProcess events are delivered.
// Remove when porting to Qt4.
while (d->running && !checkToCancelRecievingData())
{
if (d->dataPos == 0)
{
int elapsedMsecs = dcrawStartTime.msecsTo(QTime::currentTime());
if (elapsedMsecs > checkpointTime)
checkpointTime += 300;
// What we do here is a sigmoidal curve, it starts slowly,
// then grows more rapidly, slows down again and
// get asymptotically closer to the maximum.
// (this is the Hill Equation, 2.8 the Hill Coefficient, to pour some blood in this)
double elapsedMsecsPow = pow(elapsedMsecs, 2.8);
part = (elapsedMsecsPow) / (K50 + elapsedMsecsPow);
// While we waiting to receive data, progress from 0% to 40%
setWaitingDataProgress(0.4*part);
}
else if (d->dataPos > checkpoint)
{
// While receiving data, progress from 40% to 70%
double delta = 0.3 + 0.4 - 0.4*part;
int imageSize = d->width * d->height * (m_rawDecodingSettings.sixteenBitsImage ? 6 : 3);
checkpoint += (int)(imageSize / (20 * delta));
setRecievingDataProgress(0.4*part + delta * (((float)d->dataPos)/((float)imageSize)));
}
QMutexLocker lock(&d->mutex);
d->condVar.wait(&d->mutex, 10);
}
if (!d->normalExit || m_cancel)
{
delete [] d->data;
d->data = 0;
return false;
}
// Copy decoded image data to byte array.
width = d->width;
height = d->height;
rgbmax = d->rgbmax;
imageData = QByteArray(d->width * d->height * (m_rawDecodingSettings.sixteenBitsImage ? 6 : 3));
memcpy(imageData.data(), d->data, imageData.size());
delete [] d->data;
d->data = 0;
return true;
}
void KDcraw::customEvent(QCustomEvent *)
{
// KProcess (because of QSocketNotifier) is not reentrant.
// We must only use it from the main thread.
startProcess();
// set up timer to call continueQuery at regular intervals
if (d->running)
{
d->queryTimer = new QTimer;
connect(d->queryTimer, SIGNAL(timeout()),
this, SLOT(slotContinueQuery()));
d->queryTimer->start(30);
}
}
void KDcraw::slotContinueQuery()
{
// this is called from the timer
if (checkToCancelWaitingData())
{
d->process->kill();
}
}
void KDcraw::startProcess()
{
if (m_cancel)
{
d->running = false;
d->normalExit = false;
return;
}
// create KProcess and build argument list
d->process = new KProcess;
connect(d->process, SIGNAL(processExited(KProcess *)),
this, SLOT(slotProcessExited(KProcess *)));
connect(d->process, SIGNAL(receivedStdout(KProcess *, char *, int)),
this, SLOT(slotReceivedStdout(KProcess *, char *, int)));
connect(d->process, SIGNAL(receivedStderr(KProcess *, char *, int)),
this, SLOT(slotReceivedStderr(KProcess *, char *, int)));
// run dcraw with options:
// -c : write to stdout
// -v : verboze mode.
//
// -4 : 16bit ppm output
//
// -f : Interpolate RGB as four colors. This blurs the image a little, but it eliminates false 2x2 mesh patterns.
// -a : Use automatic white balance
// -w : Use camera white balance, if possible
// -n : Use wavelets to erase noise while preserving real detail.
// -j : Do not stretch the image to its correct aspect ratio.
// -q : Use an interpolation method.
// -p : Use the input ICC profiles to define the camera's raw colorspace.
// -o : Use ICC profiles to define the output colorspace.
// -h : Output a half-size color image. Twice as fast as -q 0.
// -b : set Brightness value.
// -k : set Black Point value.
// -r : set Raw Color Balance Multipliers.
// -C : set Correct chromatic aberration correction.
*d->process << DcrawBinary::path();
*d->process << "-c";
*d->process << "-v";
if (m_rawDecodingSettings.sixteenBitsImage)
*d->process << "-4";
if (m_rawDecodingSettings.halfSizeColorImage)
*d->process << "-h";
if (m_rawDecodingSettings.RGBInterpolate4Colors)
*d->process << "-f";
if (m_rawDecodingSettings.DontStretchPixels)
*d->process << "-j";
*d->process << "-H";
*d->process << QString::number(m_rawDecodingSettings.unclipColors);
*d->process << "-b";
*d->process << QString::number(m_rawDecodingSettings.brightness);
if (m_rawDecodingSettings.enableBlackPoint)
{
*d->process << "-k";
*d->process << QString::number(m_rawDecodingSettings.blackPoint);
}
switch (m_rawDecodingSettings.whiteBalance)
{
case RawDecodingSettings::NONE:
break;
case RawDecodingSettings::CAMERA:
*d->process << "-w";
break;
case RawDecodingSettings::AUTO:
*d->process << "-a";
break;
case RawDecodingSettings::CUSTOM:
/* Convert between Temperature and RGB.
*/
double T;
double RGB[3];
double xD, yD, X, Y, Z;
DcrawInfoContainer identify;
T = m_rawDecodingSettings.customWhiteBalance;
/* Here starts the code picked and adapted from ufraw (0.12.1)
to convert Temperature + green multiplier to RGB multipliers
*/
/* Convert between Temperature and RGB.
* Base on information from http://www.brucelindbloom.com/
* The fit for D-illuminant between 4000K and 12000K are from CIE
* The generalization to 2000K < T < 4000K and the blackbody fits
* are my own and should be taken with a grain of salt.
*/
const double XYZ_to_RGB[3][3] = {
{ 3.24071, -0.969258, 0.0556352 },
{-1.53726, 1.87599, -0.203996 },
{-0.498571, 0.0415557, 1.05707 } };
// Fit for CIE Daylight illuminant
if (T <= 4000)
{
xD = 0.27475e9/(T*T*T) - 0.98598e6/(T*T) + 1.17444e3/T + 0.145986;
}
else if (T <= 7000)
{
xD = -4.6070e9/(T*T*T) + 2.9678e6/(T*T) + 0.09911e3/T + 0.244063;
}
else
{
xD = -2.0064e9/(T*T*T) + 1.9018e6/(T*T) + 0.24748e3/T + 0.237040;
}
yD = -3*xD*xD + 2.87*xD - 0.275;
X = xD/yD;
Y = 1;
Z = (1-xD-yD)/yD;
RGB[0] = X*XYZ_to_RGB[0][0] + Y*XYZ_to_RGB[1][0] + Z*XYZ_to_RGB[2][0];
RGB[1] = X*XYZ_to_RGB[0][1] + Y*XYZ_to_RGB[1][1] + Z*XYZ_to_RGB[2][1];
RGB[2] = X*XYZ_to_RGB[0][2] + Y*XYZ_to_RGB[1][2] + Z*XYZ_to_RGB[2][2];
/* End of the code picked to ufraw
*/
RGB[1] = RGB[1] / m_rawDecodingSettings.customWhiteBalanceGreen;
/* By default, decraw override his default D65 WB
We need to keep it as a basis : if not, colors with some
DSLR will have a high dominant of color that will lead to
a completly wrong WB
*/
if (rawFileIdentify (identify, d->filePath))
{
RGB[0] = identify.daylightMult[0] / RGB[0];
RGB[1] = identify.daylightMult[1] / RGB[1];
RGB[2] = identify.daylightMult[2] / RGB[2];
}
else
{
RGB[0] = 1.0 / RGB[0];
RGB[1] = 1.0 / RGB[1];
RGB[2] = 1.0 / RGB[2];
qDebug("Warning: cannot get daylight multipliers");
}
*d->process << "-r";
*d->process << QString::number(RGB[0], 'f', 5);
*d->process << QString::number(RGB[1], 'f', 5);
*d->process << QString::number(RGB[2], 'f', 5);
*d->process << QString::number(RGB[1], 'f', 5);
break;
}
*d->process << "-q";
*d->process << QString::number(m_rawDecodingSettings.RAWQuality);
if (m_rawDecodingSettings.enableNoiseReduction)
{
*d->process << "-n";
*d->process << QString::number(m_rawDecodingSettings.NRThreshold);
}
if (m_rawDecodingSettings.enableCACorrection)
{
*d->process << "-C";
*d->process << QString::number(m_rawDecodingSettings.caMultiplier[0], 'f', 5);
*d->process << QString::number(m_rawDecodingSettings.caMultiplier[1], 'f', 5);
}
*d->process << "-o";
*d->process << QString::number(m_rawDecodingSettings.outputColorSpace);
*d->process << QFile::encodeName(d->filePath);
QString args;
for (uint i = 0 ; i < d->process->args().count(); i++)
{
args.append(d->process->args()[i]);
args.append(QString(" "));
}
qDebug("Running RAW decoding command: %s", args.ascii());
// actually start the process
if ( !d->process->start(KProcess::NotifyOnExit,
KProcess::Communication(KProcess::Stdout | KProcess::Stderr)) )
{
qWarning("Failed to start RAW decoding");
delete d->process;
d->process = 0;
d->running = false;
d->normalExit = false;
return;
}
}
void KDcraw::slotProcessExited(KProcess *)
{
// set variables, clean up, wake up loader thread
QMutexLocker lock(&d->mutex);
d->running = false;
d->normalExit = d->process->normalExit() && d->process->exitStatus() == 0;
delete d->process;
d->process = 0;
delete d->queryTimer;
d->queryTimer = 0;
d->condVar.wakeAll();
}
void KDcraw::slotReceivedStdout(KProcess *, char *buffer, int buflen)
{
if (!d->data)
{
// first data packet:
// Parse PPM header to find out size and allocate buffer
// PPM header is "P6 <width> <height> <maximum rgb value "
// where the blanks are newline characters
QString magic = QString::fromAscii(buffer, 2);
if (magic != "P6")
{
qWarning("Cannot parse header from RAW decoding: Magic is: %s", magic.ascii());
d->process->kill();
return;
}
// Find the third newline that marks the header end in a dcraw generated ppm.
int i = 0;
int counter = 0;
while (i < buflen)
{
if (counter == 3) break;
if (buffer[i] == '\n')
{
counter++;
}
++i;
}
QStringList splitlist = QStringList::split("\n", QString::fromAscii(buffer, i));
QStringList sizes = QStringList::split(" ", splitlist[1]);
if (splitlist.size() < 3 || sizes.size() < 2)
{
qWarning("Cannot parse header from RAW decoding: Could not split");
d->process->kill();
return;
}
d->width = sizes[0].toInt();
d->height = sizes[1].toInt();
d->rgbmax = splitlist[2].toInt();
#ifdef ENABLE_DEBUG_MESSAGES
qDebug("Parsed PPM header: width %i height %i rgbmax %i", d->width, d->height, d->rgbmax);
#endif
// cut header from data for memcpy below
buffer += i;
buflen -= i;
// allocate buffer
d->data = new uchar[d->width * d->height * (m_rawDecodingSettings.sixteenBitsImage ? 6 : 3)];
d->dataPos = 0;
}
// copy data to buffer
memcpy(d->data + d->dataPos, buffer, buflen);
d->dataPos += buflen;
}
void KDcraw::slotReceivedStderr(KProcess *, char *buffer, int buflen)
{
QCString message(buffer, buflen);
qDebug("RAW decoding StdErr: %s", (const char*)message);
}
} // namespace KDcrawIface

199
libkdcraw/libkdcraw/kdcraw.h
Unescape View File

@ -0,0 +1,199 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2006-12-09
* Description : a tread-safe dcraw program interface
*
* Copyright (C) 2006-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
* Copyright (C) 2006-2008 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
* Copyright (C) 2007-2008 by Guillaume Castagnino <casta at xwing dot info>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
#ifndef KDCRAW_H
#define KDCRAW_H
// Qt Includes.
#include <qstring.h>
#include <qobject.h>
#include <qimage.h>
// Local includes.
#include "libkdcraw_export.h"
#include "rawdecodingsettings.h"
#include "dcrawinfocontainer.h"
class QCustomEvent;
class KProcess;
namespace KDcrawIface
{
class KDcrawPriv;
class LIBKDCRAW_EXPORT KDcraw : public QObject
{
Q_OBJECT
public:
/** Standard constructor. */
KDcraw();
/** Standard destructor. */
virtual ~KDcraw();
public:
/** Return a string version of libkdcraw release */
static QString version();
/** This is a non cancelable method witch do not require a class instance to run.
It can loadEmbeddedPreview() in first and if it failed, call loadHalfPreview().
*/
static bool loadDcrawPreview(QImage& image, const QString& path);
/** Get the embedded JPEG preview image from RAW picture. This is a fast and non cancelable
This method do not require a class instance to run.
*/
static bool loadEmbeddedPreview(QImage& image, const QString& path);
/** Get the half decode RAW picture. This is a more slower than loadEmbeddedPreview() method
and non cancelable. This method do not require a class instance to run.
*/
static bool loadHalfPreview(QImage& image, const QString& path);
/** Get the camera settings witch have taken RAW file. Look into dcrawinfocontainer.h
for more details. This is a fast and non cancelable method witch do not require
a class instance to run.
*/
static bool rawFileIdentify(DcrawInfoContainer& identify, const QString& path);
public:
/** Extract a small size of decode RAW data from 'filePath' picture file using
'rawDecodingSettings' settings. This is a cancelable method witch require
a class instance to run because RAW pictures decoding can take a while.
This method return:
- A byte array container ('imageData') with picture data. Pixels order is RGB.
Color depth can be 8 or 16. In 8 bits you can access to color component
using (uchar*), in 16 bits using (ushort*).
- Size size of image in number of pixels ('width' and 'height').
- The max average of RGB components from decoded picture.
- 'false' is returned if decoding failed, else 'true'.
*/
bool decodeHalfRAWImage(const QString& filePath, RawDecodingSettings rawDecodingSettings,
QByteArray &imageData, int &width, int &height, int &rgbmax);
/** Extract a full size of RAW data from 'filePath' picture file using
'rawDecodingSettings' settings. This is a cancelable method witch require
a class instance to run because RAW pictures decoding can take a while.
This method return:
- A byte array container ('imageData') with picture data. Pixels order is RGB.
Color depth can be 8 or 16. In 8 bits you can access to color component
using (uchar*), in 16 bits using (ushort*).
- Size size of image in number of pixels ('width' and 'height').
- The max average of RGB components from decoded picture.
- 'false' is returned if decoding failed, else 'true'.
*/
bool decodeRAWImage(const QString& filePath, RawDecodingSettings rawDecodingSettings,
QByteArray &imageData, int &width, int &height, int &rgbmax);
/** To cancel 'decodeHalfRAWImage' and 'decodeRAWImage' methods running
in a separate thread.
*/
void cancel();
protected:
/** Used internally to cancel RAW decoding operation. Normally, you don't need to use it
directly, excepted if you derivated this class. Usual way is to use cancel() method
*/
bool m_cancel;
/** The settings container used to perform RAW pictures decoding. See 'rawdecodingsetting.h'
for details.
*/
RawDecodingSettings m_rawDecodingSettings;
protected:
/** Re-implement this method to control the cancelisation of loop witch wait data
from RAW decoding process with your propers envirronement.
By default, this method check if m_cancel is true.
NOTE: RAW decoding is divided to 3 stages :
1-demosaising from dcraw. no progress feedback is available. We using a pseudo
progress value. You can control this stage using checkToCancelWaitingData() and
setWaitingDataProgress() methods.
2-decoding data reception from dcraw. You can control this stage using
checkToCancelRecievingData() and setRecievingDataProgress() methods.
3-storage decoded data in your application using the QByteArray container.
*/
virtual bool checkToCancelWaitingData();
/** Re-implement this method to control the cancelisation of the loop which receives data
from RAW decoding process with your proper environment.
By default, this method check if m_cancel is true.
*/
virtual bool checkToCancelRecievingData();
/** Re-implement this method to control the pseudo progress value during RAW decoding (when dcraw run with an
internal loop without feedback) with your proper environment. By default, this method do nothing.
Progress value average for this stage is 0%-n%, with 'n' == 40% max (see setWaitingDataProgress() method).
*/
virtual void setWaitingDataProgress(double value);
/** Re-implement this method to control the progress value during RAW decoding (when dcraw return data)
with your proper environment. By default, this method do nothing.
Progress value average for this stage is n%-70%, with 'n' == 40% max (see setWaitingDataProgress() method).
*/
virtual void setRecievingDataProgress(double value);
private:
bool loadFromDcraw(const QString& filePath, QByteArray &imageData,
int &width, int &height, int &rgbmax);
void startProcess();
virtual void customEvent(QCustomEvent *);
private slots:
void slotProcessExited(KProcess *);
void slotReceivedStdout(KProcess *, char *, int);
void slotReceivedStderr(KProcess *, char *, int);
void slotContinueQuery();
private:
KDcrawPriv *d;
};
} // namespace KDcrawIface
#endif /* KDCRAW_H */

37
libkdcraw/libkdcraw/libkdcraw_export.h
Unescape View File

@ -0,0 +1,37 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2005-09-15
* Description : dcraw program interface for KDE
*
* Copyright (C) 2005 by Laurent Montel <montel@kde.org>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
#ifndef _LIBKDCRAW_EXPORT_H
#define _LIBKDCRAW_EXPORT_H
#ifdef KDEMACROS_USABLE
#include <kdemacros.h>
#endif
#ifdef KDE_EXPORT
#define LIBKDCRAW_EXPORT KDE_EXPORT
#else
#define LIBKDCRAW_EXPORT
#endif
#endif /* _LIBKDCRAW_EXPORT_H */

255
libkdcraw/libkdcraw/rawdecodingsettings.h
Unescape View File

@ -0,0 +1,255 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2006-12-09
* Description : Raw decoding settings
*
* Copyright (C) 2006-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
* Copyright (C) 2006-2008 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
* Copyright (C) 2007-2008 by Guillaume Castagnino <casta at xwing dot info>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
#ifndef RAW_DECODING_SETTINGS_H
#define RAW_DECODING_SETTINGS_H
// Local includes.
#include "libkdcraw_export.h"
namespace KDcrawIface
{
class LIBKDCRAW_EXPORT RawDecodingSettings
{
public:
/** RAW decoding Interpolation methods
Bilinear: use high-speed but low-quality bilinear
interpolation (default - for slow computer). In this method,
the red value of a non-red pixel is computed as the average of
the adjacent red pixels, and similar for blue and green.
VNG: use Variable Number of Gradients interpolation.
This method computes gradients near the pixel of interest and uses
the lower gradients (representing smoother and more similar parts
of the image) to make an estimate.
PPG: use Patterned Pixel Grouping interpolation.
Pixel Grouping uses assumptions about natural scenery in making estimates.
It has fewer color artifacts on natural images than the Variable Number of
Gradients method.
AHD: use Adaptive Homogeneity-Directed interpolation.
This method selects the direction of interpolation so as to
maximize a homogeneity metric, thus typically minimizing color artifacts.
*/
enum DecodingQuality
{
BILINEAR = 0,
VNG = 1,
PPG = 2,
AHD = 3
};
/** White balances alternatives
NONE: no white balance used : dcraw reverts to standard daylight D65 WB
CAMERA: Use the camera embeded WB if available. Reverts to NONE if not
AUTO: Averages an auto WB on the entire image
CUSTOM: Let use set it's own temperature and green factor (later converted to RGBG factors)
*/
enum WhiteBalance
{
NONE = 0,
CAMERA = 1,
AUTO = 2,
CUSTOM = 3
};
/** Output RGB color space used to decoded image */
enum OutputColorSpace
{
RAWCOLOR = 0,
SRGB,
ADOBERGB,
WIDEGAMMUT,
PROPHOTO
};
/** Standard constructor with default settings */
RawDecodingSettings()
{
sixteenBitsImage = false;
brightness = 1.0;
RAWQuality = BILINEAR;
outputColorSpace = SRGB;
RGBInterpolate4Colors = false;
DontStretchPixels = false;
unclipColors = 0;
whiteBalance = CAMERA;
customWhiteBalance = 6500;
customWhiteBalanceGreen = 1.0;
halfSizeColorImage = false;
enableBlackPoint = false;
blackPoint = 0;
enableNoiseReduction = false;
NRThreshold = 100;
enableCACorrection = false;
caMultiplier[0] = 1.0;
caMultiplier[1] = 1.0;
};
/** Compare for equality */
bool operator==(const RawDecodingSettings &o) const
{
return sixteenBitsImage == o.sixteenBitsImage
&& brightness == o.brightness
&& RAWQuality == o.RAWQuality
&& outputColorSpace == o.outputColorSpace
&& RGBInterpolate4Colors == o.RGBInterpolate4Colors
&& DontStretchPixels == o.DontStretchPixels
&& unclipColors == o.unclipColors
&& whiteBalance == o.whiteBalance
&& customWhiteBalance == o.customWhiteBalance
&& customWhiteBalanceGreen == o.customWhiteBalanceGreen
&& halfSizeColorImage == o.halfSizeColorImage
&& enableBlackPoint == o.enableBlackPoint
&& blackPoint == o.blackPoint
&& enableNoiseReduction == o.enableNoiseReduction
&& NRThreshold == o.NRThreshold
&& enableCACorrection == o.enableCACorrection
&& caMultiplier[0] == o.caMultiplier[0]
&& caMultiplier[1] == o.caMultiplier[1]
;
};
/** Standard destructor */
virtual ~RawDecodingSettings(){};
/** Method to use a settings to optimize time loading, for exemple to compute image histogram */
void optimizeTimeLoading(void)
{
sixteenBitsImage = true;
brightness = 1.0;
RAWQuality = BILINEAR;
outputColorSpace = SRGB;
RGBInterpolate4Colors = false;
DontStretchPixels = false;
unclipColors = 0;
whiteBalance = CAMERA;
customWhiteBalance = 6500;
customWhiteBalanceGreen = 1.0;
halfSizeColorImage = true;
enableBlackPoint = false;
blackPoint = 0;
enableNoiseReduction = false;
NRThreshold = 100;
enableCACorrection = false;
caMultiplier[0] = 1.0;
caMultiplier[1] = 1.0;
};
public:
/** If true, decode RAW file in 16 bits per color per pixel else 8 bits.
*/
bool sixteenBitsImage;
/** Half-size color image decoding (twice as fast as "enableRAWQuality").
Use this option to reduce time loading to render histogram for example,
no to render an image to screen.
*/
bool halfSizeColorImage;
/** White balance type to use. See WhiteBalance values for detail
*/
WhiteBalance whiteBalance;
/** The temperature and the green multiplier of the custom white balance
*/
int customWhiteBalance;
double customWhiteBalanceGreen;
/** RAW file decoding using RGB interpolation as four colors.
*/
bool RGBInterpolate4Colors;
/** For cameras with non-square pixels, do not stretch the image to its
correct aspect ratio. In any case, this option guarantees that each
output pixel corresponds to one RAW pixel.
*/
bool DontStretchPixels;
/** Unclip Highlight color level:
0 = Clip all highlights to solid white.
1 = Leave highlights unclipped in various shades of pink.
2 = Blend clipped and unclipped values together for a gradual
fade to white.
3-9 = Reconstruct highlights. Low numbers favor whites; high numbers
favor colors.
*/
int unclipColors;
/** RAW quality decoding factor value. See DecodingQuality values
for details.
*/
DecodingQuality RAWQuality;
/** Use wavelets to erase noise while preserving real detail.
*/
bool enableNoiseReduction;
/** Noise reduction threshold value.
The best threshold should be somewhere between 100 and 1000.
*/
int NRThreshold;
/** Use red and blue layer magnification to reduce chromatic aberrations
*/
bool enableCACorrection;
/** Magnification factor for Red and Blue layers
- caMultiplier[0] = red multiplier
- caMultiplier[1] = blue multiplier
*/
double caMultiplier[2];
/** Brightness of output image.
*/
float brightness;
/** Set on the black point setting to decode RAW image.
*/
bool enableBlackPoint;
/** Black Point value of output image.
*/
int blackPoint;
/** The output color space used to decoded RAW data. See OutputColorSpace
values for details.
*/
OutputColorSpace outputColorSpace;
};
} // namespace KDcrawIface
#endif /* RAW_DECODING_SETTINGS_H */

29
libkdcraw/libkdcraw/rawfiles.h
Unescape View File

@ -0,0 +1,29 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2005-11-06
* Description : list of RAW file extensions supported by
* dcraw program.
*
* Copyright (C) 2005-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful *.
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
#ifndef RAW_FILES_H
#define RAW_FILES_H
static const char raw_file_extentions[] = "*.bay *.bmq *.cr2 *.crw *.cs1 *.dc2 *.dcr *.dng *.erf *.fff *.hdr *.k25 *.kdc *.mdc *.mos *.mrw *.nef *.orf *.pef *.pxn *.raf *.raw *.rdc *.sr2 *.srf *.x3f *.arw";
#endif // RAW_FILES_H

31
libkdcraw/libkdcraw/version.h
Unescape View File

@ -0,0 +1,31 @@
/* ============================================================
*
* This file is a part of kipi-plugins project
* http://www.kipi-plugins.org
*
* Date : 2007-02-12
* Description : dcraw program interface for KDE
*
* Copyright (C) 2007-2008 by Gilles Caulier <caulier dot gilles at gmail dot com>
*
* This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software Foundation;
* either version 2, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* ============================================================ */
#ifndef KDCRAW_VERSION_H
#define KDCRAW_VERSION_H
static const char kdcraw_version[] = "0.1.4";
#define KDCRAW_VERSION 0x000104
#endif // KDCRAW_VERSION_H

1
po/Makefile.am
Unescape View File

@ -0,0 +1 @@
SUBDIRS = $(AUTODIRS)

3
po/ca/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = ca
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

478
po/ca/libkdcraw.po
Unescape View File

@ -0,0 +1,478 @@
# Translation of libkdcraw.po to Catalan
#
# Josep Ma. Ferrer <txemaq@gmail.com>, 2007, 2008.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2008-03-05 21:08+0100\n"
"Last-Translator: Josep Ma. Ferrer <txemaq@gmail.com>\n"
"Language-Team: Catalan <kde-i18n-ca@kde.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>No s'ha pogut trobar l'executable <b>%1</b>:"
"<br>cal aquest programa binari per treballar amb formats de fitxer RAW. Podeu "
"continuar, però no podreu manipular les imatges RAW. Comproveu la instal·lació "
"del paquet libkdcraw a l'ordinador."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p>L'executable <b>%1</b> no està actualitzat:"
"<br>s'ha trobat la versió %2 d'aquest programa binari a l'ordinador. Aquesta "
"versió és massa antiga per funcionar correctament. Podeu continuar, però no "
"podreu manipular les imatges RAW. Comproveu la instal·lació del paquet "
"libkdcraw a l'ordinador."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "Profunditat de color de 16 bits"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Si està habilitat, tots els fitxers RAW es descodificaran amb una "
"profunditat de color de 16 bits usant una corba gamma lineal. Per evitar la "
"renderització de fotografies fosques a l'editor, es recomana usar la gestió de "
"color en aquest mode."
"<p>Si està deshabilitat, tots els fitxers RAW es descodificaran amb una "
"profunditat de color de 8 bits usant una corba gamma BT.709 i un 99% de punt "
"blanc. Aquest mode és més ràpidìd que la descodificació amb 16 bits."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "Interpola el RGB com a quatre colors"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>Interpola el RGB com a quatre colors</b>"
"<p>Per defecte, s'assumeix que tots els píxels verds són el mateix. Si els "
"píxels verds de les files parells són més sensibles a la llum ultraviolada que "
"els de les files senars, aquesta diferència provoca un patró mallat a la "
"sortida; usant aquesta opció això es resol amb una pèrdua de detall mínima."
"<p>Resumint, aquesta opció desenfoca una mica la imatge, però elimina el patró "
"mallat 2x2 amb un mètode de qualitat VNG o amb un imbricat mètode de qualitat "
"AHD."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Visiteu el lloc web del projecte dcraw"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr "Balanç de blancs:"
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr "Balanç de blancs D65 per omissió"
#: libkdcraw/dcrawsettingswidget.cpp:194
msgid "Camera White Balance"
msgstr "Balanç de blancs de la càmera"
#: libkdcraw/dcrawsettingswidget.cpp:195
msgid "Automatic White Balance"
msgstr "Balanç de blancs automàtic"
#: libkdcraw/dcrawsettingswidget.cpp:196
msgid "Manual White balance"
msgstr "Balanç de blancs manual"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
"<p><b>Balanç de blancs</b>"
"<p>Configureu el balanç de blancs cru:"
"<p><b>Balanç de blancs D65 per omissió</b>: usa un balanç de blancs D65 de llum "
"de dia estàndard (per omissió del dcraw)"
"<p><b>Balanç de blancs de la càmera</b>: usa el balanç de blancs especificat "
"per la càmera. Si no és disponible, retorna al balanç de blancs neutre per "
"omissió"
"<p><b>Balanç de blancs automàtic</b>: calcula un balanç de blancs automàtic de "
"la mitja de tota la imatge"
"<p><b>Balanç de blancs manual</b>: fixa uns valors de temperatura "
"personalitzada i un nivell de verd"
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr "Temperatura (K):"
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr "<p><b>Temperatura</b><p>Indiqueu aquí la temperatura del color."
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr "Verd:"
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
"<p>Indiqueu aquí la component verda per a fixar el nivell d'eliminació de la "
"conversió del color magenta."
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Llums intenses:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Blanc sòlid"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Sense escurçar"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Combinació"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Reconstrucció"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Llums intenses</b>"
"<p>Seleccioneu aquí el mètode per escurçar les llums intenses:"
"<p><b>Blanc sòlid</b>: escurça les llums intenses al blanc sòlid"
"<p><b>Sense escurçar</b>: deixa les llums intenses en varis tonalitats de rosa"
"<p><b>Combinació</b>: combina els valors escurçats i els no escurçats fent un "
"encadenament gradual a blanc"
"<p><b>Reconstrucció</b>: reconstrueix les llums intenses usant un valor de "
"nivell"
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Nivell:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Nivell</b>"
"<p>Indica el nivell de reconstrucció de les llums intenses. Els valors baixos "
"afavoreixen els blancs i els valors alts afavoreixen els colors."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Brillantor:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Brillantor</b>"
"<p>Indica el nivell de brillantor de la imatge de sortida. El valor "
"predeterminat és 1,0 (només treballa en el mode de 8 bits)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Qualitat (interpolació):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Bilineal"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr "PPG"
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
"<p><b>Qualitat</b>"
"<p>Seleccioneu aquí el mètode d'interpolació per a eliminar el mosaic en "
"descodificar les imatges RAW. L'algorisme d'eliminació del mosaic és un procés "
"digital de la imatge usat per interpolar una imatge completa des de dades "
"parcials en brut rebudes del sensor d'imatge de filtrat per color intern de "
"moltes càmeres digitals en forma d'una matriu de píxels de colors. També es "
"coneix com interpolació CFA o reconstrucció del color; en anglès s'anomena "
"normalment \"demosaicing\". Hi ha 3 mètodes d'eliminació del mosaic de les "
"imatges RAW:"
"<p><b>Bilineal</b>: usa una interpolació bilineal d'alta velocitat però baixa "
"qualitat (predeterminat - per a un ordinador lent). En aquest mètode, el valor "
"vermell d'un píxel no vermell és la mitjana dels píxels vermells adjacents, i "
"el mateix pel blau i el verd."
"<p><b>VNG</b>: usa la interpolació d'un nombre variable de gradients (Variable "
"Number of Gradients). Aquest mètode calcula els gradients a prop del píxel "
"d'interès i usa els gradients més baixos (que representen els suavitzats i les "
"parts més semblants de la imatge) per fer una estimació."
"<p> <b>AHD</b>: usa la interpolació adaptativa dirigida a la homogeneïtat "
"(Adaptive Homogeneity-Directed). Aquest mètode selecciona la direcció de la "
"interpolació per maximitzar una mètrica homogènia, de manera que es minimitzen "
"els defectes dels colors."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Habilita la reducció de soroll"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Habilita la reducció de soroll</b>"
"<p>Utilitza ones petites per esborrar el soroll mentre es preserva el detall "
"real."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Llindar:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
"<p><b>Llindar</b>"
"<p>Indiqueu aquí el valor del llindar de reducció de soroll a usar."
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr "Habilita la correcció d'aberració cromàtica"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
"<p><b>Habilita la correcció d'aberració cromàtica</b>"
"<p>Augmenta les capes RAW vermella i blava per un factor indicat, habitualment "
"entre 0,999 a 1,001, per a corregir l'aberració cromàtica."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Multiplicador de vermell:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
"<p><b>Multiplicador de vermell</b>"
"<p>Indiqueu aquí el factor d'augment de la capa vermella"
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Multiplicador de blau:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
"<p><b>Multiplicador de blau</b>"
"<p>Indiqueu aquí el factor d'augment de la capa blava"
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Espai de color:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Cru (lineal)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Escala àmplia"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-Photo"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Espai de color</b>"
"<p>Seleccioneu aquí l'espai de color de sortida usat per descodificar les dades "
"RAW."
"<p><b>RAW (lineal)</b>: es aquest mode, no s'usa cap espai de color de sortida "
"durant la descodificació RAW."
"<p> <b>sRGB</b>: aquest és un espai de color RGB, creat cooperativament per "
"Hewlett-Packard i Microsoft. És la millor elecció per les imatges destinades a "
"la Web i al retrat fotogràfic."
"<p><b>Adobe RGB</b>: aquest espai de color és un espai de color RGB ampliat, "
"desenvolupat per Adobe. S'utilitza en aplicacions fotogràfiques com la "
"publicitat i l'art."
"<p><b>Gama àmplia</b>: aquest espai de color és una versió expandida de l'espai "
"de color RGB Adobe."
"<p> <b>Pro-Photo</b>: aquest espai de color és un espai de color RGB, "
"desenvolupat per Kodak, que ofereix una gama enorme i es va dissenyar en la "
"seva concepció per ser utilitzada a les sortides fotogràfiques."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Estàndard"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "No estiris o giris els píxels"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>No estiris o giris els píxels</b>"
"<p>A les càmeres Fuji Super CCD, mostra les imatges inclinades 45 graus. A les "
"càmeres amb píxels no quadrats, no allarga la imatge a la seva relació "
"d'aspecte correcta. En qualsevol cas, aquesta opció garanteix que cada píxel de "
"la sortida correspon a un píxel RAW."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Punt negre"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Punt negre</b>"
"<p>Usa un valor de punt negre específic per descodificar les fotografies RAW. "
"Si heu desactivat aquesta opció, el valor del punt negre es calcularà "
"automàticament."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Valor del punt negre</b>"
"<p>Indica el valor específic del punt negre de la imatge de sortida."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Avançat"

3
po/da/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = da
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

478
po/da/libkdcraw.po
Unescape View File

@ -0,0 +1,478 @@
# Danish translation of libkdcraw
#
# Erik Kjær Pedersen <erik@binghamton.edu>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-06-28 20:25-0400\n"
"Last-Translator: Erik Kjær Pedersen <erik@binghamton.edu>\n"
"Language-Team: Danish <dansk@klid.dk>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>Kan ikke finde den kørbare fil <b>%1</b>:"
"<br>Dette binære program kræves for at understøtte ubehandlet filformat. Du kan "
"fortsætte, men du kommer ikke til at kunne håndtere nogle ubehandlede billeder. "
"Tjek installationen af pakken libkdcraw på computeren."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p>Den kørbare fil <b>%1</b> er ikke uptodate:"
"<br> Version %2 af dette binære program blev fundet på computeren. Denne "
"version er for gammel til at køre på en rigtig måde. Du kan fortsætte, men du "
"kommer ikke til at kunne håndtere nogle ubehandlede billeder. Tjek "
"installationen af pakken libkdcraw på computeren."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16 bits farvedybde"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Hvis aktiveret, afkodae alle ubehandlede filer til 16-bits farvedybde ved at "
"bruge en lineær gammakurve. For at forhindre at et mørkt billede vises i "
"editoren, anbefales at farvehåndtering bruges sammen med denne tilstand. "
"<p>Hvis deaktiveret, afkodes alle ubehandlede filer til 8-bits farvedybde med "
"en BT.709 gammakurve og en hvidpunkt i 99. procentilen. Denne tilstand er "
"hurtigere end 16-bits afkodning."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "Interpolér RGB som fire farver"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>Interpolér RGB som fire farver</b>"
"<p>Standard er at antage at alle grønne pixler er ens. Selv hvis lige-rækker "
"pixler er mere følsomme overfor ultraviolet lys end ulige-rækker. Denne forskel "
"forårsager et gittermønster i uddata. Ved at bruge denne indstilling, løses "
"dette problem med et minimalt detaljeringstab."
"<p>For at opsummere, giver denne indstilling en lille udtværring, men "
"eliminerer falsk 2x2 gittermønstre med VNG-kvalitet-metoden eller labyrinter "
"med AHD-kvalitet-metoden."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Besøg dcraw-projektets hjemmeside"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "Brug kameraets hvidbalance"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "Automatisk farvebalance"
#: libkdcraw/dcrawsettingswidget.cpp:196
#, fuzzy
msgid "Manual White balance"
msgstr "Brug kameraets hvidbalance"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
#, fuzzy
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
"<p><b>Tærskel</b>"
"<p>Indstil støjreduceringens tærskelværdi som skal bruges her."
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Overbelyste områder:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Fuldstændig hvidt"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Unclip"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:236
#, fuzzy
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Overbelysninger</b>"
"<p>Vælg beskæringsmetoden for overbelyste områser her:"
"<p><b>Helhvide</b>: beskærer alle overbelyste områder til helhvidt"
"<p><b>Ubeskårne</b>: efterlad overbelysninger ubeskårne i forskellige rosa "
"skygninger"
"<p><b>Genoprettete</b>: genopret overbelysnigner ved brug af en niveauværdi."
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Niveau:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Niveau</b>"
"<p>Angiv niveau for genoprettede overbelysninger i resultatbilledet. En lav "
"værdi gør at hvidt foretrækkes, og en høj værdi gør at farver foretrækkes."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Lysstyrke:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Lyshed</b>"
"<p>Angiv resultatbilledets lyshet. Standardværdien er 1,0 (fungerer kun i "
"8-bit-tilstand)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Kvalitet (interpoleret):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Bilineær"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
#, fuzzy
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
"<p><b>Kvalitet</b>"
"<p>Vælg interpolationsmetode for afkodning af ubehandlede billeder for "
"mosaikfjernelse. En algoritme for mosaikfjernelse er en digital billedproces "
"som bruges til at interpolere et fuldstændigt billede fra partielt ubehandlede "
"data i form af en matrix af farvede billedpunkter, som er modtaget fra den "
"farvefiltrerede billedsensor som findes internt i mange digitalkameraer. Den er "
"også kendt som CFA-interpolation eller farverekonstruktion. Der er tre metoder "
"til at udføre mosaikfjernelse af ubehandlede billeder:"
"<p><b>Bilineær</b>: Anvender en hurtig bilineær interpolation med lav kvalitet "
"(standard for langsomme computerer). Med denne metoden beregnes den røde værdi "
"af et billedpunkt som ikke er rødt som middelværdien af røde billedpunkter ved "
"siden af, og på samme måde for blåt og grønt."
"<p><b>VNG</b>: Anvend interpolation med variabelt antal overgange. Denne metode "
"beregner overgange nær det interessante billedpunkt og bruger de laveste "
"overgange (som repræsenterer jævnere og lignende dele af billedet) til at lave "
"en vurdering."
"<p><b>AHD</b>: Anvend adaptiv homogenstyret interpolation. Denne metode vælger "
"interpolationens retning så at et homogenitetsmål maksimeres, og på den måde "
"typisk minimeres farveafvigelser."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Aktivér støjreducering"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Aktivér støjreducering</b>"
"<p>Brug bølgeelement til at reducere støj samtidig med at rigtige detaljer "
"bevares."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Tærskel:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
"<p><b>Tærskel</b>"
"<p>Indstil støjreduceringens tærskelværdi som skal bruges her."
#: libkdcraw/dcrawsettingswidget.cpp:324
#, fuzzy
msgid "Enable Chromatic Aberration correction"
msgstr "Aktivér støjreducering"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Multiplikationsfaktor for rødt:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Multiplikationsfaktor for blåt:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Farverum:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Ubehandlet (lineær)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Stort toneomfang"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-foto"
#: libkdcraw/dcrawsettingswidget.cpp:361
#, fuzzy
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Farverum</b>"
"<p>Vælg resultatets farverum som bruges til at afkode ubehandlede data her."
"<p><b>Ubehandled (lineær)</b>: Med denne tilstand bruges ingen farverum for "
"resultateter under afkodning af ubehandlede data."
"<p><b>sRGB</b>: Dette farverum er et RGB-farverum, oprettet i samarbejde mellem "
"Hewlett-Packard og Microsoft. Det er det bedste valg for billeder som er "
"beregnede til for internettet og til portrætfotografering."
"<p><b>Adobe RGB</b>: Dette farverum er et RGB-farverum, udvikled af Adobe. Det "
"bruges til fotografiske tilpasninger såsom reklame og kunst."
"<p><b>Stort toneomfang</b>: Dette farverum er en udvidet version af Adobes "
"RGB-farverum."
"<p><b>Pro-foto</b>: Dette farverum er et RGB-farverum, udviklet af Kodak, som "
"tilbyder et særligt stort toneomfang konstrueret til brug med henblik på "
"fotografiske resultater."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Standard"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Stræk eller rotér ikke billedpunkter"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>Stræk eller rotér ikke billedpunkter</b>"
"<p>Vis billedet hældet 45 grader for Fuji Super CCD-kameraer. Stræk ikke "
"billedet til at rette proportioner for kameraer med ikke-firkantede "
"billedpunkter. Under alle omstndigheder garanterer dette at hvert billedpunkt i "
"resultatet svarer til et ubehandlet billedpunkt."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Sortpunkt"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Sortpunkt</b>"
"<p>Brug en specifik sortpunktværdi til at afkode ubehandlede billeder. Hvis du "
"slå dette fra, beregnes sortpunktværdien automatisk."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Sortpunktværdi</b>"
"<p>Angiv en specifik sortpunktværdi for resultatbilledet."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Avanceret"
#~ msgid "<p><b>Use camera white balance</b><p>Use the camera's custom white-balance settings. If this can not be found, reverts to the default (which is to use fixed daylight values, calculated from sample images)."
#~ msgstr "<p><b>Brug kameraets hvidbalance</b> <p>Brug kameraets egne indstillinger af hvidbalance. Hvis de ikke kan findes, går indstillingen tilbage til standardværdier (som er at bruge faste værdier for dagslys, beregnede fra eksempelbilleder)."
#, fuzzy
#~ msgid "<p><b>Automatic color balance</b></p>Calculate the white balance by averaging the entire image."
#~ msgstr "<p><b>Automatisk farvebalance</b></p>Standard er at bruge en fast farvebalance baseret på et hvidt kort fotograferet i sollys."
#~ msgid "Color balance multipliers"
#~ msgstr "Farvebalancefaktorer"
#~ msgid "Green 1 multiplier:"
#~ msgstr "Faktor for Grøn 1:"
#~ msgid "Green 2 multiplier:"
#~ msgstr "Faktor for Grøn 2:"
#~ msgid "Reconstruct"
#~ msgstr "Rekonstruér"

3
po/de/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = de
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

484
po/de/libkdcraw.po
Unescape View File

@ -0,0 +1,484 @@
# translation of libkdcraw.po to german
# translation of libkdcraw.po to
#
# Oliver Dörr <kde@doerr-privat.de>, 2007, 2008.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2008-03-06 18:54+0100\n"
"Last-Translator: Oliver Dörr <kde@doerr-privat.de>\n"
"Language-Team: german <kde-i18n-de@kde.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>Kann das Programm <b>%1</b> nicht finden:"
"<br>Diese sProgramm wird für die Unterstützung von Rohdateiformaten benötigt. "
"Sie können fortfahren, aber Sie können keine Rohbilder verwalten. Bitte "
"überprüfen Sie dei Installation des libkdcraw Paketes auf Ihrem Rechner."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p>Das Programm <b>%1</b> int nicht aktuell genug:"
"<br> Die Version %2 wurde von dem Prpogramm auf Ihrem Rechner gefunden. Diese "
"Version ist leider zu alt, um ordnungsgemäß zu funktionieren. Sie können "
"fortfahren, aber Sie können keine Rohbilder verwalten. Bitte überprüfen Sie die "
"Installation des libkdcraw Paketes auf Ihrem Rechner."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16-Bit Farbtiefe"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Wenn die Option aktiviert wird, werden alle Rodateien mit 16-Bit Farbtiefe "
"unter Benutzung einer linearen Gammakurve dekodiert. Um das Berechnen eines "
"Schwarzbildes zu verhindern empfehlen wir Ihnen die Farbverwaltung in diesem "
"Modus zu benutzen."
"<p>Wenn die Option deaktiviert ist, werden alle Rohdateien mit 8-Bit Farbtiefe "
"unter Benutzung einer BT.709 Gammakurve und einem 99% Weißpunkt dekodiert. "
"Dieser Modus ist schneller als eine 16-Bit Dekodierung."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "RGB als vier Farben interpolieren"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>Interpoliert RGB durch vier Farben.</b> "
"<p>Die Voreinstellung ist es, anzunehmen, dass alle grünen Pixel identisch "
"sind. Da eine ebenmäßige Reihe von grünen Pixeln empfindlicher auf "
"ultraviolettes Licht reagiert als eine nicht ebenmäßige, wird normalerweise "
"durch diesen Unterschied ein Netzmuster erzeugt. Diese Option löst dieses "
"Problem mit einem minimalen Verlust von Details.\n"
"<p>Diese Option verschmiert das Bild ein wenig, aber es verhindert fehlerhafte "
"2x2 Gitter mit der VNG- oder der AHD-Qualitätsmethode."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Webseite des dcraw-Projektes besuchen"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr "Weißabgleich:"
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr "Standard D65 Weißabgleich"
#: libkdcraw/dcrawsettingswidget.cpp:194
msgid "Camera White Balance"
msgstr "Kamera-Weißabgleich"
#: libkdcraw/dcrawsettingswidget.cpp:195
msgid "Automatic White Balance"
msgstr "Automatischer Weißabgleich"
#: libkdcraw/dcrawsettingswidget.cpp:196
msgid "Manual White balance"
msgstr "Manueller Weißabgleich"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
"<p><b>Weißabgleich</b>"
"<p>Konfiguration des Roh_Weißabgleichs:"
"<p><b>Standard D65 Weißabgleich</b>: Benutzt einen "
"Standardtageslichtweißabgleich D65 (dcraw Standard)."
"<p><b>Kamera-Weißabgleich</b>: Benutzt den Weißabgleich der vond er Kamera "
"vorgegebne wurde. Wenn dieser nicht verfügbar ist, dann wird der Standard, der "
"neutrale Weißabgleich benutzt."
"<p><b>Automatischer Weißabgleich</b>: Berechnet einen automatischen "
"Weißabgleich, der das gesamte Bild mittelt."
"<p><b>Manueller Weißabgleich</b>: Setzt benutzerdefinierte Temperatur und "
"Grünwerte."
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr "Temperatur (K):"
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr "<p><b>Temperatur</b><p>Setzen Sie hier die Farbtemperatur."
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr "Grün:"
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
"<p>Legen Sie hier die Grünkomponente fest, um den Grad der Magentaentfernung zu "
"bestimmen."
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Spitzlichter:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Durchgehendes Weiß"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Lösen"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Abmischen"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Rekonstruieren"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Spitzlichter</b>"
"<p>Wählen Sie hier Spitzlichterabschneidemethode:"
"<p><b>Durchgehendes Weiß</b>: setzt alle Spitzlichter auf ein durchgehendes "
"weiß."
"<p><b>Lösen</b>: lässt alle Spitzlichter gelöst in verschiedenen Schattierungen "
"von Rosa. "
"<p><b>Abmischen</b>:Mischt gelöste und befestigte Werte zusammen für eine "
"abgestufte Abblendung nach weiß."
"<p><b>Rekonstruieren</b>: rekonstruiert alle Spitzlichter durch die Benutzung "
"eines Levelwertes."
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Niveau:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Niveau</b>"
"<p>Gibt das Spitzlichterniveau des Ausgabebildes für die Rekonstruktion. "
"Niedrige Werte bevorzugen Weiss und hohe Werte Farben."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Helligkeit:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Helligkeit</b>"
"<p>Gibt das Helligkeitsniveau des Ausgabebildes an. Der Standardwert ist 1,0. "
"Diese Funktion arbeitet nur im 8-Bit Modus."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Qualität(Interpolation):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Bilinear"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr "PPG"
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
"<p><b>Qualität</b>"
"<p>Wählen Sie hier die Interpolationsmethode zum demosaicing der Rohbilder. Ein "
"demosaicing Algorithmus ist der digitale Prozess der benutzt wird um ein "
"komplettes Bild aus den Rohdaten des farbgefilterten Bildsensors zu "
"interpolieren. Dieser Sensor ist in vielen Digitalkameras in Form einer Matrix "
"von farbigen Pixeln enthalten. Demosaicing ist auch bekannt als CFA "
"Interpolation, Farbfiltermatrix oder Farbrekonstruktion. Es gibt drei Methoden "
"zur Farbrekonstruktion von Rohbildern:"
"<p><b>Bilinear</b>: benutzt einen sehr schnellen bilineare Interpolation die "
"eine schlechte Qualität erzeugt. Diese Methode ist der Standard für langsame "
"Rechner. In der Methode wird der Rotwert eines nicht-roten Pixel als der "
"Durchschnitt der benachbarten roten Pixel berechnet. Analog wird für den Blau- "
"und Grünwert verfahren."
"<p><b>VNG</b>: benutzt zur Interpolation eine Variable Nummer von Gradienten. "
"Diese Methode berechnet Gradienten neben dem interessanten Pixel und benutzt "
"die niedrigen Gradienten, die glattere und ähnlichere Teile des Bildes "
"repräsentieren, um eine Schätzung für den Pixel zu machen. "
"<p><b>PPG</b>: benutzt eine Patterned Pixel Grouping Interpolation. "
"Pixelgruppierungen gehen von Annahmen über natürliche Szenen bei Ihren "
"Schätzungen aus. Es erzeugt daher weniger Farbartefakte bei natürlichen Bildern "
"als die VNG Methode."
"<p><b>AHD</b>: benutzt eine adaptive homogenitäts-gerichtete Interpolation. "
"Diese Methode wählt die Richtung der Interpolation, so dass eine "
"Homogenitätsmetrik maximiert wird. Die minimiert typischerweise Farbartefakte."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Rauschminderung einschalten"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Rauschminderung einschalten</b>"
"<p>Benutzt Wavelets um Rauschen zu löschen und dabei die echten Details zu "
"erhalten."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Schwellwert:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
"<p><b>Schwellwert</b>"
"<p>Geben Sie hier den Schwellwert ein, der für die Rauschminderung benutzt "
"wird."
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr "Farbabweichungskorrektur einschalten"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
"<p><b>Farbabweichungskorrektur einschalten</b>"
"<p>Vergrößert die Rot- und Blau-Ebenen der Rohdaten, um einen gegebenen Faktor, "
"üblicherweise zwischen 0,999 und 1,001, um farbabweichungen zu korrigieren."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Rotmultiplikator:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
"<p><b>Rotmultiplikator</b>"
"<p>Geben Sie hier den Vergrößerungsfaktor der Rotebene."
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Blaumultiplikator:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
"<p><b>Rotmultiplikator</b>"
"<p>Geben Sie hier den Vergrößerungsfaktor der Rotebene."
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Farbraum:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Roh (linear)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Wide Gamut"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-Foto"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Farbraum</b>"
"<p>Wählen Sie hier den Ausgabefarbraum für die dekodierten Rohdaten."
"<p><b>Roh (linear)</b>: in diesem Modus wird kein Ausgabefarbraum während der "
"Rohdekodierung benutzt."
"<p><b>sRGB</b>: dieser Farbraum ist ein RGB Farbraum, der in Kooperation "
"zwischen Hewlett-Packard und Microsoft erstellt wurde. Er ist die beste Wahl "
"für Bilder die für das Web oder als Portrait gedacht sind."
"<p><b>Adobe RGB</b>: dieser Farbraum ist ein RGB Farbraum, der von Adobe "
"entwickelt wurde. Er ist gedacht für Fotoanwendungen wie Werbung und Kunst."
"<p><b>Wide-Gamut</b>: dieser Farbraum ist eine erweiterte Version des Adobe RGB "
"Farbraums."
"<p><b>Pro-Foto</b>: dieser Farbraum ist ein RGB Farbraum, der von Kodak "
"entwickelt wurde. Er ermöglicht eine sehr große Farbskala (Gamut) und wurde für "
"die fotographische Ausgabe designt."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Standard"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Pixel nicht dehnen oder drehen"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>Pixel nicht dehnen oder drehen</b>"
"<p>Zeigt das Bild um 45 Grad gekippt für Fuji Super CCD Kameras. Für Kameras "
"mit nicht-quadratischen Pixeln wird das Bild nicht auf das richtige "
"Seitenverhältnis gedehnt. Diese Option sorgt also in allen Fälllen, dass jeder "
"Ausgabepixel genau einem Rohpixel entspricht."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Schwarzpunkt"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Schwarzpunkt</b>"
"<p>Benutzt einen spezifischen Schwarpunktwert, um die Rohbilder zu dekodieren. "
"Wenn Sie diese Option ausschalten, dann wird der Schwarzpzunktwert automatisch "
"berechnet."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Schwarzpunktwert</b>"
"<p>Geben Sie den spezifischen Schwarzpunktwert des Ausgabebildes an."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Erweitert"

3
po/el/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = el
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

485
po/el/libkdcraw.po
Unescape View File

@ -0,0 +1,485 @@
# translation of libkdcraw.po to Greek
#
# Spiros Georgaras <sng@hellug.gr>, 2007.
# Toussis Manolis <manolis@koppermind.homelinux.org>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-07-16 20:13+0300\n"
"Last-Translator: Spiros Georgaras <sng@hellug.gr>\n"
"Language-Team: Greek <i18ngr@lists.hellug.gr>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>Αδυναμία εύρεσης του εκτελέσιμου <b>%1</b>:"
"<br>Αυτό το πρόγραμμα απαιτείται για την υποστήριξη της ακατέργαστης μορφής "
"Raw. Μπορείτε να συνεχίσετε, αλλά δε θα είναι δυνατός ο χειρισμός των εικόνων "
"Raw. Παρακαλώ ελέγξτε την εγκατάσταση του πακέτου libkdcraw στον υπολογιστή "
"σας."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p>Το εκτελέσιμο <b>%1</b> δεν είναι ενημερωμένο:"
"<br> Βρέθηκε η έκδοση %2 αυτού του προγράμματος στον υπολογιστή σας. Η έκδοση "
"αυτή είναι πολύ παλιά για τη σωστή λειτουργία του προγράμματος. Μπορείτε να "
"συνεχίσετε αλλά θα είναι αδύνατος ο χειρισμός ακατέργαστων εικόνων Raw. "
"Παρακαλώ ελέγξτε την εγκατάσταση του πακέτου libkdcraw στον υπολογιστή σας."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "Βάθος χρώματος 16 bits"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Αν ενεργοποιηθεί, όλα τα αρχεία RAW θα αποκωδικοποιούνται με βάθος χρώματος "
"16-bit χρησιμοποιώντας γραμμική καμπύλη γάμμα. Προτείνεται η χρήση διαχείρισης "
"χρωμάτων σε αυτήν τη λειτουργία για την αποφυγή σκοτεινής αποτύπωσης της "
"εικόνας στον επεξεργαστή. "
"<p>Αν απενεργοποιηθεί, όλα τα αρχεία RAW θα αποκωδικοποιούνται με βάθος "
"χρώματος 8-bit με χρήση καμπύλης γάμμα BT.709 και λευκό σημείο 99ου "
"εκατοστημόριου. Αυτή η μέθοδος είναι πιο γρήγορη από την αποκωδικοποίηση "
"16-bit."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "Απόδοση του RGB ως τέσσερα χρώματα"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>Παρεμβολή RGB ως τετραχρωμία</b>"
"<p>Όλα τα πράσινα εικονοστοιχεία είναι όμοια εξ ορισμού. Αν τα πράσινα "
"εικονοστοιχεία στις μονές γραμμές είναι πιο ευαίσθητα από τα ζυγά στο υπεριώδες "
"φως, αυτό δημιουργεί κάποιο μοτίβο στην έξοδο: χρησιμοποιώντας αυτή την επιλογή "
"λύνεται αυτό το πρόβλημα με ελάχιστη απώλεια λεπτομέρειας."
"<p>Αυτή η επιλογή θολώνει ελαφριά την εικόνα, αλλά εξαφανίζει εσφαλμένα μοτίβα "
"2x2 με τη μέθοδο ποιότητας VNG ή γραμμώσεις με τη μέθοδο ποιότητας AHD."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Επισκεφτείτε το δικτυακό τόπο του dcraw"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "Χρήση ισορροπίας λευκού της φωτογραφικής"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "Αυτόματη ισορροπία χρώματος"
#: libkdcraw/dcrawsettingswidget.cpp:196
#, fuzzy
msgid "Manual White balance"
msgstr "Χρήση ισορροπίας λευκού της φωτογραφικής"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
#, fuzzy
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
"<p><b>Κατώφλι</b>"
"<p>Ορίστε εδώ το κατώφλι μείωσης θορύβου που θα χρησιμοποιηθεί."
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Υψηλοί τόνοι:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Συμπαγές λευκό"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Αναίρεση αποκοπής"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Ανάμειξη"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Επανακατασκευή"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Υψηλοί τόνοι</b>"
"<p>Επιλέξτε εδώ τη μέθοδο αποκοπής των υψηλών τόνων:"
"<p><b>Συμπαγές λευκό</b>: αποκοπή όλων των υψηλών τόνων και μετατροπή τους σε "
"συμπαγές λευκό"
"<p><b>Χωρίς αποκοπή</b>: Οι υψηλοί τόνοι παραμένουν όπως είναι σε διάφορες "
"σκιάσεις του ροζ "
"<p><b>Ανάμειξη</b>: Ανάμειξη των αποκομμένων και μη αποκομμένων τιμών ώστε να "
"επιτευχθεί μια ομαλή μετάβαση προς το λευκό"
"<p><b>Επανακατασκευή</b>: Αναδόμηση των υψηλών τόνων χρησιμοποιώντας μια τιμή "
"για το επίπεδο"
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Επίπεδο:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Επίπεδο</b>"
"<p>Καθορισμός του επιπέδου αναδόμησης των υψηλών τόνων. Οι χαμηλές τιμές "
"ευνοούν το λευκό και οι υψηλές τιμές ευνοούν τα χρώματα."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Φωτεινότητα:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Φωτεινότητα</b>"
"<p>Καθορισμός του επιπέδου φωτεινότητας της εικόνας εξόδου. Η προκαθορισμένη "
"τιμή είναι 1.0 (μόνο σε λειτουργία 8-bit)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Ποιότητα (παρεμβολή):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Bilinear"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
#, fuzzy
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
"<p><b>Ποιότητα</b>"
"<p>Επιλέξτε εδώ τη μέθοδο demosaicing αποκωδικοποίησης παρεμβολής των αρχείων "
"RAW. Ο αλγόριθμος demosaicing είναι μία μέθοδος που χρησιμοποιείται για τη "
"σύνθεση μίας ψηφιακής εικόνας από τα επί μέρους raw δεδομένα που λαμβάνονται "
"από τον χρωματικά φιλτραρισμένο αισθητήρα εικόνας. που υπάρχει σε πολλές "
"φωτογραφικές μηχανές με τη μορφή ενός πίνακα χρωματιστών εικονοστοιχείων. Είναι "
"επίσης γνωστή ως παρεμβολή CFA ή ανασυγκρότηση χρώματος. Υπάρχουν τρεις μέθοδοι "
"demosaicing εικόνων RAW:"
"<p><b>Διγραμμική</b>: χρησιμοποιεί υψηλής ταχύτητας αλλά χαμηλής ποιότητας "
"διγραμμική παρεμβολή (προκαθορισμένο για πιο αργούς υπολογιστές). Σε αυτή τη "
"μέθοδο, η τιμή του κόκκινου ενός μη κόκκινου εικονοστοιχείου, υπολογίζεται από "
"το μέσο όρο των γειτονικών κόκκινων εικονοστοιχείων. Το ίδιο γίνεται για το "
"μπλε και το πράσινο."
"<p><b>VNG</b>: χρησιμοποιεί την παρεμβολή Variable Number of Gradients. Αυτή η "
"μέθοδος υπολογίζει τις κλίσεις κοντά στο εξεταζόμενο εικονοστοιχείο και "
"χρησιμοποιεί τις χαμηλότερες από αυτές (που αναπαριστούν ομαλότερες διαφορές "
"και παρόμοια τμήματα της εικόνας) για την εξαγωγή μιας εκτιμώμενης τιμής."
"<p><b>AHD</b>: χρησιμοποιεί την παρεμβολή Adaptive Homogeneity-Directed. Αυτή η "
"μέθοδος επιλέγει την κατεύθυνση της παρεμβολής με τέτοιο τρόπο ώστε να "
"μεγιστοποιείται το ποσοστό ομοιογένειας, ελαχιστοποιώντας τα σφάλματα χρώματος."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Ενεργοποίηση μείωσης θορύβου"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Ενεργοποίηση μείωσης θορύβου</b>"
"<p>Χρήση κυματομορφών για την αφαίρεση του θορύβου με ταυτόχρονη διατήρηση της "
"πραγματικής λεπτομέρειας."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Κατώφλι:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
"<p><b>Κατώφλι</b>"
"<p>Ορίστε εδώ το κατώφλι μείωσης θορύβου που θα χρησιμοποιηθεί."
#: libkdcraw/dcrawsettingswidget.cpp:324
#, fuzzy
msgid "Enable Chromatic Aberration correction"
msgstr "Ενεργοποίηση μείωσης θορύβου"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Κόκκινος πολλαπλασιαστής:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Μπλε πολλαπλασιαστής:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Χώρος χρωμάτων:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Ακατέργαστο (γραμμικό)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Ευρεία γκάμα"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-Photo"
#: libkdcraw/dcrawsettingswidget.cpp:361
#, fuzzy
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Χώρος χρωμάτων</b>"
"<p>Επιλέξτε εδώ το χρωματικό χώρο εξόδου για την αποκωδικοποίηση δεδομένων RAW."
"<p><b>Ακατέργαστο (γραμμικό)</b>: σε αυτήν τη λειτουργία δε χρησιμοποιείται "
"κανένας χώρος χρωμάτων κατά την αποκωδικοποίηση RAW."
"<p><b>sRGB</b>: αυτός ο χρωματικός χώρος βασίζεται στο χρώμα RGB, ενώ "
"δημιουργήθηκε σε συνεργασία με τη Hewlett-Packard και τη Microsoft. Είναι η "
"καλύτερη επιλογή για εικόνες που προορίζονται για ιστοσελίδες και φωτογραφίες "
"προσώπων."
"<p><b>Adobe RGB</b>: αυτός ο χρωματικός χώρος είναι επίσης ένας χώρος RGB που "
"αναπτύχθηκε από την Adobe, που χρησιμοποιείται για εφαρμογές φωτογραφίας όπως "
"διαφημίσεις και τέχνη. "
"<p><b>Ευρεία γκάμα</b>: αυτός ο χρωματικός χώρος πρόκειται για μια εκτεταμένη "
"έκδοση του χώρου χρωμάτων Adobe RGB."
"<p><b>Pro-Photo</b>: πρόκειται για χώρο χρωμάτων RGB που αναπτύχθηκε από την "
"Kodak, και προσφέρει μια μεγάλη χρωματική γκάμα σχεδιασμένη για χρήση σε "
"φωτογραφικές εφαρμογές."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Τυπικός"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Να μη γίνει τράβηγμα ή περιστροφή εικονοστοιχείων"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>Να μη γίνει τράβηγμα ή περιστροφή εικονοστοιχείων</b>"
"<p>Για τις φωτογραφικές μηχανές με CCD Fuji Super, εμφάνιση της εικόνας με "
"περιστροφή 45 μοιρών. Για φωτογραφικές μη μη τετράγωνα εικονοστοιχεία, να μη "
"γίνει τράβηγμα της εικόνας στη σωστή της αναλογία διαστάσεων. Σε κάθε "
"περίπτωση, αυτή η επιλογή εγγυάται ότι κάθε εικονοστοιχείο εξόδου αντιστοιχεί "
"σε ένα εικονοστοιχείο της ακατέργαστης μορφής RAW."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Μαύρο σημείο"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Μαύρο σημείο</b>"
"<p>Χρήση μιας συγκεκριμένης τιμής μαύρου σημείου για την αποκωδικοποίηση των "
"ακατέργαστων εικόνων RAW. Αν απενεργοποιήσετε αυτήν την επιλογή, η τιμή του "
"μαύρου σημείου θα υπολογιστεί αυτόματα."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Τιμή μαύρου σημείου</b>"
"<p>Καθορίστε συγκεκριμένη τιμή του μαύρου σημείου για την εικόνα εξόδου."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Προχωρημένα"
#~ msgid "<p><b>Use camera white balance</b><p>Use the camera's custom white-balance settings. If this can not be found, reverts to the default (which is to use fixed daylight values, calculated from sample images)."
#~ msgstr "<p><b>Χρήση ισορροπίας λευκού της φωτογραφικής μηχανής</b><p>Γίνεται χρήση των προσαρμοσμένων ρυθμίσεων ισορροπίας λευκού της φωτογραφικής μηχανής. Αν αυτές είναι αδύνατο να βρεθούν γίνεται επαναφορά των προκαθορισμένων ρυθμίσεων (χρήση σταθερών τιμών για το φως της ημέρας, υπολογισμένες από εικόνες δείγματα)."
#~ msgid "<p><b>Automatic color balance</b></p>Calculate the white balance by averaging the entire image."
#~ msgstr "<p><b>Αυτόματη ισορροπία χρώματος</b><p>Υπολογισμός της ισορροπίας λευκού χρώματος με βάση τη μέση τιμή ολόκληρης της εικόνας."
#~ msgid "Color balance multipliers"
#~ msgstr "Πολλαπλασιαστές ισορροπίας χρώματος"
#~ msgid "Green 1 multiplier:"
#~ msgstr "Πράσινος πολλαπλασιαστής 1:"
#~ msgid "Green 2 multiplier:"
#~ msgstr "Πράσινος πολλαπλασιαστής 2:"

3
po/es/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = es
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

496
po/es/libkdcraw.po
Unescape View File

@ -0,0 +1,496 @@
# translation of libkdcraw.po to Español
# Pablo Pita Leira <pablo.pita@kdemail.net>, 2007.
# santi <santi@kde-es.org>, 2007.
# Santiago Fernández Sancho <santi@kde-es.org>, 2007.
# translation of libkdcraw.po to
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-08-23 18:07+0200\n"
"Last-Translator: Santiago Fernández Sancho <santi@kde-es.org>\n"
"Language-Team: Español <kde-es@kybs.de>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-POFile-SpellExtra: CCD Adaptive Homogeneity CIELab VNG Fuji RAW Hewlett\n"
"X-POFile-SpellExtra: Variable Directed Packard dcraw Kodak AHD libkdcraw\n"
"X-POFile-SpellExtra: of Number CFA Gamute sRGB Photo Gradients BT\n"
"X-Generator: KBabel 1.11.4\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>No se encontró el ejecutable <b>%1</b>:"
"<br>Este programa binario es necesario para soportar los formatos de archivo "
"RAW. Podrá continuar, pero no será capaz de trabajar con las imágenes RAW. "
"Compruebe la instalación del paquete «libkdcraw» en su equipo."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p>El ejecutable <b>%1</b> no está actualizado:"
"<br>Se ha encontrado la versión %2 de este programa binario en su equipo. Esta "
"versión es demasiado antigua para funcionar correctamente. Podrá continuar, "
"pero no será capaz de trabajar con las imágenes RAW. Compruebe la instalación "
"del paquete «libkdcraw» en su equipo."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "Profundidad de color de 16 bits"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Si activa la opción, todos los archivos RAW serán descodificados para una "
"profundidad de color de 16 bits, usando una curva de gamma linear. Para evitar "
"el mostrar imágenes negras en el editor, se recomienda que use el gestor de "
"colores en este modo. "
"<p>Si desactivada, todos los archivos RAW serán descodificados para una "
"profundidad de color de 8 bits, con una curva de gama BT.709 y un punto blanco "
"en el percentil-99. Este modo es mas rápido que la descodificación de 16 bits."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "Interpolar el RGB como cuatro colores"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>Interpolar el RGB como cuatro colores.</b>"
"<p>De forma predeterminada se asume que todos los puntos verdes son lo mismo. "
"Si los puntos verdes de las líneas pares fuesen más sensibles a la luz "
"ultravioleta que los de las lineas impares esta diferencia causa un patrón "
"reticular en el resultado; si se usa esta opción, se resuelve el problema con "
"una mínima pérdida de detalle."
"<p>En resumen, esta opción borra la imagen un poco, pero elimina los falsos "
"patrones en malla 2x2 con el método de calidad VNG o los laberintos con el "
"método AHD."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Visite el sitio web del proyecto «dcraw»"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "Usar el balance de blancos de la cámara"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "Balance de colores automático"
#: libkdcraw/dcrawsettingswidget.cpp:196
#, fuzzy
msgid "Manual White balance"
msgstr "Usar el balance de blancos de la cámara"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
#, fuzzy
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
"<p><b>Multiplicador rojo</b>"
"<p>Establezca aquí el factor de aumento de la capa roja"
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Tonos claros:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Blanco puro"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "No superponer"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Mezclar"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Reconstruir"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Tonos claros</b>"
"<p>Seleccione aquí el método de recorte de los tonos claros:"
"<p><b>Blanco puro</b>: ajusta todos los tonos claros hacia un blanco puro "
"<p><b>No superponer</b>: Deja los tonos claros de las diferentes zonas en "
"varios tonos de rosa"
"<p><b>Mezclar</b>: Combina los valores de las diferentes zonas para conseguir "
"una transición gradual hacia el blanco"
"<p><b>Reconstruir</b>: reconstruye los tonos claros, usando un valor de nivel"
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Nivel:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Nivel</b>"
"<p>Indica el nivel de tonos claros en la reconstrucción. Los valores bajo "
"favorecen los blancos y los valores altos favorecen los colores."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Brillo:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Brillo</b>"
"<p>Indique el nivel de brillo de la imagen resultante. El valor predeterminado "
"es 1,0 (solo funciona en el modo de 8-bit)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Calidad (interpolación):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Bilinear"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr "PPG"
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
"<p><b>Calidad</b>"
"<p>Seleccione aquí el método de interpolación en la decodificación para "
"eliminar el mosaico de las imágenes RAW. Un algoritmo de borrado de mosaicos es "
"un proceso digital sobre la imagen usado para interpolar una imagen completa a "
"partir de los datos parciales en bruto que son recibidos desde el sensor de "
"imagen con filtros de colores, sensor interno en muchas cámaras digitales en "
"forma de una matriz de puntos coloreados. Se conoce también por interpolación "
"CFA o reconstrucción de colores, siendo el otro término común el borrado de "
"mosaicos. Existen 4 métodos para borrar los mosaicos de las imágenes RAW:"
"<p><b>Bilinear</b>: usa la interpolación bilinear, rápida pero de baja calidad "
"(predeterminado para máquinas lentas). En este método, el valor de rojo de un "
"punto no-rojo se calcula como la media de los puntos rojos adyacentes, "
"aplicándose el mismo principio para el verde y el azul."
"<p><b>VNG</b>: usa la interpolación de número de gradientes variable (del "
"inglés Variable Number of Gradients). Este método calcula los gradientes, "
"próximos al punto de interés, y usa los gradientes menores (que representan las "
"partes mas suaves y semejantes de la imagen) para hacer una estimación. "
"<p><b>PPG</b>: utiliza la interpolación por agrupación de puntos en patrones "
"(del inglés Patterned Pixel Grouping). La agrupación de puntos hace "
"estimaciones para paisajes naturales. Existen pocos artefactos de color en las "
"imágenes naturales en contraposición al método del número de gradientes "
"variable."
"<p><b>AHD</b>: usa la interpolación adaptativa y direccionada a la homogeneidad "
"(del inglés Adaptive Homogeneity-Directed). Este método selecciona la dirección "
"de interpolación, de modo a maximizar una métrica de homogeneidad, minimizando "
"de esta forma los artefactos de colores."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Activar la reducción de ruido"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Activar reducción de ruido</b>"
"<p>Usa wavelets para borrar el ruido mientras se preserva los detalles reales."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Umbral:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
"<p><b>Umbral:</b>"
"<p>Configure aquí el umbral para la reducción de ruido."
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr "Activar la corrección de aberración cromática"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
"<p><b>Activar la corrección de aberración cromática</b>"
"<p>Amplía las capas de rojo y de azul en bruto de acuerdo a los factores dados, "
"normalmente 0,999 y 1,001, para corregir la aberración cromática."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Multiplicador rojo:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
"<p><b>Multiplicador rojo</b>"
"<p>Establezca aquí el factor de aumento de la capa roja"
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Multiplicador azul:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
"<p><b>Multiplicador azul</b>"
"<p>Establezca aquí el factor de aumento de la capa azul"
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Espacio de colores:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Bruto (linear)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "RGB de Adobe"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Espectro amplio"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-Photo"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Espacio de color</b>"
"<p>Seleccione aquí el espacio de color resultante utilizado para decodificar "
"los datos RAW."
"<p><b>Bruto (linear)</b>: en este modo, no se usa ningún espacio de colores "
"como resultado de la decodificación del RAW."
"<p><b>sRGB</b>: este espacio de colores es un espacio de colores RGB, "
"desarrollado en cooperación entre Hewlett-Packard y Microsoft, siendo la mejor "
"elección para imágenes destinadas a la web y a los retratos fotográficos."
"<p><b>RGB de Adobe</b>: este espacio de colores es un espacio de colores RGB, "
"desarrollado por Adobe, que se usa en aplicaciones de fotografía tales como la "
"publicidad y el arte."
"<p><b>Espectro amplio</b>: este espacio de colores es una versión expandida del "
"espacio de colores RGB de Adobe."
"<p><b>Pro-Photo</b>: este espacio de colores es un espacio RGB, desarrollado "
"por Kodak, que ofrece un espectro especialmente grande, diseñado para usarse "
"con resultados fotográficos."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Estándard"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "No modificar o girar los puntos"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>No modificar o girar los puntos</b>"
"<p>En las máquinas Fuji Super CCD, muestra la imagen girada 45 grados. Para las "
"máquinas con puntos no-cuadrados, no modifica la imagen a su proporción "
"correcta. En cualquiera de los dos casos, esta opción garantiza que cada punto "
"en el resultado corresponda a un punto RAW."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Punto negro"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Punto negro</b>"
"<p>Usar un valor específico de punto negro para decodificar las imagenes RAW. "
"Si deshabilita esta opción, el valor del punto negro se calculará "
"automaticamente."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Valor del punto negro</b>"
"<p>Especifique un valor del punto negro de la imagen resultado."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Avanzado"
#~ msgid "<p><b>Use camera white balance</b><p>Use the camera's custom white-balance settings. If this can not be found, reverts to the default (which is to use fixed daylight values, calculated from sample images)."
#~ msgstr "<p><b>Usar el balance de blancos de la cámara</b><p>Utiliza una configuración personalizada de balance de blancos de la cámara fotográfica. Si no existe configuración se vuelve al valor predeterminado (que utiliza valores fijos de la luz del día, calculados a partir de imágenes de muestra)."
#~ msgid "<p><b>Automatic color balance</b></p>Calculate the white balance by averaging the entire image."
#~ msgstr "<p><b>Balance de color automático</b></p>Calcula el balance de blanco utilizando el valor medio de la imagen completa."
#~ msgid "Color balance multipliers"
#~ msgstr "Multiplicadores del balance de color"
#~ msgid "Green 1 multiplier:"
#~ msgstr "Multiplicador verde 1:"
#~ msgid "Green 2 multiplier:"
#~ msgstr "Multiplicador verde 2:"

3
po/et/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = et
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

479
po/et/libkdcraw.po
Unescape View File

@ -0,0 +1,479 @@
# translation of libkdcraw.po to Estonian
#
# Marek Laane <bald@starman.ee>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-09-23 19:50+0300\n"
"Last-Translator: Marek Laane <bald@starman.ee>\n"
"Language-Team: Estonian <kde-et@linux.ee>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>Programmi <b>%1</b> ei leitud:"
"<br> Seda programmi on vaja toorfailivormingute toetamiseks. Jätkata võib ka "
"ilma selleta, aga sel juhul ei ole võimalik toorfailivormingus pilte vaadata "
"ega redigeerida. Palun kontrolli libkdcraw paigaldust oma arvutis."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p>Programm <b>%1</b> on vananenud:"
"<br> Arvutis leiti selle versioon %2. See versioon on liiga vana, et seda saaks "
"korralikult kasutada. Jätkata võib muidugi ka sellega, aga siis ei ole võimalik "
"toorfailivormingus pilte vaadata ega redigeerida. Palun kontrolli libkdcraw "
"paigaldust oma arvutis."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16-bitine värvisügavus"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Sisselülitamisel dekodeeritakse kõik toorfailid lineaarset gammakõverat "
"kasutades 16-bitisele värvisügavusele. Musta pildi renderdamise vältimiseks "
"redaktoris on soovitatav selles režiimis kasutada värvihaldust."
"<p>Kui see pole sisse lülitatud, dekodeeritakse kõik toorfailid 8-bitisele "
"värvisügavusele, kasutades BT.709 gammakõverat ja 99-protsendist valgepunkti. "
"See režiim on kiirem kui 16-bitine dekodeerimine."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "RGB interpoleerimine nelja värvina"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>RGB interpoleerimine nelja värvina</b>"
"<p>Vaikimisi eeldatakse, et kõik rohelised pikslid on ühesugused. Kui paarisrea "
"rohelised pikslid on ultravioletile tundlikumad kui paaritu rea omad, põhjustab "
"see erinevus väljundis võrkmustrit. Antud valiku sisselülitamisel saab sellest "
"probleemist üle minimaalse detailikaoga."
"<p>Üldiselt hägustab selle valiku kasutamine veidi pilti, kuid kõrvaldab "
"see-eest 2x2 libavõrkmustri VNG kvaliteedimeetodi või siksakid AHD "
"kvaliteedimeetodi korral."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "dcraw projekti veebilehekülg"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "Kaamera värvustasakaalu kasutamine"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "Automaatne värvibalanss"
#: libkdcraw/dcrawsettingswidget.cpp:196
#, fuzzy
msgid "Manual White balance"
msgstr "Kaamera värvustasakaalu kasutamine"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
#, fuzzy
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
"<p><b>Punase kordaja</b>"
"<p>Siin saab määrata punase kihi suurendusteguri"
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Heledad toonid:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Ühtlane valge"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Ei lõigata"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Sulandatakse"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Rekonstrueeritakse"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Heledad toonid</b>"
"<p>Siin saab valida heledate toonide lõikamise meetodi:"
"<p><b>Ühtlane valge</b>: kõik heledad toonid lõigatakse ühtlaseks valgeks"
"<p><b>Ei lõigata</b>: heledad toonid jäetakse lõikamata roosa erinevateks "
"varjunditeks"
"<p><b>Sulandatakse</b>:lõigatud ja lõikmata väärtused sulandatakse "
"järk-järgulise üleminekuna valgesse"
"<p><b>Rekonstrueeritakse</b>: heledad toonid rekonstrueeritakse taseme väärtust "
"kasutades."
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Tase:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Tase</b>"
"<p>Määrab väljundpildi heledate toonide rekonstrueerimise taseme. Väiksemad "
"väärtused eelistavad valget, kõrgemad värve."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Heledus:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Heledus</b>"
"<p>Määrab väljundpildi heledustaseme. Vaikeväärtus on 1,0 (toimib ainult "
"8-bitises režiimis)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Kvaliteet (interpoleerimine):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Bilineaarne"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr "PPG"
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
"<p><b>Kvaliteet</b>"
"<p>Siin saab valida toorpiltide dekodeerimisel kasutatava "
"värvirekonstruktsiooni (demosaicing) interpoleerimismeetodi. "
"Värvirekonstruktsiooni algoritm on mõeldud terve pildi interpoleerimiseks "
"osaliste toorandmete põhjal, mida edastab digikaamera värvifiltrit kasutav "
"pildisensor värvitud pikslite maatriksi kujul. Seda nimetatakse ka CFA "
"interpoleerimiseks. Toorpiltide värvirekonstruktsiooniks on neli viisi:"
"<p><b>Bilineaarne</b>: kasutatakse väga kiiret, aga kesise kvaliteediga "
"bilineaarset interpoleerimist (aeglasematel arvutitel on see samas väga "
"mõistlik, sellepärast on see ka vaikeväärtus). Selle korral arvutatakse "
"mittepunase piksli punase värvi väärtus naabruses asuvate punaste pikslite "
"keskmisena; sama kehtib ka sinise ja rohelise kohta."
"<p><b>VNG</b>: kasutatakse üleminekute muutarvu (Variable Number of Gradients) "
"interpoleerimist. See arvutab üleminekud huvipakkuva piksli läheduses ja "
"kasutab hindamiseks väiksema väärtusega üleminekuid (need esindavad ühtlasemaid "
"pildiosi)."
"<p><b>PPG</b>: kasutatakse pikslite mustri alusel rühmitamise (Patterned Pixel "
"Grouping) interpoleerimist. Pikslite rühmitamisel võetakse hindamisel aluseks "
"loodusvaated. Loodusvaadete puhul tekib artefakte vähem kui üleminekute "
"muutarvu interpoleerimise korral."
"<p><b>AHD</b>: kasutatakse adaptiivset homogeensust arvestavat (Adaptive "
"Homogenity-Directed) interpoleerimist. Selle korral valitakse interpoleerimise "
"suund maksimaalselt homogeensust arvetades, mis tavaliselt võimaldab "
"minimeerida artefaktide esinemist.</p>"
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Müra vähendamise lubamine"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Müra vähendamise lubamine</b>"
"<p>Kasutatakse lainikuid, mis mahendavad müra, säilitades samas servad.</p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Lävi:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr "<p><b>Lävi</b><p>Siin saab määrata kasutatava müra vähendamise läve."
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr "Värviaberratsiooni korrigeerimise lubamine"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
"<p><b>Värviaberratsiooni korrigeerimise lubamine</b>"
"<p>Toorpildi punast ja sinist kihti suurendatakse värviaberratsiooni "
"parandamiseks määratud teguri võrra (tavaliselt 0,999 kuni 1,001)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Punase kordaja:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
"<p><b>Punase kordaja</b>"
"<p>Siin saab määrata punase kihi suurendusteguri"
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Sinise kordaja:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
"<p><b>Sinise kordaja</b>"
"<p>Siin saab määrata sinise kihi suurendusteguri"
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Värviruum:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Toores (lineaarne)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Wide Gamut"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-Photo"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Värviruum</b>"
"<p>Siin saab valida toorandmete dekodeerimisel kasutatava väljundvärviruumi."
"<p><b>Toores (lineaarne)</b>: selle korral ei kasutada toorpiltide "
"dekodeerimisel väljundvärviruumi."
"<p><b>sRGB</b>: see on RGB värviruum, mille lõid Hewlett-Packard ja Microsoft. "
"See on parim valik piltidele, mis on mõeldud veebi jaoks, samuti portreedele."
"<p><b>Adobe RGB</b>: see on Adobe poolt laiendatud RGB värviruum. Seda "
"kasutatakse laialdaselt fotograafias, näiteks reklaamides ja kunstiteostes."
"<p><b>Wide Gamut</b>: see on Adobe RGB värviruumi laiendatud versioon."
"<p><b>Pro-Photo</b>: see on Kodaki loodud RGB värviruum, mis pakub "
"spetsiaalselt fotograafilist väljundit silmas pidades eriti avarat "
"värviulatust."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Standard"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Piksleid ei venitata ega pöörata"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>Piksleid ei venitata ega pöörata</b>"
"<p>Fuji Super CCD kaamerate korral näidatakse pilti 45 kraadi all kallutatuna. "
"Kaamerate puhul, mille pikslid pole ruudukujulised, ei venitata pilti korrektse "
"proportsiooni saavutamiseks. See valik tagab, et iga väljundpiksel vastab alati "
"kindlale toorpildi pikslile."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Mustpunkt"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Mustpunkt</b>"
"<p>Toorpiltide dekodeerimisel kasutatakse konkreetset mustpunkti väärtust. Kui "
"see on sisse lülitamata, arvutatakse mustpunkti väärtus automaatselt."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Mustpunkti väärtus</b>"
"<p>Siin saab määrata väljundipildi konkreetse mustpunkti väärtuse."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Muud"
#~ msgid "<p><b>Use camera white balance</b><p>Use the camera's custom white-balance settings. If this can not be found, reverts to the default (which is to use fixed daylight values, calculated from sample images)."
#~ msgstr "<p><b>Kaamera värvustasakaalu kasutamine</b><p>Kasutatakse kaamera kohandatud värvustasakaalu seadistusi. Vaikimisi pruugitakse fikseeritud päevavalguse väärtusi, mis on arvutatud näidispiltide põhjal. Kui seda ei leita, kasutatakse vaikeväärtusi."
#~ msgid "<p><b>Automatic color balance</b></p>Calculate the white balance by averaging the entire image."
#~ msgstr "<p><b>Automaatne värvibalanss</b></p>Valge tasakaalu arvutamine kogu pildi keskmise põhjal."
#~ msgid "Color balance multipliers"
#~ msgstr "Värvustasakaalu kordajad"
#~ msgid "Green 1 multiplier:"
#~ msgstr "Rohelise 1 kordaja:"
#~ msgid "Green 2 multiplier:"
#~ msgstr "Rohelise 2 kordaja:"

3
po/is/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = is
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

476
po/is/libkdcraw.po
Unescape View File

@ -0,0 +1,476 @@
# translation of libkdcraw.po to icelandic
#
# Sveinn í Felli <sveinki@nett.is>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-09-10 13:34+0000\n"
"Last-Translator: Sveinn í Felli <sveinki@nett.is>\n"
"Language-Team: icelandic <kde-isl@molar.is>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>Tekst ekki að finna <b>%1</b> forritið:"
"<br>Þetta tvíundarforrit er nauðsynlegt til að styðja RAW skráarsniðið. Þú "
"getur haldið áfram, en þá geturðu ekki meðhöndlað neinar RAW myndir. "
"Vinsamlegast athugaðu uppsetningu libkdcraw pakkans á tölvunni þinni."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p><b>%1</b> forritið hefur ekki verið uppfært:"
"<br> Útgáfa %2 af þessu tvíundarforriti fannst á tölvunni þinni. Sú útgáfa er "
"of gömul til að keyra á viðunandi máta. Þú getur haldið áfram, en þá geturðu "
"ekki meðhöndlað neinar RAW myndir. Vinsamlegast athugaðu uppsetningu libkdcraw "
"pakkans á tölvunni þinni."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16 bita litadýpt"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Ef þetta er vikjað, þá munu allar RAW skrár verða afkóðaðar í 16-bita "
"litadýpt samkvæmt línulegum litrófsferli. Til að koma í veg vyrir dökka "
"myndgerð í myndvinnsluhamnum, þá er mælt með að notuð sé litastýring (Color "
"Management) í þessum ham."
"<p>Ef þetta er óvirkt munu allar RAW skrár verða afkóðaðar í 8-bita litadýpt "
"samkvæmt BT.709 litrófsferli og 99th-percentile hvítvægi. Þessi aðferð er mun "
"hraðvirkari en 16-bita afkóðun."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "Breyta RGB í fjóra liti"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>Breyta RGB í fjóra liti</b>"
"<p>Sjálfgefið er að álykta að allir grænir dílar séu eins. Ef grænir dílar í "
"slétttölulínum eru viðkvæmari fyrir útfjólubláu ljósi heldur en oddatölulínum "
"þá getur sá munur valdið netmynstri í úttakinu; það að nota þessa aðferð leysir "
"það vandamál án þess að fórna miklu af smáatriðum."
"<p>Nánar; aðgerðin afskerpir myndina lítillega, en á móti eyðir hún tilbúnu 2x2 "
"netmynstri með VNG-gæða aðferðinni eða AHD-gæðum."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Heimsækja vef dcraw verkefnisins"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "Nota hvítvægi frá myndavél"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "Sjálfvirkt litavægi"
#: libkdcraw/dcrawsettingswidget.cpp:196
#, fuzzy
msgid "Manual White balance"
msgstr "Nota hvítvægi frá myndavél"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
#, fuzzy
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr "<p><b>Margfeldi rauðs</b><p>Stilltu hér stækkun rauða litlagsins"
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Hátónar:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Heilhvítur"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Afklemma"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Blanda"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Endurbyggja"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Hátónar</b>"
"<p>Veldu hér hvernig hátónar verða meðhöndlaðir:"
"<p><b>Heilhvítt</b>: Klippa alla hátóna yfir að heilum hvítum lit"
"<p><b>Óklippt</b>: Skilja alla hátóna eftir í ýmsum blæbrigðum af ljósbleikum "
"<p><b>Blend</b>:Bland klipptum og óklipptum gildum saman stígandi í áttina til "
"hvíts"
"<p><b>Endurbyggja</b>: Endurbyggja hátóna miðað við gildi hvítvægis."
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Styrkur:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Styrkur</b>"
"<p>Tilgreinið styrk endurbyggðra hátóna. Lágt gildi styður frekar hvítt en hátt "
"gildi liti."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Birtustig:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Birtustig</b>"
"<p>Tilgreindu birtustig endalegu myndarinnar.Sjálfgefið gildi er 1.0 (virkar "
"bara í 8-bita ham)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Gæði (innskotsaðferð):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Tvílínulegt"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr "PPG"
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
"<p><b>Gæði</b>"
"<p>Veldu hér innskotsaðferð við afkóðun og aftiglun RAW mynda. "
"Aftiglunarútreikningur (demosaicing algorithm) stafrænt myndvinnsluferli sem "
"nýtist til samsetningar heillar myndar út frá hlutum hrárra gagna sem koma frá "
"litsíum myndflögu myndavélar og eru í formi fylkja af litadílum. Einnig þekkt "
"undir nafninu CFA interpolation eða litendurbygging, enn ein stafsetningin er "
"að kalla þetta demosaicing. Það eru 3 aðferðir til að aftigla RAW myndir:"
"<p><b>Tvílínuleg</b>: notar háhraða en lággæða tvílínuleg innskot (sjálfgefið - "
"fyrir hægvirkar tölvur). Í þessari aðferð þá er reiknað rauða gildi ekki-rauðs "
"díls (pixel) sem meðaltal nærliggjandi rauðra díla; síðan gildir sama fyrir blá "
"og græna."
"<p><b>VNG</b>: notar innskot með breytilegum fjölda litstigla (Variable Number "
"of Gradients interpolation). Þessi aðferð reiknar litstigla í grennd við dílinn "
"sem er til skoðunar og notar lægri litstiglana (sem gefa til kynna mýkri og "
"líkari hluta myndar) til að áætla breytinguna. "
"<p><b>PPG</b>: notar innskot miðað við mynsturhópa (Patterned Pixel Grouping "
"interpolation). PPG styðst við fyrirfram gefnar forsendur um náttúrulegar "
"aðstæður við útreikninga. Þannig minnka gallar á myndum sem teknar eru við "
"algengar náttúrulegar aðstæður, miðað við VNG-aðferðina."
"<p><b>AHD</b>: notar aðlöguð samleitnistýrð innskot (Adaptive "
"Homogeneity-Directed interpolation). Þessi aðferð velur stefnu "
"innskotsaðgerðarinnar þannig að sem mest einsleitni mælist, þannig nást að "
"jafnaði minnst litatruflun."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Virkja truflanasíu"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Virkja truflanasíun</b>"
"<p>Nota bylgjuútreikning til að þurrka út truflanir um leið og haldið er í "
"raunveruleg smáatriði."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Þröskuldur:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr "<p><b>Þröskuldur</b><p>Stilltu hér gildi þröskuldar á truflanasíu."
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr "Virkja síu fyrir litskekkjuleiðréttingu"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
"<p><b>Virkja síu fyrir litskekkjuleiðréttingu</b>"
"<p>Stækkar hráu rauðu og bláu litlögin um valin gildi, oft á bilinu 0.999 til "
"1.001, til að leiðrétta litskekkju."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Margfeldi rauðs:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr "<p><b>Margfeldi rauðs</b><p>Stilltu hér stækkun rauða litlagsins"
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Margfeldi blás:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr "<p><b>Margfeldi blás</b><p>Stilltu hér stækkun bláa litlagsins"
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Litrýmd:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Hrágögn (línuleg)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Vítt litasvið"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-Photo"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Litrýmd</b>"
"<p>Veldu hér litrýmd þá sem úttak RAW kóðunar mun miðast við."
"<p><b>RAW (línulegt)</b>: í þessum ham er engin vörpun í neina litrýmd á meðan "
"kóðuð eru RAW gögn."
"<p><b>sRGB</b>: þetta er ein gerð RGB litrýmdar, unnin í samvinnu "
"Hewlett-Packard og Microsoft. Þetta er besta litrýmdin fyrir myndir á vefinn, "
"skjáinn og hugsanlega portrettljósmyndir."
"<p><b>Adobe RGB</b>: þetta er útvíkkuð RGB litrýmd, þróað af Adobe. Þetta er "
"notað í mörgum ljósmyndaforritum við auglýsingagerð og framsetningu listrænna "
"mynda."
"<p><b>Vítt litasvið</b>: (Wide Gamut) þessi litrýmd er útvíkkuð útgáfa af Adobe "
"RGB litrýmdinni."
"<p><b>Pro-Photo</b>: þetta er ein gerð RGB litrýmdar, þróuð af Kodak, sem "
"gefur færi á sérstaklega breiðu litasviði, hugsað til notkunar með ýmsum gerðum "
"ljósmyndaútprentunar."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Staðlað"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Ekki teygja eða snúa dílum"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>Ekki teygja eða snúa dílum</b>"
"<p>Fyrir Fuji Super CCD myndavélar, sýna myndina með 45 gráðu halla. Fyrir "
"myndavélar sem ekki hafa ferningslaga díla, þá á ekki að teygja myndina til að "
"leiðrétta stærðarhlutföllin. Í öllu falli á þetta val að tryggja að hver díll "
"úttaksmyndar samsvari einum RAW díl."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Svartgildi"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Svartgildi</b>"
"<p>Nota sérstakt gildi svartpunkts til að afkóða RAW myndir. Ef þú slekkur á "
"þessum möguleika þá verður gildið reiknað sjálfvirkt."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Svartgildi</b>"
"<p>Tilgreindu gildi svarts punkts í endanlegri mynd."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Ítarlegra"
#~ msgid "<p><b>Use camera white balance</b><p>Use the camera's custom white-balance settings. If this can not be found, reverts to the default (which is to use fixed daylight values, calculated from sample images)."
#~ msgstr "<p><b>Nota hvítvægi myndavélar</b><p>Nota sérsniðnar hvítvægisstillingar frá myndavél. Ef slíkar stillingar finnast ekki, þá er stuðst við sjálfgefnar stillingar (sem er að nota föst gildi á dagsljósi, reiknað á grunni viðmiðunarmynda)."
#~ msgid "<p><b>Automatic color balance</b></p>Calculate the white balance by averaging the entire image."
#~ msgstr "<p><b>Sjálfvirkt litajafnvægi</b></p>Reiknar hvítvægi myndar út frá meðaltali myndflatarins."
#~ msgid "Color balance multipliers"
#~ msgstr "Margfeldisstuðlar fyrir litajafnvægi"
#~ msgid "Green 1 multiplier:"
#~ msgstr "Margfeldi græns 1:"
#~ msgid "Green 2 multiplier:"
#~ msgstr "Margfeldi græns 2:"

3
po/it/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = it
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

6225
po/it/libkdcraw.po
View File

File diff suppressed because it is too large Load Diff

3
po/ja/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = ja
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

386
po/ja/libkdcraw.po
Unescape View File

@ -0,0 +1,386 @@
# translation of libkdcraw.po to Japanese
# Yukiko Bando <ybando@k6.dion.ne.jp>, 2007, 2008.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2008-02-29 20:00+0900\n"
"Last-Translator: Yukiko Bando <ybando@k6.dion.ne.jp>\n"
"Language-Team: Japanese <Kdeveloper@kde.gr.jp>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p><b>%1</b> 実行ファイルが見つかりません:"
"<br>このプログラムは RAW ファイル形式をサポートするために必要です。このまま続けることはできますが RAW "
"画像を処理することはできません。libkdcraw パッケージのインストールを確認してください。"
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p><b>%1</b> 実行ファイルのバージョンが最新ではありません:"
"<br>このプログラムのバージョン %2 をコンピュータ上に検出しました。このバージョンは古すぎて正しく動作しません。このまま続けることはできますが RAW "
"画像を処理することはできません。libkdcraw パッケージのインストールを確認してください。"
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16 ビットカラー"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>有効にすると、すべての RAW ファイルを線形ガンマカーブを使って 16 "
"ビットカラーでデコードします。エディタで画像が暗く表示されるのを防ぐために、このモードではカラーマネジメントを使用することを推奨します。"
"<p>無効にすると、すべての RAW ファイルを BT.709 ガンマカーブと 99th-percentile white point を使って 8 "
"ビットカラーでデコードします。こちらの方が 16 ビットカラーよりも高速です。"
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "RGB を 4 色として補間"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "dcraw プロジェクトのウェブサイトを訪問"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr "ホワイトバランス:"
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr "標準 D65 ホワイトバランス"
#: libkdcraw/dcrawsettingswidget.cpp:194
msgid "Camera White Balance"
msgstr "カメラのホワイトバランス"
#: libkdcraw/dcrawsettingswidget.cpp:195
msgid "Automatic White Balance"
msgstr "自動ホワイトバランス"
#: libkdcraw/dcrawsettingswidget.cpp:196
msgid "Manual White balance"
msgstr "手動ホワイトバランス"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr "色温度 (K):"
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr "<p>色温度<p>色温度を指定します。"
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "ハイライト:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "濃淡のない白"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "クリップしない"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "ブレンド"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "再構築"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p>ハイライト"
"<p>ここでハイライトクリッピングの方法を選択します:"
"<p>[濃淡のない白] すべてのハイライトをクリップして濃淡のない白にします。"
"<p>[クリップしない] ハイライトをクリップせずにさまざまな階調のピンクのまま残します。"
"<p>[ブレンド] クリップされた値とされていない値をブレンドすることによって徐々に白に減衰させます。"
"<p>[再構築] レベル値を使ってハイライトを再構築します。"
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "レベル:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr "<p>レベル<p>出力画像のハイライト復元レベルを指定します。値を低くすると白に、高くすると色に傾きます。"
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "明るさ:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr "<p>明るさ<p>出力画像の明るさを指定します。標準の値は 1.0 です (8 ビットモードでのみ有効)。"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "品質 (補間法):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "バイリニア (双線形)"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr "PPG"
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "ノイズ低減を有効にする"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr "<p>ノイズ低減を有効にする<p>ウェーブレットを使ってディテールを損なうことなくノイズを除去します。<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "しきい値:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr "<p>しきい値<p>ノイズ低減のしきい値を指定します。<p>"
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr "色収差補正を有効にする"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "赤の乗数:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "青の乗数:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "カラースペース:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "RAW (リニア)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Wide Gamut"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-Photo"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>カラースペース</b>"
"<p>RAW データのデコードに使用する出力カラースペースを選択します。"
"<p><b>Raw (リニア)</b>: このモードでは、RAW デコード中に出力カラースペースを使用しません。"
"<p><b>sRGB</b>: Hewlett-Packard と Microsoft が共同で開発した RGB "
"カラースペースです。ウェブ上に公開する画像やポートレート写真に最適です。"
"<p><b>Adobe RGB</b>: Adobe が開発した拡張 RGB カラースペースです。広告や美術作品に使用されます。"
"<p><b>Wide Gamut</b>: Adobe RGB カラースペースの拡張版です。"
"<p><b>Pro-Photo</b>: Kodak が開発した RGB カラースペースです。写真の出力を前提とした広い色域を提供します。"
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "標準"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "ブラックポイント"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p>ブラックポイント"
"<p>RAW 画像のデコードに特定のブラックポイントの値を使用します。このオプションを無効にすると、ブラックポイントの値は自動的に計算されます。"
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr "<p>ブラックポイントの値<p>出力画像のブラックポイントの値を指定します。<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "詳細"

3
po/ms/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = ms
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

370
po/ms/libkdcraw.po
Unescape View File

@ -0,0 +1,370 @@
# libkdcraw Bahasa Melalyu (Malay) (ms).
# Sharuzzaman Ahmat Raslan <sharuzzaman@myrealbox.com>, 2008.
#
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2008-02-12 00:15+0800\n"
"Last-Translator: Sharuzzaman Ahmat Raslan <sharuzzaman@myrealbox.com>\n"
"Language-Team: Malay <kedidiemas@yahoogroups.com>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "Ubah Warna Latarbelakang"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "Ubah Warna Latarbelakang"
#: libkdcraw/dcrawsettingswidget.cpp:196
msgid "Manual White balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:232
#, fuzzy
msgid "Solid white"
msgstr "Hitam & Putih"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:248
#, fuzzy
msgid "Level:"
msgstr "Tahap:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:307
#, fuzzy
msgid "Enable noise reduction"
msgstr "Hidupkan p&etikan pintar"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:354
#, fuzzy
msgid "Color space:"
msgstr "Warna latarbelakang:"
#: libkdcraw/dcrawsettingswidget.cpp:356
#, fuzzy
msgid "Raw (linear)"
msgstr "Imej Kamera RAW"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:358
#, fuzzy
msgid "Adobe RGB"
msgstr "Imej SGI (RGB)"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:360
#, fuzzy
msgid "Pro-Photo"
msgstr "Pengurusan Gambar"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:391
#, fuzzy
msgid "Standard"
msgstr "Standard"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Titik hitam"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Lanjutan"
#~ msgid "Color balance multipliers"
#~ msgstr "Pekali imbangan warna"

3
po/nds/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = nds
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

389
po/nds/libkdcraw.po
Unescape View File

@ -0,0 +1,389 @@
# translation of libkdcraw.po to
#
# Sönke Dibbern <sdibbern@foni.net>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-05-23 02:36+0200\n"
"Last-Translator: Sönke Dibbern <sdibbern@foni.net>\n"
"Language-Team: <nds@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:145
#, fuzzy
msgid "16 bits color depth"
msgstr "16 Bits Klöördeepde"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:167
#, fuzzy
msgid "Interpolate RGB as four colors"
msgstr "RGB as veer Klören estemeren"
#: libkdcraw/dcrawsettingswidget.cpp:168
#, fuzzy
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>RGB as veer Klören estemeren</b>"
"<p>Standardwies warrt all gröön Pixels as liek ankeken, man gröön Pixels in en "
"even Reeg vun den Bildsensor reageert op ultravigelett Licht anners as in en "
"uneven Reeg, un disse Verscheel föhrt to Maschmustern in de Utgaav. Disse "
"Optschoon lööst dat Problem, man dor kummt en lierlütt Deel vun de Enkelheiten "
"bi weg."
"<p>Disse Optschoon verwischt dat Bild also en beten, man maakt bi de "
"VNG-Ümwannelmetood de 2x2-Maschmustern un bi de AHD-Metood de Biestergoorns "
"weg."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:186
#, fuzzy
msgid "Visit dcraw project website"
msgstr "Na dcraw-Projektnettsiet gahn"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "Kamera-Wittbalangs bruken"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "Automaatsche Klöörbalangs"
#: libkdcraw/dcrawsettingswidget.cpp:196
#, fuzzy
msgid "Manual White balance"
msgstr "Kamera-Wittbalangs bruken"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
#, fuzzy
msgid "Highlights:"
msgstr "Gleemrebeden:"
#: libkdcraw/dcrawsettingswidget.cpp:232
#, fuzzy
msgid "Solid white"
msgstr "Witt maken"
#: libkdcraw/dcrawsettingswidget.cpp:233
#, fuzzy
msgid "Unclip"
msgstr "Künnig maken"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:248
#, fuzzy
msgid "Level:"
msgstr "Stoop:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:260
#, fuzzy
msgid "Brightness:"
msgstr "Helligkeit:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:275
#, fuzzy
msgid "Bilinear"
msgstr "Bilineaar"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:307
#, fuzzy
msgid "Enable noise reduction"
msgstr "Ruusminnern anmaken"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:315
#, fuzzy
msgid "Threshold:"
msgstr "Grenzweert:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:324
#, fuzzy
msgid "Enable Chromatic Aberration correction"
msgstr "Ruusminnern anmaken"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:391
#, fuzzy
msgid "Standard"
msgstr "Standard"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:424
#, fuzzy
msgid "Advanced"
msgstr "Verwiedert"
#, fuzzy
#~ msgid "Reconstruct"
#~ msgstr "Nieg opbuen"

3
po/nl/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = nl
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

482
po/nl/libkdcraw.po
Unescape View File

@ -0,0 +1,482 @@
# translation of libkdcraw.po to Dutch
#
# Rinse de Vries <rinsedevries@kde.nl>, 2007, 2008.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2008-03-05 01:25+0100\n"
"Last-Translator: Rinse de Vries <rinsedevries@kde.nl>\n"
"Language-Team: Dutch <kde-i18n-nl@kde.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>Het programma <b>%1</b> is niet gevonden."
"<br>Dit programma is nodig de ondersteuning van Raw-bestandsformaten. U kunt "
"doorgaan, maar zult niet in staat zijn om Raw-afbeeldingen te behandelen. "
"Controleer de installatie van het pakket libkdcraw op uw computer."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p>Het programma <b>%1</b> is niet actueel genoeg."
"<br>Programmaversie %2 is op uw computer gevonden. Deze versie is te oud om "
"goed te kunnen werken met deze plugin. U kunt doorgaan, maar zult geen "
"Raw-afbeeldingen kunnen behandelen. Controleer de installatie van het pakket "
"libkdcraw op uw computer."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16-bits kleurdiepte"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Indien ingeschakeld zullen alle RAW-bestanden worden gedecodeerd naar "
"16-bits kleurdiepte met een lineaire gammacurve. Om te voorkomen dat de "
"afbeelding te donker wordt weergegeven in de editor is het te adviseren om in "
"deze modus het kleurenbeheer te gebruiken."
"<p>Indien uitgeschakeld zullen alle RAW-bestanden worden gedecodeerd naar "
"8-bits kleurdiepte met een BT.709-gammacurve en een 99% witpunt. Deze modus is "
"sneller dan 16-bits decodering."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "RGB interpoleren als vier kleuren"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>RGB interpoleren als vier kleuren</b>"
"<p>Standaard wordt er van uitgegaan dat alle groene pixels hetzelfde zijn. Als "
"groene pixels op de evenrij meer gevoelig zijn voor ultraviolet licht dan op de "
"oneven zult u een golfpatroon in de uitvoer krijgen. Deze optie lost dit "
"probleem op met een klein detailverlies."
"<p>Bij herhaling vervaagt deze optie de afbeelding iets, maar het elimineert "
"valse 2x2 golfpatronen met de VNG-kwaliteitsmethode en mazen met de "
"AHD-kwaliteitsmethode."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Bezoek de website van het dcraw-project"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr "Witbalans:"
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr "Standaard D65-witbalans"
#: libkdcraw/dcrawsettingswidget.cpp:194
msgid "Camera White Balance"
msgstr "Witbalans van camera"
#: libkdcraw/dcrawsettingswidget.cpp:195
msgid "Automatic White Balance"
msgstr "Automatische witbalans"
#: libkdcraw/dcrawsettingswidget.cpp:196
msgid "Manual White balance"
msgstr "Handmatige witbalans"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
"<p><b>Witbalans</b> "
"<p>Stel de rauwe witbalans in: "
"<p><b>Standaard D65-witbalans</b>: gebruik een standaard D65-daglichtwitbalans "
"(standaard van dcraw) "
"<p><b>Witbalans van camera</b>: gebruik de witbalans die door de camera is "
"opgegeven. Als die niet beschikbaar is wordt teruggevallen op de standaard "
"neutrale witbalans "
"<p><b>Automatische witbalans</b>: berekent een automatische witbalans aan de "
"hand van het gemiddelde van de hele afbeelding. "
"<p><b>Handmatige witbalans</b>: laat u zelf de waarden voor temperatur en "
"groenniveau aanpassen"
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr "Temperatuur (K):"
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr "<p><b>Temperatuur</b><p>Stel hier de kleurtemperatuur in"
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr "Groen:"
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
"<p>Stel hier het groencomponent in om het verwijderniveau van de "
"magenta-kleurkast in te stellen."
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Lichten:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Geheel wit"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Unclip"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Vermengen"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Reconstrueren"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Lichten</b>"
"<p>Selecteer hier de methode voor het aanpassen van de lichten:"
"<p><b>Geheel wit</b>: zet alle lichten om in volledig wit"
"<p><b>Unclip</b>: behoud het detail in de rozetinten door het contrast niet te "
"oversturen"
"<p><b>Vermengen</b>: vermengt de lichtschakeringen met elkaar tot er een "
"vloeiende vervaging naar wit ontstaat "
"<p><b>Reconstrueren</b>: reconstrueer lichten aan de hand van een niveauwaarde"
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Niveau:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Niveau</b>"
"<p>Geef het niveau op voor het reconstrueren van lichten in de "
"uitvoerafbeelding. Een lage waarde geeft meer wit en een hoge waarde meer "
"kleur."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Helderheid:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Helderheid</b>"
"<p>Specificeer het helderheidsniveau van de uitvoerafbeelding. De "
"standaardwaarde is 1.0 (werkt alleen in 8-bit modus)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Kwaliteit (interpolatie)"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Bilineair"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr "PPG"
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
"<p><b>Kwaliteit</b> "
"<p>Selecteer hier de interpolatiemethode voor demosaicing uit RAW-afbeeldingen "
"tijdens het decoderen. Een demosaicing-algoritme is een digitaal "
"afbeeldingsproces dat gebruikt wordt om een complete afbeelding te interpoleren "
"aan de hand van een gedeelte van de raw-gegevens die ontvangen is van de "
"kleurfilterende afbeeldingssensor die veel digitale camera's in de form van een "
"matrix van gekleurde pixels hebben. Dit staat ook wel bekend als "
"CFA-interpolatie of kleurreconstructie. Er zijn 3 manieren voor demosaicing "
"raw-afbeeldingen: "
"<p><b>Bilineair</b>: gebruikt zeer snelle bilineaire interpolatie met een lage "
"kwaliteit (standaard, voor trage computers). Bij deze methode wordt de "
"roodwaarde van een niet-rode pixel berekend als het gemiddelde van aangrenzende "
"rode pixels. Ditzelfde gebeurt voor groen en blauw. "
"<p><b>VNG</b> Variable Number of Gradients-interpolatie. Deze methode berekent "
"kleurverlopen in de omgeving van de aangewezen pixel en gebruikt de laagste "
"kleurverlopen (die gladere en meer gelijke delen van het afbeelding "
"representeren) om een schatting te maken. "
"<p><b>PPG</b>: gebruik Patterned Pixel Grouping-interpolatie. Pixel Grouping "
"gebruikt aannames over de natuurlijke scene door schattingen te maken. Het "
"heeft minder artifacten op natuurlijke afbeeldingen dan de methode Variable "
"Number of Gradients"
"<p><b>AHD</b>: Adaptive Homogeneity-Directed-interpolatie. Deze methode "
"selecteert de richting van interpolatie zodanig dat het een homogenische "
"metriek genereert. Dit minimaliseert kleurartefacten. "
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Ruisreductie activeren"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Ruisreductie activeren</b> "
"<p>Gebruik wavelets om ruis uit de afbeelding te verwijderen terwijl de details "
"behouden blijven."
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Drempel:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
"<p><b>Drempel</b>"
"<p>Geef hier de drempelwaarde op die u voor de ruisreductie wilt gebruiken."
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr "Chromatische abberatie-correctie activeren"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
"<p>"
"<p>Chromatische abberatie-correctie activeren</b> "
"<p>Vergroot de rauwe rood- en blauwlagen met de opgegeven factoren, meestal "
"0.999 to 1.001 om de chromatische abberatie te corrigeren. "
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Roodversterking:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
"<p><b>Roodvermeerdering</b> "
"<p>Selecteer hier de vermeerderingsfactor voor de roodlaag"
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Blauwversterking:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
"<p><b>Blauwvermeerdering</b> "
"<p>Selecteer hier de vermeerderingsfactor voor de blauwlaag"
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Kleurruimte:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Raw (lineair)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Wide Gamut"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-Photo"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Kleurruimte </b> "
"<p>Selecteer hier de kleurruimte die u wilt gebruiken voor het decoderen van "
"raw-gegevens. "
"<p><b>Raw (lineair)</b>: in deze modus wordt er geen kleurruimte gebruikt "
"tijdens het decoderen van raw-afbeeldingen. "
"<p><b>sRGB</b>: dit is een RGB-kleurruimte, coöperatief gemaakt door "
"Hewlett-Packard en Microsoft. Het is de beste keuze voor afbeeldingen die "
"bedoeld zijn voor op internet en portretfotografie. "
"<p><b>Adobe RGB</b>: deze kleurruimte is een uitgebreide RGB-kleurruimte, "
"ontwikkelt door Adobe. Het wordt gebruikt voor foto's bedoeld voor in "
"advertenties en fijne kunst. "
"<p><b>Wide Gamut</b>: deze kleurruimte is een uitgebreide versie van Adobe's "
"RGB-kleurruimte. "
"<p><b>Pro-Photo</b>: deze RGB-kleurruimte is ontwikkeld door Kodak en biedt "
"vooral large gamut die ontworpen is voor gebruik in de fotografie."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Standaard"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Pixels niet uitrekken of roteren"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>Pixels niet uitrekken of draaien</b> "
"<p>Voor Fuji Super CCD-camera's, toon de afbeelding 45° gedraaid. Voor camera's "
"met niet-vierkante pixels, rek de afbeelding niet uit naar de juiste "
"beeldverhouding. In elk geval garandeert deze optie dat elke uitvoerpixel "
"overeenkomt met één raw-pixel."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Zwartpunt"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Zwartpunt</b> "
"<p>Gebruik een specifieke zwartpuntwaarde voor het decoderen van "
"raw-afbeeldingen. Als u deze optie uitzet zal de zwartpuntwaarde automatisch "
"worden berekend."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Zwartpuntwaarde</b> "
"<p>Specificeer een specifieke zwartpuntwaarde voor de uitvoerafbeelding."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Geavanceerd"

3
po/pa/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = pa
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

365
po/pa/libkdcraw.po
Unescape View File

@ -0,0 +1,365 @@
# translation of libkdcraw.po to Punjabi
#
# A S Alam <aalam@users.sf.net>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-03-04 13:58+0530\n"
"Last-Translator: A S Alam <aalam@users.sf.net>\n"
"Language-Team: Punjabi <punjabi-l10n@users.sf.net>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16 ਬਿੱਟ ਰੰਗ ਗਹਿਰਾਈ"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "dcraw ਪ੍ਰੋਜੈਕਟ ਵੈੱਬਸਾਇਟ ਖੋਲ੍ਹੋ"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "ਕੈਮਰਾ ਚਿੱਟਾ ਸੰਤੁਲਨ ਵਰਤੋਂ"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "ਆਟੋਮੈਟਿਕ ਰੰਗ ਅਨੁਕੂਲਣ"
#: libkdcraw/dcrawsettingswidget.cpp:196
#, fuzzy
msgid "Manual White balance"
msgstr "ਕੈਮਰਾ ਚਿੱਟਾ ਸੰਤੁਲਨ ਵਰਤੋਂ"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "ਉਘਾੜੋ:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "ਇਕਹੇਰਾ ਚਿੱਟਾ"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Unclip"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "ਪੱਧਰ:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "ਚਮਕ:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "ਬਾਈਲੀਨੀਅਰ"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "ਥਰੈਸ਼ਹੋਲਡ:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "ਰੰਗ ਥਾਂ:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Raw (ਰੇਖਿਕ)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "ਸਟੈਂਡਰਡ"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "ਤਕਨੀਕੀ"
#~ msgid "Reconstruct"
#~ msgstr "ਮੁੜ-ਨਿਰਮਾਣ"

3
po/pt/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = pt
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

484
po/pt/libkdcraw.po
Unescape View File

@ -0,0 +1,484 @@
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-08-24 17:11+0100\n"
"Last-Translator: José Nuno Coelho Pires <jncp@netcabo.pt>\n"
"Language-Team: pt <kde-i18n-pt@kde.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-POFile-SpellExtra: CCD Adaptive Homogeneity CIELab VNG Fuji RAW Hewlett\n"
"X-POFile-SpellExtra: Variable Directed Packard dcraw Kodak AHD libkdcraw\n"
"X-POFile-SpellExtra: of Number CFA Gamute sRGB Photo Gradients BT wavelets\n"
"X-POFile-SpellExtra: PPG\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>Não foi possível encontrar o executável <b>%1</b>:"
"<br>Este programa binário é necessário para suportar os formatos de ficheiro "
"RAW. Poderá continuar, mas não será capaz de lidar com nenhumas imagens RAW. "
"Verifique por favor a instalação do pacote 'libkdcraw' no seu computador."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p>O executável <b>%1</b> não está actualizado:"
"<br>É necessária a versão %2 deste programa binário para suportar os formatos "
"de ficheiro RAW. Esta versão é demasiado antiga para funcionar "
"convenientemente. Poderá continuar, mas não será capaz de lidar com nenhumas "
"imagens RAW. Verifique por favor a instalação do pacote 'libkdcraw' no seu "
"computador."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "Profundidade de cor de 16 bits"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Se activar a opção, todos os ficheiros RAW serão descodificados para uma "
"profundidade de cor de 16 bits, usando uma curva de gama linear. Para evitar o "
"desenho de imagens pretas no editor, recomenda-se que use a Gestão de Cores "
"neste modo."
"<p>Se estiver desactivada, todos os ficheiros RAW serão descodificados para uma "
"profundidade de cor de 8 bits, com uma curva de gama BT.709 e um ponto branco "
"no percentil-99. Este modo é mais rápido que a descodificação de 16 bits."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "Interpolar o RGB como quatro cores"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>Interpolar o RGB como quatro cores.</b>"
"<p>Por omissão é assumido que todos os pontos verdes são o mesmo. Se o pontos "
"verdes da linhas pares forem mais sensíveis à luz ultravioleta do que os das "
"linhas ímpares esta diferença cria um padrão no resultado; se usar esta opção, "
"resolve o problema com uma perda mínima de detalhe."
"<p>Em resumo, esta opção borra a imagem um pouco, mas elimina os falsos padrões "
"em malha 2x2 com o método de qualidade VNG ou os labirintos com o método AHD."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Visite a página Web do projecto 'dcraw'"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "Usar o balanceamento de branco da máquina"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "Balanceamento de cores automático"
#: libkdcraw/dcrawsettingswidget.cpp:196
#, fuzzy
msgid "Manual White balance"
msgstr "Usar o balanceamento de branco da máquina"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
#, fuzzy
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
"<p><b>Multiplicador de vermelho</b>"
"<p>Configure aqui o factor de ampliação da camada vermelha"
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Tons claros:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Branco puro"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Retirar o recorte"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Misturar"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Reconstruir"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Tons claros</b>"
"<p>Seleccione aqui o método de recorte dos tons claros:"
"<p><b>Branco puro</b>: ajusta todos os tons claros para o branco puro"
"<p><b>Retirar o recorte</b>: deixa os tons claros não-recortados, em vários "
"tons de rosa"
"<p><b>Misturar</b>:Mistura os valores recortados e não recortados em conjunto, "
"para gerar um desvanecimento gradual para branco"
"<p><b>Reconstruir</b>: reconstrói os tons claros, usando um nível predefinido."
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Nível:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Nível</b>"
"<p>Indique o nível de tons claros na reconstrução da imagem resultante. Os "
"valores baixos favorecem os brancos e os valores altos favorecem as cores."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Brilho:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Brilho</b>"
"<p>Indique o nível de brilho da imagem resultante. O valor por omissão é 1,0 "
"(funciona apenas no modo de 8 bits)."
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Qualidade (interpolação):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Bilinear"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr "PPG"
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
"<p><b>Qualidade</b>"
"<p>Seleccione aqui o método de interpolação na descodificação para remover o "
"mosaico das imagens RAW. Um algoritmo de remoção do mosaico é um processo "
"digital da imagem, usado para interpolar uma imagem completa a partir dos dados "
"parciais em bruto que são recebidos do sensor de imagem com filtros de cores, o "
"qual é interno em muitas máquinas digitais sob a forma de uma matriz de pixels "
"coloridos. É também conhecido por interpolação CFA ou reconstrução de cores, "
"sendo o outro termo comum a remoção de mosaicos. Existem 3 métodos para remover "
"o mosaico das imagens RAW:"
"<p><b>Bilinear</b>: usa a interpolação bilinear, rápida mas de baixa qualidade "
"(predefinida - para computadores lentos). Neste método, o valor de vermelho de "
"um pixel não-vermelho é calculado como a média dos pixels vermelhos adjacentes, "
"aplicando-se o mesmo princípio para o verde e o azul."
"<p><b>VNG</b>: usa a interpolação VNG (Variable Number of Gradients - Número de "
"Gradientes Variável). Este método calcula os gradientes, perto do pixel de "
"interesse, e usa os gradientes menores (que representam as partes mais suaves e "
"semelhantes da imagem) para fazer uma estimativa."
"<p><b>AHD</b>: usa a interpolação AHD (Adaptive Homogeneity-Directed - "
"Adaptativa e Direccionada à Homogeneidade). Este método selecciona a direcção "
"da interpolação, de modo a maximizar uma métrica de homogeneidade, minimizando "
"desta forma os artefactos de cores."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Activar a redução de ruído"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Activar a Redução de Ruído</b>"
"<p>Usa 'wavelets' (padrões ondulatórios) para eliminar o ruído, preservando à "
"mesma o detalhe real."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Limiar:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
"<p><b>Limiar:</b>"
"<p>Defina aqui o valor-limite da redução de ruído a usar."
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr "Activar a correcção da Aberração Cromática"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
"<p><b>Activar a correcção da Aberração Cromática</b>"
"<p>Aumenta as camadas de vermelho e azul pelos factores indicados, tipicamente "
"entre 0,999 e 1,001, de modo a corrigir a aberração cromática."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Multiplicador de vermelho:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
"<p><b>Multiplicador de vermelho</b>"
"<p>Configure aqui o factor de ampliação da camada vermelha"
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Multiplicador de azul:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
"<p><b>Multiplicador de azul</b>"
"<p>Configure aqui o factor de ampliação da camada azul"
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Espaço de cores:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Bruto (linear)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "RGB da Adobe"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Gamute Amplo"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-Photo"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Espaço de cores</b>"
"<p>Seleccione aqui o espaço de cores resultante que é usado para descodificar "
"os dados RAW."
"<p><b>Bruto (linear)</b>: neste modo, não é usado nenhum espaço de cores "
"resultante na descodificação do RAW."
"<p><b>sRGB</b>: este espaço de cores é um espaço de cores RGB, criado em "
"cooperação entre a Hewlett-Packard e a Microsoft, sendo a melhor escolha para "
"as imagens destinadas à Web e aos retratos fotográficos."
"<p><b>RGB da Adobe</b>: este espaço de cores é um espaço de cores RGB, "
"desenvolvido pela Adobe, que é usado em aplicações de fotografia como a "
"publicidade e a arte."
"<p><b>Gamute Amplo</b>: este espaço de cores é uma versão expandida do espaço "
"de cores RGB da Adobe."
"<p><b>Pro-Photo</b>: este espaço de cores é um espaço RGB, desenvolvido pela "
"Kodak, que oferece um gamute especialmente grande, desenhado para ser usado com "
"resultados fotográficos em mente."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Normal"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Não encolher ou rodar os pixels"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>Não encolher ou rodar os pixels</b>"
"<p>Nas máquinas Fuji Super CCD, mostra a imagem rodada em 45 graus. Para as "
"máquinas com pixels não-quadrados, não estica a imagem para a sua proporção "
"correcta. Em qualquer um dos casos, esta opção garante que cada pixel no "
"resultado corresponde a um pixel RAW."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Ponto preto"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Ponto preto</b>"
"<p>Use um valor específico do ponto preto para descodificar as imagens RAW. Se "
"desligar esta opção, o valor do Ponto Preto será calculado automaticamente."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Valor do ponto preto</b>"
"<p>Indique um valor do ponto preto específico, para a imagem resultante."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Avançado"
#~ msgid "<p><b>Use camera white balance</b><p>Use the camera's custom white-balance settings. If this can not be found, reverts to the default (which is to use fixed daylight values, calculated from sample images)."
#~ msgstr "<p><b>Usar o balanceamento de branco da máquina</b><p>Utiliza a configuração personalizada de balanceamento de branco da máquina fotográfica. Se esta não for encontrada, é usada a predefinida (onde são utilizados valores fixos de luz do dia, calculados a partir de imagens de exemplo)."
#~ msgid "<p><b>Automatic color balance</b></p>Calculate the white balance by averaging the entire image."
#~ msgstr "<p><b>Balanceamento de cores automático</b><p>Calcula o balanceamento de branco, fazendo a média em toda a imagem."
#~ msgid "Color balance multipliers"
#~ msgstr "Multiplicadores do balanceamento de cores"
#~ msgid "Green 1 multiplier:"
#~ msgstr "Multiplicador do verde 1:"
#~ msgid "Green 2 multiplier:"
#~ msgstr "Multiplicador do verde 2:"

3
po/sk/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = sk
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

359
po/sk/libkdcraw.po
Unescape View File

@ -0,0 +1,359 @@
# translation of libkdcraw.po to Slovak
#
# Richard Fric <Richard.Fric@kdemail.net>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-02-19 19:15+0100\n"
"Last-Translator: Richard Fric <Richard.Fric@kdemail.net>\n"
"Language-Team: Slovak <sk@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
"Plural-Forms: nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
msgid "Camera White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:195
msgid "Automatic White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:196
msgid "Manual White balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr ""

3
po/sr/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = sr
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

439
po/sr/libkdcraw.po
Unescape View File

@ -0,0 +1,439 @@
# translation of libkdcraw.po to Serbian
#
# Slobodan Simic <simicsl@verat.net>, 2007, 2008.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2008-03-04 14:51+0100\n"
"Last-Translator: Slobodan Simic <simicsl@verat.net>\n"
"Language-Team: Serbian <kde-i18n-sr@kde.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>"
"=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>Не могу да нађем <b>%1</b> извршни фајл:"
"<br>Овај бинарни фајл је неопходан за подршку Raw формата. Можете да наставите "
"али нећете моћи да радите са Raw сликама. Проверите инсталацију libkdcraw "
"пакета на вашем рачунару."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p><b>%1</b> није баш најновија:"
"<br> Верзија %2 овог програма је нађена на вашем рачунару. Ова верзија је "
"сувише стара да би радила како треба. Можете да наставите али нећете моћи да "
"радите са Raw сликама. Проверите инсталацију libkdcraw пакета на вашем "
"рачунару."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16-битне боје"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Ако је укључено, сви RAW фајлови ће бити декодовани са 16-битном дубином "
"помоћу линеарне Гама криве. Да би се спречиле мрачне слике, препоручљиво је да "
"се у овом режиму користи Управљање бојама."
"<p>Ако је искључено, сви RAW ће бити декодовани са 8-битном дубином помоћу "
"BT.709 Гама криве и 99-о процентном белом тачком. Овај начин је бржи од "
"16-битног декодовања."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "Интерполирај RGB као четири боје"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>Интерполирај RGB као четири боје</b>"
"<p>Подразумевано се сматра да су сви зелени пиксели исти. Ако су зелени пиксели "
"парног реда више осетљиви на ултраљубичасто светло од непарног реда, разлика "
"може довести до мрежасте слике на излазу. Коришћењем ове опције решава се тај "
"проблем са минималним губитком детаља."
"<p>Што ће рећи, ова опција малчице замућује слику али уклања лажне 2x2 мрежице "
"са VNG начином квалитета или лавиринте са AHD начином квалитета."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Посетите веб страну dcraw пројекта"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr "Баланс белог:"
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr "Подразумевани D65 баланс"
#: libkdcraw/dcrawsettingswidget.cpp:194
msgid "Camera White Balance"
msgstr "Апаратов баланс белог"
#: libkdcraw/dcrawsettingswidget.cpp:195
msgid "Automatic White Balance"
msgstr "Аутоматски баланс белог"
#: libkdcraw/dcrawsettingswidget.cpp:196
msgid "Manual White balance"
msgstr "Ручни баланс белог"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
"<p><b>Баланс белог</b>"
"<p>Подешава сирови баланс белог :"
"<p><b>Подразумевани D65 баланс</b>: Користи стандардни D65 баланс дневног "
"светла (dcraw подразумевано)"
"<p><b>Апаратов баланс белог</b>: Користи баланс белог који даје апарат. Ако "
"није доступан, враћа се на подразумевани неутрални баланс"
"<p><b>Аутоматски баланс белог</b>: Прорачунава аутоматски баланс на основу "
"просека целе слике"
"<p><b>Ручни баланс белог</b>: Поставља произвољне вредности температуре и "
"зеленог нивоа"
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr "Температура (K):"
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr "<p><b>Температура</b><p>Овде подесите температуру боје."
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr "Зелена:"
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
"<p>Овде подесите зелену компоненту да подесите ниво уклањања пурпурне боје."
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Истицања:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Пуно бело"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Стопи"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Поново изгради"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Ниво:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Ниво</b>"
"<p>Одређује ниво реконструисања. Мале вредности дају предност белом а веће "
"вредности боји."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Осветљај:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Осветљај</b>"
"<p>Одређује ниво осветљаја излазне слике. Подразумевана вредност је 1.0 (ради "
"само у 8-битном режиму)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Квалитет (интерполације):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Билинеарно"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr "PPG"
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Укључи смањење шума"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Укључи смањење шума</b>"
"<p>Користи таласиће за брисање шума и чува праве детаље."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Праг:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr "<p><b>Праг</b><p>Овде одредите вредност прага за уклањање шума."
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr "Укључи исправку хроматске аберације"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
"<p><b>Укључи исправку хроматске аберације</b>"
"<p>Увеличава сирови црвени и плави слој за задати фактор, обично 0.999 до "
"1.001, да би се исправила хроматска аберација."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Множилац црвеног:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
"<p><b>Множилац црвеног</b>"
"<p>Овде одредите фактор увећања за црвени слој"
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Множилац плавог:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr "<p><b>Множилац плавог</b><p>Овде одредите фактор увећања за плави слој"
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Простор боја:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Сирово (линеарно)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Широка палета"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Про фото"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Простор боја</b>"
"<p>Овде одредите излазни простор боја за декодовање RAW података."
"<p><b>Сирово (линеарно)</b>: у овом режиму, не користи се излазни простор боја "
"при RAW декодовању."
"<p><b>sRGB</b>: ово је RGB простор боја, заједнички направљен од стране "
"Hewlett-Packard-а и Microsoft-а. Ово је најбољи избор за слике намењене "
"интернету и фотографијама портрета."
"<p><b>Adobe RGB</b>: овај простор боја је проширени RGB простор, развијен од "
"стране Adobe-а. Користи се у програмима за обраду фотографија у рекламне и "
"уметничке сврхе."
"<p><b>Широка палета</b>: овај простор боја је проширена верзија Adobe-овог RGB "
"простора боја."
"<p><b>Про фото</b>: овај простор боја је RGB простор, развијен од стране "
"Kodak-а, који нуди изузетно широку палету намењену за професионалне фотографске "
"излазе."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Стандардно"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Не растежи и не ротирај пикселе"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>Не растежи и не ротирај пикселе</b>"
"<p>За Fuji Super CCD апарате, прикажи слике заокренуте за 45 degrees. За "
"апарате са не-квадратним пикселима, не растежи слику ради исправљања размере. У "
"сваком случају, ова опција гарантује да сваки излазни пиксел одговара RAW "
"пикселу."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Црна тачка"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Црна тачка</b>"
"<p>Користи посебну вредност црне тачке за декодовање RAW слика. Ако ову опцију "
"искључите, вредност црне тачке ће бити аутоматски прорачуната."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Вредност црне тачке</b>"
"<p>Наведите одређену вредност црне тачке за излазну слику."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Напредно"

3
po/sr@Latn/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = sr@Latn
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

369
po/sr@Latn/libkdcraw.po
Unescape View File

@ -0,0 +1,369 @@
# translation of libkdcraw.po to Serbian
#
# Slobodan Simic <simicsl@verat.net>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-07-23 14:06+0200\n"
"Last-Translator: Slobodan Simic <simicsl@verat.net>\n"
"Language-Team: Serbian <kde-i18n-sr@kde.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>"
"=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16-bitne boje"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Posetite veb stranu dcraw projekta"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "Automatski balans belog"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "Automatski balans belog"
#: libkdcraw/dcrawsettingswidget.cpp:196
msgid "Manual White balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Isticanja:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Puno belo"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Stopi"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Ponovo izgradi"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Nivo:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Osvetljaj:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Kvalitet (interpolacije):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Bilinearno"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Uključi smanjenje šuma"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Prag:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:324
#, fuzzy
msgid "Enable Chromatic Aberration correction"
msgstr "Uključi smanjenje šuma"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Množilac crvenog:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Množilac plavog:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Prostor boja:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Sirovo (linearno)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Standardno"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Ne rasteži i ne rotiraj piksele"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Crna tačka"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Napredno"
#~ msgid "Green 1 multiplier:"
#~ msgstr "Množilac zelenog 1:"
#~ msgid "Green 2 multiplier:"
#~ msgstr "Množilac zelenog 2:"

3
po/sv/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = sv
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

474
po/sv/libkdcraw.po
Unescape View File

@ -0,0 +1,474 @@
# translation of libkdcraw.po to Swedish
#
# Stefan Asserhäll <stefan.asserhall@comhem.se>, 2007, 2008.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2008-03-04 17:30+0100\n"
"Last-Translator: Stefan Asserhäll <stefan.asserhall@comhem.se>\n"
"Language-Team: Swedish <sv@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>Kan inte hitta den körbara filen <b>%1</b>:"
"<br>Detta binära program krävs för att stödja obehandlade filformat. Du kan "
"fortsätta, men du kommer inte att kunna hantera några obehandlade bilder. "
"Kontrollera installationen av paketet libkdcraw på datorn."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p>Den körbara filen <b>%1</b> är inte aktuell:"
"<br> Version %2 av detta binära program hittades på datorn. Versionen är för "
"gammal för att köra på ett riktigt sätt. Du kan fortsätta, men du kommer inte "
"att kunna hantera några obehandlade bilder. Kontrollera installationen av "
"paketet libkdcraw på datorn."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16-bitars färgdjup"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Om aktiverad, avkodas alla obehandlade filer till 16-bitars färgdjup genom "
"att använda en linjär gammakurva. För att förhindra att en mörk bild visas i "
"editorn, rekommenderas att färghantering används tillsammans med detta läge. "
"<p>Om inaktiverad, avkodas alla obehandlade filer till 8-bitars färgdjup med en "
"BT.709 gammakurva och en vitpunkt från 99:e percentilen. Läget är snabbare än "
"16-bitars avkodning."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "Interpolera RGB som fyra färger"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>Interpolera RGB som fyra färger</b>"
"<p>Förval är att anta att alla gröna bildpunkter är likadana. Om gröna "
"bildpunkter i jämna rader är känsligare för ultraviolett ljus än udda rader, "
"orsakar skillnaden ett rutmönster i utdata. Genom att använda detta alternativ "
"löses problemet med minimal detaljförlust."
"<p>För att sammanfatta, så gör alternativet bilden något suddigare, men "
"eliminerar falska 2x2 rutmönster med kvalitetsmetoden VNG, eller labyrinter med "
"kvalitetsmetoden AHD."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Besök dcraw-projektets hemsida"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr "Vitbalans:"
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr "D65 standardvitbalans"
#: libkdcraw/dcrawsettingswidget.cpp:194
msgid "Camera White Balance"
msgstr "Kamerans vitbalans"
#: libkdcraw/dcrawsettingswidget.cpp:195
msgid "Automatic White Balance"
msgstr "Automatisk vitbalans"
#: libkdcraw/dcrawsettingswidget.cpp:196
msgid "Manual White balance"
msgstr "Manuell vitbalans"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
"<p><b>Vitbalans</b>"
"<p>Ställ in obehandlad vitbalans:"
"<p><b>D65 standardvitbalans</b>: Använd en vanlig D65 dagsljusvitbalans (förval "
"i dcraw)"
"<p><b>Kamerans vitbalans</b>: Använd vitbalansen som anges av kameran. Om den "
"inte är tillgänglig, används den neutrala standardvitbalansen"
"<p><b>Automatisk vitbalans</b>: Beräkna en automatisk vitbalans genom att skapa "
"medelvärdet av hela bilden"
"<p><b>Manuell vitbalans</b>: Ställ in en egen temperatur och värde på "
"grön-nivån"
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr "Temperatur (K):"
#: libkdcraw/dcrawsettingswidget.cpp:212
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr "<p><b>Temperatur</b><p>Ställ in färgtemperaturen här."
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr "Grön:"
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
"<p>Ställ in den gröna komponenten för att ange nivå av borttagning för magenta "
"färgskiftningar."
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Dagrar:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Helvita"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Obeskurna"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr "Blanda"
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr "Återskapade"
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Dagrar</b>"
"<p>Välj beskärningsmetoden för dagrar här:"
"<p><b>Helvita</b>: beskär alla dagrar till helvitt"
"<p><b>Obeskurna</b>: lämna dagrar obeskurna i olika rosa skuggningar "
"<p><b>Blanda</b>: Blanda beskurna och obeskurna värde för att få en gradvis "
"toning till vitt"
"<p><b>Återskapade</b>: återskapa dagrar med användning av ett nivåvärde."
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Nivå:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Nivå</b>"
"<p>Ange nivå för återskapade dagrar i resultatbilden. Ett lågt värde gör att "
"vitt föredras, och ett högt värde gör att färger föredras."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Ljusstyrka:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Ljushet</b>"
"<p>Ange resultatbildens ljushet. Standardvärdet är 1,0 (fungerar bara i "
"8-bitarsläge)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Kvalitet (interpolerad):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Bilinjär"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr "PPG"
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
"<p><b>Kvalitet</b>"
"<p>Välj interpolationsmetod för avkodning av obehandlade bilder för "
"mosaikborttagning. En algoritm för mosaikborttagning är digital bildprocess som "
"används för att interpolera en fullständig bild från partiell obehandlad data i "
"form av en matris av färgade bildpunkter, som tagits emot från den "
"färgfiltrerade bildsensorn som finns internt i många digitalkameror. Den är "
"också känd som CFA-interpolation eller färgrekonstruktion. Det finns fyra "
"metoder för att utföra mosaikborttagning av obehandlade bilder:"
"<p><b>Bilinjär</b>: Använder en snabb bilinjär interpolation med låg kvalitet "
"(standard för långsamma datorer). Med den här metoden beräknas det röda värdet "
"av en bildpunkt som inte är röd som medelvärdet av intilliggande röda "
"bildpunkter, och på samma sätt för blått och grönt."
"<p><b>VNG</b>: Använd interpolation med variabelt antal gradienter. Metoden "
"beräknar gradienter intill den intressanta bildpunkten och använder de lägsta "
"gradienterna (som representerar jämnare och liknande delar av bilden) för att "
"göra en uppskattning. "
"<p><b>PPG</b>: Använd interpolation med mönsterbaserad bildpunktsgruppering. "
"Bildpunktsgruppering använder antaganden om naturliga scenerier när "
"uppskattningar görs. Den har färre färgavvikelser än metoden med variabelt "
"antal gradienter."
"<p><b>AHD</b>: Använd adaptiv homogenstyrd interpolation. Metoden väljer "
"interpolationens riktning så att ett homogenitetsmått maximeras, och på så sätt "
"typiskt minimera färgavvikelser."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Aktivera brusreducering"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Aktivera brusreducering</b>"
"<p>Använd vågelement för att reducera brus samtidigt som riktiga detaljer "
"bevaras."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Tröskel:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
"<p><b>Tröskel</b>"
"<p>Ställ in brusreduceringens tröskelvärde som ska användas här."
#: libkdcraw/dcrawsettingswidget.cpp:324
msgid "Enable Chromatic Aberration correction"
msgstr "Aktivera korrigering av kromatisk aberration"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
"<p><b>Aktivera korrigering av kromatisk aberration</b>"
"<p>Förstora de obehandlade röda och blåa lagren med angivna faktorer, typiskt "
"0,999 till 1,001, för att korrigera kromatisk aberration."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Faktor för Röd:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
"<p><b>Röd multiplikator</b>"
"<p>Ställ in förstoringsfaktorn för det röda lagret"
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Faktor för Blå:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
"<p><b>Blå multiplikator</b>"
"<p>Ställ in förstoringsfaktorn för det blåa lagret"
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Färgrymd:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Obehandlad (linjär)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Stort tonomfång"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-foto"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>Färgrymd</b>"
"<p>Välj resultatets färgrymd som används för att avkoda obehandlad data här."
"<p><b>Obehandlad (linjär)</b>: Med det här läget används ingen färgrymd för "
"resultatet under avkodning av obehandlad data."
"<p><b>sRGB</b>: Den här färgrymden är en RGB-färgrymd, skapat i samarbete "
"mellan Hewlett-Packard och Microsoft. Den är det bästa valet för bilder som är "
"avsedda för webben och för porträttfotografering."
"<p><b>Adobe RGB</b>: Den här färgrymden är en RGB-färgrymd, utvecklad av Adobe. "
"Den används för fotografiska tillämpningar som reklam och konst."
"<p><b>Stort tonomfång</b>: Den här färgrymden är en utökad version av Adobes "
"RGB-färgrymd."
"<p><b>Pro-foto</b>: Den här färgrymden är en RGB-färgrymd, utvecklad av Kodak, "
"som erbjuder ett särskilt stort tonomfång konstruerad för användning med "
"fotografiskt resultat."
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Standard"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Sträck eller rotera inte bildpunkter"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>Sträck eller rotera inte bildpunkter</b>"
"<p>Visa bilden lutad 45 grader för Fuji Super CCD-kameror. Sträck inte bilden "
"till rätt proportion för kameror med icke-fyrkantiga bildpunkter. Hur som helst "
"garanterar alternativet att varje bildpunkt i resultatet motsvarar en "
"obehandlad bildpunkt."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Svartpunkt"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Svartpunkt</b>"
"<p>Använd ett specifikt svartpunktsvärde för att avkoda obehandlade bilder. Om "
"du stänger av alternativet, beräknas svartpunktsvärdet automatiskt."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Svartpunktsvärde</b>"
"<p>Ange ett specifikt svartpunktsvärde för resultatbilden."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Avancerat"

3
po/th/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = th
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

447
po/th/libkdcraw.po
Unescape View File

@ -0,0 +1,447 @@
# translation of libkdcraw.po to Thai
#
# Thanomsub Noppaburana <donga.nb@gmail.com>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-02-28 10:03+0700\n"
"Last-Translator: Thanomsub Noppaburana <donga.nb@gmail.com>\n"
"Language-Team: Thai <l10n@opentle.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>ไม่พบแฟ้มประมวลผล <b>%1</b>:"
"<br>แฟ้มโปรแกรมนี้จำเป็นต้องใช้สำหรับการทำงานกับแฟ้มแบบ Raw "
"หากคุณต้องการทำต่อไป คุณจะไม่สามารถจัดการกับภาพ Raw บางแฟ้มได้ "
"โปรดตรวจสอบการติดตั้งแพ็กเกจ libkdcraw บนเครื่องของคุณ"
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt>"
"<p>แฟ้มประมวลผล <b>%1</b> ไม่ใช่รุ่นที่ทันสมัย:"
"<br> รุ่นของโปรแกรม %2 ที่พบบนเครื่องของคุณเป็นรุ่นเก่าเกินไป "
"หากคุณต้องการทำต่อไป คุณจะไม่สามารถจัดการกับภาพ Raw บางแฟ้มได้ "
"โปรดตรวจสอบการติดตั้งแพ็กเกจ libkdcraw บนเครื่องของคุณ"
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "ความลึกสี 16 บิต"
#: libkdcraw/dcrawsettingswidget.cpp:146
#, fuzzy
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>หากเปิดใช้งาน แฟ้มภาพแบบ RAW ทั้งหมด จะถูกถอดรหัสเป็นภาพที่มีความลึกสี 16 "
"บิตโดยใช้ค่าแกมม่าเชิงเส้น "
"เพื่อป้องกันไม่ให้ภาพดำถูกประมวลผลในเครื่องมือแก้ไขภาพ "
"ขอแนะนำให้ให้เครื่องมือจัดการสีกับโหมดสีนี้"
"<p>หากปิดการใช้งาน แฟ้มภาพแบบ RAW จะถูกถอดรหัสเป็นภาพที่มีความลึกสีแบบ 8 บิต "
"โดยใช้ค่าแกมม่าแบบเส้น BT.709 และค่าเปอร์เซ็นต์ของจุดขาวแบบเส้น 99th-percentile "
"ซึ่งโหมดนี้จะมีความเร็วในการทำงานมีสูงกว่าการถอดรหัสแบบ 16 บิตสี"
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "เพิ่มจุดสี RGB แบบเดียวกับค่าสี่สี"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>เพิ่มจุดสี RGB แบบเดียวกับค่าสี่สี</b>"
"<p>ค่าปริยายนั้นจะเพิ่มจุดสีปรับใช้จุดสีเขียวเป็นแบบเดียวกัน "
"หากจุดสีเขียวในแถวคู่มีความไวต่อแสงเหนือม่างมากกว่าแถวคี่ "
"ค่าที่แตกต่างนี้จะทำให้เกิดตารางสีต่างขึ้นในภาพเป้าหมายได้ "
"การใช้ตัวเลือกนี้จะช่วยแก้ปัญหานี้ได้ โดยทำให้สูญเสียรายละเอียดนิดหน่อย"
"<p>เพื่อทำต่อไป ตัวเลือกนี้จะทำให้ภาพเบลอเล็กน้อย แต่จะช่วยกำลัดตารางสีแบบ 2x2 "
"ที่ได้จากวิธีปรับคุณภาพภาพแบบ VNG หรือ AHD"
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw รุ่น %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "แวะชมเวบไซต์โครงการ dcraw"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "ใช้ค่าสมดุลแสงขาวของกล้อง"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "ปรับค่าสมดุลสีอัตโนมัติ"
#: libkdcraw/dcrawsettingswidget.cpp:196
#, fuzzy
msgid "Manual White balance"
msgstr "ใช้ค่าสมดุลแสงขาวของกล้อง"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
#, fuzzy
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr ""
"<p><b>ค่ากระตุ้น</b>"
"<p>ตั้งค่ากระตุ้นการลดจุดรบกวนบนภาพที่ต้องการได้ที่นี่"
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "พื้นที่แสงจ้า:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "ขาวทึบ"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "ไม่ตัดส่วนภาพ"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:236
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "ระดับแสงจ้า:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "ค่าความสว่าง:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>ค่าความสว่าง</b>"
"<p>กำหนดค่าระดับความสว่างของภาพเป้าหมาย ค่าปริยายคือ 1.0 (ทำงานในโหมดความลึกสี "
"8 บิตเท่านั้น)"
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "คุณภาพ (การเพิ่ม/ลดจุดภาพ):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "แบบ Bilinear"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "แบบ VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "แบบ AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "เปิดใช้การลดจุดรบกวนบนภาพ"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>เปิดใช้การลดจุดรบกวนบนภาพ</b>"
"<p>ใช้ wavelets เพื่อลดจุดรบกวนบนภาพ โดยยังคงรักษารายละเอียดของภาพไว้ด้วย"
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "ค่ากระตุ้น:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr ""
"<p><b>ค่ากระตุ้น</b>"
"<p>ตั้งค่ากระตุ้นการลดจุดรบกวนบนภาพที่ต้องการได้ที่นี่"
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:324
#, fuzzy
msgid "Enable Chromatic Aberration correction"
msgstr "เปิดใช้การลดจุดรบกวนบนภาพ"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "ตัวคูณค่าสีแดง:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "ตัวคูณค่าสีน้ำเงิน:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "ขอบเขตสี:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "แบบ Raw (เชิงเส้น)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "แบบ sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "แบบ Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "แบบ Wide Gamut"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "แบบ Pro-Photo"
#: libkdcraw/dcrawsettingswidget.cpp:361
#, fuzzy
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
"<p><b>ขอบเขตสี</b>"
"<p>เลือกขอบเขตสีที่จะใช้ในการถอดรหัสข้อมูลภาพแบบ RAW ได้ที่นี่"
"<p><b>แบบ Raw (เชิงเส้น)</b>: ในโหมดนี้ "
"จะไม่มีการใช้ขอบเขตสีระหว่างการถอดรหัสข้อมูล RAW"
"<p><b>แบบ sRGB</b>: ขอบเขตสีนี้ เป็นส่วนหนึ่งภายในขอบเขตสีแบบ RGB "
"ถูกสร้างจากความร่วมมือกันระหว่าง Hewlett-Packard และ Microsoft "
"เหมาะสำหรับใช้กับภาพที่มีเป้าหมายใช้บนเวบและภาพถ่ายบุคคล"
"<p><b>แบบ Adobe RGB</b>: ขอบเขตสีนี้ เป็นส่วนหนึ่งภายในขอบเขตสีแบบ RGB "
"พัฒนาขึ้นโดยบริษัท Adobe "
"โดยมีเป้าหมายสำหรับใช้กับแอพพลิเคชันจัดการและแก้ไขภาพถ่าย เช่น "
"ด้านโฆษณาและงานศิลปะ"
"<p><b>แบบ Wide Gamut</b>: ขอบเขตสีนี้เป็นส่วนขยายขอบเขตจากขอบเขตสีแบบ Adobe RGB "
"<p><b>แบบ Pro-Photo</b>: ขอบเขตสีนี้ เป็นส่วนหนึ่งภายในขอบเขตสีแบบ RGB "
"พัฒนาขึ้นโดยบริษัท Kodak ซึ่งสามารถรองรับช่วงความกว้างสีขนาดใหญ่เป็นพิเศษ "
"โดยมีเป้าหมายในการใช้งานกับการจัดการภาพถ่ายให้ตรงความเป็นจริงมากกที่สุด"
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "มาตรฐาน"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "ไม่ต้องปรับขนาดหรือหมุนจุดภาพ"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>ไม่ต้องปรับขนาดหรือหมุนจุดภาพ</b>"
"<p>สำหรับเซ็นเซอร์กล้อง Fuji แบบ Super CCD จะมีการแสดงภาพที่เหลื่มกัน 45 องศา, "
"สำหรับกล้องที่ไม่มีจุดภาพแบบสี่เหลี่ยมจตุรัส "
"จะไม่มีการปรับขนาดภาพให้ตรงกับสัดส่วนภาพที่ถูกต้อง และสำหรับกรณีอื่น "
"ตัวเลือกนี้จะช่วยรับประกันได้ว่า "
"แต่ละจุดภาพที่ถูกส่งออกนั้นจะได้มาจากจุดภาพของข้อมูล RAW"
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "จุดดำ"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>ค่าจุดดำ</b>"
"<p>ใช้ค่าจุดดำในการถอดรหัสภาพจากข้อมูล RAW หากปิดการใช้ตัวเลือกนี้ "
"จะมีการคำนวณค่าจุดดำให้อัตโนมัติ"
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr "<p><b>ค่าจุดดำ</b> <p>กำหนดค่าจุดดำของภาพเป้าหมาย <p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "เพิ่มเติม"
#~ msgid "<p><b>Use camera white balance</b><p>Use the camera's custom white-balance settings. If this can not be found, reverts to the default (which is to use fixed daylight values, calculated from sample images)."
#~ msgstr "<p><b>ใช้ค่าสมดุลแสงขาวของกล้อง</b><p>ใช้ค่าสมดุลแสงขาวที่กำหนดไว้บนกล้อง หากไม่พบค่านี้บนกล้อง จะกลับไปใช้ค่าปริยายแทน (โดยทั่วไปจะใช้ในการแก้ไขค่าสีของแสง โดยจะมีการประมวลผลร่วมกับภาพตัวอย่าง)"
#, fuzzy
#~ msgid "<p><b>Automatic color balance</b></p>Calculate the white balance by averaging the entire image."
#~ msgstr "<p><b>ปรับค่าสมดุลสีอัตโนมัติ</b></p>โดยปริยายแล้วจะใช้ปรับแก้ค่าสมดุลสี โดยมีฐานบนกระดาษขาวที่อยู่ภายใต้แสงช่วงกลางวัน"
#~ msgid "Color balance multipliers"
#~ msgstr "ตัวคูณค่าสมดุลสี"
#~ msgid "Green 1 multiplier:"
#~ msgstr "ตัวคูณค่าสีเขียว 1:"
#~ msgid "Green 2 multiplier:"
#~ msgstr "ตัวคูณค่าสีเขียว 2:"
#~ msgid "Reconstruct"
#~ msgstr "สร้างขึ้นใหม่"

3
po/uk/Makefile.am
Unescape View File

@ -0,0 +1,3 @@
KDE_LANG = uk
SUBDIRS = $(AUTODIRS)
POFILES = AUTO

438
po/uk/libkdcraw.po
Unescape View File

@ -0,0 +1,438 @@
# Translation of libkdcraw.po to Ukrainian
#
# Ivan Petrouchtchak <ivanpetrouchtchak@yahoo.com>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: libkdcraw\n"
"POT-Creation-Date: 2008-03-03 21:56+0100\n"
"PO-Revision-Date: 2007-06-11 22:01-0700\n"
"Last-Translator: Ivan Petrouchtchak <ivanpetrouchtchak@yahoo.com>\n"
"Language-Team: Ukrainian <translation@linux.org.ua>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>"
"=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
#: libkdcraw/dcrawbinary.cpp:160
msgid ""
"<qt>"
"<p>Unable to find the <b>%1</b> executable:"
"<br>This binary program is required to support Raw file formats. You can "
"continue, but you will not be able to handle any Raw images. Please check the "
"installation of libkdcraw package on your computer."
msgstr ""
"<qt>"
"<p>Не вдалося знайти програму <b>%1</b>: "
"<br>Ця програма потрібна для підтримки формату файлів Raw. Можете продовжувати "
"без неї, але ви не зможете переглядати і редагувати зображення Raw. Будь ласка, "
"перевірте на вашому комп'ютері інсталяцію пакунка libkdcraw."
#: libkdcraw/dcrawbinary.cpp:176
msgid ""
"<qt>"
"<p><b>%1</b> executable is not up to date:"
"<br> The version %2 of this binary program have been found on your computer. "
"This version is too old to run properly. You can continue, but you will not be "
"able to handle any Raw images. Please check the installation of libkdcraw "
"package on your computer."
msgstr ""
"<qt> "
"<p>Програму <b>%1</b> не оновлено: "
"<br> На вашому комп'ютері було знайдено версію %2 цієї програми. Ця версія "
"застара для того, щоб належно працювати. Можете продовжити, але ви не зможете "
"переглядати і редагувати файли формату Raw. Будь ласка, перевірте на вашому "
"комп'ютері інсталяцію libkdcraw."
#: libkdcraw/dcrawsettingswidget.cpp:145
msgid "16 bits color depth"
msgstr "16-бітова глибина кольору"
#: libkdcraw/dcrawsettingswidget.cpp:146
msgid ""
"<p>If enabled, all RAW files will be decoded in 16-bit color depth using a "
"linear gamma curve. To prevent dark picture rendering in the editor, it is "
"recommended to use Color Management in this mode."
"<p>If disabled, all RAW files will be decoded in 8-bit color depth with a "
"BT.709 gamma curve and a 99th-percentile white point. This mode is faster than "
"16-bit decoding."
msgstr ""
"<p>Якщо ввімкнено, всі RAW-файли будуть декодуватись у 16-бітову глибину "
"кольору за допомогою лінійної кривої гами. Для отримання доброї якості "
"зображення рекомендовано в цьому режимі вживати керування кольором. "
"<p>Якщо вимкнено, всі RAW-файли будуть декодуватись у 8-бітову глибину кольору "
"за допомогою кривої гами BT.709 і 99% білої точки. Цей режим швидший за "
"16-бітове перетворення."
#: libkdcraw/dcrawsettingswidget.cpp:167
msgid "Interpolate RGB as four colors"
msgstr "Інтерполювати RGB як чотири кольори"
#: libkdcraw/dcrawsettingswidget.cpp:168
msgid ""
"<p><b>Interpolate RGB as four colors</b>"
"<p>The default is to assume that all green pixels are the same. If even-row "
"green pixels are more sensitive to ultraviolet light than odd-row this "
"difference causes a mesh pattern in the output; using this option solves this "
"problem with minimal loss of detail."
"<p>To resume, this option blurs the image a little, but it eliminates false 2x2 "
"mesh patterns with VNG quality method or mazes with AHD quality method."
msgstr ""
"<p><b>Інтерполювати RGB як чотири кольори</b>"
"<p>Типово припускається, що всі зелені пікселі однакові. Однак, якщо зелені "
"пікселі парних рядів більш чутливі до ультрафіолетового світла, ніж пікселі в "
"непарних рядах, то ця різниця утворює на зображенні сітку. Вживання цього "
"параметра вирішує цю проблему з мінімальною втратою якості."
"<p>Якщо коротко, цей параметр трохи розмиває зображення, але позбувається "
"фальшивого візерунка сітки 2x2 за допомогою методу якості VNG або "
"переплітається з методом AHD."
#: libkdcraw/dcrawsettingswidget.cpp:183
#, c-format
msgid "dcraw %1"
msgstr "dcraw: %1"
#: libkdcraw/dcrawsettingswidget.cpp:186
msgid "Visit dcraw project website"
msgstr "Відвідайте веб-сайт проекту dcraw"
#: libkdcraw/dcrawsettingswidget.cpp:191
msgid "White Balance:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:193
msgid "Default D65 White Balance"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:194
#, fuzzy
msgid "Camera White Balance"
msgstr "Вживати баланс білого з камери"
#: libkdcraw/dcrawsettingswidget.cpp:195
#, fuzzy
msgid "Automatic White Balance"
msgstr "Автоматичний баланс кольору"
#: libkdcraw/dcrawsettingswidget.cpp:196
#, fuzzy
msgid "Manual White balance"
msgstr "Вживати баланс білого з камери"
#: libkdcraw/dcrawsettingswidget.cpp:197
msgid ""
"<p><b>White Balance</b>"
"<p>Configure the raw white balance :"
"<p><b>Default D65 White Balance</b>: Use a standard daylight D65 white balance "
"(dcraw defaults)"
"<p><b>Camera White Balance</b>: Use the white balance specified by the camera. "
"If not available, reverts to default neutral white balance"
"<p><b>Automatic White Balance</b>: Calculates an automatic white balance "
"averaging the entire image"
"<p><b>Manual White balance</b>: Set a custom temperature and green level values"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:211
msgid "Temperature (K):"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:212
#, fuzzy
msgid "<p><b>Temperature</b><p>Set here the color temperature."
msgstr "<p><b>Поріг</b><p>Вкажіть поріг зменшення шуму."
#: libkdcraw/dcrawsettingswidget.cpp:221
msgid "Green:"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:222
msgid ""
"<p>Set here the green component to set magenta color cast removal level."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:230
msgid "Highlights:"
msgstr "Виблиски:"
#: libkdcraw/dcrawsettingswidget.cpp:232
msgid "Solid white"
msgstr "Чисте біле"
#: libkdcraw/dcrawsettingswidget.cpp:233
msgid "Unclip"
msgstr "Не об'єднувати"
#: libkdcraw/dcrawsettingswidget.cpp:234
msgid "Blend"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:235
msgid "Rebuild"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:236
#, fuzzy
msgid ""
"<p><b>Highlights</b>"
"<p>Select here the highlight clipping method:"
"<p><b>Solid white</b>: clip all highlights to solid white"
"<p><b>Unclip</b>: leave highlights unclipped in various shades of pink"
"<p><b>Blend</b>:Blend clipped and unclipped values together for a gradual fade "
"to white"
"<p><b>Rebuild</b>: reconstruct highlights using a level value"
msgstr ""
"<p><b>Виблиски</b>"
"<p>Виберіть спосіб обрізання виблисків:"
"<p><b>Чисте біле</b>: об'єднати всі виблиски в чисте біле "
"<p><b>Не об'єднувати</b>: залишити виблиски у відтінках рожевого "
"<p><b>Реконструювати</b>: реконструювати виблиски, вживаючи значення рівня."
#: libkdcraw/dcrawsettingswidget.cpp:248
msgid "Level:"
msgstr "Рівень:"
#: libkdcraw/dcrawsettingswidget.cpp:251
msgid ""
"<p><b>Level</b>"
"<p>Specify the reconstruct highlight level. Low values favor whites and high "
"values favor colors."
msgstr ""
"<p><b>Рівень</b> "
"<p>Вкажіть рівень для реконструкції виблисків в зображенні виводу. Низькі "
"значення - надається перевага білому, великі значення - кольорам."
#: libkdcraw/dcrawsettingswidget.cpp:260
msgid "Brightness:"
msgstr "Яскравість:"
#: libkdcraw/dcrawsettingswidget.cpp:264
msgid ""
"<p><b>Brighness</b>"
"<p>Specify the brightness level of output image.The default value is 1.0 (works "
"in 8-bit mode only)."
"<p>"
msgstr ""
"<p><b>Яскравість</b> "
"<p>Вкажіть рівень яскравості зображення виводу.Типовий: 1.0 (працює тільки в "
"8-бітовому режимі)."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:273
msgid "Quality (interpolation):"
msgstr "Якість (інтерполяція):"
#: libkdcraw/dcrawsettingswidget.cpp:275
msgid "Bilinear"
msgstr "Білінійна"
#: libkdcraw/dcrawsettingswidget.cpp:276
msgid "VNG"
msgstr "VNG"
#: libkdcraw/dcrawsettingswidget.cpp:277
msgid "PPG"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:278
msgid "AHD"
msgstr "AHD"
#: libkdcraw/dcrawsettingswidget.cpp:279
msgid ""
"<p><b>Quality</b>"
"<p>Select here the demosaicing RAW images decoding interpolation method. A "
"demosaicing algorithm is a digital image process used to interpolate a complete "
"image from the partial raw data received from the color-filtered image sensor "
"internal to many digital cameras in form of a matrix of colored pixels. Also "
"known as CFA interpolation or color reconstruction, another common spelling is "
"demosaicing. There are 3 methods to demosaicing RAW images:"
"<p><b>Bilinear</b>: use high-speed but low-quality bilinear interpolation "
"(default - for slow computer). In this method, the red value of a non-red pixel "
"is computed as the average of the adjacent red pixels, and similar for blue and "
"green."
"<p><b>VNG</b>: use Variable Number of Gradients interpolation. This method "
"computes gradients near the pixel of interest and uses the lower gradients "
"(representing smoother and more similar parts of the image) to make an "
"estimate."
"<p><b>PPG</b>: use Patterned Pixel Grouping interpolation. Pixel Grouping uses "
"assumptions about natural scenery in making estimates. It has fewer color "
"artifacts on natural images than the Variable Number of Gradients method."
"<p><b>AHD</b>: use Adaptive Homogeneity-Directed interpolation. This method "
"selects the direction of interpolation so as to maximize a homogeneity metric, "
"thus typically minimizing color artifacts."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:307
msgid "Enable noise reduction"
msgstr "Увімкнути зменшення шуму"
#: libkdcraw/dcrawsettingswidget.cpp:308
msgid ""
"<p><b>Enable Noise Reduction</b>"
"<p>Use wavelets to erase noise while preserving real detail."
"<p>"
msgstr ""
"<p><b>Увімкнути зменшення шуму</b>"
"<p>Вживайте wavelets для стирання шуму, але залишаючи без зміни деталі."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:315
msgid "Threshold:"
msgstr "Поріг:"
#: libkdcraw/dcrawsettingswidget.cpp:316
msgid ""
"<p><b>Threshold</b>"
"<p>Set here the noise reduction threshold value to use."
msgstr "<p><b>Поріг</b><p>Вкажіть поріг зменшення шуму."
#: libkdcraw/dcrawsettingswidget.cpp:324
#, fuzzy
msgid "Enable Chromatic Aberration correction"
msgstr "Увімкнути зменшення шуму"
#: libkdcraw/dcrawsettingswidget.cpp:325
msgid ""
"<p><b>Enable Chromatic Aberration correction</b>"
"<p>Enlarge the raw red and blue layers by the given factors, typically 0.999 to "
"1.001, to correct chromatic aberration."
"<p>"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:331
msgid "Red multiplier:"
msgstr "Коефіцієнт червоного:"
#: libkdcraw/dcrawsettingswidget.cpp:335
msgid ""
"<p><b>Red multiplier</b>"
"<p>Set here the magnification factor of the red layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:338
msgid "Blue multiplier:"
msgstr "Коефіцієнт синього:"
#: libkdcraw/dcrawsettingswidget.cpp:342
msgid ""
"<p><b>Blue multiplier</b>"
"<p>Set here the magnification factor of the blue layer"
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:354
msgid "Color space:"
msgstr "Простір кольорів:"
#: libkdcraw/dcrawsettingswidget.cpp:356
msgid "Raw (linear)"
msgstr "Raw (лінійний)"
#: libkdcraw/dcrawsettingswidget.cpp:357
msgid "sRGB"
msgstr "sRGB"
#: libkdcraw/dcrawsettingswidget.cpp:358
msgid "Adobe RGB"
msgstr "Adobe RGB"
#: libkdcraw/dcrawsettingswidget.cpp:359
msgid "Wide Gamut"
msgstr "Широка гама"
#: libkdcraw/dcrawsettingswidget.cpp:360
msgid "Pro-Photo"
msgstr "Pro-Photo"
#: libkdcraw/dcrawsettingswidget.cpp:361
msgid ""
"<p><b>Color space</b>"
"<p>Select here the output color space used to decode RAW data."
"<p><b>Raw (linear)</b>: in this mode, no output color space is used during RAW "
"decoding."
"<p><b>sRGB</b>: this is a RGB color space, created cooperatively by "
"Hewlett-Packard and Microsoft. It is the best choice for images destined for "
"the Web and portrait photography."
"<p><b>Adobe RGB</b>: this color space is an extended RGB color space, developed "
"by Adobe. It is used for photography applications such as advertising and fine "
"art."
"<p><b>Wide Gamut</b>: this color space is an expanded version of the Adobe RGB "
"color space."
"<p><b>Pro-Photo</b>: this color space is an RGB color space, developed by "
"Kodak, that offers an especially large gamut designed for use with photographic "
"outputs in mind."
msgstr ""
#: libkdcraw/dcrawsettingswidget.cpp:391
msgid "Standard"
msgstr "Стандартний"
#: libkdcraw/dcrawsettingswidget.cpp:398
msgid "Do not stretch or rotate pixels"
msgstr "Не розтягувати і не обертати пікселі"
#: libkdcraw/dcrawsettingswidget.cpp:399
msgid ""
"<p><b>Do not stretch or rotate pixels</b>"
"<p>For Fuji Super CCD cameras, show the image tilted 45 degrees. For cameras "
"with non-square pixels, do not stretch the image to its correct aspect ratio. "
"In any case, this option guarantees that each output pixel corresponds to one "
"RAW pixel."
"<p>"
msgstr ""
"<p><b>Не розтягувати і не обертати пікселі</b>"
"<p>Для камер з Fuji Super CCD показувати зображення з нахилом 45 градусів. Для "
"камер з неквадратними пікселями - не розтягувати зображення до його правильних "
"пропорцій. Цей параметр гарантує, що кожний піксель виводу відповідає одному "
"пікселю формату RAW."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:409
msgid "Black point"
msgstr "Чорна точка"
#: libkdcraw/dcrawsettingswidget.cpp:410
msgid ""
"<p><b>Black point</b>"
"<p>Use a specific black point value to decode RAW pictures. If you set this "
"option to off, the Black Point value will be automatically computed."
"<p>"
msgstr ""
"<p><b>Чорна точка</b>"
"<p>Вживати певне значення чорної точки для декодування зображень RAW. Якщо ви "
"вимкнете цей параметр, то значення чорної точки буде вирахуване автоматично."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:416
msgid ""
"<p><b>Black point value</b>"
"<p>Specify specific black point value of the output image."
"<p>"
msgstr ""
"<p><b>Значення чорної точки</b>"
"<p>Вкажіть значення чорної точки зображення виводу."
"<p>"
#: libkdcraw/dcrawsettingswidget.cpp:424
msgid "Advanced"
msgstr "Додаткові"
#~ msgid "<p><b>Use camera white balance</b><p>Use the camera's custom white-balance settings. If this can not be found, reverts to the default (which is to use fixed daylight values, calculated from sample images)."
#~ msgstr "<p><b>Вживати баланс білого з камери</b> <p>Вживати налаштування балансу білого з камери. Типово вживаються фіксовані значення денного світла, які вираховуються з зображень-зразків. Якщо його неможливо знайти, то повернути до типового."
#, fuzzy
#~ msgid "<p><b>Automatic color balance</b></p>Calculate the white balance by averaging the entire image."
#~ msgstr "<p><b>Автоматичний баланс кольору</b></p>Типовим є використання фіксованого балансу кольорів, який взято на основі білої картки сфотографованої при сонячному світлі."
#~ msgid "Color balance multipliers"
#~ msgstr "Коефіцієнти балансу кольору"
#~ msgid "Green 1 multiplier:"
#~ msgstr "Коефіцієнт зеленого 1:"
#~ msgid "Green 2 multiplier:"
#~ msgstr "Коефіцієнт зеленого 2:"
#~ msgid "Reconstruct"
#~ msgstr "Реконструювати"

4
subdirs
Unescape View File

@ -0,0 +1,4 @@
libkexiv2
libkipi
libkdcraw
po
Write Preview
Loading…
Cancel
Save