cortex: thesis/cortex.org comparison

comparison thesis/cortex.org @ 469:ae10f35022ba

completed first draft of body section.

author	Robert McIntyre <rlm@mit.edu>
date	Fri, 28 Mar 2014 16:34:35 -0400
parents	258078f78b33
children	3401053124b0

comparison

equal deleted inserted replaced

-:258078f78b33
+:ae10f35022ba
 #+caption:
 #+caption:
 #+name: name
 #+ATTR_LaTeX: :width 10cm
 [[./images/aurellem-gray.png]]
 * COMMENT Empathy and Embodiment as problem solving strategies
 By the end of this thesis, you will have seen a novel approach to
 interpreting video using embodiment and empathy. You will have also
 the simulation. The cost is that =CORTEX= can sometimes run slower
 than real time. This can also be an advantage, however ---
 simulations of very simple creatures in =CORTEX= generally run at
 40x on my machine!
-** What is a sense?
+** COMMENT What is a sense?
 If =CORTEX= is to support a wide variety of senses, it would help
 to have a better understanding of what a ``sense'' actually is!
 While vision, touch, and hearing all seem like they are quite
 different things, I was supprised to learn during the course of
 #+caption: density of touch sensors at the tip.
 #+name: finger-side-view
 #+ATTR_LaTeX: :width 10cm
 [[./images/finger-1.png]]
 ** COMMENT Video game engines are a great starting point
 I did not need to write my own physics simulation code or shader to
 build =CORTEX=. Doing so would lead to a system that is impossible
 for anyone but myself to use anyway. Instead, I use a video game
 I chose jMonkeyEngine3 because it because it had the most features
 out of all the free projects I looked at, and because I could then
 write my code in clojure, an implementation of =LISP= that runs on
 the JVM.
-** =CORTEX= uses Blender to create creature models
+** COMMENT =CORTEX= uses Blender to create creature models
 For the simple worm-like creatures I will use later on in this
 thesis, I could define a simple API in =CORTEX= that would allow
 one to create boxes, spheres, etc., and leave that API as the sole
 way to create creatures. However, for =CORTEX= to truly be useful
 #+caption: of muscles, ears, eyes, or joints.
 #+name: sense-nodes
 #+ATTR_LaTeX: :width 10cm
 [[./images/empty-sense-nodes.png]]
+** COMMENT Bodies are composed of segments connected by joints
-** Bodies are composed of segments connected by joints
 Blender is a general purpose animation tool, which has been used in
 the past to create high quality movies such as Sintel
 \cite{sintel}. Though Blender can model and render even complicated
 things like water, it is crucual to keep models that are meant to
 stay as one piece forever; they can be dynamically replaced with
 multiple sections to simulate splitting in two. This could be used
 to simulate retractable claws or =EVE='s hands, which are able to
 coalesce into one object in the movie.
-*** Solidifying/Connecting the body
+*** Solidifying/Connecting a body
-#+caption: View of the hand model in Blender showing the main ``joints''
+=CORTEX= creates a creature in two steps: first, it traverses the
-#+caption: node (highlighted in yellow) and its children which each
+nodes in the blender file and creates physical representations for
-#+caption: represent a joint in the hand. Each joint node has metadata
+any of them that have mass defined in their blender meta-data.
-#+caption: specifying what sort of joint it is.
-#+name: blender-hand
-#+ATTR_LaTeX: :width 10cm
-[[./images/hand-screenshot1.png]]
-=CORTEX= creates a creature in two steps: first, it traverses the
-nodes in the blender file and creates physical representations for
-any of them that have mass defined.
 #+caption: Program for iterating through the nodes in a blender file
 #+caption: and generating physical jMonkeyEngine3 objects with mass
 #+caption: and a matching physics shape.
 #+name: name
 (filter #(isa? (class %) Geometry )
 (node-seq creature)))))
 #+end_src
 #+end_listing
 The next step to making a proper body is to connect those pieces
 together with joints. jMonkeyEngine has a large array of joints
 available via =bullet=, such as Point2Point, Cone, Hinge, and a
 generic Six Degree of Freedom joint, with or without spring
-restitution. =CORTEX='s procedure for binding the creature together
+restitution.
-with joints is as follows:
+Joints are treated a lot like proper senses, in that there is a
-- Find the children of the "joints" node.
+top-level empty node named ``joints'' whose children each
-- Determine the two spatials the joint is meant to connect.
+represent a joint.
-- Create the joint based on the meta-data of the empty node.
+#+caption: View of the hand model in Blender showing the main ``joints''
-The higher order function =sense-nodes= from =cortex.sense=
+#+caption: node (highlighted in yellow) and its children which each
-simplifies finding the joints based on their parent ``joints''
+#+caption: represent a joint in the hand. Each joint node has metadata
-node.
+#+caption: specifying what sort of joint it is.
+#+name: blender-hand
+#+ATTR_LaTeX: :width 10cm
+[[./images/hand-screenshot1.png]]
+=CORTEX='s procedure for binding the creature together with joints
+is as follows:
+- Find the children of the ``joints'' node.
+- Determine the two spatials the joint is meant to connect.
+- Create the joint based on the meta-data of the empty node.
+The higher order function =sense-nodes= from =cortex.sense=
+simplifies finding the joints based on their parent ``joints''
+node.
 #+caption: Retrieving the children empty nodes from a single
 #+caption: named empty node is a common pattern in =CORTEX=
 #+caption: further instances of this technique for the senses
 #+caption: will be omitted
 joints
 (sense-nodes "joints"))
 #+end_src
 #+end_listing
-To find a joint's targets targets, =CORTEX= creates a small cube,
+To find a joint's targets, =CORTEX= creates a small cube, centered
-centered around the empty-node, and grows the cube exponentially
+around the empty-node, and grows the cube exponentially until it
-until it intersects two /physical/ objects. The objects are ordered
+intersects two physical objects. The objects are ordered according
-according to the joint's rotation, with the first one being the
+to the joint's rotation, with the first one being the object that
-object that has more negative coordinates in the joint's reference
+has more negative coordinates in the joint's reference frame.
-frame. Since the objects must be physical, the empty-node itself
+Since the objects must be physical, the empty-node itself escapes
-escapes detection. Because the objects must be physical,
+detection. Because the objects must be physical, =joint-targets=
-=joint-targets= must be called /after/ =physical!= is called.
+must be called /after/ =physical!= is called.
 #+caption: Program to find the targets of a joint node by
 #+caption: exponentiallly growth of a search cube.
 #+name: joint-targets
 #+begin_listing clojure
 #+begin_src clojure
 (defn joint-targets
 "Return the two closest two objects to the joint object, ordered
 from bottom to top according to the joint's rotation."
 [#^Node parts #^Node joint]
 (loop [radius (float 0.01)]
 (.subtract (.getWorldTranslation %)
 (.getWorldTranslation joint))))]
 (.dot (Vector3f. 1 1 1) joint-ref-frame-position))
 (take 2 targets))
 (recur (float (* radius 2))))))))
 #+end_src
 #+end_listing
-Once =CORTEX= finds all joints and targets, it creates them using a
+Once =CORTEX= finds all joints and targets, it creates them using
-simple dispatch on the metadata of the joint node.
+a dispatch on the metadata of each joint node.
 #+caption: Program to dispatch on blender metadata and create joints
 #+caption: sutiable for physical simulation.
 #+name: joint-dispatch
 #+begin_listing clojure
 #+begin_src clojure
 (defmulti joint-dispatch
 "Translate blender pseudo-joints into real JME joints."
 (fn [constraints & _]
 (:type constraints)))
 twist    (:twist constraints)]
 (doto (ConeJoint. control-a control-b pivot-a pivot-b
 rotation rotation)
 (.setLimit (float limit-xz) (float limit-xy)
 (float twist)))))
 #+end_src
 #+end_listing
 All that is left for joints it to combine the above pieces into a
 something that can operate on the collection of nodes that a
 blender file represents.
 #+caption: Program to completely create a joint given information
 #+caption: from a blender file.
 #+name: connect
 #+begin_listing clojure
 #+begin_src clojure
 (defn connect
 "Create a joint between 'obj-a and 'obj-b at the location of
 'joint. The type of joint is determined by the metadata on 'joint.
 ;; when the simulation is started.
 (joint-dispatch constraints
 control-a control-b
 pivot-a pivot-b
 joint-rotation))))
 #+end_src
 #+end_listing
 In general, whenever =CORTEX= exposes a sense (or in this case
 physicality), it provides a function of the type =sense!=, which
 takes in a collection of nodes and augments it to support that
 sense. The function returns any controlls necessary to use that
 sense. In this case =body!= cerates a physical body and returns no
 control functions.
 #+caption: Program to give joints to a creature.
 #+name: name
 #+begin_listing clojure
 #+begin_src clojure
 (defn joints!
 "Connect the solid parts of the creature with physical joints. The
 joints are taken from the \"joints\" node in the creature."
 [#^Node creature]
 (dorun
 particulars of the joints and the masses of each body part are
 determined in blender."
 [#^Node creature]
 (physical! creature)
 (joints! creature))
 #+end_src
 #+end_listing
 All of the code you have just seen amounts to only 130 lines, yet
 because it builds on top of Blender and jMonkeyEngine3, those few
 lines pack quite a punch!
-The hand from figure \ref{blender-hand}, which was modeled after my
+The hand from figure \ref{blender-hand}, which was modeled after
-own right hand, can now be given joints and simulated as a
+my own right hand, can now be given joints and simulated as a
 creature.
 #+caption: With the ability to create physical creatures from blender,
-#+caption: =CORTEX= gets one step closer to a full creature simulation
+#+caption: =CORTEX= gets one step closer to becomming a full creature
-#+caption: environment.
+#+caption: simulation environment.
 #+name: name
 #+ATTR_LaTeX: :width 15cm
 [[./images/physical-hand.png]]
 ** Eyes reuse standard video game components
 ** Hearing is hard; =CORTEX= does it right

Mercurial > cortex

comparison thesis/cortex.org @ 469:ae10f35022ba