(ns laser.rasterize)

 

 (import '(java.io File))

 (import '(org.apache.commons.io FileUtils))

 (import '(javax.imageio ImageIO) )

 (import '(javax.swing JFrame))

 (import '(java.awt Color BorderLayout))

 (import '(ij ImagePlus IJ))

 (import '(java.lang Math))

 (import '(java.awt Graphics2D Panel))

 (import '(ij Macro))

 

 (import '(java.io BufferedReader InputStreamReader))

 (import '(java.awt.image BufferedImage))

 

 (use 'clojure.contrib.str-utils)

 (use 'clojure.contrib.seq-utils)

 (use 'clojure.contrib.combinatorics)

 (use 'clojure.contrib.duck-streams)

 

 (use 'clojure.contrib.repl-utils)

 

 (set! *print-length* 20)

 

 

 

 

 (def feed 120)

 (def  dpi [500, 500])

 

 

 

 

 (defn preserve-meta [f]

   (fn [& x] (with-meta

 	      (apply f x)

 	      (meta (last x)))))

 

 (defmulti frame-hash-multi  class)

 

 

 (defmethod frame-hash-multi ImagePlus

   [image+]

     (with-meta

       (let [buf (.. image+ getBufferedImage)

 	    color (.getColorModel buf)]

 	(apply hash-map 

 	       (interleave 

 		(doall (for [x (range (.getWidth image+)) y (range (.getHeight image+))]

 			 (vector x y)))

 		(doall (for [x (range (.getWidth image+)) y (range (.getHeight image+))]

 			 (let [data (.getRGB buf x y)] 

 			   (hash-map :r (bit-shift-right (bit-and 0xff0000 data) 16)

 				     :g (bit-shift-right (bit-and 0x00ff00 data) 8)

 				     :b (bit-and 0x0000ff data))))))))

       {:width  (.getWidth image+) :height (.getHeight image+)}))

 

 

 (defmethod frame-hash-multi String

   [image-name]

   (let [image+ (ImagePlus. image-name)]

     (frame-hash-multi image+)))

 

 

 (defn frame-hash

   "yields a convienent representation for the pixles in an image.

    Because of the size of the structvre generated, this must only be used

    in a transient way so that java can do it's garbage collection."

   [something]

   (frame-hash-multi something))

 

 ;(def frame-hash (preserve-meta frame-hash))

  

 

 

 

 (def white {:r 255, :g 255, :b 255})

 (def black {:r 0,   :g 0,   :b 0})

 

 (def expt #(Math/pow %1 %2))

 

 (defn rgb-euclidian

   [{r1 :r g1 :g b1 :b} {r2 :r g2 :g b2 :b} ]

   (expt (+ (expt (- r1 r2) 2)

 	  (expt (- g1 g2) 2)

 	  (expt (- b1 b2) 2)) 0.5))

 

 (defn b&w

   "turn everything strictly black or white"

   [window]

   (with-meta

   (zipmap

    (keys window)

    (map (fn  [rgb] 

 	  (if (> (rgb-euclidian rgb white) (rgb-euclidian rgb black))

 	    black white))

 	(vals window))) (meta window)))

 

 

 

 (defn raster-preamble []

   (str-join \newline

 	    ["M63 P0\nG61"

 	    (str \F feed)

 	    "M101"

 	    "M3 S1\n"]))

 

 (defn raster-epilogue []

   (str-join \newline

 	    ["M63 P0"

 	     "M5"

 	     "M2\n"]))

 

 

 (defn raster-comment [string]

   (str "(" (re-gsub #"[()]" "" string) ")"))

 

 (defn filter-keys [fun m]

   (select-keys m (filter fun (keys m))))

 

 (def filter-keys (preserve-meta filter-keys))

 

 (defn filter-vals [fun m]

     (into {} (filter (comp fun val) m)))

 

 (def filter-vals (preserve-meta filter-vals))

 

 (defn frame-hash->bufferedImage

   [frame-hash]

     (let [data  (meta frame-hash)

 	image (BufferedImage. (:width data) (:height data) BufferedImage/TYPE_INT_BGR)]

 	

 	(doall (for [element frame-hash] 

 	  (let [coord  (key element) 

 		rgb   (val element)

 		packed-RGB 

 		(+ (bit-shift-left (:r rgb) 16)

 		   (bit-shift-left (:g rgb) 8)

 		                   (:b rgb))]

 	    (.setRGB image (first coord) (last coord) packed-RGB))))

 	image))

   

 (defmulti  display "Creates a JFrame and displays a buffered image"  class)

 

 (defn- makePanel [image] (proxy [Panel] [] (paint [g]  (.drawImage g image 0 0 nil))))

 

 (defn select-row [x window]

   (filter-keys (comp (partial = x) first) window))

 

 

 

 (defmethod display 

   BufferedImage  [image] 

   (let [panel (makePanel image)

 	frame (JFrame. "Oh Yeah!")]

     (.add frame panel) 

     (.pack frame) 

     (.setVisible frame true ) 

     (.setSize frame(.getWidth image) (.getHeight image))))

  

 (defmethod display

   ImagePlus [image]

   (display (.getBufferedImage image)))

 

 (defmethod display

   clojure.lang.PersistentHashMap [frame-hash]

   (display (frame-hash->bufferedImage frame-hash)))

 

 (defmethod display

     clojure.lang.PersistentArrayMap [frame-hash]

     (display (frame-hash->bufferedImage frame-hash)))

 

 

 

 

 

 ;this is a sequence of rows

 

 ;(defn span [row]

 ;  (let [sorted-row (sort #(< (first %1) (first %2)) row)]

 ;    (vector (first sorted-row) (last sorted-row))))

 

 

 (defn row->gcode [[x-dpi y-dpi] row]

   (let [[x1 y1] (first row)

 	[x2 y2] (last row)]

     (str (format "G0 X%.3f Y%.3f\n"

 		 (float (* x1 (/ x-dpi)))

 		 (float (* y1 (/ y-dpi))))

 	 

 	 (format "G1 X%.3f Y%.3f\n"

 		 (float (* x2 (/ x-dpi)))

 		 (float (* y2 (/ y-dpi)))))))

 

 (defn gather-row [row]

   (let [base    [[(first (first row)) (first (first row))]]]

 					;  (println base)

     (reduce 

      (fn colapse [collection new-n]

        

        (let [collection (apply vector collection)

 	     prevoius (last (last collection))

 	     range-start (first (last collection))]

 					;       (println new-n)

 					;       (println prevoius)

 					;       (println range-start)

 	 (if (<= new-n (+ prevoius 1))

 		     (do ;(println "join")

 					;(println (butlast collection)) 

 		       (conj (apply vector (butlast collection))  (vector range-start new-n)))

 		     (conj collection  (vector new-n new-n)))))

      

      base

 	       (map first row))))

 

 

 

 (defn row->gmask [[x-dpi y-dpi] forward? row]

 

   (let [start (float (* (/ x-dpi) (first (first row))))]

 

     (let [preamble (if forward?

 		     (str 

 		     (format "0 0 0 %.3f\n" start)

 		     (format "0 0 1 %.3f\n" start)))

 	  body

 	  (for [[x y] (gather-row row)]

 	    (let [x (float (* x (/ x-dpi)))

 		  y (float (* y (/ x-dpi)))]

 	      (if forward?

 		(str (format "0 0 1 %.3f\n" x)

 		     (format "0 1 1 %.3f\n" y))

 		

 		(str (format "0 0 0 %.3f\n" x)

 		     (format "0 1 0 %.3f\n" y)))))]

 

       (str preamble (str-join "" body)))))

 

 

 

 (defn make-rows [pic]

   

   (map (partial sort #(< (first %1) (first %2)))

        (partition-by last

 		     (sort (fn [[x1 y1][x2 y2]] (> y2 y1))

 			   (map first (filter-vals (partial = black) pic))))))

 

 

 

 (defn generate-gmask [pic]

 

   (str "1 0 0 0\n"

        (str-join "" (map (fn [[index row]]

 			   (row->gmask dpi (odd? index) row))

 			 (indexed (make-rows pic))))))

 

 ;; 1 0 0 0

 ;; 0 0 1 2.881

 ;; 0 0 0 2.881

 ;; 0 1 0 2.863

 ;; 0 0 0 2.769

 ;; 0 1 0 2.751

 ;; 0 0 0 2.729

 ;; 0 1 0 2.617

 ;; 0 0 0 2.593

 ;; 0 1 0 2.561

 ;; 0 0 0 2.463

 ;; 0 1 0 2.445

 ;; 0 0 0 2.385

 ;; 0 1 0 2.317

 ;; 0 0 0 2.253

 ;; 0 1 0 2.233

 ;; 0 0 0 2.177

 

 

 

 (defn generate-gcode [pic]

   (str (raster-preamble)

        

        

        (str-join "" (map (partial row->gcode dpi) (make-rows pic)))

        (raster-epilogue)))

   

 

 

 (defn rotate [degrees #^ImagePlus image]

   (.rotate (.getChannelProcessor image) degrees)

   image)

 

 (defn map-keys [f m]

   (into {} (map (fn [[key val]] [(f key) val]) m)))

 

 

 

 (defn invert-frame-hash [pic]

   (map-keys (fn [[x y]] [x (- (:height (meta pic)) y 1)]) pic ))

 

 

 (defn generate-files [pic]

   (let [image (invert-frame-hash (b&w (frame-hash  (rotate 180 (ImagePlus. pic)))))]

     (spit "/home/r/kevin/out.ngc" (generate-gcode image))

     (spit "/home/r/kevin/out.gmask" (generate-gmask image))

     image))

 

   

 

 ;;;; testing

 

 (defn init []

   (let [stuff

     

       (bound-fn []

 

 	(do 

 	  (println "hi everyone")

 	  (def img "/home/r/kevin/sing.png")

 	  (def pic (frame-hash (let [image  (ImagePlus. img)]

 				 (.rotate (.getChannelProcessor image) 180)

 				 image)))

 

 

 	  (def test-image

 	       (invert-frame-hash (b&w (frame-hash  (rotate 180 (ImagePlus. img))))))

 	  

 	  (defn test-gmask []

 	    (println (str-join "" (take 170 (generate-gmask test-image)))))

 

 	  (println "ALL variables initialized!")

 

 	  ))]

   (.start

      (Thread. stuff))))

 

 

 

 (defn thread-test []

 

   (let [temp *out*]

     (.start

      (Thread.

       (fn []

 	(with-bindings  {#'clojure.core/*out* temp}

 	  (Thread/sleep 5000)

 	  (println "hi")))))))