cortex: org/touch.org comparison

comparison org/touch.org @ 243:f33fec68f775

touch has been restored, with some very slight speed improvements, and now with much less code

author	Robert McIntyre <rlm@mit.edu>
date	Sun, 12 Feb 2012 14:14:57 -0700
parents	a7f26a074071
children	f23217324f72

comparison

equal deleted inserted replaced

-:a7f26a074071
+:f33fec68f775
 ** TODO add image showing example touch-uv map
 ** TODO add metadata display for worm
 * Skin Creation
-* TODO get the actual lengths for each hair
+* TODO get the actual lengths for each feeler
-#+begin_src clojure
-pixel-triangles
-xyz-triangles
-conversions (map triangles->affine-transform pixel-triangles
-xyz-triangles)
-#+end_src
 =(touch-kernel)= generates the functions which implement the sense of
 touch for a creature. These functions must do 6 things to obtain touch
 data.
 For both of these, =(feeler-tips)=
 - Generate some sort of topology for the sensors.
 =(touch-topology)=
-#+begin_src clojure
-#+end_src
 #+name: kernel
 #+begin_src clojure
 (in-ns 'cortex.touch)
 (declare touch-topology feelers set-ray)
-(defn set-ray [#^Ray ray #^Matrix4f transform
+(defn set-ray [#^Ray ray #^Matrix4f transform #^Vector3f origin
-#^Vector3f origin #^Vector3f tip
+#^Vector3f tip length]
-length]
+;; Doing everything locally recduces garbage collection by enough to
-(.setOrigin ray (.mult transform origin))
+;; be worth it.
-(.setDirection  ray (.subtract
+(.mult transform origin (.getOrigin ray))
-(.mult transform tip)
-(.getOrigin ray)))
+(.mult transform tip (.getDirection ray))
-(.setLimit ray length)
+(.subtractLocal (.getDirection ray) (.getOrigin ray))
-ray)
+(.setLimit ray length))
 (defn touch-kernel
 "Constructs a function which will return tactile sensory data from
 'geo when called from inside a running simulation"
 [#^Geometry geo]
-(let [profile (tactile-sensor-profile geo)
+(if-let
-ray-reference-origins (feeler-origins geo profile)
+[profile (tactile-sensor-profile geo)]
-ray-reference-tips (feeler-tips geo profile)
+(let [ray-reference-origins (feeler-origins geo profile)
-ray-lengths (repeat 9000 0.1)
+ray-reference-tips (feeler-tips geo profile)
-current-rays (map (fn [] (Ray.)) ray-reference-origins)
+ray-lengths (repeat 9000 0.1)
-topology (touch-topology geo profile)]
+current-rays (map (fn [_] (Ray.)) ray-reference-origins)
-(if (empty? ray-reference-origins) nil
+topology (touch-topology geo profile)]
-(fn [node]
-(let [transform (.getWorldMatrix geo)]
-(dorun
-(map (fn [ray ref-origin ref-tip length]
-(set-ray ray transform ref-origin ref-tip length))
-current-rays ray-reference-origins
-ray-reference-tips ray-lengths))
-(vector
-topology
-(vec
-(for [ray current-rays]
-(do
-(let [results (CollisionResults.)]
-(.collideWith node ray results)
-(let [touch-objects
-(filter #(not (= geo (.getGeometry %)))
-results)]
-[(if (empty? touch-objects)
-(.getLimit ray)
-(.getDistance (first touch-objects)))
-(.getLimit ray)])))))))))))
-(defn touch-kernel*
-"Returns a function which returns tactile sensory data when called
-inside a running simulation."
-[#^Geometry geo]
-(let [feeler-coords (feeler-coordinates geo)
-tris (triangles geo)
-limit (tactile-scale geo)]
-(if (empty? (touch-topology geo))
-nil
 (fn [node]
-(let [sensor-origins
+(let [transform (.getWorldMatrix geo)]
-(map
+(dorun
-#(map (partial local-to-world geo) %)
+(map (fn [ray ref-origin ref-tip length]
-feeler-coords)
+(set-ray ray transform ref-origin ref-tip length))
-triangle-normals
+current-rays ray-reference-origins
-(map (partial get-ray-direction geo)
+ray-reference-tips ray-lengths))
-tris)
-rays
-(flatten
-(map (fn [origins norm]
-(map #(doto (Ray. % norm)
-(.setLimit limit)) origins))
-sensor-origins triangle-normals))]
 (vector
-(touch-topology geo)
+topology
 (vec
-(for [ray rays]
+(for [ray current-rays]
 (do
 (let [results (CollisionResults.)]
 (.collideWith node ray results)
 (let [touch-objects
 (filter #(not (= geo (.getGeometry %)))
 results)]
 [(if (empty? touch-objects)
-limit (.getDistance (first touch-objects)))
+(.getLimit ray)
-limit])))))))))))
+(.getDistance (first touch-objects)))
+(.getLimit ray)])))))))))))
 (defn touch!
 "Endow the creature with the sense of touch. Returns a sequence of
 functions, one for each body part with a tactile-sensor-proile,
 each of which when called returns sensory data for that body part."
 (comp not nil?)
 (map touch-kernel
 (filter #(isa? (class %) Geometry)
 (node-seq creature)))))
 #+end_src
+#+results: kernel
+: #'cortex.touch/touch!
 * Sensor Related Functions
 These functions analyze the touch-sensor-profile image convert the
 location of each touch sensor from pixel coordinates to UV-coordinates
 (map #(.add % normal) origins))
 world-coords normals)))
 (defn touch-topology [#^Geometry geo image]
-(collapse (feeler-pixel-coords geo image)))
+(collapse (reduce concat (feeler-pixel-coords geo image))))
+#+end_src
-(defn sensors-in-triangle
-"Locate the touch sensors in the triangle, returning a map of their
-UV and geometry-relative coordinates."
-[image mesh tri-index]
-(let [width (.getWidth image)
-height (.getHeight image)
-UV-vertex-coords (triangle-UV-coord mesh width height tri-index)
-bounds (convex-bounds UV-vertex-coords)
-cutout-triangle (points->triangle UV-vertex-coords)
-UV-sensor-coords
-(filter (comp (partial inside-triangle? cutout-triangle)
-(fn [[u v]] (Vector3f. u v 0)))
-(white-coordinates image bounds))
-UV->geometry (triangle-transformation
-cutout-triangle
-(mesh-triangle mesh tri-index))
-geometry-sensor-coords
-(map (fn [[u v]] (.mult UV->geometry (Vector3f. u v 0)))
-UV-sensor-coords)]
-{:UV UV-sensor-coords :geometry geometry-sensor-coords}))
-(defn-memo locate-feelers
-"Search the geometry's tactile UV profile for touch sensors,
-returning their positions in geometry-relative coordinates."
-[#^Geometry geo]
-(let [mesh (.getMesh geo)
-num-triangles (.getTriangleCount mesh)]
-(if-let [image (tactile-sensor-profile geo)]
-(map
-(partial sensors-in-triangle image mesh)
-(range num-triangles))
-(repeat (.getTriangleCount mesh) {:UV nil :geometry nil}))))
-(defn-memo touch-topology
-"Return a sequence of vectors of the form [x y] describing the
-\"topology\" of the tactile sensors. Points that are close together
-in the touch-topology are generally close together in the simulation."
-[#^Gemoetry geo]
-(vec (collapse (reduce concat (map :UV (locate-feelers geo))))))
-(defn-memo feeler-coordinates
-"The location of the touch sensors in world-space coordinates."
-[#^Geometry geo]
-(vec (map :geometry (locate-feelers geo))))
-#+end_src
 * Visualizing Touch
 #+name: visualization
 #+begin_src clojure
 (in-ns 'cortex.touch)
 for translating any coordinate within the UV triangle to the
 cooresponding coordinate in the XYZ triangle.
 #+name: triangles-3
 #+begin_src clojure
+(in-ns 'cortex.touch)
 (defn triangle->matrix4f
 "Converts the triangle into a 4x4 matrix: The first three columns
 contain the vertices of the triangle; the last contains the unit
 normal of the triangle. The bottom row is filled with 1s."
 [#^Triangle t]
 It is convienent to treat a =Triangle= as a sequence of verticies, and
 a =Vector2f= and =Vector3f= as a sequence of floats. These conversion
 functions make this easy. If these classes implemented =Iterable= then
 this code would not be necessary. Hopefully they will in the future.
-#+name: triangles-2
-#+begin_src clojure
-(defn point->vector2f [[u v]]
-(Vector2f. u v))
-(defn vector2f->vector3f [v]
-(Vector3f. (.getX v) (.getY v) 0))
-(defn map-triangle [f #^Triangle tri]
-(Triangle.
-(f 0 (.get1 tri))
-(f 1 (.get2 tri))
-(f 2 (.get3 tri))))
-(defn points->triangle
-"Convert a list of points into a triangle."
-[points]
-(apply #(Triangle. %1 %2 %3)
-(map (fn [point]
-(let [point (vec point)]
-(Vector3f. (get point 0 0)
-(get point 1 0)
-(get point 2 0))))
-(take 3 points))))
-#+end_src
 * Triangle Boundaries
 For efficiency's sake I will divide the UV-image into small squares
 which inscribe each UV-triangle, then extract the points which lie
 (same-side? vert-1 vert-2 vert-3 p)
 (same-side? vert-2 vert-3 vert-1 p)
 (same-side? vert-3 vert-1 vert-2 p))))
 #+end_src
-#+results: triangles-4
-: #'cortex.touch/inside-triangle?
 * Physics Collision Objects
 The "hairs" are actually =Rays= which extend  from a point on a
 =Triangle= in the =Mesh= normal to the =Triangle's= surface.
-#+name: rays
-#+begin_src clojure
-(defn get-ray-origin
-"Return the origin which a Ray would have to have to be in the exact
-center of a particular Triangle in the Geometry in World
-Coordinates."
-[geom tri]
-(let [new (Vector3f.)]
-(.calculateCenter tri)
-(.localToWorld geom (.getCenter tri) new) new))
-(defn get-ray-direction
-"Return the direction which a Ray would have to have to be to point
-normal to the Triangle, in coordinates relative to the center of the
-Triangle."
-[geom tri]
-(let [n+c (Vector3f.)]
-(.calculateNormal tri)
-(.calculateCenter tri)
-(.localToWorld
-geom
-(.add (.getCenter tri) (.getNormal tri)) n+c)
-(.subtract n+c (get-ray-origin geom tri))))
-#+end_src
 * Headers
 #+name: touch-header
 #+begin_src clojure
 (ns cortex.touch
 (fn [world]
 (light-up-everything world))
 (fn [world tpf]
-(touch-display (map #(% (.getRootNode world)) touch))))))
+(dorun (map #(% (.getRootNode world)) touch))
+))))
 #+end_src
 * Source Listing
 * Next
 * COMMENT Code Generation
 #+begin_src clojure :tangle ../src/cortex/touch.clj
 <<touch-header>>
 <<meta-data>>
 <<triangles-1>>
-<<triangles-2>>
 <<triangles-3>>
 <<triangles-4>>
 <<sensors>>
-<<rays>>
 <<kernel>>
 <<visualization>>
 #+end_src

Mercurial > cortex

comparison org/touch.org @ 243:f33fec68f775