w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

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