cg-Cad

Lisp »Tips 'n Tricks »Frattali »1 »2 »3 »4 »5 »6 »7

Il frattale di Mandelbrot

MANB3 implementa in AutoLISP il metodo di scansione del contorno per disegnare l'insieme di Mandelbrot degli insiemi di Julia di z²+c.

Il metodo consiste nell'iterare 20 volte ogni punto di una griglia di punti nel piano (punto considerato come valore di c): se l'orbita del punto non fugge all'infinito allora si deve iterare 20 volte i 4 punti (x+n,y),(x-n,y),(x,y+n),(x,y-n) che circondano c e se almeno una di queste orbite fugge all'infinito allora si disegna il punto (M,N) della griglia.

Impostando la griglia a 1000 e n=0.01 ho cercato un equilibrio tra il tempo (lungo) di esecuzione e la bellezza (precisione) del frattale.
Notare le differenze minime con il sorgente di JL5 e il tipo diverso di simmetria usato per ridurre il tempo di esecuzione del disegno.
Al contrario di J, M non è simmetrico rispetto all'origine ma è simmetrico rispetto all'asse X.

;|
  MANB3 (C) 2004 by Claudio Piccini
  7 Maggio 2004
  www.cg-cad.com
  Disegna il frattale di Mandelbrot 
  con il metodo di scansione del contorno
|;

(defun iterOrb ( xM yN / x1 y1 R j )
 (setq j 0)
 (while (< j 20)
  (setq j (1+ j))
  (setq x1 (+ (- (* xM xM)(* yN yN)) cx))
  (setq y1 (+ (* 2 xM yN) cy))
  (setq xM x1)
  (setq yN y1)
  (setq R (+ (* xM xM)(* yN yN)))
  (if (> R 4)(setq j 99))
 )
 (setq j j)
)

(defun mandelbrot ( itera / test
                    i R M N 
                    xM yN x0 y0 x y x1 y1 
 )
 (setq M 0)
 (while (<= M itera)
  (setq cx (+ -2 (/ M K)))
  (setq N 0)
  (while (<= N (/ itera 2))
   (setq cy (- 2 (/ N K)))
   (setq x cx)
   (setq y cy)
   (setq i 0)
   (while
    (progn
     (setq i (1+ i))
     (setq x1 (+ (- (* x x)(* y y)) cx))
     (setq y1 (+ (* 2 x y) cy))
     (setq R (+ (* x x)(* y y)))
     (setq x x1)
     (setq y y1)
     (if (> R 4)  nil T) 
     (if (< i 20) T nil)
    )
   )
   (setq test 0)
   (if (< R 4)
    (progn
     (setq xM (+ cx 0.01))       
     (setq yN cy)
     (if (= (iterOrb xM yN) 99)
      (setq test 1)
      (progn
       (setq xM (- cx 0.01))       
       (setq yN cy)
       (if (= (iterOrb xM yN) 99)
        (setq test 1)
        (progn
         (setq xM cx)
         (setq yN (+ cy 0.01))
         (if (= (iterOrb xM yN) 99)
          (setq test 1)
          (progn
           (setq xM cx)
           (setq yN (- cy 0.01))
           (if (= (iterOrb xM yN) 99)
            (setq test 1)
           )
          )
         )
        )
       )
      )
     )
    )
   )
   (if (= test 1)
    (progn      
     (command "_point" (list M N))
     (command "_point" (list M (- itera N)))
    )
   )
   (setq N (1+ N))
  )
  (setq M (1+ M))
 )
)

(defun c:manb3 ( / snapp K griglia )
 (setvar "cmdecho" 0)
 (setq snapp (getvar "osmode"))
 (command "_osnap" "_non")
 (setq griglia 1000)
 (setq K (/ griglia 4.0))
 (mandelbrot griglia)
 (setvar "osmode" snapp)
 (command "_redraw")
 (setvar "cmdecho" 1)
 (princ)
)
;eof

Output

manb3
griglia=100

manb3
griglia=500

manb3
griglia=1000

Lisp »Tips 'n Tricks

Ultimo Aggiornamento_Last Update: 7 Maggio 2004