221 lines
8.8 KiB
Python
221 lines
8.8 KiB
Python
from startup import *
|
|
from ijutils import *
|
|
from mathutils import *
|
|
import ch.psi.pshell.imaging.Filter as Filter
|
|
from ch.psi.pshell.imaging.Overlays import *
|
|
import ch.psi.pshell.imaging.Pen as Pen
|
|
import java.awt.Color as Color
|
|
import random
|
|
import ch.psi.pshell.imaging.ImageListener as ImageListener
|
|
from operator import add, mul, sub, truediv
|
|
from ch.psi.pshell.imaging.Utils import sub
|
|
|
|
REMOVE_BACKGROUND = True
|
|
PLOT_PROFILE = True
|
|
|
|
"""
|
|
def get_centroid(source):
|
|
bi = source.getImage()
|
|
if bi is None:
|
|
return None
|
|
op = show_panel(bi, "Original")
|
|
ip = load_image(bi)
|
|
plot(get_histogram(ip), title = "Histogram")
|
|
grayscale(ip)
|
|
invert(ip)
|
|
gaussian_blur(ip)
|
|
auto_threshold(ip)
|
|
|
|
#binary_erode(ip)
|
|
show_panel(ip.getBufferedImage(), "Image")
|
|
(results,output_img)=analyse_particles(ip, 2000,20000, exclude_edges=False, print_table=True)
|
|
op.clearOverlays()
|
|
show_panel(output_img.getBufferedImage(), "Outlines")
|
|
if results.size()>0:
|
|
centroid = (results.getValue("XM",0), results.getValue("YM",0))
|
|
ov = Crosshairs(Pen(Color.ORANGE), java.awt.Point(int(centroid[0]),int(centroid[1])), java.awt.Dimension(15,15))
|
|
op.addOverlay(ov)
|
|
return centroid
|
|
"""
|
|
|
|
|
|
class SimulatedSource(Filter):
|
|
def process(self, img, data):
|
|
self.img=img
|
|
if img is None:
|
|
return None
|
|
ip = load_image(img)
|
|
pad_h = int((random.random()-0.5) * 500)
|
|
pad_v = int((random.random()-0.5) * 500)
|
|
#print "Pad = " , (pad_h, pad_v)
|
|
ip = pad_image(ip, -pad_h, pad_h, pad_v, -pad_v, fill_color = Color.BLACK)
|
|
return ip.getBufferedImage()
|
|
#return img
|
|
|
|
def waitNext(self, timeout):
|
|
self.pushImage(self.process(self.img, None))
|
|
|
|
|
|
|
|
class ImageStats(DeviceBase):
|
|
def __init__(self, name, source):
|
|
DeviceBase.__init__(self, name)
|
|
if isinstance(source, basestring):
|
|
self.source = get_context().getClassByName("SfCamera")(source, source)
|
|
self.private_source = True
|
|
self.source.initialize()
|
|
else:
|
|
self.private_source = False
|
|
self.source = source
|
|
self.com_x_samples, self.com_y_samples = [], []
|
|
self.rms_x_samples, self.rms_y_samples = [], []
|
|
self.background = None
|
|
class ComX(Readable):
|
|
def read(self):
|
|
if len(self.image_stats.com_x_samples)==0: return None
|
|
return mean(self.image_stats.com_x_samples)
|
|
self.com_x_mean = ComX(); self.com_x_mean.image_stats = self
|
|
class ComY(Readable):
|
|
def read(self):
|
|
if len(self.image_stats.com_y_samples)==0: return None
|
|
return mean(self.image_stats.com_y_samples)
|
|
self.com_y_mean = ComY(); self.com_y_mean.image_stats = self
|
|
class ComXVar(Readable):
|
|
def read(self):
|
|
if len(self.image_stats.com_x_samples)==0: return None
|
|
return stdev(self.image_stats.com_x_samples)
|
|
self.com_x_stdev = ComXVar(); self.com_x_stdev.image_stats = self
|
|
class ComYVar(Readable):
|
|
def read(self):
|
|
if len(self.image_stats.com_y_samples)==0: return None
|
|
return stdev(self.image_stats.com_y_samples)
|
|
self.com_y_stdev = ComYVar(); self.com_y_stdev.image_stats = self
|
|
set_device_alias(self.com_x_mean, name + " com x mean")
|
|
set_device_alias(self.com_y_mean, name + " com y mean")
|
|
set_device_alias(self.com_x_stdev, name + " com x stdev")
|
|
set_device_alias(self.com_y_stdev, name + " com y stdev")
|
|
#self.bg_en = False
|
|
self.num_images = 5
|
|
|
|
class BackgroundSubtractor(Filter):
|
|
def __init__(self, obj):
|
|
self.obj=obj
|
|
def process(self, image, data):
|
|
if self.obj.background is None:
|
|
raise Exception("No background captured")
|
|
return sub(image, self.obj.background, True)
|
|
self.backgroundFilter = BackgroundSubtractor(self)
|
|
|
|
self.initialize()
|
|
self.start()
|
|
|
|
#class SourceListener (ImageListener):
|
|
# def __init__(self, dev):
|
|
# self.dev=dev
|
|
# def onImage(self, origin, image, data):
|
|
# self.dev.doUpdate()
|
|
# def onError(self, origin, ex):
|
|
# self.dev.com_x_samples, self.dev.com_y_samples = [], []
|
|
# self.rms_x_samples, self.rms_y_samples = [], []
|
|
#self.listener = SourceListener(self)
|
|
#self.source.addListener(self.listener)
|
|
|
|
|
|
def doUpdate(self):
|
|
#print "Do update"
|
|
self.com_x_samples, self.com_y_samples = [], []
|
|
self.rms_x_samples, self.rms_y_samples = [], []
|
|
for i in range(self.num_images):
|
|
if type(self.source) is not ch.psi.pshell.imaging.FileSource:
|
|
self.source.waitNext(5000)
|
|
|
|
x_profile = self.source.data.integrateVertically(True)
|
|
x_profile_x = self.source.data.getRowSelectionX(True)
|
|
|
|
y_profile = self.source.data.integrateHorizontally(True)
|
|
y_profile_x = self.source.data.getColSelectionX(True)
|
|
|
|
#Remove background
|
|
if (self.source.backgroundEnabled == False) and REMOVE_BACKGROUND:
|
|
(a, b, amp, com, sigma) = fit_gaussian_linear(x_profile, x_profile_x)
|
|
x_profile = [x_profile[i]-(a*x_profile_x[i]+b) for i in range(len(x_profile))]
|
|
(a, b, amp, com, sigma) = fit_gaussian_linear(y_profile, y_profile_x)
|
|
y_profile = [y_profile[i]-(a*y_profile_x[i]+b) for i in range(len(y_profile))]
|
|
com_x,rms_x = center_of_mass(x_profile, x_profile_x)
|
|
com_y,rms_y = center_of_mass(y_profile, y_profile_x)
|
|
self.com_x_samples.append(com_x)
|
|
self.com_y_samples.append(com_y)
|
|
self.rms_x_samples.append(rms_x)
|
|
self.rms_y_samples.append(rms_y)
|
|
if PLOT_PROFILE:
|
|
p = get_plots("Profile")
|
|
if (p is None) or (len(p)==0):
|
|
p = plot([x_profile, y_profile], ["x_profile", "yprofile"], [x_profile_x,y_profile_x], title ="Profile")
|
|
if p is not None:
|
|
p[0].removeMarker(None)
|
|
p[1].removeMarker(None)
|
|
p[0].getSeries(0).setData(x_profile_x, x_profile)
|
|
p[1].getSeries(0).setData(y_profile_x, y_profile)
|
|
p[0].addMarker(com_x, None, "COM = " + str(com_x), Color.GREEN)
|
|
p[1].addMarker(com_y, None, "COM = " + str(com_y), Color.GREEN)
|
|
|
|
def setNumberOfImages(self, value):
|
|
self.num_images = value
|
|
|
|
def enableBackground(self, value):
|
|
self.source.backgroundEnabled = value
|
|
|
|
def grabBackground(self, images):
|
|
self.source.captureBackground(images,0)
|
|
|
|
def doClose(self):
|
|
if self.private_source:
|
|
self.source.close()
|
|
else:
|
|
self.source.backgroundEnabled = False
|
|
|
|
def start(self):
|
|
if self.private_source:
|
|
self.source.polling = 200
|
|
self.source.waitNext(2000)
|
|
|
|
def stop(self):
|
|
if self.private_source:
|
|
self.source.polling = 0
|
|
|
|
|
|
def get_simulated_source(img):
|
|
simulated_source = SimulatedSource()
|
|
simulated_source.img=None
|
|
simulated_source.initialize()
|
|
img.addListener(simulated_source)
|
|
show_panel(simulated_source)
|
|
return simulated_source
|
|
|
|
"""
|
|
if __name__ == "__builtin__":
|
|
#simulated_source = get_simulated_source(image)
|
|
#print get_centroid(simulated_source)
|
|
add_device(ImageStats("image_stats", "SLG-LCAM-C041"), True)
|
|
add_device(image_stats.source, True)
|
|
#cam3.waitNext(2000)
|
|
|
|
#for i in range (10):
|
|
# image_stats.update()
|
|
# print image_stats.take(), image_stats.com_x_mean.read(), image_stats.com_y_mean.read()
|
|
# time.sleep(1)
|
|
|
|
image_stats.setNumberOfImages(3)
|
|
sensors = [image_stats.com_x_mean, image_stats.com_y_mean, image_stats.com_x_stdev, image_stats.com_y_stdev]
|
|
|
|
image_stats.grabBackground(1)
|
|
|
|
def before_sample():
|
|
image_stats.update()
|
|
image_stats.enableBackground(False)
|
|
try:
|
|
tscan(sensors, 10, 0.1, before_read = before_sample)
|
|
finally:
|
|
image_stats.enableBackground(False)
|
|
image_stats.stop()
|
|
""" |