(ns org.aurellem.worm-learn

   "General worm creation framework."

   {:author "Robert McIntyre"}

   (:use (cortex world util import body sense

                 hearing touch vision proprioception movement))

   (:import (com.jme3.math ColorRGBA Vector3f))

   (:import java.io.File)

   (:import com.jme3.audio.AudioNode)

   (:import com.aurellem.capture.RatchetTimer)

   (:import (com.aurellem.capture Capture IsoTimer))

   (:import (com.jme3.math Vector3f ColorRGBA)))

   

 

 (dorun (cortex.import/mega-import-jme3))

 (rlm.rlm-commands/help)

 

 (load-bullet)

 

 (def hand "Models/test-creature/hand.blend")

 

 (defn worm-model []

   (load-blender-model "Models/worm/worm.blend"))

 

 (def output-base (File. "/home/r/proj/cortex/render/worm-learn/curl"))

 

 

 (defn motor-control-program

   "Create a function which will execute the motor script"

   [muscle-positions

    script]

   (let [current-frame (atom -1)

         keyed-script (group-by first script)

         current-forces (atom {}) ]

     (fn [effectors]

       (let [indexed-effectors (vec effectors)]

         (dorun 

          (for [[_ part force] (keyed-script (swap! current-frame inc))]

            (swap! current-forces (fn [m] (assoc m part force)))))

         (doall (map (fn [effector power]

                       (effector (int power)))

                     effectors

                     (map #(@current-forces % 0) muscle-positions)))))))

 

 

 

 

 ;; These are scripts that direct the worm to move in two radically

 ;; different patterns -- a sinusoidal wiggling motion, and a curling

 ;; motions that causes the worm to form a circle.

 

 (def curl-script

   [[370 :d-up 40]

    [600 :d-up 0]])

 

 (def period 18)

 

 (def muscle-labels

   [:base-up :base-down

    :a-up :a-down

    :b-up :b-down

    :c-up :c-down

    :d-up :d-down])

 

 (defn gen-wiggle [[flexor extensor :as muscle-pair] time-base]

   (let [period period

         power 45]

     [[time-base flexor power]

      [(+ time-base period) flexor 0]

      [(+ time-base period 1) extensor power]

      [(+ time-base (+ (* 2 period) 2))  extensor 0]]))

   

 (def wiggle-script

   (mapcat gen-wiggle (repeat 40 [:a-down :a-up])

                      (range 100 10000 (+ 3 (* period 2)))))

 

 

 ;; Normally, we'd use unsupervised/supervised machine learning to pick

 ;; out the defining features of the different actions available to the

 ;; worm. For this project, I am going to explicitely define functions

 ;; that recognize curling and wiggling respectively. These functions

 ;; are defined using all the information available from an embodied

 ;; simulation of the action. Note how much easier they are to define

 ;; than if I only had vision to work with. Things like scale/position

 ;; invariance are complete non-issues here. This is the advantage of

 ;; body-centered action recognition and what I hope to show with this

 ;; thesis.

 

 (defn last-nth

   "Create function that will, when called each frame with the senses

    of a creature, will record those results and return the last n

    results."

   [n]

   (let [last-n  '()]

     (fn [frame-num {:keys [touch proprioception muscles hearing]}]

       (take n (cons [frame-num :stuff] last-n)))))

       

 

 (defn wiggling?

   "Generate a function which, when called each frame with the sensory

    inputs of a worm, will determine whether the worm is wiggling."

   [{:keys [touch proprioception muscles hearing]}]

   (map (fn [f] (f)) proprioception

    

 

 ))

 

 (defn curling?

   "Is the worm curled up?"

   []

   )

 

 (defn resting?

   "Is the worm on the ground in a neutral position?"

   [])

 

 (def standard-world-view

   [(Vector3f. 4.207176, -3.7366982, 3.0816958)

    (Quaternion. 0.11118768, 0.87678415, 0.24434438, -0.3989771)])

 

 (def worm-side-view

   [(Vector3f. 4.207176, -3.7366982, 3.0816958)

    (Quaternion. -0.11555642, 0.88188726, -0.2854942, -0.3569518)])

 

 (def degenerate-worm-view

   [(Vector3f. -0.0708936, -8.570261, 2.6487997)

    (Quaternion. -2.318909E-4, 0.9985348, 0.053941682, 0.004291452)])

 

 (defn worm-world

   ""

   ([] (worm-world curl-script))

   ([motion-script]

      (let [record? false ;;true

            worm (doto (worm-model) (body!))

            touch   (touch! worm)

            prop    (proprioception! worm)

            muscles (movement! worm)

            

            touch-display  (view-touch)

            prop-display   (view-proprioception)

            muscle-display (view-movement)

 

            floor (box 10 1 10 :position (Vector3f. 0 -10 0)

                       :color ColorRGBA/Gray :mass 0)

 

            control-script (motor-control-program

                            muscle-labels motion-script)]

        (world

         (nodify [worm floor])

         standard-debug-controls

         

         (fn [world]

           ;; (set-gravity world Vector3f/ZERO)

           (position-camera world degenerate-worm-view)

           (let [timer (IsoTimer. 60)]

             (.setTimer world timer)

             (display-dilated-time world timer))

           (if record?

             (Capture/captureVideo

              world

              (File. output-base "main-view")))

           (speed-up world)

           (light-up-everything world))

         (fn [world tpf]

           (muscle-display

            (control-script muscles)

            (if record? (File. output-base "muscle")))

           (prop-display

            (prop)

            (if record? (File. output-base "proprio")))             

           (touch-display 

            (map #(% (.getRootNode world)) touch)

            (if record?

              (File. output-base "touch"))))))))