summaryrefslogtreecommitdiff
path: root/core/src/fxcodec/lcms2/lcms2-2.6/src/cmswtpnt.c
diff options
context:
space:
mode:
Diffstat (limited to 'core/src/fxcodec/lcms2/lcms2-2.6/src/cmswtpnt.c')
-rw-r--r--core/src/fxcodec/lcms2/lcms2-2.6/src/cmswtpnt.c349
1 files changed, 349 insertions, 0 deletions
diff --git a/core/src/fxcodec/lcms2/lcms2-2.6/src/cmswtpnt.c b/core/src/fxcodec/lcms2/lcms2-2.6/src/cmswtpnt.c
new file mode 100644
index 0000000000..903fdd7497
--- /dev/null
+++ b/core/src/fxcodec/lcms2/lcms2-2.6/src/cmswtpnt.c
@@ -0,0 +1,349 @@
+//---------------------------------------------------------------------------------
+//
+// Little Color Management System
+// Copyright (c) 1998-2014 Marti Maria Saguer
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the Software
+// is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//---------------------------------------------------------------------------------
+//
+
+#include "lcms2_internal.h"
+
+
+// D50 - Widely used
+const cmsCIEXYZ* CMSEXPORT cmsD50_XYZ(void)
+{
+ static cmsCIEXYZ D50XYZ = {cmsD50X, cmsD50Y, cmsD50Z};
+
+ return &D50XYZ;
+}
+
+const cmsCIExyY* CMSEXPORT cmsD50_xyY(void)
+{
+ static cmsCIExyY D50xyY;
+
+ cmsXYZ2xyY(&D50xyY, cmsD50_XYZ());
+
+ return &D50xyY;
+}
+
+// Obtains WhitePoint from Temperature
+cmsBool CMSEXPORT cmsWhitePointFromTemp(cmsCIExyY* WhitePoint, cmsFloat64Number TempK)
+{
+ cmsFloat64Number x, y;
+ cmsFloat64Number T, T2, T3;
+ // cmsFloat64Number M1, M2;
+
+ _cmsAssert(WhitePoint != NULL);
+
+ T = TempK;
+ T2 = T*T; // Square
+ T3 = T2*T; // Cube
+
+ // For correlated color temperature (T) between 4000K and 7000K:
+
+ if (T >= 4000. && T <= 7000.)
+ {
+ x = -4.6070*(1E9/T3) + 2.9678*(1E6/T2) + 0.09911*(1E3/T) + 0.244063;
+ }
+ else
+ // or for correlated color temperature (T) between 7000K and 25000K:
+
+ if (T > 7000.0 && T <= 25000.0)
+ {
+ x = -2.0064*(1E9/T3) + 1.9018*(1E6/T2) + 0.24748*(1E3/T) + 0.237040;
+ }
+ else {
+ cmsSignalError(0, cmsERROR_RANGE, "cmsWhitePointFromTemp: invalid temp");
+ return FALSE;
+ }
+
+ // Obtain y(x)
+
+ y = -3.000*(x*x) + 2.870*x - 0.275;
+
+ // wave factors (not used, but here for futures extensions)
+
+ // M1 = (-1.3515 - 1.7703*x + 5.9114 *y)/(0.0241 + 0.2562*x - 0.7341*y);
+ // M2 = (0.0300 - 31.4424*x + 30.0717*y)/(0.0241 + 0.2562*x - 0.7341*y);
+
+ WhitePoint -> x = x;
+ WhitePoint -> y = y;
+ WhitePoint -> Y = 1.0;
+
+ return TRUE;
+}
+
+
+
+typedef struct {
+
+ cmsFloat64Number mirek; // temp (in microreciprocal kelvin)
+ cmsFloat64Number ut; // u coord of intersection w/ blackbody locus
+ cmsFloat64Number vt; // v coord of intersection w/ blackbody locus
+ cmsFloat64Number tt; // slope of ISOTEMPERATURE. line
+
+ } ISOTEMPERATURE;
+
+static ISOTEMPERATURE isotempdata[] = {
+// {Mirek, Ut, Vt, Tt }
+ {0, 0.18006, 0.26352, -0.24341},
+ {10, 0.18066, 0.26589, -0.25479},
+ {20, 0.18133, 0.26846, -0.26876},
+ {30, 0.18208, 0.27119, -0.28539},
+ {40, 0.18293, 0.27407, -0.30470},
+ {50, 0.18388, 0.27709, -0.32675},
+ {60, 0.18494, 0.28021, -0.35156},
+ {70, 0.18611, 0.28342, -0.37915},
+ {80, 0.18740, 0.28668, -0.40955},
+ {90, 0.18880, 0.28997, -0.44278},
+ {100, 0.19032, 0.29326, -0.47888},
+ {125, 0.19462, 0.30141, -0.58204},
+ {150, 0.19962, 0.30921, -0.70471},
+ {175, 0.20525, 0.31647, -0.84901},
+ {200, 0.21142, 0.32312, -1.0182 },
+ {225, 0.21807, 0.32909, -1.2168 },
+ {250, 0.22511, 0.33439, -1.4512 },
+ {275, 0.23247, 0.33904, -1.7298 },
+ {300, 0.24010, 0.34308, -2.0637 },
+ {325, 0.24702, 0.34655, -2.4681 },
+ {350, 0.25591, 0.34951, -2.9641 },
+ {375, 0.26400, 0.35200, -3.5814 },
+ {400, 0.27218, 0.35407, -4.3633 },
+ {425, 0.28039, 0.35577, -5.3762 },
+ {450, 0.28863, 0.35714, -6.7262 },
+ {475, 0.29685, 0.35823, -8.5955 },
+ {500, 0.30505, 0.35907, -11.324 },
+ {525, 0.31320, 0.35968, -15.628 },
+ {550, 0.32129, 0.36011, -23.325 },
+ {575, 0.32931, 0.36038, -40.770 },
+ {600, 0.33724, 0.36051, -116.45 }
+};
+
+#define NISO sizeof(isotempdata)/sizeof(ISOTEMPERATURE)
+
+
+// Robertson's method
+cmsBool CMSEXPORT cmsTempFromWhitePoint(cmsFloat64Number* TempK, const cmsCIExyY* WhitePoint)
+{
+ cmsUInt32Number j;
+ cmsFloat64Number us,vs;
+ cmsFloat64Number uj,vj,tj,di,dj,mi,mj;
+ cmsFloat64Number xs, ys;
+
+ _cmsAssert(WhitePoint != NULL);
+ _cmsAssert(TempK != NULL);
+
+ di = mi = 0;
+ xs = WhitePoint -> x;
+ ys = WhitePoint -> y;
+
+ // convert (x,y) to CIE 1960 (u,WhitePoint)
+
+ us = (2*xs) / (-xs + 6*ys + 1.5);
+ vs = (3*ys) / (-xs + 6*ys + 1.5);
+
+
+ for (j=0; j < NISO; j++) {
+
+ uj = isotempdata[j].ut;
+ vj = isotempdata[j].vt;
+ tj = isotempdata[j].tt;
+ mj = isotempdata[j].mirek;
+
+ dj = ((vs - vj) - tj * (us - uj)) / sqrt(1.0 + tj * tj);
+
+ if ((j != 0) && (di/dj < 0.0)) {
+
+ // Found a match
+ *TempK = 1000000.0 / (mi + (di / (di - dj)) * (mj - mi));
+ return TRUE;
+ }
+
+ di = dj;
+ mi = mj;
+ }
+
+ // Not found
+ return FALSE;
+}
+
+
+// Compute chromatic adaptation matrix using Chad as cone matrix
+
+static
+cmsBool ComputeChromaticAdaptation(cmsMAT3* Conversion,
+ const cmsCIEXYZ* SourceWhitePoint,
+ const cmsCIEXYZ* DestWhitePoint,
+ const cmsMAT3* Chad)
+
+{
+
+ cmsMAT3 Chad_Inv;
+ cmsVEC3 ConeSourceXYZ, ConeSourceRGB;
+ cmsVEC3 ConeDestXYZ, ConeDestRGB;
+ cmsMAT3 Cone, Tmp;
+
+
+ Tmp = *Chad;
+ if (!_cmsMAT3inverse(&Tmp, &Chad_Inv)) return FALSE;
+
+ _cmsVEC3init(&ConeSourceXYZ, SourceWhitePoint -> X,
+ SourceWhitePoint -> Y,
+ SourceWhitePoint -> Z);
+
+ _cmsVEC3init(&ConeDestXYZ, DestWhitePoint -> X,
+ DestWhitePoint -> Y,
+ DestWhitePoint -> Z);
+
+ _cmsMAT3eval(&ConeSourceRGB, Chad, &ConeSourceXYZ);
+ _cmsMAT3eval(&ConeDestRGB, Chad, &ConeDestXYZ);
+
+ // Build matrix
+ _cmsVEC3init(&Cone.v[0], ConeDestRGB.n[0]/ConeSourceRGB.n[0], 0.0, 0.0);
+ _cmsVEC3init(&Cone.v[1], 0.0, ConeDestRGB.n[1]/ConeSourceRGB.n[1], 0.0);
+ _cmsVEC3init(&Cone.v[2], 0.0, 0.0, ConeDestRGB.n[2]/ConeSourceRGB.n[2]);
+
+
+ // Normalize
+ _cmsMAT3per(&Tmp, &Cone, Chad);
+ _cmsMAT3per(Conversion, &Chad_Inv, &Tmp);
+
+ return TRUE;
+}
+
+// Returns the final chrmatic adaptation from illuminant FromIll to Illuminant ToIll
+// The cone matrix can be specified in ConeMatrix. If NULL, Bradford is assumed
+cmsBool _cmsAdaptationMatrix(cmsMAT3* r, const cmsMAT3* ConeMatrix, const cmsCIEXYZ* FromIll, const cmsCIEXYZ* ToIll)
+{
+ cmsMAT3 LamRigg = {{ // Bradford matrix
+ {{ 0.8951, 0.2664, -0.1614 }},
+ {{ -0.7502, 1.7135, 0.0367 }},
+ {{ 0.0389, -0.0685, 1.0296 }}
+ }};
+
+ if (ConeMatrix == NULL)
+ ConeMatrix = &LamRigg;
+
+ return ComputeChromaticAdaptation(r, FromIll, ToIll, ConeMatrix);
+}
+
+// Same as anterior, but assuming D50 destination. White point is given in xyY
+static
+cmsBool _cmsAdaptMatrixToD50(cmsMAT3* r, const cmsCIExyY* SourceWhitePt)
+{
+ cmsCIEXYZ Dn;
+ cmsMAT3 Bradford;
+ cmsMAT3 Tmp;
+
+ cmsxyY2XYZ(&Dn, SourceWhitePt);
+
+ if (!_cmsAdaptationMatrix(&Bradford, NULL, &Dn, cmsD50_XYZ())) return FALSE;
+
+ Tmp = *r;
+ _cmsMAT3per(r, &Bradford, &Tmp);
+
+ return TRUE;
+}
+
+// Build a White point, primary chromas transfer matrix from RGB to CIE XYZ
+// This is just an approximation, I am not handling all the non-linear
+// aspects of the RGB to XYZ process, and assumming that the gamma correction
+// has transitive property in the tranformation chain.
+//
+// the alghoritm:
+//
+// - First I build the absolute conversion matrix using
+// primaries in XYZ. This matrix is next inverted
+// - Then I eval the source white point across this matrix
+// obtaining the coeficients of the transformation
+// - Then, I apply these coeficients to the original matrix
+//
+cmsBool _cmsBuildRGB2XYZtransferMatrix(cmsMAT3* r, const cmsCIExyY* WhitePt, const cmsCIExyYTRIPLE* Primrs)
+{
+ cmsVEC3 WhitePoint, Coef;
+ cmsMAT3 Result, Primaries;
+ cmsFloat64Number xn, yn;
+ cmsFloat64Number xr, yr;
+ cmsFloat64Number xg, yg;
+ cmsFloat64Number xb, yb;
+
+ xn = WhitePt -> x;
+ yn = WhitePt -> y;
+ xr = Primrs -> Red.x;
+ yr = Primrs -> Red.y;
+ xg = Primrs -> Green.x;
+ yg = Primrs -> Green.y;
+ xb = Primrs -> Blue.x;
+ yb = Primrs -> Blue.y;
+
+ // Build Primaries matrix
+ _cmsVEC3init(&Primaries.v[0], xr, xg, xb);
+ _cmsVEC3init(&Primaries.v[1], yr, yg, yb);
+ _cmsVEC3init(&Primaries.v[2], (1-xr-yr), (1-xg-yg), (1-xb-yb));
+
+
+ // Result = Primaries ^ (-1) inverse matrix
+ if (!_cmsMAT3inverse(&Primaries, &Result))
+ return FALSE;
+
+
+ _cmsVEC3init(&WhitePoint, xn/yn, 1.0, (1.0-xn-yn)/yn);
+
+ // Across inverse primaries ...
+ _cmsMAT3eval(&Coef, &Result, &WhitePoint);
+
+ // Give us the Coefs, then I build transformation matrix
+ _cmsVEC3init(&r -> v[0], Coef.n[VX]*xr, Coef.n[VY]*xg, Coef.n[VZ]*xb);
+ _cmsVEC3init(&r -> v[1], Coef.n[VX]*yr, Coef.n[VY]*yg, Coef.n[VZ]*yb);
+ _cmsVEC3init(&r -> v[2], Coef.n[VX]*(1.0-xr-yr), Coef.n[VY]*(1.0-xg-yg), Coef.n[VZ]*(1.0-xb-yb));
+
+
+ return _cmsAdaptMatrixToD50(r, WhitePt);
+
+}
+
+
+// Adapts a color to a given illuminant. Original color is expected to have
+// a SourceWhitePt white point.
+cmsBool CMSEXPORT cmsAdaptToIlluminant(cmsCIEXYZ* Result,
+ const cmsCIEXYZ* SourceWhitePt,
+ const cmsCIEXYZ* Illuminant,
+ const cmsCIEXYZ* Value)
+{
+ cmsMAT3 Bradford;
+ cmsVEC3 In, Out;
+
+ _cmsAssert(Result != NULL);
+ _cmsAssert(SourceWhitePt != NULL);
+ _cmsAssert(Illuminant != NULL);
+ _cmsAssert(Value != NULL);
+
+ if (!_cmsAdaptationMatrix(&Bradford, NULL, SourceWhitePt, Illuminant)) return FALSE;
+
+ _cmsVEC3init(&In, Value -> X, Value -> Y, Value -> Z);
+ _cmsMAT3eval(&Out, &Bradford, &In);
+
+ Result -> X = Out.n[0];
+ Result -> Y = Out.n[1];
+ Result -> Z = Out.n[2];
+
+ return TRUE;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-01 11:55:35 +0000