130 lines
4.8 KiB
Python
130 lines
4.8 KiB
Python
run("imgproc/NewCoverDetection")
|
|
|
|
|
|
class CoverDetectionConfig(RegisterConfig):
|
|
def __init__(self):
|
|
self.number_images = 1
|
|
self.continuous = False
|
|
self.modulo = 1
|
|
self.center_x = 820.0
|
|
self.center_y = 570.0
|
|
self.scale_x = 1.0
|
|
self.scale_y = 1.0
|
|
|
|
class CoverDetection(ReadonlyAsyncRegisterBase, ReadonlyRegisterArray):
|
|
|
|
def __init__(self, name, image):
|
|
ReadonlyAsyncRegisterBase.__init__(self, name, CoverDetectionConfig())
|
|
self.image = image
|
|
|
|
class ImgListener (ImageListener):
|
|
def onImage(s, origin, image, data):
|
|
self.append(image)
|
|
def onError(s, origin, ex):
|
|
print ex
|
|
|
|
self.listener = ImgListener()
|
|
self.enabled = False
|
|
self.images = []
|
|
self.processing_time = None
|
|
self.renderer = None
|
|
self.error = None
|
|
self.error_overlay=None
|
|
self.img_counter, self.proc_counter = 0, 0
|
|
self.offset_px = self.offset_um = None
|
|
|
|
def doInitialize(self):
|
|
self.enable()
|
|
self.clear()
|
|
|
|
def doClose(self):
|
|
self.disable()
|
|
|
|
def set_renderer(self, renderer):
|
|
self.clear()
|
|
self.renderer = renderer
|
|
|
|
def enable(self):
|
|
if not self.enabled:
|
|
self.enabled = True
|
|
self.image.addListener(self.listener)
|
|
self.img_counter, self.proc_counter = 0, 0
|
|
self.offset_px = self.offset_um = None
|
|
|
|
def disable(self):
|
|
if self.enabled:
|
|
self.image.removeListener(self.listener)
|
|
self.enabled = False
|
|
self.onReadout(None)
|
|
self.clear()
|
|
|
|
def clear(self):
|
|
self.set_marker(None)
|
|
self.set_error_overlay(None)
|
|
|
|
def append(self, image):
|
|
self.img_counter += 1
|
|
if self.img_counter % self.config.modulo == 0:
|
|
ip = load_image(ImagingUtils.grayscale(image, None))
|
|
self.images.append(ip)
|
|
while len(self.images) > self.config.number_images:
|
|
self.images.pop(0)
|
|
if len(self.images) == self.config.number_images:
|
|
start = time.time()
|
|
if len(self.images) ==1:
|
|
ip = self.images[0]
|
|
else:
|
|
ip = integrate(self.images)
|
|
try:
|
|
self.error = None
|
|
x,y = detect(ip)
|
|
except Exception as e:
|
|
self.error = e
|
|
x,y = -1, -1
|
|
self.processing_time = time.time()-start
|
|
self.proc_counter += 1
|
|
self.set(x, y, self.processing_time * 1000, self.error)
|
|
if not self.config.continuous:
|
|
self.images=[]
|
|
|
|
def set(self, x, y, tm, error):
|
|
if self.enabled:
|
|
if error:
|
|
self.offset_px = self.offset_um = None
|
|
value = None
|
|
else:
|
|
offx, offy = x-cover_detection.config.center_x, -(y-cover_detection.config.center_y)
|
|
self.offset_px = opx, opy = round(offx), round(offy)
|
|
self.offset_um = omx, omy = self.config.scale_x * offx * 1000.0, self.config.scale_y * offy *1000.0
|
|
value = to_array([x, y, opx, opy, omx, omy, tm], 'i')
|
|
self.onReadout(value)
|
|
if self.renderer is not None:
|
|
if error is None:
|
|
marker = Overlays.Crosshairs(renderer.getPenProfile(), Point(int(x),int(y)), Dimension(-1, -1))
|
|
else:
|
|
marker = None
|
|
self.set_marker(marker);
|
|
self.set_error_overlay(error)
|
|
|
|
def set_marker(self, marker):
|
|
if self.renderer is not None:
|
|
self.renderer.setMarker(marker)
|
|
|
|
def set_error_overlay(self, error):
|
|
if self.renderer is not None:
|
|
if error is None:
|
|
error_overlay = None
|
|
else:
|
|
error_overlay = Overlays.Text(renderer.getPenErrorText(), str(error), Font("Verdana", Font.PLAIN, 12), Point(20, 20))
|
|
error_overlay.setFixed(True)
|
|
error_overlay.setAnchor(Overlay.ANCHOR_VIEWPORT_TOP_LEFT)
|
|
renderer.updateOverlays(error_overlay, self.error_overlay)
|
|
self.error_overlay = error_overlay
|
|
else:
|
|
self.error_overlay = None
|
|
|
|
|
|
add_device(CoverDetection("cover_detection", image), force = True)
|
|
renderer=show_panel(image)
|
|
cover_detection.set_renderer(renderer)
|