(ns laser.rasterize

   (:use [rlm

 	 image-utils

 	 map-utils]

 	[clojure.contrib

 	 [str-utils :only [str-join re-gsub re-split]]

 	 [seq :only [indexed]]

 	 [math]])

   (:import [ij ImagePlus IJ]))

 

 ;(import '(java.io File))

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

 ;(import '(javax.imageio ImageIO) )

 

 

 (set! *print-length* 20)

 (def feed 120)

 (def  dpi [500, 500])

 (def paramaters {:x-dpi 500 :y-dpi 500 :margin 0.501 :x-offset 1.001 :y-offset 1})

 

 ;;; this process is divided into two tasks,

 ;;; creating the raster g-code, which sweeps back and forth

 ;;; and creating the gmask, which turns the laser on and off.

 

 

 ;;; we'll be using frame-hashes, which represent picutres as

 ;;; a 3D vector field over 2D space, with the vectors representing

 ;;; the rgb values at that particulat point. 

 

 (defn select-row

   "returns a frame hash that is just a single line at the chosen y"

   [y window]

   (filter-keys (comp (partial = y) last) window))

 

 (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))))))

 

 

 ;;; generate rastering g-code

 

 (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) ")"))

 

 

 ;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))))

 

 

 (comment

 

   (import 'org.im4java.core.ConvertCmd)

   (import 'org.im4java.core.IMOperation)

   (import 'org.im4java.core.Stream2BufferedImage)			

   

   (def target (.getBufferedImage (ImagePlus. sing)))

   (def shiv (IMOperation.))

   (.addImage shiv)

   (.addImage shiv (into-array String ["png:-"]))

   (def conv-shiv (ConvertCmd.))

   (def s2b (Stream2BufferedImage.))

   (.setOutputConsumer conv-shiv s2b)

   (.run conv-shiv shiv (into-array Object [target]))

   (def result (.getImage s2b ))

 

   )

 

 (defn mirror

   "ImagePlus to ImagePlus via imageMagick through im4java!" 

   [#^ImagePlus img]

   (let [title (.getTitle img)

 	target (.getBufferedImage img)

 	s2b (Stream2BufferedImage.)

 	shiv (doto (IMOperation.)

 	       ;(.blur 2.0)

 	       (.flip)

 	       (.addImage)

 	       (.addImage (into-array String ["png:-"])))

 	conv-shiv (doto (ConvertCmd.)

 		    (.setOutputConsumer s2b))]

 

     (.run conv-shiv shiv (into-array Object [target]))

     (ImagePlus. title (.getImage s2b))))

 	

     

  

 (defn row->gcode [{:keys [x-dpi y-dpi margin x-offset y-offset]} forward? row]

   

   (let [[x1 y1] (if forward? (last row) (first row))

 	[x2 y2] (if forward? (first row) (last row))]

 

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

 	  x2 (* x2 (/ x-dpi))

 	  y1 (* y1 (/ y-dpi))

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

 

     (let [x1 (+ x1 x-offset)

 	  x2 (+ x2 x-offset)

 	  y1 (+ y1 y-offset)

 	  y2 (+ y2 y-offset)]

 

       (let [margin (if forward? margin (- margin))]

 

 	(let [x1 (+ x1 margin)

 	      x2 (- x2 margin)]

 

       

           

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

 		   (float x1 )

 		   (float  y1))

 	   

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

 		   (float x2)

 		   (float y2)))))))))

   

 (defn generate-gcode [pic]

   (str (raster-preamble)

        (str-join ""

 		 (map

 		  (fn [[index row]]

 		    (row->gcode paramaters (even? index) row))

 		    (indexed (make-rows pic))))

 		 (raster-epilogue)))

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 (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 [{:keys [x-dpi y-dpi margin x-offset y-offset]} forward? row]

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

 					  (if forward?

 					    (reverse row) row)))))

 	start (+ start x-offset)

 	]

     (let [preamble (if-not forward?

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

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

 	  body

 	  (for [[x y]

 		(if forward?

 		  (reverse (gather-row row))

 		  (gather-row row))]

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

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

 		  x (+ x x-offset)

 		  y (+ y y-offset)

 

 

 

 

 		  ]

 	      

      

 	      (if-not forward?

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

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

 		

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

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

 

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

 

 

 (defn generate-gmask [pic]

   (str "1 0 0 0\n"

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

 			   (row->gmask paramaters (even? index) row))

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

 

 

 

 

 ;;;; testing

 

 (defn generate-files [pic]

     (println "made-image")

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

     (println "/home/r/kevin/out.ngc")

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

     (println "/home/r/kevin/out.gmask")

     pic)

 

 (defn update-state []

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

   (def pic (frame-hash (mirror (ImagePlus. sing))))

   (def pic (b&w pic)))

 

 (defn compare-gen-fn [n f cmp]

   (let [theirs (re-split #"\n" (slurp cmp))

 	ours   (re-split #"\n" (f pic))]

     (println (format "%1$-25s%2$s" "OURS" "THEIRS"))

     (println "_______________________________________")

     (dorun (map (fn [[us them]] (println

 			     (format "%1$-25s%2$s" us them)))

 			     (take n (partition 2 (interleave  ours theirs)))))))

 

 (defn compare-gcode [n]

   (compare-gen-fn n generate-gcode "/home/r/kevin/reference.ngc"))

 (defn compare-gmask [n]

   (compare-gen-fn n generate-gmask "/home/r/kevin/reference.gmask"))