cortex: org/test-creature.org comparison

comparison org/test-creature.org @ 108:92b857b6145d

slow implementation of UV-mapped touch is complete

author	Robert McIntyre <rlm@mit.edu>
date	Sun, 15 Jan 2012 04:08:31 -0700
parents	53fb379ac678
children	c05d8d222166

comparison

equal deleted inserted replaced

-:53fb379ac678
+:92b857b6145d
 (import java.awt.Dimension)
 (import javax.swing.JFrame)
 (import java.awt.Dimension)
 (import com.aurellem.capture.RatchetTimer)
 (declare joint-create)
+(use 'clojure.contrib.def)
 (defn view-image
 "Initailizes a JPanel on which you may draw a BufferedImage.
 Returns a function that accepts a BufferedImage and draws it to the
 JPanel."
 (defn collapse
 "Take a set of pairs of integers and collapse them into a
 contigous bitmap."
 [points]
-(let
+(if (empty? points) []
-[num-points (count points)
+(let
-center (vector
+[num-points (count points)
-(int (average (map first points)))
+center (vector
-(int (average (map first points))))
+(int (average (map first points)))
-flattened
+(int (average (map first points))))
-(reduce
+flattened
-concat
+(reduce
-(map
+concat
-(fn [column]
+(map
-(map vector
+(fn [column]
-(map first column)
+(map vector
-(collapse-1d (second center)
+(map first column)
-(map second column))))
+(collapse-1d (second center)
-(partition-by first (sort-by first points))))
+(map second column))))
-squeezed
+(partition-by first (sort-by first points))))
-(reduce
+squeezed
-concat
+(reduce
-(map
+concat
-(fn [row]
+(map
-(map vector
+(fn [row]
-(collapse-1d (first center)
+(map vector
-(map first row))
+(collapse-1d (first center)
-(map second row)))
+(map first row))
-(partition-by second (sort-by second flattened))))
+(map second row)))
-relocate
+(partition-by second (sort-by second flattened))))
-(let [min-x (apply min (map first squeezed))
+relocate
-min-y (apply min (map second squeezed))]
+(let [min-x (apply min (map first squeezed))
-(map (fn [[x y]]
+min-y (apply min (map second squeezed))]
-[(- x min-x)
+(map (fn [[x y]]
-(- y min-y)])
+[(- x min-x)
-squeezed))]
+(- y min-y)])
-relocate
+squeezed))]
-))
+relocate
+)))
 (defn load-bullet []
 (let [sim (world (Node.) {} no-op no-op)]
 (doto sim
 (.enqueue
 (import jme3tools.converters.ImageToAwt)
 (import ij.ImagePlus)
-(defn triangle-indices
+;; Every Mesh has many triangles, each with its own index.
-"Get the triangle vertex indices of a given triangle from a given
+;; Every vertex has its own index as well.
-mesh."
-[#^Mesh mesh triangle-index]
+(defn tactile-sensor-image
-(let [indices (int-array 3)]
-(.getTriangle mesh triangle-index indices)
-(vec indices)))
-(defn 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))]
-(Vector2f.
-(.get UV-buffer (* vertex-index 2))
-(.get UV-buffer (+ 1 (* vertex-index 2))))))
-(defn tri-uv-coord
-"Get the uv-cooridnates of the triangle's verticies."
-[#^Mesh mesh #^Triangle triangle]
-(map (partial uv-coord mesh)
-(triangle-indices mesh (.getIndex triangle))))
-(defn touch-receptor-image
 "Return the touch-sensor distribution image in ImagePlus format, or
 nil if it does not exist."
 [#^Geometry obj]
 (let [mat (.getMaterial obj)]
 (if-let [texture-param
 MaterialHelper/TEXTURE_TYPE_DIFFUSE)]
 (let
 [texture
 (.getTextureValue texture-param)
 im (.getImage texture)]
-(ImagePlus.
+(ImageToAwt/convert im false false 0)))))
-"UV-map"
-(ImageToAwt/convert im false false 0))))))
 (import ij.process.ImageProcessor)
 (import java.awt.image.BufferedImage)
 (def white -1)
 (defn filter-pixels
-"List the coordinates of all pixels matching pred."
+"List the coordinates of all pixels matching pred, within the bounds
+provided. Bounds -> [x0 y0 width height]"
 {:author "Dylan Holmes"}
-[pred #^ImageProcessor ip]
+([pred #^BufferedImage image]
-(let
+(filter-pixels pred image [0 0 (.getWidth image) (.getHeight image)]))
-[width (.getWidth ip)
+([pred #^BufferedImage image [x0 y0 width height]]
-height (.getHeight ip)]
+((fn accumulate [x y matches]
-((fn accumulate [x y matches]
+(cond
-(cond
+(>= y (+ height y0)) matches
-(>= y height) matches
+(>= x (+ width x0)) (recur 0 (inc y) matches)
-(>= x width) (recur 0 (inc y) matches)
+(pred (.getRGB image x y))
-(pred (.getPixel ip x y))
+(recur (inc x) y (conj matches [x y]))
-(recur (inc x) y (conj matches (Vector2f. x y)))
+:else (recur (inc x) y matches)))
-:else (recur (inc x) y matches)))
+x0 y0 [])))
-0 0 [])))
 (defn white-coordinates
-"List the coordinates of all the white pixels in an image."
+"Coordinates of all the white pixels in a subset of the image."
-[#^ImageProcessor ip]
+[#^BufferedImage image bounds]
-(filter-pixels #(= % white) ip))
+(filter-pixels #(= % white) image bounds))
+(defn triangle
+"Get the triangle specified by triangle-index from the mesh"
+[#^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))))
 (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 of vertices: The first
+"Converts the triangle into a 4x4 matrix: The first three columns
-three columns contain the vertices of the triangle; the last
+contain the vertices of the triangle; the last contains the unit
-contains the unit normal of the triangle. The bottom row is filled
+normal of the triangle. The bottom row is filled with 1s."
-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))
 [#^Triangle tri-1 #^Triangle tri-2]
 (.mult
 (triangle->matrix4f tri-2)
 (.invert (triangle->matrix4f tri-1))))
-(def death (Triangle.
+(defn point->vector2f [[u v]]
-(Vector3f. 1 1 1)
+(Vector2f. u v))
-(Vector3f. 1 2 3)
-(Vector3f. 5 6 7)))
-(def death-2 (Triangle.
-(Vector3f. 2 2 2)
-(Vector3f. 1 1 1)
-(Vector3f. 0 1 0)))
 (defn vector2f->vector3f [v]
 (Vector3f. (.getX v) (.getY v) 0))
-(extend-type Triangle
-Textual
-(text [t]
-(println "Triangle: " \newline (.get1 t) \newline
-(.get2 t) \newline (.get3 t))))
 (defn map-triangle [f #^Triangle tri]
 (Triangle.
 (f 0 (.get1 tri))
 (f 1 (.get2 tri))
 (f 2 (.get3 tri))))
-(defn triangle-seq [#^Triangle tri]
+(defn points->triangle
-[(.get1 tri) (.get2 tri) (.get3 tri)])
+"Convert a list of points into a triangle."
+[points]
-(defn vector3f-seq [#^Vector3f v]
-[(.getX v) (.getY v) (.getZ v)])
-(defn inside-triangle?
-"Is the point inside the triangle? Now what do we do?
-You might want to hold on there"
-{:author "Dylan Holmes"}
-[tri 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 uv-triangle
-"Convert the mesh triangle into the cooresponding triangle in
-UV-space. Z-component of these triangles is always zero."
-[#^Mesh mesh #^Triangle tri]
 (apply #(Triangle. %1 %2 %3)
-(map vector2f->vector3f
+(map (fn [point]
-(tri-uv-coord mesh tri))))
+(let [point (vec point)]
+(Vector3f. (get point 0 0)
-(defn pixel-triangle
+(get point 1 0)
-"Convert the mesh triangle into the corresponding triangle in
+(get point 2 0))))
-UV-pixel-space. Z compenent will be zero."
+(take 3 points))))
-[#^Mesh mesh #^Triangle tri width height]
-(map-triangle (fn [_ v]
+(defn convex-bounds
-(Vector3f. (* width (.getX v))
+"Dimensions of the smallest integer bounding square of the list of
-(* height (.getY v))
+2D verticies in the form: [x y width height]."
-0))
+[uv-verts]
-(uv-triangle mesh tri)))
+(let [xs (map first uv-verts)
+ys (map second uv-verts)
-(def rasterize pixel-triangle)
+x0 (Math/floor (apply min xs))
+y0 (Math/floor (apply min ys))
+x1 (Math/ceil (apply max xs))
-(defn triangle-bounds
+y1 (Math/ceil (apply max ys))]
-"Dimensions of the bounding square of the triangle in the form
+[x0 y0 (- x1 x0) (- y1 y0)]))
-[x y width height].
-Assumes that the triangle lies in the XY plane."
-[#^Triangle tri]
-(let [verts (map vector3f-seq (triangle-seq tri))
-x (apply min (map first verts))
-y (apply min (map second verts))]
-[x y
-(- (apply max (map first verts)) x)
-(- (apply max (map second verts)) y)
-]))
 (defn sensors-in-triangle
 "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)]
+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)))
-(defn locate-feelers
+(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]
-(if-let [image (touch-receptor-image geo)]
+(let [mesh (.getMesh geo)
-(let [mesh (.getMesh geo)
+num-triangles (.getTriangleCount mesh)]
-tris (triangles geo)
+(if-let [image (tactile-sensor-image geo)]
+(map
-width (.getWidth image)
+(partial sensors-in-triangle image mesh)
-height (.getHeight image)
+(range num-triangles))
+(repeat (.getTriangleCount mesh) {:UV nil :geometry nil}))))
-;; for each triangle
-sensor-coords
-(fn [tri]
-;; translate triangle to uv-pixel-space
-(let [uv-tri
-(pixel-triangle mesh tri width height)
-bounds (vec (triangle-bounds uv-tri))]
-;; get that part of the picture
-(apply #(.setRoi image %1 %2 %3 %4) bounds)
-(let [cutout (.crop (.getProcessor image))
-;; extract white pixels inside triangle
-cutout-tri
-(map-triangle
-(fn [_ v]
-(.subtract
-v
-(Vector3f. (bounds 0) (bounds 1) (float 0))))
-uv-tri)
-whites (filter (partial inside-triangle? cutout-tri)
-(map vector2f->vector3f
-(white-coordinates cutout)))
-;; translate pixel coordinates to world-space
-transform (triangle-transformation cutout-tri tri)]
-(map #(.mult transform %) whites))))]
-(vec (map sensor-coords tris)))
-(repeat (count (triangles geo)) [])))
 (use 'clojure.contrib.def)
 (defn-memo touch-topology [#^Gemoetry geo]
-(if-let [image (touch-receptor-image geo)]
+(vec (collapse (reduce concat (map :UV (locate-feelers geo))))))
-(let [feeler-coords
-(map
+(defn-memo feeler-coordinates [#^Geometry geo]
-#(vector (int (.getX %)) (int (.getY %)))
+(vec (map :geometry (locate-feelers geo))))
-(white-coordinates
-(.getProcessor image)))]
-(vec (collapse feeler-coords)))
-[]))
 (defn enable-touch [#^Geometry geo]
-(let [feeler-coords (locate-feelers geo)
+(let [feeler-coords (feeler-coordinates geo)
 tris (triangles geo)
 limit 0.1]
 (fn [node]
 (let [sensor-origins
 (map
 (light-up-everything world)
 (enable-debug world)
 ;;(com.aurellem.capture.Capture/captureVideo
 ;; world (file-str "/home/r/proj/ai-videos/hand"))
 (.setTimer world (RatchetTimer. 60))
+;;(speed-up world)
 ;;(set-gravity world (Vector3f. 0 0 0))
 )
 (fn [world tpf]
 (dorun
 (map #(%1 (%2 (.getRootNode world))) touch-debug-windows touch-nerves))

Mercurial > cortex

comparison org/test-creature.org @ 108:92b857b6145d