drRacketFractalMP4

#lang racket
(require racket/draw)
(require racket/gui/base)
(require racket/string)

(define imageWidth 1920)
(define imageHeight 1080)
(define output-dir "cactus_output")
(define MIN-SIZE 2.0)
(define BASE-MAX-RECURSION 12)
(define INITIAL-SCALE 120.0)
(define ZOOM_SCALE 0.4)

(define TEAL-COLOR (make-color 0 128 128))
(define CERULEAN-COLOR (make-color 0 123 167))
(define BASE-BLUE (make-color 42 82 190))

(define total-polygon-count 0)
(define smallest-polygon-size +inf.0)

(struct rectangle (left top right bottom))

(define (make-rectangle left top right bottom)
  (rectangle left top right bottom))

(define (rectangle-contains-point? rect x y)
  (and (<= (rectangle-left rect) x (rectangle-right rect))
       (<= (rectangle-top rect) y (rectangle-bottom rect))))

(define (distance-from-center x y center-x center-y)
  (sqrt (+ (sqr (- x center-x))
           (sqr (- y center-y)))))

(define (calculate-polygon-size size)
  (* size size))

(define (draw-spine-pattern dc x y size angle level max-level visible-area min-detail-size
                           #:random-seed [seed 0]
                           #:center-x [center-x (/ imageWidth 2)]
                           #:center-y [center-y (/ imageHeight 2)])
  (when (and (>= size min-detail-size)
             (rectangle-contains-point? visible-area x y)
             (<= level max-level))
    
    (set! total-polygon-count (add1 total-polygon-count))
    (let ([current-size (calculate-polygon-size size)])
      (when (< current-size smallest-polygon-size)
        (set! smallest-polygon-size current-size)))

    (define-values (outline-color fill-color)
      (cond
        [(= level 4)
         (if (and (member (modulo (+ seed 0) 6) '(1 3 5)))
             (values CERULEAN-COLOR (make-color 255 0 0))
             (values BASE-BLUE (make-color 0 255 0)))]
        [(= level 3)
         (values TEAL-COLOR (make-color 220 220 150))]
        [(= level 2)
         (values CERULEAN-COLOR (make-color 0 255 0))]
        [else
         (values BASE-BLUE TEAL-COLOR)]))

    (when (and (> size (* 10 (+ 1 (* level 0.2))))
               (< (distance-from-center x y center-x center-y)
                  (* (/ imageWidth 2) 0.9)))
      (define node-size (min 4 (/ size 20)))
      (define adjusted-node-size
        (* node-size
           (- 1 (* 0.3 (/ (distance-from-center x y center-x center-y)
                         (/ imageWidth 2))))))
      
      (send dc set-brush outline-color 'solid)
      (send dc draw-ellipse
            (- x (+ adjusted-node-size 0.5))
            (- y (+ adjusted-node-size 0.5))
            (* (+ adjusted-node-size 0.5) 2)
            (* (+ adjusted-node-size 0.5) 2))
      
      (send dc set-brush fill-color 'solid)
      (send dc draw-ellipse
            (- x adjusted-node-size)
            (- y adjusted-node-size)
            (* adjusted-node-size 2)
            (* adjusted-node-size 2)))

    (define line-thickness
      (* (max 0.5 (min 0.005 (floor (/ size 50))))
         (- 1 (* 0.2 (/ (distance-from-center x y center-x center-y)
                       (/ imageWidth 2))))))
    (define outline-thickness (+ line-thickness 0.5))

    (for ([i (in-range 6)])
      (define branch-angle (+ angle (* i (/ (* 2 pi) 6))))
      (define end-x (+ x (* size (cos branch-angle))))
      (define end-y (+ y (* size (sin branch-angle))))

      (when (< (distance-from-center end-x end-y center-x center-y)
               (* (/ imageWidth 2) 1.5))
        (send dc set-pen outline-color outline-thickness 'solid)
        (send dc draw-line x y end-x end-y)
        (send dc set-pen fill-color line-thickness 'solid)
        (send dc draw-line x y end-x end-y))

      (when (< level max-level)
        (draw-spine-pattern dc end-x end-y (* size 0.5)
                           branch-angle (+ level 1) max-level
                           visible-area min-detail-size
                           #:random-seed (+ seed i)
                           #:center-x center-x
                           #:center-y center-y)))))

(define (create-multi-cactus-fractal dc x y visible-area min-detail-size)
  (define main-pattern-size INITIAL-SCALE)
  
  (draw-spine-pattern dc x y main-pattern-size 0 0 BASE-MAX-RECURSION
                      visible-area min-detail-size)

  (for ([ring-level (in-range 1 5)])
    (define current-size (* main-pattern-size (expt 0.6 ring-level)))
    (define ring-radius (* main-pattern-size (+ 2.125 (* ring-level 0.2))))
    (define num-patterns (* 6 ring-level))

    (for ([i (range num-patterns)])
      (define angle (+ (/ pi num-patterns)
                      (* i (/ (* 2 pi) num-patterns))))
      (define pattern-x (+ x (* ring-radius (cos angle))))
      (define pattern-y (+ y (* ring-radius (sin angle))))

      (when (and (>= current-size min-detail-size)
                (rectangle-contains-point? visible-area pattern-x pattern-y)
                (< (distance-from-center pattern-x pattern-y x y)
                   (* (/ imageWidth 2) 0.95)))
        (draw-spine-pattern dc pattern-x pattern-y current-size angle 0
                           BASE-MAX-RECURSION visible-area min-detail-size
                           #:random-seed (+ i ring-level))))))

(define pattern-canvas%
  (class canvas%
    (init parent)
    (super-new [parent parent])
    
    (define full-bitmap (make-bitmap imageWidth imageHeight))
    (define full-dc (new bitmap-dc% [bitmap full-bitmap]))
    
    (define display-width (inexact->exact (floor (* imageWidth ZOOM_SCALE))))
    (define display-height (inexact->exact (floor (* imageHeight ZOOM_SCALE))))
    (define display-bitmap (make-bitmap display-width display-height))
    (define display-dc (new bitmap-dc% [bitmap display-bitmap]))
    
    (define/override (on-paint)
      (define dc-canvas (send this get-dc))
      (send dc-canvas draw-bitmap display-bitmap 0 0))
    
    (define/public (generate-pattern)
      (define visible-area (make-rectangle 0 0 imageWidth imageHeight))
      
      (send full-dc set-background (make-color 0 0 0))
      (send full-dc clear)
      (create-multi-cactus-fractal full-dc (/ imageWidth 2) (/ imageHeight 2)
                                  visible-area MIN-SIZE)
      
      (send display-dc set-background (make-color 0 0 0))
      (send display-dc clear)
      (send display-dc scale ZOOM_SCALE ZOOM_SCALE)
      (send display-dc draw-bitmap full-bitmap 0 0)
      
      (unless (directory-exists? output-dir)
        (make-directory output-dir))
      (send full-bitmap save-file (build-path output-dir "fractal.png") 'png)
      
      (send this refresh)
      
      (printf "Total polygons: ~a~n" total-polygon-count)
      (printf "Smallest polygon size: ~a~n" smallest-polygon-size))))

(module+ main
  (define frame (new frame%
                    [label "Fractal Pattern"]
                    [width (inexact->exact (floor (* imageWidth ZOOM_SCALE)))]
                    [height (inexact->exact (floor (* imageHeight ZOOM_SCALE)))]))
  
  (define canvas (new pattern-canvas% [parent frame]))
  
  (send frame show #t)
  (send canvas generate-pattern))