[tauruslib-devel] [PATCH] Generalize the LimaCCDs code to the ImageCounterDevice.

[Sergi Blanch-T. <sb...@ce...>]

I've been reported, when the model is an ImgGrabber or an
ImgBeamAnalyzer the image is not refresh with the events emitted by the
ImageCounter.

I've seen that LimaCCDs works and move it to the superclass to make it
work for all of them. Tested with an ImgGrabber, an ImgBeamAnalyser and
a LimaCCDs.

---
 lib/taurus/core/tango/img/img.py | 69
+++++++++++++++++++++++-----------------
 1 file changed, 40 insertions(+), 29 deletions(-)

diff --git a/lib/taurus/core/tango/img/img.py
b/lib/taurus/core/tango/img/img.py
index a152ce8..1f2b6e8 100644
--- a/lib/taurus/core/tango/img/img.py
+++ b/lib/taurus/core/tango/img/img.py
@@ -35,7 +35,6 @@ __docformat__ = 'restructuredtext'
 from taurus.core.taurusbasetypes import TaurusEventType
 from taurus.core.tango import TangoDevice
 from taurus.core.util.containers import CaselessDict, CaselessList
-from threading import RLock


 class ImageDevice(TangoDevice):
@@ -65,10 +64,13 @@ class ImageCounterDevice(ImageDevice):
     """A class encapsulating a generic image device that has an image
counter
     attribute"""

-    def __init__(self, name, image_name='image', **kw):
+    def __init__(self, name, image_name='image', image_ct='imagecounter',
+                 **kw):
         self._image_data = CaselessDict()
-        self.call__init__(ImageDevice, name, **kw)
-        self._image_id_attr = self.getAttribute(self.getImageIDAttrName())
+        self.call__init__(ImageDevice, name, image_name, **kw)
+        self._image_id_attr_name = image_ct
+        self._busy = False
+        self._image_id_attr = self.getAttribute(self._image_id_attr_name)
         self._image_id_attr.addListener(self)

     def _setDirty(self, names=None):
@@ -82,21 +84,46 @@ class ImageCounterDevice(ImageDevice):
         dirty = []
         for name in names:
             d = self._image_data.get(name)
-            if d is None or d[0] == True:
+            if d is None or d[0]:
                 dirty.append(name)
         return names

     def getImageIDAttrName(self):
-        return 'imagecounter'
+        return self._image_id_attr_name

     def eventReceived(self, evt_src, evt_type, evt_value):
         if evt_src == self._image_id_attr:
             if evt_type == TaurusEventType.Change:
-                self._setDirty()
-                self.fireEvent(evt_type, evt_value)
+                if not self._busy:
+                    self.debug("Processing image %d" % evt_value.value)
+                    # discared events if there is one being processed
+                    self._busy = True
+                    # read the related Image attributes
+                    # (asap and in one action)
+                    images = self.getImageData()
+                    self._setDirty()
+                    self.fireEvent(evt_type, evt_value)
+                    # maintain this fireEvent for backwards compatibility
+                    # with Qub widget
+                    self._emitImageEvents(evt_type, images)
+                    self._busy = False
+                else:
+                    self.debug("Discard image %d" % evt_value.value)
         else:
             ImageDevice.eventReceived(self, evt_src, evt_type, evt_value)

+    def _emitImageEvents(self, evt_type, images):
+        for attr_image_name in images:
+            image_value = images[attr_image_name][1]
+            if hasattr(image_value, 'is_empty') and not
image_value.is_empty:
+                self.debug("fireEvent for %s attribute" % attr_image_name)
+                if not hasattr(image_value, 'rvalue'):
+                    image_value.rvalue = image_value.value
+                # Only emit to upper layers the events where
+                # something has been read.
+                attr_image = self.getAttribute(image_value.name)
+                attr_image.fireEvent(evt_type, image_value)
+
     def getImageData(self, names=None):
         if names is None:
             names = self.getImageAttrNames()
@@ -151,24 +178,8 @@ class ImgBeamAnalyzer(ImageCounterDevice):

 class LimaCCDs(ImageCounterDevice):

-    def __init__(self, name, image_name='video_last_image', **kw):
-        self.call__init__(ImageCounterDevice, name, image_name, **kw)
-        self.rlock = RLock()
-        self.processing = False
-
-    def getImageIDAttrName(self):
-        return 'video_last_image_counter'
-
-    def eventReceived(self, evt_src, evt_type, evt_value):
-        if evt_src == self._image_id_attr and self.processing == False:
-            if evt_type == TaurusEventType.Change:
-                with self.rlock:
-                    self.processing = True
-                    attr_image = self.getAttribute('video_last_image')
-                    evt_value = attr_image.read(False)
-                    attr_image.fireEvent(evt_type, evt_value)
-                    self.processing = False
-
-        else:
-            ImageCounterDevice.eventReceived(
-                self, evt_src, evt_type, evt_value)
+    def __init__(self, name, image_name='video_last_image',
+                 image_ct='video_last_image_counter', **kw):
+        self.call__init__(ImageCounterDevice, name, image_name,
image_ct, **kw)
+        self.debug("Prepared to listen image counter (%s) for the %s
images"
+                   % (self.getImageIDAttrName(), self.getImageAttrNames()))
-- 
2.1.4