//--------------------------------------------------------------------------------- // // Little Color Management System // Copyright (c) 1998-2011 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" // ------------------------------------------------------------------------ // Gamut boundary description by using Jan Morovic's Segment maxima method // Many thanks to Jan for allowing me to use his algorithm. // r = C* // alpha = Hab // theta = L* #define SECTORS 16 // number of divisions in alpha and theta // Spherical coordinates typedef struct { cmsFloat64Number r; cmsFloat64Number alpha; cmsFloat64Number theta; } cmsSpherical; typedef enum { GP_EMPTY, GP_SPECIFIED, GP_MODELED } GDBPointType; typedef struct { GDBPointType Type; cmsSpherical p; // Keep also alpha & theta of maximum } cmsGDBPoint; typedef struct { cmsContext ContextID; cmsGDBPoint Gamut[SECTORS][SECTORS]; } cmsGDB; // A line using the parametric form // P = a + t*u typedef struct { cmsVEC3 a; cmsVEC3 u; } cmsLine; // A plane using the parametric form // Q = b + r*v + s*w typedef struct { cmsVEC3 b; cmsVEC3 v; cmsVEC3 w; } cmsPlane; // -------------------------------------------------------------------------------------------- // ATAN2() which always returns degree positive numbers static cmsFloat64Number _cmsAtan2(cmsFloat64Number y, cmsFloat64Number x) { cmsFloat64Number a; // Deal with undefined case if (x == 0.0 && y == 0.0) return 0; a = (atan2(y, x) * 180.0) / M_PI; while (a < 0) { a += 360; } return a; } // Convert to spherical coordinates static void ToSpherical(cmsSpherical* sp, const cmsVEC3* v) { cmsFloat64Number L, a, b; L = v ->n[VX]; a = v ->n[VY]; b = v ->n[VZ]; sp ->r = sqrt( L*L + a*a + b*b ); if (sp ->r == 0) { sp ->alpha = sp ->theta = 0; return; } sp ->alpha = _cmsAtan2(a, b); sp ->theta = _cmsAtan2(sqrt(a*a + b*b), L); } // Convert to cartesian from spherical static void ToCartesian(cmsVEC3* v, const cmsSpherical* sp) { cmsFloat64Number sin_alpha; cmsFloat64Number cos_alpha; cmsFloat64Number sin_theta; cmsFloat64Number cos_theta; cmsFloat64Number L, a, b; sin_alpha = sin((M_PI * sp ->alpha) / 180.0); cos_alpha = cos((M_PI * sp ->alpha) / 180.0); sin_theta = sin((M_PI * sp ->theta) / 180.0); cos_theta = cos((M_PI * sp ->theta) / 180.0); a = sp ->r * sin_theta * sin_alpha; b = sp ->r * sin_theta * cos_alpha; L = sp ->r * cos_theta; v ->n[VX] = L; v ->n[VY] = a; v ->n[VZ] = b; } // Quantize sector of a spherical coordinate. Saturate 360, 180 to last sector // The limits are the centers of each sector, so static void QuantizeToSector(const cmsSpherical* sp, int* alpha, int* theta) { *alpha = (int) floor(((sp->alpha * (SECTORS)) / 360.0) ); *theta = (int) floor(((sp->theta * (SECTORS)) / 180.0) ); if (*alpha >= SECTORS) *alpha = SECTORS-1; if (*theta >= SECTORS) *theta = SECTORS-1; } // Line determined by 2 points static void LineOf2Points(cmsLine* line, cmsVEC3* a, cmsVEC3* b) { _cmsVEC3init(&line ->a, a ->n[VX], a ->n[VY], a ->n[VZ]); _cmsVEC3init(&line ->u, b ->n[VX] - a ->n[VX], b ->n[VY] - a ->n[VY], b ->n[VZ] - a ->n[VZ]); } // Evaluate parametric line static void GetPointOfLine(cmsVEC3* p, const cmsLine* line, cmsFloat64Number t) { p ->n[VX] = line ->a.n[VX] + t * line->u.n[VX]; p ->n[VY] = line ->a.n[VY] + t * line->u.n[VY]; p ->n[VZ] = line ->a.n[VZ] + t * line->u.n[VZ]; } /* Closest point in sector line1 to sector line2 (both are defined as 0 <=t <= 1) http://softsurfer.com/Archive/algorithm_0106/algorithm_0106.htm Copyright 2001, softSurfer (www.softsurfer.com) This code may be freely used and modified for any purpose providing that this copyright notice is included with it. SoftSurfer makes no warranty for this code, and cannot be held liable for any real or imagined damage resulting from its use. Users of this code must verify correctness for their application. */ static cmsBool ClosestLineToLine(cmsVEC3* r, const cmsLine* line1, const cmsLine* line2) { cmsFloat64Number a, b, c, d, e, D; cmsFloat64Number sc, sN, sD; cmsFloat64Number tc, tN, tD; cmsVEC3 w0; _cmsVEC3minus(&w0, &line1 ->a, &line2 ->a); a = _cmsVEC3dot(&line1 ->u, &line1 ->u); b = _cmsVEC3dot(&line1 ->u, &line2 ->u); c = _cmsVEC3dot(&line2 ->u, &line2 ->u); d = _cmsVEC3dot(&line1 ->u, &w0); e = _cmsVEC3dot(&line2 ->u, &w0); D = a*c - b * b; // Denominator sD = tD = D; // default sD = D >= 0 if (D < MATRIX_DET_TOLERANCE) { // the lines are almost parallel sN = 0.0; // force using point P0 on segment S1 sD = 1.0; // to prevent possible division by 0.0 later tN = e; tD = c; } else { // get the closest points on the infinite lines sN = (b*e - c*d); tN = (a*e - b*d); if (sN < 0.0) { // sc < 0 => the s=0 edge is visible sN = 0.0; tN = e; tD = c; } else if (sN > sD) { // sc > 1 => the s=1 edge is visible sN = sD; tN = e + b; tD = c; } } if (tN < 0.0) { // tc < 0 => the t=0 edge is visible tN = 0.0; // recompute sc for this edge if (-d < 0.0) sN = 0.0; else if (-d > a) sN = sD; else { sN = -d; sD = a; } } else if (tN > tD) { // tc > 1 => the t=1 edge is visible tN = tD; // recompute sc for this edge if ((-d + b) < 0.0) sN = 0; else if ((-d + b) > a) sN = sD; else { sN = (-d + b); sD = a; } } // finally do the division to get sc and tc sc = (fabs(sN) < MATRIX_DET_TOLERANCE ? 0.0 : sN / sD); tc = (fabs(tN) < MATRIX_DET_TOLERANCE ? 0.0 : tN / tD); GetPointOfLine(r, line1, sc); return TRUE; } // ------------------------------------------------------------------ Wrapper // Allocate & free structure cmsHANDLE CMSEXPORT cmsGBDAlloc(cmsContext ContextID) { cmsGDB* gbd = (cmsGDB*) _cmsMallocZero(ContextID, sizeof(cmsGDB)); if (gbd == NULL) return NULL; gbd -> ContextID = ContextID; return (cmsHANDLE) gbd; } void CMSEXPORT cmsGBDFree(cmsHANDLE hGBD) { cmsGDB* gbd = (cmsGDB*) hGBD; if (hGBD != NULL) _cmsFree(gbd->ContextID, (void*) gbd); } // Auxiliar to retrieve a pointer to the segmentr containing the Lab value static cmsGDBPoint* GetPoint(cmsGDB* gbd, const cmsCIELab* Lab, cmsSpherical* sp) { cmsVEC3 v; int alpha, theta; // Housekeeping _cmsAssert(gbd != NULL); _cmsAssert(Lab != NULL); _cmsAssert(sp != NULL); // Center L* by substracting half of its domain, that's 50 _cmsVEC3init(&v, Lab ->L - 50.0, Lab ->a, Lab ->b); // Convert to spherical coordinates ToSpherical(sp, &v); if (sp ->r < 0 || sp ->alpha < 0 || sp->theta < 0) { cmsSignalError(gbd ->ContextID, cmsERROR_RANGE, "spherical value out of range"); return NULL; } // On which sector it falls? QuantizeToSector(sp, &alpha, &theta); if (alpha < 0 || theta < 0 || alpha >= SECTORS || theta >= SECTORS) { cmsSignalError(gbd ->ContextID, cmsERROR_RANGE, " quadrant out of range"); return NULL; } // Get pointer to the sector return &gbd ->Gamut[theta][alpha]; } // Add a point to gamut descriptor. Point to add is in Lab color space. // GBD is centered on a=b=0 and L*=50 cmsBool CMSEXPORT cmsGDBAddPoint(cmsHANDLE hGBD, const cmsCIELab* Lab) { cmsGDB* gbd = (cmsGDB*) hGBD; cmsGDBPoint* ptr; cmsSpherical sp; // Get pointer to the sector ptr = GetPoint(gbd, Lab, &sp); if (ptr == NULL) return FALSE; // If no samples at this sector, add it if (ptr ->Type == GP_EMPTY) { ptr -> Type = GP_SPECIFIED; ptr -> p = sp; } else { // Substitute only if radius is greater if (sp.r > ptr -> p.r) { ptr -> Type = GP_SPECIFIED; ptr -> p = sp; } } return TRUE; } // Check if a given point falls inside gamut cmsBool CMSEXPORT cmsGDBCheckPoint(cmsHANDLE hGBD, const cmsCIELab* Lab) { cmsGDB* gbd = (cmsGDB*) hGBD; cmsGDBPoint* ptr; cmsSpherical sp; // Get pointer to the sector ptr = GetPoint(gbd, Lab, &sp); if (ptr == NULL) return FALSE; // If no samples at this sector, return no data if (ptr ->Type == GP_EMPTY) return FALSE; // In gamut only if radius is greater return (sp.r <= ptr -> p.r); } // ----------------------------------------------------------------------------------------------------------------------- // Find near sectors. The list of sectors found is returned on Close[]. // The function returns the number of sectors as well. // 24 9 10 11 12 // 23 8 1 2 13 // 22 7 * 3 14 // 21 6 5 4 15 // 20 19 18 17 16 // // Those are the relative movements // {-2,-2}, {-1, -2}, {0, -2}, {+1, -2}, {+2, -2}, // {-2,-1}, {-1, -1}, {0, -1}, {+1, -1}, {+2, -1}, // {-2, 0}, {-1, 0}, {0, 0}, {+1, 0}, {+2, 0}, // {-2,+1}, {-1, +1}, {0, +1}, {+1, +1}, {+2, +1}, // {-2,+2}, {-1, +2}, {0, +2}, {+1, +2}, {+2, +2}}; static const struct _spiral { int AdvX, AdvY; } Spiral[] = { {0, -1}, {+1, -1}, {+1, 0}, {+1, +1}, {0, +1}, {-1, +1}, {-1, 0}, {-1, -1}, {-1, -2}, {0, -2}, {+1, -2}, {+2, -2}, {+2, -1}, {+2, 0}, {+2, +1}, {+2, +2}, {+1, +2}, {0, +2}, {-1, +2}, {-2, +2}, {-2, +1}, {-2, 0}, {-2, -1}, {-2, -2} }; #define NSTEPS (sizeof(Spiral) / sizeof(struct _spiral)) static int FindNearSectors(cmsGDB* gbd, int alpha, int theta, cmsGDBPoint* Close[]) { int nSectors = 0; int i, a, t; cmsGDBPoint* pt; for (i=0; i < NSTEPS; i++) { a = alpha + Spiral[i].AdvX; t = theta + Spiral[i].AdvY; // Cycle at the end a %= SECTORS; t %= SECTORS; // Cycle at the begin if (a < 0) a = SECTORS + a; if (t < 0) t = SECTORS + t; pt = &gbd ->Gamut[t][a]; if (pt -> Type != GP_EMPTY) { Close[nSectors++] = pt; } } return nSectors; } // Interpolate a missing sector. Method identifies whatever this is top, bottom or mid static cmsBool InterpolateMissingSector(cmsGDB* gbd, int alpha, int theta) { cmsSpherical sp; cmsVEC3 Lab; cmsVEC3 Centre; cmsLine ray; int nCloseSectors; cmsGDBPoint* Close[NSTEPS + 1]; cmsSpherical closel, templ; cmsLine edge; int k, m; // Is that point already specified? if (gbd ->Gamut[theta][alpha].Type != GP_EMPTY) return TRUE; // Fill close points nCloseSectors = FindNearSectors(gbd, alpha, theta, Close); // Find a central point on the sector sp.alpha = (cmsFloat64Number) ((alpha + 0.5) * 360.0) / (SECTORS); sp.theta = (cmsFloat64Number) ((theta + 0.5) * 180.0) / (SECTORS); sp.r = 50.0; // Convert to Cartesian ToCartesian(&Lab, &sp); // Create a ray line from centre to this point _cmsVEC3init(&Centre, 50.0, 0, 0); LineOf2Points(&ray, &Lab, &Centre); // For all close sectors closel.r = 0.0; closel.alpha = 0; closel.theta = 0; for (k=0; k < nCloseSectors; k++) { for(m = k+1; m < nCloseSectors; m++) { cmsVEC3 temp, a1, a2; // A line from sector to sector ToCartesian(&a1, &Close[k]->p); ToCartesian(&a2, &Close[m]->p); LineOf2Points(&edge, &a1, &a2); // Find a line ClosestLineToLine(&temp, &ray, &edge); // Convert to spherical ToSpherical(&templ, &temp); if ( templ.r > closel.r && templ.theta >= (theta*180.0/SECTORS) && templ.theta <= ((theta+1)*180.0/SECTORS) && templ.alpha >= (alpha*360.0/SECTORS) && templ.alpha <= ((alpha+1)*360.0/SECTORS)) { closel = templ; } } } gbd ->Gamut[theta][alpha].p = closel; gbd ->Gamut[theta][alpha].Type = GP_MODELED; return TRUE; } // Interpolate missing parts. The algorithm fist computes slices at // theta=0 and theta=Max. cmsBool CMSEXPORT cmsGDBCompute(cmsHANDLE hGBD, cmsUInt32Number dwFlags) { int alpha, theta; cmsGDB* gbd = (cmsGDB*) hGBD; _cmsAssert(hGBD != NULL); // Interpolate black for (alpha = 0; alpha <= SECTORS; alpha++) { if (!InterpolateMissingSector(gbd, alpha, 0)) return FALSE; } // Interpolate white for (alpha = 0; alpha <= SECTORS; alpha++) { if (!InterpolateMissingSector(gbd, alpha, SECTORS-1)) return FALSE; } // Interpolate Mid for (theta = 1; theta < SECTORS; theta++) { for (alpha = 0; alpha <= SECTORS; alpha++) { if (!InterpolateMissingSector(gbd, alpha, theta)) return FALSE; } } // Done return TRUE; cmsUNUSED_PARAMETER(dwFlags); } // -------------------------------------------------------------------------------------------------------- // Great for debug, but not suitable for real use #if 0 cmsBool cmsGBDdumpVRML(cmsHANDLE hGBD, const char* fname) { FILE* fp; int i, j; cmsGDB* gbd = (cmsGDB*) hGBD; cmsGDBPoint* pt; fp = fopen (fname, "wt"); if (fp == NULL) return FALSE; fprintf (fp, "#VRML V2.0 utf8\n"); // set the viewing orientation and distance fprintf (fp, "DEF CamTest Group {\n"); fprintf (fp, "\tchildren [\n"); fprintf (fp, "\t\tDEF Cameras Group {\n"); fprintf (fp, "\t\t\tchildren [\n"); fprintf (fp, "\t\t\t\tDEF DefaultView Viewpoint {\n"); fprintf (fp, "\t\t\t\t\tposition 0 0 340\n"); fprintf (fp, "\t\t\t\t\torientation 0 0 1 0\n"); fprintf (fp, "\t\t\t\t\tdescription \"default view\"\n"); fprintf (fp, "\t\t\t\t}\n"); fprintf (fp, "\t\t\t]\n"); fprintf (fp, "\t\t},\n"); fprintf (fp, "\t]\n"); fprintf (fp, "}\n"); // Output the background stuff fprintf (fp, "Background {\n"); fprintf (fp, "\tskyColor [\n"); fprintf (fp, "\t\t.5 .5 .5\n"); fprintf (fp, "\t]\n"); fprintf (fp, "}\n"); // Output the shape stuff fprintf (fp, "Transform {\n"); fprintf (fp, "\tscale .3 .3 .3\n"); fprintf (fp, "\tchildren [\n"); // Draw the axes as a shape: fprintf (fp, "\t\tShape {\n"); fprintf (fp, "\t\t\tappearance Appearance {\n"); fprintf (fp, "\t\t\t\tmaterial Material {\n"); fprintf (fp, "\t\t\t\t\tdiffuseColor 0 0.8 0\n"); fprintf (fp, "\t\t\t\t\temissiveColor 1.0 1.0 1.0\n"); fprintf (fp, "\t\t\t\t\tshininess 0.8\n"); fprintf (fp, "\t\t\t\t}\n"); fprintf (fp, "\t\t\t}\n"); fprintf (fp, "\t\t\tgeometry IndexedLineSet {\n"); fprintf (fp, "\t\t\t\tcoord Coordinate {\n"); fprintf (fp, "\t\t\t\t\tpoint [\n"); fprintf (fp, "\t\t\t\t\t0.0 0.0 0.0,\n"); fprintf (fp, "\t\t\t\t\t%f 0.0 0.0,\n", 255.0); fprintf (fp, "\t\t\t\t\t0.0 %f 0.0,\n", 255.0); fprintf (fp, "\t\t\t\t\t0.0 0.0 %f]\n", 255.0); fprintf (fp, "\t\t\t\t}\n"); fprintf (fp, "\t\t\t\tcoordIndex [\n"); fprintf (fp, "\t\t\t\t\t0, 1, -1\n"); fprintf (fp, "\t\t\t\t\t0, 2, -1\n"); fprintf (fp, "\t\t\t\t\t0, 3, -1]\n"); fprintf (fp, "\t\t\t}\n"); fprintf (fp, "\t\t}\n"); fprintf (fp, "\t\tShape {\n"); fprintf (fp, "\t\t\tappearance Appearance {\n"); fprintf (fp, "\t\t\t\tmaterial Material {\n"); fprintf (fp, "\t\t\t\t\tdiffuseColor 0 0.8 0\n"); fprintf (fp, "\t\t\t\t\temissiveColor 1 1 1\n"); fprintf (fp, "\t\t\t\t\tshininess 0.8\n"); fprintf (fp, "\t\t\t\t}\n"); fprintf (fp, "\t\t\t}\n"); fprintf (fp, "\t\t\tgeometry PointSet {\n"); // fill in the points here fprintf (fp, "\t\t\t\tcoord Coordinate {\n"); fprintf (fp, "\t\t\t\t\tpoint [\n"); // We need to transverse all gamut hull. for (i=0; i < SECTORS; i++) for (j=0; j < SECTORS; j++) { cmsVEC3 v; pt = &gbd ->Gamut[i][j]; ToCartesian(&v, &pt ->p); fprintf (fp, "\t\t\t\t\t%g %g %g", v.n[0]+50, v.n[1], v.n[2]); if ((j == SECTORS - 1) && (i == SECTORS - 1)) fprintf (fp, "]\n"); else fprintf (fp, ",\n"); } fprintf (fp, "\t\t\t\t}\n"); // fill in the face colors fprintf (fp, "\t\t\t\tcolor Color {\n"); fprintf (fp, "\t\t\t\t\tcolor [\n"); for (i=0; i < SECTORS; i++) for (j=0; j < SECTORS; j++) { cmsVEC3 v; pt = &gbd ->Gamut[i][j]; ToCartesian(&v, &pt ->p); if (pt ->Type == GP_EMPTY) fprintf (fp, "\t\t\t\t\t%g %g %g", 0.0, 0.0, 0.0); else if (pt ->Type == GP_MODELED) fprintf (fp, "\t\t\t\t\t%g %g %g", 1.0, .5, .5); else { fprintf (fp, "\t\t\t\t\t%g %g %g", 1.0, 1.0, 1.0); } if ((j == SECTORS - 1) && (i == SECTORS - 1)) fprintf (fp, "]\n"); else fprintf (fp, ",\n"); } fprintf (fp, "\t\t\t}\n"); fprintf (fp, "\t\t\t}\n"); fprintf (fp, "\t\t}\n"); fprintf (fp, "\t]\n"); fprintf (fp, "}\n"); fclose (fp); return TRUE; } #endif