1 /* ccurve, Copyright (c) 1998, 1999
2 * Rick Campbell <rick@campbellcentral.org>
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation. No representations are made about the suitability of this
9 * software for any purpose. It is provided "as is" without express or
14 /* Draw self-similar linear fractals including the classic ``C Curve''
16 * 16 Aug 1999 Rick Campbell <rick@campbellcentral.org>
17 * Eliminated sub-windows-with-backing-store-double-buffering crap in
18 * favor of drawing the new image in a pixmap and then splatting that on
21 * 19 Dec 1998 Rick Campbell <rick@campbellcentral.org>
31 #include "screenhack.h"
35 #define SQRT3 (1.73205080756887729353)
36 #define MAXIMUM_COLOR_COUNT (256)
37 #define EPSILON (1e-5)
39 typedef struct Position_struct
46 typedef struct Segment_struct
60 XColor colors [MAXIMUM_COLOR_COUNT];
63 double plot_maximum_x;
64 double plot_maximum_y;
65 double plot_minimum_x;
66 double plot_minimum_y;
69 unsigned long int background;
80 double draw_maximum_x;
81 double draw_maximum_y;
82 double draw_minimum_x;
83 double draw_minimum_y;
84 int draw_segment_count;
85 Segment* draw_segments;
95 /* normalize alters the sequence to go from (0,0) to (1,0) */
97 normalized_plot (int segment_count,
109 for (index = 0; index < segment_count; ++index)
111 Segment* segment = segments + index;
112 double length = segment->length;
113 double angle = segment->angle;
115 x += length * cos (angle);
116 y += length * sin (angle);
117 points [index].x = x;
118 points [index].y = y;
120 angle = -(atan2 (y, x));
121 cosine = cos (angle);
123 length = sqrt ((x * x) + (y * y));
124 /* rotate and scale */
125 for (index = 0; index < segment_count; ++index)
127 double temp_x = points [index].x;
128 double temp_y = points [index].y;
129 points [index].x = ((temp_x * cosine) + (temp_y * (-sine))) / length;
130 points [index].y = ((temp_x * sine) + (temp_y * cosine)) / length;
135 copy_points (int segment_count,
141 for (index = 0; index < segment_count; ++index)
143 target [index] = source [index];
157 double delta_x = 0.0;
158 double delta_y = 0.0;
165 angle = atan2 (delta_y, delta_x);
166 cosine = cos (angle);
168 length = sqrt ((delta_x * delta_x) + (delta_y * delta_y));
169 /* rotate, scale, then shift */
170 for (index = 0; index < segment_count; ++index)
172 double temp_x = points [index].x;
173 double temp_y = points [index].y;
175 = (length * ((temp_x * cosine) + (temp_y * (-sine)))) + x1;
177 = (length * ((temp_x * sine) + (temp_y * cosine))) + y1;
182 self_similar_normalized (struct state *st,
197 double delta_x = maximum_x - minimum_x;
198 double delta_y = maximum_y - minimum_y;
199 st->color_index = (int)(((double)(st->line_count * st->color_count))
200 / ((double)st->total_lines));
202 XSetForeground (st->dpy, st->context, st->colors [st->color_index].pixel);
203 if (st->plot_maximum_x < x1) st->plot_maximum_x = x1;
204 if (st->plot_maximum_x < x2) st->plot_maximum_x = x2;
205 if (st->plot_maximum_y < y1) st->plot_maximum_y = y1;
206 if (st->plot_maximum_y < y2) st->plot_maximum_y = y2;
207 if (st->plot_minimum_x > x1) st->plot_minimum_x = x1;
208 if (st->plot_minimum_x > x2) st->plot_minimum_x = x2;
209 if (st->plot_minimum_y > y1) st->plot_minimum_y = y1;
210 if (st->plot_minimum_y > y2) st->plot_minimum_y = y2;
211 XDrawLine (st->dpy, st->pixmap, st->context,
212 (int)(((x1 - minimum_x) / delta_x) * st->width),
213 (int)(((maximum_y - y1) / delta_y) * st->height),
214 (int)(((x2 - minimum_x) / delta_x) * st->width),
215 (int)(((maximum_y - y2) / delta_y) * st->height));
222 Position* replacement = (Position*)NULL;
226 replacement = (Position*)(malloc (segment_count * sizeof (Segment)));
227 copy_points (segment_count, points, replacement);
228 assert (fabs ((replacement [segment_count - 1].x) - 1.0) < EPSILON);
229 assert (fabs (replacement [segment_count - 1].y) < EPSILON);
230 realign (x1, y1, x2, y2, segment_count, replacement);
231 assert (fabs (x2 - (replacement [segment_count - 1].x)) < EPSILON);
232 assert (fabs (y2 - (replacement [segment_count - 1].y)) < EPSILON);
235 for (index = 0; index < segment_count; ++index)
237 next_x = replacement [index].x;
238 next_y = replacement [index].y;
239 self_similar_normalized (st,
240 iterations - 1, x, y, next_x, next_y,
241 maximum_x, maximum_y,
242 minimum_x, minimum_y,
243 segment_count, points);
247 free((void*)replacement);
252 self_similar (struct state *st,
269 Position* points = (Position*)NULL;
271 points = (Position*)(malloc (segment_count * sizeof (Position)));
272 normalized_plot (segment_count, segments, points);
273 assert (fabs ((points [segment_count - 1].x) - 1.0) < EPSILON);
274 assert (fabs (points [segment_count - 1].y) < EPSILON);
275 self_similar_normalized (st, iterations,
277 maximum_x, maximum_y,
278 minimum_x, minimum_y,
279 segment_count, points);
285 random_double (double base,
290 unsigned int steps = 0;
292 assert (base < limit);
293 assert (epsilon > 0.0);
294 range = limit - base;
295 steps = (unsigned int)(floor (range / epsilon));
296 return base + ((random () % steps) * epsilon);
300 select_2_pattern (Segment* segments)
302 if ((random () % 2) == 0)
304 if ((random () % 2) == 0)
306 segments [0].angle = -M_PI_4;
307 segments [0].length = M_SQRT2;
308 segments [1].angle = M_PI_4;
309 segments [1].length = M_SQRT2;
313 segments [0].angle = M_PI_4;
314 segments [0].length = M_SQRT2;
315 segments [1].angle = -M_PI_4;
316 segments [1].length = M_SQRT2;
322 = random_double (M_PI / 6.0, M_PI / 3.0, M_PI / 180.0);
323 segments [0].length = random_double (0.25, 0.67, 0.001);
324 if ((random () % 2) == 0)
326 segments [1].angle = -(segments [0].angle);
327 segments [1].length = segments [0].length;
331 segments [1].angle = random_double ((-M_PI) / 3.0,
334 segments [1].length = random_double (0.25, 0.67, 0.001);
340 select_3_pattern (Segment* segments)
342 switch (random () % 5)
345 if ((random () % 2) == 0)
347 segments [0].angle = M_PI_4;
348 segments [0].length = M_SQRT2 / 4.0;
349 segments [1].angle = -M_PI_4;
350 segments [1].length = M_SQRT2 / 2.0;
351 segments [2].angle = M_PI_4;
352 segments [2].length = M_SQRT2 / 4.0;
356 segments [0].angle = -M_PI_4;
357 segments [0].length = M_SQRT2 / 4.0;
358 segments [1].angle = M_PI_4;
359 segments [1].length = M_SQRT2 / 2.0;
360 segments [2].angle = -M_PI_4;
361 segments [2].length = M_SQRT2 / 4.0;
365 if ((random () % 2) == 0)
367 segments [0].angle = M_PI / 6.0;
368 segments [0].length = 1.0;
369 segments [1].angle = -M_PI_2;
370 segments [1].length = 1.0;
371 segments [2].angle = M_PI / 6.0;
372 segments [2].length = 1.0;
376 segments [0].angle = -M_PI / 6.0;
377 segments [0].length = 1.0;
378 segments [1].angle = M_PI_2;
379 segments [1].length = 1.0;
380 segments [2].angle = -M_PI / 6.0;
381 segments [2].length = 1.0;
388 = random_double (M_PI / 6.0, M_PI / 3.0, M_PI / 180.0);
389 segments [0].length = random_double (0.25, 0.67, 0.001);
391 = random_double (-M_PI / 3.0, -M_PI / 6.0, M_PI / 180.0);
392 segments [1].length = random_double (0.25, 0.67, 0.001);
393 if ((random () % 3) == 0)
395 if ((random () % 2) == 0)
397 segments [2].angle = segments [0].angle;
401 segments [2].angle = -(segments [0].angle);
403 segments [2].length = segments [0].length;
408 = random_double (-M_PI / 3.0, -M_PI / 6.0, M_PI / 180.0);
409 segments [2].length = random_double (0.25, 0.67, 0.001);
416 select_4_pattern (Segment* segments)
418 switch (random () % 9)
421 if ((random () % 2) == 0)
423 double length = random_double (0.25, 0.50, 0.001);
425 segments [0].angle = 0.0;
426 segments [0].length = 0.5;
427 segments [1].angle = M_PI_2;
428 segments [1].length = length;
429 segments [2].angle = -M_PI_2;
430 segments [2].length = length;
431 segments [3].angle = 0.0;
432 segments [3].length = 0.5;
436 double length = random_double (0.25, 0.50, 0.001);
438 segments [0].angle = 0.0;
439 segments [0].length = 0.5;
440 segments [1].angle = -M_PI_2;
441 segments [1].length = length;
442 segments [2].angle = M_PI_2;
443 segments [2].length = length;
444 segments [3].angle = 0.0;
445 segments [3].length = 0.5;
449 if ((random () % 2) == 0)
451 segments [0].angle = 0.0;
452 segments [0].length = 0.5;
453 segments [1].angle = M_PI_2;
454 segments [1].length = 0.45;
455 segments [2].angle = -M_PI_2;
456 segments [2].length = 0.45;
457 segments [3].angle = 0.0;
458 segments [3].length = 0.5;
462 segments [0].angle = 0.0;
463 segments [0].length = 0.5;
464 segments [1].angle = -M_PI_2;
465 segments [1].length = 0.45;
466 segments [2].angle = M_PI_2;
467 segments [2].length = 0.45;
468 segments [3].angle = 0.0;
469 segments [3].length = 0.5;
473 if ((random () % 2) == 0)
475 segments [0].angle = 0.0;
476 segments [0].length = 1.0;
477 segments [1].angle = (5.0 * M_PI) / 12.0;
478 segments [1].length = 1.2;
479 segments [2].angle = (-5.0 * M_PI) / 12.0;
480 segments [2].length = 1.2;
481 segments [3].angle = 0.0;
482 segments [3].length = 1.0;
486 segments [0].angle = 0.0;
487 segments [0].length = 1.0;
488 segments [1].angle = (-5.0 * M_PI) / 12.0;
489 segments [1].length = 1.2;
490 segments [2].angle = (5.0 * M_PI) / 12.0;
491 segments [2].length = 1.2;
492 segments [3].angle = 0.0;
493 segments [3].length = 1.0;
497 if ((random () % 2) == 0)
500 = random_double (M_PI / 4.0,
504 segments [0].angle = 0.0;
505 segments [0].length = 1.0;
506 segments [1].angle = angle;
507 segments [1].length = 1.2;
508 segments [2].angle = (-angle);
509 segments [2].length = 1.2;
510 segments [3].angle = 0.0;
511 segments [3].length = 1.0;
516 = random_double (M_PI / 4.0,
520 segments [0].angle = 0.0;
521 segments [0].length = 1.0;
522 segments [1].angle = (-angle);
523 segments [1].length = 1.2;
524 segments [2].angle = angle;
525 segments [2].length = 1.2;
526 segments [3].angle = 0.0;
527 segments [3].length = 1.0;
531 if ((random () % 2) == 0)
534 = random_double (M_PI / 4.0,
538 segments [0].angle = 0.0;
539 segments [0].length = 1.0;
540 segments [1].angle = angle;
541 segments [1].length = 1.2;
542 segments [2].angle = (-angle);
543 segments [2].length = 1.2;
544 segments [3].angle = 0.0;
545 segments [3].length = 1.0;
550 = random_double (M_PI / 4.0,
554 segments [0].angle = 0.0;
555 segments [0].length = 1.0;
556 segments [1].angle = (-angle);
557 segments [1].length = 1.2;
558 segments [2].angle = angle;
559 segments [2].length = 1.2;
560 segments [3].angle = 0.0;
561 segments [3].length = 1.0;
565 if ((random () % 2) == 0)
568 = random_double (M_PI / 4.0,
571 double length = random_double (0.25, 0.50, 0.001);
573 segments [0].angle = 0.0;
574 segments [0].length = 1.0;
575 segments [1].angle = angle;
576 segments [1].length = length;
577 segments [2].angle = (-angle);
578 segments [2].length = length;
579 segments [3].angle = 0.0;
580 segments [3].length = 1.0;
585 = random_double (M_PI / 4.0,
588 double length = random_double (0.25, 0.50, 0.001);
590 segments [0].angle = 0.0;
591 segments [0].length = 1.0;
592 segments [1].angle = (-angle);
593 segments [1].length = length;
594 segments [2].angle = angle;
595 segments [2].length = length;
596 segments [3].angle = 0.0;
597 segments [3].length = 1.0;
604 = random_double (M_PI / 12.0, (11.0 * M_PI) / 12.0, 0.001);
605 segments [0].length = random_double (0.25, 0.50, 0.001);
607 = random_double (M_PI / 12.0, (11.0 * M_PI) / 12.0, 0.001);
608 segments [1].length = random_double (0.25, 0.50, 0.001);
609 if ((random () % 3) == 0)
612 = random_double (M_PI / 12.0, (11.0 * M_PI) / 12.0, 0.001);
613 segments [2].length = random_double (0.25, 0.50, 0.001);
615 = random_double (M_PI / 12.0, (11.0 * M_PI) / 12.0, 0.001);
616 segments [3].length = random_double (0.25, 0.50, 0.001);
620 if ((random () % 2) == 0)
622 segments [2].angle = -(segments [1].angle);
623 segments [2].length = segments [1].length;
624 segments [3].angle = -(segments [0].angle);
625 segments [3].length = segments [0].length;
629 segments [2].angle = segments [1].angle;
630 segments [2].length = segments [1].length;
631 segments [3].angle = segments [0].angle;
632 segments [3].length = segments [0].length;
640 select_pattern (int segment_count,
643 switch (segment_count)
646 select_2_pattern (segments);
649 select_3_pattern (segments);
652 select_4_pattern (segments);
655 fprintf (stderr, "\nBad segment count, must be 2, 3, or 4.\n");
660 #define Y_START (0.5)
663 ccurve_init (Display *dpy, Window window)
665 struct state *st = (struct state *) calloc (1, sizeof(*st));
666 unsigned long int black = 0;
668 XWindowAttributes hack_attributes;
670 unsigned long int white = 0;
675 st->delay = get_float_resource (st->dpy, "delay", "Integer");
676 st->delay2 = get_float_resource (st->dpy, "pause", "Integer");
677 st->maximum_lines = get_integer_resource (st->dpy, "limit", "Integer");
678 black = BlackPixel (st->dpy, DefaultScreen (st->dpy));
679 white = WhitePixel (st->dpy, DefaultScreen (st->dpy));
680 st->background = black;
681 XGetWindowAttributes (st->dpy, st->window, &hack_attributes);
682 st->width = hack_attributes.width;
683 st->height = hack_attributes.height;
684 depth = hack_attributes.depth;
685 st->color_map = hack_attributes.colormap;
686 st->pixmap = XCreatePixmap (st->dpy, st->window, st->width, st->height, depth);
687 values.foreground = white;
688 values.background = black;
689 st->context = XCreateGC (st->dpy, st->window, GCForeground | GCBackground,
691 st->color_count = MAXIMUM_COLOR_COUNT;
692 make_color_loop (st->dpy, st->color_map,
696 st->colors, &st->color_count, True, False);
697 if (st->color_count <= 0)
700 st->colors [0].red = st->colors [0].green = st->colors [0].blue = 0xFFFF;
701 XAllocColor (st->dpy, st->color_map, &st->colors [0]);
704 st->draw_maximum_x = 1.20;
705 st->draw_maximum_y = 0.525;
706 st->draw_minimum_x = -0.20;
707 st->draw_minimum_y = -0.525;
714 ccurve_draw (Display *dpy, Window window, void *closure)
716 struct state *st = (struct state *) closure;
717 static const int lengths [] = { 4, 4, 4, 4, 4, 3, 3, 3, 2 };
719 if (st->draw_index == 0)
721 st->draw_segment_count
722 = lengths [random () % (sizeof (lengths) / sizeof (int))];
724 = (Segment*)(malloc ((st->draw_segment_count) * sizeof (Segment)));
725 select_pattern (st->draw_segment_count, st->draw_segments);
726 st->draw_iterations = floor (log (st->maximum_lines)
727 / log (((double)(st->draw_segment_count))));
728 if ((random () % 3) != 0)
730 double factor = 0.45;
731 st->draw_x1 += random_double (-factor, factor, 0.001);
732 st->draw_y1 += random_double (-factor, factor, 0.001);
733 st->draw_x2 += random_double (-factor, factor, 0.001);
734 st->draw_y2 += random_double (-factor, factor, 0.001);
736 /* background = (random () % 2) ? black : white; */
740 /* for (st->draw_index = 0; st->draw_index < st->draw_iterations; ++st->draw_index) */
742 double delta_x = 0.0;
743 double delta_y = 0.0;
745 XSetForeground (st->dpy, st->context, st->background);
746 XFillRectangle (st->dpy, st->pixmap, st->context, 0, 0, st->width, st->height);
748 st->total_lines = (int)(pow ((double)(st->draw_segment_count),
749 (double)st->draw_index));
750 st->plot_maximum_x = -1000.00;
751 st->plot_maximum_y = -1000.00;
752 st->plot_minimum_x = 1000.00;
753 st->plot_minimum_y = 1000.00;
754 self_similar (st, st->pixmap, st->context, st->width, st->height, st->draw_index,
755 st->draw_x1, st->draw_y1, st->draw_x2, st->draw_y2,
760 st->draw_segment_count, st->draw_segments);
761 delta_x = st->plot_maximum_x - st->plot_minimum_x;
762 delta_y = st->plot_maximum_y - st->plot_minimum_y;
763 st->draw_maximum_x = st->plot_maximum_x + (delta_x * 0.2);
764 st->draw_maximum_y = st->plot_maximum_y + (delta_y * 0.2);
765 st->draw_minimum_x = st->plot_minimum_x - (delta_x * 0.2);
766 st->draw_minimum_y = st->plot_minimum_y - (delta_y * 0.2);
767 delta_x = st->draw_maximum_x - st->draw_minimum_x;
768 delta_y = st->draw_maximum_y - st->draw_minimum_y;
769 if ((delta_y / delta_x) > (((double)st->height) / ((double)st->width)))
772 = (delta_y * ((double)st->width)) / ((double)st->height);
773 st->draw_minimum_x -= (new_delta_x - delta_x) / 2.0;
774 st->draw_maximum_x += (new_delta_x - delta_x) / 2.0;
779 = (delta_x * ((double)st->height)) / ((double)st->width);
780 st->draw_minimum_y -= (new_delta_y - delta_y) / 2.0;
781 st->draw_maximum_y += (new_delta_y - delta_y) / 2.0;
783 XCopyArea (st->dpy, st->pixmap, st->window, st->context, 0, 0, st->width, st->height,
788 if (st->draw_index >= st->draw_iterations)
791 free((void*)st->draw_segments);
792 st->draw_segments = 0;
793 return (int) (1000000 * st->delay);
796 return (int) (1000000 * st->delay2);
800 ccurve_reshape (Display *dpy, Window window, void *closure,
801 unsigned int w, unsigned int h)
806 ccurve_event (Display *dpy, Window window, void *closure, XEvent *event)
812 ccurve_free (Display *dpy, Window window, void *closure)
817 static const char *ccurve_defaults [] =
819 ".background: black",
820 ".foreground: white",
827 static XrmOptionDescRec ccurve_options [] =
829 { "-delay", ".delay", XrmoptionSepArg, 0 },
830 { "-pause", ".pause", XrmoptionSepArg, 0 },
831 { "-limit", ".limit", XrmoptionSepArg, 0 },
835 XSCREENSAVER_MODULE ("CCurve", ccurve)