cortex: org/skin.org comparison

comparison org/skin.org @ 156:e8df6e76c3e5

refactored touch

author	Robert McIntyre <rlm@mit.edu>
date	Fri, 03 Feb 2012 06:15:34 -0700
parents	39e4e1542e4a
children

comparison

equal deleted inserted replaced

-:95bf55614211
+:e8df6e76c3e5
 "Simulate the sense of touch in jMonkeyEngine3. Enables any Geometry
 to be outfitted with touch sensors with density proportional to the
 density of triangles along the surface of the Geometry. Enables a
 Geometry to know what parts of itself are touching nearby objects."
 {:author "Robert McIntyre"}
-(:use (cortex world util))
+(:use (cortex world util sense))
 (:import com.jme3.scene.Geometry)
 (:import com.jme3.collision.CollisionResults)
+(:import jme3tools.converters.ImageToAwt)
 (:import (com.jme3.math Triangle Vector3f Ray)))
+(use 'clojure.contrib.def)
+(cortex.import/mega-import-jme3)
 (defn triangles
 "Return a sequence of all the Triangles which compose a given
 Geometry."
 [#^Geometry geom]
 (let
 (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 in the
+"Return the direction which a Ray would have to have to be to point
-exact center of a particular Triangle in the Geometry, pointing
 normal to the Triangle, in coordinates relative to the center of the
 Triangle."
 [geom tri]
 (let [n+c (Vector3f.)]
 (.calculateNormal tri)
 (.localToWorld
 geom
 (.add (.getCenter tri) (.getNormal tri)) n+c)
 (.subtract n+c (get-ray-origin geom tri))))
-(defn normal-rays
+;; Every Mesh has many triangles, each with its own index.
-"For each Triangle which comprises the Geometry, returns a Ray which
+;; Every vertex has its own index as well.
-is centered on that Triangle, points outward in a normal direction,
-and extends for =limit= distance."
+(defn tactile-sensor-image
-[limit #^Geometry geom]
+"Return the touch-sensor distribution image in BufferedImage format,
-(vec
+or nil if it does not exist."
-(map
+[#^Geometry obj]
-(fn [tri]
+(if-let [image-path (meta-data obj "touch")]
-(doto
+(ImageToAwt/convert
-(Ray. (get-ray-origin geom tri)
+(.getImage
-(get-ray-direction geom tri))
+(.loadTexture
-(.setLimit limit)))
+(asset-manager)
-(triangles geom))))
+image-path))
+false false 0)))
-(defn touch-percieve
-"Augment a Geometry with the sense of touch. Returns a sequence of
-non-negative integers, one for each triangle, with the value of the
-integer describing how many objects a ray of length =limit=, normal
+(defn triangle
-to the triangle and originating from its center, encountered. The
+"Get the triangle specified by triangle-index from the mesh within
-Geometry itself is not counted among the results."
+bounds."
-[limit geom node]
+[#^Mesh mesh triangle-index]
-(let [normals  (normal-rays limit geom)]
+(let [scratch (Triangle.)]
-(doall
+(.getTriangle mesh triangle-index scratch)
-(for [ray normals]
+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))))
+(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 triangle-seq [#^Triangle tri]
+[(.get1 tri) (.get2 tri) (.get3 tri)])
+(defn vector3f-seq [#^Vector3f v]
+[(.getX v) (.getY v) (.getZ v)])
+(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))))
+(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
-(let [results (CollisionResults.)]
+(.set mat col row (.get (vertices row)col))
-(.collideWith node ray results)
+(.set mat 3 row 1))))
-(let [touch-objects
+mat))
-(set (filter #(not (= geom %))
-(map #(.getGeometry %) results)))]
+(defn triangle-transformation
-(count touch-objects))))))))
+"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))))
+(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))))
+(defn convex-bounds
+;;dylan
+"Returns the smallest square containing the given
+vertices, as a vector of integers [left top width height]."
+;; "Dimensions of the smallest integer bounding square of the list of
+;;  2D verticies in the form: [x y 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 sensors-in-triangle
+;;dylan
+"Locate the touch sensors in the triangle, returning a map of their UV and geometry-relative coordinates."
+;;"Find the locations of the touch sensors within a triangle in both
+;; UV and gemoetry 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
+(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 image 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-image geo)]
+(map
+(partial sensors-in-triangle image mesh)
+(range num-triangles))
+(repeat (.getTriangleCount mesh) {:UV nil :geometry nil}))))
+(defn-memo touch-topology [#^Gemoetry geo]
+(vec (collapse (reduce concat (map :UV (locate-feelers geo))))))
+(defn-memo feeler-coordinates [#^Geometry geo]
+(vec (map :geometry (locate-feelers geo))))
+(defn enable-touch [#^Geometry geo]
+(let [feeler-coords (feeler-coordinates geo)
+tris (triangles geo)
+limit 0.1
+;;results (CollisionResults.)
+]
+(if (empty? (touch-topology geo))
+nil
+(fn [node]
+(let [sensor-origins
+(map
+#(map (partial local-to-world geo) %)
+feeler-coords)
+triangle-normals
+(map (partial get-ray-direction geo)
+tris)
+rays
+(flatten
+(map (fn [origins norm]
+(map #(doto (Ray. % norm)
+(.setLimit limit)) origins))
+sensor-origins triangle-normals))]
+(vector
+(touch-topology geo)
+(vec
+(for [ray rays]
+(do
+(let [results (CollisionResults.)]
+(.collideWith node ray results)
+(let [touch-objects
+(filter #(not (= geo (.getGeometry %)))
+results)]
+(- 255
+(if (empty? touch-objects) 255
+(rem
+(int
+(* 255 (/ (.getDistance
+(first touch-objects)) limit)))
+256))))))))))))))
+(defn touch [#^Node pieces]
+(filter (comp not nil?)
+(map enable-touch
+(filter #(isa? (class %) Geometry)
+(node-seq pieces)))))
 #+end_src
 * Example

Mercurial > cortex

comparison org/skin.org @ 156:e8df6e76c3e5