/* xscreensaver, Copyright (c) 1997 Jamie Zawinski * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation. No representations are made about the suitability of this * software for any purpose. It is provided "as is" without express or * implied warranty. */ /* This file contains some utility routines for randomly picking the colors to hack the screen with. */ #include #include #include #include #include #include #include #include "xs_visual.h" #include "xs_yarandom.h" #include "xs_hsv.h" #include "xs_colors.h" /* extern char *progname; */ void free_colors(Display *dpy, Colormap cmap, XColor *colors, int ncolors) { int i; if (ncolors > 0) { unsigned long *pixels = (unsigned long *) malloc(sizeof(*pixels) * ncolors); for (i = 0; i < ncolors; i++) pixels[i] = colors[i].pixel; XFreeColors (dpy, cmap, pixels, ncolors, 0L); free(pixels); } } void allocate_writable_colors (Display *dpy, Colormap cmap, unsigned long *pixels, int *ncolorsP) { int desired = *ncolorsP; int got = 0; int requested = desired; unsigned long *new_pixels = pixels; *ncolorsP = 0; while (got < desired && requested > 0) { if (desired - got < requested) requested = desired - got; if (XAllocColorCells (dpy, cmap, False, 0, 0, new_pixels, requested)) { /* Got all the pixels we asked for. */ new_pixels += requested; got += requested; } else { /* We didn't get all/any of the pixels we asked for. This time, ask for half as many. (If we do get all that we ask for, we ask for the same number again next time, so we only do O(log(n)) server roundtrips.) */ requested = requested / 2; } } *ncolorsP += got; } void make_color_ramp (Display *dpy, Colormap cmap, int h1, double s1, double v1, /* 0-360, 0-1.0, 0-1.0 */ int h2, double s2, double v2, /* 0-360, 0-1.0, 0-1.0 */ XColor *colors, int *ncolorsP, Bool closed_p, Bool allocate_p, Bool writable_p) { int i; int ncolors = *ncolorsP; double dh, ds, dv; /* deltas */ AGAIN: memset (colors, 0, (*ncolorsP) * sizeof(*colors)); if (closed_p) ncolors = (ncolors / 2) + 1; /* Note: unlike other routines in this module, this function assumes that if h1 and h2 are more than 180 degrees apart, then the desired direction is always from h1 to h2 (rather than the shorter path.) make_uniform depends on this. */ dh = ((double)h2 - (double)h1) / ncolors; ds = (s2 - s1) / ncolors; dv = (v2 - v1) / ncolors; for (i = 0; i < ncolors; i++) { colors[i].flags = DoRed|DoGreen|DoBlue; hsv_to_rgb ((int) (h1 + (i*dh)), (s1 + (i*ds)), (v1 + (i*dv)), &colors[i].red, &colors[i].green, &colors[i].blue); } if (closed_p) for (i = ncolors; i < *ncolorsP; i++) colors[i] = colors[(*ncolorsP)-i]; if (!allocate_p) return; if (writable_p) { unsigned long *pixels = (unsigned long *) malloc(sizeof(*pixels) * ((*ncolorsP) + 1)); /* allocate_writable_colors() won't do here, because we need exactly this number of cells, or the color sequence we've chosen won't fit. */ if (! XAllocColorCells(dpy, cmap, False, 0, 0, pixels, *ncolorsP)) { free(pixels); goto FAIL; } for (i = 0; i < *ncolorsP; i++) colors[i].pixel = pixels[i]; free (pixels); XStoreColors (dpy, cmap, colors, *ncolorsP); } else { for (i = 0; i < *ncolorsP; i++) { XColor color; color = colors[i]; if (XAllocColor (dpy, cmap, &color)) { colors[i].pixel = color.pixel; } else { free_colors (dpy, cmap, colors, i); goto FAIL; } } } return; FAIL: /* we weren't able to allocate all the colors we wanted; decrease the requested number and try again. */ ncolors = (ncolors > 170 ? ncolors - 20 : ncolors > 100 ? ncolors - 10 : ncolors > 75 ? ncolors - 5 : ncolors > 25 ? ncolors - 3 : ncolors > 10 ? ncolors - 2 : ncolors > 2 ? ncolors - 1 : 0); *ncolorsP = ncolors; if (ncolors > 0) goto AGAIN; } #define MAXPOINTS 50 /* yeah, so I'm lazy */ static void make_color_path (Display *dpy, Colormap cmap, int npoints, int *h, double *s, double *v, XColor *colors, int *ncolorsP, Bool allocate_p, Bool writable_p) { int i, j, k; int total_ncolors = *ncolorsP; int ncolors[MAXPOINTS]; /* number of pixels per edge */ double dh[MAXPOINTS]; /* distance between pixels, per edge (0 - 360.0) */ double ds[MAXPOINTS]; /* distance between pixels, per edge (0 - 1.0) */ double dv[MAXPOINTS]; /* distance between pixels, per edge (0 - 1.0) */ if (npoints == 0) { *ncolorsP = 0; return; } else if (npoints == 2) /* using make_color_ramp() will be faster */ { make_color_ramp (dpy, cmap, h[0], s[0], v[0], h[1], s[1], v[1], colors, ncolorsP, True, /* closed_p */ allocate_p, writable_p); return; } else if (npoints >= MAXPOINTS) { npoints = MAXPOINTS-1; } AGAIN: { double DH[MAXPOINTS]; /* Distance between H values in the shortest direction around the circle, that is, the distance between 10 and 350 is 20. (Range is 0 - 360.0.) */ double edge[MAXPOINTS]; /* lengths of edges in unit HSV space. */ double ratio[MAXPOINTS]; /* proportions of the edges (total 1.0) */ double circum = 0; double one_point_oh = 0; /* (debug) */ for (i = 0; i < npoints; i++) { int j = (i+1) % npoints; double d = ((double) (h[i] - h[j])) / 360; if (d < 0) d = -d; if (d > 0.5) d = 0.5 - (d - 0.5); DH[i] = d; } for (i = 0; i < npoints; i++) { int j = (i+1) % npoints; edge[i] = sqrt((DH[i] * DH[j]) + ((s[j] - s[i]) * (s[j] - s[i])) + ((v[j] - v[i]) * (v[j] - v[i]))); circum += edge[i]; } #ifdef DEBUG fprintf(stderr, "\ncolors:"); for (i=0; i < npoints; i++) fprintf(stderr, " (%d, %.3f, %.3f)", h[i], s[i], v[i]); fprintf(stderr, "\nlengths:"); for (i=0; i < npoints; i++) fprintf(stderr, " %.3f", edge[i]); #endif /* DEBUG */ if (circum < 0.0001) goto FAIL; for (i = 0; i < npoints; i++) { ratio[i] = edge[i] / circum; one_point_oh += ratio[i]; } #ifdef DEBUG fprintf(stderr, "\nratios:"); for (i=0; i < npoints; i++) fprintf(stderr, " %.3f", ratio[i]); #endif /* DEBUG */ if (one_point_oh < 0.99999 || one_point_oh > 1.00001) abort(); /* space the colors evenly along the circumference -- that means that the number of pixels on a edge is proportional to the length of that edge (relative to the lengths of the other edges.) */ for (i = 0; i < npoints; i++) ncolors[i] = total_ncolors * ratio[i]; #ifdef DEBUG fprintf(stderr, "\npixels:"); for (i=0; i < npoints; i++) fprintf(stderr, " %d", ncolors[i]); fprintf(stderr, " (%d)\n", total_ncolors); #endif /* DEBUG */ for (i = 0; i < npoints; i++) { int j = (i+1) % npoints; if (ncolors[i] > 0) { dh[i] = 360 * (DH[i] / ncolors[i]); ds[i] = (s[j] - s[i]) / ncolors[i]; dv[i] = (v[j] - v[i]) / ncolors[i]; } } } memset (colors, 0, (*ncolorsP) * sizeof(*colors)); k = 0; for (i = 0; i < npoints; i++) { int distance, direction; distance = h[(i+1) % npoints] - h[i]; direction = (distance >= 0 ? -1 : 1); if (distance > 180) distance = 180 - (distance - 180); else if (distance < -180) distance = -(180 - ((-distance) - 180)); else direction = -direction; #ifdef DEBUG fprintf (stderr, "point %d: %3d %.2f %.2f\n", i, h[i], s[i], v[i]); fprintf(stderr, " h[i]=%d dh[i]=%.2f ncolors[i]=%d\n", h[i], dh[i], ncolors[i]); #endif /* DEBUG */ for (j = 0; j < ncolors[i]; j++, k++) { double hh = (h[i] + (j * dh[i] * direction)); if (hh < 0) hh += 360; else if (hh > 360) hh -= 0; colors[k].flags = DoRed|DoGreen|DoBlue; hsv_to_rgb ((int) hh, (s[i] + (j * ds[i])), (v[i] + (j * dv[i])), &colors[k].red, &colors[k].green, &colors[k].blue); #ifdef DEBUG fprintf (stderr, "point %d+%d: %.2f %.2f %.2f %04X %04X %04X\n", i, j, hh, (s[i] + (j * ds[i])), (v[i] + (j * dv[i])), colors[k].red, colors[k].green, colors[k].blue); #endif /* DEBUG */ } } /* Floating-point round-off can make us decide to use fewer colors. */ if (k < *ncolorsP) { *ncolorsP = k; if (k <= 0) return; } if (!allocate_p) return; if (writable_p) { unsigned long *pixels = (unsigned long *) malloc(sizeof(*pixels) * ((*ncolorsP) + 1)); /* allocate_writable_colors() won't do here, because we need exactly this number of cells, or the color sequence we've chosen won't fit. */ if (! XAllocColorCells(dpy, cmap, False, 0, 0, pixels, *ncolorsP)) { free(pixels); goto FAIL; } for (i = 0; i < *ncolorsP; i++) colors[i].pixel = pixels[i]; free (pixels); XStoreColors (dpy, cmap, colors, *ncolorsP); } else { for (i = 0; i < *ncolorsP; i++) { XColor color; color = colors[i]; if (XAllocColor (dpy, cmap, &color)) { colors[i].pixel = color.pixel; } else { free_colors (dpy, cmap, colors, i); goto FAIL; } } } return; FAIL: /* we weren't able to allocate all the colors we wanted; decrease the requested number and try again. */ total_ncolors = (total_ncolors > 170 ? total_ncolors - 20 : total_ncolors > 100 ? total_ncolors - 10 : total_ncolors > 75 ? total_ncolors - 5 : total_ncolors > 25 ? total_ncolors - 3 : total_ncolors > 10 ? total_ncolors - 2 : total_ncolors > 2 ? total_ncolors - 1 : 0); *ncolorsP = total_ncolors; if (total_ncolors > 0) goto AGAIN; } void make_color_loop (Display *dpy, Colormap cmap, int h0, double s0, double v0, /* 0-360, 0-1.0, 0-1.0 */ int h1, double s1, double v1, /* 0-360, 0-1.0, 0-1.0 */ int h2, double s2, double v2, /* 0-360, 0-1.0, 0-1.0 */ XColor *colors, int *ncolorsP, Bool allocate_p, Bool writable_p) { int h[3]; double s[3], v[3]; h[0] = h0; h[1] = h1; h[2] = h2; s[0] = s0; s[1] = s1; s[2] = s2; v[0] = v0; v[1] = v1; v[2] = v2; make_color_path(dpy, cmap, 3, h, s, v, colors, ncolorsP, allocate_p, writable_p); } static void complain (int wanted_colors, int got_colors, Bool wanted_writable, Bool got_writable) { if (wanted_writable && !got_writable) fprintf(stderr, "%s: wanted %d writable colors; got %d read-only colors.\n", "colors (tdescreensaver)", wanted_colors, got_colors); else if (wanted_colors > (got_colors + 10)) /* don't bother complaining if we're within ten pixels. */ fprintf(stderr, "%s: wanted %d%s colors; got %d.\n", "colors (tdescreensaver)", wanted_colors, (got_writable ? " writable" : ""), got_colors); } void make_smooth_colormap (Display *dpy, Visual *visual, Colormap cmap, XColor *colors, int *ncolorsP, Bool allocate_p, Bool *writable_pP, Bool verbose_p) { int npoints; int ncolors = *ncolorsP; Bool wanted_writable = (allocate_p && writable_pP && *writable_pP); int i; int h[MAXPOINTS]; double s[MAXPOINTS]; double v[MAXPOINTS]; double total_s = 0; double total_v = 0; Screen *screen = DefaultScreenOfDisplay(dpy); /* #### WRONG! */ if (*ncolorsP <= 0) return; { int n = random() % 20; if (n <= 5) npoints = 2; /* 30% of the time */ else if (n <= 15) npoints = 3; /* 50% of the time */ else if (n <= 18) npoints = 4; /* 15% of the time */ else npoints = 5; /* 5% of the time */ } REPICK_ALL_COLORS: for (i = 0; i < npoints; i++) { REPICK_THIS_COLOR: h[i] = random() % 360; s[i] = frand(1.0); v[i] = frand(0.8) + 0.2; /* Make sure that no two adjascent colors are *too* close together. If they are, try again. */ if (i > 0) { int j = (i+1 == npoints) ? 0 : (i-1); double hi = ((double) h[i]) / 360; double hj = ((double) h[j]) / 360; double dh = hj - hi; double distance; if (dh < 0) dh = -dh; if (dh > 0.5) dh = 0.5 - (dh - 0.5); distance = sqrt ((dh * dh) + ((s[j] - s[i]) * (s[j] - s[i])) + ((v[j] - v[i]) * (v[j] - v[i]))); if (distance < 0.2) goto REPICK_THIS_COLOR; } total_s += s[i]; total_v += v[i]; } /* If the average saturation or intensity are too low, repick the colors, so that we don't end up with a black-and-white or too-dark map. */ if (total_s / npoints < 0.2) goto REPICK_ALL_COLORS; if (total_v / npoints < 0.3) goto REPICK_ALL_COLORS; /* If this visual doesn't support writable cells, don't bother trying. */ if (wanted_writable && !has_writable_cells(screen, visual)) *writable_pP = False; RETRY_NON_WRITABLE: make_color_path (dpy, cmap, npoints, h, s, v, colors, &ncolors, allocate_p, (writable_pP && *writable_pP)); /* If we tried for writable cells and got none, try for non-writable. */ if (allocate_p && *ncolorsP == 0 && *writable_pP) { *writable_pP = False; goto RETRY_NON_WRITABLE; } if (verbose_p) complain(*ncolorsP, ncolors, wanted_writable, wanted_writable && *writable_pP); *ncolorsP = ncolors; } void make_uniform_colormap (Display *dpy, Visual *visual, Colormap cmap, XColor *colors, int *ncolorsP, Bool allocate_p, Bool *writable_pP, Bool verbose_p) { int ncolors = *ncolorsP; Bool wanted_writable = (allocate_p && writable_pP && *writable_pP); Screen *screen = DefaultScreenOfDisplay(dpy); /* #### WRONG! */ double S = ((double) (random() % 34) + 66) / 100.0; /* range 66%-100% */ double V = ((double) (random() % 34) + 66) / 100.0; /* range 66%-100% */ if (*ncolorsP <= 0) return; /* If this visual doesn't support writable cells, don't bother trying. */ if (wanted_writable && !has_writable_cells(screen, visual)) *writable_pP = False; RETRY_NON_WRITABLE: make_color_ramp(dpy, cmap, 0, S, V, 359, S, V, colors, &ncolors, False, True, wanted_writable); /* If we tried for writable cells and got none, try for non-writable. */ if (allocate_p && *ncolorsP == 0 && writable_pP && *writable_pP) { ncolors = *ncolorsP; *writable_pP = False; goto RETRY_NON_WRITABLE; } if (verbose_p) complain(*ncolorsP, ncolors, wanted_writable, wanted_writable && *writable_pP); *ncolorsP = ncolors; } void make_random_colormap (Display *dpy, Visual *visual, Colormap cmap, XColor *colors, int *ncolorsP, Bool bright_p, Bool allocate_p, Bool *writable_pP, Bool verbose_p) { Bool wanted_writable = (allocate_p && writable_pP && *writable_pP); int ncolors = *ncolorsP; int i; Screen *screen = DefaultScreenOfDisplay(dpy); /* #### WRONG! */ if (*ncolorsP <= 0) return; /* If this visual doesn't support writable cells, don't bother trying. */ if (wanted_writable && !has_writable_cells(screen, visual)) *writable_pP = False; for (i = 0; i < ncolors; i++) { colors[i].flags = DoRed|DoGreen|DoBlue; if (bright_p) { int H = random() % 360; /* range 0-360 */ double S = ((double) (random()%70) + 30)/100.0; /* range 30%-100% */ double V = ((double) (random()%34) + 66)/100.0; /* range 66%-100% */ hsv_to_rgb (H, S, V, &colors[i].red, &colors[i].green, &colors[i].blue); } else { colors[i].red = random() % 0xFFFF; colors[i].green = random() % 0xFFFF; colors[i].blue = random() % 0xFFFF; } } if (!allocate_p) return; RETRY_NON_WRITABLE: if (writable_pP && *writable_pP) { unsigned long *pixels = (unsigned long *) malloc(sizeof(*pixels) * (ncolors + 1)); allocate_writable_colors (dpy, cmap, pixels, &ncolors); if (ncolors > 0) for (i = 0; i < ncolors; i++) colors[i].pixel = pixels[i]; free (pixels); if (ncolors > 0) XStoreColors (dpy, cmap, colors, ncolors); } else { for (i = 0; i < ncolors; i++) { XColor color; color = colors[i]; if (!XAllocColor (dpy, cmap, &color)) break; colors[i].pixel = color.pixel; } ncolors = i; } /* If we tried for writable cells and got none, try for non-writable. */ if (allocate_p && ncolors == 0 && writable_pP && *writable_pP) { ncolors = *ncolorsP; *writable_pP = False; goto RETRY_NON_WRITABLE; } if (verbose_p) complain(*ncolorsP, ncolors, wanted_writable, wanted_writable && *writable_pP); *ncolorsP = ncolors; } void rotate_colors (Display *dpy, Colormap cmap, XColor *colors, int ncolors, int distance) { int i; XColor *colors2 = (XColor *) malloc(sizeof(*colors2) * ncolors); if (ncolors < 2) return; distance = distance % ncolors; for (i = 0; i < ncolors; i++) { int j = i - distance; if (j >= ncolors) j -= ncolors; if (j < 0) j += ncolors; colors2[i] = colors[j]; colors2[i].pixel = colors[i].pixel; } XStoreColors (dpy, cmap, colors2, ncolors); XFlush(dpy); memcpy(colors, colors2, sizeof(*colors) * ncolors); free(colors2); }