#+title: Fun with Gabor Filters

 #+author: Robert McIntyre

 #+email: rlm@mit.edu

 #+description: gabor filters in clojure with opencv

 #+keywords: computer vision, jMonkeyEngine3, clojure, opencv

 #+SETUPFILE: ../../aurellem/org/setup.org

 #+INCLUDE: ../../aurellem/org/level-0.org

 #+babel: :mkdirp yes :noweb yes :exports both

 

 

 

 #+name: gabor

 #+begin_src clojure

 (ns cortex.gabor

   (:import org.opencv.core.CvType)

   (:import java.awt.image.BufferedImage)

   (:import ij.ImagePlus)

   (:import org.opencv.core.Mat)

   (:use (cortex world sense util vision))

   (:import com.jme3.post.SceneProcessor)

   (:import (com.jme3.util BufferUtils Screenshots))

   (:import java.nio.ByteBuffer)

   (:import java.awt.image.BufferedImage)

   (:import (com.jme3.renderer ViewPort Camera))

   (:import (com.jme3.math ColorRGBA Vector3f Matrix3f Vector2f))

   (:import com.jme3.renderer.Renderer)

   (:import com.jme3.app.Application)

   (:import com.jme3.texture.FrameBuffer)

   (:import (com.jme3.scene Node Spatial)))

 

 

 (cortex.import/mega-import-jme3)

 

 (defn load-opencv

   "Load the opencv native library. Must be called before any OpenCV

   stuff is used."

   []

   (clojure.lang.RT/loadLibrary "opencv_java249"))

 

 (defn gabor-kernel [sigma aspect-ratio theta wavelength phase-offset]

   

   ;; first, find the size of the kernel which is required

   (let [square #(expt % 2)

         rotated (fn [[x y]]

                   [(+ (* x (Math/cos theta)) (* y (Math/sin theta)))

                    (- (* y (Math/cos theta))  (* x (Math/sin theta)))])

                              

         gaussian (fn [[x y]]

                    (let [[x' y'] (rotated [x y])]

                      (Math/exp (- (/ (+ (square x')

                                         (square (* aspect-ratio y')))

                                    (* 2 (square sigma)))))))

         sinusoid (fn [[x y]]

                    (let [[x' y'] (rotated [x y])]

                      (Math/cos

                       (+ (* 2 Math/PI (/ x' wavelength))

                          phase-offset))))

 

         half-width

         (let [std-dev-capture 5]

           (max

            (int (* std-dev-capture (/ sigma aspect-ratio)))

            (int (* std-dev-capture sigma))

            (int (* std-dev-capture (/ aspect-ratio sigma)))))

 

         grid (let [axis (range (- half-width) (inc half-width))]

                (for [y (reverse axis) x axis] (vector x y)))

 

         scale (reduce + (map gaussian grid))

         

         gabor (fn [[x y :as coord]]

                 (* (sinusoid coord) (gaussian coord) (/ scale)))

 

         mat-width (+ 1 (* 2 half-width))

         mat (Mat. mat-width mat-width CvType/CV_32F)]

     

     (.put mat 0 0 (float-array (map gabor grid)))

     mat))

 

 

 (defn draw-kernel! [kernel img-path]

   (let [output img-path

         size (.size kernel)

         width (int (.width size))

         height (int (.height size))

         tmp-array (float-array (* width height))]

 

     ;; read values from matrix.

     (.get kernel 0 0 tmp-array)

 

     ;; find overall dynamic range of the filter

     (let [vals (vec tmp-array)

           low (apply min vals)

           high (apply max vals)

           scaled-vals (map #(* 255 (- % low) (/ (- high low))) vals)

           new-mat (Mat. height width CvType/CV_32F)]

       (.put new-mat 0 0 (float-array scaled-vals))

       (org.opencv.highgui.Highgui/imwrite output new-mat))))

 

 (defn show-kernel [kernel]

   (let [img-path "/home/r/proj/cortex/tmp/kernel.png"]

     (draw-kernel! kernel img-path)

     (view (ImagePlus. output))))

 

 (defn print-kernel [kernel]

   (println (.dump kernel)))

                            

 

 (def brick-length 0.48)

 (def brick-width 0.24)

 (def brick-height 0.12)

 (def gravity (Vector3f. 0 -9.81 0))

 

 

 (defn brick* [position]

   (println "get brick.")

   (doto (box brick-length brick-height brick-width

 	     :position position :name "brick"

 	     :material "Common/MatDefs/Misc/Unshaded.j3md"

 	     :texture "Textures/Terrain/BrickWall/BrickWall.jpg"

 	     :mass 34)

     (->

      (.getMesh)

      (.scaleTextureCoordinates (Vector2f. 1 0.5)))

     (.setShadowMode RenderQueue$ShadowMode/CastAndReceive)

     )

   )

 

 

 (defn floor*

   "make a sturdy, unmovable physical floor"

   []

   (box 10 0.1 5 :name "floor" :mass 0 :color ColorRGBA/Gray :position (Vector3f. 0 0 0)))

 

 (defn floor* []

   (doto (box 10 0.1 5 :name "floor" ;10 0.1 5 ; 240 0.1 240

 	     :material "Common/MatDefs/Misc/Unshaded.j3md"

 	     :texture "Textures/BronzeCopper030.jpg"

 	     :position (Vector3f. 0 0 0 )

 	     :mass 0)

     (->

      (.getMesh)

      (.scaleTextureCoordinates (Vector2f. 3 6)));64 64

     (->

      (.getMaterial)

      (.getTextureParam "ColorMap")

      (.getTextureValue)

      (.setWrap Texture$WrapMode/Repeat))

     (.setShadowMode RenderQueue$ShadowMode/Receive)

   ))

 

 

 (defn brick-wall* []

   (let [node (Node. "brick-wall")]

     (dorun

      (map

       (comp  #(.attachChild node %) brick*)

        (for [y (range 10)

 	     x (range 4)

 	     z (range 1)]

        	    (Vector3f.

        	     (+ (* 2 x brick-length)

 		(if (even? (+ y z)) 

 		  (/ brick-length 4) (/ brick-length -4)))

        	     (+ (* brick-height (inc (* 2 y))))

 	     (* 2 z brick-width) ))))

     (.setShadowMode node RenderQueue$ShadowMode/CastAndReceive)

     node))

 

 (import com.aurellem.capture.Capture)

 

 (import java.io.File)

 

 

 (defn brick-wall-game-run [record?]

   (doto

       (world

        (doto (Node.) (.attachChild (floor*))

 	     (.attachChild (brick-wall*))

 	     )

        {"key-f" (fn [game value] 

 		  (if (not value) (add-element game (brick-wall*))))

 	"key-space" (fire-cannon-ball )}

        (fn [world]

          (position-camera world

           (Vector3f. 1.382548, 4.0383573, 5.994235)

           (Quaternion. 0.0013082094, 0.98581666, -0.1676442, 0.0076932586))

 

          ;;(speed-up world)

          

          (if record?

            (Capture/captureVideo

             world

             (File.

              "/home/r/proj/cortex/render/gabor-1/main")))

            (add-camera! world (.getCamera world) no-op))

        (fn [& _]))     

     (.start)))

 

 (defn convolve-practice [kernel]

   (let [input "/home/r/proj/cortex/render/gabor-1/main/0000032.png"

         

         

         output "/home/r/ppp.png"

 

         i (org.opencv.highgui.Highgui/imread input)

 

         kernel (gabor-kernel 10 1 (/ Math/PI 2) 10 0)

 

         new-mat (Mat.)

                 

         ]

 

     (org.opencv.imgproc.Imgproc/filter2D  i new-mat CvType/CV_32F kernel)

     

     (org.opencv.highgui.Highgui/imwrite "/home/r/ppp.png" new-mat)

     

     (view (ImagePlus. input))

     (view (ImagePlus. output))))

 

 

 

 (defn generate-gabor-images []

   (gabor-kernel 2.8 1 0 3.5 0)

 

 

 

 

 #+end_src

 

 

 

 * COMMENT Generate Source

 #+begin_src clojure :tangle ../src/cortex/gabor.clj

 <<gabor>>

 #+end_src