liz/rawTherapee
liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'dev' into filecatalog_speedups

Browse Source
This commit is contained in:
Ingo Weyrich 2019-07-19 00:50:55 +02:00
commit 0840b3ee00
47 changed files with 1809 additions and 459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -5,6 +5,7 @@
.project
.settings
.directory
.vscode
CMakeCache.txt
CMakeFiles

1
AUTHORS.txt
View File

@ -28,6 +28,7 @@ Development contributors, in last name alphabetical order:
Adam Reichold
Philip Rinn
Jan Rinze
Alberto Romei
Ben S.
Andrey Skvortsov
Fabio Suprani

9
rtdata/languages/Catala
View File

@ -1314,6 +1314,8 @@ ZOOMPANEL_ZOOMOUT;Allunya\nDrecera: <b>-</b>
!HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -1851,6 +1853,13 @@ ZOOMPANEL_ZOOMOUT;Allunya\nDrecera: <b>-</b>
!TP_EXPOSURE_TCMODE_PERCEPTUAL;Perceptual
!TP_EXPOS_BLACKPOINT_LABEL;Raw Black Points
!TP_EXPOS_WHITEPOINT_LABEL;Raw White Points
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_FILMSIMULATION_LABEL;Film Simulation
!TP_FILMSIMULATION_SLOWPARSEDIR;RawTherapee is configured to look for Hald CLUT images, which are used for the Film Simulation tool, in a folder which is taking too long to load.\nGo to Preferences > Image Processing > Film Simulation\nto see which folder is being used. You should either point RawTherapee to a folder which contains only Hald CLUT images and nothing more, or to an empty folder if you don't want to use the Film Simulation tool.\n\nRead the Film Simulation article in RawPedia for more information.\n\nDo you want to cancel the scan now?
!TP_FILMSIMULATION_STRENGTH;Strength

9
rtdata/languages/Chinese (Simplified)
View File

@ -1361,6 +1361,8 @@ ZOOMPANEL_ZOOMOUT;缩放拉远\n快捷键: <b>-</b>
!HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -1798,6 +1800,13 @@ ZOOMPANEL_ZOOMOUT;缩放拉远\n快捷键: <b>-</b>
!TP_EXPOSURE_TCMODE_PERCEPTUAL;Perceptual
!TP_EXPOS_BLACKPOINT_LABEL;Raw Black Points
!TP_EXPOS_WHITEPOINT_LABEL;Raw White Points
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_FILMSIMULATION_LABEL;Film Simulation
!TP_FILMSIMULATION_SLOWPARSEDIR;RawTherapee is configured to look for Hald CLUT images, which are used for the Film Simulation tool, in a folder which is taking too long to load.\nGo to Preferences > Image Processing > Film Simulation\nto see which folder is being used. You should either point RawTherapee to a folder which contains only Hald CLUT images and nothing more, or to an empty folder if you don't want to use the Film Simulation tool.\n\nRead the Film Simulation article in RawPedia for more information.\n\nDo you want to cancel the scan now?
!TP_FILMSIMULATION_STRENGTH;Strength

10
rtdata/languages/Deutsch
View File

@ -2365,3 +2365,13 @@ ZOOMPANEL_ZOOMOUT;Herauszoomen\nTaste: <b>-</b>
FILEBROWSER_POPUPREMOVE;Unwiderruflich löschen
FILEBROWSER_POPUPREMOVEINCLPROC;Unwiderruflich löschen\n(einschl. aller Dateien der Stabelverarbeitung)
FILEBROWSER_SHOWNOTTRASHHINT;Nur Bilder außerhalb des Papierkorbs anzeigen.
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots

9
rtdata/languages/English (UK)
View File

@ -838,6 +838,8 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh
!HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -1665,6 +1667,13 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh
!TP_EXPOSURE_TCMODE_WEIGHTEDSTD;Weighted Standard
!TP_EXPOS_BLACKPOINT_LABEL;Raw Black Points
!TP_EXPOS_WHITEPOINT_LABEL;Raw White Points
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_FILMSIMULATION_LABEL;Film Simulation
!TP_FILMSIMULATION_SLOWPARSEDIR;RawTherapee is configured to look for Hald CLUT images, which are used for the Film Simulation tool, in a folder which is taking too long to load.\nGo to Preferences > Image Processing > Film Simulation\nto see which folder is being used. You should either point RawTherapee to a folder which contains only Hald CLUT images and nothing more, or to an empty folder if you don't want to use the Film Simulation tool.\n\nRead the Film Simulation article in RawPedia for more information.\n\nDo you want to cancel the scan now?
!TP_FILMSIMULATION_STRENGTH;Strength

9
rtdata/languages/English (US)
View File

@ -748,6 +748,8 @@
!HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -1636,6 +1638,13 @@
!TP_EXPOSURE_TCMODE_WEIGHTEDSTD;Weighted Standard
!TP_EXPOS_BLACKPOINT_LABEL;Raw Black Points
!TP_EXPOS_WHITEPOINT_LABEL;Raw White Points
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_FILMSIMULATION_LABEL;Film Simulation
!TP_FILMSIMULATION_SLOWPARSEDIR;RawTherapee is configured to look for Hald CLUT images, which are used for the Film Simulation tool, in a folder which is taking too long to load.\nGo to Preferences > Image Processing > Film Simulation\nto see which folder is being used. You should either point RawTherapee to a folder which contains only Hald CLUT images and nothing more, or to an empty folder if you don't want to use the Film Simulation tool.\n\nRead the Film Simulation article in RawPedia for more information.\n\nDo you want to cancel the scan now?
!TP_FILMSIMULATION_STRENGTH;Strength

9
rtdata/languages/Italiano
View File

@ -1539,6 +1539,8 @@ ZOOMPANEL_ZOOMOUT;Rimpicciolisci.\nScorciatoia: <b>-</b>
!HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -1903,6 +1905,13 @@ ZOOMPANEL_ZOOMOUT;Rimpicciolisci.\nScorciatoia: <b>-</b>
!TP_EXPOSURE_TCMODE_PERCEPTUAL;Perceptual
!TP_EXPOS_BLACKPOINT_LABEL;Raw Black Points
!TP_EXPOS_WHITEPOINT_LABEL;Raw White Points
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_FILMSIMULATION_LABEL;Film Simulation
!TP_FILMSIMULATION_SLOWPARSEDIR;RawTherapee is configured to look for Hald CLUT images, which are used for the Film Simulation tool, in a folder which is taking too long to load.\nGo to Preferences > Image Processing > Film Simulation\nto see which folder is being used. You should either point RawTherapee to a folder which contains only Hald CLUT images and nothing more, or to an empty folder if you don't want to use the Film Simulation tool.\n\nRead the Film Simulation article in RawPedia for more information.\n\nDo you want to cancel the scan now?
!TP_FILMSIMULATION_STRENGTH;Strength

9
rtdata/languages/Magyar
View File

@ -1248,6 +1248,8 @@ ZOOMPANEL_ZOOMOUT;Kicsinyítés <b>-</b>
!HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -1816,6 +1818,13 @@ ZOOMPANEL_ZOOMOUT;Kicsinyítés <b>-</b>
!TP_EXPOSURE_TCMODE_WEIGHTEDSTD;Weighted Standard
!TP_EXPOS_BLACKPOINT_LABEL;Raw Black Points
!TP_EXPOS_WHITEPOINT_LABEL;Raw White Points
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_FILMSIMULATION_LABEL;Film Simulation
!TP_FILMSIMULATION_SLOWPARSEDIR;RawTherapee is configured to look for Hald CLUT images, which are used for the Film Simulation tool, in a folder which is taking too long to load.\nGo to Preferences > Image Processing > Film Simulation\nto see which folder is being used. You should either point RawTherapee to a folder which contains only Hald CLUT images and nothing more, or to an empty folder if you don't want to use the Film Simulation tool.\n\nRead the Film Simulation article in RawPedia for more information.\n\nDo you want to cancel the scan now?
!TP_FILMSIMULATION_STRENGTH;Strength

9
rtdata/languages/Nederlands
View File

@ -2036,6 +2036,8 @@ ZOOMPANEL_ZOOMOUT;Zoom uit\nSneltoets: <b>-</b>
!HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -2230,6 +2232,13 @@ ZOOMPANEL_ZOOMOUT;Zoom uit\nSneltoets: <b>-</b>
!TP_EXPOSURE_CLAMPOOG;Clip out-of-gamut colors
!TP_EXPOSURE_HISTMATCHING;Auto-Matched Tone Curve
!TP_EXPOSURE_HISTMATCHING_TOOLTIP;Automatically adjust sliders and curves (except exposure compensation) to match the look of the embedded JPEG thumbnail.
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_ICM_WORKING_TRC;Tone response curve:
!TP_ICM_WORKING_TRC_CUSTOM;Custom
!TP_ICM_WORKING_TRC_GAMMA;Gamma

9
rtdata/languages/Polish
View File

@ -1621,6 +1621,8 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrót: <b>-</b>
!HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -1929,6 +1931,13 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrót: <b>-</b>
!TP_EXPOSURE_HISTMATCHING_TOOLTIP;Automatically adjust sliders and curves (except exposure compensation) to match the look of the embedded JPEG thumbnail.
!TP_EXPOSURE_TCMODE_LUMINANCE;Luminance
!TP_EXPOSURE_TCMODE_PERCEPTUAL;Perceptual
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_FILMSIMULATION_SLOWPARSEDIR;RawTherapee is configured to look for Hald CLUT images, which are used for the Film Simulation tool, in a folder which is taking too long to load.\nGo to Preferences > Image Processing > Film Simulation\nto see which folder is being used. You should either point RawTherapee to a folder which contains only Hald CLUT images and nothing more, or to an empty folder if you don't want to use the Film Simulation tool.\n\nRead the Film Simulation article in RawPedia for more information.\n\nDo you want to cancel the scan now?
!TP_ICM_APPLYBASELINEEXPOSUREOFFSET;Baseline exposure
!TP_ICM_APPLYBASELINEEXPOSUREOFFSET_TOOLTIP;Employ the embedded DCP baseline exposure offset. The setting is only available if the selected DCP has one.

9
rtdata/languages/Portugues (Brasil)
View File

@ -2258,6 +2258,8 @@ ZOOMPANEL_ZOOMOUT;Menos Zoom\nAtalho: <b>-</b>
!FILEBROWSER_SHOWNOTTRASHHINT;Show only images not in trash.
!HISTORY_MSG_COLORTONING_LABREGION_OFFSET;CT - region offset
!HISTORY_MSG_COLORTONING_LABREGION_POWER;CT - region power
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!MAIN_FRAME_PLACES_DEL;Remove
!PREFERENCES_APPEARANCE_PSEUDOHIDPI;Pseudo-HiDPI mode
!PREFERENCES_CACHECLEAR_SAFETY;Only files in the cache are cleared. Processing profiles stored alongside the source images are not touched.
@ -2271,6 +2273,13 @@ ZOOMPANEL_ZOOMOUT;Menos Zoom\nAtalho: <b>-</b>
!TP_COLORTONING_LABREGION_OFFSET;Offset
!TP_COLORTONING_LABREGION_POWER;Power
!TP_CROP_PPI;PPI
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_LENSPROFILE_CORRECTION_AUTOMATCH;Automatically selected
!TP_LENSPROFILE_CORRECTION_MANUAL;Manually selected
!TP_LENSPROFILE_LENS_WARNING;Warning: the crop factor used for lens profiling is larger than the crop factor of the camera, the results might be wrong.

9
rtdata/languages/Russian
View File

@ -1706,6 +1706,8 @@ ZOOMPANEL_ZOOMOUT;Отдалить\nГорячая клавиша: <b>-</b>
!HISTORY_MSG_COLORTONING_LABREGION_SLOPE;CT - region slope
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
!HISTORY_MSG_ICM_OUTPUT_TYPE;Output - Type
@ -1974,6 +1976,13 @@ ZOOMPANEL_ZOOMOUT;Отдалить\nГорячая клавиша: <b>-</b>
!TP_DISTORTION_AUTO_TIP;Automatically corrects lens distortion in raw files by matching it against the embedded JPEG image if one exists and has had its lens disortion auto-corrected by the camera.
!TP_EXPOS_BLACKPOINT_LABEL;Raw Black Points
!TP_EXPOS_WHITEPOINT_LABEL;Raw White Points
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_FILMSIMULATION_SLOWPARSEDIR;RawTherapee is configured to look for Hald CLUT images, which are used for the Film Simulation tool, in a folder which is taking too long to load.\nGo to Preferences > Image Processing > Film Simulation\nto see which folder is being used. You should either point RawTherapee to a folder which contains only Hald CLUT images and nothing more, or to an empty folder if you don't want to use the Film Simulation tool.\n\nRead the Film Simulation article in RawPedia for more information.\n\nDo you want to cancel the scan now?
!TP_FLATFIELD_CLIPCONTROL;Clip control
!TP_FLATFIELD_CLIPCONTROL_TOOLTIP;Clip control avoids clipped highlights caused by applying the flat field. If there are already clipped highlights before applying the flat field, clip control can lead to color cast.

9
rtdata/languages/Serbian (Cyrilic Characters)
View File

@ -1514,6 +1514,8 @@ ZOOMPANEL_ZOOMOUT;Умањује приказ слике <b>-</b>
!HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -1902,6 +1904,13 @@ ZOOMPANEL_ZOOMOUT;Умањује приказ слике <b>-</b>
!TP_EXPOSURE_TCMODE_PERCEPTUAL;Perceptual
!TP_EXPOS_BLACKPOINT_LABEL;Raw Black Points
!TP_EXPOS_WHITEPOINT_LABEL;Raw White Points
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_FILMSIMULATION_LABEL;Film Simulation
!TP_FILMSIMULATION_SLOWPARSEDIR;RawTherapee is configured to look for Hald CLUT images, which are used for the Film Simulation tool, in a folder which is taking too long to load.\nGo to Preferences > Image Processing > Film Simulation\nto see which folder is being used. You should either point RawTherapee to a folder which contains only Hald CLUT images and nothing more, or to an empty folder if you don't want to use the Film Simulation tool.\n\nRead the Film Simulation article in RawPedia for more information.\n\nDo you want to cancel the scan now?
!TP_FILMSIMULATION_STRENGTH;Strength

9
rtdata/languages/Swedish
View File

@ -1863,6 +1863,8 @@ ZOOMPANEL_ZOOMOUT;Förminska.\nKortkommando: <b>-</b>
!HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
!HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
!HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
!HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
!HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
!HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
!HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
!HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -2117,6 +2119,13 @@ ZOOMPANEL_ZOOMOUT;Förminska.\nKortkommando: <b>-</b>
!TP_EXPOSURE_CLAMPOOG;Clip out-of-gamut colors
!TP_EXPOSURE_HISTMATCHING;Auto-Matched Tone Curve
!TP_EXPOSURE_HISTMATCHING_TOOLTIP;Automatically adjust sliders and curves (except exposure compensation) to match the look of the embedded JPEG thumbnail.
!TP_FILMNEGATIVE_BLUE;Blue ratio
!TP_FILMNEGATIVE_GREEN;Green exponent
!TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
!TP_FILMNEGATIVE_LABEL;Film Negative
!TP_FILMNEGATIVE_PICK;Pick white and black spots
!TP_FILMNEGATIVE_RED;Red ratio
!TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
!TP_FLATFIELD_CLIPCONTROL;Clip control
!TP_FLATFIELD_CLIPCONTROL_TOOLTIP;Clip control avoids clipped highlights caused by applying the flat field. If there are already clipped highlights before applying the flat field, clip control can lead to color cast.
!TP_ICM_APPLYBASELINEEXPOSUREOFFSET_TOOLTIP;Employ the embedded DCP baseline exposure offset. The setting is only available if the selected DCP has one.

10
rtdata/languages/default
View File

@ -747,6 +747,8 @@ HISTORY_MSG_DEHAZE_SHOW_DEPTH_MAP;Dehaze - Show depth map
HISTORY_MSG_DEHAZE_STRENGTH;Dehaze - Strength
HISTORY_MSG_DUALDEMOSAIC_AUTO_CONTRAST;Dual demosaic - Auto threshold
HISTORY_MSG_DUALDEMOSAIC_CONTRAST;Dual demosaic - Contrast threshold
HISTORY_MSG_FILMNEGATIVE_ENABLED;Film Negative
HISTORY_MSG_FILMNEGATIVE_VALUES;Film negative values
HISTORY_MSG_HISTMATCHING;Auto-matched tone curve
HISTORY_MSG_ICM_OUTPUT_PRIMARIES;Output - Primaries
HISTORY_MSG_ICM_OUTPUT_TEMP;Output - ICC-v4 illuminant D
@ -983,6 +985,7 @@ PARTIALPASTE_EVERYTHING;Everything
PARTIALPASTE_EXIFCHANGES;Exif
PARTIALPASTE_EXPOSURE;Exposure
PARTIALPASTE_FILMSIMULATION;Film simulation
PARTIALPASTE_FILMNEGATIVE;Film Negative
PARTIALPASTE_FLATFIELDAUTOSELECT;Flat-field auto-selection
PARTIALPASTE_FLATFIELDBLURRADIUS;Flat-field blur radius
PARTIALPASTE_FLATFIELDBLURTYPE;Flat-field blur type
@ -1635,6 +1638,13 @@ TP_EXPOSURE_TCMODE_STANDARD;Standard
TP_EXPOSURE_TCMODE_WEIGHTEDSTD;Weighted Standard
TP_EXPOS_BLACKPOINT_LABEL;Raw Black Points
TP_EXPOS_WHITEPOINT_LABEL;Raw White Points
TP_FILMNEGATIVE_BLUE;Blue ratio
TP_FILMNEGATIVE_GREEN;Reference exponent (contrast)
TP_FILMNEGATIVE_GUESS_TOOLTIP;Calculate exponents by picking 2 neutral reference spots in the image; one white (light gray) and one black (dark gray).\nThe order does not matter. The exponents will be updated after the second spot is picked.
TP_FILMNEGATIVE_LABEL;Film Negative
TP_FILMNEGATIVE_PICK;Pick white and black spots
TP_FILMNEGATIVE_RED;Red ratio
TP_FILMNEGATIVE_REF_SPOTS;Film negative reference spots
TP_FILMSIMULATION_LABEL;Film Simulation
TP_FILMSIMULATION_SLOWPARSEDIR;RawTherapee is configured to look for Hald CLUT images, which are used for the Film Simulation tool, in a folder which is taking too long to load.\nGo to Preferences > Image Processing > Film Simulation\nto see which folder is being used. You should either point RawTherapee to a folder which contains only Hald CLUT images and nothing more, or to an empty folder if you don't want to use the Film Simulation tool.\n\nRead the Film Simulation article in RawPedia for more information.\n\nDo you want to cancel the scan now?
TP_FILMSIMULATION_STRENGTH;Strength

2
rtengine/CMakeLists.txt
View File

@ -61,6 +61,8 @@ set(RTENGINESOURCEFILES
eahd_demosaic.cc
fast_demo.cc
ffmanager.cc
filmnegativeproc.cc
filmnegativethumb.cc
flatcurves.cc
gauss.cc
green_equil_RT.cc

5
rtengine/camconst.json
View File

@ -2437,6 +2437,11 @@ Camera constants:
"pdaf_offset" : 31
},
{ // Quality C,
"make_model": "Sony ILCE-7RM4",
"raw_crop": [ 0, 0, 9568, 0 ] // full raw frame 9600x6376 - 32 rightmost columns are garbage
},
{ // Quality B, color matrix copied from a7rm2
"make_model": "Sony ILCE-9",
"dcraw_matrix": [ 6389,-1703,-378,-4562,12265,2587,-670,1489,6550 ], // DNG_v9.12 D65

403
rtengine/filmnegativeproc.cc Normal file
View File

@ -0,0 +1,403 @@
/*
* This file is part of RawTherapee.
*
* Copyright (c) 2019 Alberto Romei <aldrop8@gmail.com>
*
* RawTherapee 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 3 of the License, or
* (at your option) any later version.
*
* RawTherapee 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 RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include <cmath>
#include <iostream>
#ifdef _OPENMP
#include <omp.h>
#endif
#include "rawimagesource.h"
#include "mytime.h"
#include "opthelper.h"
#include "procparams.h"
#include "rt_algo.h"
#include "rtengine.h"
//#define BENCHMARK
#include "StopWatch.h"
namespace rtengine
{
extern const Settings* settings;
}
namespace
{
bool channelsAvg(
const rtengine::RawImage* ri,
int width,
int height,
const float* cblacksom,
rtengine::Coord spotPos,
int spotSize,
const rtengine::procparams::FilmNegativeParams& params,
std::array<float, 3>& avgs
)
{
avgs = {}; // Channel averages
if (ri->getSensorType() != rtengine::ST_BAYER && ri->getSensorType() != rtengine::ST_FUJI_XTRANS) {
return false;
}
if (rtengine::settings->verbose) {
printf("Spot coord: x=%d y=%d\n", spotPos.x, spotPos.y);
}
const int half_spot_size = spotSize / 2;
const int& x1 = spotPos.x - half_spot_size;
const int& x2 = spotPos.x + half_spot_size;
const int& y1 = spotPos.y - half_spot_size;
const int& y2 = spotPos.y + half_spot_size;
if (x1 < 0 || x2 > width || y1 < 0 || y2 > height) {
return false; // Spot goes outside bounds, bail out.
}
std::array<int, 3> pxCount = {}; // Per-channel sample counts
for (int c = spotPos.x - spotSize; c < spotPos.x + spotSize; ++c) {
for (int r = spotPos.y - spotSize; r < spotPos.y + spotSize; ++r) {
const int ch = ri->getSensorType() == rtengine::ST_BAYER ? ri->FC(r,c) : ri->XTRANSFC(r,c);
++pxCount[ch];
// Sample the original unprocessed values from RawImage, subtracting black levels.
// Scaling is irrelevant, as we are only interested in the ratio between two spots.
avgs[ch] += ri->data[r][c] - cblacksom[ch];
}
}
for (int ch = 0; ch < 3; ++ch) {
avgs[ch] /= pxCount[ch];
}
return true;
}
}
bool rtengine::RawImageSource::getFilmNegativeExponents(Coord2D spotA, Coord2D spotB, int tran, const FilmNegativeParams &currentParams, std::array<float, 3>& newExps)
{
newExps = {
static_cast<float>(currentParams.redRatio * currentParams.greenExp),
static_cast<float>(currentParams.greenExp),
static_cast<float>(currentParams.blueRatio * currentParams.greenExp)
};
constexpr int spotSize = 32; // TODO: Make this configurable?
Coord spot;
std::array<float, 3> clearVals;
std::array<float, 3> denseVals;
// Sample first spot
transformPosition(spotA.x, spotA.y, tran, spot.x, spot.y);
if (!channelsAvg(ri, W, H, cblacksom, spot, spotSize, currentParams, clearVals)) {
return false;
}
// Sample second spot
transformPosition(spotB.x, spotB.y, tran, spot.x, spot.y);
if (!channelsAvg(ri, W, H, cblacksom, spot, spotSize, currentParams, denseVals)) {
return false;
}
// Detect which one is the dense spot, based on green channel
if (clearVals[1] < denseVals[1]) {
std::swap(clearVals, denseVals);
}
if (settings->verbose) {
printf("Clear film values: R=%g G=%g B=%g\n", clearVals[0], clearVals[1], clearVals[2]);
printf("Dense film values: R=%g G=%g B=%g\n", denseVals[0], denseVals[1], denseVals[2]);
}
const float denseGreenRatio = clearVals[1] / denseVals[1];
// Calculate logarithms in arbitrary base
const auto logBase =
[](float base, float num) -> float
{
return std::log(num) / std::log(base);
};
// Calculate exponents for each channel, based on the ratio between the bright and dark values,
// compared to the ratio in the reference channel (green)
for (int ch = 0; ch < 3; ++ch) {
if (ch == 1) {
newExps[ch] = 1.f; // Green is the reference channel
} else {
newExps[ch] = CLAMP(logBase(clearVals[ch] / denseVals[ch], denseGreenRatio), 0.3f, 4.f);
}
}
if (settings->verbose) {
printf("New exponents: R=%g G=%g B=%g\n", newExps[0], newExps[1], newExps[2]);
}
return true;
}
void rtengine::RawImageSource::filmNegativeProcess(const procparams::FilmNegativeParams &params)
{
// BENCHFUNMICRO
if (!params.enabled) {
return;
}
// Exponents are expressed as positive in the parameters, so negate them in order
// to get the reciprocals.
const std::array<float, 3> exps = {
static_cast<float>(-params.redRatio * params.greenExp),
static_cast<float>(-params.greenExp),
static_cast<float>(-params.blueRatio * params.greenExp)
};
MyTime t1, t2, t3,t4, t5;
t1.set();
// Channel vectors to calculate medians
std::array<std::vector<float>, 3> cvs;
// Sample one every 5 pixels, and push the value in the appropriate channel vector.
// Choose an odd step, not a multiple of the CFA size, to get a chance to visit each channel.
if (ri->getSensorType() == ST_BAYER) {
for (int row = 0; row < H; row += 5) {
const int c0 = ri->FC(row, 0);
const int c1 = ri->FC(row, 5);
int col = 0;
for (; col < W - 5; col += 10) {
cvs[c0].push_back(rawData[row][col]);
cvs[c1].push_back(rawData[row][col + 5]);
}
if (col < W) {
cvs[c0].push_back(rawData[row][col]);
}
}
}
else if (ri->getSensorType() == ST_FUJI_XTRANS) {
for (int row = 0; row < H; row += 5) {
const std::array<unsigned int, 6> cs = {
ri->XTRANSFC(row, 0),
ri->XTRANSFC(row, 5),
ri->XTRANSFC(row, 10),
ri->XTRANSFC(row, 15),
ri->XTRANSFC(row, 20),
ri->XTRANSFC(row, 25)
};
int col = 0;
for (; col < W - 25; col += 30) {
for (int c = 0; c < 6; ++c) {
cvs[cs[c]].push_back(rawData[row][col + c * 5]);
}
}
for (int c = 0; col < W; col += 5, ++c) {
cvs[cs[c]].push_back(rawData[row][col]);
}
}
}
constexpr float MAX_OUT_VALUE = 65000.f;
t2.set();
if (settings->verbose) {
printf("Median vector fill loop time us: %d\n", t2.etime(t1));
}
t2.set();
std::array<float, 3> medians; // Channel median values
std::array<float, 3> mults = {
1.f,
1.f,
1.f
}; // Channel normalization multipliers
for (int c = 0; c < 3; ++c) {
// Find median values for each channel
if (!cvs[c].empty()) {
findMinMaxPercentile(cvs[c].data(), cvs[c].size(), 0.5f, medians[c], 0.5f, medians[c], true);
medians[c] = pow_F(rtengine::max(medians[c], 1.f), exps[c]);
// Determine the channel multiplier so that N times the median becomes 65k. This clips away
// the values in the dark border surrounding the negative (due to the film holder, for example),
// the reciprocal of which have blown up to stellar values.
mults[c] = MAX_OUT_VALUE / (medians[c] * 24.f);
}
}
t3.set();
if (settings->verbose) {
printf("Sample count: %zu, %zu, %zu\n", cvs[0].size(), cvs[1].size(), cvs[2].size());
printf("Medians: %g %g %g\n", medians[0], medians[1], medians[2] );
printf("Computed multipliers: %g %g %g\n", mults[0], mults[1], mults[2] );
printf("Median calc time us: %d\n", t3.etime(t2));
}
constexpr float CLIP_VAL = 65535.f;
t3.set();
if (ri->getSensorType() == ST_BAYER) {
#ifdef __SSE2__
const vfloat onev = F2V(1.f);
const vfloat clipv = F2V(CLIP_VAL);
#endif
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic, 16)
#endif
for (int row = 0; row < H; ++row) {
int col = 0;
// Avoid trouble with zeroes, minimum pixel value is 1.
const float exps0 = exps[FC(row, col)];
const float exps1 = exps[FC(row, col + 1)];
const float mult0 = mults[FC(row, col)];
const float mult1 = mults[FC(row, col + 1)];
#ifdef __SSE2__
const vfloat expsv = _mm_setr_ps(exps0, exps1, exps0, exps1);
const vfloat multsv = _mm_setr_ps(mult0, mult1, mult0, mult1);
for (; col < W - 3; col += 4) {
STVFU(rawData[row][col], vminf(multsv * pow_F(vmaxf(LVFU(rawData[row][col]), onev), expsv), clipv));
}
#endif // __SSE2__
for (; col < W - 1; col += 2) {
rawData[row][col] = rtengine::min(mult0 * pow_F(rtengine::max(rawData[row][col], 1.f), exps0), CLIP_VAL);
rawData[row][col + 1] = rtengine::min(mult1 * pow_F(rtengine::max(rawData[row][col + 1], 1.f), exps1), CLIP_VAL);
}
if (col < W) {
rawData[row][col] = rtengine::min(mult0 * pow_F(rtengine::max(rawData[row][col], 1.f), exps0), CLIP_VAL);
}
}
} else if (ri->getSensorType() == ST_FUJI_XTRANS) {
#ifdef __SSE2__
const vfloat onev = F2V(1.f);
const vfloat clipv = F2V(CLIP_VAL);
#endif
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic, 16)
#endif
for (int row = 0; row < H; row ++) {
int col = 0;
// Avoid trouble with zeroes, minimum pixel value is 1.
const std::array<float, 6> expsc = {
exps[ri->XTRANSFC(row, 0)],
exps[ri->XTRANSFC(row, 1)],
exps[ri->XTRANSFC(row, 2)],
exps[ri->XTRANSFC(row, 3)],
exps[ri->XTRANSFC(row, 4)],
exps[ri->XTRANSFC(row, 5)]
};
const std::array<float, 6> multsc = {
mults[ri->XTRANSFC(row, 0)],
mults[ri->XTRANSFC(row, 1)],
mults[ri->XTRANSFC(row, 2)],
mults[ri->XTRANSFC(row, 3)],
mults[ri->XTRANSFC(row, 4)],
mults[ri->XTRANSFC(row, 5)]
};
#ifdef __SSE2__
const vfloat expsv0 = _mm_setr_ps(expsc[0], expsc[1], expsc[2], expsc[3]);
const vfloat expsv1 = _mm_setr_ps(expsc[4], expsc[5], expsc[0], expsc[1]);
const vfloat expsv2 = _mm_setr_ps(expsc[2], expsc[3], expsc[4], expsc[5]);
const vfloat multsv0 = _mm_setr_ps(multsc[0], multsc[1], multsc[2], multsc[3]);
const vfloat multsv1 = _mm_setr_ps(multsc[4], multsc[5], multsc[0], multsc[1]);
const vfloat multsv2 = _mm_setr_ps(multsc[2], multsc[3], multsc[4], multsc[5]);
for (; col < W - 11; col += 12) {
STVFU(rawData[row][col], vminf(multsv0 * pow_F(vmaxf(LVFU(rawData[row][col]), onev), expsv0), clipv));
STVFU(rawData[row][col + 4], vminf(multsv1 * pow_F(vmaxf(LVFU(rawData[row][col + 4]), onev), expsv1), clipv));
STVFU(rawData[row][col + 8], vminf(multsv2 * pow_F(vmaxf(LVFU(rawData[row][col + 8]), onev), expsv2), clipv));
}
#endif // __SSE2__
for (; col < W - 5; col += 6) {
for (int c = 0; c < 6; ++c) {
rawData[row][col + c] = rtengine::min(multsc[c] * pow_F(rtengine::max(rawData[row][col + c], 1.f), expsc[c]), CLIP_VAL);
}
}
for (int c = 0; col < W; col++, c++) {
rawData[row][col + c] = rtengine::min(multsc[c] * pow_F(rtengine::max(rawData[row][col + c], 1.f), expsc[c]), CLIP_VAL);
}
}
}
t4.set();
if (settings->verbose) {
printf("Pow loop time us: %d\n", t4.etime(t3));
}
t4.set();
PixelsMap bitmapBads(W, H);
int totBP = 0; // Hold count of bad pixels to correct
if (ri->getSensorType() == ST_BAYER) {
#ifdef _OPENMP
#pragma omp parallel for reduction(+:totBP) schedule(dynamic,16)
#endif
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
if (rawData[i][j] >= MAX_OUT_VALUE) {
bitmapBads.set(j, i);
++totBP;
}
}
}
if (totBP > 0) {
interpolateBadPixelsBayer(bitmapBads, rawData);
}
}
else if (ri->getSensorType() == ST_FUJI_XTRANS) {
#ifdef _OPENMP
#pragma omp parallel for reduction(+:totBP) schedule(dynamic,16)
#endif
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
if (rawData[i][j] >= MAX_OUT_VALUE) {
bitmapBads.set(j, i);
totBP++;
}
}
}
if (totBP > 0) {
interpolateBadPixelsXtrans(bitmapBads);
}
}
t5.set();
if (settings->verbose) {
printf("Bad pixels count: %d\n", totBP);
printf("Bad pixels interpolation time us: %d\n", t5.etime(t4));
}
}

131
rtengine/filmnegativethumb.cc Normal file
View File

@ -0,0 +1,131 @@
/*
* This file is part of RawTherapee.
*
* Copyright (c) 2019 Alberto Romei <aldrop8@gmail.com>
*
* RawTherapee 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 3 of the License, or
* (at your option) any later version.
*
* RawTherapee 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 RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include <cmath>
#include "rtengine.h"
#include "rtthumbnail.h"
#include "opthelper.h"
#include "rt_algo.h"
#include "rtengine.h"
#include "settings.h"
#include "procparams.h"
#define BENCHMARK
#include "StopWatch.h"
namespace rtengine
{
extern const Settings* settings;
}
void rtengine::Thumbnail::processFilmNegative(
const procparams::ProcParams &params,
const Imagefloat* baseImg,
const int rwidth, const int rheight,
float &rmi, float &gmi, float &bmi
) {
StopWatch stop1("Thumbnail film negative", true);
// Channel exponents
const float rexp = -params.filmNegative.redRatio * params.filmNegative.greenExp;
const float gexp = -params.filmNegative.greenExp;
const float bexp = -params.filmNegative.blueRatio * params.filmNegative.greenExp;
// Need to calculate channel averages, to fake the same conditions
// found in rawimagesource, where get_ColorsCoeff is called with
// forceAutoWB=true.
float rsum = 0.f, gsum = 0.f, bsum = 0.f;
// Channel vectors to calculate medians
std::vector<float> rv, gv, bv;
for (int i = 0; i < rheight; i++) {
for (int j = 0; j < rwidth; j++) {
const float r = baseImg->r(i, j);
const float g = baseImg->g(i, j);
const float b = baseImg->b(i, j);
rsum += r;
gsum += g;
bsum += b;
rv.push_back(r);
gv.push_back(g);
bv.push_back(b);
}
}
const float ravg = rsum / (rheight*rwidth);
const float gavg = gsum / (rheight*rwidth);
const float bavg = bsum / (rheight*rwidth);
// Shifting current WB multipliers, based on channel averages.
rmi /= (gavg/ravg);
// gmi /= (gAvg/gAvg); green chosen as reference channel
bmi /= (gavg/bavg);
float rmed, gmed, bmed;
findMinMaxPercentile(rv.data(), rv.size(), 0.5f, rmed, 0.5f, rmed, true);
findMinMaxPercentile(gv.data(), gv.size(), 0.5f, gmed, 0.5f, gmed, true);
findMinMaxPercentile(bv.data(), bv.size(), 0.5f, bmed, 0.5f, bmed, true);
rmed = powf(rmed, rexp);
gmed = powf(gmed, gexp);
bmed = powf(bmed, bexp);
const float MAX_OUT_VALUE = 65000.f;
const float rmult = (MAX_OUT_VALUE / (rmed * 24)) ;
const float gmult = (MAX_OUT_VALUE / (gmed * 24)) ;
const float bmult = (MAX_OUT_VALUE / (bmed * 24)) ;
if (settings->verbose) {
printf("Thumbnail channel medians: %g %g %g\n", rmed, gmed, bmed);
printf("Thumbnail computed multipliers: %g %g %g\n", rmult, gmult, bmult);
}
#ifdef __SSE2__
const vfloat clipv = F2V(MAXVALF);
const vfloat rexpv = F2V(rexp);
const vfloat gexpv = F2V(gexp);
const vfloat bexpv = F2V(bexp);
const vfloat rmultv = F2V(rmult);
const vfloat gmultv = F2V(gmult);
const vfloat bmultv = F2V(bmult);
#endif
for (int i = 0; i < rheight; i++) {
float *rline = baseImg->r(i);
float *gline = baseImg->g(i);
float *bline = baseImg->b(i);
int j = 0;
#ifdef __SSE2__
for (; j < rwidth - 3; j +=4) {
STVFU(rline[j], vminf(rmultv * pow_F(LVFU(rline[j]), rexpv), clipv));
STVFU(gline[j], vminf(gmultv * pow_F(LVFU(gline[j]), gexpv), clipv));
STVFU(bline[j], vminf(bmultv * pow_F(LVFU(bline[j]), bexpv), clipv));
}
#endif
for (; j < rwidth; ++j) {
rline[j] = CLIP(rmult * pow_F(rline[j], rexp));
gline[j] = CLIP(gmult * pow_F(gline[j], gexp));
bline[j] = CLIP(bmult * pow_F(bline[j], bexp));
}
}
}

76
rtengine/imagedata.cc
View File

@ -69,36 +69,40 @@ FramesMetaData* FramesMetaData::fromFile (const Glib::ustring& fname, std::uniqu
return new FramesData (fname, std::move(rml), firstFrameOnly);
}
FrameData::FrameData (rtexif::TagDirectory* frameRootDir_, rtexif::TagDirectory* rootDir, rtexif::TagDirectory* firstRootDir)
: frameRootDir(frameRootDir_), iptc(nullptr), time(), timeStamp(), iso_speed(0), aperture(0.), focal_len(0.), focal_len35mm(0.), focus_dist(0.f),
shutter(0.), expcomp(0.), make("Unknown"), model("Unknown"), orientation("Unknown"), lens("Unknown"),
sampleFormat(IIOSF_UNKNOWN), isPixelShift(false), isHDR(false)
FrameData::FrameData(rtexif::TagDirectory* frameRootDir_, rtexif::TagDirectory* rootDir, rtexif::TagDirectory* firstRootDir) :
frameRootDir(frameRootDir_),
iptc(nullptr),
time{},
timeStamp{},
iso_speed(0),
aperture(0.),
focal_len(0.),
focal_len35mm(0.),
focus_dist(0.f),
shutter(0.),
expcomp(0.),
make("Unknown"),
model("Unknown"),
orientation("Unknown"),
rating(0),
lens("Unknown"),
sampleFormat(IIOSF_UNKNOWN),
isPixelShift(false),
isHDR(false)
{
memset (&time, 0, sizeof(time));
if (!frameRootDir) {
return;
}
rtexif::Tag* tag;
rtexif::TagDirectory* newFrameRootDir = frameRootDir;
memset(&time, 0, sizeof(time));
timeStamp = 0;
iso_speed = 0;
aperture = 0.0;
focal_len = 0.0;
focal_len35mm = 0.0;
focus_dist = 0.0f;
shutter = 0.0;
expcomp = 0.0;
make.clear();
model.clear();
serial.clear();
orientation.clear();
lens.clear();
tag = newFrameRootDir->findTag("Make");
rtexif::TagDirectory* newFrameRootDir = frameRootDir;
rtexif::Tag* tag = newFrameRootDir->findTag("Make");
if (!tag) {
newFrameRootDir = rootDir;
tag = newFrameRootDir->findTag("Make");
@ -187,6 +191,23 @@ FrameData::FrameData (rtexif::TagDirectory* frameRootDir_, rtexif::TagDirectory*
orientation = tag->valueToString ();
}
// Look for Rating metadata in the following order:
// 1. EXIF
// 2. XMP
// 3. pp3 sidecar file
tag = newFrameRootDir->findTagUpward("Rating");
if (tag && tag->toInt() != 0) {
rating = tag->toInt();
}
char sXMPRating[64];
if (newFrameRootDir->getXMPTagValue("xmp:Rating", sXMPRating)) {
// Guard against out-of-range values (<0, >5)
rating = rtengine::max(0, rtengine::min(5, atoi(sXMPRating)));
// Currently, Rating=-1 is not supported. A value of -1 should mean
// "Rejected" according to the specification. Maybe in the future, Rating=-1
// sets InTrash=true?
}
tag = newFrameRootDir->findTagUpward("MakerNote");
rtexif::TagDirectory* mnote = nullptr;
if (tag) {
@ -876,6 +897,11 @@ std::string FrameData::getOrientation () const
return orientation;
}
int FrameData::getRating () const
{
return rating;
}
void FramesData::setDCRawFrameCount (unsigned int frameCount)
@ -1169,10 +1195,20 @@ std::string FramesData::getOrientation(unsigned int frame) const
);
}
int FramesData::getRating(unsigned int frame) const
{
return getFromFrame<int>(
frames,
frame,
[](const FrameData& frame_data)
{
return frame_data.getRating();
}
);
}
//------inherited functions--------------//
std::string FramesMetaData::apertureToString (double aperture)
{

3
rtengine/imagedata.h
View File

@ -48,6 +48,7 @@ protected:
double expcomp;
std::string make, model, serial;
std::string orientation;
int rating;
std::string lens;
IIOSampleFormat sampleFormat;
@ -84,6 +85,7 @@ public:
std::string getLens () const;
std::string getSerialNumber () const;
std::string getOrientation () const;
int getRating () const;
};
class FramesData : public FramesMetaData {
@ -126,6 +128,7 @@ public:
std::string getLens (unsigned int frame = 0) const override;
std::string getSerialNumber (unsigned int frame = 0) const;
std::string getOrientation (unsigned int frame = 0) const override;
int getRating (unsigned int frame = 0) const override;
};

22
rtengine/imagesource.h
View File

@ -16,20 +16,22 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _IMAGESOURCE_
#define _IMAGESOURCE_
#pragma once
#include <array>
#include <vector>
#include <glibmm.h>
#include <vector>
#include "rtengine.h"
#include "colortemp.h"
#include "coord2d.h"
#include "dcp.h"
#include "LUT.h"
#include "imagedata.h"
#include "image8.h"
#include "image16.h"
#include "image8.h"
#include "imagedata.h"
#include "imagefloat.h"
#include "LUT.h"
#include "rtengine.h"
namespace rtengine
{
@ -39,6 +41,7 @@ namespace procparams
struct CoarseTransformParams;
struct ColorManagementParams;
struct FilmNegativeParams;
struct LensProfParams;
struct RAWParams;
struct RetinexParams;
@ -56,6 +59,7 @@ public:
double cam_xyz[3][3] = {};
};
// TODO: Move implementation to .cc (Flössie)
class ImageSource : public InitialImage
{
@ -77,6 +81,8 @@ public:
~ImageSource () override {}
virtual int load (const Glib::ustring &fname) = 0;
virtual void preprocess (const procparams::RAWParams &raw, const procparams::LensProfParams &lensProf, const procparams::CoarseTransformParams& coarse, bool prepareDenoise = true) {};
virtual void filmNegativeProcess (const procparams::FilmNegativeParams &params) {};
virtual bool getFilmNegativeExponents (Coord2D spotA, Coord2D spotB, int tran, const FilmNegativeParams& currentParams, std::array<float, 3>& newExps) { return false; };
virtual void demosaic (const procparams::RAWParams &raw, bool autoContrast, double &contrastThreshold) {};
virtual void retinex (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &deh, const procparams::ToneCurveParams& Tc, LUTf & cdcurve, LUTf & mapcurve, const RetinextransmissionCurve & dehatransmissionCurve, const RetinexgaintransmissionCurve & dehagaintransmissionCurve, multi_array2D<float, 4> &conversionBuffer, bool dehacontlutili, bool mapcontlutili, bool useHsl, float &minCD, float &maxCD, float &mini, float &maxi, float &Tmean, float &Tsigma, float &Tmin, float &Tmax, LUTu &histLRETI) {};
virtual void retinexPrepareCurves (const procparams::RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) {};
@ -177,5 +183,5 @@ public:
}
virtual void getRawValues(int x, int y, int rotate, int &R, int &G, int &B) = 0;
};
}
#endif

37
rtengine/improccoordinator.cc
View File

@ -277,6 +277,18 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
imgsrc->getRAWHistogram(histRedRaw, histGreenRaw, histBlueRaw);
highDetailPreprocessComputed = highDetailNeeded;
// After preprocess, run film negative processing if enabled
if (
(todo & M_RAW)
&& (
imgsrc->getSensorType() == ST_BAYER
|| imgsrc->getSensorType() == ST_FUJI_XTRANS
)
&& params->filmNegative.enabled
) {
imgsrc->filmNegativeProcess(params->filmNegative);
}
}
/*
@ -1250,6 +1262,31 @@ void ImProcCoordinator::getSpotWB(int x, int y, int rect, double& temp, double&
}
}
bool ImProcCoordinator::getFilmNegativeExponents(int xA, int yA, int xB, int yB, std::array<float, 3>& newExps)
{
MyMutex::MyLock lock(mProcessing);
const auto xlate =
[this](int x, int y) -> Coord2D
{
const std::vector<Coord2D> points = {Coord2D(x, y)};
std::vector<Coord2D> red;
std::vector<Coord2D> green;
std::vector<Coord2D> blue;
ipf.transCoord(fw, fh, points, red, green, blue);
return green[0];
};
const int tr = getCoarseBitMask(params->coarse);
const Coord2D p1 = xlate(xA, yA);
const Coord2D p2 = xlate(xB, yB);
return imgsrc->getFilmNegativeExponents(p1, p2, tr, params->filmNegative, newExps);
}
void ImProcCoordinator::getAutoCrop(double ratio, int &x, int &y, int &w, int &h)
{

1
rtengine/improccoordinator.h
View File

@ -269,6 +269,7 @@ public:
bool getAutoWB (double& temp, double& green, double equal, double tempBias) override;
void getCamWB (double& temp, double& green) override;
void getSpotWB (int x, int y, int rectSize, double& temp, double& green) override;
bool getFilmNegativeExponents(int xA, int yA, int xB, int yB, std::array<float, 3>& newExps) override;
void getAutoCrop (double ratio, int &x, int &y, int &w, int &h) override;
bool getHighQualComputed() override;
void setHighQualComputed() override;

42
rtengine/procparams.cc
View File

@ -2734,6 +2734,27 @@ bool MetaDataParams::operator!=(const MetaDataParams &other) const
return !(*this == other);
}
FilmNegativeParams::FilmNegativeParams() :
enabled(false),
redRatio(1.36),
greenExp(1.5),
blueRatio(0.86)
{
}
bool FilmNegativeParams::operator ==(const FilmNegativeParams& other) const
{
return
enabled == other.enabled
&& redRatio == other.redRatio
&& greenExp == other.greenExp
&& blueRatio == other.blueRatio;
}
bool FilmNegativeParams::operator !=(const FilmNegativeParams& other) const
{
return !(*this == other);
}
ProcParams::ProcParams()
{
@ -2832,7 +2853,10 @@ void ProcParams::setDefaults()
exif.clear();
iptc.clear();
rank = 0;
// -1 means that there's no pp3 data with rank yet. In this case, the
// embedded Rating metadata should take precedence. -1 should never be
// written to pp3 on disk.
rank = -1;
colorlabel = 0;
inTrash = false;
@ -3566,6 +3590,12 @@ int ProcParams::save(const Glib::ustring& fname, const Glib::ustring& fname2, bo
// MetaData
saveToKeyfile(!pedited || pedited->metadata.mode, "MetaData", "Mode", metadata.mode, keyFile);
// Film negative
saveToKeyfile(!pedited || pedited->filmNegative.enabled, "Film Negative", "Enabled", filmNegative.enabled, keyFile);
saveToKeyfile(!pedited || pedited->filmNegative.redRatio, "Film Negative", "RedRatio", filmNegative.redRatio, keyFile);
saveToKeyfile(!pedited || pedited->filmNegative.greenExp, "Film Negative", "GreenExponent", filmNegative.greenExp, keyFile);
saveToKeyfile(!pedited || pedited->filmNegative.blueRatio, "Film Negative", "BlueRatio", filmNegative.blueRatio, keyFile);
// EXIF change list
if (!pedited || pedited->exif) {
for (ExifPairs::const_iterator i = exif.begin(); i != exif.end(); ++i) {
@ -5109,6 +5139,13 @@ int ProcParams::load(const Glib::ustring& fname, ParamsEdited* pedited)
assignFromKeyfile(keyFile, "RAW X-Trans", "PreBlackBlue", pedited, raw.xtranssensor.blackblue, pedited->raw.xtranssensor.exBlackBlue);
}
if (keyFile.has_group("Film Negative")) {
assignFromKeyfile(keyFile, "Film Negative", "Enabled", pedited, filmNegative.enabled, pedited->filmNegative.enabled);
assignFromKeyfile(keyFile, "Film Negative", "RedRatio", pedited, filmNegative.redRatio, pedited->filmNegative.redRatio);
assignFromKeyfile(keyFile, "Film Negative", "GreenExponent", pedited, filmNegative.greenExp, pedited->filmNegative.greenExp);
assignFromKeyfile(keyFile, "Film Negative", "BlueRatio", pedited, filmNegative.blueRatio, pedited->filmNegative.blueRatio);
}
if (keyFile.has_group("MetaData")) {
int mode = int(MetaDataParams::TUNNEL);
assignFromKeyfile(keyFile, "MetaData", "Mode", pedited, mode, pedited->metadata.mode);
@ -5231,7 +5268,8 @@ bool ProcParams::operator ==(const ProcParams& other) const
&& metadata == other.metadata
&& exif == other.exif
&& iptc == other.iptc
&& dehaze == other.dehaze;
&& dehaze == other.dehaze
&& filmNegative == other.filmNegative;
}
bool ProcParams::operator !=(const ProcParams& other) const

21
rtengine/procparams.h
View File

@ -728,7 +728,6 @@ struct DirPyrDenoiseParams {
bool operator !=(const DirPyrDenoiseParams& other) const;
void getCurves(NoiseCurve& lCurve, NoiseCurve& cCurve) const;
};
// EPD related parameters.
@ -1056,7 +1055,6 @@ struct ColorManagementParams {
bool operator !=(const ColorManagementParams& other) const;
};
/**
* Parameters for metadata handling
*/
@ -1295,7 +1293,6 @@ struct HSVEqualizerParams {
bool operator !=(const HSVEqualizerParams& other) const;
};
/**
* Film simualtion params
*/
@ -1310,7 +1307,6 @@ struct FilmSimulationParams {
bool operator !=(const FilmSimulationParams& other) const;
};
struct SoftLightParams {
bool enabled;
int strength;
@ -1334,7 +1330,6 @@ struct DehazeParams {
bool operator!=(const DehazeParams &other) const;
};
/**
* Parameters for RAW demosaicing, common to all sensor type
*/
@ -1501,6 +1496,21 @@ struct RAWParams {
static Glib::ustring getFlatFieldBlurTypeString(FlatFieldBlurType type);
};
/**
* Parameters of film negative
*/
struct FilmNegativeParams {
bool enabled;
double redRatio;
double greenExp;
double blueRatio;
FilmNegativeParams();
bool operator ==(const FilmNegativeParams& other) const;
bool operator !=(const FilmNegativeParams& other) const;
};
/**
* This class holds all the processing parameters applied on the images
*/
@ -1549,6 +1559,7 @@ public:
FilmSimulationParams filmSimulation; ///< film simulation parameters
SoftLightParams softlight; ///< softlight parameters
DehazeParams dehaze; ///< dehaze parameters
FilmNegativeParams filmNegative; ///< Film negative parameters
int rank; ///< Custom image quality ranking
int colorlabel; ///< Custom color label
bool inTrash; ///< Marks deleted image

2
rtengine/rawimage.cc
View File

@ -67,7 +67,7 @@ RawImage::~RawImage()
}
}
eSensorType RawImage::getSensorType()
eSensorType RawImage::getSensorType() const
{
if (isBayer()) {
return ST_BAYER;

2
rtengine/rawimage.h
View File

@ -113,7 +113,7 @@ public:
return float_raw_image;
}
eSensorType getSensorType();
eSensorType getSensorType() const;
void getRgbCam (float rgbcam[3][4]);
void getXtransMatrix ( int xtransMatrix[6][6]);

10
rtengine/rawimagesource.h
View File

@ -16,9 +16,9 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _RAWIMAGESOURCE_
#define _RAWIMAGESOURCE_
#pragma once
#include <array>
#include <iostream>
#include <memory>
@ -37,7 +37,6 @@ namespace rtengine
class RawImageSource : public ImageSource
{
private:
static DiagonalCurve *phaseOneIccCurve;
static DiagonalCurve *phaseOneIccCurveInv;
@ -109,7 +108,6 @@ protected:
inline void getRowStartEnd (int x, int &start, int &end);
static void getProfilePreprocParams(cmsHPROFILE in, float& gammafac, float& lineFac, float& lineSum);
public:
RawImageSource ();
~RawImageSource () override;
@ -117,6 +115,8 @@ public:
int load(const Glib::ustring &fname) override { return load(fname, false); }
int load(const Glib::ustring &fname, bool firstFrameOnly);
void preprocess (const procparams::RAWParams &raw, const procparams::LensProfParams &lensProf, const procparams::CoarseTransformParams& coarse, bool prepareDenoise = true) override;
void filmNegativeProcess (const procparams::FilmNegativeParams &params) override;
bool getFilmNegativeExponents (Coord2D spotA, Coord2D spotB, int tran, const FilmNegativeParams &currentParams, std::array<float, 3>& newExps) override;
void demosaic (const procparams::RAWParams &raw, bool autoContrast, double &contrastThreshold) override;
void retinex (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &deh, const procparams::ToneCurveParams& Tc, LUTf & cdcurve, LUTf & mapcurve, const RetinextransmissionCurve & dehatransmissionCurve, const RetinexgaintransmissionCurve & dehagaintransmissionCurve, multi_array2D<float, 4> &conversionBuffer, bool dehacontlutili, bool mapcontlutili, bool useHsl, float &minCD, float &maxCD, float &mini, float &maxi, float &Tmean, float &Tsigma, float &Tmin, float &Tmax, LUTu &histLRETI) override;
void retinexPrepareCurves (const procparams::RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) override;
@ -307,5 +307,5 @@ protected:
void getRawValues(int x, int y, int rotate, int &R, int &G, int &B) override;
};
}
#endif

38
rtengine/rtengine.h
View File

@ -16,23 +16,29 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _RTENGINE_
#define _RTENGINE_
#pragma once
#include "imageformat.h"
#include "rt_math.h"
#include "procevents.h"
#include <lcms2.h>
#include <string>
#include <glibmm.h>
#include <array>
#include <ctime>
#include "../rtexif/rtexif.h"
#include "rawmetadatalocation.h"
#include <string>
#include <glibmm.h>
#include <lcms2.h>
#include "iimage.h"
#include "utils.h"
#include "../rtgui/threadutils.h"
#include "settings.h"
#include "imageformat.h"
#include "LUT.h"
#include "procevents.h"
#include "rawmetadatalocation.h"
#include "rt_math.h"
#include "settings.h"
#include "utils.h"
#include "../rtexif/rtexif.h"
#include "../rtgui/threadutils.h"
/**
* @file
* This file contains the main functionality of the RawTherapee engine.
@ -133,6 +139,8 @@ public:
virtual std::string getLens (unsigned int frame = 0) const = 0;
/** @return the orientation of the image */
virtual std::string getOrientation (unsigned int frame = 0) const = 0;
/** @return the rating of the image */
virtual int getRating (unsigned int frame = 0) const = 0;
/** @return true if the file is a PixelShift shot (Pentax and Sony bodies) */
virtual bool getPixelShift () const = 0;
@ -499,6 +507,7 @@ public:
virtual bool getAutoWB (double& temp, double& green, double equal, double tempBias) = 0;
virtual void getCamWB (double& temp, double& green) = 0;
virtual void getSpotWB (int x, int y, int rectSize, double& temp, double& green) = 0;
virtual bool getFilmNegativeExponents(int xA, int yA, int xB, int yB, std::array<float, 3>& newExps) = 0;
virtual void getAutoCrop (double ratio, int &x, int &y, int &w, int &h) = 0;
virtual void saveInputICCReference (const Glib::ustring& fname, bool apply_wb) = 0;
@ -612,6 +621,3 @@ void startBatchProcessing (ProcessingJob* job, BatchProcessingListener* bpl);
extern MyMutex* lcmsMutex;
}
#endif

4
rtengine/rtthumbnail.cc
View File

@ -1167,6 +1167,10 @@ IImage8* Thumbnail::processImage (const procparams::ProcParams& params, eSensorT
Imagefloat* baseImg = resizeTo<Imagefloat> (rwidth, rheight, interp, thumbImg);
if (isRaw && params.filmNegative.enabled) {
processFilmNegative(params, baseImg, rwidth, rheight, rmi, gmi, bmi);
}
if (params.coarse.rotate) {
baseImg->rotate (params.coarse.rotate);
rwidth = baseImg->getWidth();

2
rtengine/rtthumbnail.h
View File

@ -68,6 +68,8 @@ class Thumbnail
bool gammaCorrected;
double colorMatrix[3][3];
void processFilmNegative(const procparams::ProcParams& params, const Imagefloat* baseImg, int rwidth, int rheight, float &rmi, float &gmi, float &bmi);
public:
bool isRaw;

5
rtengine/simpleprocess.cc
View File

@ -209,6 +209,11 @@ private:
imgsrc->setCurrentFrame (params.raw.bayersensor.imageNum);
imgsrc->preprocess ( params.raw, params.lensProf, params.coarse, params.dirpyrDenoise.enabled);
// After preprocess, run film negative processing if enabled
if (imgsrc->getSensorType() == ST_BAYER && params.filmNegative.enabled) {
imgsrc->filmNegativeProcess (params.filmNegative);
}
if (pl) {
pl->setProgress (0.20);
}

6
rtexif/rtexif.cc
View File

@ -3037,6 +3037,12 @@ void ExifManager::parse (bool isRaw, bool skipIgnored)
}
}
if (!root->getTag ("Rating")) {
Tag *t = new Tag (root, root->getAttrib("Rating"));
t->initInt (0, LONG);
root->addTag (t);
}
// --- detecting image root IFD based on SubFileType, or if not provided, on PhotometricInterpretation
bool frameRootDetected = false;

17
rtgui/CMakeLists.txt
View File

@ -43,6 +43,7 @@ set(NONCLISOURCEFILES
curveeditorgroup.cc
darkframe.cc
defringe.cc
dehaze.cc
diagonalcurveeditorsubgroup.cc
dirbrowser.cc
dirpyrdenoise.cc
@ -55,15 +56,18 @@ set(NONCLISOURCEFILES
editwidgets.cc
editwindow.cc
epd.cc
eventmapper.cc
exiffiltersettings.cc
exifpanel.cc
exportpanel.cc
extprog.cc
fattaltonemap.cc
filebrowser.cc
filebrowserentry.cc
filecatalog.cc
filepanel.cc
filethumbnailbuttonset.cc
filmnegative.cc
filmsimulation.cc
filterpanel.cc
flatcurveeditorsubgroup.cc
@ -83,12 +87,15 @@ set(NONCLISOURCEFILES
inspector.cc
iptcpanel.cc
labcurve.cc
labgrid.cc
lensgeom.cc
lensprofile.cc
localcontrast.cc
lockablecolorpicker.cc
lwbutton.cc
lwbuttonset.cc
main.cc
metadatapanel.cc
multilangmgr.cc
mycurve.cc
mydiagonalcurve.cc
@ -122,8 +129,8 @@ set(NONCLISOURCEFILES
rgbcurves.cc
rotate.cc
rtimage.cc
rtsurface.cc
rtscalable.cc
rtsurface.cc
rtwindow.cc
saveasdlg.cc
saveformatpanel.cc
@ -134,6 +141,7 @@ set(NONCLISOURCEFILES
sharpening.cc
sharpenmicro.cc
shcselector.cc
softlight.cc
soundman.cc
splash.cc
threadutils.cc
@ -154,13 +162,6 @@ set(NONCLISOURCEFILES
xtransprocess.cc
xtransrawexposure.cc
zoompanel.cc
fattaltonemap.cc
localcontrast.cc
eventmapper.cc
metadatapanel.cc
labgrid.cc
softlight.cc
dehaze.cc
)
include_directories(BEFORE "${CMAKE_CURRENT_BINARY_DIR}")

42
rtgui/cacheimagedata.cc
View File

@ -24,12 +24,37 @@
#include "../rtengine/procparams.h"
CacheImageData::CacheImageData ()
: md5(""), supported(false), format(FT_Invalid), rankOld(-1), inTrashOld(false), recentlySaved(false),
timeValid(false), year(0), month(0), day(0), hour(0), min(0), sec(0), exifValid(false), frameCount(1),
fnumber(0.0), shutter(0.0), focalLen(0.0), focalLen35mm(0.0), focusDist(0.f), iso(0), isHDR (false),
isPixelShift (false), sensortype(rtengine::ST_NONE), sampleFormat(rtengine::IIOSF_UNKNOWN),
redAWBMul(-1.0), greenAWBMul(-1.0), blueAWBMul(-1.0), rotate(0), thumbImgType(0)
CacheImageData::CacheImageData() :
supported(false),
format(FT_Invalid),
rankOld(-1),
inTrashOld(false),
recentlySaved(false),
timeValid(false),
year(0),
month(0),
day(0),
hour(0),
min(0),
sec(0),
exifValid(false),
frameCount(1),
fnumber(0.0),
shutter(0.0),
focalLen(0.0),
focalLen35mm(0.0),
focusDist(0.f),
iso(0),
rating(0),
isHDR (false),
isPixelShift (false),
sensortype(rtengine::ST_NONE),
sampleFormat(rtengine::IIOSF_UNKNOWN),
redAWBMul(-1.0),
greenAWBMul(-1.0),
blueAWBMul(-1.0),
rotate(0),
thumbImgType(0)
{
}
@ -66,6 +91,10 @@ int CacheImageData::load (const Glib::ustring& fname)
rankOld = keyFile.get_integer ("General", "Rank");
}
if (keyFile.has_key ("General", "Rating")) {
rating = keyFile.get_integer ("General", "Rating");
}
if (keyFile.has_key ("General", "InTrash")) {
inTrashOld = keyFile.get_boolean ("General", "InTrash");
}
@ -227,6 +256,7 @@ int CacheImageData::save (const Glib::ustring& fname)
keyFile.set_boolean ("General", "Supported", supported);
keyFile.set_integer ("General", "Format", format);
keyFile.set_boolean ("General", "RecentlySaved", recentlySaved);
keyFile.set_integer ("General", "Rating", rating);
// remove the old implementation of Rank and InTrash from cache
if (keyFile.has_key ("General", "Rank")) {

2
rtgui/cacheimagedata.h
View File

@ -54,6 +54,7 @@ public:
double focalLen, focalLen35mm;
float focusDist;
unsigned iso;
int rating;
bool isHDR;
bool isPixelShift;
int sensortype;
@ -108,6 +109,7 @@ public:
std::string getModel (unsigned int frame = 0) const override { return camModel; }
std::string getLens (unsigned int frame = 0) const override { return lens; }
std::string getOrientation (unsigned int frame = 0) const override { return ""; } // TODO
int getRating (unsigned int frame = 0) const override { return rating; } // FIXME-piotr : missing rating
bool getPixelShift () const override { return isPixelShift; }
bool getHDR (unsigned int frame = 0) const override { return isHDR; }
std::string getImageType (unsigned int frame) const override { return isPixelShift ? "PS" : isHDR ? "HDR" : "STD"; }

317
rtgui/filmnegative.cc Normal file
View File

@ -0,0 +1,317 @@
/*
* This file is part of RawTherapee.
*
* Copyright (c) 2019 Alberto Romei <aldrop8@gmail.com>
*
* RawTherapee 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 3 of the License, or
* (at your option) any later version.
*
* RawTherapee 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 RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include <iomanip>
#include "filmnegative.h"
#include "editwidgets.h"
#include "eventmapper.h"
#include "options.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
namespace
{
Adjuster* createExponentAdjuster(AdjusterListener* listener, const Glib::ustring& label, double minV, double maxV, double defaultVal)
{
Adjuster* const adj = Gtk::manage(new Adjuster(label, minV, maxV, 0.001, defaultVal));
adj->setAdjusterListener(listener);
adj->setLogScale(6, 1, true);
if (adj->delay < options.adjusterMaxDelay) {
adj->delay = options.adjusterMaxDelay;
}
adj->show();
return adj;
}
}
FilmNegative::FilmNegative() :
FoldableToolPanel(this, "filmnegative", M("TP_FILMNEGATIVE_LABEL"), false, true),
EditSubscriber(ET_OBJECTS),
evFilmNegativeExponents(ProcEventMapper::getInstance()->newEvent(FIRST, "HISTORY_MSG_FILMNEGATIVE_VALUES")),
evFilmNegativeEnabled(ProcEventMapper::getInstance()->newEvent(FIRST, "HISTORY_MSG_FILMNEGATIVE_ENABLED")),
fnp(nullptr),
greenExp(createExponentAdjuster(this, M("TP_FILMNEGATIVE_GREEN"), 0.3, 4, 1.5)), // master exponent (green channel)
redRatio(createExponentAdjuster(this, M("TP_FILMNEGATIVE_RED"), 0.3, 3, (2.04 / 1.5))), // ratio of red exponent to master exponent
blueRatio(createExponentAdjuster(this, M("TP_FILMNEGATIVE_BLUE"), 0.3, 3, (1.29 / 1.5))), // ratio of blue exponent to master exponent
spotgrid(Gtk::manage(new Gtk::Grid())),
spotbutton(Gtk::manage(new Gtk::ToggleButton(M("TP_FILMNEGATIVE_PICK"))))
{
spotgrid->get_style_context()->add_class("grid-spacing");
setExpandAlignProperties(spotgrid, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_CENTER);
setExpandAlignProperties(spotbutton, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_CENTER);
spotbutton->get_style_context()->add_class("independent");
spotbutton->set_tooltip_text(M("TP_FILMNEGATIVE_GUESS_TOOLTIP"));
spotbutton->set_image (*Gtk::manage (new RTImage ("color-picker-small.png")));
// TODO make spot size configurable ?
// Gtk::Label* slab = Gtk::manage (new Gtk::Label (M("TP_WBALANCE_SIZE")));
// setExpandAlignProperties(slab, false, false, Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
// Gtk::Grid* wbsizehelper = Gtk::manage(new Gtk::Grid());
// wbsizehelper->set_name("WB-Size-Helper");
// setExpandAlignProperties(wbsizehelper, false, false, Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
// spotsize = Gtk::manage (new MyComboBoxText ());
// setExpandAlignProperties(spotsize, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_CENTER);
// spotsize->append ("2");
// spotsize->set_active(0);
// spotsize->append ("4");
spotgrid->attach (*spotbutton, 0, 1, 1, 1);
// spotgrid->attach (*slab, 1, 0, 1, 1);
// spotgrid->attach (*wbsizehelper, 2, 0, 1, 1);
pack_start(*greenExp, Gtk::PACK_SHRINK, 0);
pack_start(*redRatio, Gtk::PACK_SHRINK, 0);
pack_start(*blueRatio, Gtk::PACK_SHRINK, 0);
pack_start(*spotgrid, Gtk::PACK_SHRINK, 0);
spotbutton->signal_toggled().connect(sigc::mem_fun(*this, &FilmNegative::editToggled));
// spotsize->signal_changed().connect( sigc::mem_fun(*this, &WhiteBalance::spotSizeChanged) );
// Editing geometry; create the spot rectangle
Rectangle* const spotRect = new Rectangle();
spotRect->filled = false;
visibleGeometry.push_back(spotRect);
// Stick a dummy rectangle over the whole image in mouseOverGeometry.
// This is to make sure the getCursor() call is fired everywhere.
Rectangle* const imgRect = new Rectangle();
imgRect->filled = true;
mouseOverGeometry.push_back(imgRect);
}
FilmNegative::~FilmNegative()
{
for (auto geometry : visibleGeometry) {
delete geometry;
}
for (auto geometry : mouseOverGeometry) {
delete geometry;
}
}
void FilmNegative::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
disableListener();
if (pedited) {
redRatio->setEditedState(pedited->filmNegative.redRatio ? Edited : UnEdited);
greenExp->setEditedState(pedited->filmNegative.greenExp ? Edited : UnEdited);
blueRatio->setEditedState(pedited->filmNegative.blueRatio ? Edited : UnEdited);
set_inconsistent(multiImage && !pedited->filmNegative.enabled);
}
setEnabled(pp->filmNegative.enabled);
redRatio->setValue(pp->filmNegative.redRatio);
greenExp->setValue(pp->filmNegative.greenExp);
blueRatio->setValue(pp->filmNegative.blueRatio);
enableListener();
}
void FilmNegative::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
pp->filmNegative.redRatio = redRatio->getValue();
pp->filmNegative.greenExp = greenExp->getValue();
pp->filmNegative.blueRatio = blueRatio->getValue();
pp->filmNegative.enabled = getEnabled();
if (pedited) {
pedited->filmNegative.redRatio = redRatio->getEditedState();
pedited->filmNegative.greenExp = greenExp->getEditedState();
pedited->filmNegative.blueRatio = blueRatio->getEditedState();
pedited->filmNegative.enabled = !get_inconsistent();
}
}
void FilmNegative::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
redRatio->setValue(defParams->filmNegative.redRatio);
greenExp->setValue(defParams->filmNegative.greenExp);
blueRatio->setValue(defParams->filmNegative.blueRatio);
if (pedited) {
redRatio->setDefaultEditedState(pedited->filmNegative.redRatio ? Edited : UnEdited);
greenExp->setDefaultEditedState(pedited->filmNegative.greenExp ? Edited : UnEdited);
blueRatio->setDefaultEditedState(pedited->filmNegative.blueRatio ? Edited : UnEdited);
} else {
redRatio->setDefaultEditedState(Irrelevant);
greenExp->setDefaultEditedState(Irrelevant);
blueRatio->setDefaultEditedState(Irrelevant);
}
}
void FilmNegative::setBatchMode(bool batchMode)
{
if (batchMode) {
spotConn.disconnect();
removeIfThere(this, spotgrid, false);
ToolPanel::setBatchMode(batchMode);
redRatio->showEditedCB();
greenExp->showEditedCB();
blueRatio->showEditedCB();
}
}
void FilmNegative::adjusterChanged(Adjuster* a, double newval)
{
if (listener) {
if (a == redRatio || a == greenExp || a == blueRatio) {
if (getEnabled()) {
listener->panelChanged(
evFilmNegativeExponents,
Glib::ustring::compose(
"Ref=%1 ; R=%2 ; B=%3",
greenExp->getValue(),
redRatio->getValue(),
blueRatio->getValue()
)
);
}
}
}
}
void FilmNegative::adjusterAutoToggled(Adjuster* a, bool newval)
{
}
void FilmNegative::enabledChanged()
{
if (listener) {
if (get_inconsistent()) {
listener->panelChanged(evFilmNegativeEnabled, M("GENERAL_UNCHANGED"));
}
else if (getEnabled()) {
listener->panelChanged(evFilmNegativeEnabled, M("GENERAL_ENABLED"));
}
else {
listener->panelChanged(evFilmNegativeEnabled, M("GENERAL_DISABLED"));
}
}
}
void FilmNegative::setFilmNegProvider(FilmNegProvider* provider)
{
fnp = provider;
}
void FilmNegative::setEditProvider(EditDataProvider* provider)
{
EditSubscriber::setEditProvider(provider);
}
CursorShape FilmNegative::getCursor(int objectID) const
{
return CSSpotWB;
}
bool FilmNegative::mouseOver(int modifierKey)
{
EditDataProvider* const provider = getEditProvider();
Rectangle* const spotRect = static_cast<Rectangle*>(visibleGeometry.at(0));
spotRect->setXYWH(provider->posImage.x - 16, provider->posImage.y - 16, 32, 32);
return true;
}
bool FilmNegative::button1Pressed(int modifierKey)
{
EditDataProvider* const provider = getEditProvider();
EditSubscriber::action = EditSubscriber::Action::NONE;
if (listener) {
refSpotCoords.push_back(provider->posImage);
if (refSpotCoords.size() == 2) {
// User has selected 2 reference gray spots. Calculating new exponents
// from channel values and updating parameters.
std::array<float, 3> newExps;
if (fnp->getFilmNegativeExponents(refSpotCoords[0], refSpotCoords[1], newExps)) {
disableListener();
// Leaving green exponent unchanged, setting red and blue exponents based on
// the ratios between newly calculated exponents.
redRatio->setValue(newExps[0] / newExps[1]);
blueRatio->setValue(newExps[2] / newExps[1]);
enableListener();
if (listener && getEnabled()) {
listener->panelChanged(
evFilmNegativeExponents,
Glib::ustring::compose(
"Ref=%1 ; R=%2 ; B=%3",
greenExp->getValue(),
redRatio->getValue(),
blueRatio->getValue()
)
);
}
}
switchOffEditMode();
}
}
return true;
}
bool FilmNegative::button1Released()
{
EditSubscriber::action = EditSubscriber::Action::NONE;
return true;
}
void FilmNegative::switchOffEditMode()
{
refSpotCoords.clear();
unsubscribe();
spotbutton->set_active(false);
}
void FilmNegative::editToggled()
{
if (spotbutton->get_active()) {
subscribe();
int w, h;
getEditProvider()->getImageSize(w, h);
// Stick a dummy rectangle over the whole image in mouseOverGeometry.
// This is to make sure the getCursor() call is fired everywhere.
Rectangle* const imgRect = static_cast<Rectangle*>(mouseOverGeometry.at(0));
imgRect->setXYWH(0, 0, w, h);
} else {
refSpotCoords.clear();
unsubscribe();
}
}

89
rtgui/filmnegative.h Normal file
View File

@ -0,0 +1,89 @@
/*
* This file is part of RawTherapee.
*
* Copyright (c) 2019 Alberto Romei <aldrop8@gmail.com>
*
* RawTherapee 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 3 of the License, or
* (at your option) any later version.
*
* RawTherapee 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 RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <array>
#include <gtkmm.h>
#include "adjuster.h"
#include "editcallbacks.h"
#include "guiutils.h"
#include "toolpanel.h"
#include "wbprovider.h"
#include "../rtengine/noncopyable.h"
class FilmNegProvider
{
public:
virtual ~FilmNegProvider() = default;
virtual bool getFilmNegativeExponents(rtengine::Coord spotA, rtengine::Coord spotB, std::array<float, 3>& newExps) = 0;
};
class FilmNegative :
public rtengine::NonCopyable,
public ToolParamBlock,
public AdjusterListener,
public FoldableToolPanel,
public EditSubscriber
{
public:
FilmNegative();
~FilmNegative() override;
void read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited = nullptr) override;
void write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited = nullptr) override;
void setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited = nullptr) override;
void setBatchMode(bool batchMode) override;
void adjusterChanged(Adjuster* a, double newval) override;
void adjusterAutoToggled(Adjuster* a, bool newval) override;
void enabledChanged() override;
void setFilmNegProvider(FilmNegProvider* provider);
void setEditProvider(EditDataProvider* provider) override;
// EditSubscriber interface
CursorShape getCursor(int objectID) const override;
bool mouseOver(int modifierKey) override;
bool button1Pressed(int modifierKey) override;
bool button1Released() override;
void switchOffEditMode() override;
private:
void editToggled();
const rtengine::ProcEvent evFilmNegativeExponents;
const rtengine::ProcEvent evFilmNegativeEnabled;
std::vector<rtengine::Coord> refSpotCoords;
FilmNegProvider* fnp;
Adjuster* const greenExp;
Adjuster* const redRatio;
Adjuster* const blueRatio;
Gtk::Grid* const spotgrid;
Gtk::ToggleButton* const spotbutton;
sigc::connection spotConn;
};

35
rtgui/paramsedited.cc
View File

@ -580,6 +580,10 @@ void ParamsEdited::set(bool v)
dehaze.showDepthMap = v;
dehaze.depth = v;
metadata.mode = v;
filmNegative.enabled = v;
filmNegative.redRatio = v;
filmNegative.greenExp = v;
filmNegative.blueRatio = v;
exif = v;
iptc = v;
@ -1142,6 +1146,10 @@ void ParamsEdited::initFrom(const std::vector<rtengine::procparams::ProcParams>&
dehaze.showDepthMap = dehaze.showDepthMap && p.dehaze.showDepthMap == other.dehaze.showDepthMap;
dehaze.depth = dehaze.depth && p.dehaze.depth == other.dehaze.depth;
metadata.mode = metadata.mode && p.metadata.mode == other.metadata.mode;
filmNegative.enabled = filmNegative.enabled && p.filmNegative.enabled == other.filmNegative.enabled;
filmNegative.redRatio = filmNegative.redRatio && p.filmNegative.redRatio == other.filmNegative.redRatio;
filmNegative.greenExp = filmNegative.greenExp && p.filmNegative.greenExp == other.filmNegative.greenExp;
filmNegative.blueRatio = filmNegative.blueRatio && p.filmNegative.blueRatio == other.filmNegative.blueRatio;
// How the hell can we handle that???
// exif = exif && p.exif==other.exif
@ -3175,18 +3183,36 @@ void ParamsEdited::combine(rtengine::procparams::ProcParams& toEdit, const rteng
toEdit.metadata.mode = mods.metadata.mode;
}
if (filmNegative.enabled) {
toEdit.filmNegative.enabled = mods.filmNegative.enabled;
}
if (filmNegative.redRatio) {
toEdit.filmNegative.redRatio = mods.filmNegative.redRatio;
}
if (filmNegative.greenExp) {
toEdit.filmNegative.greenExp = mods.filmNegative.greenExp;
}
if (filmNegative.blueRatio) {
toEdit.filmNegative.blueRatio = mods.filmNegative.blueRatio;
}
// Exif changes are added to the existing ones
if (exif)
if (exif) {
for (procparams::ExifPairs::const_iterator i = mods.exif.begin(); i != mods.exif.end(); ++i) {
toEdit.exif[i->first] = i->second;
}
}
// IPTC changes are added to the existing ones
if (iptc)
if (iptc) {
for (procparams::IPTCPairs::const_iterator i = mods.iptc.begin(); i != mods.iptc.end(); ++i) {
toEdit.iptc[i->first] = i->second;
}
}
}
bool RAWParamsEdited::BayerSensor::isUnchanged() const
{
@ -3216,3 +3242,8 @@ bool RetinexParamsEdited::isUnchanged() const
{
return enabled && retinexcolorspace && gammaretinex && gam && slope;
}
bool FilmNegativeParamsEdited::isUnchanged() const
{
return enabled && redRatio && greenExp && blueRatio;
}

10
rtgui/paramsedited.h
View File

@ -666,6 +666,15 @@ struct MetaDataParamsEdited {
bool mode;
};
struct FilmNegativeParamsEdited {
bool enabled;
bool redRatio;
bool greenExp;
bool blueRatio;
bool isUnchanged() const;
};
struct ParamsEdited {
GeneralParamsEdited general;
ToneCurveParamsEdited toneCurve;
@ -710,6 +719,7 @@ struct ParamsEdited {
SoftLightParamsEdited softlight;
DehazeParamsEdited dehaze;
MetaDataParamsEdited metadata;
FilmNegativeParamsEdited filmNegative;
bool exif;
bool iptc;

16
rtgui/partialpastedlg.cc
View File

@ -134,6 +134,8 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren
raw_ca_autocorrect = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_AUTO")));
raw_caredblue = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_CAREDBLUE")));
raw_ca_avoid_colourshift = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_AVOIDCOLORSHIFT")));
//---
filmNegative = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_FILMNEGATIVE")) );
Gtk::VBox* vboxes[8];
Gtk::HSeparator* hseps[8];
@ -249,6 +251,8 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren
vboxes[7]->pack_start (*raw_ca_autocorrect, Gtk::PACK_SHRINK, 2);
vboxes[7]->pack_start (*raw_caredblue, Gtk::PACK_SHRINK, 2);
vboxes[7]->pack_start (*raw_ca_avoid_colourshift, Gtk::PACK_SHRINK, 2);
vboxes[7]->pack_start (*Gtk::manage (new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 0);
vboxes[7]->pack_start (*filmNegative, Gtk::PACK_SHRINK, 2);
Gtk::VBox* vbCol1 = Gtk::manage (new Gtk::VBox ());
Gtk::VBox* vbCol2 = Gtk::manage (new Gtk::VBox ());
@ -396,6 +400,8 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren
raw_ca_autocorrectConn = raw_ca_autocorrect->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true));
raw_caredblueConn = raw_caredblue->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true));
raw_ca_avoid_colourshiftconn = raw_ca_avoid_colourshift->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true));
//---
filmNegativeConn = filmNegative->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true));
add_button (M("GENERAL_OK"), Gtk::RESPONSE_OK);
add_button (M("GENERAL_CANCEL"), Gtk::RESPONSE_CANCEL);
@ -467,6 +473,7 @@ void PartialPasteDlg::rawToggled ()
ConnectionBlocker raw_ca_autocorrectBlocker(raw_ca_autocorrectConn);
ConnectionBlocker raw_caredblueBlocker(raw_caredblueConn);
ConnectionBlocker raw_ca_avoid_colourshiftBlocker(raw_ca_avoid_colourshiftconn);
ConnectionBlocker filmNegativeBlocker(filmNegativeConn);
raw->set_inconsistent (false);
@ -495,6 +502,7 @@ void PartialPasteDlg::rawToggled ()
raw_ca_autocorrect->set_active (raw->get_active ());
raw_caredblue->set_active (raw->get_active ());
raw_ca_avoid_colourshift->set_active (raw->get_active ());
filmNegative->set_active (raw->get_active());
}
void PartialPasteDlg::basicToggled ()
@ -966,6 +974,13 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param
filterPE.raw.ff_AutoClipControl = falsePE.raw.ff_AutoClipControl;
}
if (!filmNegative->get_active ()) {
filterPE.filmNegative.enabled = falsePE.filmNegative.enabled;
filterPE.filmNegative.redRatio = falsePE.filmNegative.redRatio;
filterPE.filmNegative.greenExp = falsePE.filmNegative.greenExp;
filterPE.filmNegative.blueRatio = falsePE.filmNegative.blueRatio;
}
if (dstPE) {
*dstPE = filterPE;
}
@ -973,4 +988,3 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param
// Apply the filter!
filterPE.combine(*dstPP, *srcPP, true);
}

3
rtgui/partialpastedlg.h
View File

@ -130,6 +130,8 @@ public:
Gtk::CheckButton* ff_BlurType;
Gtk::CheckButton* ff_ClipControl;
Gtk::CheckButton* filmNegative;
sigc::connection everythingConn, basicConn, detailConn, colorConn, lensConn, compositionConn, metaConn, rawConn, advancedConn;
sigc::connection wbConn, exposureConn, localcontrastConn, shConn, pcvignetteConn, gradientConn, labcurveConn, colorappearanceConn;
@ -140,6 +142,7 @@ public:
sigc::connection metadataConn, exifchConn, iptcConn, icmConn;
sigc::connection df_fileConn, df_AutoSelectConn, ff_fileConn, ff_AutoSelectConn, ff_BlurRadiusConn, ff_BlurTypeConn, ff_ClipControlConn;
sigc::connection raw_caredblueConn, raw_ca_autocorrectConn, raw_ca_avoid_colourshiftconn, raw_hotpix_filtConn, raw_deadpix_filtConn, raw_pdaf_lines_filterConn, raw_linenoiseConn, raw_greenthreshConn, raw_ccStepsConn, raw_methodConn, raw_borderConn, raw_imagenumConn, raw_dcb_iterationsConn, raw_lmmse_iterationsConn, raw_pixelshiftConn, raw_dcb_enhanceConn, raw_exposConn, raw_blackConn;
sigc::connection filmNegativeConn;
public:
PartialPasteDlg (const Glib::ustring &title, Gtk::Window* parent);

10
rtgui/thumbnail.cc
View File

@ -813,6 +813,7 @@ int Thumbnail::infoFromImage (const Glib::ustring& fname, std::unique_ptr<rtengi
cfs.lens = idata->getLens();
cfs.camMake = idata->getMake();
cfs.camModel = idata->getModel();
cfs.rating = idata->getRating();
if (idata->getOrientation() == "Rotate 90 CW") {
deg = 90;
@ -1005,15 +1006,22 @@ void Thumbnail::setFileName (const Glib::ustring &fn)
int Thumbnail::getRank () const
{
// prefer the user-set rank over the embedded Rating
// pparams->rank == -1 means that there is no saved rank yet, so we should
// next look for the embedded Rating metadata.
if (pparams->rank != -1) {
return pparams->rank;
} else {
return cfs.rating;
}
}
void Thumbnail::setRank (int rank)
{
if (pparams->rank != rank) {
pparams->rank = rank;
pparamsValid = true;
}
pparamsValid = true;
}
int Thumbnail::getColorLabel () const

15
rtgui/toolpanelcoord.cc
View File

@ -92,6 +92,7 @@ ToolPanelCoordinator::ToolPanelCoordinator (bool batch) : ipc (nullptr), favorit
bayerrawexposure = Gtk::manage (new BayerRAWExposure ());
xtransrawexposure = Gtk::manage (new XTransRAWExposure ());
fattal = Gtk::manage (new FattalToneMapping ());
filmNegative = Gtk::manage (new FilmNegative ());
// So Demosaic, Line noise filter, Green Equilibration, Ca-Correction (garder le nom de section identique!) and Black-Level will be moved in a "Bayer sensor" tool,
// and a separate Demosaic and Black Level tool will be created in an "X-Trans sensor" tool
@ -154,6 +155,7 @@ ToolPanelCoordinator::ToolPanelCoordinator (bool batch) : ipc (nullptr), favorit
addfavoritePanel (rawPanel, preprocess);
addfavoritePanel (rawPanel, darkframe);
addfavoritePanel (rawPanel, flatfield);
addfavoritePanel (rawPanel, filmNegative);
int favoriteCount = 0;
for(auto it = favorites.begin(); it != favorites.end(); ++it) {
@ -255,6 +257,7 @@ ToolPanelCoordinator::ToolPanelCoordinator (bool batch) : ipc (nullptr), favorit
distortion->setLensGeomListener (this);
crop->setCropPanelListener (this);
icm->setICMPanelListener (this);
filmNegative->setFilmNegProvider (this);
toolBar = new ToolBar ();
toolBar->setToolBarListener (this);
@ -305,6 +308,7 @@ void ToolPanelCoordinator::imageTypeChanged (bool isRaw, bool isBayer, bool isXt
sensorbayer->FoldableToolPanel::show();
preprocess->FoldableToolPanel::show();
flatfield->FoldableToolPanel::show();
filmNegative->FoldableToolPanel::show();
retinex->FoldableToolPanel::setGrayedOut(false);
return false;
@ -320,6 +324,7 @@ void ToolPanelCoordinator::imageTypeChanged (bool isRaw, bool isBayer, bool isXt
sensorbayer->FoldableToolPanel::hide();
preprocess->FoldableToolPanel::show();
flatfield->FoldableToolPanel::show();
filmNegative->FoldableToolPanel::show();
retinex->FoldableToolPanel::setGrayedOut(false);
return false;
@ -335,6 +340,7 @@ void ToolPanelCoordinator::imageTypeChanged (bool isRaw, bool isBayer, bool isXt
sensorxtrans->FoldableToolPanel::hide();
preprocess->FoldableToolPanel::hide();
flatfield->FoldableToolPanel::show();
filmNegative->FoldableToolPanel::hide();
retinex->FoldableToolPanel::setGrayedOut(false);
return false;
@ -349,6 +355,7 @@ void ToolPanelCoordinator::imageTypeChanged (bool isRaw, bool isBayer, bool isXt
sensorxtrans->FoldableToolPanel::hide();
preprocess->FoldableToolPanel::hide();
flatfield->FoldableToolPanel::hide();
filmNegative->FoldableToolPanel::hide();
retinex->FoldableToolPanel::setGrayedOut(false);
return false;
@ -360,6 +367,7 @@ void ToolPanelCoordinator::imageTypeChanged (bool isRaw, bool isBayer, bool isXt
[this]() -> bool
{
rawPanelSW->set_sensitive(false);
filmNegative->FoldableToolPanel::hide();
retinex->FoldableToolPanel::setGrayedOut(true);
return false;
@ -476,7 +484,7 @@ void ToolPanelCoordinator::profileChange(
lParams[1] = *mergedParams;
pe.initFrom (lParams);
filterRawRefresh = pe.raw.isUnchanged() && pe.lensProf.isUnchanged() && pe.retinex.isUnchanged();
filterRawRefresh = pe.raw.isUnchanged() && pe.lensProf.isUnchanged() && pe.retinex.isUnchanged() && pe.filmNegative.isUnchanged();
}
*params = *mergedParams;
@ -1014,3 +1022,8 @@ void ToolPanelCoordinator::setEditProvider (EditDataProvider *provider)
toolPanels.at (i)->setEditProvider (provider);
}
}
bool ToolPanelCoordinator::getFilmNegativeExponents(rtengine::Coord spotA, rtengine::Coord spotB, std::array<float, 3>& newExps)
{
return ipc && ipc->getFilmNegativeExponents(spotA.x, spotA.y, spotB.x, spotB.y, newExps);
}

8
rtgui/toolpanelcoord.h
View File

@ -82,6 +82,7 @@
#include "softlight.h"
#include "dehaze.h"
#include "guiutils.h"
#include "filmnegative.h"
class ImageEditorCoordinator;
@ -97,7 +98,8 @@ class ToolPanelCoordinator :
public CropPanelListener,
public ICMPanelListener,
public ImageAreaToolListener,
public rtengine::ImageTypeListener
public rtengine::ImageTypeListener,
public FilmNegProvider
{
protected:
WhiteBalance* whitebalance;
@ -152,6 +154,7 @@ protected:
XTransRAWExposure* xtransrawexposure;
FattalToneMapping *fattal;
MetaDataPanel* metadata;
FilmNegative* filmNegative;
std::vector<PParamsChangeListener*> paramcListeners;
@ -288,6 +291,9 @@ public:
rtengine::RawImage* getFF() override;
Glib::ustring GetCurrentImageFilePath() override;
// FilmNegProvider interface
bool getFilmNegativeExponents(rtengine::Coord spotA, rtengine::Coord spotB, std::array<float, 3>& newExps) override;
// rotatelistener interface
void straightenRequested () override;
void autoCropRequested () override;