diff --git a/rtdata/images/Dark/actions/spGamutCheck.png b/rtdata/images/Dark/actions/spGamutCheck.png
new file mode 100644
index 000000000..ab812272a
Binary files /dev/null and b/rtdata/images/Dark/actions/spGamutCheck.png differ
diff --git a/rtdata/images/Dark/actions/unchanged-18.png b/rtdata/images/Dark/actions/unchanged-18.png
new file mode 100644
index 000000000..9d08dda26
Binary files /dev/null and b/rtdata/images/Dark/actions/unchanged-18.png differ
diff --git a/rtdata/images/Dark/actions/unchanged-22.png b/rtdata/images/Dark/actions/unchanged-22.png
new file mode 100644
index 000000000..db03d456a
Binary files /dev/null and b/rtdata/images/Dark/actions/unchanged-22.png differ
diff --git a/rtdata/images/Light/actions/spGamutCheck.png b/rtdata/images/Light/actions/spGamutCheck.png
new file mode 100644
index 000000000..b1ae3e423
Binary files /dev/null and b/rtdata/images/Light/actions/spGamutCheck.png differ
diff --git a/rtdata/images/Light/actions/unchanged-18.png b/rtdata/images/Light/actions/unchanged-18.png
new file mode 100644
index 000000000..9d08dda26
Binary files /dev/null and b/rtdata/images/Light/actions/unchanged-18.png differ
diff --git a/rtdata/images/Light/actions/unchanged-22.png b/rtdata/images/Light/actions/unchanged-22.png
new file mode 100644
index 000000000..db03d456a
Binary files /dev/null and b/rtdata/images/Light/actions/unchanged-22.png differ
diff --git a/rtdata/languages/Francais b/rtdata/languages/Francais
index 2dc71124e..deca1cdd2 100644
--- a/rtdata/languages/Francais
+++ b/rtdata/languages/Francais
@@ -632,6 +632,7 @@ HISTORY_MSG_403;O - NB - Sensibilité des bords
HISTORY_MSG_404;O - NB - Base amplification
HISTORY_MSG_405;O - Débruitage - Niveau 4
HISTORY_MSG_406;O - NB - Pixels voisins
+HISTORY_MSG_443;Compensation du Point Noir de Sortie
HISTORY_NEWSNAPSHOT;Ajouter
HISTORY_NEWSNAPSHOT_TOOLTIP;Raccourci: Alt-s
HISTORY_SNAPSHOT;Capture
@@ -953,6 +954,7 @@ PREFERENCES_MENUGROUPPROFILEOPERATIONS;Opérations sur les profils
PREFERENCES_MENUGROUPRANK;Classement
PREFERENCES_MENUOPTIONS;Options du menu
PREFERENCES_METADATA;Metadonnées
+PREFERENCES_MONBPC;Compensation du Point Noir pour la transformation L*a*b*->Moniteur
PREFERENCES_MIN;Mini (100x115)
PREFERENCES_MULTITAB;Éditeurs multiple
PREFERENCES_MULTITABDUALMON;Éditeurs multiple, si possible sur un second moniteur
@@ -1083,6 +1085,8 @@ SAVEDLG_SUBSAMP_3;Meilleure qualité
SAVEDLG_TIFFUNCOMPRESSED;TIFF non compressé
SAVEDLG_WARNFILENAME;Le fichier sera nommé
SHCSELECTOR_TOOLTIP;Cliquez le bouton droit de la souris\npour réinitialiser la position de ces 3 curseurs
+SOFTPROOF_GAMUTCHECK_TOOLTIP;Si activé, indique en gris les pixels dont la couleurs est en dehors du gamut du profile de sortie
+SOFTPROOF_TOOLTIP;Épreuvage écran\nSi activé, simule le rendu généré par le profiles de sortie de l'outil ICM. Particulièrement utile pour simuler le rendu en sortie d'imprimante.
THRESHOLDSELECTOR_B;Bas
THRESHOLDSELECTOR_BL;Bas-gauche
THRESHOLDSELECTOR_BR;Bas-droite
@@ -1456,6 +1460,8 @@ TP_ICM_APPLYLOOKTABLE;Table de recherche
TP_ICM_APPLYLOOKTABLE_TOOLTIP;Utilise la table de recherche (LUT) contenu dans le profil DCP. Ce réglage n'est possible que si le profil DCP sélectionné en contient une.
TP_ICM_BLENDCMSMATRIX;Mélange des hautes lumières\ndu profil ICC avec la matrice
TP_ICM_BLENDCMSMATRIX_TOOLTIP;Activer la récupération des zones brûlées lorsque les profils ICC basés sur la LUT sont utilisés
+TP_ICM_BPC;Compensation du Point Noir
+TP_ICM_BPC_TOOLTIP;Activez ceci pour faire correspondre le canal Luminosité à l'espace couleur de sortie avec un Point Blanc fixe
TP_ICM_DCPILLUMINANT;Illuminant
TP_ICM_DCPILLUMINANT_INTERPOLATED;Interpolé
TP_ICM_DCPILLUMINANT_TOOLTIP;Sélectionne quel illuminant DCP inclus utiliser. La valeur par défaut est "Interpolé", qui est un mix entre les 2 profils inclus basé sur la Balance des Blancs choisie. Ce paramètre n'est actif que si un fichier DCP Bi-Illuminant avec support de l'interpolation est choisi.
diff --git a/rtdata/languages/default b/rtdata/languages/default
index ddf2864c5..605c2ea63 100644
--- a/rtdata/languages/default
+++ b/rtdata/languages/default
@@ -674,6 +674,7 @@ HISTORY_MSG_439;Retinex - Process
HISTORY_MSG_440;CbDL - Method
HISTORY_MSG_441;Retinex - Gain transmission
HISTORY_MSG_442;Retinex - Scale
+HISTORY_MSG_443;Output Black Point Compensation
HISTORY_NEWSNAPSHOT;Add
HISTORY_NEWSNAPSHOT_TOOLTIP;Shortcut: Alt-s
HISTORY_SNAPSHOT;Snapshot
@@ -1000,6 +1001,7 @@ PREFERENCES_MENUGROUPRANK;Group "Rank"
PREFERENCES_MENUOPTIONS;Context Menu Options
PREFERENCES_METADATA;Metadata
PREFERENCES_MIN;Mini (100x115)
+PREFERENCES_MONBPC;Black Point Compensation for the L*a*b*->Monitor transform
PREFERENCES_MONINTENT;Default monitor intent
PREFERENCES_MONPROFILE;Default monitor profile
PREFERENCES_MULTITAB;Multiple Editor Tabs Mode
@@ -1136,6 +1138,8 @@ SAVEDLG_SUBSAMP_TOOLTIP;Best compression:\nJ:a:b 4:2:0\nh/v 2/2\nChroma halved h
SAVEDLG_TIFFUNCOMPRESSED;Uncompressed TIFF
SAVEDLG_WARNFILENAME;File will be named
SHCSELECTOR_TOOLTIP;Click right mouse button to reset the position of those 3 sliders.
+SOFTPROOF_GAMUTCHECK_TOOLTIP;If active, indicates in grey the pixels which have out of gamut colors from the output profile.
+SOFTPROOF_TOOLTIP;Soft-proofing\nIf active, let you simulate de rendering generated by the output profile of the ICM tool. Most useful for simulating printing outputs.
THRESHOLDSELECTOR_B;Bottom
THRESHOLDSELECTOR_BL;Bottom-left
THRESHOLDSELECTOR_BR;Bottom-right
@@ -1523,6 +1527,8 @@ TP_ICM_APPLYLOOKTABLE;Look table
TP_ICM_APPLYLOOKTABLE_TOOLTIP;Employ the embedded DCP look table. The setting is only enabled if the selected DCP has one.
TP_ICM_BLENDCMSMATRIX;Blend ICC highlights with matrix
TP_ICM_BLENDCMSMATRIX_TOOLTIP;Enable to recover clipped highlights when using LUT-based ICC profiles.
+TP_ICM_BPC;Black Point Compensation
+TP_ICM_BPC_TOOLTIP;Enable this to fit the Luminosity channel to the output color space with a fix White Point
TP_ICM_DCPILLUMINANT;Illuminant
TP_ICM_DCPILLUMINANT_INTERPOLATED;Interpolated
TP_ICM_DCPILLUMINANT_TOOLTIP;Select which embedded DCP illuminant to employ. Default is "interpolated" which is a mix between the two based on white balance. The setting is only enabled if a Dual-Illuminant DCP with interpolation support is selected.
diff --git a/rtengine/CA_correct_RT.cc b/rtengine/CA_correct_RT.cc
index 64bb19113..7c28801ae 100644
--- a/rtengine/CA_correct_RT.cc
+++ b/rtengine/CA_correct_RT.cc
@@ -156,11 +156,9 @@ void RawImageSource::CA_correct_RT(const double cared, const double cablue, cons
const int vblsz = ceil((float)(height + border2) / (ts - border2) + 2 + vz1);
const int hblsz = ceil((float)(width + border2) / (ts - border2) + 2 + hz1);
- char *buffer1 = (char *) calloc(vblsz * hblsz * (2 * 2 + 1), sizeof(float));
-
//block CA shift values and weight assigned to block
- float *blockwt = (float*)buffer1;
- float (*blockshifts)[2][2] = (float (*)[2][2])(buffer1 + (vblsz * hblsz * sizeof(float)));
+ float* const blockwt = static_cast(calloc(vblsz * hblsz * (2 * 2 + 1), sizeof(float)));
+ float (*blockshifts)[2][2] = (float (*)[2][2])(blockwt + vblsz * hblsz);
double fitparams[2][2][16];
@@ -1013,7 +1011,7 @@ void RawImageSource::CA_correct_RT(const double cared, const double cablue, cons
}
free(Gtmp);
- free(buffer1);
+ free(blockwt);
free(RawDataTmp);
if(plistener) {
diff --git a/rtengine/EdgePreservingDecomposition.cc b/rtengine/EdgePreservingDecomposition.cc
index 21abe733c..c80d5e092 100644
--- a/rtengine/EdgePreservingDecomposition.cc
+++ b/rtengine/EdgePreservingDecomposition.cc
@@ -17,20 +17,20 @@ calculates A x where x is some vector. Stops when rms residual < RMSResidual or
Stops at n iterates if MaximumIterates = 0 since that many iterates gives exact solution. Applicable to symmetric positive
definite problems only, which is what unconstrained smooth optimization pretty much always is.
Parameter pass can be passed through, containing whatever info you like it to contain (matrix info?).
-Takes less memory with OkToModify_b = true, and Preconditioner = NULL. */
+Takes less memory with OkToModify_b = true, and Preconditioner = nullptr. */
float *SparseConjugateGradient(void Ax(float *Product, float *x, void *Pass), float *b, int n, bool OkToModify_b,
float *x, float RMSResidual, void *Pass, int MaximumIterates, void Preconditioner(float *Product, float *x, void *Pass))
{
int iterate, i;
- char* buffer = (char*)malloc(2 * n * sizeof(float) + 128);
- float *r = (float*)(buffer + 64);
+ float* buffer = (float*)malloc(2 * n * sizeof(float) + 128);
+ float *r = (buffer + 16);
//Start r and x.
if(x == nullptr) {
x = new float[n];
- memset(x, 0, sizeof(float)*n); //Zero initial guess if x == NULL.
+ memset(x, 0, sizeof(float)*n); //Zero initial guess if x == nullptr.
memcpy(r, b, sizeof(float)*n);
} else {
Ax(r, x, Pass);
@@ -61,7 +61,7 @@ float *SparseConjugateGradient(void Ax(float *Product, float *x, void *Pass), fl
}
//Search direction d.
- float *d = (float*)(buffer + n * sizeof(float) + 128);
+ float *d = (buffer + n + 32);
memcpy(d, s, sizeof(float)*n);
@@ -127,15 +127,13 @@ float *SparseConjugateGradient(void Ax(float *Product, float *x, void *Pass), fl
#endif
{
float c = 0.0f;
- float t;
- float temp;
#ifdef _OPENMP
#pragma omp for reduction(+:rs) // Summation with error correction
#endif
for(int ii = 0; ii < n; ii++) {
- temp = r[ii] * s[ii];
- t = rs + temp;
+ float temp = r[ii] * s[ii];
+ float t = rs + temp;
if( fabsf(rs) >= fabsf(temp) ) {
c += ((rs - t) + temp);
@@ -183,7 +181,7 @@ float *SparseConjugateGradient(void Ax(float *Product, float *x, void *Pass), fl
return x;
}
-MultiDiagonalSymmetricMatrix::MultiDiagonalSymmetricMatrix(int Dimension, int NumberOfDiagonalsInLowerTriangle)
+MultiDiagonalSymmetricMatrix::MultiDiagonalSymmetricMatrix(int Dimension, int NumberOfDiagonalsInLowerTriangle) : buffer(nullptr), DiagBuffer(nullptr)
{
n = Dimension;
m = NumberOfDiagonalsInLowerTriangle;
@@ -223,7 +221,7 @@ bool MultiDiagonalSymmetricMatrix::CreateDiagonal(int index, int StartRow)
{
DiagBuffer = nullptr;
} else {
- DiagBuffer = (char*)( ( uintptr_t(buffer) + uintptr_t(63)) / 64 * 64);
+ DiagBuffer = (float*)( ( uintptr_t(buffer) + uintptr_t(63)) / 64 * 64);
}
}
@@ -239,7 +237,7 @@ bool MultiDiagonalSymmetricMatrix::CreateDiagonal(int index, int StartRow)
}
if(DiagBuffer != nullptr) {
- Diagonals[index] = (float*)(DiagBuffer + (index * (n + padding) * sizeof(float)) + ((index + 16) * 64));
+ Diagonals[index] = (DiagBuffer + (index * (n + padding)) + ((index + 16) * 16));
} else {
Diagonals[index] = new float[DiagonalLength(StartRow)];
@@ -305,9 +303,9 @@ SSEFUNCTION void MultiDiagonalSymmetricMatrix::VectorProduct(float* RESTRICT Pro
const int chunkSize = (lm - srm) / (omp_get_num_procs() * 32);
#else
const int chunkSize = (lm - srm) / (omp_get_num_procs() * 8);
-#endif
#endif
#pragma omp parallel
+#endif
{
// First fill the big part in the middle
// This can be done without intermediate stores to memory and it can be parallelized too
@@ -443,8 +441,8 @@ bool MultiDiagonalSymmetricMatrix::CreateIncompleteCholeskyFactorization(int Max
}
//It's all initialized? Uhkay. Do the actual math then.
- int sss, ss, s;
- int k, MaxStartRow = StartRows[m - 1]; //Handy number.
+ int sss, ss;
+ int MaxStartRow = StartRows[m - 1]; //Handy number.
float **l = ic->Diagonals;
float *d = ic->Diagonals[0]; //Describes D in LDLt.
int icm = ic->m;
@@ -506,8 +504,8 @@ bool MultiDiagonalSymmetricMatrix::CreateIncompleteCholeskyFactorization(int Max
//This is a loop over k from 1 to j, inclusive. We'll cover that by looping over the index of the diagonals (s), and get k from it.
//The first diagonal is d (k = 0), so skip that and have s start at 1. Cover all available s but stop if k exceeds j.
- s = 1;
- k = icStartRows[s];
+ int s = 1;
+ int k = icStartRows[s];
while(k <= j) {
d[j] -= l[s][j - k] * l[s][j - k] * d[j - k];
@@ -554,7 +552,7 @@ bool MultiDiagonalSymmetricMatrix::CreateIncompleteCholeskyFactorization(int Max
return true;
}
-void MultiDiagonalSymmetricMatrix::KillIncompleteCholeskyFactorization()
+void MultiDiagonalSymmetricMatrix::KillIncompleteCholeskyFactorization(void)
{
delete IncompleteCholeskyFactorization;
}
@@ -713,9 +711,7 @@ SSEFUNCTION float *EdgePreservingDecomposition::CreateBlur(float *Source, float
a = Blur, g = Source;
}
- int i;
int w1 = w - 1, h1 = h - 1;
-// float eps = 0.02f;
const float sqreps = 0.0004f; // removed eps*eps from inner loop
diff --git a/rtengine/EdgePreservingDecomposition.h b/rtengine/EdgePreservingDecomposition.h
index 944e0ec7f..bf567f103 100644
--- a/rtengine/EdgePreservingDecomposition.h
+++ b/rtengine/EdgePreservingDecomposition.h
@@ -93,7 +93,7 @@ public:
*/
float **Diagonals;
char *buffer;
- char *DiagBuffer;
+ float *DiagBuffer;
int *StartRows;
bool CreateDiagonal(int index, int StartRow);
int n, m; //The matrix is n x n, with m diagonals on the lower triangle. Don't change these. They should be private but aren't for convenience.
diff --git a/rtengine/FTblockDN.cc b/rtengine/FTblockDN.cc
index c74e49218..6bb0c4c3c 100644
--- a/rtengine/FTblockDN.cc
+++ b/rtengine/FTblockDN.cc
@@ -37,6 +37,7 @@
#include "opthelper.h"
#include "cplx_wavelet_dec.h"
#include "median.h"
+#include "iccstore.h"
#ifdef _OPENMP
#include
#endif
diff --git a/rtengine/LUT.h b/rtengine/LUT.h
index 2d3d91ed5..d83a431ca 100644
--- a/rtengine/LUT.h
+++ b/rtengine/LUT.h
@@ -536,6 +536,8 @@ public:
size = 0;
upperBound = 0;
maxs = 0;
+ maxsf = 0.f;
+ clip = 0;
}
// create an identity LUT (LUT(x) = x) or a scaled identity LUT (LUT(x) = x / divisor)
diff --git a/rtengine/array2D.h b/rtengine/array2D.h
index d9cfb23e2..2d38d2e15 100644
--- a/rtengine/array2D.h
+++ b/rtengine/array2D.h
@@ -74,7 +74,8 @@ class array2D :
{
private:
- int x, y, owner, flags;
+ int x, y, owner;
+ unsigned int flags;
T ** ptr;
T * data;
bool lock; // useful lock to ensure data is not changed anymore.
@@ -82,19 +83,19 @@ private:
{
if ((ptr) && ((h > y) || (4 * h < y))) {
delete[] ptr;
- ptr = nullptr;
+ ptr = NULL;
}
if ((data) && (((h * w) > (x * y)) || ((h * w) < ((x * y) / 4)))) {
delete[] data;
- data = nullptr;
+ data = NULL;
}
- if (ptr == nullptr) {
+ if (ptr == NULL) {
ptr = new T*[h];
}
- if (data == nullptr) {
+ if (data == NULL) {
data = new T[h * w + offset];
}
@@ -112,7 +113,7 @@ public:
// use as empty declaration, resize before use!
// very useful as a member object
array2D() :
- x(0), y(0), owner(0), ptr(nullptr), data(nullptr), lock(0)
+ x(0), y(0), owner(0), ptr(NULL), data(NULL), lock(0), flags(0)
{
//printf("got empty array2D init\n");
}
@@ -150,7 +151,7 @@ public:
if (owner) {
data = new T[h * w];
} else {
- data = nullptr;
+ data = NULL;
}
x = w;
@@ -285,6 +286,8 @@ public:
if (this != &rhs)
{
+ flags = rhs.flags;
+ lock = rhs.lock;
if (!owner) { // we can only copy same size data
if ((x != rhs.x) || (y != rhs.y)) {
printf(" assignment error in array2D\n");
diff --git a/rtengine/camconst.cc b/rtengine/camconst.cc
index 91d4e6c8b..5a155e051 100644
--- a/rtengine/camconst.cc
+++ b/rtengine/camconst.cc
@@ -558,10 +558,20 @@ CameraConstantsStore::parse_camera_constants_file(Glib::ustring filename_)
while ((ret = fread(&buf[datasize], 1, bufsize - datasize, stream)) != 0) {
datasize += ret;
- if (datasize == bufsize) {
+ if (datasize == bufsize) { // we need more memory
bufsize += increment;
- buf = (char *)realloc(buf, bufsize);
- increment *= 2;
+ void *temp = realloc(buf, bufsize); // try to realloc buffer with new size
+ if(!temp) { // realloc failed
+ temp = malloc(bufsize); // alloc now buffer
+ if (temp) { // alloc worked
+ memcpy(temp, buf, bufsize - increment); // copy old buffer content to new buffer
+ free(buf); // free old buffer
+ } else { // alloc didn't work, break
+ break;
+ }
+ }
+ buf = (char *)temp; // assign new buffer
+ increment *= 2; // double increment
}
}
diff --git a/rtengine/cfa_linedn_RT.cc b/rtengine/cfa_linedn_RT.cc
index 78da79bb5..21fcfb1e5 100644
--- a/rtengine/cfa_linedn_RT.cc
+++ b/rtengine/cfa_linedn_RT.cc
@@ -68,11 +68,10 @@ void RawImageSource::CLASS cfa_linedn(float noise)
{
// allocate memory and assure the arrays don't have same 64 byte boundary to avoid L1 conflict misses
- char *buffer = (char*)malloc(4 * TS * TS * sizeof(float) + 3 * 64);
- float *cfain = (float*)(buffer);
- float *cfablur = (float*)(buffer + (TS * TS * sizeof(float)) + 1 * 64);
- float *cfadiff = (float*)(buffer + (2 * TS * TS * sizeof(float)) + 2 * 64);
- float *cfadn = (float*)(buffer + (3 * TS * TS * sizeof(float)) + 3 * 64);
+ float *cfain = (float*)malloc(4 * TS * TS * sizeof(float) + 3 * 16 * sizeof(float));
+ float *cfablur = (cfain + (TS * TS) + 1 * 16);
+ float *cfadiff = (cfain + (2 * TS * TS) + 2 * 16);
+ float *cfadn = (cfain + (3 * TS * TS) + 3 * 16);
float linehvar[4], linevvar[4], noisefactor[4][8][2], coeffsq;
@@ -250,7 +249,7 @@ void RawImageSource::CLASS cfa_linedn(float noise)
}
// clean up
- free(buffer);
+ free(cfain);
// copy temporary buffer back to image matrix
#pragma omp for
diff --git a/rtengine/color.cc b/rtengine/color.cc
index aa7232db6..5cf1d45b1 100644
--- a/rtengine/color.cc
+++ b/rtengine/color.cc
@@ -23,6 +23,7 @@
#include "mytime.h"
#include "sleef.c"
#include "opthelper.h"
+#include "iccstore.h"
#define pow_F(a,b) (xexpf(b*xlogf(a)))
@@ -542,7 +543,7 @@ void Color::rgb2hsl(float r, float g, float b, float &h, float &s, float &l)
h_ = 4. + (var_R - var_G) / C;
}
- h = float(h_ /= 6.0);
+ h = float(h_ / 6.0);
if ( h < 0.f ) {
h += 1.f;
@@ -923,7 +924,7 @@ void Color::hsv2rgb (float h, float s, float v, int &r, int &g, int &b)
r1 = t;
g1 = p;
b1 = v;
- } else if (i == 5) {
+ } else /*if (i == 5)*/ {
r1 = v;
g1 = p;
b1 = q;
@@ -1647,7 +1648,7 @@ void Color::interpolateRGBColor (float realL, float iplow, float iphigh, int alg
Color::xyz2rgb(X, Y, Z, ro, go, bo, rgb_xyz);// ro go bo in gamut
}
-void Color::calcGamma (double pwr, double ts, int mode, int imax, double &gamma0, double &gamma1, double &gamma2, double &gamma3, double &gamma4, double &gamma5)
+void Color::calcGamma (double pwr, double ts, int mode, int imax, GammaValues &gamma)
{
//from Dcraw (D.Coffin)
int i;
@@ -1683,12 +1684,13 @@ void Color::calcGamma (double pwr, double ts, int mode, int imax, double &gamma0
}
if (!mode--) {
- gamma0 = g[0];
- gamma1 = g[1];
- gamma2 = g[2];
- gamma3 = g[3];
- gamma4 = g[4];
- gamma5 = g[5];
+ gamma[0] = g[0];
+ gamma[1] = g[1];
+ gamma[2] = g[2];
+ gamma[3] = g[3];
+ gamma[4] = g[4];
+ gamma[5] = g[5];
+ gamma[6] = 0.;
return;
}
}
@@ -1996,7 +1998,6 @@ void Color::skinred ( double J, double h, double sres, double Sp, float dred, fl
float factorskin, factorsat, factor, factorskinext, interm;
float scale = 100.0f / 100.1f; //reduction in normal zone
float scaleext = 1.0f; //reduction in transition zone
- float protect_redh;
float deltaHH = 0.3f; //HH value transition : I have choice 0.3 radians
float HH;
bool doskin = false;
@@ -2077,7 +2078,6 @@ void Color::skinredfloat ( float J, float h, float sres, float Sp, float dred, f
if(doskin) {
float factorskin, factorsat, factor, factorskinext;
- float protect_redh;
float deltaHH = 0.3f; //HH value transition : I have choice 0.3 radians
float chromapro = sres / Sp;
@@ -2757,8 +2757,8 @@ SSEFUNCTION void Color::LabGamutMunsell(float *labL, float *laba, float *labb,
printf(" Gamut : G1negat=%iiter G165535=%iiter \n", negat, moreRGB);
if (MunsDebugInfo) {
- printf(" Munsell chrominance: MaxBP=%1.2frad MaxRY=%1.2frad MaxGY=%1.2frad MaxRP=%1.2frad depass=%i\n", MunsDebugInfo->maxdhue[0], MunsDebugInfo->maxdhue[1], MunsDebugInfo->maxdhue[2], MunsDebugInfo->maxdhue[3], MunsDebugInfo->depass);
- printf(" Munsell luminance : MaxBP=%1.2frad MaxRY=%1.2frad MaxGY=%1.2frad MaxRP=%1.2frad depass=%i\n", MunsDebugInfo->maxdhuelum[0] , MunsDebugInfo->maxdhuelum[1], MunsDebugInfo->maxdhuelum[2], MunsDebugInfo->maxdhuelum[3], MunsDebugInfo->depassLum);
+ printf(" Munsell chrominance: MaxBP=%1.2frad MaxRY=%1.2frad MaxGY=%1.2frad MaxRP=%1.2frad depass=%u\n", MunsDebugInfo->maxdhue[0], MunsDebugInfo->maxdhue[1], MunsDebugInfo->maxdhue[2], MunsDebugInfo->maxdhue[3], MunsDebugInfo->depass);
+ printf(" Munsell luminance : MaxBP=%1.2frad MaxRY=%1.2frad MaxGY=%1.2frad MaxRP=%1.2frad depass=%u\n", MunsDebugInfo->maxdhuelum[0] , MunsDebugInfo->maxdhuelum[1], MunsDebugInfo->maxdhuelum[2], MunsDebugInfo->maxdhuelum[3], MunsDebugInfo->depassLum);
} else {
printf(" Munsell correction wasn't requested\n");
}
diff --git a/rtengine/color.h b/rtengine/color.h
index 508efeb31..e2b32e834 100644
--- a/rtengine/color.h
+++ b/rtengine/color.h
@@ -23,7 +23,6 @@
#include "rt_math.h"
#include "LUT.h"
#include "labimage.h"
-#include "iccstore.h"
#include "iccmatrices.h"
#include "sleef.c"
#define SAT(a,b,c) ((float)max(a,b,c)-(float)min(a,b,c))/(float)max(a,b,c)
@@ -31,6 +30,8 @@
namespace rtengine
{
+typedef std::array GammaValues;
+
#ifdef _DEBUG
class MunsellDebugInfo
@@ -47,6 +48,7 @@ public:
#endif
+
class Color
{
@@ -880,21 +882,21 @@ public:
return h;
}
-
/**
* @brief Get the gamma curves' parameters used by LCMS2
* @param pwr gamma value [>1]
* @param ts slope [0 ; 20]
* @param mode [always 0]
* @imax imax [always 0]
- * @param gamma0 used in ip2Lab2rgb [0 ; 1], usually near 0.5 (return value)
- * @param gamma1 used in ip2Lab2rgb [0 ; 20], can be superior to 20, but it's quite unusual(return value)
- * @param gamma2 used in ip2Lab2rgb [0 ; 1], usually near 0.03(return value)
- * @param gamma3 used in ip2Lab2rgb [0 ; 1], usually near 0.003(return value)
- * @param gamma4 used in ip2Lab2rgb [0 ; 1], usually near 0.03(return value)
- * @param gamma5 used in ip2Lab2rgb [0 ; 1], usually near 0.5 (return value)
+ * @param gamma a pointer to an array of 6 double gamma values:
+ * gamma0 used in ip2Lab2rgb [0 ; 1], usually near 0.5 (return value)
+ * gamma1 used in ip2Lab2rgb [0 ; 20], can be superior to 20, but it's quite unusual(return value)
+ * gamma2 used in ip2Lab2rgb [0 ; 1], usually near 0.03(return value)
+ * gamma3 used in ip2Lab2rgb [0 ; 1], usually near 0.003(return value)
+ * gamma4 used in ip2Lab2rgb [0 ; 1], usually near 0.03(return value)
+ * gamma5 used in ip2Lab2rgb [0 ; 1], usually near 0.5 (return value)
*/
- static void calcGamma (double pwr, double ts, int mode, int imax, double &gamma0, double &gamma1, double &gamma2, double &gamma3, double &gamma4, double &gamma5);
+ static void calcGamma (double pwr, double ts, int mode, int imax, GammaValues &gamma);
/**
diff --git a/rtengine/curves.cc b/rtengine/curves.cc
index 2cd56dbb9..cf2fd0d04 100644
--- a/rtengine/curves.cc
+++ b/rtengine/curves.cc
@@ -36,6 +36,7 @@
#include "opthelper.h"
#include "ciecam02.h"
#include "color.h"
+#include "iccstore.h"
#undef CLIPD
#define CLIPD(a) ((a)>0.0f?((a)<1.0f?(a):1.0f):0.0f)
@@ -44,7 +45,7 @@ using namespace std;
namespace rtengine
{
-Curve::Curve () : N(0), x(nullptr), y(nullptr), ypp(nullptr), hashSize(1000 /* has to be initialized to the maximum value */) {}
+Curve::Curve () : N(0), ppn(0), x(nullptr), y(nullptr), mc(0.0), mfc(0.0), msc(0.0), mhc(0.0), ypp(nullptr), x1(0.0), y1(0.0), x2(0.0), y2(0.0), x3(0.0), y3(0.0), firstPointIncluded(false), increment(0.0), nbr_points(0), hashSize(1000 /* has to be initialized to the maximum value */) {}
void Curve::AddPolygons ()
{
@@ -1434,11 +1435,9 @@ void ColorGradientCurve::SetXYZ(const Curve *pCurve, const double xyz_rgb[3][3],
double currY = pCurve->getVal(x) - prevY;
if (dY > 0.000001 || dY < -0.000001) {
- float r1, g1, b1, r2, g2, b2, ro, go, bo;
+ float r1, g1, b1, r2, g2, b2;
Color::hsv2rgb(float(prevY), satur, lr1, r1, g1, b1);
Color::hsv2rgb(float(nextY), satur, lr2, r2, g2, b2);
- bool chr = false;
- bool lum = true;
LUTf dum;
float X1, X2, Y1, Y2, Z1, Z2, L1, a_1, b_1, c1, h1;
Color::rgbxyz(r2, g2, b2, X2, Y2, Z2, xyz_rgb);
diff --git a/rtengine/dcraw.cc b/rtengine/dcraw.cc
index 3593f2777..54fc09622 100644
--- a/rtengine/dcraw.cc
+++ b/rtengine/dcraw.cc
@@ -4132,127 +4132,127 @@ mask_set:
}
}
-void CLASS remove_zeroes()
-{
- unsigned row, col, tot, n, r, c;
-
- for (row=0; row < height; row++)
- for (col=0; col < width; col++)
- if (BAYER(row,col) == 0) {
- tot = n = 0;
- for (r = row-2; r <= row+2; r++)
- for (c = col-2; c <= col+2; c++)
- if (r < height && c < width &&
- FC(r,c) == FC(row,col) && BAYER(r,c))
- tot += (n++,BAYER(r,c));
- if (n) BAYER(row,col) = tot/n;
- }
-}
+//void CLASS remove_zeroes()
+//{
+// unsigned row, col, tot, n, r, c;
+//
+// for (row=0; row < height; row++)
+// for (col=0; col < width; col++)
+// if (BAYER(row,col) == 0) {
+// tot = n = 0;
+// for (r = row-2; r <= row+2; r++)
+// for (c = col-2; c <= col+2; c++)
+// if (r < height && c < width &&
+// FC(r,c) == FC(row,col) && BAYER(r,c))
+// tot += (n++,BAYER(r,c));
+// if (n) BAYER(row,col) = tot/n;
+// }
+//}
/*
Seach from the current directory up to the root looking for
a ".badpixels" file, and fix those pixels now.
*/
-void CLASS bad_pixels (const char *cfname)
-{
- FILE *fp=0;
- char *fname, *cp, line[128];
- int len, time, row, col, r, c, rad, tot, n, fixed=0;
+//void CLASS bad_pixels (const char *cfname)
+//{
+// FILE *fp=0;
+// char *fname, *cp, line[128];
+// int len, time, row, col, r, c, rad, tot, n, fixed=0;
+//
+// if (!filters) return;
+// if (cfname)
+// fp = fopen (cfname, "r");
+// else {
+// for (len=32 ; ; len *= 2) {
+// fname = (char *) malloc (len);
+// if (!fname) return;
+// if (getcwd (fname, len-16)) break;
+// free (fname);
+// if (errno != ERANGE) return;
+// }
+//#if defined(WIN32) || defined(DJGPP)
+// if (fname[1] == ':')
+// memmove (fname, fname+2, len-2);
+// for (cp=fname; *cp; cp++)
+// if (*cp == '\\') *cp = '/';
+//#endif
+// cp = fname + strlen(fname);
+// if (cp[-1] == '/') cp--;
+// while (*fname == '/') {
+// strcpy (cp, "/.badpixels");
+// if ((fp = fopen (fname, "r"))) break;
+// if (cp == fname) break;
+// while (*--cp != '/');
+// }
+// free (fname);
+// }
+// if (!fp) return;
+// while (fgets (line, 128, fp)) {
+// cp = strchr (line, '#');
+// if (cp) *cp = 0;
+// if (sscanf (line, "%d %d %d", &col, &row, &time) != 3) continue;
+// if ((unsigned) col >= width || (unsigned) row >= height) continue;
+// if (time > timestamp) continue;
+// for (tot=n=0, rad=1; rad < 3 && n==0; rad++)
+// for (r = row-rad; r <= row+rad; r++)
+// for (c = col-rad; c <= col+rad; c++)
+// if ((unsigned) r < height && (unsigned) c < width &&
+// (r != row || c != col) && fcol(r,c) == fcol(row,col)) {
+// tot += BAYER2(r,c);
+// n++;
+// }
+// BAYER2(row,col) = tot/n;
+// if (verbose) {
+// if (!fixed++)
+// fprintf (stderr,_("Fixed dead pixels at:"));
+// fprintf (stderr, " %d,%d", col, row);
+// }
+// }
+// if (fixed) fputc ('\n', stderr);
+// fclose (fp);
+//}
- if (!filters) return;
- if (cfname)
- fp = fopen (cfname, "r");
- else {
- for (len=32 ; ; len *= 2) {
- fname = (char *) malloc (len);
- if (!fname) return;
- if (getcwd (fname, len-16)) break;
- free (fname);
- if (errno != ERANGE) return;
- }
-#if defined(WIN32) || defined(DJGPP)
- if (fname[1] == ':')
- memmove (fname, fname+2, len-2);
- for (cp=fname; *cp; cp++)
- if (*cp == '\\') *cp = '/';
-#endif
- cp = fname + strlen(fname);
- if (cp[-1] == '/') cp--;
- while (*fname == '/') {
- strcpy (cp, "/.badpixels");
- if ((fp = fopen (fname, "r"))) break;
- if (cp == fname) break;
- while (*--cp != '/');
- }
- free (fname);
- }
- if (!fp) return;
- while (fgets (line, 128, fp)) {
- cp = strchr (line, '#');
- if (cp) *cp = 0;
- if (sscanf (line, "%d %d %d", &col, &row, &time) != 3) continue;
- if ((unsigned) col >= width || (unsigned) row >= height) continue;
- if (time > timestamp) continue;
- for (tot=n=0, rad=1; rad < 3 && n==0; rad++)
- for (r = row-rad; r <= row+rad; r++)
- for (c = col-rad; c <= col+rad; c++)
- if ((unsigned) r < height && (unsigned) c < width &&
- (r != row || c != col) && fcol(r,c) == fcol(row,col)) {
- tot += BAYER2(r,c);
- n++;
- }
- BAYER2(row,col) = tot/n;
- if (verbose) {
- if (!fixed++)
- fprintf (stderr,_("Fixed dead pixels at:"));
- fprintf (stderr, " %d,%d", col, row);
- }
- }
- if (fixed) fputc ('\n', stderr);
- fclose (fp);
-}
-
-void CLASS subtract (const char *fname)
-{
- FILE *fp;
- int dim[3]={0,0,0}, comment=0, number=0, error=0, nd=0, c, row, col;
- ushort *pixel;
-
- if (!(fp = fopen (fname, "rb"))) {
- perror (fname); return;
- }
- if (fgetc(fp) != 'P' || fgetc(fp) != '5') error = 1;
- while (!error && nd < 3 && (c = fgetc(fp)) != EOF) {
- if (c == '#') comment = 1;
- if (c == '\n') comment = 0;
- if (comment) continue;
- if (isdigit(c)) number = 1;
- if (number) {
- if (isdigit(c)) dim[nd] = dim[nd]*10 + c -'0';
- else if (isspace(c)) {
- number = 0; nd++;
- } else error = 1;
- }
- }
- if (error || nd < 3) {
- fprintf (stderr,_("%s is not a valid PGM file!\n"), fname);
- fclose (fp); return;
- } else if (dim[0] != width || dim[1] != height || dim[2] != 65535) {
- fprintf (stderr,_("%s has the wrong dimensions!\n"), fname);
- fclose (fp); return;
- }
- pixel = (ushort *) calloc (width, sizeof *pixel);
- merror (pixel, "subtract()");
- for (row=0; row < height; row++) {
- fread (pixel, 2, width, fp);
- for (col=0; col < width; col++)
- BAYER(row,col) = MAX (BAYER(row,col) - ntohs(pixel[col]), 0);
- }
- free (pixel);
- fclose (fp);
- memset (cblack, 0, sizeof cblack);
- black = 0;
-}
+//void CLASS subtract (const char *fname)
+//{
+// FILE *fp;
+// int dim[3]={0,0,0}, comment=0, number=0, error=0, nd=0, c, row, col;
+// ushort *pixel;
+//
+// if (!(fp = fopen (fname, "rb"))) {
+// perror (fname); return;
+// }
+// if (fgetc(fp) != 'P' || fgetc(fp) != '5') error = 1;
+// while (!error && nd < 3 && (c = fgetc(fp)) != EOF) {
+// if (c == '#') comment = 1;
+// if (c == '\n') comment = 0;
+// if (comment) continue;
+// if (isdigit(c)) number = 1;
+// if (number) {
+// if (isdigit(c)) dim[nd] = dim[nd]*10 + c -'0';
+// else if (isspace(c)) {
+// number = 0; nd++;
+// } else error = 1;
+// }
+// }
+// if (error || nd < 3) {
+// fprintf (stderr,_("%s is not a valid PGM file!\n"), fname);
+// fclose (fp); return;
+// } else if (dim[0] != width || dim[1] != height || dim[2] != 65535) {
+// fprintf (stderr,_("%s has the wrong dimensions!\n"), fname);
+// fclose (fp); return;
+// }
+// pixel = (ushort *) calloc (width, sizeof *pixel);
+// merror (pixel, "subtract()");
+// for (row=0; row < height; row++) {
+// fread (pixel, 2, width, fp);
+// for (col=0; col < width; col++)
+// BAYER(row,col) = MAX (BAYER(row,col) - ntohs(pixel[col]), 0);
+// }
+// free (pixel);
+// fclose (fp);
+// memset (cblack, 0, sizeof cblack);
+// black = 0;
+//}
void CLASS gamma_curve (double pwr, double ts, int mode, int imax)
{
@@ -4417,94 +4417,94 @@ void CLASS colorcheck()
}
#endif
-void CLASS hat_transform (float *temp, float *base, int st, int size, int sc)
-{
- int i;
- for (i=0; i < sc; i++)
- temp[i] = 2*base[st*i] + base[st*(sc-i)] + base[st*(i+sc)];
- for (; i+sc < size; i++)
- temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(i+sc)];
- for (; i < size; i++)
- temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(2*size-2-(i+sc))];
-}
+//void CLASS hat_transform (float *temp, float *base, int st, int size, int sc)
+//{
+// int i;
+// for (i=0; i < sc; i++)
+// temp[i] = 2*base[st*i] + base[st*(sc-i)] + base[st*(i+sc)];
+// for (; i+sc < size; i++)
+// temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(i+sc)];
+// for (; i < size; i++)
+// temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(2*size-2-(i+sc))];
+//}
-void CLASS wavelet_denoise()
-{
- float *fimg=0, *temp, thold, mul[2], avg, diff;
- int scale=1, size, lev, hpass, lpass, row, col, nc, c, i, wlast, blk[2];
- ushort *window[4];
- static const float noise[] =
- { 0.8002,0.2735,0.1202,0.0585,0.0291,0.0152,0.0080,0.0044 };
-
- if (verbose) fprintf (stderr,_("Wavelet denoising...\n"));
-
- while (maximum << scale < 0x10000) scale++;
- maximum <<= --scale;
- black <<= scale;
- FORC4 cblack[c] <<= scale;
- if ((size = iheight*iwidth) < 0x15550000)
- fimg = (float *) malloc ((size*3 + iheight + iwidth) * sizeof *fimg);
- merror (fimg, "wavelet_denoise()");
- temp = fimg + size*3;
- if ((nc = colors) == 3 && filters) nc++;
- FORC(nc) { /* denoise R,G1,B,G3 individually */
- for (i=0; i < size; i++)
- fimg[i] = 256 * sqrt(image[i][c] << scale);
- for (hpass=lev=0; lev < 5; lev++) {
- lpass = size*((lev & 1)+1);
- for (row=0; row < iheight; row++) {
- hat_transform (temp, fimg+hpass+row*iwidth, 1, iwidth, 1 << lev);
- for (col=0; col < iwidth; col++)
- fimg[lpass + row*iwidth + col] = temp[col] * 0.25;
- }
- for (col=0; col < iwidth; col++) {
- hat_transform (temp, fimg+lpass+col, iwidth, iheight, 1 << lev);
- for (row=0; row < iheight; row++)
- fimg[lpass + row*iwidth + col] = temp[row] * 0.25;
- }
- thold = threshold * noise[lev];
- for (i=0; i < size; i++) {
- fimg[hpass+i] -= fimg[lpass+i];
- if (fimg[hpass+i] < -thold) fimg[hpass+i] += thold;
- else if (fimg[hpass+i] > thold) fimg[hpass+i] -= thold;
- else fimg[hpass+i] = 0;
- if (hpass) fimg[i] += fimg[hpass+i];
- }
- hpass = lpass;
- }
- for (i=0; i < size; i++)
- image[i][c] = CLIP(SQR(fimg[i]+fimg[lpass+i])/0x10000);
- }
- if (filters && colors == 3) { /* pull G1 and G3 closer together */
- for (row=0; row < 2; row++) {
- mul[row] = 0.125 * pre_mul[FC(row+1,0) | 1] / pre_mul[FC(row,0) | 1];
- blk[row] = cblack[FC(row,0) | 1];
- }
- for (i=0; i < 4; i++)
- window[i] = (ushort *) fimg + width*i;
- for (wlast=-1, row=1; row < height-1; row++) {
- while (wlast < row+1) {
- for (wlast++, i=0; i < 4; i++)
- window[(i+3) & 3] = window[i];
- for (col = FC(wlast,1) & 1; col < width; col+=2)
- window[2][col] = BAYER(wlast,col);
- }
- thold = threshold/512;
- for (col = (FC(row,0) & 1)+1; col < width-1; col+=2) {
- avg = ( window[0][col-1] + window[0][col+1] +
- window[2][col-1] + window[2][col+1] - blk[~row & 1]*4 )
- * mul[row & 1] + (window[1][col] + blk[row & 1]) * 0.5;
- avg = avg < 0 ? 0 : sqrt(avg);
- diff = sqrt(BAYER(row,col)) - avg;
- if (diff < -thold) diff += thold;
- else if (diff > thold) diff -= thold;
- else diff = 0;
- BAYER(row,col) = CLIP(SQR(avg+diff) + 0.5);
- }
- }
- }
- free (fimg);
-}
+//void CLASS wavelet_denoise()
+//{
+// float *fimg=0, *temp, thold, mul[2], avg, diff;
+// int scale=1, size, lev, hpass, lpass, row, col, nc, c, i, wlast, blk[2];
+// ushort *window[4];
+// static const float noise[] =
+// { 0.8002,0.2735,0.1202,0.0585,0.0291,0.0152,0.0080,0.0044 };
+//
+// if (verbose) fprintf (stderr,_("Wavelet denoising...\n"));
+//
+// while (maximum << scale < 0x10000) scale++;
+// maximum <<= --scale;
+// black <<= scale;
+// FORC4 cblack[c] <<= scale;
+// if ((size = iheight*iwidth) < 0x15550000)
+// fimg = (float *) malloc ((size*3 + iheight + iwidth) * sizeof *fimg);
+// merror (fimg, "wavelet_denoise()");
+// temp = fimg + size*3;
+// if ((nc = colors) == 3 && filters) nc++;
+// FORC(nc) { /* denoise R,G1,B,G3 individually */
+// for (i=0; i < size; i++)
+// fimg[i] = 256 * sqrt(image[i][c] << scale);
+// for (hpass=lev=0; lev < 5; lev++) {
+// lpass = size*((lev & 1)+1);
+// for (row=0; row < iheight; row++) {
+// hat_transform (temp, fimg+hpass+row*iwidth, 1, iwidth, 1 << lev);
+// for (col=0; col < iwidth; col++)
+// fimg[lpass + row*iwidth + col] = temp[col] * 0.25;
+// }
+// for (col=0; col < iwidth; col++) {
+// hat_transform (temp, fimg+lpass+col, iwidth, iheight, 1 << lev);
+// for (row=0; row < iheight; row++)
+// fimg[lpass + row*iwidth + col] = temp[row] * 0.25;
+// }
+// thold = threshold * noise[lev];
+// for (i=0; i < size; i++) {
+// fimg[hpass+i] -= fimg[lpass+i];
+// if (fimg[hpass+i] < -thold) fimg[hpass+i] += thold;
+// else if (fimg[hpass+i] > thold) fimg[hpass+i] -= thold;
+// else fimg[hpass+i] = 0;
+// if (hpass) fimg[i] += fimg[hpass+i];
+// }
+// hpass = lpass;
+// }
+// for (i=0; i < size; i++)
+// image[i][c] = CLIP(SQR(fimg[i]+fimg[lpass+i])/0x10000);
+// }
+// if (filters && colors == 3) { /* pull G1 and G3 closer together */
+// for (row=0; row < 2; row++) {
+// mul[row] = 0.125 * pre_mul[FC(row+1,0) | 1] / pre_mul[FC(row,0) | 1];
+// blk[row] = cblack[FC(row,0) | 1];
+// }
+// for (i=0; i < 4; i++)
+// window[i] = (ushort *) fimg + width*i;
+// for (wlast=-1, row=1; row < height-1; row++) {
+// while (wlast < row+1) {
+// for (wlast++, i=0; i < 4; i++)
+// window[(i+3) & 3] = window[i];
+// for (col = FC(wlast,1) & 1; col < width; col+=2)
+// window[2][col] = BAYER(wlast,col);
+// }
+// thold = threshold/512;
+// for (col = (FC(row,0) & 1)+1; col < width-1; col+=2) {
+// avg = ( window[0][col-1] + window[0][col+1] +
+// window[2][col-1] + window[2][col+1] - blk[~row & 1]*4 )
+// * mul[row & 1] + (window[1][col] + blk[row & 1]) * 0.5;
+// avg = avg < 0 ? 0 : sqrt(avg);
+// diff = sqrt(BAYER(row,col)) - avg;
+// if (diff < -thold) diff += thold;
+// else if (diff > thold) diff -= thold;
+// else diff = 0;
+// BAYER(row,col) = CLIP(SQR(avg+diff) + 0.5);
+// }
+// }
+// }
+// free (fimg);
+//}
void CLASS scale_colors()
{
@@ -4562,7 +4562,7 @@ skip_block: ;
if (pre_mul[3] == 0) pre_mul[3] = colors < 4 ? pre_mul[1] : 1;
dark = black;
sat = maximum;
- if (threshold) wavelet_denoise();
+// if (threshold) wavelet_denoise();
maximum -= black;
for (dmin=DBL_MAX, dmax=c=0; c < 4; c++) {
if (dmin > pre_mul[c])
@@ -4668,440 +4668,440 @@ void CLASS pre_interpolate()
if (half_size) filters = 0;
}
-void CLASS border_interpolate (int border)
-{
- unsigned row, col, y, x, f, c, sum[8];
-
- for (row=0; row < height; row++)
- for (col=0; col < width; col++) {
- if (col==border && row >= border && row < height-border)
- col = width-border;
- memset (sum, 0, sizeof sum);
- for (y=row-1; y != row+2; y++)
- for (x=col-1; x != col+2; x++)
- if (y < height && x < width) {
- f = fcol(y,x);
- sum[f] += image[y*width+x][f];
- sum[f+4]++;
- }
- f = fcol(row,col);
- FORCC if (c != f && sum[c+4])
- image[row*width+col][c] = sum[c] / sum[c+4];
- }
-}
+//void CLASS border_interpolate (int border)
+//{
+// unsigned row, col, y, x, f, c, sum[8];
+//
+// for (row=0; row < height; row++)
+// for (col=0; col < width; col++) {
+// if (col==border && row >= border && row < height-border)
+// col = width-border;
+// memset (sum, 0, sizeof sum);
+// for (y=row-1; y != row+2; y++)
+// for (x=col-1; x != col+2; x++)
+// if (y < height && x < width) {
+// f = fcol(y,x);
+// sum[f] += image[y*width+x][f];
+// sum[f+4]++;
+// }
+// f = fcol(row,col);
+// FORCC if (c != f && sum[c+4])
+// image[row*width+col][c] = sum[c] / sum[c+4];
+// }
+//}
/* RT: delete interpolation functions */
-void CLASS cielab (ushort rgb[3], short lab[3])
-{
- int c, i, j, k;
- float r, xyz[3];
- static float cbrt[0x10000], xyz_cam[3][4];
+//void CLASS cielab (ushort rgb[3], short lab[3])
+//{
+// int c, i, j, k;
+// float r, xyz[3];
+// static float cbrt[0x10000], xyz_cam[3][4];
+//
+// if (!rgb) {
+// for (i=0; i < 0x10000; i++) {
+// r = i / 65535.0;
+// cbrt[i] = r > 0.008856 ? pow(r,1/3.0) : 7.787*r + 16/116.0;
+// }
+// for (i=0; i < 3; i++)
+// for (j=0; j < colors; j++)
+// for (xyz_cam[i][j] = k=0; k < 3; k++)
+// xyz_cam[i][j] += xyz_rgb[i][k] * rgb_cam[k][j] / d65_white[i];
+// return;
+// }
+// xyz[0] = xyz[1] = xyz[2] = 0.5;
+// FORCC {
+// xyz[0] += xyz_cam[0][c] * rgb[c];
+// xyz[1] += xyz_cam[1][c] * rgb[c];
+// xyz[2] += xyz_cam[2][c] * rgb[c];
+// }
+// xyz[0] = cbrt[CLIP((int) xyz[0])];
+// xyz[1] = cbrt[CLIP((int) xyz[1])];
+// xyz[2] = cbrt[CLIP((int) xyz[2])];
+// lab[0] = 64 * (116 * xyz[1] - 16);
+// lab[1] = 64 * 500 * (xyz[0] - xyz[1]);
+// lab[2] = 64 * 200 * (xyz[1] - xyz[2]);
+//}
+//
+//#define TS 512 /* Tile Size */
+//#define fcol(row,col) xtrans[(row+6) % 6][(col+6) % 6]
+//
+///*
+// Frank Markesteijn's algorithm for Fuji X-Trans sensors
+// */
+//void CLASS xtrans_interpolate (int passes)
+//{
+// int c, d, f, g, h, i, v, ng, row, col, top, left, mrow, mcol;
+// int val, ndir, pass, hm[8], avg[4], color[3][8];
+// static const short orth[12] = { 1,0,0,1,-1,0,0,-1,1,0,0,1 },
+// patt[2][16] = { { 0,1,0,-1,2,0,-1,0,1,1,1,-1,0,0,0,0 },
+// { 0,1,0,-2,1,0,-2,0,1,1,-2,-2,1,-1,-1,1 } },
+// dir[4] = { 1,TS,TS+1,TS-1 };
+// short allhex[3][3][2][8], *hex;
+// ushort min, max, sgrow, sgcol;
+// ushort (*rgb)[TS][TS][3], (*rix)[3], (*pix)[4];
+// short (*lab) [TS][3], (*lix)[3];
+// float (*drv)[TS][TS], diff[6], tr;
+// char (*homo)[TS][TS], *buffer;
+//
+// if (verbose)
+// fprintf (stderr,_("%d-pass X-Trans interpolation...\n"), passes);
+//
+// cielab (0,0);
+// ndir = 4 << (passes > 1);
+// buffer = (char *) malloc (TS*TS*(ndir*11+6));
+// merror (buffer, "xtrans_interpolate()");
+// rgb = (ushort(*)[TS][TS][3]) buffer;
+// lab = (short (*) [TS][3])(buffer + TS*TS*(ndir*6));
+// drv = (float (*)[TS][TS]) (buffer + TS*TS*(ndir*6+6));
+// homo = (char (*)[TS][TS]) (buffer + TS*TS*(ndir*10+6));
+//
+///* Map a green hexagon around each non-green pixel and vice versa: */
+// for (row=0; row < 3; row++)
+// for (col=0; col < 3; col++)
+// for (ng=d=0; d < 10; d+=2) {
+// g = fcol(row,col) == 1;
+// if (fcol(row+orth[d],col+orth[d+2]) == 1) ng=0; else ng++;
+// if (ng == 4) { sgrow = row; sgcol = col; }
+// if (ng == g+1) FORC(8) {
+// v = orth[d ]*patt[g][c*2] + orth[d+1]*patt[g][c*2+1];
+// h = orth[d+2]*patt[g][c*2] + orth[d+3]*patt[g][c*2+1];
+// allhex[row][col][0][c^(g*2 & d)] = h + v*width;
+// allhex[row][col][1][c^(g*2 & d)] = h + v*TS;
+// }
+// }
+//
+///* Set green1 and green3 to the minimum and maximum allowed values: */
+// for (row=2; row < height-2; row++)
+// for (min=~(max=0), col=2; col < width-2; col++) {
+// if (fcol(row,col) == 1 && (min=~(max=0))) continue;
+// pix = image + row*width + col;
+// hex = allhex[row % 3][col % 3][0];
+// if (!max) FORC(6) {
+// val = pix[hex[c]][1];
+// if (min > val) min = val;
+// if (max < val) max = val;
+// }
+// pix[0][1] = min;
+// pix[0][3] = max;
+// switch ((row-sgrow) % 3) {
+// case 1: if (row < height-3) { row++; col--; } break;
+// case 2: if ((min=~(max=0)) && (col+=2) < width-3 && row > 2) row--;
+// }
+// }
+//
+// for (top=3; top < height-19; top += TS-16)
+// for (left=3; left < width-19; left += TS-16) {
+// mrow = MIN (top+TS, height-3);
+// mcol = MIN (left+TS, width-3);
+// for (row=top; row < mrow; row++)
+// for (col=left; col < mcol; col++)
+// memcpy (rgb[0][row-top][col-left], image[row*width+col], 6);
+// FORC3 memcpy (rgb[c+1], rgb[0], sizeof *rgb);
+//
+///* Interpolate green horizontally, vertically, and along both diagonals: */
+// for (row=top; row < mrow; row++)
+// for (col=left; col < mcol; col++) {
+// if ((f = fcol(row,col)) == 1) continue;
+// pix = image + row*width + col;
+// hex = allhex[row % 3][col % 3][0];
+// color[1][0] = 174 * (pix[ hex[1]][1] + pix[ hex[0]][1]) -
+// 46 * (pix[2*hex[1]][1] + pix[2*hex[0]][1]);
+// color[1][1] = 223 * pix[ hex[3]][1] + pix[ hex[2]][1] * 33 +
+// 92 * (pix[ 0 ][f] - pix[ -hex[2]][f]);
+// FORC(2) color[1][2+c] =
+// 164 * pix[hex[4+c]][1] + 92 * pix[-2*hex[4+c]][1] + 33 *
+// (2*pix[0][f] - pix[3*hex[4+c]][f] - pix[-3*hex[4+c]][f]);
+// FORC4 rgb[c^!((row-sgrow) % 3)][row-top][col-left][1] =
+// LIM(color[1][c] >> 8,pix[0][1],pix[0][3]);
+// }
+//
+// for (pass=0; pass < passes; pass++) {
+// if (pass == 1)
+// memcpy (rgb+=4, buffer, 4*sizeof *rgb);
+//
+///* Recalculate green from interpolated values of closer pixels: */
+// if (pass) {
+// for (row=top+2; row < mrow-2; row++)
+// for (col=left+2; col < mcol-2; col++) {
+// if ((f = fcol(row,col)) == 1) continue;
+// pix = image + row*width + col;
+// hex = allhex[row % 3][col % 3][1];
+// for (d=3; d < 6; d++) {
+// rix = &rgb[(d-2)^!((row-sgrow) % 3)][row-top][col-left];
+// val = rix[-2*hex[d]][1] + 2*rix[hex[d]][1]
+// - rix[-2*hex[d]][f] - 2*rix[hex[d]][f] + 3*rix[0][f];
+// rix[0][1] = LIM(val/3,pix[0][1],pix[0][3]);
+// }
+// }
+// }
+//
+///* Interpolate red and blue values for solitary green pixels: */
+// for (row=(top-sgrow+4)/3*3+sgrow; row < mrow-2; row+=3)
+// for (col=(left-sgcol+4)/3*3+sgcol; col < mcol-2; col+=3) {
+// rix = &rgb[0][row-top][col-left];
+// h = fcol(row,col+1);
+// memset (diff, 0, sizeof diff);
+// for (i=1, d=0; d < 6; d++, i^=TS^1, h^=2) {
+// for (c=0; c < 2; c++, h^=2) {
+// g = 2*rix[0][1] - rix[i< 1)
+// diff[d] += SQR (rix[i< 1 && (d & 1))
+// if (diff[d-1] < diff[d])
+// FORC(2) color[c*2][d] = color[c*2][d-1];
+// if (d < 2 || (d & 1)) {
+// FORC(2) rix[0][c*2] = CLIP(color[c*2][d]/2);
+// rix += TS*TS;
+// }
+// }
+// }
+//
+///* Interpolate red for blue pixels and vice versa: */
+// for (row=top+3; row < mrow-3; row++)
+// for (col=left+3; col < mcol-3; col++) {
+// if ((f = 2-fcol(row,col)) == 1) continue;
+// rix = &rgb[0][row-top][col-left];
+// c = (row-sgrow) % 3 ? TS:1;
+// h = 3 * (c ^ TS ^ 1);
+// for (d=0; d < 4; d++, rix += TS*TS) {
+// i = d > 1 || ((d ^ c) & 1) ||
+// ((ABS(rix[0][1]-rix[c][1])+ABS(rix[0][1]-rix[-c][1])) <
+// 2*(ABS(rix[0][1]-rix[h][1])+ABS(rix[0][1]-rix[-h][1]))) ? c:h;
+// rix[0][f] = CLIP((rix[i][f] + rix[-i][f] +
+// 2*rix[0][1] - rix[i][1] - rix[-i][1])/2);
+// }
+// }
+//
+///* Fill in red and blue for 2x2 blocks of green: */
+// for (row=top+2; row < mrow-2; row++) if ((row-sgrow) % 3)
+// for (col=left+2; col < mcol-2; col++) if ((col-sgcol) % 3) {
+// rix = &rgb[0][row-top][col-left];
+// hex = allhex[row % 3][col % 3][1];
+// for (d=0; d < ndir; d+=2, rix += TS*TS)
+// if (hex[d] + hex[d+1]) {
+// g = 3*rix[0][1] - 2*rix[hex[d]][1] - rix[hex[d+1]][1];
+// for (c=0; c < 4; c+=2) rix[0][c] =
+// CLIP((g + 2*rix[hex[d]][c] + rix[hex[d+1]][c])/3);
+// } else {
+// g = 2*rix[0][1] - rix[hex[d]][1] - rix[hex[d+1]][1];
+// for (c=0; c < 4; c+=2) rix[0][c] =
+// CLIP((g + rix[hex[d]][c] + rix[hex[d+1]][c])/2);
+// }
+// }
+// }
+// rgb = (ushort(*)[TS][TS][3]) buffer;
+// mrow -= top;
+// mcol -= left;
+//
+///* Convert to CIELab and differentiate in all directions: */
+// for (d=0; d < ndir; d++) {
+// for (row=2; row < mrow-2; row++)
+// for (col=2; col < mcol-2; col++)
+// cielab (rgb[d][row][col], lab[row][col]);
+// for (f=dir[d & 3],row=3; row < mrow-3; row++)
+// for (col=3; col < mcol-3; col++) {
+// lix = &lab[row][col];
+// g = 2*lix[0][0] - lix[f][0] - lix[-f][0];
+// drv[d][row][col] = SQR(g)
+// + SQR((2*lix[0][1] - lix[f][1] - lix[-f][1] + g*500/232))
+// + SQR((2*lix[0][2] - lix[f][2] - lix[-f][2] - g*500/580));
+// }
+// }
+//
+///* Build homogeneity maps from the derivatives: */
+// memset(homo, 0, ndir*TS*TS);
+// for (row=4; row < mrow-4; row++)
+// for (col=4; col < mcol-4; col++) {
+// for (tr=FLT_MAX, d=0; d < ndir; d++)
+// if (tr > drv[d][row][col])
+// tr = drv[d][row][col];
+// tr *= 8;
+// for (d=0; d < ndir; d++)
+// for (v=-1; v <= 1; v++)
+// for (h=-1; h <= 1; h++)
+// if (drv[d][row+v][col+h] <= tr)
+// homo[d][row][col]++;
+// }
+//
+///* Average the most homogenous pixels for the final result: */
+// if (height-top < TS+4) mrow = height-top+2;
+// if (width-left < TS+4) mcol = width-left+2;
+// for (row = MIN(top,8); row < mrow-8; row++)
+// for (col = MIN(left,8); col < mcol-8; col++) {
+// for (d=0; d < ndir; d++)
+// for (hm[d]=0, v=-2; v <= 2; v++)
+// for (h=-2; h <= 2; h++)
+// hm[d] += homo[d][row+v][col+h];
+// for (d=0; d < ndir-4; d++)
+// if (hm[d] < hm[d+4]) hm[d ] = 0; else
+// if (hm[d] > hm[d+4]) hm[d+4] = 0;
+// for (max=hm[0],d=1; d < ndir; d++)
+// if (max < hm[d]) max = hm[d];
+// max -= max >> 3;
+// memset (avg, 0, sizeof avg);
+// for (d=0; d < ndir; d++)
+// if (hm[d] >= max) {
+// FORC3 avg[c] += rgb[d][row][col][c];
+// avg[3]++;
+// }
+// FORC3 image[(row+top)*width+col+left][c] = avg[c]/avg[3];
+// }
+// }
+// free(buffer);
+// border_interpolate(8);
+//}
+//#undef fcol
+//
+//
+//#undef TS
- if (!rgb) {
- for (i=0; i < 0x10000; i++) {
- r = i / 65535.0;
- cbrt[i] = r > 0.008856 ? pow(r,1/3.0) : 7.787*r + 16/116.0;
- }
- for (i=0; i < 3; i++)
- for (j=0; j < colors; j++)
- for (xyz_cam[i][j] = k=0; k < 3; k++)
- xyz_cam[i][j] += xyz_rgb[i][k] * rgb_cam[k][j] / d65_white[i];
- return;
- }
- xyz[0] = xyz[1] = xyz[2] = 0.5;
- FORCC {
- xyz[0] += xyz_cam[0][c] * rgb[c];
- xyz[1] += xyz_cam[1][c] * rgb[c];
- xyz[2] += xyz_cam[2][c] * rgb[c];
- }
- xyz[0] = cbrt[CLIP((int) xyz[0])];
- xyz[1] = cbrt[CLIP((int) xyz[1])];
- xyz[2] = cbrt[CLIP((int) xyz[2])];
- lab[0] = 64 * (116 * xyz[1] - 16);
- lab[1] = 64 * 500 * (xyz[0] - xyz[1]);
- lab[2] = 64 * 200 * (xyz[1] - xyz[2]);
-}
-
-#define TS 512 /* Tile Size */
-#define fcol(row,col) xtrans[(row+6) % 6][(col+6) % 6]
-
-/*
- Frank Markesteijn's algorithm for Fuji X-Trans sensors
- */
-void CLASS xtrans_interpolate (int passes)
-{
- int c, d, f, g, h, i, v, ng, row, col, top, left, mrow, mcol;
- int val, ndir, pass, hm[8], avg[4], color[3][8];
- static const short orth[12] = { 1,0,0,1,-1,0,0,-1,1,0,0,1 },
- patt[2][16] = { { 0,1,0,-1,2,0,-1,0,1,1,1,-1,0,0,0,0 },
- { 0,1,0,-2,1,0,-2,0,1,1,-2,-2,1,-1,-1,1 } },
- dir[4] = { 1,TS,TS+1,TS-1 };
- short allhex[3][3][2][8], *hex;
- ushort min, max, sgrow, sgcol;
- ushort (*rgb)[TS][TS][3], (*rix)[3], (*pix)[4];
- short (*lab) [TS][3], (*lix)[3];
- float (*drv)[TS][TS], diff[6], tr;
- char (*homo)[TS][TS], *buffer;
-
- if (verbose)
- fprintf (stderr,_("%d-pass X-Trans interpolation...\n"), passes);
-
- cielab (0,0);
- ndir = 4 << (passes > 1);
- buffer = (char *) malloc (TS*TS*(ndir*11+6));
- merror (buffer, "xtrans_interpolate()");
- rgb = (ushort(*)[TS][TS][3]) buffer;
- lab = (short (*) [TS][3])(buffer + TS*TS*(ndir*6));
- drv = (float (*)[TS][TS]) (buffer + TS*TS*(ndir*6+6));
- homo = (char (*)[TS][TS]) (buffer + TS*TS*(ndir*10+6));
-
-/* Map a green hexagon around each non-green pixel and vice versa: */
- for (row=0; row < 3; row++)
- for (col=0; col < 3; col++)
- for (ng=d=0; d < 10; d+=2) {
- g = fcol(row,col) == 1;
- if (fcol(row+orth[d],col+orth[d+2]) == 1) ng=0; else ng++;
- if (ng == 4) { sgrow = row; sgcol = col; }
- if (ng == g+1) FORC(8) {
- v = orth[d ]*patt[g][c*2] + orth[d+1]*patt[g][c*2+1];
- h = orth[d+2]*patt[g][c*2] + orth[d+3]*patt[g][c*2+1];
- allhex[row][col][0][c^(g*2 & d)] = h + v*width;
- allhex[row][col][1][c^(g*2 & d)] = h + v*TS;
- }
- }
-
-/* Set green1 and green3 to the minimum and maximum allowed values: */
- for (row=2; row < height-2; row++)
- for (min=~(max=0), col=2; col < width-2; col++) {
- if (fcol(row,col) == 1 && (min=~(max=0))) continue;
- pix = image + row*width + col;
- hex = allhex[row % 3][col % 3][0];
- if (!max) FORC(6) {
- val = pix[hex[c]][1];
- if (min > val) min = val;
- if (max < val) max = val;
- }
- pix[0][1] = min;
- pix[0][3] = max;
- switch ((row-sgrow) % 3) {
- case 1: if (row < height-3) { row++; col--; } break;
- case 2: if ((min=~(max=0)) && (col+=2) < width-3 && row > 2) row--;
- }
- }
-
- for (top=3; top < height-19; top += TS-16)
- for (left=3; left < width-19; left += TS-16) {
- mrow = MIN (top+TS, height-3);
- mcol = MIN (left+TS, width-3);
- for (row=top; row < mrow; row++)
- for (col=left; col < mcol; col++)
- memcpy (rgb[0][row-top][col-left], image[row*width+col], 6);
- FORC3 memcpy (rgb[c+1], rgb[0], sizeof *rgb);
-
-/* Interpolate green horizontally, vertically, and along both diagonals: */
- for (row=top; row < mrow; row++)
- for (col=left; col < mcol; col++) {
- if ((f = fcol(row,col)) == 1) continue;
- pix = image + row*width + col;
- hex = allhex[row % 3][col % 3][0];
- color[1][0] = 174 * (pix[ hex[1]][1] + pix[ hex[0]][1]) -
- 46 * (pix[2*hex[1]][1] + pix[2*hex[0]][1]);
- color[1][1] = 223 * pix[ hex[3]][1] + pix[ hex[2]][1] * 33 +
- 92 * (pix[ 0 ][f] - pix[ -hex[2]][f]);
- FORC(2) color[1][2+c] =
- 164 * pix[hex[4+c]][1] + 92 * pix[-2*hex[4+c]][1] + 33 *
- (2*pix[0][f] - pix[3*hex[4+c]][f] - pix[-3*hex[4+c]][f]);
- FORC4 rgb[c^!((row-sgrow) % 3)][row-top][col-left][1] =
- LIM(color[1][c] >> 8,pix[0][1],pix[0][3]);
- }
-
- for (pass=0; pass < passes; pass++) {
- if (pass == 1)
- memcpy (rgb+=4, buffer, 4*sizeof *rgb);
-
-/* Recalculate green from interpolated values of closer pixels: */
- if (pass) {
- for (row=top+2; row < mrow-2; row++)
- for (col=left+2; col < mcol-2; col++) {
- if ((f = fcol(row,col)) == 1) continue;
- pix = image + row*width + col;
- hex = allhex[row % 3][col % 3][1];
- for (d=3; d < 6; d++) {
- rix = &rgb[(d-2)^!((row-sgrow) % 3)][row-top][col-left];
- val = rix[-2*hex[d]][1] + 2*rix[hex[d]][1]
- - rix[-2*hex[d]][f] - 2*rix[hex[d]][f] + 3*rix[0][f];
- rix[0][1] = LIM(val/3,pix[0][1],pix[0][3]);
- }
- }
- }
-
-/* Interpolate red and blue values for solitary green pixels: */
- for (row=(top-sgrow+4)/3*3+sgrow; row < mrow-2; row+=3)
- for (col=(left-sgcol+4)/3*3+sgcol; col < mcol-2; col+=3) {
- rix = &rgb[0][row-top][col-left];
- h = fcol(row,col+1);
- memset (diff, 0, sizeof diff);
- for (i=1, d=0; d < 6; d++, i^=TS^1, h^=2) {
- for (c=0; c < 2; c++, h^=2) {
- g = 2*rix[0][1] - rix[i< 1)
- diff[d] += SQR (rix[i< 1 && (d & 1))
- if (diff[d-1] < diff[d])
- FORC(2) color[c*2][d] = color[c*2][d-1];
- if (d < 2 || (d & 1)) {
- FORC(2) rix[0][c*2] = CLIP(color[c*2][d]/2);
- rix += TS*TS;
- }
- }
- }
-
-/* Interpolate red for blue pixels and vice versa: */
- for (row=top+3; row < mrow-3; row++)
- for (col=left+3; col < mcol-3; col++) {
- if ((f = 2-fcol(row,col)) == 1) continue;
- rix = &rgb[0][row-top][col-left];
- c = (row-sgrow) % 3 ? TS:1;
- h = 3 * (c ^ TS ^ 1);
- for (d=0; d < 4; d++, rix += TS*TS) {
- i = d > 1 || ((d ^ c) & 1) ||
- ((ABS(rix[0][1]-rix[c][1])+ABS(rix[0][1]-rix[-c][1])) <
- 2*(ABS(rix[0][1]-rix[h][1])+ABS(rix[0][1]-rix[-h][1]))) ? c:h;
- rix[0][f] = CLIP((rix[i][f] + rix[-i][f] +
- 2*rix[0][1] - rix[i][1] - rix[-i][1])/2);
- }
- }
-
-/* Fill in red and blue for 2x2 blocks of green: */
- for (row=top+2; row < mrow-2; row++) if ((row-sgrow) % 3)
- for (col=left+2; col < mcol-2; col++) if ((col-sgcol) % 3) {
- rix = &rgb[0][row-top][col-left];
- hex = allhex[row % 3][col % 3][1];
- for (d=0; d < ndir; d+=2, rix += TS*TS)
- if (hex[d] + hex[d+1]) {
- g = 3*rix[0][1] - 2*rix[hex[d]][1] - rix[hex[d+1]][1];
- for (c=0; c < 4; c+=2) rix[0][c] =
- CLIP((g + 2*rix[hex[d]][c] + rix[hex[d+1]][c])/3);
- } else {
- g = 2*rix[0][1] - rix[hex[d]][1] - rix[hex[d+1]][1];
- for (c=0; c < 4; c+=2) rix[0][c] =
- CLIP((g + rix[hex[d]][c] + rix[hex[d+1]][c])/2);
- }
- }
- }
- rgb = (ushort(*)[TS][TS][3]) buffer;
- mrow -= top;
- mcol -= left;
-
-/* Convert to CIELab and differentiate in all directions: */
- for (d=0; d < ndir; d++) {
- for (row=2; row < mrow-2; row++)
- for (col=2; col < mcol-2; col++)
- cielab (rgb[d][row][col], lab[row][col]);
- for (f=dir[d & 3],row=3; row < mrow-3; row++)
- for (col=3; col < mcol-3; col++) {
- lix = &lab[row][col];
- g = 2*lix[0][0] - lix[f][0] - lix[-f][0];
- drv[d][row][col] = SQR(g)
- + SQR((2*lix[0][1] - lix[f][1] - lix[-f][1] + g*500/232))
- + SQR((2*lix[0][2] - lix[f][2] - lix[-f][2] - g*500/580));
- }
- }
-
-/* Build homogeneity maps from the derivatives: */
- memset(homo, 0, ndir*TS*TS);
- for (row=4; row < mrow-4; row++)
- for (col=4; col < mcol-4; col++) {
- for (tr=FLT_MAX, d=0; d < ndir; d++)
- if (tr > drv[d][row][col])
- tr = drv[d][row][col];
- tr *= 8;
- for (d=0; d < ndir; d++)
- for (v=-1; v <= 1; v++)
- for (h=-1; h <= 1; h++)
- if (drv[d][row+v][col+h] <= tr)
- homo[d][row][col]++;
- }
-
-/* Average the most homogenous pixels for the final result: */
- if (height-top < TS+4) mrow = height-top+2;
- if (width-left < TS+4) mcol = width-left+2;
- for (row = MIN(top,8); row < mrow-8; row++)
- for (col = MIN(left,8); col < mcol-8; col++) {
- for (d=0; d < ndir; d++)
- for (hm[d]=0, v=-2; v <= 2; v++)
- for (h=-2; h <= 2; h++)
- hm[d] += homo[d][row+v][col+h];
- for (d=0; d < ndir-4; d++)
- if (hm[d] < hm[d+4]) hm[d ] = 0; else
- if (hm[d] > hm[d+4]) hm[d+4] = 0;
- for (max=hm[0],d=1; d < ndir; d++)
- if (max < hm[d]) max = hm[d];
- max -= max >> 3;
- memset (avg, 0, sizeof avg);
- for (d=0; d < ndir; d++)
- if (hm[d] >= max) {
- FORC3 avg[c] += rgb[d][row][col][c];
- avg[3]++;
- }
- FORC3 image[(row+top)*width+col+left][c] = avg[c]/avg[3];
- }
- }
- free(buffer);
- border_interpolate(8);
-}
-#undef fcol
-
-
-#undef TS
-
-void CLASS median_filter()
-{
- ushort (*pix)[4];
- int pass, c, i, j, k, med[9];
- static const uchar opt[] = /* Optimal 9-element median search */
- { 1,2, 4,5, 7,8, 0,1, 3,4, 6,7, 1,2, 4,5, 7,8,
- 0,3, 5,8, 4,7, 3,6, 1,4, 2,5, 4,7, 4,2, 6,4, 4,2 };
-
- for (pass=1; pass <= med_passes; pass++) {
- if (verbose)
- fprintf (stderr,_("Median filter pass %d...\n"), pass);
- for (c=0; c < 3; c+=2) {
- for (pix = image; pix < image+width*height; pix++)
- pix[0][3] = pix[0][c];
- for (pix = image+width; pix < image+width*(height-1); pix++) {
- if ((pix-image+1) % width < 2) continue;
- for (k=0, i = -width; i <= width; i += width)
- for (j = i-1; j <= i+1; j++)
- med[k++] = pix[j][3] - pix[j][1];
- for (i=0; i < sizeof opt; i+=2)
- if (med[opt[i]] > med[opt[i+1]])
- SWAP (med[opt[i]] , med[opt[i+1]]);
- pix[0][c] = CLIP(med[4] + pix[0][1]);
- }
- }
- }
-}
-
-void CLASS blend_highlights()
-{
- int clip=INT_MAX, row, col, c, i, j;
- static const float trans[2][4][4] =
- { { { 1,1,1 }, { 1.7320508,-1.7320508,0 }, { -1,-1,2 } },
- { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
- static const float itrans[2][4][4] =
- { { { 1,0.8660254,-0.5 }, { 1,-0.8660254,-0.5 }, { 1,0,1 } },
- { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
- float cam[2][4], lab[2][4], sum[2], chratio;
-
- if ((unsigned) (colors-3) > 1) return;
- if (verbose) fprintf (stderr,_("Blending highlights...\n"));
- FORCC if (clip > (i = 65535*pre_mul[c])) clip = i;
- for (row=0; row < height; row++)
- for (col=0; col < width; col++) {
- FORCC if (image[row*width+col][c] > clip) break;
- if (c == colors) continue;
- FORCC {
- cam[0][c] = image[row*width+col][c];
- cam[1][c] = MIN(cam[0][c],clip);
- }
- for (i=0; i < 2; i++) {
- FORCC for (lab[i][c]=j=0; j < colors; j++)
- lab[i][c] += trans[colors-3][c][j] * cam[i][j];
- for (sum[i]=0,c=1; c < colors; c++)
- sum[i] += SQR(lab[i][c]);
- }
- chratio = sqrt(sum[1]/sum[0]);
- for (c=1; c < colors; c++)
- lab[0][c] *= chratio;
- FORCC for (cam[0][c]=j=0; j < colors; j++)
- cam[0][c] += itrans[colors-3][c][j] * lab[0][j];
- FORCC image[row*width+col][c] = cam[0][c] / colors;
- }
-}
-
-#define SCALE (4 >> shrink)
-void CLASS recover_highlights()
-{
- float *map, sum, wgt, grow;
- int hsat[4], count, spread, change, val, i;
- unsigned high, wide, mrow, mcol, row, col, kc, c, d, y, x;
- ushort *pixel;
- static const signed char dir[8][2] =
- { {-1,-1}, {-1,0}, {-1,1}, {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1} };
-
- if (verbose) fprintf (stderr,_("Rebuilding highlights...\n"));
-
- grow = pow (2, 4-highlight);
- FORCC hsat[c] = 32000 * pre_mul[c];
- for (kc=0, c=1; c < colors; c++)
- if (pre_mul[kc] < pre_mul[c]) kc = c;
- high = height / SCALE;
- wide = width / SCALE;
- map = (float *) calloc (high, wide*sizeof *map);
- merror (map, "recover_highlights()");
- FORCC if (c != kc) {
- memset (map, 0, high*wide*sizeof *map);
- for (mrow=0; mrow < high; mrow++)
- for (mcol=0; mcol < wide; mcol++) {
- sum = wgt = count = 0;
- for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
- for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
- pixel = image[row*width+col];
- if (pixel[c] / hsat[c] == 1 && pixel[kc] > 24000) {
- sum += pixel[c];
- wgt += pixel[kc];
- count++;
- }
- }
- if (count == SCALE*SCALE)
- map[mrow*wide+mcol] = sum / wgt;
- }
- for (spread = 32/grow; spread--; ) {
- for (mrow=0; mrow < high; mrow++)
- for (mcol=0; mcol < wide; mcol++) {
- if (map[mrow*wide+mcol]) continue;
- sum = count = 0;
- for (d=0; d < 8; d++) {
- y = mrow + dir[d][0];
- x = mcol + dir[d][1];
- if (y < high && x < wide && map[y*wide+x] > 0) {
- sum += (1 + (d & 1)) * map[y*wide+x];
- count += 1 + (d & 1);
- }
- }
- if (count > 3)
- map[mrow*wide+mcol] = - (sum+grow) / (count+grow);
- }
- for (change=i=0; i < high*wide; i++)
- if (map[i] < 0) {
- map[i] = -map[i];
- change = 1;
- }
- if (!change) break;
- }
- for (i=0; i < high*wide; i++)
- if (map[i] == 0) map[i] = 1;
- for (mrow=0; mrow < high; mrow++)
- for (mcol=0; mcol < wide; mcol++) {
- for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
- for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
- pixel = image[row*width+col];
- if (pixel[c] / hsat[c] > 1) {
- val = pixel[kc] * map[mrow*wide+mcol];
- if (pixel[c] < val) pixel[c] = CLIP(val);
- }
- }
- }
- }
- free (map);
-}
-#undef SCALE
+//void CLASS median_filter()
+//{
+// ushort (*pix)[4];
+// int pass, c, i, j, k, med[9];
+// static const uchar opt[] = /* Optimal 9-element median search */
+// { 1,2, 4,5, 7,8, 0,1, 3,4, 6,7, 1,2, 4,5, 7,8,
+// 0,3, 5,8, 4,7, 3,6, 1,4, 2,5, 4,7, 4,2, 6,4, 4,2 };
+//
+// for (pass=1; pass <= med_passes; pass++) {
+// if (verbose)
+// fprintf (stderr,_("Median filter pass %d...\n"), pass);
+// for (c=0; c < 3; c+=2) {
+// for (pix = image; pix < image+width*height; pix++)
+// pix[0][3] = pix[0][c];
+// for (pix = image+width; pix < image+width*(height-1); pix++) {
+// if ((pix-image+1) % width < 2) continue;
+// for (k=0, i = -width; i <= width; i += width)
+// for (j = i-1; j <= i+1; j++)
+// med[k++] = pix[j][3] - pix[j][1];
+// for (i=0; i < sizeof opt; i+=2)
+// if (med[opt[i]] > med[opt[i+1]])
+// SWAP (med[opt[i]] , med[opt[i+1]]);
+// pix[0][c] = CLIP(med[4] + pix[0][1]);
+// }
+// }
+// }
+//}
+//
+//void CLASS blend_highlights()
+//{
+// int clip=INT_MAX, row, col, c, i, j;
+// static const float trans[2][4][4] =
+// { { { 1,1,1 }, { 1.7320508,-1.7320508,0 }, { -1,-1,2 } },
+// { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
+// static const float itrans[2][4][4] =
+// { { { 1,0.8660254,-0.5 }, { 1,-0.8660254,-0.5 }, { 1,0,1 } },
+// { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
+// float cam[2][4], lab[2][4], sum[2], chratio;
+//
+// if ((unsigned) (colors-3) > 1) return;
+// if (verbose) fprintf (stderr,_("Blending highlights...\n"));
+// FORCC if (clip > (i = 65535*pre_mul[c])) clip = i;
+// for (row=0; row < height; row++)
+// for (col=0; col < width; col++) {
+// FORCC if (image[row*width+col][c] > clip) break;
+// if (c == colors) continue;
+// FORCC {
+// cam[0][c] = image[row*width+col][c];
+// cam[1][c] = MIN(cam[0][c],clip);
+// }
+// for (i=0; i < 2; i++) {
+// FORCC for (lab[i][c]=j=0; j < colors; j++)
+// lab[i][c] += trans[colors-3][c][j] * cam[i][j];
+// for (sum[i]=0,c=1; c < colors; c++)
+// sum[i] += SQR(lab[i][c]);
+// }
+// chratio = sqrt(sum[1]/sum[0]);
+// for (c=1; c < colors; c++)
+// lab[0][c] *= chratio;
+// FORCC for (cam[0][c]=j=0; j < colors; j++)
+// cam[0][c] += itrans[colors-3][c][j] * lab[0][j];
+// FORCC image[row*width+col][c] = cam[0][c] / colors;
+// }
+//}
+//
+//#define SCALE (4 >> shrink)
+//void CLASS recover_highlights()
+//{
+// float *map, sum, wgt, grow;
+// int hsat[4], count, spread, change, val, i;
+// unsigned high, wide, mrow, mcol, row, col, kc, c, d, y, x;
+// ushort *pixel;
+// static const signed char dir[8][2] =
+// { {-1,-1}, {-1,0}, {-1,1}, {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1} };
+//
+// if (verbose) fprintf (stderr,_("Rebuilding highlights...\n"));
+//
+// grow = pow (2, 4-highlight);
+// FORCC hsat[c] = 32000 * pre_mul[c];
+// for (kc=0, c=1; c < colors; c++)
+// if (pre_mul[kc] < pre_mul[c]) kc = c;
+// high = height / SCALE;
+// wide = width / SCALE;
+// map = (float *) calloc (high, wide*sizeof *map);
+// merror (map, "recover_highlights()");
+// FORCC if (c != kc) {
+// memset (map, 0, high*wide*sizeof *map);
+// for (mrow=0; mrow < high; mrow++)
+// for (mcol=0; mcol < wide; mcol++) {
+// sum = wgt = count = 0;
+// for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
+// for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
+// pixel = image[row*width+col];
+// if (pixel[c] / hsat[c] == 1 && pixel[kc] > 24000) {
+// sum += pixel[c];
+// wgt += pixel[kc];
+// count++;
+// }
+// }
+// if (count == SCALE*SCALE)
+// map[mrow*wide+mcol] = sum / wgt;
+// }
+// for (spread = 32/grow; spread--; ) {
+// for (mrow=0; mrow < high; mrow++)
+// for (mcol=0; mcol < wide; mcol++) {
+// if (map[mrow*wide+mcol]) continue;
+// sum = count = 0;
+// for (d=0; d < 8; d++) {
+// y = mrow + dir[d][0];
+// x = mcol + dir[d][1];
+// if (y < high && x < wide && map[y*wide+x] > 0) {
+// sum += (1 + (d & 1)) * map[y*wide+x];
+// count += 1 + (d & 1);
+// }
+// }
+// if (count > 3)
+// map[mrow*wide+mcol] = - (sum+grow) / (count+grow);
+// }
+// for (change=i=0; i < high*wide; i++)
+// if (map[i] < 0) {
+// map[i] = -map[i];
+// change = 1;
+// }
+// if (!change) break;
+// }
+// for (i=0; i < high*wide; i++)
+// if (map[i] == 0) map[i] = 1;
+// for (mrow=0; mrow < high; mrow++)
+// for (mcol=0; mcol < wide; mcol++) {
+// for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
+// for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
+// pixel = image[row*width+col];
+// if (pixel[c] / hsat[c] > 1) {
+// val = pixel[kc] * map[mrow*wide+mcol];
+// if (pixel[c] < val) pixel[c] = CLIP(val);
+// }
+// }
+// }
+// }
+// free (map);
+//}
+//#undef SCALE
void CLASS tiff_get (unsigned base,
unsigned *tag, unsigned *type, unsigned *len, unsigned *save)
@@ -9533,55 +9533,55 @@ notraw:
if (flip == UINT_MAX) flip = 0;
}
-#ifndef NO_LCMS
-void CLASS apply_profile (const char *input, const char *output)
-{
- char *prof;
- cmsHPROFILE hInProfile=0, hOutProfile=0;
- cmsHTRANSFORM hTransform;
- FILE *fp;
- unsigned size;
-
- if (strcmp (input, "embed"))
- hInProfile = cmsOpenProfileFromFile (input, "r");
- else if (profile_length) {
- prof = (char *) malloc (profile_length);
- merror (prof, "apply_profile()");
- fseek (ifp, profile_offset, SEEK_SET);
- fread (prof, 1, profile_length, ifp);
- hInProfile = cmsOpenProfileFromMem (prof, profile_length);
- free (prof);
- } else
- fprintf (stderr,_("%s has no embedded profile.\n"), ifname);
- if (!hInProfile) return;
- if (!output)
- hOutProfile = cmsCreate_sRGBProfile();
- else if ((fp = fopen (output, "rb"))) {
- fread (&size, 4, 1, fp);
- fseek (fp, 0, SEEK_SET);
- oprof = (unsigned *) malloc (size = ntohl(size));
- merror (oprof, "apply_profile()");
- fread (oprof, 1, size, fp);
- fclose (fp);
- if (!(hOutProfile = cmsOpenProfileFromMem (oprof, size))) {
- free (oprof);
- oprof = 0;
- }
- } else
- fprintf (stderr,_("Cannot open file %s!\n"), output);
- if (!hOutProfile) goto quit;
- if (verbose)
- fprintf (stderr,_("Applying color profile...\n"));
- hTransform = cmsCreateTransform (hInProfile, TYPE_RGBA_16,
- hOutProfile, TYPE_RGBA_16, INTENT_PERCEPTUAL, 0);
- cmsDoTransform (hTransform, image, image, width*height);
- raw_color = 1; /* Don't use rgb_cam with a profile */
- cmsDeleteTransform (hTransform);
- cmsCloseProfile (hOutProfile);
-quit:
- cmsCloseProfile (hInProfile);
-}
-#endif
+//#ifndef NO_LCMS
+//void CLASS apply_profile (const char *input, const char *output)
+//{
+// char *prof;
+// cmsHPROFILE hInProfile=0, hOutProfile=0;
+// cmsHTRANSFORM hTransform;
+// FILE *fp;
+// unsigned size;
+//
+// if (strcmp (input, "embed"))
+// hInProfile = cmsOpenProfileFromFile (input, "r");
+// else if (profile_length) {
+// prof = (char *) malloc (profile_length);
+// merror (prof, "apply_profile()");
+// fseek (ifp, profile_offset, SEEK_SET);
+// fread (prof, 1, profile_length, ifp);
+// hInProfile = cmsOpenProfileFromMem (prof, profile_length);
+// free (prof);
+// } else
+// fprintf (stderr,_("%s has no embedded profile.\n"), ifname);
+// if (!hInProfile) return;
+// if (!output)
+// hOutProfile = cmsCreate_sRGBProfile();
+// else if ((fp = fopen (output, "rb"))) {
+// fread (&size, 4, 1, fp);
+// fseek (fp, 0, SEEK_SET);
+// oprof = (unsigned *) malloc (size = ntohl(size));
+// merror (oprof, "apply_profile()");
+// fread (oprof, 1, size, fp);
+// fclose (fp);
+// if (!(hOutProfile = cmsOpenProfileFromMem (oprof, size))) {
+// free (oprof);
+// oprof = 0;
+// }
+// } else
+// fprintf (stderr,_("Cannot open file %s!\n"), output);
+// if (!hOutProfile) goto quit;
+// if (verbose)
+// fprintf (stderr,_("Applying color profile...\n"));
+// hTransform = cmsCreateTransform (hInProfile, TYPE_RGBA_16,
+// hOutProfile, TYPE_RGBA_16, INTENT_PERCEPTUAL, 0);
+// cmsDoTransform (hTransform, image, image, width*height);
+// raw_color = 1; /* Don't use rgb_cam with a profile */
+// cmsDeleteTransform (hTransform);
+// cmsCloseProfile (hOutProfile);
+//quit:
+// cmsCloseProfile (hInProfile);
+//}
+//#endif
/* RT: DNG Float */
diff --git a/rtengine/dcraw.h b/rtengine/dcraw.h
index 666b4276f..9d15a5826 100644
--- a/rtengine/dcraw.h
+++ b/rtengine/dcraw.h
@@ -43,14 +43,14 @@ public:
:exif_base(-1)
,ciff_base(-1)
,ciff_len(0)
- ,ifp(nullptr),ofp(nullptr)
+ ,ifp(NULL),ofp(NULL)
,order(0x4949)
- ,ifname(nullptr)
- ,meta_data(nullptr)
+ ,ifname(NULL)
+ ,meta_data(NULL)
,shot_select(0),multi_out(0)
- ,float_raw_image(nullptr)
- ,image(nullptr)
- ,bright(1.),threshold(0.)
+ ,float_raw_image(NULL)
+ ,image(NULL)
+ ,bright(1.)
,half_size(0),four_color_rgb(0),document_mode(0),highlight(0)
,verbose(0)
,use_auto_wb(0),use_camera_wb(0),use_camera_matrix(1)
@@ -344,23 +344,23 @@ void foveon_make_curves(short **curvep, float dq[3], float div[3], float filt);
int foveon_apply_curve (short *curve, int i);
void foveon_interpolate();
-void xtrans_interpolate (int passes);
-void cielab (ushort rgb[3], short lab[3]);
+//void xtrans_interpolate (int passes);
+//void cielab (ushort rgb[3], short lab[3]);
-void remove_zeroes();
-void bad_pixels (const char *cfname);
-void subtract (const char *fname);
+//void remove_zeroes();
+//void bad_pixels (const char *cfname);
+//void subtract (const char *fname);
void gamma_curve (double pwr, double ts, int mode, int imax);
void pseudoinverse (double (*in)[3], double (*out)[3], int size);
void cam_xyz_coeff (float rgb_cam[3][4], double cam_xyz[4][3]);
-void hat_transform (float *temp, float *base, int st, int size, int sc);
-void wavelet_denoise();
+//void hat_transform (float *temp, float *base, int st, int size, int sc);
+//void wavelet_denoise();
void scale_colors();
void pre_interpolate();
-void border_interpolate (int border);
-void median_filter();
-void blend_highlights();
-void recover_highlights();
+//void border_interpolate (int border);
+//void median_filter();
+//void blend_highlights();
+//void recover_highlights();
void crop_masked_pixels();
void tiff_get (unsigned base, unsigned *tag, unsigned *type, unsigned *len, unsigned *save);
@@ -397,7 +397,6 @@ void simple_coeff (int index);
short guess_byte_order (int words);
float find_green (int bps, int bite, int off0, int off1);
void identify();
-void apply_profile (const char *input, const char *output);
void jpeg_thumb() {} // not needed
bool dcraw_coeff_overrides(const char make[], const char model[], int iso_speed, short trans[12], int *black_level, int *white_level);
void shiftXtransMatrix( const int offsy, const int offsx) {
diff --git a/rtengine/dcraw.patch b/rtengine/dcraw.patch
index 82f2ec9b8..e23136d68 100644
--- a/rtengine/dcraw.patch
+++ b/rtengine/dcraw.patch
@@ -1,5 +1,5 @@
---- dcraw.c 2016-09-30 21:19:28.312191811 +0200
-+++ dcraw.cc 2016-09-30 22:41:28.157442526 +0200
+--- dcraw.c 2016-10-11 13:24:24 +0000
++++ dcraw.cc 2016-10-17 19:32:24 +0000
@@ -1,3 +1,16 @@
+/*RT*/#include
+/*RT*/#include
@@ -833,10 +833,468 @@
if (mask[0][3] > 0) goto mask_set;
if (load_raw == &CLASS canon_load_raw ||
load_raw == &CLASS lossless_jpeg_load_raw) {
-@@ -4366,239 +4690,8 @@
- }
+@@ -3808,127 +4132,127 @@
+ }
}
+-void CLASS remove_zeroes()
+-{
+- unsigned row, col, tot, n, r, c;
+-
+- for (row=0; row < height; row++)
+- for (col=0; col < width; col++)
+- if (BAYER(row,col) == 0) {
+- tot = n = 0;
+- for (r = row-2; r <= row+2; r++)
+- for (c = col-2; c <= col+2; c++)
+- if (r < height && c < width &&
+- FC(r,c) == FC(row,col) && BAYER(r,c))
+- tot += (n++,BAYER(r,c));
+- if (n) BAYER(row,col) = tot/n;
+- }
+-}
++//void CLASS remove_zeroes()
++//{
++// unsigned row, col, tot, n, r, c;
++//
++// for (row=0; row < height; row++)
++// for (col=0; col < width; col++)
++// if (BAYER(row,col) == 0) {
++// tot = n = 0;
++// for (r = row-2; r <= row+2; r++)
++// for (c = col-2; c <= col+2; c++)
++// if (r < height && c < width &&
++// FC(r,c) == FC(row,col) && BAYER(r,c))
++// tot += (n++,BAYER(r,c));
++// if (n) BAYER(row,col) = tot/n;
++// }
++//}
+
+ /*
+ Seach from the current directory up to the root looking for
+ a ".badpixels" file, and fix those pixels now.
+ */
+-void CLASS bad_pixels (const char *cfname)
+-{
+- FILE *fp=0;
+- char *fname, *cp, line[128];
+- int len, time, row, col, r, c, rad, tot, n, fixed=0;
+-
+- if (!filters) return;
+- if (cfname)
+- fp = fopen (cfname, "r");
+- else {
+- for (len=32 ; ; len *= 2) {
+- fname = (char *) malloc (len);
+- if (!fname) return;
+- if (getcwd (fname, len-16)) break;
+- free (fname);
+- if (errno != ERANGE) return;
+- }
+-#if defined(WIN32) || defined(DJGPP)
+- if (fname[1] == ':')
+- memmove (fname, fname+2, len-2);
+- for (cp=fname; *cp; cp++)
+- if (*cp == '\\') *cp = '/';
+-#endif
+- cp = fname + strlen(fname);
+- if (cp[-1] == '/') cp--;
+- while (*fname == '/') {
+- strcpy (cp, "/.badpixels");
+- if ((fp = fopen (fname, "r"))) break;
+- if (cp == fname) break;
+- while (*--cp != '/');
+- }
+- free (fname);
+- }
+- if (!fp) return;
+- while (fgets (line, 128, fp)) {
+- cp = strchr (line, '#');
+- if (cp) *cp = 0;
+- if (sscanf (line, "%d %d %d", &col, &row, &time) != 3) continue;
+- if ((unsigned) col >= width || (unsigned) row >= height) continue;
+- if (time > timestamp) continue;
+- for (tot=n=0, rad=1; rad < 3 && n==0; rad++)
+- for (r = row-rad; r <= row+rad; r++)
+- for (c = col-rad; c <= col+rad; c++)
+- if ((unsigned) r < height && (unsigned) c < width &&
+- (r != row || c != col) && fcol(r,c) == fcol(row,col)) {
+- tot += BAYER2(r,c);
+- n++;
+- }
+- BAYER2(row,col) = tot/n;
+- if (verbose) {
+- if (!fixed++)
+- fprintf (stderr,_("Fixed dead pixels at:"));
+- fprintf (stderr, " %d,%d", col, row);
+- }
+- }
+- if (fixed) fputc ('\n', stderr);
+- fclose (fp);
+-}
+-
+-void CLASS subtract (const char *fname)
+-{
+- FILE *fp;
+- int dim[3]={0,0,0}, comment=0, number=0, error=0, nd=0, c, row, col;
+- ushort *pixel;
+-
+- if (!(fp = fopen (fname, "rb"))) {
+- perror (fname); return;
+- }
+- if (fgetc(fp) != 'P' || fgetc(fp) != '5') error = 1;
+- while (!error && nd < 3 && (c = fgetc(fp)) != EOF) {
+- if (c == '#') comment = 1;
+- if (c == '\n') comment = 0;
+- if (comment) continue;
+- if (isdigit(c)) number = 1;
+- if (number) {
+- if (isdigit(c)) dim[nd] = dim[nd]*10 + c -'0';
+- else if (isspace(c)) {
+- number = 0; nd++;
+- } else error = 1;
+- }
+- }
+- if (error || nd < 3) {
+- fprintf (stderr,_("%s is not a valid PGM file!\n"), fname);
+- fclose (fp); return;
+- } else if (dim[0] != width || dim[1] != height || dim[2] != 65535) {
+- fprintf (stderr,_("%s has the wrong dimensions!\n"), fname);
+- fclose (fp); return;
+- }
+- pixel = (ushort *) calloc (width, sizeof *pixel);
+- merror (pixel, "subtract()");
+- for (row=0; row < height; row++) {
+- fread (pixel, 2, width, fp);
+- for (col=0; col < width; col++)
+- BAYER(row,col) = MAX (BAYER(row,col) - ntohs(pixel[col]), 0);
+- }
+- free (pixel);
+- fclose (fp);
+- memset (cblack, 0, sizeof cblack);
+- black = 0;
+-}
++//void CLASS bad_pixels (const char *cfname)
++//{
++// FILE *fp=0;
++// char *fname, *cp, line[128];
++// int len, time, row, col, r, c, rad, tot, n, fixed=0;
++//
++// if (!filters) return;
++// if (cfname)
++// fp = fopen (cfname, "r");
++// else {
++// for (len=32 ; ; len *= 2) {
++// fname = (char *) malloc (len);
++// if (!fname) return;
++// if (getcwd (fname, len-16)) break;
++// free (fname);
++// if (errno != ERANGE) return;
++// }
++//#if defined(WIN32) || defined(DJGPP)
++// if (fname[1] == ':')
++// memmove (fname, fname+2, len-2);
++// for (cp=fname; *cp; cp++)
++// if (*cp == '\\') *cp = '/';
++//#endif
++// cp = fname + strlen(fname);
++// if (cp[-1] == '/') cp--;
++// while (*fname == '/') {
++// strcpy (cp, "/.badpixels");
++// if ((fp = fopen (fname, "r"))) break;
++// if (cp == fname) break;
++// while (*--cp != '/');
++// }
++// free (fname);
++// }
++// if (!fp) return;
++// while (fgets (line, 128, fp)) {
++// cp = strchr (line, '#');
++// if (cp) *cp = 0;
++// if (sscanf (line, "%d %d %d", &col, &row, &time) != 3) continue;
++// if ((unsigned) col >= width || (unsigned) row >= height) continue;
++// if (time > timestamp) continue;
++// for (tot=n=0, rad=1; rad < 3 && n==0; rad++)
++// for (r = row-rad; r <= row+rad; r++)
++// for (c = col-rad; c <= col+rad; c++)
++// if ((unsigned) r < height && (unsigned) c < width &&
++// (r != row || c != col) && fcol(r,c) == fcol(row,col)) {
++// tot += BAYER2(r,c);
++// n++;
++// }
++// BAYER2(row,col) = tot/n;
++// if (verbose) {
++// if (!fixed++)
++// fprintf (stderr,_("Fixed dead pixels at:"));
++// fprintf (stderr, " %d,%d", col, row);
++// }
++// }
++// if (fixed) fputc ('\n', stderr);
++// fclose (fp);
++//}
++
++//void CLASS subtract (const char *fname)
++//{
++// FILE *fp;
++// int dim[3]={0,0,0}, comment=0, number=0, error=0, nd=0, c, row, col;
++// ushort *pixel;
++//
++// if (!(fp = fopen (fname, "rb"))) {
++// perror (fname); return;
++// }
++// if (fgetc(fp) != 'P' || fgetc(fp) != '5') error = 1;
++// while (!error && nd < 3 && (c = fgetc(fp)) != EOF) {
++// if (c == '#') comment = 1;
++// if (c == '\n') comment = 0;
++// if (comment) continue;
++// if (isdigit(c)) number = 1;
++// if (number) {
++// if (isdigit(c)) dim[nd] = dim[nd]*10 + c -'0';
++// else if (isspace(c)) {
++// number = 0; nd++;
++// } else error = 1;
++// }
++// }
++// if (error || nd < 3) {
++// fprintf (stderr,_("%s is not a valid PGM file!\n"), fname);
++// fclose (fp); return;
++// } else if (dim[0] != width || dim[1] != height || dim[2] != 65535) {
++// fprintf (stderr,_("%s has the wrong dimensions!\n"), fname);
++// fclose (fp); return;
++// }
++// pixel = (ushort *) calloc (width, sizeof *pixel);
++// merror (pixel, "subtract()");
++// for (row=0; row < height; row++) {
++// fread (pixel, 2, width, fp);
++// for (col=0; col < width; col++)
++// BAYER(row,col) = MAX (BAYER(row,col) - ntohs(pixel[col]), 0);
++// }
++// free (pixel);
++// fclose (fp);
++// memset (cblack, 0, sizeof cblack);
++// black = 0;
++//}
+
+ void CLASS gamma_curve (double pwr, double ts, int mode, int imax)
+ {
+@@ -4093,94 +4417,94 @@
+ }
+ #endif
+
+-void CLASS hat_transform (float *temp, float *base, int st, int size, int sc)
+-{
+- int i;
+- for (i=0; i < sc; i++)
+- temp[i] = 2*base[st*i] + base[st*(sc-i)] + base[st*(i+sc)];
+- for (; i+sc < size; i++)
+- temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(i+sc)];
+- for (; i < size; i++)
+- temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(2*size-2-(i+sc))];
+-}
+-
+-void CLASS wavelet_denoise()
+-{
+- float *fimg=0, *temp, thold, mul[2], avg, diff;
+- int scale=1, size, lev, hpass, lpass, row, col, nc, c, i, wlast, blk[2];
+- ushort *window[4];
+- static const float noise[] =
+- { 0.8002,0.2735,0.1202,0.0585,0.0291,0.0152,0.0080,0.0044 };
+-
+- if (verbose) fprintf (stderr,_("Wavelet denoising...\n"));
+-
+- while (maximum << scale < 0x10000) scale++;
+- maximum <<= --scale;
+- black <<= scale;
+- FORC4 cblack[c] <<= scale;
+- if ((size = iheight*iwidth) < 0x15550000)
+- fimg = (float *) malloc ((size*3 + iheight + iwidth) * sizeof *fimg);
+- merror (fimg, "wavelet_denoise()");
+- temp = fimg + size*3;
+- if ((nc = colors) == 3 && filters) nc++;
+- FORC(nc) { /* denoise R,G1,B,G3 individually */
+- for (i=0; i < size; i++)
+- fimg[i] = 256 * sqrt(image[i][c] << scale);
+- for (hpass=lev=0; lev < 5; lev++) {
+- lpass = size*((lev & 1)+1);
+- for (row=0; row < iheight; row++) {
+- hat_transform (temp, fimg+hpass+row*iwidth, 1, iwidth, 1 << lev);
+- for (col=0; col < iwidth; col++)
+- fimg[lpass + row*iwidth + col] = temp[col] * 0.25;
+- }
+- for (col=0; col < iwidth; col++) {
+- hat_transform (temp, fimg+lpass+col, iwidth, iheight, 1 << lev);
+- for (row=0; row < iheight; row++)
+- fimg[lpass + row*iwidth + col] = temp[row] * 0.25;
+- }
+- thold = threshold * noise[lev];
+- for (i=0; i < size; i++) {
+- fimg[hpass+i] -= fimg[lpass+i];
+- if (fimg[hpass+i] < -thold) fimg[hpass+i] += thold;
+- else if (fimg[hpass+i] > thold) fimg[hpass+i] -= thold;
+- else fimg[hpass+i] = 0;
+- if (hpass) fimg[i] += fimg[hpass+i];
+- }
+- hpass = lpass;
+- }
+- for (i=0; i < size; i++)
+- image[i][c] = CLIP(SQR(fimg[i]+fimg[lpass+i])/0x10000);
+- }
+- if (filters && colors == 3) { /* pull G1 and G3 closer together */
+- for (row=0; row < 2; row++) {
+- mul[row] = 0.125 * pre_mul[FC(row+1,0) | 1] / pre_mul[FC(row,0) | 1];
+- blk[row] = cblack[FC(row,0) | 1];
+- }
+- for (i=0; i < 4; i++)
+- window[i] = (ushort *) fimg + width*i;
+- for (wlast=-1, row=1; row < height-1; row++) {
+- while (wlast < row+1) {
+- for (wlast++, i=0; i < 4; i++)
+- window[(i+3) & 3] = window[i];
+- for (col = FC(wlast,1) & 1; col < width; col+=2)
+- window[2][col] = BAYER(wlast,col);
+- }
+- thold = threshold/512;
+- for (col = (FC(row,0) & 1)+1; col < width-1; col+=2) {
+- avg = ( window[0][col-1] + window[0][col+1] +
+- window[2][col-1] + window[2][col+1] - blk[~row & 1]*4 )
+- * mul[row & 1] + (window[1][col] + blk[row & 1]) * 0.5;
+- avg = avg < 0 ? 0 : sqrt(avg);
+- diff = sqrt(BAYER(row,col)) - avg;
+- if (diff < -thold) diff += thold;
+- else if (diff > thold) diff -= thold;
+- else diff = 0;
+- BAYER(row,col) = CLIP(SQR(avg+diff) + 0.5);
+- }
+- }
+- }
+- free (fimg);
+-}
++//void CLASS hat_transform (float *temp, float *base, int st, int size, int sc)
++//{
++// int i;
++// for (i=0; i < sc; i++)
++// temp[i] = 2*base[st*i] + base[st*(sc-i)] + base[st*(i+sc)];
++// for (; i+sc < size; i++)
++// temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(i+sc)];
++// for (; i < size; i++)
++// temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(2*size-2-(i+sc))];
++//}
++
++//void CLASS wavelet_denoise()
++//{
++// float *fimg=0, *temp, thold, mul[2], avg, diff;
++// int scale=1, size, lev, hpass, lpass, row, col, nc, c, i, wlast, blk[2];
++// ushort *window[4];
++// static const float noise[] =
++// { 0.8002,0.2735,0.1202,0.0585,0.0291,0.0152,0.0080,0.0044 };
++//
++// if (verbose) fprintf (stderr,_("Wavelet denoising...\n"));
++//
++// while (maximum << scale < 0x10000) scale++;
++// maximum <<= --scale;
++// black <<= scale;
++// FORC4 cblack[c] <<= scale;
++// if ((size = iheight*iwidth) < 0x15550000)
++// fimg = (float *) malloc ((size*3 + iheight + iwidth) * sizeof *fimg);
++// merror (fimg, "wavelet_denoise()");
++// temp = fimg + size*3;
++// if ((nc = colors) == 3 && filters) nc++;
++// FORC(nc) { /* denoise R,G1,B,G3 individually */
++// for (i=0; i < size; i++)
++// fimg[i] = 256 * sqrt(image[i][c] << scale);
++// for (hpass=lev=0; lev < 5; lev++) {
++// lpass = size*((lev & 1)+1);
++// for (row=0; row < iheight; row++) {
++// hat_transform (temp, fimg+hpass+row*iwidth, 1, iwidth, 1 << lev);
++// for (col=0; col < iwidth; col++)
++// fimg[lpass + row*iwidth + col] = temp[col] * 0.25;
++// }
++// for (col=0; col < iwidth; col++) {
++// hat_transform (temp, fimg+lpass+col, iwidth, iheight, 1 << lev);
++// for (row=0; row < iheight; row++)
++// fimg[lpass + row*iwidth + col] = temp[row] * 0.25;
++// }
++// thold = threshold * noise[lev];
++// for (i=0; i < size; i++) {
++// fimg[hpass+i] -= fimg[lpass+i];
++// if (fimg[hpass+i] < -thold) fimg[hpass+i] += thold;
++// else if (fimg[hpass+i] > thold) fimg[hpass+i] -= thold;
++// else fimg[hpass+i] = 0;
++// if (hpass) fimg[i] += fimg[hpass+i];
++// }
++// hpass = lpass;
++// }
++// for (i=0; i < size; i++)
++// image[i][c] = CLIP(SQR(fimg[i]+fimg[lpass+i])/0x10000);
++// }
++// if (filters && colors == 3) { /* pull G1 and G3 closer together */
++// for (row=0; row < 2; row++) {
++// mul[row] = 0.125 * pre_mul[FC(row+1,0) | 1] / pre_mul[FC(row,0) | 1];
++// blk[row] = cblack[FC(row,0) | 1];
++// }
++// for (i=0; i < 4; i++)
++// window[i] = (ushort *) fimg + width*i;
++// for (wlast=-1, row=1; row < height-1; row++) {
++// while (wlast < row+1) {
++// for (wlast++, i=0; i < 4; i++)
++// window[(i+3) & 3] = window[i];
++// for (col = FC(wlast,1) & 1; col < width; col+=2)
++// window[2][col] = BAYER(wlast,col);
++// }
++// thold = threshold/512;
++// for (col = (FC(row,0) & 1)+1; col < width-1; col+=2) {
++// avg = ( window[0][col-1] + window[0][col+1] +
++// window[2][col-1] + window[2][col+1] - blk[~row & 1]*4 )
++// * mul[row & 1] + (window[1][col] + blk[row & 1]) * 0.5;
++// avg = avg < 0 ? 0 : sqrt(avg);
++// diff = sqrt(BAYER(row,col)) - avg;
++// if (diff < -thold) diff += thold;
++// else if (diff > thold) diff -= thold;
++// else diff = 0;
++// BAYER(row,col) = CLIP(SQR(avg+diff) + 0.5);
++// }
++// }
++// }
++// free (fimg);
++//}
+
+ void CLASS scale_colors()
+ {
+@@ -4238,7 +4562,7 @@
+ if (pre_mul[3] == 0) pre_mul[3] = colors < 4 ? pre_mul[1] : 1;
+ dark = black;
+ sat = maximum;
+- if (threshold) wavelet_denoise();
++// if (threshold) wavelet_denoise();
+ maximum -= black;
+ for (dmin=DBL_MAX, dmax=c=0; c < 4; c++) {
+ if (dmin > pre_mul[c])
+@@ -4344,776 +4668,440 @@
+ if (half_size) filters = 0;
+ }
+
+-void CLASS border_interpolate (int border)
+-{
+- unsigned row, col, y, x, f, c, sum[8];
+-
+- for (row=0; row < height; row++)
+- for (col=0; col < width; col++) {
+- if (col==border && row >= border && row < height-border)
+- col = width-border;
+- memset (sum, 0, sizeof sum);
+- for (y=row-1; y != row+2; y++)
+- for (x=col-1; x != col+2; x++)
+- if (y < height && x < width) {
+- f = fcol(y,x);
+- sum[f] += image[y*width+x][f];
+- sum[f+4]++;
+- }
+- f = fcol(row,col);
+- FORCC if (c != f && sum[c+4])
+- image[row*width+col][c] = sum[c] / sum[c+4];
+- }
+-}
+-
-void CLASS lin_interpolate()
-{
- int code[16][16][32], size=16, *ip, sum[4];
@@ -884,8 +1342,7 @@
- This algorithm is officially called:
-
- "Interpolation using a Threshold-based variable number of gradients"
-+/* RT: delete interpolation functions */
-
+-
- described in http://scien.stanford.edu/pages/labsite/1999/psych221/projects/99/tingchen/algodep/vargra.html
-
- I've extended the basic idea to work with non-Bayer filter arrays.
@@ -1071,13 +1528,271 @@
- pix[0][c] = CLIP((guess[0]+guess[1]) >> 2);
- }
-}
-
- void CLASS cielab (ushort rgb[3], short lab[3])
- {
-@@ -4864,112 +4957,7 @@
- }
- #undef fcol
-
+-
+-void CLASS cielab (ushort rgb[3], short lab[3])
+-{
+- int c, i, j, k;
+- float r, xyz[3];
+- static float cbrt[0x10000], xyz_cam[3][4];
+-
+- if (!rgb) {
+- for (i=0; i < 0x10000; i++) {
+- r = i / 65535.0;
+- cbrt[i] = r > 0.008856 ? pow(r,1/3.0) : 7.787*r + 16/116.0;
+- }
+- for (i=0; i < 3; i++)
+- for (j=0; j < colors; j++)
+- for (xyz_cam[i][j] = k=0; k < 3; k++)
+- xyz_cam[i][j] += xyz_rgb[i][k] * rgb_cam[k][j] / d65_white[i];
+- return;
+- }
+- xyz[0] = xyz[1] = xyz[2] = 0.5;
+- FORCC {
+- xyz[0] += xyz_cam[0][c] * rgb[c];
+- xyz[1] += xyz_cam[1][c] * rgb[c];
+- xyz[2] += xyz_cam[2][c] * rgb[c];
+- }
+- xyz[0] = cbrt[CLIP((int) xyz[0])];
+- xyz[1] = cbrt[CLIP((int) xyz[1])];
+- xyz[2] = cbrt[CLIP((int) xyz[2])];
+- lab[0] = 64 * (116 * xyz[1] - 16);
+- lab[1] = 64 * 500 * (xyz[0] - xyz[1]);
+- lab[2] = 64 * 200 * (xyz[1] - xyz[2]);
+-}
+-
+-#define TS 512 /* Tile Size */
+-#define fcol(row,col) xtrans[(row+6) % 6][(col+6) % 6]
+-
+-/*
+- Frank Markesteijn's algorithm for Fuji X-Trans sensors
+- */
+-void CLASS xtrans_interpolate (int passes)
+-{
+- int c, d, f, g, h, i, v, ng, row, col, top, left, mrow, mcol;
+- int val, ndir, pass, hm[8], avg[4], color[3][8];
+- static const short orth[12] = { 1,0,0,1,-1,0,0,-1,1,0,0,1 },
+- patt[2][16] = { { 0,1,0,-1,2,0,-1,0,1,1,1,-1,0,0,0,0 },
+- { 0,1,0,-2,1,0,-2,0,1,1,-2,-2,1,-1,-1,1 } },
+- dir[4] = { 1,TS,TS+1,TS-1 };
+- short allhex[3][3][2][8], *hex;
+- ushort min, max, sgrow, sgcol;
+- ushort (*rgb)[TS][TS][3], (*rix)[3], (*pix)[4];
+- short (*lab) [TS][3], (*lix)[3];
+- float (*drv)[TS][TS], diff[6], tr;
+- char (*homo)[TS][TS], *buffer;
+-
+- if (verbose)
+- fprintf (stderr,_("%d-pass X-Trans interpolation...\n"), passes);
+-
+- cielab (0,0);
+- ndir = 4 << (passes > 1);
+- buffer = (char *) malloc (TS*TS*(ndir*11+6));
+- merror (buffer, "xtrans_interpolate()");
+- rgb = (ushort(*)[TS][TS][3]) buffer;
+- lab = (short (*) [TS][3])(buffer + TS*TS*(ndir*6));
+- drv = (float (*)[TS][TS]) (buffer + TS*TS*(ndir*6+6));
+- homo = (char (*)[TS][TS]) (buffer + TS*TS*(ndir*10+6));
+-
+-/* Map a green hexagon around each non-green pixel and vice versa: */
+- for (row=0; row < 3; row++)
+- for (col=0; col < 3; col++)
+- for (ng=d=0; d < 10; d+=2) {
+- g = fcol(row,col) == 1;
+- if (fcol(row+orth[d],col+orth[d+2]) == 1) ng=0; else ng++;
+- if (ng == 4) { sgrow = row; sgcol = col; }
+- if (ng == g+1) FORC(8) {
+- v = orth[d ]*patt[g][c*2] + orth[d+1]*patt[g][c*2+1];
+- h = orth[d+2]*patt[g][c*2] + orth[d+3]*patt[g][c*2+1];
+- allhex[row][col][0][c^(g*2 & d)] = h + v*width;
+- allhex[row][col][1][c^(g*2 & d)] = h + v*TS;
+- }
+- }
+-
+-/* Set green1 and green3 to the minimum and maximum allowed values: */
+- for (row=2; row < height-2; row++)
+- for (min=~(max=0), col=2; col < width-2; col++) {
+- if (fcol(row,col) == 1 && (min=~(max=0))) continue;
+- pix = image + row*width + col;
+- hex = allhex[row % 3][col % 3][0];
+- if (!max) FORC(6) {
+- val = pix[hex[c]][1];
+- if (min > val) min = val;
+- if (max < val) max = val;
+- }
+- pix[0][1] = min;
+- pix[0][3] = max;
+- switch ((row-sgrow) % 3) {
+- case 1: if (row < height-3) { row++; col--; } break;
+- case 2: if ((min=~(max=0)) && (col+=2) < width-3 && row > 2) row--;
+- }
+- }
+-
+- for (top=3; top < height-19; top += TS-16)
+- for (left=3; left < width-19; left += TS-16) {
+- mrow = MIN (top+TS, height-3);
+- mcol = MIN (left+TS, width-3);
+- for (row=top; row < mrow; row++)
+- for (col=left; col < mcol; col++)
+- memcpy (rgb[0][row-top][col-left], image[row*width+col], 6);
+- FORC3 memcpy (rgb[c+1], rgb[0], sizeof *rgb);
+-
+-/* Interpolate green horizontally, vertically, and along both diagonals: */
+- for (row=top; row < mrow; row++)
+- for (col=left; col < mcol; col++) {
+- if ((f = fcol(row,col)) == 1) continue;
+- pix = image + row*width + col;
+- hex = allhex[row % 3][col % 3][0];
+- color[1][0] = 174 * (pix[ hex[1]][1] + pix[ hex[0]][1]) -
+- 46 * (pix[2*hex[1]][1] + pix[2*hex[0]][1]);
+- color[1][1] = 223 * pix[ hex[3]][1] + pix[ hex[2]][1] * 33 +
+- 92 * (pix[ 0 ][f] - pix[ -hex[2]][f]);
+- FORC(2) color[1][2+c] =
+- 164 * pix[hex[4+c]][1] + 92 * pix[-2*hex[4+c]][1] + 33 *
+- (2*pix[0][f] - pix[3*hex[4+c]][f] - pix[-3*hex[4+c]][f]);
+- FORC4 rgb[c^!((row-sgrow) % 3)][row-top][col-left][1] =
+- LIM(color[1][c] >> 8,pix[0][1],pix[0][3]);
+- }
+-
+- for (pass=0; pass < passes; pass++) {
+- if (pass == 1)
+- memcpy (rgb+=4, buffer, 4*sizeof *rgb);
+-
+-/* Recalculate green from interpolated values of closer pixels: */
+- if (pass) {
+- for (row=top+2; row < mrow-2; row++)
+- for (col=left+2; col < mcol-2; col++) {
+- if ((f = fcol(row,col)) == 1) continue;
+- pix = image + row*width + col;
+- hex = allhex[row % 3][col % 3][1];
+- for (d=3; d < 6; d++) {
+- rix = &rgb[(d-2)^!((row-sgrow) % 3)][row-top][col-left];
+- val = rix[-2*hex[d]][1] + 2*rix[hex[d]][1]
+- - rix[-2*hex[d]][f] - 2*rix[hex[d]][f] + 3*rix[0][f];
+- rix[0][1] = LIM(val/3,pix[0][1],pix[0][3]);
+- }
+- }
+- }
+-
+-/* Interpolate red and blue values for solitary green pixels: */
+- for (row=(top-sgrow+4)/3*3+sgrow; row < mrow-2; row+=3)
+- for (col=(left-sgcol+4)/3*3+sgcol; col < mcol-2; col+=3) {
+- rix = &rgb[0][row-top][col-left];
+- h = fcol(row,col+1);
+- memset (diff, 0, sizeof diff);
+- for (i=1, d=0; d < 6; d++, i^=TS^1, h^=2) {
+- for (c=0; c < 2; c++, h^=2) {
+- g = 2*rix[0][1] - rix[i< 1)
+- diff[d] += SQR (rix[i< 1 && (d & 1))
+- if (diff[d-1] < diff[d])
+- FORC(2) color[c*2][d] = color[c*2][d-1];
+- if (d < 2 || (d & 1)) {
+- FORC(2) rix[0][c*2] = CLIP(color[c*2][d]/2);
+- rix += TS*TS;
+- }
+- }
+- }
+-
+-/* Interpolate red for blue pixels and vice versa: */
+- for (row=top+3; row < mrow-3; row++)
+- for (col=left+3; col < mcol-3; col++) {
+- if ((f = 2-fcol(row,col)) == 1) continue;
+- rix = &rgb[0][row-top][col-left];
+- c = (row-sgrow) % 3 ? TS:1;
+- h = 3 * (c ^ TS ^ 1);
+- for (d=0; d < 4; d++, rix += TS*TS) {
+- i = d > 1 || ((d ^ c) & 1) ||
+- ((ABS(rix[0][1]-rix[c][1])+ABS(rix[0][1]-rix[-c][1])) <
+- 2*(ABS(rix[0][1]-rix[h][1])+ABS(rix[0][1]-rix[-h][1]))) ? c:h;
+- rix[0][f] = CLIP((rix[i][f] + rix[-i][f] +
+- 2*rix[0][1] - rix[i][1] - rix[-i][1])/2);
+- }
+- }
+-
+-/* Fill in red and blue for 2x2 blocks of green: */
+- for (row=top+2; row < mrow-2; row++) if ((row-sgrow) % 3)
+- for (col=left+2; col < mcol-2; col++) if ((col-sgcol) % 3) {
+- rix = &rgb[0][row-top][col-left];
+- hex = allhex[row % 3][col % 3][1];
+- for (d=0; d < ndir; d+=2, rix += TS*TS)
+- if (hex[d] + hex[d+1]) {
+- g = 3*rix[0][1] - 2*rix[hex[d]][1] - rix[hex[d+1]][1];
+- for (c=0; c < 4; c+=2) rix[0][c] =
+- CLIP((g + 2*rix[hex[d]][c] + rix[hex[d+1]][c])/3);
+- } else {
+- g = 2*rix[0][1] - rix[hex[d]][1] - rix[hex[d+1]][1];
+- for (c=0; c < 4; c+=2) rix[0][c] =
+- CLIP((g + rix[hex[d]][c] + rix[hex[d+1]][c])/2);
+- }
+- }
+- }
+- rgb = (ushort(*)[TS][TS][3]) buffer;
+- mrow -= top;
+- mcol -= left;
+-
+-/* Convert to CIELab and differentiate in all directions: */
+- for (d=0; d < ndir; d++) {
+- for (row=2; row < mrow-2; row++)
+- for (col=2; col < mcol-2; col++)
+- cielab (rgb[d][row][col], lab[row][col]);
+- for (f=dir[d & 3],row=3; row < mrow-3; row++)
+- for (col=3; col < mcol-3; col++) {
+- lix = &lab[row][col];
+- g = 2*lix[0][0] - lix[f][0] - lix[-f][0];
+- drv[d][row][col] = SQR(g)
+- + SQR((2*lix[0][1] - lix[f][1] - lix[-f][1] + g*500/232))
+- + SQR((2*lix[0][2] - lix[f][2] - lix[-f][2] - g*500/580));
+- }
+- }
+-
+-/* Build homogeneity maps from the derivatives: */
+- memset(homo, 0, ndir*TS*TS);
+- for (row=4; row < mrow-4; row++)
+- for (col=4; col < mcol-4; col++) {
+- for (tr=FLT_MAX, d=0; d < ndir; d++)
+- if (tr > drv[d][row][col])
+- tr = drv[d][row][col];
+- tr *= 8;
+- for (d=0; d < ndir; d++)
+- for (v=-1; v <= 1; v++)
+- for (h=-1; h <= 1; h++)
+- if (drv[d][row+v][col+h] <= tr)
+- homo[d][row][col]++;
+- }
+-
+-/* Average the most homogenous pixels for the final result: */
+- if (height-top < TS+4) mrow = height-top+2;
+- if (width-left < TS+4) mcol = width-left+2;
+- for (row = MIN(top,8); row < mrow-8; row++)
+- for (col = MIN(left,8); col < mcol-8; col++) {
+- for (d=0; d < ndir; d++)
+- for (hm[d]=0, v=-2; v <= 2; v++)
+- for (h=-2; h <= 2; h++)
+- hm[d] += homo[d][row+v][col+h];
+- for (d=0; d < ndir-4; d++)
+- if (hm[d] < hm[d+4]) hm[d ] = 0; else
+- if (hm[d] > hm[d+4]) hm[d+4] = 0;
+- for (max=hm[0],d=1; d < ndir; d++)
+- if (max < hm[d]) max = hm[d];
+- max -= max >> 3;
+- memset (avg, 0, sizeof avg);
+- for (d=0; d < ndir; d++)
+- if (hm[d] >= max) {
+- FORC3 avg[c] += rgb[d][row][col][c];
+- avg[3]++;
+- }
+- FORC3 image[(row+top)*width+col+left][c] = avg[c]/avg[3];
+- }
+- }
+- free(buffer);
+- border_interpolate(8);
+-}
+-#undef fcol
+-
-/*
- Adaptive Homogeneity-Directed interpolation is based on
- the work of Keigo Hirakawa, Thomas Parks, and Paul Lee.
@@ -1103,7 +1818,7 @@
-
- for (top=2; top < height-5; top += TS-6)
- for (left=2; left < width-5; left += TS-6) {
-
+-
-/* Interpolate green horizontally and vertically: */
- for (row=top; row < top+TS && row < height-2; row++) {
- col = left + (FC(row,left) & 1);
@@ -1184,9 +1899,587 @@
- }
- free (buffer);
-}
- #undef TS
+-#undef TS
+-
+-void CLASS median_filter()
+-{
+- ushort (*pix)[4];
+- int pass, c, i, j, k, med[9];
+- static const uchar opt[] = /* Optimal 9-element median search */
+- { 1,2, 4,5, 7,8, 0,1, 3,4, 6,7, 1,2, 4,5, 7,8,
+- 0,3, 5,8, 4,7, 3,6, 1,4, 2,5, 4,7, 4,2, 6,4, 4,2 };
+-
+- for (pass=1; pass <= med_passes; pass++) {
+- if (verbose)
+- fprintf (stderr,_("Median filter pass %d...\n"), pass);
+- for (c=0; c < 3; c+=2) {
+- for (pix = image; pix < image+width*height; pix++)
+- pix[0][3] = pix[0][c];
+- for (pix = image+width; pix < image+width*(height-1); pix++) {
+- if ((pix-image+1) % width < 2) continue;
+- for (k=0, i = -width; i <= width; i += width)
+- for (j = i-1; j <= i+1; j++)
+- med[k++] = pix[j][3] - pix[j][1];
+- for (i=0; i < sizeof opt; i+=2)
+- if (med[opt[i]] > med[opt[i+1]])
+- SWAP (med[opt[i]] , med[opt[i+1]]);
+- pix[0][c] = CLIP(med[4] + pix[0][1]);
+- }
+- }
+- }
+-}
+-
+-void CLASS blend_highlights()
+-{
+- int clip=INT_MAX, row, col, c, i, j;
+- static const float trans[2][4][4] =
+- { { { 1,1,1 }, { 1.7320508,-1.7320508,0 }, { -1,-1,2 } },
+- { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
+- static const float itrans[2][4][4] =
+- { { { 1,0.8660254,-0.5 }, { 1,-0.8660254,-0.5 }, { 1,0,1 } },
+- { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
+- float cam[2][4], lab[2][4], sum[2], chratio;
+-
+- if ((unsigned) (colors-3) > 1) return;
+- if (verbose) fprintf (stderr,_("Blending highlights...\n"));
+- FORCC if (clip > (i = 65535*pre_mul[c])) clip = i;
+- for (row=0; row < height; row++)
+- for (col=0; col < width; col++) {
+- FORCC if (image[row*width+col][c] > clip) break;
+- if (c == colors) continue;
+- FORCC {
+- cam[0][c] = image[row*width+col][c];
+- cam[1][c] = MIN(cam[0][c],clip);
+- }
+- for (i=0; i < 2; i++) {
+- FORCC for (lab[i][c]=j=0; j < colors; j++)
+- lab[i][c] += trans[colors-3][c][j] * cam[i][j];
+- for (sum[i]=0,c=1; c < colors; c++)
+- sum[i] += SQR(lab[i][c]);
+- }
+- chratio = sqrt(sum[1]/sum[0]);
+- for (c=1; c < colors; c++)
+- lab[0][c] *= chratio;
+- FORCC for (cam[0][c]=j=0; j < colors; j++)
+- cam[0][c] += itrans[colors-3][c][j] * lab[0][j];
+- FORCC image[row*width+col][c] = cam[0][c] / colors;
+- }
+-}
+-
+-#define SCALE (4 >> shrink)
+-void CLASS recover_highlights()
+-{
+- float *map, sum, wgt, grow;
+- int hsat[4], count, spread, change, val, i;
+- unsigned high, wide, mrow, mcol, row, col, kc, c, d, y, x;
+- ushort *pixel;
+- static const signed char dir[8][2] =
+- { {-1,-1}, {-1,0}, {-1,1}, {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1} };
+-
+- if (verbose) fprintf (stderr,_("Rebuilding highlights...\n"));
+-
+- grow = pow (2, 4-highlight);
+- FORCC hsat[c] = 32000 * pre_mul[c];
+- for (kc=0, c=1; c < colors; c++)
+- if (pre_mul[kc] < pre_mul[c]) kc = c;
+- high = height / SCALE;
+- wide = width / SCALE;
+- map = (float *) calloc (high, wide*sizeof *map);
+- merror (map, "recover_highlights()");
+- FORCC if (c != kc) {
+- memset (map, 0, high*wide*sizeof *map);
+- for (mrow=0; mrow < high; mrow++)
+- for (mcol=0; mcol < wide; mcol++) {
+- sum = wgt = count = 0;
+- for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
+- for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
+- pixel = image[row*width+col];
+- if (pixel[c] / hsat[c] == 1 && pixel[kc] > 24000) {
+- sum += pixel[c];
+- wgt += pixel[kc];
+- count++;
+- }
+- }
+- if (count == SCALE*SCALE)
+- map[mrow*wide+mcol] = sum / wgt;
+- }
+- for (spread = 32/grow; spread--; ) {
+- for (mrow=0; mrow < high; mrow++)
+- for (mcol=0; mcol < wide; mcol++) {
+- if (map[mrow*wide+mcol]) continue;
+- sum = count = 0;
+- for (d=0; d < 8; d++) {
+- y = mrow + dir[d][0];
+- x = mcol + dir[d][1];
+- if (y < high && x < wide && map[y*wide+x] > 0) {
+- sum += (1 + (d & 1)) * map[y*wide+x];
+- count += 1 + (d & 1);
+- }
+- }
+- if (count > 3)
+- map[mrow*wide+mcol] = - (sum+grow) / (count+grow);
+- }
+- for (change=i=0; i < high*wide; i++)
+- if (map[i] < 0) {
+- map[i] = -map[i];
+- change = 1;
+- }
+- if (!change) break;
+- }
+- for (i=0; i < high*wide; i++)
+- if (map[i] == 0) map[i] = 1;
+- for (mrow=0; mrow < high; mrow++)
+- for (mcol=0; mcol < wide; mcol++) {
+- for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
+- for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
+- pixel = image[row*width+col];
+- if (pixel[c] / hsat[c] > 1) {
+- val = pixel[kc] * map[mrow*wide+mcol];
+- if (pixel[c] < val) pixel[c] = CLIP(val);
+- }
+- }
+- }
+- }
+- free (map);
+-}
+-#undef SCALE
++//void CLASS border_interpolate (int border)
++//{
++// unsigned row, col, y, x, f, c, sum[8];
++//
++// for (row=0; row < height; row++)
++// for (col=0; col < width; col++) {
++// if (col==border && row >= border && row < height-border)
++// col = width-border;
++// memset (sum, 0, sizeof sum);
++// for (y=row-1; y != row+2; y++)
++// for (x=col-1; x != col+2; x++)
++// if (y < height && x < width) {
++// f = fcol(y,x);
++// sum[f] += image[y*width+x][f];
++// sum[f+4]++;
++// }
++// f = fcol(row,col);
++// FORCC if (c != f && sum[c+4])
++// image[row*width+col][c] = sum[c] / sum[c+4];
++// }
++//}
++
++/* RT: delete interpolation functions */
++
++
++//void CLASS cielab (ushort rgb[3], short lab[3])
++//{
++// int c, i, j, k;
++// float r, xyz[3];
++// static float cbrt[0x10000], xyz_cam[3][4];
++//
++// if (!rgb) {
++// for (i=0; i < 0x10000; i++) {
++// r = i / 65535.0;
++// cbrt[i] = r > 0.008856 ? pow(r,1/3.0) : 7.787*r + 16/116.0;
++// }
++// for (i=0; i < 3; i++)
++// for (j=0; j < colors; j++)
++// for (xyz_cam[i][j] = k=0; k < 3; k++)
++// xyz_cam[i][j] += xyz_rgb[i][k] * rgb_cam[k][j] / d65_white[i];
++// return;
++// }
++// xyz[0] = xyz[1] = xyz[2] = 0.5;
++// FORCC {
++// xyz[0] += xyz_cam[0][c] * rgb[c];
++// xyz[1] += xyz_cam[1][c] * rgb[c];
++// xyz[2] += xyz_cam[2][c] * rgb[c];
++// }
++// xyz[0] = cbrt[CLIP((int) xyz[0])];
++// xyz[1] = cbrt[CLIP((int) xyz[1])];
++// xyz[2] = cbrt[CLIP((int) xyz[2])];
++// lab[0] = 64 * (116 * xyz[1] - 16);
++// lab[1] = 64 * 500 * (xyz[0] - xyz[1]);
++// lab[2] = 64 * 200 * (xyz[1] - xyz[2]);
++//}
++//
++//#define TS 512 /* Tile Size */
++//#define fcol(row,col) xtrans[(row+6) % 6][(col+6) % 6]
++//
++///*
++// Frank Markesteijn's algorithm for Fuji X-Trans sensors
++// */
++//void CLASS xtrans_interpolate (int passes)
++//{
++// int c, d, f, g, h, i, v, ng, row, col, top, left, mrow, mcol;
++// int val, ndir, pass, hm[8], avg[4], color[3][8];
++// static const short orth[12] = { 1,0,0,1,-1,0,0,-1,1,0,0,1 },
++// patt[2][16] = { { 0,1,0,-1,2,0,-1,0,1,1,1,-1,0,0,0,0 },
++// { 0,1,0,-2,1,0,-2,0,1,1,-2,-2,1,-1,-1,1 } },
++// dir[4] = { 1,TS,TS+1,TS-1 };
++// short allhex[3][3][2][8], *hex;
++// ushort min, max, sgrow, sgcol;
++// ushort (*rgb)[TS][TS][3], (*rix)[3], (*pix)[4];
++// short (*lab) [TS][3], (*lix)[3];
++// float (*drv)[TS][TS], diff[6], tr;
++// char (*homo)[TS][TS], *buffer;
++//
++// if (verbose)
++// fprintf (stderr,_("%d-pass X-Trans interpolation...\n"), passes);
++//
++// cielab (0,0);
++// ndir = 4 << (passes > 1);
++// buffer = (char *) malloc (TS*TS*(ndir*11+6));
++// merror (buffer, "xtrans_interpolate()");
++// rgb = (ushort(*)[TS][TS][3]) buffer;
++// lab = (short (*) [TS][3])(buffer + TS*TS*(ndir*6));
++// drv = (float (*)[TS][TS]) (buffer + TS*TS*(ndir*6+6));
++// homo = (char (*)[TS][TS]) (buffer + TS*TS*(ndir*10+6));
++//
++///* Map a green hexagon around each non-green pixel and vice versa: */
++// for (row=0; row < 3; row++)
++// for (col=0; col < 3; col++)
++// for (ng=d=0; d < 10; d+=2) {
++// g = fcol(row,col) == 1;
++// if (fcol(row+orth[d],col+orth[d+2]) == 1) ng=0; else ng++;
++// if (ng == 4) { sgrow = row; sgcol = col; }
++// if (ng == g+1) FORC(8) {
++// v = orth[d ]*patt[g][c*2] + orth[d+1]*patt[g][c*2+1];
++// h = orth[d+2]*patt[g][c*2] + orth[d+3]*patt[g][c*2+1];
++// allhex[row][col][0][c^(g*2 & d)] = h + v*width;
++// allhex[row][col][1][c^(g*2 & d)] = h + v*TS;
++// }
++// }
++//
++///* Set green1 and green3 to the minimum and maximum allowed values: */
++// for (row=2; row < height-2; row++)
++// for (min=~(max=0), col=2; col < width-2; col++) {
++// if (fcol(row,col) == 1 && (min=~(max=0))) continue;
++// pix = image + row*width + col;
++// hex = allhex[row % 3][col % 3][0];
++// if (!max) FORC(6) {
++// val = pix[hex[c]][1];
++// if (min > val) min = val;
++// if (max < val) max = val;
++// }
++// pix[0][1] = min;
++// pix[0][3] = max;
++// switch ((row-sgrow) % 3) {
++// case 1: if (row < height-3) { row++; col--; } break;
++// case 2: if ((min=~(max=0)) && (col+=2) < width-3 && row > 2) row--;
++// }
++// }
++//
++// for (top=3; top < height-19; top += TS-16)
++// for (left=3; left < width-19; left += TS-16) {
++// mrow = MIN (top+TS, height-3);
++// mcol = MIN (left+TS, width-3);
++// for (row=top; row < mrow; row++)
++// for (col=left; col < mcol; col++)
++// memcpy (rgb[0][row-top][col-left], image[row*width+col], 6);
++// FORC3 memcpy (rgb[c+1], rgb[0], sizeof *rgb);
++//
++///* Interpolate green horizontally, vertically, and along both diagonals: */
++// for (row=top; row < mrow; row++)
++// for (col=left; col < mcol; col++) {
++// if ((f = fcol(row,col)) == 1) continue;
++// pix = image + row*width + col;
++// hex = allhex[row % 3][col % 3][0];
++// color[1][0] = 174 * (pix[ hex[1]][1] + pix[ hex[0]][1]) -
++// 46 * (pix[2*hex[1]][1] + pix[2*hex[0]][1]);
++// color[1][1] = 223 * pix[ hex[3]][1] + pix[ hex[2]][1] * 33 +
++// 92 * (pix[ 0 ][f] - pix[ -hex[2]][f]);
++// FORC(2) color[1][2+c] =
++// 164 * pix[hex[4+c]][1] + 92 * pix[-2*hex[4+c]][1] + 33 *
++// (2*pix[0][f] - pix[3*hex[4+c]][f] - pix[-3*hex[4+c]][f]);
++// FORC4 rgb[c^!((row-sgrow) % 3)][row-top][col-left][1] =
++// LIM(color[1][c] >> 8,pix[0][1],pix[0][3]);
++// }
++//
++// for (pass=0; pass < passes; pass++) {
++// if (pass == 1)
++// memcpy (rgb+=4, buffer, 4*sizeof *rgb);
++//
++///* Recalculate green from interpolated values of closer pixels: */
++// if (pass) {
++// for (row=top+2; row < mrow-2; row++)
++// for (col=left+2; col < mcol-2; col++) {
++// if ((f = fcol(row,col)) == 1) continue;
++// pix = image + row*width + col;
++// hex = allhex[row % 3][col % 3][1];
++// for (d=3; d < 6; d++) {
++// rix = &rgb[(d-2)^!((row-sgrow) % 3)][row-top][col-left];
++// val = rix[-2*hex[d]][1] + 2*rix[hex[d]][1]
++// - rix[-2*hex[d]][f] - 2*rix[hex[d]][f] + 3*rix[0][f];
++// rix[0][1] = LIM(val/3,pix[0][1],pix[0][3]);
++// }
++// }
++// }
++//
++///* Interpolate red and blue values for solitary green pixels: */
++// for (row=(top-sgrow+4)/3*3+sgrow; row < mrow-2; row+=3)
++// for (col=(left-sgcol+4)/3*3+sgcol; col < mcol-2; col+=3) {
++// rix = &rgb[0][row-top][col-left];
++// h = fcol(row,col+1);
++// memset (diff, 0, sizeof diff);
++// for (i=1, d=0; d < 6; d++, i^=TS^1, h^=2) {
++// for (c=0; c < 2; c++, h^=2) {
++// g = 2*rix[0][1] - rix[i< 1)
++// diff[d] += SQR (rix[i< 1 && (d & 1))
++// if (diff[d-1] < diff[d])
++// FORC(2) color[c*2][d] = color[c*2][d-1];
++// if (d < 2 || (d & 1)) {
++// FORC(2) rix[0][c*2] = CLIP(color[c*2][d]/2);
++// rix += TS*TS;
++// }
++// }
++// }
++//
++///* Interpolate red for blue pixels and vice versa: */
++// for (row=top+3; row < mrow-3; row++)
++// for (col=left+3; col < mcol-3; col++) {
++// if ((f = 2-fcol(row,col)) == 1) continue;
++// rix = &rgb[0][row-top][col-left];
++// c = (row-sgrow) % 3 ? TS:1;
++// h = 3 * (c ^ TS ^ 1);
++// for (d=0; d < 4; d++, rix += TS*TS) {
++// i = d > 1 || ((d ^ c) & 1) ||
++// ((ABS(rix[0][1]-rix[c][1])+ABS(rix[0][1]-rix[-c][1])) <
++// 2*(ABS(rix[0][1]-rix[h][1])+ABS(rix[0][1]-rix[-h][1]))) ? c:h;
++// rix[0][f] = CLIP((rix[i][f] + rix[-i][f] +
++// 2*rix[0][1] - rix[i][1] - rix[-i][1])/2);
++// }
++// }
++//
++///* Fill in red and blue for 2x2 blocks of green: */
++// for (row=top+2; row < mrow-2; row++) if ((row-sgrow) % 3)
++// for (col=left+2; col < mcol-2; col++) if ((col-sgcol) % 3) {
++// rix = &rgb[0][row-top][col-left];
++// hex = allhex[row % 3][col % 3][1];
++// for (d=0; d < ndir; d+=2, rix += TS*TS)
++// if (hex[d] + hex[d+1]) {
++// g = 3*rix[0][1] - 2*rix[hex[d]][1] - rix[hex[d+1]][1];
++// for (c=0; c < 4; c+=2) rix[0][c] =
++// CLIP((g + 2*rix[hex[d]][c] + rix[hex[d+1]][c])/3);
++// } else {
++// g = 2*rix[0][1] - rix[hex[d]][1] - rix[hex[d+1]][1];
++// for (c=0; c < 4; c+=2) rix[0][c] =
++// CLIP((g + rix[hex[d]][c] + rix[hex[d+1]][c])/2);
++// }
++// }
++// }
++// rgb = (ushort(*)[TS][TS][3]) buffer;
++// mrow -= top;
++// mcol -= left;
++//
++///* Convert to CIELab and differentiate in all directions: */
++// for (d=0; d < ndir; d++) {
++// for (row=2; row < mrow-2; row++)
++// for (col=2; col < mcol-2; col++)
++// cielab (rgb[d][row][col], lab[row][col]);
++// for (f=dir[d & 3],row=3; row < mrow-3; row++)
++// for (col=3; col < mcol-3; col++) {
++// lix = &lab[row][col];
++// g = 2*lix[0][0] - lix[f][0] - lix[-f][0];
++// drv[d][row][col] = SQR(g)
++// + SQR((2*lix[0][1] - lix[f][1] - lix[-f][1] + g*500/232))
++// + SQR((2*lix[0][2] - lix[f][2] - lix[-f][2] - g*500/580));
++// }
++// }
++//
++///* Build homogeneity maps from the derivatives: */
++// memset(homo, 0, ndir*TS*TS);
++// for (row=4; row < mrow-4; row++)
++// for (col=4; col < mcol-4; col++) {
++// for (tr=FLT_MAX, d=0; d < ndir; d++)
++// if (tr > drv[d][row][col])
++// tr = drv[d][row][col];
++// tr *= 8;
++// for (d=0; d < ndir; d++)
++// for (v=-1; v <= 1; v++)
++// for (h=-1; h <= 1; h++)
++// if (drv[d][row+v][col+h] <= tr)
++// homo[d][row][col]++;
++// }
++//
++///* Average the most homogenous pixels for the final result: */
++// if (height-top < TS+4) mrow = height-top+2;
++// if (width-left < TS+4) mcol = width-left+2;
++// for (row = MIN(top,8); row < mrow-8; row++)
++// for (col = MIN(left,8); col < mcol-8; col++) {
++// for (d=0; d < ndir; d++)
++// for (hm[d]=0, v=-2; v <= 2; v++)
++// for (h=-2; h <= 2; h++)
++// hm[d] += homo[d][row+v][col+h];
++// for (d=0; d < ndir-4; d++)
++// if (hm[d] < hm[d+4]) hm[d ] = 0; else
++// if (hm[d] > hm[d+4]) hm[d+4] = 0;
++// for (max=hm[0],d=1; d < ndir; d++)
++// if (max < hm[d]) max = hm[d];
++// max -= max >> 3;
++// memset (avg, 0, sizeof avg);
++// for (d=0; d < ndir; d++)
++// if (hm[d] >= max) {
++// FORC3 avg[c] += rgb[d][row][col][c];
++// avg[3]++;
++// }
++// FORC3 image[(row+top)*width+col+left][c] = avg[c]/avg[3];
++// }
++// }
++// free(buffer);
++// border_interpolate(8);
++//}
++//#undef fcol
++//
++//
++//#undef TS
++
++//void CLASS median_filter()
++//{
++// ushort (*pix)[4];
++// int pass, c, i, j, k, med[9];
++// static const uchar opt[] = /* Optimal 9-element median search */
++// { 1,2, 4,5, 7,8, 0,1, 3,4, 6,7, 1,2, 4,5, 7,8,
++// 0,3, 5,8, 4,7, 3,6, 1,4, 2,5, 4,7, 4,2, 6,4, 4,2 };
++//
++// for (pass=1; pass <= med_passes; pass++) {
++// if (verbose)
++// fprintf (stderr,_("Median filter pass %d...\n"), pass);
++// for (c=0; c < 3; c+=2) {
++// for (pix = image; pix < image+width*height; pix++)
++// pix[0][3] = pix[0][c];
++// for (pix = image+width; pix < image+width*(height-1); pix++) {
++// if ((pix-image+1) % width < 2) continue;
++// for (k=0, i = -width; i <= width; i += width)
++// for (j = i-1; j <= i+1; j++)
++// med[k++] = pix[j][3] - pix[j][1];
++// for (i=0; i < sizeof opt; i+=2)
++// if (med[opt[i]] > med[opt[i+1]])
++// SWAP (med[opt[i]] , med[opt[i+1]]);
++// pix[0][c] = CLIP(med[4] + pix[0][1]);
++// }
++// }
++// }
++//}
++//
++//void CLASS blend_highlights()
++//{
++// int clip=INT_MAX, row, col, c, i, j;
++// static const float trans[2][4][4] =
++// { { { 1,1,1 }, { 1.7320508,-1.7320508,0 }, { -1,-1,2 } },
++// { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
++// static const float itrans[2][4][4] =
++// { { { 1,0.8660254,-0.5 }, { 1,-0.8660254,-0.5 }, { 1,0,1 } },
++// { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
++// float cam[2][4], lab[2][4], sum[2], chratio;
++//
++// if ((unsigned) (colors-3) > 1) return;
++// if (verbose) fprintf (stderr,_("Blending highlights...\n"));
++// FORCC if (clip > (i = 65535*pre_mul[c])) clip = i;
++// for (row=0; row < height; row++)
++// for (col=0; col < width; col++) {
++// FORCC if (image[row*width+col][c] > clip) break;
++// if (c == colors) continue;
++// FORCC {
++// cam[0][c] = image[row*width+col][c];
++// cam[1][c] = MIN(cam[0][c],clip);
++// }
++// for (i=0; i < 2; i++) {
++// FORCC for (lab[i][c]=j=0; j < colors; j++)
++// lab[i][c] += trans[colors-3][c][j] * cam[i][j];
++// for (sum[i]=0,c=1; c < colors; c++)
++// sum[i] += SQR(lab[i][c]);
++// }
++// chratio = sqrt(sum[1]/sum[0]);
++// for (c=1; c < colors; c++)
++// lab[0][c] *= chratio;
++// FORCC for (cam[0][c]=j=0; j < colors; j++)
++// cam[0][c] += itrans[colors-3][c][j] * lab[0][j];
++// FORCC image[row*width+col][c] = cam[0][c] / colors;
++// }
++//}
++//
++//#define SCALE (4 >> shrink)
++//void CLASS recover_highlights()
++//{
++// float *map, sum, wgt, grow;
++// int hsat[4], count, spread, change, val, i;
++// unsigned high, wide, mrow, mcol, row, col, kc, c, d, y, x;
++// ushort *pixel;
++// static const signed char dir[8][2] =
++// { {-1,-1}, {-1,0}, {-1,1}, {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1} };
++//
++// if (verbose) fprintf (stderr,_("Rebuilding highlights...\n"));
++//
++// grow = pow (2, 4-highlight);
++// FORCC hsat[c] = 32000 * pre_mul[c];
++// for (kc=0, c=1; c < colors; c++)
++// if (pre_mul[kc] < pre_mul[c]) kc = c;
++// high = height / SCALE;
++// wide = width / SCALE;
++// map = (float *) calloc (high, wide*sizeof *map);
++// merror (map, "recover_highlights()");
++// FORCC if (c != kc) {
++// memset (map, 0, high*wide*sizeof *map);
++// for (mrow=0; mrow < high; mrow++)
++// for (mcol=0; mcol < wide; mcol++) {
++// sum = wgt = count = 0;
++// for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
++// for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
++// pixel = image[row*width+col];
++// if (pixel[c] / hsat[c] == 1 && pixel[kc] > 24000) {
++// sum += pixel[c];
++// wgt += pixel[kc];
++// count++;
++// }
++// }
++// if (count == SCALE*SCALE)
++// map[mrow*wide+mcol] = sum / wgt;
++// }
++// for (spread = 32/grow; spread--; ) {
++// for (mrow=0; mrow < high; mrow++)
++// for (mcol=0; mcol < wide; mcol++) {
++// if (map[mrow*wide+mcol]) continue;
++// sum = count = 0;
++// for (d=0; d < 8; d++) {
++// y = mrow + dir[d][0];
++// x = mcol + dir[d][1];
++// if (y < high && x < wide && map[y*wide+x] > 0) {
++// sum += (1 + (d & 1)) * map[y*wide+x];
++// count += 1 + (d & 1);
++// }
++// }
++// if (count > 3)
++// map[mrow*wide+mcol] = - (sum+grow) / (count+grow);
++// }
++// for (change=i=0; i < high*wide; i++)
++// if (map[i] < 0) {
++// map[i] = -map[i];
++// change = 1;
++// }
++// if (!change) break;
++// }
++// for (i=0; i < high*wide; i++)
++// if (map[i] == 0) map[i] = 1;
++// for (mrow=0; mrow < high; mrow++)
++// for (mcol=0; mcol < wide; mcol++) {
++// for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
++// for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
++// pixel = image[row*width+col];
++// if (pixel[c] / hsat[c] > 1) {
++// val = pixel[kc] * map[mrow*wide+mcol];
++// if (pixel[c] < val) pixel[c] = CLIP(val);
++// }
++// }
++// }
++// }
++// free (map);
++//}
++//#undef SCALE
- void CLASS median_filter()
+ void CLASS tiff_get (unsigned base,
+ unsigned *tag, unsigned *type, unsigned *len, unsigned *save)
@@ -5139,7 +5127,7 @@
}
}
@@ -1783,9 +3076,141 @@
is_raw = 0;
#ifdef NO_JASPER
if (load_raw == &CLASS redcine_load_raw) {
-@@ -9452,199 +9583,250 @@
+@@ -9402,249 +9533,300 @@
+ if (flip == UINT_MAX) flip = 0;
}
- #endif
+
+-#ifndef NO_LCMS
+-void CLASS apply_profile (const char *input, const char *output)
+-{
+- char *prof;
+- cmsHPROFILE hInProfile=0, hOutProfile=0;
+- cmsHTRANSFORM hTransform;
+- FILE *fp;
+- unsigned size;
+-
+- if (strcmp (input, "embed"))
+- hInProfile = cmsOpenProfileFromFile (input, "r");
+- else if (profile_length) {
+- prof = (char *) malloc (profile_length);
+- merror (prof, "apply_profile()");
+- fseek (ifp, profile_offset, SEEK_SET);
+- fread (prof, 1, profile_length, ifp);
+- hInProfile = cmsOpenProfileFromMem (prof, profile_length);
+- free (prof);
+- } else
+- fprintf (stderr,_("%s has no embedded profile.\n"), ifname);
+- if (!hInProfile) return;
+- if (!output)
+- hOutProfile = cmsCreate_sRGBProfile();
+- else if ((fp = fopen (output, "rb"))) {
+- fread (&size, 4, 1, fp);
+- fseek (fp, 0, SEEK_SET);
+- oprof = (unsigned *) malloc (size = ntohl(size));
+- merror (oprof, "apply_profile()");
+- fread (oprof, 1, size, fp);
+- fclose (fp);
+- if (!(hOutProfile = cmsOpenProfileFromMem (oprof, size))) {
+- free (oprof);
+- oprof = 0;
++//#ifndef NO_LCMS
++//void CLASS apply_profile (const char *input, const char *output)
++//{
++// char *prof;
++// cmsHPROFILE hInProfile=0, hOutProfile=0;
++// cmsHTRANSFORM hTransform;
++// FILE *fp;
++// unsigned size;
++//
++// if (strcmp (input, "embed"))
++// hInProfile = cmsOpenProfileFromFile (input, "r");
++// else if (profile_length) {
++// prof = (char *) malloc (profile_length);
++// merror (prof, "apply_profile()");
++// fseek (ifp, profile_offset, SEEK_SET);
++// fread (prof, 1, profile_length, ifp);
++// hInProfile = cmsOpenProfileFromMem (prof, profile_length);
++// free (prof);
++// } else
++// fprintf (stderr,_("%s has no embedded profile.\n"), ifname);
++// if (!hInProfile) return;
++// if (!output)
++// hOutProfile = cmsCreate_sRGBProfile();
++// else if ((fp = fopen (output, "rb"))) {
++// fread (&size, 4, 1, fp);
++// fseek (fp, 0, SEEK_SET);
++// oprof = (unsigned *) malloc (size = ntohl(size));
++// merror (oprof, "apply_profile()");
++// fread (oprof, 1, size, fp);
++// fclose (fp);
++// if (!(hOutProfile = cmsOpenProfileFromMem (oprof, size))) {
++// free (oprof);
++// oprof = 0;
++// }
++// } else
++// fprintf (stderr,_("Cannot open file %s!\n"), output);
++// if (!hOutProfile) goto quit;
++// if (verbose)
++// fprintf (stderr,_("Applying color profile...\n"));
++// hTransform = cmsCreateTransform (hInProfile, TYPE_RGBA_16,
++// hOutProfile, TYPE_RGBA_16, INTENT_PERCEPTUAL, 0);
++// cmsDoTransform (hTransform, image, image, width*height);
++// raw_color = 1; /* Don't use rgb_cam with a profile */
++// cmsDeleteTransform (hTransform);
++// cmsCloseProfile (hOutProfile);
++//quit:
++// cmsCloseProfile (hInProfile);
++//}
++//#endif
++
++/* RT: DNG Float */
++
++#include
++#include
++
++static void decodeFPDeltaRow(Bytef * src, Bytef * dst, size_t tileWidth, size_t realTileWidth, int bytesps, int factor) {
++ // DecodeDeltaBytes
++ for (size_t col = factor; col < realTileWidth*bytesps; ++col) {
++ src[col] += src[col - factor];
++ }
++ // Reorder bytes into the image
++ // 16 and 32-bit versions depend on local architecture, 24-bit does not
++ if (bytesps == 3) {
++ for (size_t col = 0; col < tileWidth; ++col) {
++ dst[col*3] = src[col];
++ dst[col*3 + 1] = src[col + realTileWidth];
++ dst[col*3 + 2] = src[col + realTileWidth*2];
+ }
+- } else
+- fprintf (stderr,_("Cannot open file %s!\n"), output);
+- if (!hOutProfile) goto quit;
+- if (verbose)
+- fprintf (stderr,_("Applying color profile...\n"));
+- hTransform = cmsCreateTransform (hInProfile, TYPE_RGBA_16,
+- hOutProfile, TYPE_RGBA_16, INTENT_PERCEPTUAL, 0);
+- cmsDoTransform (hTransform, image, image, width*height);
+- raw_color = 1; /* Don't use rgb_cam with a profile */
+- cmsDeleteTransform (hTransform);
+- cmsCloseProfile (hOutProfile);
+-quit:
+- cmsCloseProfile (hInProfile);
++ } else {
++ union X { uint32_t x; uint8_t c; };
++ if (((union X){1}).c) {
++ for (size_t col = 0; col < tileWidth; ++col) {
++ for (size_t byte = 0; byte < bytesps; ++byte)
++ dst[col*bytesps + byte] = src[col + realTileWidth*(bytesps-byte-1)]; // Little endian
++ }
++ } else {
++ for (size_t col = 0; col < tileWidth; ++col) {
++ for (size_t byte = 0; byte < bytesps; ++byte)
++ dst[col*bytesps + byte] = src[col + realTileWidth*byte];
++ }
++ }
++ }
++
+ }
+-#endif
-void CLASS convert_to_rgb()
-{
@@ -1872,41 +3297,6 @@
- for (j=0; j < colors; j++)
- for (out_cam[i][j] = k=0; k < 3; k++)
- out_cam[i][j] += out_rgb[output_color-1][i][k] * rgb_cam[k][j];
-+/* RT: DNG Float */
-+
-+#include
-+#include
-+
-+static void decodeFPDeltaRow(Bytef * src, Bytef * dst, size_t tileWidth, size_t realTileWidth, int bytesps, int factor) {
-+ // DecodeDeltaBytes
-+ for (size_t col = factor; col < realTileWidth*bytesps; ++col) {
-+ src[col] += src[col - factor];
-+ }
-+ // Reorder bytes into the image
-+ // 16 and 32-bit versions depend on local architecture, 24-bit does not
-+ if (bytesps == 3) {
-+ for (size_t col = 0; col < tileWidth; ++col) {
-+ dst[col*3] = src[col];
-+ dst[col*3 + 1] = src[col + realTileWidth];
-+ dst[col*3 + 2] = src[col + realTileWidth*2];
-+ }
-+ } else {
-+ union X { uint32_t x; uint8_t c; };
-+ if (((union X){1}).c) {
-+ for (size_t col = 0; col < tileWidth; ++col) {
-+ for (size_t byte = 0; byte < bytesps; ++byte)
-+ dst[col*bytesps + byte] = src[col + realTileWidth*(bytesps-byte-1)]; // Little endian
-+ }
-+ } else {
-+ for (size_t col = 0; col < tileWidth; ++col) {
-+ for (size_t byte = 0; byte < bytesps; ++byte)
-+ dst[col*bytesps + byte] = src[col + realTileWidth*byte];
-+ }
-+ }
-+ }
-+
-+}
-+
+// From DNG SDK dng_utils.h
+static inline uint32_t DNG_HalfToFloat(uint16_t halfValue) {
+ int32_t sign = (halfValue >> 15) & 0x00000001;
diff --git a/rtengine/dcrop.cc b/rtengine/dcrop.cc
index 22c5f91d9..1b1d460f3 100644
--- a/rtengine/dcrop.cc
+++ b/rtengine/dcrop.cc
@@ -962,24 +962,14 @@ void Crop::update (int todo)
// all pipette buffer processing should be finished now
PipetteBuffer::setReady();
- // switch back to rgb
+ // Computing the preview image, i.e. converting from lab->Monitor color space (soft-proofing disabled) or lab->Output profile->Monitor color space (soft-proofing enabled)
parent->ipf.lab2monitorRgb (labnCrop, cropImg);
if (cropImageListener) {
- // this in output space held in parallel to allow analysis like shadow/highlight
- Glib::ustring outProfile = params.icm.output;
- Glib::ustring workProfile = params.icm.working;
- Image8 *cropImgtrue;
+ // Computing the internal image for analysis, i.e. conversion from lab->Output profile (rtSettings.HistogramWorking disabled) or lab->WCS (rtSettings.HistogramWorking enabled)
- if(settings->HistogramWorking) {
- cropImgtrue = parent->ipf.lab2rgb (labnCrop, 0, 0, cropw, croph, workProfile, RI_RELATIVE, false); // HOMBRE: was RELATIVE by default in lab2rgb, is it safe to assume we have to use it again ?
- } else {
- if (params.icm.output == "" || params.icm.output == ColorManagementParams::NoICMString) {
- outProfile = "sRGB";
- }
-
- cropImgtrue = parent->ipf.lab2rgb (labnCrop, 0, 0, cropw, croph, outProfile, params.icm.outputIntent, false);
- }
+ // internal image in output color space for analysis
+ Image8 *cropImgtrue = parent->ipf.lab2rgb (labnCrop, 0, 0, cropw, croph, params.icm);
int finalW = rqcropw;
@@ -1121,7 +1111,7 @@ bool Crop::setCropSizes (int rcx, int rcy, int rcw, int rch, int skip, bool inte
PreviewProps cp (orx, ory, orw, orh, skip);
int orW, orH;
- parent->imgsrc->getSize (tr, cp, orW, orH);
+ parent->imgsrc->getSize (cp, orW, orH);
int cw = SKIPS(bw, skip);
int ch = SKIPS(bh, skip);
diff --git a/rtengine/dcrop.h b/rtengine/dcrop.h
index f1230bf01..450c659f0 100644
--- a/rtengine/dcrop.h
+++ b/rtengine/dcrop.h
@@ -44,7 +44,7 @@ protected:
Imagefloat* origCrop; // "one chunk" allocation
LabImage* laboCrop; // "one chunk" allocation
LabImage* labnCrop; // "one chunk" allocation
- Image8* cropImg; // "one chunk" allocation
+ Image8* cropImg; // "one chunk" allocation ; displayed image in monitor color space, showing the output profile as well (soft-proofing enabled, which then correspond to workimg) or not
float * cbuf_real; // "one chunk" allocation
SHMap* cshmap; // per line allocation
diff --git a/rtengine/dfmanager.cc b/rtengine/dfmanager.cc
index 347b96792..e0dea012b 100644
--- a/rtengine/dfmanager.cc
+++ b/rtengine/dfmanager.cc
@@ -36,16 +36,18 @@ extern const Settings* settings;
inline dfInfo& dfInfo::operator =(const dfInfo &o)
{
- pathname = o.pathname;
- maker = o.maker;
- model = o.model;
- iso = o.iso;
- shutter = o.shutter;
- timestamp = o.timestamp;
+ if (this != &o) {
+ pathname = o.pathname;
+ maker = o.maker;
+ model = o.model;
+ iso = o.iso;
+ shutter = o.shutter;
+ timestamp = o.timestamp;
- if( ri ) {
- delete ri;
- ri = nullptr;
+ if( ri ) {
+ delete ri;
+ ri = NULL;
+ }
}
return *this;
@@ -138,7 +140,7 @@ void dfInfo::updateRawImage()
if( ri->loadRaw(true)) {
delete ri;
- ri = nullptr;
+ ri = NULL;
} else {
int H = ri->get_height();
int W = ri->get_width();
@@ -200,7 +202,7 @@ void dfInfo::updateRawImage()
if( ri->loadRaw(true)) {
delete ri;
- ri = nullptr;
+ ri = NULL;
} else {
ri->compress_image();
}
@@ -332,11 +334,11 @@ dfInfo* DFManager::addFileInfo (const Glib::ustring& filename, bool pool)
auto file = Gio::File::create_for_path (filename);
if (!file) {
- return nullptr;
+ return 0;
}
if (!file->query_exists ()) {
- return nullptr;
+ return 0;
}
try {
@@ -344,11 +346,11 @@ dfInfo* DFManager::addFileInfo (const Glib::ustring& filename, bool pool)
auto info = file->query_info ();
if (!info && info->get_file_type () == Gio::FILE_TYPE_DIRECTORY) {
- return nullptr;
+ return 0;
}
if (!options.fbShowHidden && info->is_hidden ()) {
- return nullptr;
+ return 0;
}
Glib::ustring ext;
@@ -359,14 +361,14 @@ dfInfo* DFManager::addFileInfo (const Glib::ustring& filename, bool pool)
}
if (!options.is_extention_enabled (ext)) {
- return nullptr;
+ return 0;
}
RawImage ri (filename);
int res = ri.loadRaw (false); // Read informations about shot
if (res != 0) {
- return nullptr;
+ return 0;
}
dfList_t::iterator iter;
@@ -406,7 +408,7 @@ dfInfo* DFManager::addFileInfo (const Glib::ustring& filename, bool pool)
} catch(Gio::Error&) {}
- return nullptr;
+ return 0;
}
void DFManager::getStat( int &totFiles, int &totTemplates)
@@ -433,7 +435,7 @@ void DFManager::getStat( int &totFiles, int &totTemplates)
dfInfo* DFManager::find( const std::string &mak, const std::string &mod, int isospeed, double shut, time_t t )
{
if( dfList.empty() ) {
- return nullptr;
+ return 0;
}
std::string key( dfInfo::key(mak, mod, isospeed, shut) );
@@ -467,7 +469,7 @@ dfInfo* DFManager::find( const std::string &mak, const std::string &mod, int iso
}
}
- return bestD != INFINITY ? &(bestMatch->second) : nullptr ;
+ return bestD != INFINITY ? &(bestMatch->second) : 0 ;
}
}
@@ -478,7 +480,7 @@ RawImage* DFManager::searchDarkFrame( const std::string &mak, const std::string
if( df ) {
return df->getRawImage();
} else {
- return nullptr;
+ return 0;
}
}
@@ -496,7 +498,7 @@ RawImage* DFManager::searchDarkFrame( const Glib::ustring filename )
return df->getRawImage();
}
- return nullptr;
+ return 0;
}
std::vector *DFManager::getHotPixels ( const Glib::ustring filename )
{
@@ -506,7 +508,7 @@ std::vector *DFManager::getHotPixels ( const Glib::ustring filename )
}
}
- return nullptr;
+ return 0;
}
std::vector *DFManager::getHotPixels ( const std::string &mak, const std::string &mod, int iso, double shut, time_t t )
{
@@ -525,7 +527,7 @@ std::vector *DFManager::getHotPixels ( const std::string &mak, const std
return &df->getHotPixels();
} else {
- return nullptr;
+ return 0;
}
}
@@ -624,7 +626,7 @@ std::vector *DFManager::getBadPixels ( const std::string &mak, const std
}
if(!found) {
- return nullptr;
+ return 0;
} else {
return &(iter->second);
}
diff --git a/rtengine/diagonalcurves.cc b/rtengine/diagonalcurves.cc
index a5505391e..2178e3dac 100644
--- a/rtengine/diagonalcurves.cc
+++ b/rtengine/diagonalcurves.cc
@@ -245,7 +245,7 @@ void DiagonalCurve::NURBS_set ()
printf("sc_length[%zu/3]=%f \n", it, sc_length[it / 3]);
}
- printf("NURBS diagonal curve: error detected!\n i=%d nbr_points=%d ppn=%d N=%d sc_length[i/3]=%f total_length=%f", i, nbr_points, ppn, N, sc_length[i / 3], total_length);
+ printf("NURBS diagonal curve: error detected!\n i=%u nbr_points=%d ppn=%d N=%d sc_length[i/3]=%f total_length=%f", i, nbr_points, ppn, N, sc_length[i / 3], total_length);
exit(0);
}
diff --git a/rtengine/ffmanager.cc b/rtengine/ffmanager.cc
index eae00cad0..29121a696 100644
--- a/rtengine/ffmanager.cc
+++ b/rtengine/ffmanager.cc
@@ -31,17 +31,19 @@ extern const Settings* settings;
inline ffInfo& ffInfo::operator =(const ffInfo &o)
{
- pathname = o.pathname;
- maker = o.maker;
- model = o.model;
- lens = o.lens;
- shutter = o.shutter;
- focallength = o.focallength;
- timestamp = o.timestamp;
+ if (this != &o) {
+ pathname = o.pathname;
+ maker = o.maker;
+ model = o.model;
+ lens = o.lens;
+ focallength = o.focallength;
+ timestamp = o.timestamp;
+ aperture = o.aperture;
- if( ri ) {
- delete ri;
- ri = nullptr;
+ if( ri ) {
+ delete ri;
+ ri = NULL;
+ }
}
return *this;
@@ -131,7 +133,7 @@ void ffInfo::updateRawImage()
if( ri->loadRaw(true)) {
delete ri;
- ri = nullptr;
+ ri = NULL;
} else {
int H = ri->get_height();
int W = ri->get_width();
@@ -193,7 +195,7 @@ void ffInfo::updateRawImage()
if( ri->loadRaw(true)) {
delete ri;
- ri = nullptr;
+ ri = NULL;
} else {
ri->compress_image();
}
@@ -291,11 +293,11 @@ ffInfo* FFManager::addFileInfo (const Glib::ustring& filename, bool pool)
auto file = Gio::File::create_for_path (filename);
if (!file ) {
- return nullptr;
+ return 0;
}
if (!file->query_exists ()) {
- return nullptr;
+ return 0;
}
try {
@@ -303,11 +305,11 @@ ffInfo* FFManager::addFileInfo (const Glib::ustring& filename, bool pool)
auto info = file->query_info ();
if (!info || info->get_file_type () == Gio::FILE_TYPE_DIRECTORY) {
- return nullptr;
+ return 0;
}
if (!options.fbShowHidden && info->is_hidden ()) {
- return nullptr;
+ return 0;
}
Glib::ustring ext;
@@ -319,7 +321,7 @@ ffInfo* FFManager::addFileInfo (const Glib::ustring& filename, bool pool)
}
if (!options.is_extention_enabled (ext)) {
- return nullptr;
+ return 0;
}
@@ -327,7 +329,7 @@ ffInfo* FFManager::addFileInfo (const Glib::ustring& filename, bool pool)
int res = ri.loadRaw (false); // Read informations about shot
if (res != 0) {
- return nullptr;
+ return 0;
}
ffList_t::iterator iter;
@@ -367,7 +369,7 @@ ffInfo* FFManager::addFileInfo (const Glib::ustring& filename, bool pool)
} catch (Gio::Error&) {}
- return nullptr;
+ return 0;
}
void FFManager::getStat( int &totFiles, int &totTemplates)
@@ -394,7 +396,7 @@ void FFManager::getStat( int &totFiles, int &totTemplates)
ffInfo* FFManager::find( const std::string &mak, const std::string &mod, const std::string &len, double focal, double apert, time_t t )
{
if( ffList.empty() ) {
- return nullptr;
+ return 0;
}
std::string key( ffInfo::key(mak, mod, len, focal, apert) );
@@ -428,7 +430,7 @@ ffInfo* FFManager::find( const std::string &mak, const std::string &mod, const s
}
}
- return bestD != INFINITY ? &(bestMatch->second) : nullptr ;
+ return bestD != INFINITY ? &(bestMatch->second) : 0 ;
}
}
@@ -439,7 +441,7 @@ RawImage* FFManager::searchFlatField( const std::string &mak, const std::string
if( ff ) {
return ff->getRawImage();
} else {
- return nullptr;
+ return 0;
}
}
@@ -457,7 +459,7 @@ RawImage* FFManager::searchFlatField( const Glib::ustring filename )
return ff->getRawImage();
}
- return nullptr;
+ return 0;
}
diff --git a/rtengine/ffmanager.h b/rtengine/ffmanager.h
index f285bb5bf..4a65c2ed7 100644
--- a/rtengine/ffmanager.h
+++ b/rtengine/ffmanager.h
@@ -34,8 +34,6 @@ public:
std::string maker; ///< manufacturer
std::string model; ///< model
std::string lens; ///< lens
- int iso; ///< ISO (gain)
- double shutter; ///< shutter or exposure time in sec
double aperture; ///< aperture in stops
double focallength; ///< focal length in mm
time_t timestamp; ///< seconds since 1 Jan 1970
diff --git a/rtengine/flatcurves.cc b/rtengine/flatcurves.cc
index 5a4dfeacf..ae1a895ff 100644
--- a/rtengine/flatcurves.cc
+++ b/rtengine/flatcurves.cc
@@ -311,10 +311,10 @@ void FlatCurve::CtrlPoints_set ()
if (nbr_points < 0) {
for(size_t it = 0; it < sc_x.size(); it += 3) {
- printf("sc_length[%zd/3]=%f \n", it, sc_length[it / 3]);
+ printf("sc_length[%zu/3]=%f \n", it, sc_length[it / 3]);
}
- printf("Flat curve: error detected!\n i=%d k=%d periodic=%d nbr_points=%d ppn=%d N=%d sc_length[i/3]=%f total_length=%f\n", i, k, periodic, nbr_points, ppn, N, sc_length[i / 3], total_length);
+ printf("Flat curve: error detected!\n i=%u k=%u periodic=%d nbr_points=%d ppn=%d N=%d sc_length[i/3]=%f total_length=%f\n", i, k, periodic, nbr_points, ppn, N, sc_length[i / 3], total_length);
exit(0);
}
diff --git a/rtengine/hlrecovery.cc b/rtengine/hlrecovery.cc
deleted file mode 100644
index 4f527b660..000000000
--- a/rtengine/hlrecovery.cc
+++ /dev/null
@@ -1,397 +0,0 @@
-/*
- * This file is part of RawTherapee.
- *
- * Copyright (c) 2004-2010 Gabor Horvath
- *
- * 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 .
- */
-
-namespace rtengine
-{
-
-template T** allocArray (int W, int H)
-{
-
- T** t = new T*[H];
-
- for (int i = 0; i < H; i++) {
- t[i] = new T[W];
- }
-
- return t;
-}
-
-void RawImageSource::updateHLRecoveryMap (bool needred, bool needgreen, bool needblue, bool full)
-{
-
- // detect maximal pixel values
- unsigned short* red = new unsigned short[W];
- unsigned short* blue = new unsigned short[W];
- int maxr = 0, maxg = 0, maxb = 0;
-
- for (int i = 32; i < H - 32; i++) {
- interpolate_row_rb (red, blue, green[i - 1], green[i], green[i + 1], i);
-
- for (int j = 32; j < W - 32; j++) {
- if (red[j] > maxr) {
- maxr = red[j];
- }
-
- if (green[i][j] > maxg) {
- maxg = green[i][j];
- }
-
- if (blue[j] > maxb) {
- maxb = blue[j];
- }
- }
- }
-
- delete [] red;
- delete [] blue;
-
- maxr = maxr * 19 / 20;
- maxg = maxg * 19 / 20;
- maxb = maxb * 19 / 20;
- int max[3];
- max[0] = maxr;
- max[1] = maxg;
- max[2] = maxb;
-
- if( options.rtSettings.verbose ) {
- printf ("HLRecoveryMap Maximum: R: %d, G: %d, B: %d\n", maxr, maxg, maxb);
- }
-
- // downscale image
- int dw = W / SCALE;
- int dh = H / SCALE;
- Image16* ds = new Image16 (dw, dh);
-
- // overburnt areas
- int** rec[3];
-
- for (int i = 0; i < 3; i++) {
- rec[i] = allocArray (dw, dh);
- }
-
- unsigned short* reds[SCALE];
- unsigned short* blues[SCALE];
-
- for (int i = 0; i < SCALE; i++) {
- reds[i] = new unsigned short[W];
- blues[i] = new unsigned short[W];
- }
-
- for (int i = 0; i < dh; i++) {
- for (int j = 0; j < SCALE; j++) {
- interpolate_row_rb (reds[j], blues[j], green[SCALE * i + j - 1], green[SCALE * i + j], green[SCALE * i + j + 1], SCALE * i + j);
- }
-
- for (int j = 0; j < dw; j++) {
- int sumr = 0;
- int cr = 0;
- int sumg = 0;
- int cg = 0;
- int sumb = 0;
- int cb = 0;
-
- for (int x = 0; x < SCALE; x++)
- for (int y = 0; y < SCALE; y++) {
- int ix = SCALE * i + x;
- int jy = SCALE * j + y;
- sumr += reds[x][jy];
-
- if (reds[x][jy] < maxr) {
- cr++;
- }
-
- sumg += green[ix][jy];
-
- if (green[ix][jy] < maxg) {
- cg++;
- }
-
- sumb += blues[x][jy];
-
- if (blues[x][jy] < maxb) {
- cb++;
- }
- }
-
- if (cr < SCALE * SCALE && needred) {
- rec[0][i][j] = INT_MAX;
- } else {
- rec[0][i][j] = sumr / SCALE / SCALE;
- }
-
- if (cg < SCALE * SCALE && needgreen) {
- rec[1][i][j] = INT_MAX;
- } else {
- rec[1][i][j] = sumg / SCALE / SCALE;
- }
-
- if (cb < SCALE * SCALE && needblue) {
- rec[2][i][j] = INT_MAX;
- } else {
- rec[2][i][j] = sumb / SCALE / SCALE;
- }
-
- ds->r(i, j) = sumr / SCALE / SCALE;
- ds->g(i, j) = sumg / SCALE / SCALE;
- ds->b(i, j) = sumb / SCALE / SCALE;
- }
- }
-
- for (int i = 0; i < SCALE; i++) {
- delete [] reds[i];
- delete [] blues[i];
- }
-
-
- // STEP I. recover color from the partially lost areas
- bool phase2 = false;
-
- for (int k = 0; k < 400; k++) {
- if (k > 200) {
- phase2 = true;
- }
-
- for (int i = 1; i < dh - 1; i++)
- for (int j = 1; j < dw - 1; j++) {
- for (int c = 0; c < 3; c++) {
- // if channel c is lost
- if (rec[c][i][j] == INT_MAX) {
- double ratio[2] = {0.0, 0.0};
- double w[2] = {0.0, 0.0};
- int count[2] = {0, 0};
- int ix = 0;
-
- for (int m = 0; m < 3; m++) {
- if (m == c) {
- continue;
- }
-
- // if channel m is not lost at this point (or already recovered)
- if (rec[m][i][j] != INT_MAX && rec[m][i][j] >= 0) {
- for (int x = -1; x <= 1; x++)
- for (int y = -1; y <= 1; y++)
-
- // average m/c color ratios in the surrounding pixels
- if (rec[m][i + x][j + y] >= 0 && rec[m][i + x][j + y] != INT_MAX && rec[c][i + x][j + y] > 0 && rec[c][i + x][j + y] != INT_MAX) {
- double ww = 1.0;
-
- if (!phase2 && (/*(double)(rec[m][i+x][j+y] - rec[m][i][j])/max[m]*(rec[m][i+x][j+y] - rec[m][i][j])/max[m] > 1.0/2 || */rec[c][i + x][j + y] < max[c] * 3 / 4)) {
- continue;
- }
-
- w[ix] += ww;
- ratio[ix] += ww * rec[m][i + x][j + y] / rec[c][i + x][j + y];
- count[ix] ++;
- }
- }
-
- ix++;
- }
-
- // compute new pixel values from the surrounding color ratios
- double newc = 0.0;
- int nc = 0;
- ix = 0;
-
- for (int m = 0; m < 3; m++) {
- if (c == m) {
- continue;
- }
-
- if (count[ix]) {
- newc += (double)rec[m][i][j] / ratio[ix] * w[ix];
- nc++;
- }
-
- ix++;
- }
-
- if (nc) {
- rec[c][i][j] = - (int) (newc / nc);
- }
- }
- }
- }
-
- bool change = false;
-
- for (int i = 0; i < dh; i++)
- for (int j = 0; j < dw; j++)
- for (int c = 0; c < 3; c++) {
- if (rec[c][i][j] < 0) {
- rec[c][i][j] = -rec[c][i][j];
- }
-
- change = true;
- }
-
- if (!change) {
- break;
- }
- }
-
- printf ("Phase1 vege\n");
-
- // STEP II. recover fully lost pixels
- if (full) {
- int maxY = (299 * max[0] + 587 * max[1] + 114 * max[2]) / 1000;
- phase2 = false;
-
- for (int k = 0; k < 600; k++) {
- if (k > 200) {
- phase2 = true;
- }
-
- for (int i = 1; i < dh - 1; i++)
- for (int j = 1; j < dw - 1; j++) {
- if (rec[0][i][j] == INT_MAX || rec[1][i][j] == INT_MAX || rec[2][i][j] == INT_MAX) {
- int count = 0;
- double yavg = 0, iavg = 0, qavg = 0, weight = 0.0;
-
- for (int x = -1; x <= 1; x++)
- for (int y = -1; y <= 1; y++)
- if (rec[0][i + x][j + y] > 0 && rec[0][i + x][j + y] != INT_MAX && rec[1][i + x][j + y] > 0 && rec[1][i + x][j + y] != INT_MAX && rec[2][i + x][j + y] > 0 && rec[2][i + x][j + y] != INT_MAX) {
- // convert to yiq
- double Y = 0.299 * rec[0][i + x][j + y] + 0.587 * rec[1][i + x][j + y] + 0.114 * rec[2][i + x][j + y];
- double I = 0.596 * rec[0][i + x][j + y] - 0.275 * rec[1][i + x][j + y] - 0.321 * rec[2][i + x][j + y];
- double Q = 0.212 * rec[0][i + x][j + y] - 0.523 * rec[1][i + x][j + y] + 0.311 * rec[2][i + x][j + y];
-
- if (Y > maxY * 7 / 10) {
- double w = 1.0;// / (I*I+Q*Q);
- yavg += Y * w;
- iavg += I * w;
- qavg += Q * w;
- weight += w;
- count++;
- }
- }
-
- if ((!phase2 && count > 5) || (phase2 && count > 3)) {
- double Y = yavg / weight;
- double I = iavg / weight;
- double Q = qavg / weight;
- rec[0][i][j] = - (Y + 0.956 * I + 0.621 * Q);
- rec[1][i][j] = - (Y - 0.272 * I - 0.647 * Q);
- rec[2][i][j] = - (Y - 1.105 * I + 1.702 * Q);
- }
- }
-
- }
-
- bool change = false;
-
- for (int i = 0; i < dh; i++)
- for (int j = 0; j < dw; j++)
- for (int c = 0; c < 3; c++) {
- if (rec[c][i][j] < 0) {
- rec[c][i][j] = -rec[c][i][j];
- }
-
- change = true;
- }
-
- if (!change) {
- break;
- }
- }
- }
-
- int maxval = 0;
-
- for (int i = 0; i < dh; i++)
- for (int j = 0; j < dw; j++)
- for (int c = 0; c < 3; c++)
- if (rec[c][i][j] != INT_MAX && rec[c][i][j] > maxval) {
- maxval = rec[c][i][j];
- }
-
- for (int i = 0; i < dh; i++)
- for (int j = 0; j < dw; j++)
- if (rec[0][i][j] == INT_MAX || rec[1][i][j] == INT_MAX || rec[2][i][j] == INT_MAX) {
- rec[0][i][j] = maxval;
- rec[1][i][j] = maxval;
- rec[2][i][j] = maxval;
- }
-
- if (hrmap[0] != NULL) {
- freeArray (hrmap[0], dh);
- freeArray (hrmap[1], dh);
- freeArray (hrmap[2], dh);
- }
-
- hrmap[0] = allocArray (dw, dh);
- hrmap[1] = allocArray (dw, dh);
- hrmap[2] = allocArray (dw, dh);
-
- this->full = full;
-
- for (int i = 0; i < dh; i++)
- for (int j = 0; j < dw; j++) {
- hrmap[0][i][j] = (double)rec[0][i][j] / ds->r(i, j);
- hrmap[1][i][j] = (double)rec[1][i][j] / ds->g(i, j);
- hrmap[2][i][j] = (double)rec[2][i][j] / ds->b(i, j);
- }
-
- /* for (int i=0; ir(i,j) = CLIP (rec[0][i][j]);
- ds->g(i,j) = CLIP (rec[1][i][j]);
- ds->b(i,j) = CLIP (rec[2][i][j]);
- }
- ds->save ("test.png");
- */
- delete ds;
- freeArray (rec[0], dh);
- freeArray (rec[1], dh);
- freeArray (rec[2], dh);
-
- printf ("HLMap vege\n");
-}
-
-void RawImageSource::hlRecovery (unsigned short* red, unsigned short* green, unsigned short* blue, int i, int sx1, int sx2, int skip)
-{
-
- int blr = (i + SCALE / 2) / SCALE - 1;
-
- if (blr < 0 || blr >= H / SCALE - 1) {
- return;
- }
-
- double mr1 = 1.0 - ((double)((i + SCALE / 2) % SCALE) / SCALE + 0.5 / SCALE);
- int jx = 0;
- int maxcol = W / SCALE;
-
- for (int j = sx1, jx = 0; j < sx2; j += skip, jx++) {
- int blc = (j + SCALE / 2) / SCALE - 1;
-
- if (blc < 0 || blc >= maxcol - 1) {
- continue;
- }
-
- double mc1 = 1.0 - ((double)((j + SCALE / 2) % SCALE) / SCALE + 0.5 / SCALE);
- double mulr = mr1 * mc1 * hrmap[0][blr][blc] + mr1 * (1.0 - mc1) * hrmap[0][blr][blc + 1] + (1.0 - mr1) * mc1 * hrmap[0][blr + 1][blc] + (1.0 - mr1) * (1.0 - mc1) * hrmap[0][blr + 1][blc + 1];
- double mulg = mr1 * mc1 * hrmap[1][blr][blc] + mr1 * (1.0 - mc1) * hrmap[1][blr][blc + 1] + (1.0 - mr1) * mc1 * hrmap[1][blr + 1][blc] + (1.0 - mr1) * (1.0 - mc1) * hrmap[1][blr + 1][blc + 1];
- double mulb = mr1 * mc1 * hrmap[2][blr][blc] + mr1 * (1.0 - mc1) * hrmap[2][blr][blc + 1] + (1.0 - mr1) * mc1 * hrmap[2][blr + 1][blc] + (1.0 - mr1) * (1.0 - mc1) * hrmap[2][blr + 1][blc + 1];
- red[jx] = CLIP(red[jx] * mulr);
- green[jx] = CLIP(green[jx] * mulg);
- blue[jx] = CLIP(blue[jx] * mulb);
- }
-}
-}
-
diff --git a/rtengine/iccstore.cc b/rtengine/iccstore.cc
index 85409fd53..7b52a7a53 100644
--- a/rtengine/iccstore.cc
+++ b/rtengine/iccstore.cc
@@ -32,14 +32,15 @@
#include "../rtgui/options.h"
-namespace
+namespace rtengine
{
+extern const Settings* settings;
void loadProfiles (const Glib::ustring& dirName,
std::map* profiles,
- std::map* profileContents,
+ std::map* profileContents,
std::map* profileNames,
- bool nameUpper, bool onlyRgb)
+ bool nameUpper)
{
if (dirName.empty ()) {
return;
@@ -76,10 +77,10 @@ void loadProfiles (const Glib::ustring& dirName,
}
if (profiles) {
- const rtengine::ProfileContent content (filePath);
+ const ProfileContent content (filePath);
const cmsHPROFILE profile = content.toProfile ();
- if (profile && (!onlyRgb || cmsGetColorSpace (profile) == cmsSigRgbData)) {
+ if (profile) {
profiles->insert (std::make_pair (name, profile));
if (profileContents) {
@@ -95,20 +96,20 @@ void loadProfiles (const Glib::ustring& dirName,
} catch (Glib::Exception&) {}
}
-inline void getSupportedIntent (cmsHPROFILE profile, cmsUInt32Number intent, cmsUInt32Number direction, std::uint8_t& result)
+inline void getSupportedIntent (cmsHPROFILE profile, cmsUInt32Number intent, cmsUInt32Number direction, uint8_t& result)
{
if (cmsIsIntentSupported (profile, intent, direction)) {
result |= 1 << intent;
}
}
-inline std::uint8_t getSupportedIntents (cmsHPROFILE profile, cmsUInt32Number direction)
+inline uint8_t getSupportedIntents (cmsHPROFILE profile, cmsUInt32Number direction)
{
if (!profile) {
return 0;
}
- std::uint8_t result = 0;
+ uint8_t result = 0;
getSupportedIntent (profile, INTENT_PERCEPTUAL, direction, result);
getSupportedIntent (profile, INTENT_RELATIVE_COLORIMETRIC, direction, result);
@@ -121,7 +122,7 @@ inline std::uint8_t getSupportedIntents (cmsHPROFILE profile, cmsUInt32Number di
inline cmsHPROFILE createXYZProfile ()
{
double mat[3][3] = { {1.0, 0, 0}, {0, 1.0, 0}, {0, 0, 1.0} };
- return rtengine::ICCStore::createFromMatrix (mat, false, "XYZ");
+ return ICCStore::createFromMatrix (mat, false, "XYZ");
}
const double (*wprofiles[])[3] = {xyz_sRGB, xyz_adobe, xyz_prophoto, xyz_widegamut, xyz_bruce, xyz_beta, xyz_best, xyz_rec2020};
@@ -164,7 +165,7 @@ std::vector getWorkingProfiles ()
return res;
}
-std::vector ICCStore::getProfiles () const
+std::vector ICCStore::getProfiles (const bool onlyRgb) const
{
MyMutex::MyLock lock(mutex_);
@@ -172,6 +173,7 @@ std::vector ICCStore::getProfiles () const
std::vector res;
for (ProfileMap::const_iterator profile = fileProfiles.begin (); profile != fileProfiles.end (); ++profile) {
+ if (!onlyRgb || (onlyRgb && cmsGetColorSpace (profile->second) == cmsSigRgbData))
res.push_back (profile->first);
}
@@ -187,8 +189,8 @@ std::vector ICCStore::getProfilesFromDir (const Glib::ustring& di
ProfileMap profiles;
- loadProfiles (profilesDir, &profiles, nullptr, nullptr, false, true);
- loadProfiles (dirName, &profiles, nullptr, nullptr, false, true);
+ loadProfiles (profilesDir, &profiles, nullptr, nullptr, false);
+ loadProfiles (dirName, &profiles, nullptr, nullptr, false);
for (ProfileMap::const_iterator profile = profiles.begin (); profile != profiles.end (); ++profile) {
res.push_back (profile->first);
@@ -205,7 +207,7 @@ cmsHPROFILE ICCStore::makeStdGammaProfile (cmsHPROFILE iprof)
}
cmsUInt32Number bytesNeeded = 0;
- cmsSaveProfileToMem(iprof, nullptr, &bytesNeeded);
+ cmsSaveProfileToMem(iprof, 0, &bytesNeeded);
if (bytesNeeded == 0) {
return nullptr;
@@ -362,6 +364,312 @@ cmsHPROFILE ICCStore::workingSpaceGamma (const Glib::ustring& name) const
}
}
+void ICCStore::getGammaArray(const procparams::ColorManagementParams &icm, GammaValues &ga)
+{
+ const double eps = 0.000000001; // not divide by zero
+ if (!icm.freegamma) {//if Free gamma not selected
+ // gamma : ga[0],ga[1],ga[2],ga[3],ga[4],ga[5] by calcul
+ if(icm.gamma == "BT709_g2.2_s4.5") {
+ ga[0] = 2.22; //BT709 2.2 4.5 - my preferred as D.Coffin
+ ga[1] = 0.909995;
+ ga[2] = 0.090005;
+ ga[3] = 0.222222;
+ ga[4] = 0.081071;
+ } else if (icm.gamma == "sRGB_g2.4_s12.92") {
+ ga[0] = 2.40; //sRGB 2.4 12.92 - RT default as Lightroom
+ ga[1] = 0.947858;
+ ga[2] = 0.052142;
+ ga[3] = 0.077399;
+ ga[4] = 0.039293;
+ } else if (icm.gamma == "High_g1.3_s3.35") {
+ ga[0] = 1.3 ; //for high dynamic images
+ ga[1] = 0.998279;
+ ga[2] = 0.001721;
+ ga[3] = 0.298507;
+ ga[4] = 0.005746;
+ } else if (icm.gamma == "Low_g2.6_s6.9") {
+ ga[0] = 2.6 ; //gamma 2.6 variable : for low contrast images
+ ga[1] = 0.891161;
+ ga[2] = 0.108839;
+ ga[3] = 0.144928;
+ ga[4] = 0.076332;
+ } else if (icm.gamma == "standard_g2.2") {
+ ga[0] = 2.2; //gamma=2.2 (as gamma of Adobe, Widegamut...)
+ ga[1] = 1.;
+ ga[2] = 0.;
+ ga[3] = 1. / eps;
+ ga[4] = 0.;
+ } else if (icm.gamma == "standard_g1.8") {
+ ga[0] = 1.8; //gamma=1.8 (as gamma of Prophoto)
+ ga[1] = 1.;
+ ga[2] = 0.;
+ ga[3] = 1. / eps;
+ ga[4] = 0.;
+ } else /* if (icm.gamma == "linear_g1.0") */ {
+ ga[0] = 1.0; //gamma=1 linear : for high dynamic images (cf : D.Coffin...)
+ ga[1] = 1.;
+ ga[2] = 0.;
+ ga[3] = 1. / eps;
+ ga[4] = 0.;
+ }
+ ga[5] = 0.0;
+ ga[6] = 0.0;
+ } else { //free gamma selected
+ GammaValues g_a; //gamma parameters
+ double pwr = 1.0 / icm.gampos;
+ double ts = icm.slpos;
+ double slope = icm.slpos == 0 ? eps : icm.slpos;
+
+ int mode = 0, imax = 0;
+ Color::calcGamma(pwr, ts, mode, imax, g_a); // call to calcGamma with selected gamma and slope : return parameters for LCMS2
+ ga[4] = g_a[3] * ts;
+ //printf("g_a.gamma0=%f g_a.gamma1=%f g_a.gamma2=%f g_a.gamma3=%f g_a.gamma4=%f\n", g_a.gamma0,g_a.gamma1,g_a.gamma2,g_a.gamma3,g_a.gamma4);
+ ga[0] = icm.gampos;
+ ga[1] = 1. / (1.0 + g_a[4]);
+ ga[2] = g_a[4] / (1.0 + g_a[4]);
+ ga[3] = 1. / slope;
+ ga[5] = 0.0;
+ ga[6] = 0.0;
+ //printf("ga[0]=%f ga[1]=%f ga[2]=%f ga[3]=%f ga[4]=%f\n", ga[0],ga[1],ga[2],ga[3],ga[4]);
+ }
+}
+
+// WARNING: the caller must lock lcmsMutex
+cmsHPROFILE ICCStore::createGammaProfile (const procparams::ColorManagementParams &icm, GammaValues &ga) {
+ float p[6]; //primaries
+ ga[6] = 0.0;
+
+ enum class ColorTemp {
+ D50 = 5003, // for Widegamut, Prophoto Best, Beta -> D50
+ D65 = 6504 // for sRGB, AdobeRGB, Bruce Rec2020 -> D65
+ };
+ ColorTemp temp = ColorTemp::D50;
+
+ //primaries for 7 working profiles ==> output profiles
+ // eventually to adapt primaries if RT used special profiles !
+ if (icm.output == "WideGamut") {
+ p[0] = 0.7350; //Widegamut primaries
+ p[1] = 0.2650;
+ p[2] = 0.1150;
+ p[3] = 0.8260;
+ p[4] = 0.1570;
+ p[5] = 0.0180;
+ } else if (icm.output == "Adobe RGB") {
+ p[0] = 0.6400; //Adobe primaries
+ p[1] = 0.3300;
+ p[2] = 0.2100;
+ p[3] = 0.7100;
+ p[4] = 0.1500;
+ p[5] = 0.0600;
+ temp = ColorTemp::D65;
+ } else if (icm.output == "sRGB") {
+ p[0] = 0.6400; // sRGB primaries
+ p[1] = 0.3300;
+ p[2] = 0.3000;
+ p[3] = 0.6000;
+ p[4] = 0.1500;
+ p[5] = 0.0600;
+ temp = ColorTemp::D65;
+ } else if (icm.output == "BruceRGB") {
+ p[0] = 0.6400; // Bruce primaries
+ p[1] = 0.3300;
+ p[2] = 0.2800;
+ p[3] = 0.6500;
+ p[4] = 0.1500;
+ p[5] = 0.0600;
+ temp = ColorTemp::D65;
+ } else if (icm.output == "Beta RGB") {
+ p[0] = 0.6888; // Beta primaries
+ p[1] = 0.3112;
+ p[2] = 0.1986;
+ p[3] = 0.7551;
+ p[4] = 0.1265;
+ p[5] = 0.0352;
+ } else if (icm.output == "BestRGB") {
+ p[0] = 0.7347; // Best primaries
+ p[1] = 0.2653;
+ p[2] = 0.2150;
+ p[3] = 0.7750;
+ p[4] = 0.1300;
+ p[5] = 0.0350;
+ } else if (icm.output == "Rec2020") {
+ p[0] = 0.7080; // Rec2020 primaries
+ p[1] = 0.2920;
+ p[2] = 0.1700;
+ p[3] = 0.7970;
+ p[4] = 0.1310;
+ p[5] = 0.0460;
+ temp = ColorTemp::D65;
+ } else {
+ p[0] = 0.7347; //ProPhoto and default primaries
+ p[1] = 0.2653;
+ p[2] = 0.1596;
+ p[3] = 0.8404;
+ p[4] = 0.0366;
+ p[5] = 0.0001;
+ }
+
+ cmsCIExyY xyD;
+ cmsCIExyYTRIPLE Primaries = {
+ {p[0], p[1], 1.0}, // red
+ {p[2], p[3], 1.0}, // green
+ {p[4], p[5], 1.0} // blue
+ };
+ cmsToneCurve* GammaTRC[3];
+
+ // 7 parameters for smoother curves
+ cmsFloat64Number Parameters[7] = { ga[0], ga[1], ga[2], ga[3], ga[4], ga[5], ga[6] } ;
+
+ //lcmsMutex->lock (); Mutex acquired by the caller
+ cmsWhitePointFromTemp(&xyD, (double)temp);
+ GammaTRC[0] = GammaTRC[1] = GammaTRC[2] = cmsBuildParametricToneCurve(NULL, 5, Parameters); //5 = smoother than 4
+ cmsHPROFILE oprofdef = cmsCreateRGBProfile(&xyD, &Primaries, GammaTRC); //oprofdef become Outputprofile
+ cmsFreeToneCurve(GammaTRC[0]);
+ //lcmsMutex->unlock ();
+
+ return oprofdef;
+}
+
+// WARNING: the caller must lock lcmsMutex
+cmsHPROFILE ICCStore::createCustomGammaOutputProfile (const procparams::ColorManagementParams &icm, GammaValues &ga) {
+ bool pro = false;
+ Glib::ustring outProfile;
+ cmsHPROFILE outputProfile = nullptr;
+
+ if (icm.freegamma && icm.gampos < 1.35) {
+ pro = true; //select profil with gammaTRC modified :
+ } else if (icm.gamma == "linear_g1.0" || (icm.gamma == "High_g1.3_s3.35")) {
+ pro = true; //pro=0 RT_sRGB || Prophoto
+ }
+
+ // Check that output profiles exist, otherwise use LCMS2
+ // Use the icc/icm profiles associated to possible working profiles, set in "options"
+ if (icm.working == "ProPhoto" && iccStore->outputProfileExist(options.rtSettings.prophoto) && !pro) {
+ outProfile = options.rtSettings.prophoto;
+ } else if (icm.working == "Adobe RGB" && iccStore->outputProfileExist(options.rtSettings.adobe) ) {
+ outProfile = options.rtSettings.adobe;
+ } else if (icm.working == "WideGamut" && iccStore->outputProfileExist(options.rtSettings.widegamut) ) {
+ outProfile = options.rtSettings.widegamut;
+ } else if (icm.working == "Beta RGB" && iccStore->outputProfileExist(options.rtSettings.beta) ) {
+ outProfile = options.rtSettings.beta;
+ } else if (icm.working == "BestRGB" && iccStore->outputProfileExist(options.rtSettings.best) ) {
+ outProfile = options.rtSettings.best;
+ } else if (icm.working == "BruceRGB" && iccStore->outputProfileExist(options.rtSettings.bruce) ) {
+ outProfile = options.rtSettings.bruce;
+ } else if (icm.working == "sRGB" && iccStore->outputProfileExist(options.rtSettings.srgb) && !pro) {
+ outProfile = options.rtSettings.srgb;
+ } else if (icm.working == "sRGB" && iccStore->outputProfileExist(options.rtSettings.srgb10) && pro) {
+ outProfile = options.rtSettings.srgb10;
+ } else if (icm.working == "ProPhoto" && iccStore->outputProfileExist(options.rtSettings.prophoto10) && pro) {
+ outProfile = options.rtSettings.prophoto10;
+ } else if (icm.working == "Rec2020" && iccStore->outputProfileExist(options.rtSettings.rec2020) ) {
+ outProfile = options.rtSettings.rec2020;
+ } else {
+ // Should not occurs
+ if (settings->verbose) {
+ printf("\"%s\": unknown working profile! - use LCMS2 substitution\n", icm.working.c_str() );
+ }
+
+ return nullptr;
+ }
+
+ //begin adaptation rTRC gTRC bTRC
+ //"outputProfile" profile has the same characteristics than RGB values, but TRC are adapted... for applying profile
+ if (settings->verbose) {
+ printf("Output Gamma - profile: \"%s\"\n", outProfile.c_str() ); //c_str()
+ }
+
+ outputProfile = iccStore->getProfile(outProfile); //get output profile
+
+ if (outputProfile == nullptr) {
+
+ if (settings->verbose) {
+ printf("\"%s\" ICC output profile not found!\n", outProfile.c_str());
+ }
+ return nullptr;
+ }
+
+ // 7 parameters for smoother curves
+ cmsFloat64Number Parameters[7] = { ga[0], ga[1], ga[2], ga[3], ga[4], ga[5], ga[6] };
+
+ //change desc Tag , to "free gamma", or "BT709", etc.
+ cmsMLU *mlu;
+ cmsContext ContextID = cmsGetProfileContextID(outputProfile); // create context to modify some TAGs
+ mlu = cmsMLUalloc(ContextID, 1);
+
+ // instruction with //ICC are used to generate ICC profile
+ if (mlu == nullptr) {
+ printf("Description error\n");
+ } else {
+
+ // Description TAG : selection of gamma and Primaries
+ if (!icm.freegamma) {
+ std::wstring gammaStr;
+
+ if(icm.gamma == "High_g1.3_s3.35") {
+ gammaStr = std::wstring(L"GammaTRC: High g=1.3 s=3.35");
+ } else if (icm.gamma == "Low_g2.6_s6.9") {
+ gammaStr = std::wstring(L"GammaTRC: Low g=2.6 s=6.9");
+ } else if (icm.gamma == "sRGB_g2.4_s12.92") {
+ gammaStr = std::wstring(L"GammaTRC: sRGB g=2.4 s=12.92");
+ } else if (icm.gamma == "BT709_g2.2_s4.5") {
+ gammaStr = std::wstring(L"GammaTRC: BT709 g=2.2 s=4.5");
+ } else if (icm.gamma == "linear_g1.0") {
+ gammaStr = std::wstring(L"GammaTRC: Linear g=1.0");
+ } else if (icm.gamma == "standard_g2.2") {
+ gammaStr = std::wstring(L"GammaTRC: g=2.2");
+ } else if (icm.gamma == "standard_g1.8") {
+ gammaStr = std::wstring(L"GammaTRC: g=1.8");
+ }
+
+ cmsMLUsetWide(mlu, "en", "US", gammaStr.c_str());
+ } else {
+ // create description with gamma + slope + primaries
+ std::wostringstream gammaWs;
+ gammaWs.precision(2);
+ gammaWs << "Manual GammaTRC: g=" << (float)icm.gampos << " s=" << (float)icm.slpos;
+
+ cmsMLUsetWide(mlu, "en", "US", gammaWs.str().c_str());
+ }
+
+ cmsWriteTag(outputProfile, cmsSigProfileDescriptionTag, mlu);//desc changed
+
+ /*
+ cmsMLUsetWide(mlu, "en", "US", L"General Public License - AdobeRGB compatible");//adapt to profil
+ cmsWriteTag(outputProfile, cmsSigCopyrightTag, mlu);
+
+ cmsMLUsetWide(mlu, "en", "US", L"RawTherapee");
+ cmsWriteTag(outputProfile, cmsSigDeviceMfgDescTag, mlu);
+
+ cmsMLUsetWide(mlu, "en", "US", L"RTMedium"); //adapt to profil
+ cmsWriteTag(outputProfile, cmsSigDeviceModelDescTag, mlu);
+
+ */
+
+ cmsMLUfree (mlu);
+ }
+
+ // Calculate output profile's rTRC gTRC bTRC
+ cmsToneCurve* GammaTRC = nullptr;
+ GammaTRC = cmsBuildParametricToneCurve(nullptr, 5, Parameters);
+ cmsWriteTag(outputProfile, cmsSigRedTRCTag, (void*)GammaTRC );
+ cmsWriteTag(outputProfile, cmsSigGreenTRCTag, (void*)GammaTRC );
+ cmsWriteTag(outputProfile, cmsSigBlueTRCTag, (void*)GammaTRC );
+
+ if (GammaTRC) {
+ cmsFreeToneCurve(GammaTRC);
+ }
+
+ return outputProfile;
+}
+
+bool ICCStore::outputProfileExist (const Glib::ustring& name) const
+{
+
+ MyMutex::MyLock lock(mutex_);
+ return fileProfiles.find(name) != fileProfiles.end();
+}
+
cmsHPROFILE ICCStore::getProfile (const Glib::ustring& name) const
{
@@ -433,21 +741,21 @@ ProfileContent ICCStore::getContent (const Glib::ustring& name) const
return r != fileProfileContents.end () ? r->second : ProfileContent();
}
-std::uint8_t ICCStore::getInputIntents (cmsHPROFILE profile) const
+uint8_t ICCStore::getInputIntents (cmsHPROFILE profile) const
{
MyMutex::MyLock lock (mutex_);
return getSupportedIntents (profile, LCMS_USED_AS_INPUT);
}
-std::uint8_t ICCStore::getOutputIntents (cmsHPROFILE profile) const
+uint8_t ICCStore::getOutputIntents (cmsHPROFILE profile) const
{
MyMutex::MyLock lock (mutex_);
return getSupportedIntents (profile, LCMS_USED_AS_OUTPUT);
}
-std::uint8_t ICCStore::getProofIntents (cmsHPROFILE profile) const
+uint8_t ICCStore::getProofIntents (cmsHPROFILE profile) const
{
MyMutex::MyLock lock (mutex_);
@@ -464,15 +772,15 @@ void ICCStore::init (const Glib::ustring& usrICCDir, const Glib::ustring& rtICCD
profilesDir = Glib::build_filename (rtICCDir, "output");
fileProfiles.clear();
fileProfileContents.clear();
- loadProfiles (profilesDir, &fileProfiles, &fileProfileContents, nullptr, false, true);
- loadProfiles (usrICCDir, &fileProfiles, &fileProfileContents, nullptr, false, true);
+ loadProfiles (profilesDir, &fileProfiles, &fileProfileContents, nullptr, false);
+ loadProfiles (usrICCDir, &fileProfiles, &fileProfileContents, nullptr, false);
// Input profiles
// Load these to different areas, since the short name (e.g. "NIKON D700" may overlap between system/user and RT dir)
stdProfilesDir = Glib::build_filename (rtICCDir, "input");
fileStdProfiles.clear();
fileStdProfilesFileNames.clear();
- loadProfiles (stdProfilesDir, nullptr, nullptr, &fileStdProfilesFileNames, true, false);
+ loadProfiles (stdProfilesDir, nullptr, nullptr, &fileStdProfilesFileNames, true);
}
// Determine the first monitor default profile of operating system, if selected
@@ -551,7 +859,7 @@ ProfileContent::ProfileContent (cmsHPROFILE hProfile) : data(nullptr), length(0)
if (hProfile != nullptr) {
cmsUInt32Number bytesNeeded = 0;
- cmsSaveProfileToMem(hProfile, nullptr, &bytesNeeded);
+ cmsSaveProfileToMem(hProfile, 0, &bytesNeeded);
if (bytesNeeded > 0) {
data = new char[bytesNeeded + 1];
diff --git a/rtengine/iccstore.h b/rtengine/iccstore.h
index 62212e397..bb9693f1a 100644
--- a/rtengine/iccstore.h
+++ b/rtengine/iccstore.h
@@ -23,6 +23,9 @@
#include
#include