Closedown

script/LedDetection.py

@@ -1,115 +0,0 @@
-################################################################################################### 
-# Example of using ImageJ functionalities through ijutils.
-################################################################################################### 
-
-import datetime
-from ijutils import *
-import java.awt.Color as Color
-
-import ch.psi.pshell.imaging.Filter as Filter
-from ch.psi.pshell.imaging.Overlays import *
-import ch.psi.pshell.imaging.Pen as Pen
-
-
-roi_center = (800, 600)
-roi_radius = 600
-integration_count = 10
-integration_continuous = False
-integration_partial = False
-frames = []            
-
-roi = (roi_center[0] - roi_radius, roi_center[1] - roi_radius, 2* roi_radius, 2*roi_radius)
-
-
-color_roi = Color(0, 128, 0)
-
-renderer = show_panel(img)
-renderer.clearOverlays()
-ov_roi_shape = Ellipse(Pen(color_roi, 0,), java.awt.Point(roi[0], roi[1]), java.awt.Dimension(roi[2], roi[3]))       
-ov_roi_bound = Rect(Pen(color_roi, 0, Pen.LineStyle.dotted), java.awt.Point(roi[0], roi[1]), java.awt.Dimension(roi[2], roi[3]))       
-ov_roi_center = Crosshairs(Pen(color_roi, 0),  java.awt.Point(roi_center[0],roi_center[1]), java.awt.Dimension(15,15))
-
-renderer.addOverlays([ov_roi_shape, ov_roi_bound,ov_roi_center])
-
-
-def in_roi(x,y):
-    return math.hypot(x-roi_radius, y-roi_radius) < roi_radius
-
-
-def integrate (ips):    
-    for i in range(len(ips)):
-        if i==0:
-            aux = new_image(roi[2], roi[3], image_type="float", title = "sum", fill_color = None)
-        op_image(aux, ips[i], "add", float_result=True, in_place=True)
-    op_const(aux, "divide", len(ips), in_place=True)
-    return aux
-
-
-last_ret = (None, None)
-def detect_led(ip):
-    global roi_center, roi_radius, integration_count, integration_continuous, integration_partial, frames
-    global count , last_ret 
-    aux = sub_image(ip, roi[0], roi[1], roi[2], roi[3])
-    grayscale(aux)
-    #gaussian_blur(aux)
-    if (integration_count>1):             
-        frames.append(aux)        
-        if len(frames) >integration_count:
-            del frames[0]        
-        if not integration_continuous:            
-            if (len(frames)< integration_count):                
-                if last_ret[1] is not None: invert(last_ret[1])                
-                return last_ret                   
-        if (not integration_partial) and len(frames) <integration_count:            
-            return last_ret
-        aux = integrate(frames)
-    
-    #aux = get_channel(aux, "blue")
-    invert(aux)
-    #subtract_background(aux) 
-    #Tested ok: Huang, Mean, MaxEntropy, Percentile, Triangle, Yen
-    auto_threshold(aux, method = "Percentile")
-    #binary_open(aux)
-    (results,output) =  analyse_particles(aux, 250,1000, 
-            fill_holes = True, exclude_edges = False, print_table=False,
-            output_image = "outlines", minCirc = 0.3
-            , maxCirc = 1.0)
-    r=results
-
-
-    points = ""
-    npoints = 0
-    for row in range (r.counter):
-        if in_roi(r.getValue("XM",row), r.getValue("YM",row)):
-            points = points + " (" + str(int(r.getValue("XM", row))+roi[0]) + ", "  + str(int(r.getValue("YM", row))+roi[1]) + ")"
-            npoints = npoints + 1
-    print str(npoints) + " - " + points
-        
-    last_ret = (results,output)
-    if not integration_continuous:
-        frames = []  
-
-    #if npoints!=12:        
-    #    save_image(op_image(aux, output,"xor", in_place=False),  "{images}/" + str(datetime.datetime.now().strftime("%Y%m%d_%H%M%S"))+".png", "png")        
-    #return (results,aux)    
-    return (results,output)
-
-
-
-
-ip = None
-
-class MyFilter(Filter):
-    def process(self, image, data):
-        global roi_center, roi_radius, ip   
-        ip = load_image(image)                            
-        (results,output) = detect_led(ip)
-        if output is not None:
-            invert(output)
-            output = pad_image(output, roi[0], 0,roi[1], 0)        
-            op_image(ip, output, "xor")        
-        return ip.getBufferedImage()
-
-#Setting the filter to a source
-img.setFilter(MyFilter())
-

script/LedDetectionFilter.py

@@ -11,15 +11,11 @@ from ch.psi.pshell.imaging.Overlays import *
 import ch.psi.pshell.imaging.Pen as Pen
 
 
-roi_center = (800, 600)
-roi_radius = 600
 integration_count = 10
 integration_continuous = False
 integration_partial = False
 frames = []            
 
-roi = (roi_center[0] - roi_radius, roi_center[1] - roi_radius, 2* roi_radius, 2*roi_radius)
-
 
 color_roi = Color(0, 128, 0)
 
@@ -32,21 +28,11 @@ ov_roi_center = Crosshairs(Pen(color_roi, 0),  java.awt.Point(roi_center[0],roi_
 renderer.addOverlays([ov_roi_shape, ov_roi_bound,ov_roi_center])
 
 
-def in_roi(x,y):
-    return math.hypot(x-roi_radius, y-roi_radius) < roi_radius
-
-
-def integrate (ips):    
-    for i in range(len(ips)):
-        if i==0:
-            aux = new_image(roi[2], roi[3], image_type="float", title = "sum", fill_color = None)
-        op_image(aux, ips[i], "add", float_result=True, in_place=True)
-    op_const(aux, "divide", len(ips), in_place=True)
-    return aux
 
 
 last_ret = (None, None)
 def detect_led(ip):
+    roi = get_roi
     global roi_center, roi_radius, integration_count, integration_continuous, integration_partial, frames
     global count , last_ret 
     aux = sub_image(ip, roi[0], roi[1], roi[2], roi[3])

script/LedDetectionProc.py

@@ -1,46 +1,6 @@
-from ijutils import *
-from ch.psi.pshell.imaging.Overlays import *
-import ch.psi.pshell.imaging.Pen as Pen
 
-roi_center = (800, 600)
-roi_radius = 600
-roi = (roi_center[0] - roi_radius, roi_center[1] - roi_radius, 2* roi_radius, 2*roi_radius)
 #roi = (0,0,1600,1200)
 
-
-def in_roi(x,y):
-    return math.hypot(x-roi_radius, y-roi_radius) < roi_radius
-
-
-def integrate(ips):    
-    aux = None
-    for i in range(len(ips)):
-        if i==0:
-            aux = new_image(roi[2], roi[3], image_type="float", title = "sum", fill_color = None)
-        op_image(aux, ips[i], "add", float_result=True, in_place=True)    
-    return aux
-
-def average (ips):   
-    aux = integrate(ips)     
-    op_const(aux, "divide", len(ips), in_place=True)    
-    return aux
-
-def grab_frames(samples):
-    frames = []            
-    for i in range(samples):
-        ip = load_image(img.image)                            
-        aux = sub_image(ip, roi[0], roi[1], roi[2], roi[3])
-        grayscale(aux)
-        frames.append(aux)        
-    return frames
-    
-def average_frames(samples = 1):
-    return average(grab_frames(samples))
-
-def integrate_frames(samples = 1):
-    return integrate(grab_frames(samples))
-
-
 img.backgroundEnabled=False
 led_ctrl1.write(0.0)
 led_ctrl2.write(0.0)
@@ -48,10 +8,10 @@ time.sleep(0.1)
 img.waitNext(100)
 
 background = average_frames(5)
-#img.setBackground(background.getBufferedImage())
+
+#img.backgroundImage=background.bufferedImage
 #img.captureBackground(1,0)
 #show_panel(img.backgroundImage)
-
 #img.backgroundEnabled = True
 
 led_ctrl1.write(0.40)
@@ -60,6 +20,9 @@ time.sleep(0.1)
 img.waitNext(100)
 image = average_frames(5)
 
+led_ctrl1.write(0.0)
+led_ctrl2.write(0.0)
+
 op_image(image, background, "subtract", float_result=True, in_place=True)
 
 

script/local.py

@@ -42,6 +42,7 @@ def in_roi(x,y):
 
 
 def integrate(ips):    
+    roi =  get_roi()
     aux = None
     for i in range(len(ips)):
         if i==0:
@@ -77,9 +78,14 @@ def get_roi():
 
 
 def get_image():
+    roi =  get_roi()
     ip = load_image(img.image)                            
     return sub_image(ip, roi[0], roi[1], roi[2], roi[3])
 
+def get_image(bi):
+    roi =  get_roi()
+    ip = load_image(bi)                            
+    return sub_image(ip, roi[0], roi[1], roi[2], roi[3])
 
 
 def detect_pucks(ip):