script/tools/CameraTools.py

@@ -0,0 +1,128 @@
+import json
+import java.math.BigInteger as BigInteger
+import org.python.core.PyLong as PyLong
+import org.python.core.PyFloat as PyFloat
+import traceback
+import datetime
+
+run("Devices/Elements")
+
+def get_processing_parameters(stream_value):
+    return json.loads(stream_value.getValue("processing_parameters"))  
+
+def _create_tables(paths, stream_value, data_type, shape, images):
+    root = paths["root"]
+    create_dataset(paths["image"], data_type, dimensions = [images, shape[0], shape[1]])
+    create_dataset(paths["pid"], 'l', dimensions = [images])
+    create_dataset(paths["timestamp_str"], 's', dimensions = [images])
+    for id in stream_value.identifiers:
+        val = stream_value.getValue(id)
+        if id == "image":
+            pass
+        elif id == "processing_parameters":                                                                     
+            val = json.loads(val)                
+            for key in val.keys():
+                if val[key] is not None and isinstance(val[key], dict):    
+                    for k in val[key].keys():
+                        set_attribute(paths["image"], key + " " + k , "" if val[key][k] is None else val[key][k] )               
+                else:  
+                    set_attribute(paths["image"], key, "" if val[key] is None else val[key] )               
+        elif isinstance(val, PyArray):
+            create_dataset(root + id, 'd', dimensions = [images, len(val)])                                
+        elif isinstance(val, PyLong):
+            create_dataset(root + id, 'l', dimensions = [images])                
+        elif isinstance(val, PyFloat):
+            create_dataset(root + id, 'd', dimensions = [images])                
+        else:   
+            print "Unmanaged stream type: ", val, type(val)
+            pass
+    
+
+def _append_frame(paths, stream_value, index, data_type, shape):
+    print "Saving frame :", index
+    #append_dataset(paths["image"], data, index, type = data_type)    
+    root = paths["root"]
+    append_dataset(paths["image"], stream_value.getValue("image"),[index,0,0], type = data_type,  shape=[1, shape[0], shape[1]])      
+    append_dataset(paths["pid"], stream_value.getPulseId(), index)
+    append_dataset(paths["timestamp_str"], datetime.datetime.fromtimestamp(stream_value.timestampNanos/1e9).strftime('%Y-%m-%d %H:%M:%S.%f'), index)   
+
+    for id in stream_value.identifiers:
+        try:
+            val = stream_value.getValue(id)
+            if id == "image":
+                pass
+            elif isinstance(val, PyArray):
+                append_dataset(root + id, val, index)
+            elif isinstance(val, PyLong):
+                append_dataset(root + id, int(val), index)
+            elif isinstance(val, PyFloat):
+                append_dataset(root + id, float(val), index)
+            else:      
+                pass
+        except:
+            print id, val
+            traceback.print_exc()
+       
+    #print "Saved frame: ", index
+
+
+def _write_metadata(paths, camera, images, interval):
+    root = paths["root"]    
+    set_attribute(root, "Camera", camera)
+    set_attribute(root, "Images", images)
+    set_attribute(root, "Interval", interval)
+    cam_type = get_camera_type(camera)
+    set_attribute(root, "Type", cam_type)
+    if cam_type=="ELECTRONS":
+        set_attribute(root, "Screen", caget(camera + (":POSITION" if (camera.startswith("DSRM")) else ":GET_SCREEN1_POS"), 's'))
+        set_attribute(root, "Filter", caget(camera + ":GET_FILTER", 's'))
+
+    
+def save_camera_data(server, images = 1, interval = -1, root = "/camera1", parallel = True, pause = False):
+    stream_value = server.stream.take()
+    if stream_value is None:
+        server.waitNext(10000)
+        stream_value = server.stream.take()
+    if not root.endswith('/'):
+        root = root + "/"
+    camera = get_processing_parameters(stream_value)["camera_name"]
+    paths = {"root": root, "image":root+"image", "pid":root+"/pulse_id", "timestamp_str":root+"/timestamp_str"}    
+    shape = [stream_value.getValue("height"),stream_value.getValue("width")]
+    data_type = stream_value.getValue("image").typecode    
+    tasks = []  
+    if pause:
+        server.paused = True
+    try:    
+        for i in range(images):    
+            #print i
+            if i==0:                                
+                _create_tables(paths, stream_value, data_type, shape, images)                
+                _write_metadata(paths, camera, images, interval)            
+            start = time.time()
+            stream_value = server.stream.take()
+            if parallel:                                
+                tasks.extend( fork((_append_frame,(paths, stream_value, i, data_type, shape)),) )
+            else:
+                print "append"
+                _append_frame(paths, stream_value, i, data_type, shape)
+            print "OK"
+            if i< (images-1):
+                if interval<=0:
+                    print "WAITING"
+                    server.stream.waitCacheChange(10000)                            
+                else:
+                    print "Other"
+                    sleep_time = float(interval)/1000.0 - (time.time()-start)
+                    time.sleep(max(sleep_time,0))    
+    finally:      
+        if pause:
+            server.paused = False
+        pass
+    data_file = get_exec_pars().path
+    #print "Waiting finish : ", data_file
+    join(tasks)
+    #print "Done"
+    return data_file
+
+def save_camera_snapshot(server, file, format = "png"):
+    ImageBuffer.saveImage(server.output, file, "png")

script/tools/save_camera_data.py

@@ -0,0 +1,91 @@
+import ch.psi.pshell.imaging.ImageBuffer as ImageBuffer
+import json
+import ch.psi.pshell.bs.PipelineServer as PipelineServer
+import ch.psi.pshell.imaging.Colormap as Colormap
+
+
+if get_exec_pars().source == CommandSource.ui:
+    #camera_name = "SARBD02-DSCR050" # "SLG-LCAM-C041_sp"
+    #camera_name = "SARBD02-DSCR050_sp" # "SLG-LCAM-C041_sp"
+    camera_name = "simulation_sp" # "SLG-LCAM-C041_sp"    
+    shared = False
+    images = 1
+    interval = -1
+    roi = ""
+    #roi = "[300, 200]"
+    #roi = "[540, 200, 430,100]"
+    snapshot = False
+else:    
+    camera_name = args[0]
+    shared = args[1].lower() == "true"
+    images = int(args[2]) if len(args)>2 else 1
+    interval = int(args[3]) if len(args)>3 else -1
+    roi = args[4] if len(args)>4 else ""
+    snapshot = args[5].lower() == "true" if len(args)>5 else False
+
+
+background = get_exec_pars().background 
+
+
+run("Tools/CameraTools")        
+set_exec_pars(name="camera_data")
+
+if background:    
+    _server = PipelineServer("pipeline_server", cam_server.url)
+    _server.config.colormap = Colormap.Flame
+    _server.config.colormapAutomatic = True    
+    _server.initialize()
+else:
+    _server = cam_server
+
+try:
+    _server.start(camera_name + "_sp1" if shared else camera_name, shared)
+      
+    if roi is not None and len(roi.strip())>0:
+        roi = json.loads(roi)   
+        if len(roi) == 2:
+        
+            if _server.stream.take() == None:
+                _server.waitNext(10000)           
+            while True:
+                if json.loads(_server.stream.take()["processing_parameters"])["image_region_of_interest"] == None: 
+                    break
+                _server.resetRoi()
+                _server.waitNext(10000)                                  
+            iw, ih, cx, cy = _server.getValue("width"), _server.getValue("height"), _server.getValue("x_fit_mean"), _server.getValue("y_fit_mean")
+            xa, ya = _server.getValue("x_axis"), _server.getValue("y_axis") 
+            cx  = (cx - xa[0]) / (xa[-1]-xa[0]) * iw
+            cy  = (cy - ya[0]) / (ya[-1]-ya[0]) * ih
+            w, h = roi[0], roi[1]
+            x, y = int(max(cx- (w/2), 0)), int(max(cy-(h/2), 0))
+            w, h = min(w, iw-x), min(h, ih-y)        
+            roi = [x, w, y, h]
+            if (w<0) or (h<0):
+                raise Exception("Invalid ROI: " + str(roi))
+            _server.setRoi(roi[0], roi[2], roi[1], roi[3])    
+        elif len(roi) == 4: 
+            _server.setRoi(roi[0], roi[2], roi[1], roi[3])    
+        else:
+            raise Exception("Invalid ROI: " + str(roi))
+        while True:        
+            _server.waitNext(10000)
+            r = json.loads(_server.stream.take()["processing_parameters"])
+            if  roi == r["image_region_of_interest"]:
+                break;
+    else:
+        _server.waitNext(10000)
+
+    
+    data_file = save_camera_data(_server, images, interval, parallel = True, pause=True)    
+    set_exec_pars(open = False)
+    
+    if snapshot:
+        format ="png"
+        save_camera_snapshot(_server, data_file + "." + format, format)
+finally:    
+    if background:
+        _server.close()
+    else:
+        _server.stop()
+
+set_return(data_file)