                 (swap! state assoc
                        :burst-time-offset (- (elapsed-time @state)
                                              (core-time-from-tags (image :tags)))))
-              (println (image+ :tags))
+              ;(println (image+ :tags))
               (.put out-queue (make-TaggedImage (annotate-image image+ evt @state
                                                                 (burst-time (:tags image) @state)))))
             (when (core isBufferOverflowed)
               (swap! state assoc :stop true)
               (ReportingUtils/showError "Circular buffer overflowed."))))
-        (flatten (map make-multicamera-events) (event :burst-data)))))
+        (flatten (map make-multicamera-events (event :burst-data))))))
   (while (and (not (@state :stop)) (. mmc isSequenceRunning))
     (Thread/sleep 5)))
 
 (defn collect-snap-image [event out-queue]
-  (log "collect-snap-image")
-  (doall
-    (for [event1 (make-multicamera-events event)]
-      (let [image
-            {:pix (core getImage (event1 :camera-channel-index))
-             :tags nil}]
-        (log "collect-snap-image: "
-             (select-keys event [:position-index :frame-index
-                                 :slice-index :channel-index]))
-        (when out-queue
-          (.put out-queue
-                (make-TaggedImage (annotate-image image event1 @state (elapsed-time @state)))))
-        image))))
+  (let [image
+        {:pix (core getImage)
+         :tags nil}]
+    (select-keys event [:position-index :frame-index
+                        :slice-index :channel-index])
+    (when out-queue
+      (.put out-queue
+            (make-TaggedImage (annotate-image image event @state (elapsed-time @state)))))
+    image))
 
 (defn return-config []
   (dorun (map set-property

;; generic metadata

(defn convert-settings [^SequenceSettings settings]
  (-> settings
    (data-object-to-map)
    (rekey

  
(defn load-slice-sequence [slice-sequence relative-z]
  (when slice-sequence
    (let [z (core getFocusDevice)
          ref (@state :reference-z)
          adjusted-slices (vec (if relative-z
                                 (map #(+ ref %) slice-sequence)
                                 slice-sequence))
          new-seq (not= [z adjusted-slices] @active-slice-sequence)]
      (when new-seq
        (core loadStageSequence z (double-vector adjusted-slices)))
      (reset! active-slice-sequence [z adjusted-slices])
