1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.  Oracle designates this
   7  * particular file as subject to the "Classpath" exception as provided
   8  * by Oracle in the LICENSE file that accompanied this code.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  */
  24 
  25 // This file is available under and governed by the GNU General Public
  26 // License version 2 only, as published by the Free Software Foundation.
  27 // However, the following notice accompanied the original version of this
  28 // file:
  29 //
  30 //---------------------------------------------------------------------------------
  31 //
  32 //  Little Color Management System
  33 //  Copyright (c) 1998-2017 Marti Maria Saguer
  34 //
  35 // Permission is hereby granted, free of charge, to any person obtaining
  36 // a copy of this software and associated documentation files (the "Software"),
  37 // to deal in the Software without restriction, including without limitation
  38 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  39 // and/or sell copies of the Software, and to permit persons to whom the Software
  40 // is furnished to do so, subject to the following conditions:
  41 //
  42 // The above copyright notice and this permission notice shall be included in
  43 // all copies or substantial portions of the Software.
  44 //
  45 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  46 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  47 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  48 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  49 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  50 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  51 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  52 //
  53 //---------------------------------------------------------------------------------
  54 //
  55 
  56 #include "lcms2_internal.h"
  57 
  58 
  59 // ------------------------------------------------------------------------
  60 
  61 // Gamut boundary description by using Jan Morovic's Segment maxima method
  62 // Many thanks to Jan for allowing me to use his algorithm.
  63 
  64 // r = C*
  65 // alpha = Hab
  66 // theta = L*
  67 
  68 #define SECTORS 16      // number of divisions in alpha and theta
  69 
  70 // Spherical coordinates
  71 typedef struct {
  72 
  73     cmsFloat64Number r;
  74     cmsFloat64Number alpha;
  75     cmsFloat64Number theta;
  76 
  77 } cmsSpherical;
  78 
  79 typedef  enum {
  80         GP_EMPTY,
  81         GP_SPECIFIED,
  82         GP_MODELED
  83 
  84     } GDBPointType;
  85 
  86 
  87 typedef struct {
  88 
  89     GDBPointType Type;
  90     cmsSpherical p;         // Keep also alpha & theta of maximum
  91 
  92 } cmsGDBPoint;
  93 
  94 
  95 typedef struct {
  96 
  97     cmsContext ContextID;
  98     cmsGDBPoint Gamut[SECTORS][SECTORS];
  99 
 100 } cmsGDB;
 101 
 102 
 103 // A line using the parametric form
 104 // P = a + t*u
 105 typedef struct {
 106 
 107     cmsVEC3 a;
 108     cmsVEC3 u;
 109 
 110 } cmsLine;
 111 
 112 
 113 // A plane using the parametric form
 114 // Q = b + r*v + s*w
 115 typedef struct {
 116 
 117     cmsVEC3 b;
 118     cmsVEC3 v;
 119     cmsVEC3 w;
 120 
 121 } cmsPlane;
 122 
 123 
 124 
 125 // --------------------------------------------------------------------------------------------
 126 
 127 // ATAN2() which always returns degree positive numbers
 128 
 129 static
 130 cmsFloat64Number _cmsAtan2(cmsFloat64Number y, cmsFloat64Number x)
 131 {
 132     cmsFloat64Number a;
 133 
 134     // Deal with undefined case
 135     if (x == 0.0 && y == 0.0) return 0;
 136 
 137     a = (atan2(y, x) * 180.0) / M_PI;
 138 
 139     while (a < 0) {
 140         a += 360;
 141     }
 142 
 143     return a;
 144 }
 145 
 146 // Convert to spherical coordinates
 147 static
 148 void ToSpherical(cmsSpherical* sp, const cmsVEC3* v)
 149 {
 150 
 151     cmsFloat64Number L, a, b;
 152 
 153     L = v ->n[VX];
 154     a = v ->n[VY];
 155     b = v ->n[VZ];
 156 
 157     sp ->r = sqrt( L*L + a*a + b*b );
 158 
 159    if (sp ->r == 0) {
 160         sp ->alpha = sp ->theta = 0;
 161         return;
 162     }
 163 
 164     sp ->alpha = _cmsAtan2(a, b);
 165     sp ->theta = _cmsAtan2(sqrt(a*a + b*b), L);
 166 }
 167 
 168 
 169 // Convert to cartesian from spherical
 170 static
 171 void ToCartesian(cmsVEC3* v, const cmsSpherical* sp)
 172 {
 173     cmsFloat64Number sin_alpha;
 174     cmsFloat64Number cos_alpha;
 175     cmsFloat64Number sin_theta;
 176     cmsFloat64Number cos_theta;
 177     cmsFloat64Number L, a, b;
 178 
 179     sin_alpha = sin((M_PI * sp ->alpha) / 180.0);
 180     cos_alpha = cos((M_PI * sp ->alpha) / 180.0);
 181     sin_theta = sin((M_PI * sp ->theta) / 180.0);
 182     cos_theta = cos((M_PI * sp ->theta) / 180.0);
 183 
 184     a = sp ->r * sin_theta * sin_alpha;
 185     b = sp ->r * sin_theta * cos_alpha;
 186     L = sp ->r * cos_theta;
 187 
 188     v ->n[VX] = L;
 189     v ->n[VY] = a;
 190     v ->n[VZ] = b;
 191 }
 192 
 193 
 194 // Quantize sector of a spherical coordinate. Saturate 360, 180 to last sector
 195 // The limits are the centers of each sector, so
 196 static
 197 void QuantizeToSector(const cmsSpherical* sp, int* alpha, int* theta)
 198 {
 199     *alpha = (int) floor(((sp->alpha * (SECTORS)) / 360.0) );
 200     *theta = (int) floor(((sp->theta * (SECTORS)) / 180.0) );
 201 
 202     if (*alpha >= SECTORS)
 203         *alpha = SECTORS-1;
 204     if (*theta >= SECTORS)
 205         *theta = SECTORS-1;
 206 }
 207 
 208 
 209 // Line determined by 2 points
 210 static
 211 void LineOf2Points(cmsLine* line, cmsVEC3* a, cmsVEC3* b)
 212 {
 213 
 214     _cmsVEC3init(&line ->a, a ->n[VX], a ->n[VY], a ->n[VZ]);
 215     _cmsVEC3init(&line ->u, b ->n[VX] - a ->n[VX],
 216                             b ->n[VY] - a ->n[VY],
 217                             b ->n[VZ] - a ->n[VZ]);
 218 }
 219 
 220 
 221 // Evaluate parametric line
 222 static
 223 void GetPointOfLine(cmsVEC3* p, const cmsLine* line, cmsFloat64Number t)
 224 {
 225     p ->n[VX] = line ->a.n[VX] + t * line->u.n[VX];
 226     p ->n[VY] = line ->a.n[VY] + t * line->u.n[VY];
 227     p ->n[VZ] = line ->a.n[VZ] + t * line->u.n[VZ];
 228 }
 229 
 230 
 231 
 232 /*
 233     Closest point in sector line1 to sector line2 (both are defined as 0 <=t <= 1)
 234     http://softsurfer.com/Archive/algorithm_0106/algorithm_0106.htm
 235 
 236     Copyright 2001, softSurfer (www.softsurfer.com)
 237     This code may be freely used and modified for any purpose
 238     providing that this copyright notice is included with it.
 239     SoftSurfer makes no warranty for this code, and cannot be held
 240     liable for any real or imagined damage resulting from its use.
 241     Users of this code must verify correctness for their application.
 242 
 243 */
 244 
 245 static
 246 cmsBool ClosestLineToLine(cmsVEC3* r, const cmsLine* line1, const cmsLine* line2)
 247 {
 248     cmsFloat64Number a, b, c, d, e, D;
 249     cmsFloat64Number sc, sN, sD;
 250     //cmsFloat64Number tc; // left for future use
 251     cmsFloat64Number tN, tD;
 252     cmsVEC3 w0;
 253 
 254     _cmsVEC3minus(&w0, &line1 ->a, &line2 ->a);
 255 
 256     a  = _cmsVEC3dot(&line1 ->u, &line1 ->u);
 257     b  = _cmsVEC3dot(&line1 ->u, &line2 ->u);
 258     c  = _cmsVEC3dot(&line2 ->u, &line2 ->u);
 259     d  = _cmsVEC3dot(&line1 ->u, &w0);
 260     e  = _cmsVEC3dot(&line2 ->u, &w0);
 261 
 262     D  = a*c - b * b;      // Denominator
 263     sD = tD = D;           // default sD = D >= 0
 264 
 265     if (D <  MATRIX_DET_TOLERANCE) {   // the lines are almost parallel
 266 
 267         sN = 0.0;        // force using point P0 on segment S1
 268         sD = 1.0;        // to prevent possible division by 0.0 later
 269         tN = e;
 270         tD = c;
 271     }
 272     else {                // get the closest points on the infinite lines
 273 
 274         sN = (b*e - c*d);
 275         tN = (a*e - b*d);
 276 
 277         if (sN < 0.0) {       // sc < 0 => the s=0 edge is visible
 278 
 279             sN = 0.0;
 280             tN = e;
 281             tD = c;
 282         }
 283         else if (sN > sD) {   // sc > 1 => the s=1 edge is visible
 284             sN = sD;
 285             tN = e + b;
 286             tD = c;
 287         }
 288     }
 289 
 290     if (tN < 0.0) {           // tc < 0 => the t=0 edge is visible
 291 
 292         tN = 0.0;
 293         // recompute sc for this edge
 294         if (-d < 0.0)
 295             sN = 0.0;
 296         else if (-d > a)
 297             sN = sD;
 298         else {
 299             sN = -d;
 300             sD = a;
 301         }
 302     }
 303     else if (tN > tD) {      // tc > 1 => the t=1 edge is visible
 304 
 305         tN = tD;
 306 
 307         // recompute sc for this edge
 308         if ((-d + b) < 0.0)
 309             sN = 0;
 310         else if ((-d + b) > a)
 311             sN = sD;
 312         else {
 313             sN = (-d + b);
 314             sD = a;
 315         }
 316     }
 317     // finally do the division to get sc and tc
 318     sc = (fabs(sN) < MATRIX_DET_TOLERANCE ? 0.0 : sN / sD);
 319     //tc = (fabs(tN) < MATRIX_DET_TOLERANCE ? 0.0 : tN / tD); // left for future use.
 320 
 321     GetPointOfLine(r, line1, sc);
 322     return TRUE;
 323 }
 324 
 325 
 326 
 327 // ------------------------------------------------------------------ Wrapper
 328 
 329 
 330 // Allocate & free structure
 331 cmsHANDLE  CMSEXPORT cmsGBDAlloc(cmsContext ContextID)
 332 {
 333     cmsGDB* gbd = (cmsGDB*) _cmsMallocZero(ContextID, sizeof(cmsGDB));
 334     if (gbd == NULL) return NULL;
 335 
 336     gbd -> ContextID = ContextID;
 337 
 338     return (cmsHANDLE) gbd;
 339 }
 340 
 341 
 342 void CMSEXPORT cmsGBDFree(cmsHANDLE hGBD)
 343 {
 344     cmsGDB* gbd = (cmsGDB*) hGBD;
 345     if (hGBD != NULL)
 346         _cmsFree(gbd->ContextID, (void*) gbd);
 347 }
 348 
 349 
 350 // Auxiliary to retrieve a pointer to the segmentr containing the Lab value
 351 static
 352 cmsGDBPoint* GetPoint(cmsGDB* gbd, const cmsCIELab* Lab, cmsSpherical* sp)
 353 {
 354     cmsVEC3 v;
 355     int alpha, theta;
 356 
 357     // Housekeeping
 358     _cmsAssert(gbd != NULL);
 359     _cmsAssert(Lab != NULL);
 360     _cmsAssert(sp != NULL);
 361 
 362     // Center L* by subtracting half of its domain, that's 50
 363     _cmsVEC3init(&v, Lab ->L - 50.0, Lab ->a, Lab ->b);
 364 
 365     // Convert to spherical coordinates
 366     ToSpherical(sp, &v);
 367 
 368     if (sp ->r < 0 || sp ->alpha < 0 || sp->theta < 0) {
 369          cmsSignalError(gbd ->ContextID, cmsERROR_RANGE, "spherical value out of range");
 370          return NULL;
 371     }
 372 
 373     // On which sector it falls?
 374     QuantizeToSector(sp, &alpha, &theta);
 375 
 376     if (alpha < 0 || theta < 0 || alpha >= SECTORS || theta >= SECTORS) {
 377          cmsSignalError(gbd ->ContextID, cmsERROR_RANGE, " quadrant out of range");
 378          return NULL;
 379     }
 380 
 381     // Get pointer to the sector
 382     return &gbd ->Gamut[theta][alpha];
 383 }
 384 
 385 // Add a point to gamut descriptor. Point to add is in Lab color space.
 386 // GBD is centered on a=b=0 and L*=50
 387 cmsBool CMSEXPORT cmsGDBAddPoint(cmsHANDLE hGBD, const cmsCIELab* Lab)
 388 {
 389     cmsGDB* gbd = (cmsGDB*) hGBD;
 390     cmsGDBPoint* ptr;
 391     cmsSpherical sp;
 392 
 393 
 394     // Get pointer to the sector
 395     ptr = GetPoint(gbd, Lab, &sp);
 396     if (ptr == NULL) return FALSE;
 397 
 398     // If no samples at this sector, add it
 399     if (ptr ->Type == GP_EMPTY) {
 400 
 401         ptr -> Type = GP_SPECIFIED;
 402         ptr -> p    = sp;
 403     }
 404     else {
 405 
 406 
 407         // Substitute only if radius is greater
 408         if (sp.r > ptr -> p.r) {
 409 
 410                 ptr -> Type = GP_SPECIFIED;
 411                 ptr -> p    = sp;
 412         }
 413     }
 414 
 415     return TRUE;
 416 }
 417 
 418 // Check if a given point falls inside gamut
 419 cmsBool CMSEXPORT cmsGDBCheckPoint(cmsHANDLE hGBD, const cmsCIELab* Lab)
 420 {
 421     cmsGDB* gbd = (cmsGDB*) hGBD;
 422     cmsGDBPoint* ptr;
 423     cmsSpherical sp;
 424 
 425     // Get pointer to the sector
 426     ptr = GetPoint(gbd, Lab, &sp);
 427     if (ptr == NULL) return FALSE;
 428 
 429     // If no samples at this sector, return no data
 430     if (ptr ->Type == GP_EMPTY) return FALSE;
 431 
 432     // In gamut only if radius is greater
 433 
 434     return (sp.r <= ptr -> p.r);
 435 }
 436 
 437 // -----------------------------------------------------------------------------------------------------------------------
 438 
 439 // Find near sectors. The list of sectors found is returned on Close[].
 440 // The function returns the number of sectors as well.
 441 
 442 // 24   9  10  11  12
 443 // 23   8   1   2  13
 444 // 22   7   *   3  14
 445 // 21   6   5   4  15
 446 // 20  19  18  17  16
 447 //
 448 // Those are the relative movements
 449 // {-2,-2}, {-1, -2}, {0, -2}, {+1, -2}, {+2,  -2},
 450 // {-2,-1}, {-1, -1}, {0, -1}, {+1, -1}, {+2,  -1},
 451 // {-2, 0}, {-1,  0}, {0,  0}, {+1,  0}, {+2,   0},
 452 // {-2,+1}, {-1, +1}, {0, +1}, {+1,  +1}, {+2,  +1},
 453 // {-2,+2}, {-1, +2}, {0, +2}, {+1,  +2}, {+2,  +2}};
 454 
 455 
 456 static
 457 const struct _spiral {
 458 
 459     int AdvX, AdvY;
 460 
 461     } Spiral[] = { {0,  -1}, {+1, -1}, {+1,  0}, {+1, +1}, {0,  +1}, {-1, +1},
 462                    {-1,  0}, {-1, -1}, {-1, -2}, {0,  -2}, {+1, -2}, {+2, -2},
 463                    {+2, -1}, {+2,  0}, {+2, +1}, {+2, +2}, {+1, +2}, {0,  +2},
 464                    {-1, +2}, {-2, +2}, {-2, +1}, {-2, 0},  {-2, -1}, {-2, -2} };
 465 
 466 #define NSTEPS (sizeof(Spiral) / sizeof(struct _spiral))
 467 
 468 static
 469 int FindNearSectors(cmsGDB* gbd, int alpha, int theta, cmsGDBPoint* Close[])
 470 {
 471     int nSectors = 0;
 472     int a, t;
 473     cmsUInt32Number i;
 474     cmsGDBPoint* pt;
 475 
 476     for (i=0; i < NSTEPS; i++) {
 477 
 478         a = alpha + Spiral[i].AdvX;
 479         t = theta + Spiral[i].AdvY;
 480 
 481         // Cycle at the end
 482         a %= SECTORS;
 483         t %= SECTORS;
 484 
 485         // Cycle at the begin
 486         if (a < 0) a = SECTORS + a;
 487         if (t < 0) t = SECTORS + t;
 488 
 489         pt = &gbd ->Gamut[t][a];
 490 
 491         if (pt -> Type != GP_EMPTY) {
 492 
 493             Close[nSectors++] = pt;
 494         }
 495     }
 496 
 497     return nSectors;
 498 }
 499 
 500 
 501 // Interpolate a missing sector. Method identifies whatever this is top, bottom or mid
 502 static
 503 cmsBool InterpolateMissingSector(cmsGDB* gbd, int alpha, int theta)
 504 {
 505     cmsSpherical sp;
 506     cmsVEC3 Lab;
 507     cmsVEC3 Centre;
 508     cmsLine ray;
 509     int nCloseSectors;
 510     cmsGDBPoint* Close[NSTEPS + 1];
 511     cmsSpherical closel, templ;
 512     cmsLine edge;
 513     int k, m;
 514 
 515     // Is that point already specified?
 516     if (gbd ->Gamut[theta][alpha].Type != GP_EMPTY) return TRUE;
 517 
 518     // Fill close points
 519     nCloseSectors = FindNearSectors(gbd, alpha, theta, Close);
 520 
 521 
 522     // Find a central point on the sector
 523     sp.alpha = (cmsFloat64Number) ((alpha + 0.5) * 360.0) / (SECTORS);
 524     sp.theta = (cmsFloat64Number) ((theta + 0.5) * 180.0) / (SECTORS);
 525     sp.r     = 50.0;
 526 
 527     // Convert to Cartesian
 528     ToCartesian(&Lab, &sp);
 529 
 530     // Create a ray line from centre to this point
 531     _cmsVEC3init(&Centre, 50.0, 0, 0);
 532     LineOf2Points(&ray, &Lab, &Centre);
 533 
 534     // For all close sectors
 535     closel.r = 0.0;
 536     closel.alpha = 0;
 537     closel.theta = 0;
 538 
 539     for (k=0; k < nCloseSectors; k++) {
 540 
 541         for(m = k+1; m < nCloseSectors; m++) {
 542 
 543             cmsVEC3 temp, a1, a2;
 544 
 545             // A line from sector to sector
 546             ToCartesian(&a1, &Close[k]->p);
 547             ToCartesian(&a2, &Close[m]->p);
 548 
 549             LineOf2Points(&edge, &a1, &a2);
 550 
 551             // Find a line
 552             ClosestLineToLine(&temp, &ray, &edge);
 553 
 554             // Convert to spherical
 555             ToSpherical(&templ, &temp);
 556 
 557 
 558             if ( templ.r > closel.r &&
 559                  templ.theta >= (theta*180.0/SECTORS) &&
 560                  templ.theta <= ((theta+1)*180.0/SECTORS) &&
 561                  templ.alpha >= (alpha*360.0/SECTORS) &&
 562                  templ.alpha <= ((alpha+1)*360.0/SECTORS)) {
 563 
 564                 closel = templ;
 565             }
 566         }
 567     }
 568 
 569     gbd ->Gamut[theta][alpha].p = closel;
 570     gbd ->Gamut[theta][alpha].Type = GP_MODELED;
 571 
 572     return TRUE;
 573 
 574 }
 575 
 576 
 577 // Interpolate missing parts. The algorithm fist computes slices at
 578 // theta=0 and theta=Max.
 579 cmsBool CMSEXPORT cmsGDBCompute(cmsHANDLE hGBD, cmsUInt32Number dwFlags)
 580 {
 581     int alpha, theta;
 582     cmsGDB* gbd = (cmsGDB*) hGBD;
 583 
 584     _cmsAssert(hGBD != NULL);
 585 
 586     // Interpolate black
 587     for (alpha = 0; alpha < SECTORS; alpha++) {
 588 
 589         if (!InterpolateMissingSector(gbd, alpha, 0)) return FALSE;
 590     }
 591 
 592     // Interpolate white
 593     for (alpha = 0; alpha < SECTORS; alpha++) {
 594 
 595         if (!InterpolateMissingSector(gbd, alpha, SECTORS-1)) return FALSE;
 596     }
 597 
 598 
 599     // Interpolate Mid
 600     for (theta = 1; theta < SECTORS; theta++) {
 601         for (alpha = 0; alpha < SECTORS; alpha++) {
 602 
 603             if (!InterpolateMissingSector(gbd, alpha, theta)) return FALSE;
 604         }
 605     }
 606 
 607     // Done
 608     return TRUE;
 609 
 610     cmsUNUSED_PARAMETER(dwFlags);
 611 }
 612 
 613 
 614 
 615 
 616 // --------------------------------------------------------------------------------------------------------
 617 
 618 // Great for debug, but not suitable for real use
 619 
 620 #if 0
 621 cmsBool cmsGBDdumpVRML(cmsHANDLE hGBD, const char* fname)
 622 {
 623     FILE* fp;
 624     int   i, j;
 625     cmsGDB* gbd = (cmsGDB*) hGBD;
 626     cmsGDBPoint* pt;
 627 
 628     fp = fopen (fname, "wt");
 629     if (fp == NULL)
 630         return FALSE;
 631 
 632     fprintf (fp, "#VRML V2.0 utf8\n");
 633 
 634     // set the viewing orientation and distance
 635     fprintf (fp, "DEF CamTest Group {\n");
 636     fprintf (fp, "\tchildren [\n");
 637     fprintf (fp, "\t\tDEF Cameras Group {\n");
 638     fprintf (fp, "\t\t\tchildren [\n");
 639     fprintf (fp, "\t\t\t\tDEF DefaultView Viewpoint {\n");
 640     fprintf (fp, "\t\t\t\t\tposition 0 0 340\n");
 641     fprintf (fp, "\t\t\t\t\torientation 0 0 1 0\n");
 642     fprintf (fp, "\t\t\t\t\tdescription \"default view\"\n");
 643     fprintf (fp, "\t\t\t\t}\n");
 644     fprintf (fp, "\t\t\t]\n");
 645     fprintf (fp, "\t\t},\n");
 646     fprintf (fp, "\t]\n");
 647     fprintf (fp, "}\n");
 648 
 649     // Output the background stuff
 650     fprintf (fp, "Background {\n");
 651     fprintf (fp, "\tskyColor [\n");
 652     fprintf (fp, "\t\t.5 .5 .5\n");
 653     fprintf (fp, "\t]\n");
 654     fprintf (fp, "}\n");
 655 
 656     // Output the shape stuff
 657     fprintf (fp, "Transform {\n");
 658     fprintf (fp, "\tscale .3 .3 .3\n");
 659     fprintf (fp, "\tchildren [\n");
 660 
 661     // Draw the axes as a shape:
 662     fprintf (fp, "\t\tShape {\n");
 663     fprintf (fp, "\t\t\tappearance Appearance {\n");
 664     fprintf (fp, "\t\t\t\tmaterial Material {\n");
 665     fprintf (fp, "\t\t\t\t\tdiffuseColor 0 0.8 0\n");
 666     fprintf (fp, "\t\t\t\t\temissiveColor 1.0 1.0 1.0\n");
 667     fprintf (fp, "\t\t\t\t\tshininess 0.8\n");
 668     fprintf (fp, "\t\t\t\t}\n");
 669     fprintf (fp, "\t\t\t}\n");
 670     fprintf (fp, "\t\t\tgeometry IndexedLineSet {\n");
 671     fprintf (fp, "\t\t\t\tcoord Coordinate {\n");
 672     fprintf (fp, "\t\t\t\t\tpoint [\n");
 673     fprintf (fp, "\t\t\t\t\t0.0 0.0 0.0,\n");
 674     fprintf (fp, "\t\t\t\t\t%f 0.0 0.0,\n",  255.0);
 675     fprintf (fp, "\t\t\t\t\t0.0 %f 0.0,\n",  255.0);
 676     fprintf (fp, "\t\t\t\t\t0.0 0.0 %f]\n",  255.0);
 677     fprintf (fp, "\t\t\t\t}\n");
 678     fprintf (fp, "\t\t\t\tcoordIndex [\n");
 679     fprintf (fp, "\t\t\t\t\t0, 1, -1\n");
 680     fprintf (fp, "\t\t\t\t\t0, 2, -1\n");
 681     fprintf (fp, "\t\t\t\t\t0, 3, -1]\n");
 682     fprintf (fp, "\t\t\t}\n");
 683     fprintf (fp, "\t\t}\n");
 684 
 685 
 686     fprintf (fp, "\t\tShape {\n");
 687     fprintf (fp, "\t\t\tappearance Appearance {\n");
 688     fprintf (fp, "\t\t\t\tmaterial Material {\n");
 689     fprintf (fp, "\t\t\t\t\tdiffuseColor 0 0.8 0\n");
 690     fprintf (fp, "\t\t\t\t\temissiveColor 1 1 1\n");
 691     fprintf (fp, "\t\t\t\t\tshininess 0.8\n");
 692     fprintf (fp, "\t\t\t\t}\n");
 693     fprintf (fp, "\t\t\t}\n");
 694     fprintf (fp, "\t\t\tgeometry PointSet {\n");
 695 
 696     // fill in the points here
 697     fprintf (fp, "\t\t\t\tcoord Coordinate {\n");
 698     fprintf (fp, "\t\t\t\t\tpoint [\n");
 699 
 700     // We need to transverse all gamut hull.
 701     for (i=0; i < SECTORS; i++)
 702         for (j=0; j < SECTORS; j++) {
 703 
 704             cmsVEC3 v;
 705 
 706             pt = &gbd ->Gamut[i][j];
 707             ToCartesian(&v, &pt ->p);
 708 
 709             fprintf (fp, "\t\t\t\t\t%g %g %g", v.n[0]+50, v.n[1], v.n[2]);
 710 
 711             if ((j == SECTORS - 1) && (i == SECTORS - 1))
 712                 fprintf (fp, "]\n");
 713             else
 714                 fprintf (fp, ",\n");
 715 
 716         }
 717 
 718         fprintf (fp, "\t\t\t\t}\n");
 719 
 720 
 721 
 722     // fill in the face colors
 723     fprintf (fp, "\t\t\t\tcolor Color {\n");
 724     fprintf (fp, "\t\t\t\t\tcolor [\n");
 725 
 726     for (i=0; i < SECTORS; i++)
 727         for (j=0; j < SECTORS; j++) {
 728 
 729            cmsVEC3 v;
 730 
 731             pt = &gbd ->Gamut[i][j];
 732 
 733 
 734             ToCartesian(&v, &pt ->p);
 735 
 736 
 737         if (pt ->Type == GP_EMPTY)
 738             fprintf (fp, "\t\t\t\t\t%g %g %g", 0.0, 0.0, 0.0);
 739         else
 740             if (pt ->Type == GP_MODELED)
 741                 fprintf (fp, "\t\t\t\t\t%g %g %g", 1.0, .5, .5);
 742             else {
 743                 fprintf (fp, "\t\t\t\t\t%g %g %g", 1.0, 1.0, 1.0);
 744 
 745             }
 746 
 747         if ((j == SECTORS - 1) && (i == SECTORS - 1))
 748                 fprintf (fp, "]\n");
 749             else
 750                 fprintf (fp, ",\n");
 751     }
 752     fprintf (fp, "\t\t\t}\n");
 753 
 754 
 755     fprintf (fp, "\t\t\t}\n");
 756     fprintf (fp, "\t\t}\n");
 757     fprintf (fp, "\t]\n");
 758     fprintf (fp, "}\n");
 759 
 760     fclose (fp);
 761 
 762     return TRUE;
 763 }
 764 #endif
 765