cortex: org/touch.org comparison

comparison org/touch.org @ 233:f27c9fd9134d

seperated out image generating code from touch-kernel

author	Robert McIntyre <rlm@mit.edu>
date	Sun, 12 Feb 2012 06:21:30 -0700
parents	b7762699eeb5
children	712bd7e5b148

comparison

equal deleted inserted replaced

-:b7762699eeb5
+:f27c9fd9134d
 "Return the touch-sensor distribution image in BufferedImage format,
 or nil if it does not exist."
 [#^Geometry obj]
 (if-let [image-path (meta-data obj "touch")]
 (load-image image-path)))
-#+end_src
+(defn tactile-scale
+"Return the maximum length of a hair.  All hairs are scalled between
+0.0 and this length, depending on their color. Black is 0, and
+white is maximum length, and everything in between is scalled
+linearlly. Default scale is 0.01 jMonkeyEngine units."
+[#^Geometry obj]
+(if-let [scale (meta-data obj "scale")]
+scale 0.1))
+#+end_src
 ** TODO add image showing example touch-uv map
 ** TODO add metadata display for worm
-* Triangle Manipulation Functions
-The rigid bodies which make up a creature have an underlying
-=Geometry=, which is a =Mesh= plus a =Material= and other important
-data involved with displaying the body.
-A =Mesh= is composed of =Triangles=, and each =Triangle= has three
-verticies which have coordinates in XYZ space and UV space.
-Here, =(triangles)= gets all the triangles which compose a mesh, and
-=(triangle-UV-coord)= returns the the UV coordinates of the verticies
-of a triangle.
-#+name: triangles-1
-#+begin_src clojure
-(defn triangles
-"Return a sequence of all the Triangles which compose a given
-Geometry."
-[#^Geometry geom]
-(let
-[mesh (.getMesh geom)
-triangles (transient [])]
-(dorun
-(for [n (range (.getTriangleCount mesh))]
-(let [tri (Triangle.)]
-(.getTriangle mesh n tri)
-;; (.calculateNormal tri)
-;; (.calculateCenter tri)
-(conj! triangles tri))))
-(persistent! triangles)))
-(defn mesh-triangle
-"Get the triangle specified by triangle-index from the mesh within
-bounds."
-[#^Mesh mesh triangle-index]
-(let [scratch (Triangle.)]
-(.getTriangle mesh triangle-index scratch)
-scratch))
-(defn triangle-vertex-indices
-"Get the triangle vertex indices of a given triangle from a given
-mesh."
-[#^Mesh mesh triangle-index]
-(let [indices (int-array 3)]
-(.getTriangle mesh triangle-index indices)
-(vec indices)))
-(defn vertex-UV-coord
-"Get the UV-coordinates of the vertex named by vertex-index"
-[#^Mesh mesh vertex-index]
-(let [UV-buffer
-(.getData
-(.getBuffer
-mesh
-VertexBuffer$Type/TexCoord))]
-[(.get UV-buffer (* vertex-index 2))
-(.get UV-buffer (+ 1 (* vertex-index 2)))]))
-(defn triangle-UV-coord
-"Get the UV-cooridnates of the triangle's verticies."
-[#^Mesh mesh width height triangle-index]
-(map (fn [[u v]] (vector (* width u) (* height v)))
-(map (partial vertex-UV-coord mesh)
-(triangle-vertex-indices mesh triangle-index))))
-#+end_src
-* Schrapnel Conversion Functions
-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 triangle-seq [#^Triangle tri]
-[(.get1 tri) (.get2 tri) (.get3 tri)])
-(defn vector3f-seq [#^Vector3f v]
-[(.getX v) (.getY v) (.getZ v)])
-(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 Affine Transforms
-The position of each hair is stored in a 2D image in UV
-coordinates. To place the hair in 3D space we must convert from UV
-coordinates to XYZ coordinates. Each =Triangle= has coordinates in
-both UV-space and XYZ-space, which defines a unique [[http://mathworld.wolfram.com/AffineTransformation.html ][Affine Transform]]
-for translating any coordinate within the UV triangle to the
-cooresponding coordinate in the XYZ triangle.
-#+name: triangles-3
-#+begin_src clojure
-(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]
-(let [mat (Matrix4f.)
-[vert-1 vert-2 vert-3]
-((comp vec map) #(.get t %) (range 3))
-unit-normal (do (.calculateNormal t)(.getNormal t))
-vertices [vert-1 vert-2 vert-3 unit-normal]]
-(dorun
-(for [row (range 4) col (range 3)]
-(do
-(.set mat col row (.get (vertices row)col))
-(.set mat 3 row 1))))
-mat))
-(defn triangle-transformation
-"Returns the affine transformation that converts each vertex in the
-first triangle into the corresponding vertex in the second
-triangle."
-[#^Triangle tri-1 #^Triangle tri-2]
-(.mult
-(triangle->matrix4f tri-2)
-(.invert (triangle->matrix4f tri-1))))
-#+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
-inside the triangle and map them to 3D-space using
-=(triangle-transform)= above. To do this I need a function,
-=(inside-triangle?)=, which determines whether a point is inside a
-triangle in 2D UV-space.
-#+name: triangles-4
-#+begin_src clojure
-(defn convex-bounds
-"Returns the smallest square containing the given vertices, as a
-vector of integers [left top width height]."
-[uv-verts]
-(let [xs (map first uv-verts)
-ys (map second uv-verts)
-x0 (Math/floor (apply min xs))
-y0 (Math/floor (apply min ys))
-x1 (Math/ceil (apply max xs))
-y1 (Math/ceil (apply max ys))]
-[x0 y0 (- x1 x0) (- y1 y0)]))
-(defn same-side?
-"Given the points p1 and p2 and the reference point ref, is point p
-on the same side of the line that goes through p1 and p2 as ref is?"
-[p1 p2 ref p]
-(<=
-0
-(.dot
-(.cross (.subtract p2 p1) (.subtract p p1))
-(.cross (.subtract p2 p1) (.subtract ref p1)))))
-(defn inside-triangle?
-"Is the point inside the triangle?"
-{:author "Dylan Holmes"}
-[#^Triangle tri #^Vector3f p]
-(let [[vert-1 vert-2 vert-3] (triangle-seq tri)]
-(and
-(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
-* Sensor Related Functions
-These functions analyze the touch-sensor-profile image convert the
-location of each touch sensor from pixel coordinates to UV-coordinates
-and XYZ-coordinates.
-#+name: sensors
-#+begin_src clojure
-(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
-* 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
 * Skin Creation
 #+name: kernel
 #+begin_src clojure
-(defn touch-fn
+(in-ns 'cortex.touch)
+(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 0.1
+limit (tactile-scale geo)]
-;;results (CollisionResults.)
-]
 (if (empty? (touch-topology geo))
 nil
 (fn [node]
 (let [sensor-origins
 (map
 (let [results (CollisionResults.)]
 (.collideWith node ray results)
 (let [touch-objects
 (filter #(not (= geo (.getGeometry %)))
 results)]
-(- 255
+[(if (empty? touch-objects)
-(if (empty? touch-objects) 255
+limit (.getDistance (first touch-objects)))
-(rem
+limit])))))))))))
-(int
-(* 255 (/ (.getDistance
-(first touch-objects)) limit)))
-256))))))))))))))
 (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."
 [#^Node creature]
 (filter
 (comp not nil?)
-(map touch-fn
+(map touch-kernel
 (filter #(isa? (class %) Geometry)
 (node-seq creature)))))
 #+end_src
 * Visualizing Touch
 #+name: visualization
 #+begin_src clojure
+(in-ns 'cortex.touch)
+(defn touch->gray
+"Convert a pair of [distance, max-distance] into a grayscale pixel"
+[distance max-distance]
+(gray
+(- 255
+(rem
+(int
+(* 255 (/ distance max-distance)))
+256))))
 (defn view-touch
 "Creates a function which accepts a list of  touch sensor-data and
 displays each element to the screen."
 []
 (view-sense
 [[coords sensor-data]]
 (let [image (points->image coords)]
 (dorun
 (for [i (range (count coords))]
 (.setRGB image ((coords i) 0) ((coords i) 1)
-(gray (sensor-data i)))))
+(apply touch->gray (sensor-data i)))))
 image))))
 #+end_src
+* Triangle Manipulation Functions
+The rigid bodies which make up a creature have an underlying
+=Geometry=, which is a =Mesh= plus a =Material= and other important
+data involved with displaying the body.
+A =Mesh= is composed of =Triangles=, and each =Triangle= has three
+verticies which have coordinates in XYZ space and UV space.
+Here, =(triangles)= gets all the triangles which compose a mesh, and
+=(triangle-UV-coord)= returns the the UV coordinates of the verticies
+of a triangle.
+#+name: triangles-1
+#+begin_src clojure
+(defn triangles
+"Return a sequence of all the Triangles which compose a given
+Geometry."
+[#^Geometry geom]
+(let
+[mesh (.getMesh geom)
+triangles (transient [])]
+(dorun
+(for [n (range (.getTriangleCount mesh))]
+(let [tri (Triangle.)]
+(.getTriangle mesh n tri)
+;; (.calculateNormal tri)
+;; (.calculateCenter tri)
+(conj! triangles tri))))
+(persistent! triangles)))
+(defn mesh-triangle
+"Get the triangle specified by triangle-index from the mesh within
+bounds."
+[#^Mesh mesh triangle-index]
+(let [scratch (Triangle.)]
+(.getTriangle mesh triangle-index scratch)
+scratch))
+(defn triangle-vertex-indices
+"Get the triangle vertex indices of a given triangle from a given
+mesh."
+[#^Mesh mesh triangle-index]
+(let [indices (int-array 3)]
+(.getTriangle mesh triangle-index indices)
+(vec indices)))
+(defn vertex-UV-coord
+"Get the UV-coordinates of the vertex named by vertex-index"
+[#^Mesh mesh vertex-index]
+(let [UV-buffer
+(.getData
+(.getBuffer
+mesh
+VertexBuffer$Type/TexCoord))]
+[(.get UV-buffer (* vertex-index 2))
+(.get UV-buffer (+ 1 (* vertex-index 2)))]))
+(defn triangle-UV-coord
+"Get the UV-cooridnates of the triangle's verticies."
+[#^Mesh mesh width height triangle-index]
+(map (fn [[u v]] (vector (* width u) (* height v)))
+(map (partial vertex-UV-coord mesh)
+(triangle-vertex-indices mesh triangle-index))))
+#+end_src
+* Schrapnel Conversion Functions
+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 triangle-seq [#^Triangle tri]
+[(.get1 tri) (.get2 tri) (.get3 tri)])
+(defn vector3f-seq [#^Vector3f v]
+[(.getX v) (.getY v) (.getZ v)])
+(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 Affine Transforms
+The position of each hair is stored in a 2D image in UV
+coordinates. To place the hair in 3D space we must convert from UV
+coordinates to XYZ coordinates. Each =Triangle= has coordinates in
+both UV-space and XYZ-space, which defines a unique [[http://mathworld.wolfram.com/AffineTransformation.html ][Affine Transform]]
+for translating any coordinate within the UV triangle to the
+cooresponding coordinate in the XYZ triangle.
+#+name: triangles-3
+#+begin_src clojure
+(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]
+(let [mat (Matrix4f.)
+[vert-1 vert-2 vert-3]
+((comp vec map) #(.get t %) (range 3))
+unit-normal (do (.calculateNormal t)(.getNormal t))
+vertices [vert-1 vert-2 vert-3 unit-normal]]
+(dorun
+(for [row (range 4) col (range 3)]
+(do
+(.set mat col row (.get (vertices row)col))
+(.set mat 3 row 1))))
+mat))
+(defn triangle-transformation
+"Returns the affine transformation that converts each vertex in the
+first triangle into the corresponding vertex in the second
+triangle."
+[#^Triangle tri-1 #^Triangle tri-2]
+(.mult
+(triangle->matrix4f tri-2)
+(.invert (triangle->matrix4f tri-1))))
+#+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
+inside the triangle and map them to 3D-space using
+=(triangle-transform)= above. To do this I need a function,
+=(inside-triangle?)=, which determines whether a point is inside a
+triangle in 2D UV-space.
+#+name: triangles-4
+#+begin_src clojure
+(defn convex-bounds
+"Returns the smallest square containing the given vertices, as a
+vector of integers [left top width height]."
+[uv-verts]
+(let [xs (map first uv-verts)
+ys (map second uv-verts)
+x0 (Math/floor (apply min xs))
+y0 (Math/floor (apply min ys))
+x1 (Math/ceil (apply max xs))
+y1 (Math/ceil (apply max ys))]
+[x0 y0 (- x1 x0) (- y1 y0)]))
+(defn same-side?
+"Given the points p1 and p2 and the reference point ref, is point p
+on the same side of the line that goes through p1 and p2 as ref is?"
+[p1 p2 ref p]
+(<=
+0
+(.dot
+(.cross (.subtract p2 p1) (.subtract p p1))
+(.cross (.subtract p2 p1) (.subtract ref p1)))))
+(defn inside-triangle?
+"Is the point inside the triangle?"
+{:author "Dylan Holmes"}
+[#^Triangle tri #^Vector3f p]
+(let [[vert-1 vert-2 vert-3] (triangle-seq tri)]
+(and
+(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
+* Sensor Related Functions
+These functions analyze the touch-sensor-profile image convert the
+location of each touch sensor from pixel coordinates to UV-coordinates
+and XYZ-coordinates.
+#+name: sensors
+#+begin_src clojure
+(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
+* 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
 (fn [world]
 (light-up-everything world))
 (fn [world tpf]
 (touch-display (map #(% (.getRootNode world)) touch))))))
 #+end_src
 * Source Listing
 * Next

Mercurial > cortex

comparison org/touch.org @ 233:f27c9fd9134d