Design Statement:

	We attempted to study the aesthetics involved in circular objects arranged linearly.  We chose to make the objects concentric to allow them to overlap, thus letting them interact and making the image more interesting via their interactions.  The positions of the circles along the diagonal straight line varies with n, with larger values of n corresponding to lower and more leftward positions.  Each circle will also appear at the upper-rightmost corner if it travels “off the canvas,” allowing the four circles to exhibit either synchronous or asynchronous patterns.

	We used a monochromatic color scheme to display the subtle changes that occur when using  overlapping circles. Further, we used blue to form an abstract representation of water droplets hitting water, in which the foreground colors create a rippling effect. We used different shades of blue for the ripples because of the different shades that are created in nature as a result of sunlight striking the water. Since we designed a code that replicates nature, we felt it necessary to have a static code representative of nature. 



Technical Statement:

	We used recursion to form the concentric circles, which are the foundation of the image. We specifically used the image.draw-concentric-circles! function to draw our circles. Due to the constraint of using only three parameters, we liberally used the let* and let functions via nested lets. This allowed us more freedom to base the position of the circles partially upon the size of the canvas. To also aid us in this we used modulo so that the position of the circles did not exceed the canvas size. Through this, one can virtually use any positive integer as n with our code.  We also had to create a hypotenuse function, using let*, as a means of keeping the circles in a diagonal formation.  The let* function also allowed us to set col and row as values dependent upon (modulo n width) and (modulo n height), respectively. These values were called in the image.select-ellipse! function, which is itself called in image.draw-concentric-circles!. 

	To use a monochromatic color scheme, calls to the specific colors are used within the code. By using a call to image.draw-concentric-circles! in our helper function image-series-sub (tail recursion) we only had to call image-series-sub twice, meaning that more circles could potentially be added to our code, if one may so choose. However, this is an unwise decision because the canvas quickly gets cluttered.

(define image-series
  (lambda (n width height)
    (envt.set-bgcolor! color.blue)
    (let* ((myround 
            (lambda (num)
              (->int (round num))))
           (hypotenuse (myround (sqrt (+ (* width width) (* height height)))))
           (canvas (image.new width height))
           (image-series-sub
            (lambda (n width height)
              (envt.set-bgcolor! color.blue)
              (envt.set-brush! "Circle (07)")
              (envt.set-fgcolor! (rgb.new 25 140 215))
              (let* 
                  ((col (modulo n width))
                   (row (modulo n height))
                   (radius (* .25 width))
                   (min-area (* .25 height))
                   (image.draw-circle!
                    (lambda (image col row radius)
                      (image.select-ellipse! image selection.replace
                                             (- col radius) (- row radius)
                                             (+ radius radius) (+ radius radius))
                      (image.stroke! image)
                      (image.select-nothing! image)))
                   (image.draw-concentric-circles!
                    (let ((area (lambda (r) (* pi r r))))
                      (lambda (image col row radius ratio min-area)
                        (cond
                          ((> (area radius) min-area)
                           (image.draw-circle! image col row radius
                                               (image.draw-concentric-circles! image
                                                                               col row
                                                                               (* ratio radius)
                                                                               ratio
                                                                               min-area))))))))
                (envt.set-fgcolor! (rgb.new 25 140 215))
                (image.draw-concentric-circles! canvas col (* (/ height width) col) (* .5 width) .6 25)
                (envt.set-fgcolor! color.slate-blue)
                (image.draw-concentric-circles! canvas col (* (/ height width) col) (* .5 width .90) .6 25)
                (image.draw-concentric-circles! canvas col (* (/ height width) col) (* .5 width 1.1) .6 25)
                (envt.update-displays!)))))
      (image-series-sub (modulo n hypotenuse) width height)
      (image-series-sub (modulo (+ n (myround (* .6 hypotenuse))) hypotenuse) width height)
      (image.show canvas))))