1
2
3
4
5
6
7
8
9
10
11
12
13 import os,sys
14 THISPATH = os.path.dirname(os.path.abspath(__file__))
15
16 from types import IntType, LongType, UnicodeType, ListType, TupleType, StringType, StringTypes
17 from datetime import datetime
18 from cStringIO import StringIO
19 import ConfigParser
20
21 import omero
22 import omero.clients
23 import Ice
24 import Glacier2
25
26 import traceback
27 import time
28 import array
29
30 import logging
31 logger = logging.getLogger('blitz_gateway')
32
33 try:
34 from PIL import Image, ImageDraw, ImageFont
35 except ImportError:
36 try:
37 import Image, ImageDraw, ImageFont
38 except:
39 logger.error('No PIL installed, line plots and split channel will fail!')
40
41 from cStringIO import StringIO
42 from math import sqrt
43
44 import omero_Constants_ice
45 import omero_ROMIO_ice
46 from omero.rtypes import rstring, rint, rlong, rbool, rtime
49 """
50 Converts rtypes from static factory methods:
51 - StringType to rstring
52 - UnicodeType to rstring
53 - IntType to rint
54 - LongType to rlong
55 elswere return the argument itself
56
57 @param val: value
58 @return: matched RType or value
59 """
60
61 if isinstance(val, StringType):
62 return rstring(val)
63 elif isinstance(val, UnicodeType):
64 return rstring(val.encode('utf-8'))
65 elif isinstance(val, IntType):
66 return rint(val)
67 elif isinstance(val, LongType):
68 return rlong(val)
69 else:
70 return val
71
73 """
74 Decorator to measure the execution time of a function.
75
76 @param level: the level to use for logging
77 """
80
82 def wrapped (*args, **kwargs):
83 logger.log(self._level, "timing %s" % (func.func_name))
84 now = time.time()
85 rv = func(*args, **kwargs)
86 logger.log(self._level, "timed %s: %f" % (func.func_name, time.time()-now))
87 return rv
88 return wrapped
89
91 """
92 Measures the execution time of a function using time.time()
93 and the a @ function decorator.
94
95 Logs at logging.DEBUG level.
96 """
97 def wrapped (*args, **kwargs):
98 logger.log(self._level, "timing %s" % (func.func_name))
99 now = time.time()
100 rv = func(*args, **kwargs)
101 logger.log(self._level, "timed %s: %f" % (func.func_name, time.time()-now))
102 return rv
103 return TimeIt()(func)
104
109 """
110 Object wrapper class.
111 """
112
113 OMERO_CLASS = None
114 LINK_CLASS = None
115 CHILD_WRAPPER_CLASS = None
116 PARENT_WRAPPER_CLASS = None
117
118 - def __init__ (self, conn=None, obj=None, cache={}, **kwargs):
119 self.__bstrap__()
120 self._obj = obj
121 self._cache = cache
122 self._conn = conn
123 if conn is None:
124 return
125 if hasattr(obj, 'id') and obj.id is not None:
126 self._oid = obj.id.val
127 if not self._obj.loaded:
128 try:
129 self._obj = self._conn.getQueryService().get(self._obj.__class__.__name__, self._oid)
130 except:
131 print traceback.format_exc()
132 self.__prepare__ (**kwargs)
133
136
139
142
147
158
169
172
173
175 p = self.listParents()
176 link = self._conn.getQueryService().findAllByQuery("select l from %s as l where l.parent.id=%i and l.child.id=%i" % (p.LINK_CLASS, p.id, self.id), None)
177 if len(link):
178 return link[0]
179 return None
180
182 """ moves this object from the current parent container to a new one """
183 p = self.listParents()
184 if type(p) == type(newParent):
185 link = self._conn.getQueryService().findAllByQuery("select l from %s as l where l.parent.id=%i and l.child.id=%i" % (p.LINK_CLASS, p.id, self.id), None)
186 if len(link):
187 link[0].parent = newParent._obj
188 self._conn.getUpdateService().saveObject(link[0])
189 return True
190 return False
191
198
203
205 try:
206 if self._obj.acquisitionDate.val is not None and self._obj.acquisitionDate.val > 0:
207 t = self._obj.acquisitionDate.val
208 else:
209 t = self._obj.details.creationEvent.time.val
210 except:
211 t = self._conn.getQueryService().get("Event", self._obj.details.creationEvent.id.val).time.val
212 return datetime.fromtimestamp(t/1000)
213
216
218 """ Save this object, keeping the object owner the same as the one on provided details """
219 if self._conn.isAdmin():
220 d = self.getDetails()
221 if d.getOwner() and \
222 d.getOwner().omeName == details.getOwner().omeName and \
223 d.getGroup().name == details.getGroup().name:
224 return self.save()
225 else:
226 newConn = self._conn.suConn(details.getOwner().omeName, details.getGroup().name)
227
228
229
230
231
232
233
234 clone = self.__class__(newConn, self._obj)
235 clone.save()
236 self._obj = clone._obj
237 return
238 else:
239 return self.save()
240
242 return self._conn.canWrite(self._obj)
243
245 return self._obj.details.permissions.isUserWrite()
246
248 return (self._obj.details.owner.id.val == self._conn.getEventContext().userId)
249
251 if self._obj.details.group.id.val in self._conn.getEventContext().leaderOfGroups:
252 return True
253 return False
254
261
263 return self._obj.details.permissions.isWorldRead()
264
266 if not self.isPublic():
267 return self._obj.details.permissions.isGroupRead()
268 return False
269
271 if not self.isPublic() and not self.isShared():
272 return self._obj.details.permissions.isUserRead()
273 return False
274
276 if self.isPublic() and not self._obj.details.permissions.isWorldWrite():
277 return True
278 elif self.isShared() and not self._obj.details.permissions.isGroupWrite():
279 return True
280 elif self.isPrivate() and not self._obj.details.permissions.isUserWrite():
281 return True
282 return False
283
284
285
286
287
288
289
290
291
292
293
294
295
297 """
298 Counts available number of child objects.
299
300 @return: Long. The number of child objects available
301 """
302
303 childw = self._getChildWrapper()
304 klass = "%sLinks" % childw().OMERO_CLASS.lower()
305
306 self._cached_countChildren = self._conn.getContainerService().getCollectionCount(self.OMERO_CLASS, klass, [self._oid], None)[self._oid]
307 return self._cached_countChildren
308
310 """
311 countChildren, but caching the first result, useful if you need to call this multiple times in
312 a single sequence, but have no way of storing the value between them.
313 It is actually a hack to support django template's lack of break in for loops
314
315 @return: Long
316 """
317
318 if not hasattr(self, '_cached_countChildren'):
319 return self.countChildren()
320 return self._cached_countChildren
321
323 """
324 Lists available child objects.
325
326 @return: Generator yielding child objects.
327 """
328
329 childw = self._getChildWrapper()
330 klass = childw().OMERO_CLASS
331
332
333
334
335
336 if not params:
337 params = omero.sys.Parameters()
338 if not params.map:
339 params.map = {}
340 params.map["dsid"] = omero_type(self._oid)
341 query = "select c from %s as c" % self.LINK_CLASS
342 if ns is not None:
343 params.map["ns"] = omero_type(ns)
344
345
346 query += """ join fetch c.child as ch
347 left outer join fetch ch.annotationLinks as ial
348 left outer join fetch ial.child as a """
349 query += " where c.parent.id=:dsid"
350 if ns is not None:
351 query += " and a.ns=:ns"
352 if val is not None:
353 if isinstance(val, StringTypes):
354 params.map["val"] = omero_type(val)
355 query +=" and a.textValue=:val"
356 query += " order by c.child.name"
357 childnodes = [ x.child for x in self._conn.getQueryService().findAllByQuery(query, params)]
358 for child in childnodes:
359 yield childw(self._conn, child, self._cache)
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
379 """
380 Lists available parent objects.
381
382 @return: Generator yielding parent objects
383 """
384
385 if self.PARENT_WRAPPER_CLASS is None:
386 if single:
387 return withlinks and (None, None) or None
388 return ()
389 parentw = self._getParentWrapper()
390 param = omero.sys.Parameters()
391 if withlinks:
392 parentnodes = [ (parentw(self._conn, x.parent, self._cache), BlitzObjectWrapper(self._conn, x)) for x in self._conn.getQueryService().findAllByQuery("from %s as c where c.child.id=%i" % (parentw().LINK_CLASS, self._oid), param)]
393 else:
394 parentnodes = [ parentw(self._conn, x.parent, self._cache) for x in self._conn.getQueryService().findAllByQuery("from %s as c where c.child.id=%i" % (parentw().LINK_CLASS, self._oid), param)]
395 if single:
396 return len(parentnodes) and parentnodes[0] or None
397 return parentnodes
398
399
407
408
410 if not hasattr(self._obj, 'isAnnotationLinksLoaded'):
411 raise NotImplementedError
412 if not self._obj.isAnnotationLinksLoaded():
413 links = self._conn.getQueryService().findAllByQuery("select l from %sAnnotationLink as l join fetch l.child as a where l.parent.id=%i" % (self.OMERO_CLASS, self._oid), None)
414 self._obj._annotationLinksLoaded = True
415 self._obj._annotationLinksSeq = links
416
417
419 self._loadAnnotationLinks()
420 rv = self.copyAnnotationLinks()
421 if ns is not None:
422 rv = filter(lambda x: x.getChild().getNs() and x.getChild().getNs().val == ns, rv)
423 return rv
424
425
433
435 """
436 ets the first annotation in the ns namespace, linked to this object
437
438 @return: #AnnotationWrapper or None
439 """
440 rv = self._getAnnotationLinks(ns)
441 if len(rv):
442 return AnnotationWrapper._wrap(self._conn, rv[0].child)
443 return None
444
446 """
447 List annotations in the ns namespace, linked to this object
448
449 @return: Generator yielding AnnotationWrapper
450 """
451
452 for ann in self._getAnnotationLinks(ns):
453 yield AnnotationWrapper._wrap(self._conn, ann.child, link=ann)
454
455
457 if not ann.getId():
458
459 ann.details.setPermissions(omero.model.PermissionsI())
460 ann.details.permissions.setWorldRead(True)
461 ann.details.permissions.setGroupWrite(True)
462 ann = ann.__class__(self._conn, self._conn.getUpdateService().saveAndReturnObject(ann._obj))
463
464
465 lnktype = "%sAnnotationLinkI" % self.OMERO_CLASS
466 lnk = getattr(omero.model, lnktype)()
467 lnk.details.setPermissions(omero.model.PermissionsI())
468 lnk.details.permissions.setWorldRead(True)
469 lnk.details.permissions.setGroupWrite(True)
470 lnk.details.permissions.setUserWrite(True)
471 lnk.setParent(self._obj.__class__(self._obj.id, False))
472 lnk.setChild(ann._obj.__class__(ann._obj.id, False))
473 self._conn.getUpdateService().saveObject(lnk)
474 return ann
475
476
509
510
512 rv = {'type': self.OMERO_CLASS,
513 'id': self.getId(),
514 'name': self.getName(),
515 'description': self.getDescription(),
516 }
517 if hasattr(self, '_attrs'):
518
519
520
521
522 for k in self._attrs:
523 if ';' in k:
524 s = k.split(';')
525 k = s[0]
526 rk = ';'.join(s[1:])
527 else:
528 rk = k
529 rk = rk.replace('#', '')
530 if '|' in k:
531 s = k.split('|')
532 k2 = s[0]
533 w = '|'.join(s[1:])
534 if rk == k:
535 rk = k2
536 k = k2
537
538 v = getattr(self, k)
539 if v is not None:
540 v = getattr(omero.gateway, w)(self._conn, v).simpleMarshal()
541 else:
542 if k.startswith('#'):
543 v = getattr(self, k[1:])
544 if v is not None:
545 v = v._value
546 else:
547 v = getattr(self, k)
548 if hasattr(v, 'val'):
549 v = v.val
550 rv[rk] = v
551 if xtra:
552 if xtra.has_key('childCount'):
553 rv['child_count'] = self.countChildren()
554 if parents:
555 rv['parents'] = map(lambda x: x.simpleMarshal(), self.getAncestry())
556 return rv
557
558
559
560
561
562
564 if attr != 'get' and attr.startswith('get') and hasattr(self, '_attrs'):
565 tattr = attr[3].lower() + attr[4:]
566 attrs = filter(lambda x: tattr in x, self._attrs)
567 for a in attrs:
568 if a.startswith('#') and a[1:] == tattr:
569 v = getattr(self, tattr)
570 if v is not None:
571 v = v._value
572 def wrap ():
573 return v
574 return wrap
575 if len(a) > len(tattr) and a[len(tattr)] == '|':
576 def wrap ():
577 return getattr(omero.gateway, a[len(tattr)+1:])(self._conn, getattr(self, tattr))
578 return wrap
579 if not hasattr(self._obj, attr) and hasattr(self._obj, '_'+attr):
580 attr = '_' + attr
581 if hasattr(self._obj, attr):
582 rv = getattr(self._obj, attr)
583 if hasattr(rv, 'val'):
584 return isinstance(rv.val, StringType) and rv.val.decode('utf8') or rv.val
585 return rv
586 raise AttributeError("'%s' object has no attribute '%s'" % (self._obj.__class__.__name__, attr))
587
588
589
590
592 """
593 Gets this object ID
594
595 @return: Long or None
596 """
597 oid = self._obj.getId()
598 if oid is not None:
599 return oid.val
600 return None
601
603 """
604 Gets this object name
605
606 @return: String or None
607 """
608 if hasattr(self._obj, 'name'):
609 if hasattr(self._obj.name, 'val'):
610 return self._obj.getName().val
611 else:
612 return self._obj.getName()
613 else:
614 return None
615
617 """
618 Gets this object description
619
620 @return: String
621 """
622
623 rv = hasattr(self._obj, 'description') and self._obj.getDescription() or None
624 return rv and rv.val or ''
625
627 """
628 Gets user who is the owner of this object.
629
630 @return: _ExperimenterWrapper
631 """
632
633 return self.getDetails().getOwner()
634
636 """
637 Gets full name of the owner of this object.
638
639 @return: String or None
640 """
641
642 try:
643 lastName = self.getDetails().getOwner().lastName
644 firstName = self.getDetails().getOwner().firstName
645 middleName = self.getDetails().getOwner().middleName
646
647 if middleName is not None and middleName != '':
648 name = "%s %s. %s" % (firstName, middleName, lastName)
649 else:
650 name = "%s %s" % (firstName, lastName)
651 return name
652 except:
653 logger.error(traceback.format_exc())
654 return None
655
657 """
658 Gets omeName of the owner of this object.
659
660 @return: String
661 """
662 return self.getDetails().getOwner().omeName
663
665 """
666 Gets event time in timestamp format (yyyy-mm-dd hh:mm:ss.fffffff) when object was created.
667
668 @return: Long
669 """
670
671 try:
672 if self._obj.details.creationEvent.time is not None:
673 t = self._obj.details.creationEvent.time.val
674 else:
675 t = self._conn.getQueryService().get("Event", self._obj.details.creationEvent.id.val).time.val
676 except:
677 t = self._conn.getQueryService().get("Event", self._obj.details.creationEvent.id.val).time.val
678 return datetime.fromtimestamp(t/1000)
679
681 """
682 Gets event time in timestamp format (yyyy-mm-dd hh:mm:ss.fffffff) when object was updated.
683
684 @return: Long
685 """
686
687 try:
688 if self._obj.details.updateEvent.time is not None:
689 t = self._obj.details.updateEvent.time.val
690 else:
691 t = self._conn.getQueryService().get("Event", self._obj.details.updateEvent.id.val).time.val
692 except:
693 t = self._conn.getQueryService().get("Event", self._obj.details.updateEvent.id.val).time.val
694 return datetime.fromtimestamp(t/1000)
695
696
697
698
701
704
709 raise Ice.ConnectionLostException
710
712 """
713 ICE_CONFIG - Defines the path to the Ice configuration
714 """
715
716 ICE_CONFIG = None
717
718
719 - def __init__ (self, username=None, passwd=None, client_obj=None, group=None, clone=False, try_super=False, host=None, port=None, extra_config=[], secure=False):
720 """
721 TODO: Constructor
722
723 @param username: User name. String
724 @param passwd: Password. String
725 @param client_obj: omero.client
726 @param group: admin group
727 @param clone: Boolean
728 @param try_super: Boolean
729 @param host: Omero server host. String
730 @param port: Omero server port. Integer
731 @param extra_config:
732 @param secure: Initial underlying omero.client connection type (True=SSL/False=insecure)
733 """
734
735 super(_BlitzGateway, self).__init__()
736 self.client = client_obj
737 if not type(extra_config) in (type(()), type([])):
738 extra_config=[extra_config]
739 self.extra_config = extra_config
740 self.ice_config = [self.ICE_CONFIG]
741 self.ice_config.extend(extra_config)
742 self.ice_config = map(lambda x: str(x), filter(None, self.ice_config))
743
744 self.host = host
745 self.port = port
746 self.secure = secure
747
748 self._resetOmeroClient()
749 if not username:
750 username = self.c.ic.getProperties().getProperty('omero.gateway.anon_user')
751 passwd = self.c.ic.getProperties().getProperty('omero.gateway.anon_pass')
752
753 if try_super:
754 self.group = 'system'
755 else:
756 self.group = group and group or None
757 self._sessionUuid = None
758 self._session_cb = None
759 self._session = None
760 self._lastGroupId = None
761 self._anonymous = True
762
763
764 self.setIdentity(username, passwd, not clone)
765
766 self._connected = False
767 self._user = None
768 self._userid = None
769 self._proxies = NoProxies()
770
773
775 return self.__class__(self._ic_props[omero.constants.USERNAME],
776 self._ic_props[omero.constants.PASSWORD],
777 host = self.host,
778 port = self.port,
779 extra_config=self.extra_config,
780 clone=True,
781 secure=self.secure)
782
783
784 - def setIdentity (self, username, passwd, _internal=False):
785 """
786 TODO: description
787
788 @param username: User name. String
789 @param passwd: Password. String
790 @param _internal: Boolean
791 """
792
793 self._ic_props = {omero.constants.USERNAME: username,
794 omero.constants.PASSWORD: passwd}
795 self._anonymous = _internal
796
797 - def suConn (self, username, group=None, ttl=60000):
798 """ If current user isAdmin, return new connection owned by 'username' """
799 if self.isAdmin():
800 if group is None:
801 e = self.lookupExperimenter(username)
802 if e is None:
803 return
804 group = e._obj._groupExperimenterMapSeq[0].parent.name.val
805 p = omero.sys.Principal()
806 p.name = username
807 p.group = group
808 p.eventType = "User"
809 newConnId = self.getSessionService().createSessionWithTimeout(p, ttl)
810 newConn = self.clone()
811 newConn.connect(sUuid=newConnId.getUuid().val)
812 return newConn
813
815 """
816 Keeps service alive.
817 Returns True if connected. If connection was lost, reconnecting.
818
819 @return: Boolean
820 """
821
822 try:
823 if self.c.sf is None:
824 logger.debug('... c.sf is None, reconnecting')
825 return self.connect()
826 return self.c.sf.keepAlive(self._proxies['admin']._obj)
827 except Ice.ObjectNotExistException:
828
829 logger.debug(traceback.format_exc())
830 logger.debug("... reset, not reconnecting")
831 return False
832 except Ice.ConnectionLostException:
833
834 logger.debug(traceback.format_exc())
835 logger.debug("... lost, reconnecting")
836 return self.connect()
837 except Ice.ConnectionRefusedException:
838
839 logger.debug(traceback.format_exc())
840 logger.debug("... refused, not reconnecting")
841 return False
842 except omero.SessionTimeoutException:
843
844 logger.debug(traceback.format_exc())
845 logger.debug("... reset, not reconnecting")
846 return False
847 except omero.RemovedSessionException:
848
849 logger.debug(traceback.format_exc())
850 logger.debug("... session has left the building, not reconnecting")
851 return False
852 except Ice.UnknownException, x:
853
854 logger.debug(traceback.format_exc())
855 logger.debug('Ice.UnknownException: %s' % str(x))
856 logger.debug("... ice says something bad happened, not reconnecting")
857 return False
858 except:
859
860 logger.debug(traceback.format_exc())
861 logger.debug("... error not reconnecting")
862 return False
863
864 - def seppuku (self, softclose=False):
865 """
866 Terminates connection. If softclose is False, the session is really
867 terminate disregarding its connection refcount.
868
869 @param softclose: Boolean
870 """
871
872 self._connected = False
873 if self.c:
874 try:
875 self.c.sf.closeOnDestroy()
876 except Ice.ConnectionLostException:
877 pass
878 except Glacier2.SessionNotExistException:
879 pass
880 except AttributeError:
881 pass
882 try:
883 if softclose:
884 try:
885 r = self.c.sf.getSessionService().getReferenceCount(self._sessionUuid)
886 self.c.closeSession()
887 if r < 2:
888 self._session_cb and self._session_cb.close(self)
889 except Ice.OperationNotExistException:
890 self.c.closeSession()
891 else:
892 self._closeSession()
893 except Glacier2.SessionNotExistException:
894 pass
895 except Ice.ConnectionLostException:
896 pass
897 self.c = None
898 self._proxies = NoProxies()
899 logger.info("closed connecion (uuid=%s)" % str(self._sessionUuid))
900
902 logger.debug("##GARBAGE COLLECTOR KICK IN")
903
905 """
906 Creates proxies to the server services.
907 """
908
909 if not isinstance(self._proxies, NoProxies):
910 logger.debug("## Reusing proxies")
911 for k, p in self._proxies.items():
912 p._resyncConn(self)
913 else:
914 logger.debug("## Creating proxies")
915 self._proxies = {}
916 self._proxies['admin'] = ProxyObjectWrapper(self, 'getAdminService')
917 self._proxies['config'] = ProxyObjectWrapper(self, 'getConfigService')
918 self._proxies['container'] = ProxyObjectWrapper(self, 'getContainerService')
919 self._proxies['delete'] = ProxyObjectWrapper(self, 'getDeleteService')
920 self._proxies['export'] = ProxyObjectWrapper(self, 'createExporter')
921 self._proxies['ldap'] = ProxyObjectWrapper(self, 'getLdapService')
922 self._proxies['metadata'] = ProxyObjectWrapper(self, 'getMetadataService')
923 self._proxies['query'] = ProxyObjectWrapper(self, 'getQueryService')
924 self._proxies['pixel'] = ProxyObjectWrapper(self, 'getPixelsService')
925 self._proxies['projection'] = ProxyObjectWrapper(self, 'getProjectionService')
926 self._proxies['rawpixels'] = ProxyObjectWrapper(self, 'createRawPixelsStore')
927 self._proxies['rendering'] = ProxyObjectWrapper(self, 'createRenderingEngine')
928 self._proxies['rendsettings'] = ProxyObjectWrapper(self, 'getRenderingSettingsService')
929 self._proxies['rawfile'] = ProxyObjectWrapper(self, 'createRawFileStore')
930 self._proxies['repository'] = ProxyObjectWrapper(self, 'getRepositoryInfoService')
931 self._proxies['script'] = ProxyObjectWrapper(self, 'getScriptService')
932 self._proxies['search'] = ProxyObjectWrapper(self, 'createSearchService')
933 self._proxies['session'] = ProxyObjectWrapper(self, 'getSessionService')
934 self._proxies['share'] = ProxyObjectWrapper(self, 'getShareService')
935 self._proxies['thumbs'] = ProxyObjectWrapper(self, 'createThumbnailStore')
936 self._proxies['timeline'] = ProxyObjectWrapper(self, 'getTimelineService')
937 self._proxies['types'] = ProxyObjectWrapper(self, 'getTypesService')
938 self._proxies['update'] = ProxyObjectWrapper(self, 'getUpdateService')
939
940 self._ctx = self._proxies['admin'].getEventContext()
941 self._userid = self._ctx.userId
942 self._user = self.getExperimenter(self._userid)
943 if self._session_cb:
944 if self._was_join:
945 self._session_cb.join(self)
946 else:
947 self._session_cb.create(self)
948
950 """ Switches between SSL and insecure (faster) connections to Blitz.
951 The gateway must already be connected. """
952 if hasattr(self.c, 'createClient') and (secure ^ self.c.isSecure()):
953 self.c = self.c.createClient(secure=secure)
954 self._createProxies()
955 self.secure = secure
956
958 """ Returns 'True' if the underlying omero.clients.BaseClient is connected using SSL """
959 return hasattr(self.c, 'isSecure') and self.c.isSecure() or False
960
977
979 """
980 Close session.
981 """
982
983 self._session_cb and self._session_cb.close(self)
984 if self._sessionUuid:
985 s = omero.model.SessionI()
986 s._uuid = omero_type(self._sessionUuid)
987 try:
988 r = 1
989 while r:
990 r = self.c.sf.getSessionService().closeSession(s)
991 except Ice.ObjectNotExistException:
992 pass
993 except omero.RemovedSessionException:
994 pass
995 except ValueError:
996 raise
997 except:
998 logger.warn(traceback.format_exc())
999 try:
1000 self.c.closeSession()
1001 except Glacier2.SessionNotExistException:
1002 pass
1003
1005 """
1006 Resets omero.client object.
1007 """
1008
1009 if self.host is not None:
1010 self.c = omero.client(host=str(self.host), port=int(self.port))
1011 else:
1012 self.c = omero.client(pmap=['--Ice.Config='+','.join(self.ice_config)])
1013
1014 if hasattr(self.c, "setAgent"):
1015 self.c.setAgent("OMERO.py.gateway")
1016
1018 """
1019 Creates or retrieves connection for the given sessionUuid.
1020 Returns True if connected.
1021
1022 @param sUuid: omero_model_SessionI
1023 @return: Boolean
1024 """
1025
1026 logger.debug("Connect attempt, sUuid=%s, group=%s, self.sUuid=%s" % (str(sUuid), str(self.group), self._sessionUuid))
1027 if not self.c:
1028 self._connected = False
1029 logger.debug("Ooops. no self._c")
1030 return False
1031 try:
1032 if self._sessionUuid is None and sUuid:
1033 self._sessionUuid = sUuid
1034 if self._sessionUuid is not None:
1035 try:
1036 logger.debug('connected? %s' % str(self._connected))
1037 if self._connected:
1038 self._connected = False
1039 logger.debug("was connected, creating new omero.client")
1040 self._resetOmeroClient()
1041 s = self.c.joinSession(self._sessionUuid)
1042 s.detachOnDestroy()
1043 logger.debug('joinSession(%s)' % self._sessionUuid)
1044 self._was_join = True
1045 except Ice.SyscallException:
1046 raise
1047 except Exception, x:
1048 logger.debug("Error: " + str(x))
1049 self._sessionUuid = None
1050 if sUuid:
1051 return False
1052 if self._sessionUuid is None:
1053 if sUuid:
1054 logger.debug("Uncaptured sUuid failure!")
1055 if self._connected:
1056 self._connected = False
1057 try:
1058
1059
1060 self._closeSession()
1061 self._resetOmeroClient()
1062
1063 except Glacier2.SessionNotExistException:
1064 pass
1065 setprop = self.c.ic.getProperties().setProperty
1066 map(lambda x: setprop(x[0],str(x[1])), self._ic_props.items())
1067 if self._anonymous:
1068 self.c.ic.getImplicitContext().put(omero.constants.EVENT, 'Internal')
1069 if self.group is not None:
1070 self.c.ic.getImplicitContext().put(omero.constants.GROUP, self.group)
1071 try:
1072 self._createSession()
1073 except omero.SecurityViolation:
1074 if self.group is not None:
1075
1076 logger.debug("## User not in '%s' group" % self.group)
1077 self.group = None
1078 self._closeSession()
1079 self._sessionUuid = None
1080 self._connected=True
1081 return self.connect()
1082 else:
1083 logger.debug("BlitzGateway.connect().createSession(): " + traceback.format_exc())
1084 logger.info('first create session threw SecurityViolation, hold off 10 secs and retry (but only once)')
1085
1086 try:
1087 self._createSession()
1088 except omero.SecurityViolation:
1089 if self.group is not None:
1090
1091 logger.debug("## User not in '%s' group" % self.group)
1092 self.group = None
1093 self._connected=True
1094 return self.connect()
1095 else:
1096 raise
1097 except Ice.SyscallException:
1098 raise
1099 except:
1100 logger.info("BlitzGateway.connect().createSession(): " + traceback.format_exc())
1101 logger.debug(str(self._ic_props))
1102
1103 self._createSession()
1104
1105 self._last_error = None
1106 self._createProxies()
1107 self._connected = True
1108 logger.info('created connection (uuid=%s)' % str(self._sessionUuid))
1109 except Ice.SyscallException:
1110 logger.debug('This one is a SyscallException')
1111 raise
1112 except Ice.LocalException, x:
1113 logger.debug("connect(): " + traceback.format_exc())
1114 self._last_error = x
1115 return False
1116 except Exception, x:
1117 logger.debug("connect(): " + traceback.format_exc())
1118 self._last_error = x
1119 return False
1120 logger.debug(".. connected!")
1121 return True
1122
1124 """
1125 Returns error if thrown by _BlitzGateway.connect connect.
1126
1127 @return: String
1128 """
1129
1130 return self._last_error
1131
1133 """
1134 Returns last status of connection.
1135
1136 @return: Boolean
1137 """
1138
1139 return self._connected
1140
1141
1142
1143
1144 - def getEventContext (self):
1145 """
1146 Returns omero_System_ice.EventContext.
1147 It containes::
1148 shareId, sessionId, sessionUuid, userId, userName,
1149 groupId, groupName, isAdmin, isReadOnly,
1150 eventId, eventType, eventType,
1151 memberOfGroups, leaderOfGroups
1152
1153 @return: omero.sys.EventContext
1154 """
1155
1156 self._ctx = self._proxies['admin'].getEventContext()
1157 return self._ctx
1158
1160 """
1161 Returns current omero_model_ExperimenterI.
1162
1163 @return: omero.model.ExperimenterI
1164 """
1165
1166 return self._user
1167
1169 """
1170 Checks if a user has administration privileges.
1171
1172 @return: Boolean
1173 """
1174
1175 return self.getEventContext().isAdmin
1176
1178 """
1179 Checks if a user is in system group, i.e. can have administration privileges.
1180
1181 @return: Boolean
1182 """
1183 return 0 in self.getEventContext().memberOfGroups
1184
1186 """
1187 Checks if a user has owner privileges.
1188
1189 @return: Boolean
1190 """
1191 if not isinstance(gid, LongType) or not isinstance(gid, IntType):
1192 gid = long(gid)
1193 if gid is not None:
1194 for gem in self._user.copyGroupExperimenterMap():
1195 if gem.parent.id.val == gid and gem.owner.val == True:
1196 return True
1197 else:
1198 for gem in self._user.copyGroupExperimenterMap():
1199 if gem.owner.val == True:
1200 return True
1201 return False
1202
1204 """
1205 Checks if a user has write privileges to the given object.
1206
1207 @param obj: Given object
1208 @return: Boolean
1209 """
1210
1211 return self.isAdmin() or (self._userid == obj.details.owner.id.val and obj.details.permissions.isUserWrite())
1212
1214 if self._session is None:
1215 ss = self.c.sf.getSessionService()
1216 self._session = ss.getSession(self._sessionUuid)
1217 return self._session
1218
1219
1220
1221
1222
1223
1224
1229
1231 if self.getEventContext().groupId == groupid:
1232 return True
1233 if groupid not in self._ctx.memberOfGroups:
1234 return False
1235 self._lastGroupId = self._ctx.groupId
1236 if hasattr(self.c, 'setSecurityContext'):
1237
1238 self.c.sf.setSecurityContext(omero.model.ExperimenterGroupI(groupid, False))
1239 else:
1240 self.getSession()
1241 self._session.getDetails().setGroup(omero.model.ExperimenterGroupI(groupid, False))
1242 self._session.setTimeToIdle(None)
1243 self.getSessionService().updateSession(self._session)
1244 return True
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1262 if self._lastGroupId is not None:
1263 self.setGroupForSession(self._lastGroupId)
1264 self._lastGroupId = None
1265
1266
1267
1268
1270 """
1271 Gets reference to the admin service from ProxyObjectWrapper.
1272
1273 @return: omero.gateway.ProxyObjectWrapper
1274 """
1275
1276 return self._proxies['admin']
1277
1279 """
1280 Gets reference to the query service from ProxyObjectWrapper.
1281
1282 @return: omero.gateway.ProxyObjectWrapper
1283 """
1284 return self._proxies['query']
1285
1287 """
1288 Gets reference to the container service from ProxyObjectWrapper.
1289
1290 @return: omero.gateway.ProxyObjectWrapper
1291 """
1292
1293 return self._proxies['container']
1294
1296 """
1297 Gets reference to the pixels service from ProxyObjectWrapper.
1298
1299 @return: omero.gateway.ProxyObjectWrapper
1300 """
1301
1302 return self._proxies['pixel']
1303
1312
1314 """
1315 Creates a new raw file store.
1316 This service is special in that it does not get cached inside BlitzGateway so every call to this function
1317 returns a new object, avoiding unexpected inherited states.
1318
1319 @return: omero.gateway.ProxyObjectWrapper
1320 """
1321
1322 return self._proxies['rawfile']
1323
1325 """
1326 Gets reference to the repository info service from ProxyObjectWrapper.
1327
1328 @return: omero.gateway.ProxyObjectWrapper
1329 """
1330
1331 return self._proxies['repository']
1332
1334 """
1335 Gets reference to the share service from ProxyObjectWrapper.
1336
1337 @return: omero.gateway.ProxyObjectWrapper
1338 """
1339
1340 return self._proxies['share']
1341
1343 """
1344 Gets reference to the timeline service from ProxyObjectWrapper.
1345
1346 @return: omero.gateway.ProxyObjectWrapper
1347 """
1348
1349 return self._proxies['timeline']
1350
1352 """
1353 Gets reference to the types service from ProxyObjectWrapper.
1354
1355 @return: omero.gateway.ProxyObjectWrapper
1356 """
1357
1358 return self._proxies['types']
1359
1361 """
1362 Gets reference to the config service from ProxyObjectWrapper.
1363
1364 @return: omero.gateway.ProxyObjectWrapper
1365 """
1366
1367 return self._proxies['config']
1368
1370 """
1371 Creates a new rendering engine.
1372 This service is special in that it does not get cached inside BlitzGateway so every call to this function
1373 returns a new object, avoiding unexpected inherited states.
1374
1375 @return: omero.gateway.ProxyObjectWrapper
1376 """
1377
1378 rv = self._proxies['rendering']
1379 if rv._tainted:
1380 rv = self._proxies['rendering'] = rv.clone()
1381 rv.taint()
1382 return rv
1383
1385 """
1386 Gets reference to the rendering settings service from ProxyObjectWrapper.
1387
1388 @return: omero.gateway.ProxyObjectWrapper
1389 """
1390
1391 return self._proxies['rendsettings']
1392
1394 """
1395 Creates a new raw pixels store.
1396 This service is special in that it does not get cached inside BlitzGateway so every call to this function
1397 returns a new object, avoiding unexpected inherited states.
1398
1399 @return: omero.gateway.ProxyObjectWrapper
1400 """
1401
1402 return self._proxies['rawpixels']
1403
1405 """
1406 Gets a reference to the thumbnail store on this connection object or creates a new one
1407 if none exists.
1408
1409 @rtype: omero.gateway.ProxyObjectWrapper
1410 @return: The proxy wrapper of the thumbnail store
1411 """
1412
1413 return self._proxies['thumbs']
1414
1416 """
1417 Creates a new search service.
1418 This service is special in that it does not get cached inside BlitzGateway so every call to this function
1419 returns a new object, avoiding unexpected inherited states.
1420
1421 @return: omero.gateway.ProxyObjectWrapper
1422 """
1423 return self._proxies['search']
1424
1426 """
1427 Gets reference to the update service from ProxyObjectWrapper.
1428
1429 @return: omero.gateway.ProxyObjectWrapper
1430 """
1431 return self._proxies['update']
1432
1434 """
1435 Gets reference to the delete service from ProxyObjectWrapper.
1436
1437 @return: omero.gateway.ProxyObjectWrapper
1438 """
1439 return self._proxies['delete']
1440
1442 """
1443 Gets reference to the session service from ProxyObjectWrapper.
1444
1445 @return: omero.gateway.ProxyObjectWrapper
1446 """
1447 return self._proxies['session']
1448
1450 """
1451 New instance of non cached Exporter, wrapped in ProxyObjectWrapper.
1452
1453 @return: omero.gateway.ProxyObjectWrapper
1454 """
1455
1456 return self._proxies['export']
1457
1458
1459
1460
1462 """
1463 List every Projects controlled by the security system.
1464
1465 @param only_owned: Only owned by the logged user. Boolean.
1466 @return: Generator yielding _ProjectWrapper
1467 """
1468
1469 q = self.getQueryService()
1470 cache = {}
1471 if only_owned:
1472 params = omero.sys.Parameters()
1473 params.map = {'owner_id': rlong(self._userid)}
1474 for e in q.findAllByQuery("from Project as p where p.details.owner.id=:owner_id order by p.name", params):
1475 yield ProjectWrapper(self, e, cache)
1476 else:
1477 for e in q.findAll('Project', None):
1478 yield ProjectWrapper(self, e, cache)
1479
1480
1481
1482
1483
1484
1485
1487 """
1488 Return a generator for all Experimenters whose omeName starts with 'start'.
1489 The generated values follow the alphabetic order on omeName.
1490
1491 @param start: Only if omero_model_ExperimenterI.omeName starts with. String.
1492 @return: Generator yielding _ExperimenterWrapper
1493 """
1494
1495 if isinstance(start, UnicodeType):
1496 start = start.encode('utf8')
1497 params = omero.sys.Parameters()
1498 params.map = {'start': rstring('%s%%' % start.lower())}
1499 q = self.getQueryService()
1500 rv = q.findAllByQuery("from Experimenter e where lower(e.omeName) like :start", params)
1501 rv.sort(lambda x,y: cmp(x.omeName.val,y.omeName.val))
1502 for e in rv:
1503 yield ExperimenterWrapper(self, e)
1504
1506 """
1507 Return an Experimenter for the given ID.
1508
1509 @param eid: User ID.
1510 @return: _ExperimenterWrapper or None
1511 """
1512
1513 admin_serv = self.getAdminService()
1514 try:
1515 exp = admin_serv.getExperimenter(long(eid))
1516 return ExperimenterWrapper(self, exp)
1517 except omero.ApiUsageException:
1518 return None
1519
1521 """
1522 Return an Experimenter for the given username.
1523
1524 @param name: Username. String
1525 @return: _ExperimenterWrapper or None
1526 """
1527
1528 admin_serv = self.getAdminService()
1529 try:
1530 exp = admin_serv.lookupExperimenter(str(name))
1531 return ExperimenterWrapper(self, exp)
1532 except omero.ApiUsageException:
1533 return None
1534
1535
1536
1537
1539 """
1540 List images based on the their creation times.
1541 If both tfrom and tto are None, grab the most recent batch.
1542
1543 @param tfrom: milliseconds since the epoch for start date
1544 @param tto: milliseconds since the epoch for end date
1545 @param tlimit: maximum number of results
1546 @param only_owned: Only owned by the logged user. Boolean.
1547 @return: Generator yielding _ImageWrapper
1548 """
1549 tm = self.getTimelineService()
1550 p = omero.sys.Parameters()
1551 f = omero.sys.Filter()
1552 if only_owned:
1553 f.ownerId = rlong(self.getEventContext().userId)
1554 f.groupId = rlong(self.getEventContext().groupId)
1555 else:
1556 f.ownerId = rlong(-1)
1557 f.groupId = None
1558 f.limit = rint(limit)
1559 p.theFilter = f
1560 if tfrom is None and tto is None:
1561 for e in tm.getMostRecentObjects(['Image'], p, False)["Image"]:
1562 yield ImageWrapper(self, e)
1563 else:
1564 if tfrom is None:
1565 tfrom = 0
1566 if tto is None:
1567 tto = time.time() * 1000
1568 for e in tm.getByPeriod(['Image'], rtime(long(tfrom)), rtime(long(tto)), p, False)['Image']:
1569 yield ImageWrapper(self, e)
1570
1571
1572
1573
1574
1575
1576
1578 """
1579 Return Project for the given ID.
1580
1581 @param oid: Project ID.
1582 @return: _ProjectWrapper or None
1583 """
1584
1585 q = self.getQueryService()
1586 pr = q.find("Project", long(oid))
1587 if pr is not None:
1588 pr = ProjectWrapper(self, pr)
1589 return pr
1590
1592 """
1593 Return Project with the given name.
1594
1595 @param name: Project name.
1596 @return: _ProjectWrapper or None
1597 """
1598 q = self.getQueryService()
1599 params = omero.sys.Parameters()
1600 if not params.map:
1601 params.map = {}
1602 params.map['name'] = rstring(name)
1603 pr = q.findAllByQuery("from Project as p where p.name=:name", params)
1604 if len(pr):
1605 return ProjectWrapper(self, pr[0])
1606 return None
1607
1609 """
1610 Return Dataset for the given ID.
1611
1612 @param oid: Dataset ID.
1613 @return: _DatasetWrapper or None
1614 """
1615
1616 q = self.getQueryService()
1617 ds = q.find("Dataset", long(oid))
1618 if ds is not None:
1619 ds = DatasetWrapper(self, ds)
1620 return ds
1621
1623 """
1624 Return Image for the given ID.
1625
1626 @param oid: Image ID.
1627 @return: _ImageWrapper or None
1628 """
1629
1630 q = self.getQueryService()
1631 img = q.find("Image", long(oid))
1632 if img is not None:
1633 img = ImageWrapper(self, img)
1634 return img
1635
1636
1637
1638
1640 """
1641 TODO: description
1642
1643 @return: Generator yielding _ImageWrapper
1644 """
1645
1646 if not params:
1647 params = omero.sys.Parameters()
1648 if not params.map:
1649 params.map = {}
1650 params.map["ns"] = omero_type(ns)
1651 query = """
1652 select i
1653 from Image i
1654 join i.annotationLinks ial
1655 join ial.child as a
1656 where a.ns = :ns
1657 order by a.id desc """
1658 for i in self.getQueryService().findAllByQuery(query, params):
1659 yield ImageWrapper(self, i)
1660
1661
1662
1663
1664
1666 types = self.getTypesService()
1667 for e in types.allEnumerations(str(klass)):
1668 yield EnumerationWrapper(self, e)
1669
1671 types = self.getTypesService()
1672 obj = types.getEnumeration(str(klass), str(string))
1673 if obj is not None:
1674 return EnumerationWrapper(self, obj)
1675 else:
1676 return None
1677
1679 query_serv = self.getQueryService()
1680 obj = query_serv.find(klass, long(eid))
1681 if obj is not None:
1682 return EnumerationWrapper(self, obj)
1683 else:
1684 return None
1685
1694
1696 types = self.getTypesService()
1697 return types.getEnumerationTypes()
1698
1708
1712
1716
1720
1724
1725
1726
1727
1728
1729
1731 """
1732 Fulltext search for images
1733 """
1734 return self.simpleSearch(text,(ImageWrapper,))
1735
1736
1738 """
1739 Fulltext search on Projects, Datasets and Images.
1740 TODO: search other object types?
1741 TODO: batch support.
1742 """
1743 if not text:
1744 return []
1745 if isinstance(text, UnicodeType):
1746 text = text.encode('utf8')
1747 if types is None:
1748 types = (ProjectWrapper, DatasetWrapper, ImageWrapper)
1749 search = self.createSearchService()
1750 if text[0] in ('?','*'):
1751 search.setAllowLeadingWildcard(True)
1752 rv = []
1753 for t in types:
1754 def actualSearch ():
1755 search.onlyType(t().OMERO_CLASS)
1756 search.byFullText(text)
1757 timeit(actualSearch)()
1758 if search.hasNext():
1759 def searchProcessing ():
1760 rv.extend(map(lambda x: t(self, x), search.results()))
1761 timeit(searchProcessing)()
1762 search.close()
1763 return rv
1764
1766 """
1767 Captures called function. Throws an exception.
1768
1769 @return:
1770 """
1771
1772 def inner (*args, **kwargs):
1773 try:
1774 return f(*args, **kwargs)
1775 except omero.ResourceError:
1776 logger.debug('captured resource error')
1777 raise
1778 except omero.SecurityViolation:
1779 raise
1780 except omero.ApiUsageException:
1781 raise
1782 except Ice.MemoryLimitException:
1783 raise
1784 except omero.InternalException:
1785 raise
1786 except Ice.Exception, x:
1787
1788 logger.debug( "Ice.Exception (1) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs)))
1789 logger.debug(traceback.format_exc())
1790
1791 try:
1792 self._obj = self._create_func()
1793 func = getattr(self._obj, attr)
1794 return func(*args, **kwargs)
1795 except Ice.MemoryLimitException:
1796 raise
1797 except Ice.Exception, x:
1798
1799 logger.debug("Ice.Exception (2) on safe call %s(%s,%s)" % (attr, str(args), str(kwargs)))
1800 logger.debug(traceback.format_exc())
1801 try:
1802
1803 self._connect()
1804 logger.debug('last try for %s' % attr)
1805
1806 func = getattr(self._obj, attr)
1807 return func(*args, **kwargs)
1808 except:
1809 raise
1810
1811 def wrapped (*args, **kwargs):
1812 try:
1813 return inner(*args, **kwargs)
1814 except Ice.MemoryLimitException:
1815 logger.debug("MemoryLimitException! abort, abort...")
1816 raise
1817 except omero.SecurityViolation:
1818 logger.debug("SecurityViolation, bailing out")
1819 raise
1820 except omero.ApiUsageException:
1821 logger.debug("ApiUsageException, bailing out")
1822 raise
1823 except Ice.UnknownException:
1824 logger.debug("UnknownException, bailing out")
1825 raise
1826 except Ice.Exception, x:
1827 logger.debug('wrapped ' + f.func_name)
1828 logger.debug(x.__dict__)
1829 if x.serverExceptionClass == 'ome.conditions.InternalException':
1830 if x.message.find('java.lang.NullPointerException') > 0:
1831 logger.debug("NullPointerException, bailing out")
1832 raise
1833 elif x.message.find('Session is dirty') >= 0:
1834 logger.debug("Session is dirty, bailing out")
1835 raise
1836 else:
1837 logger.debug(x.message)
1838 logger.debug("exception caught, first time we back off for 10 secs")
1839 logger.debug(traceback.format_exc())
1840
1841 return inner(*args, **kwargs)
1842 return wrapped
1843
1844
1845 BlitzGateway = _BlitzGateway
1849 """ splits an hex stream of characters into an array of bytes in format (R,G,B,A).
1850 - abc -> (0xAA, 0xBB, 0xCC, 0xFF)
1851 - abcd -> (0xAA, 0xBB, 0xCC, 0xDD)
1852 - abbccd -> (0xAB, 0xBC, 0xCD, 0xFF)
1853 - abbccdde -> (0xAB, 0xBC, 0xCD, 0xDE)
1854 """
1855 try:
1856 out = []
1857 if len(color) in (3,4):
1858 c = color
1859 color = ''
1860 for e in c:
1861 color += e + e
1862 if len(color) == 6:
1863 color += 'FF'
1864 if len(color) == 8:
1865 for i in range(0, 8, 2):
1866 out.append(int(color[i:i+2], 16))
1867 return out
1868 except:
1869 pass
1870 return None
1871
1875 self._obj = None
1876 self._func_str = func_str
1877 self._resyncConn(conn)
1878 self._tainted = False
1879
1882
1884 """
1885 Returns True if connected.
1886
1887 @return: Boolean
1888 """
1889
1890 logger.debug("proxy_connect: a");
1891 if not self._conn.connect():
1892 logger.debug('connect failed')
1893 logger.debug('/n'.join(traceback.format_stack()))
1894 return False
1895 logger.debug("proxy_connect: b");
1896 self._resyncConn(self._conn)
1897 logger.debug("proxy_connect: c");
1898 self._obj = self._create_func()
1899 logger.debug("proxy_connect: d");
1900 return True
1901
1903 self._tainted = True
1904
1906 self._tainted = False
1907
1909 """
1910 Closes the underlaying service, so next call to the proxy will create a new
1911 instance of it.
1912 """
1913
1914 if self._obj:
1915 self._obj.close()
1916 self._obj = None
1917
1919 """
1920
1921 @param conn: Connection
1922 """
1923
1924 self._conn = conn
1925 self._sf = conn.c.sf
1926 self._create_func = getattr(self._sf, self._func_str)
1927 if self._obj is not None:
1928 try:
1929 logger.debug("## - refreshing %s" % (self._func_str))
1930 obj = conn.c.ic.stringToProxy(str(self._obj))
1931 self._obj = self._obj.checkedCast(obj)
1932 except Ice.ObjectNotExistException:
1933 self._obj = None
1934
1936 """
1937
1938 @return: obj
1939 """
1940 if not self._obj:
1941 self._obj = self._create_func()
1942 else:
1943 self._ping()
1944 return self._obj
1945
1947 """
1948 For some reason, it seems that keepAlive doesn't, so every so often I need to recreate the objects.
1949
1950 @return: Boolean
1951 """
1952
1953 try:
1954 if not self._sf.keepAlive(self._obj):
1955 logger.debug("... died, recreating ...")
1956 self._obj = self._create_func()
1957 except Ice.ObjectNotExistException:
1958
1959 logger.debug("... reset, reconnecting")
1960 self._connect()
1961 return False
1962 except Ice.ConnectionLostException:
1963
1964 logger.debug(traceback.format_stack())
1965 logger.debug("... lost, reconnecting")
1966 self._conn._connected = False
1967 self._connect()
1968 return False
1969 except Ice.ConnectionRefusedException:
1970
1971 logger.debug(traceback.format_stack())
1972 logger.debug("... refused, reconnecting")
1973 self._connect()
1974 return False
1975 except omero.RemovedSessionException:
1976
1977 logger.debug(traceback.format_stack())
1978 logger.debug("... session has left the building, reconnecting")
1979 self._connect()
1980 return False
1981 except Ice.UnknownException:
1982
1983 logger.debug(traceback.format_stack())
1984 logger.debug("... ice says something bad happened, reconnecting")
1985 self._connect()
1986 return False
1987 return True
1988
1990 """
1991
1992 @param attr: Connection
1993 @return: rv
1994 """
1995
1996 obj = self._obj or self._getObj()
1997 rv = getattr(obj, attr)
1998 if callable(rv):
1999 rv = safeCallWrap(self, attr, rv)
2000
2001 return rv
2002
2005 """
2006 omero_model_AnnotationI class wrapper extends BlitzObjectWrapper.
2007 """
2008 registry = {}
2009 OMERO_TYPE = None
2010
2016
2019
2020 @classmethod
2023
2024 @classmethod
2025 - def _wrap (klass, conn, obj, link=None):
2026 if obj.__class__ in klass.registry:
2027 kwargs = dict()
2028 if link is not None:
2029 kwargs['link'] = BlitzObjectWrapper(conn, link)
2030 return klass.registry[obj.__class__](conn, obj, **kwargs)
2031 else:
2032 return None
2033
2034 @classmethod
2041
2043 return self._obj.ns.val
2044
2047
2049 raise NotImplementedError
2050
2052 raise NotImplementedError
2053
2054 from omero_model_FileAnnotationI import FileAnnotationI
2057 """
2058 omero_model_FileAnnotatio class wrapper extends AnnotationWrapper.
2059 """
2060
2061 OMERO_TYPE = FileAnnotationI
2062
2066
2069
2072
2081
2084
2086 self.__loadedHotSwap__()
2087 name = self._obj.file.name.val
2088 l = len(name)
2089 if l < 35:
2090 return name
2091 return name[:16] + "..." + name[l - 16:]
2092
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131 AnnotationWrapper._register(FileAnnotationWrapper)
2132
2133 from omero_model_TimestampAnnotationI import TimestampAnnotationI
2136 """
2137 omero_model_TimestampAnnotatio class wrapper extends AnnotationWrapper.
2138 """
2139
2140 OMERO_TYPE = TimestampAnnotationI
2141
2143 return datetime.fromtimestamp(self._obj.timeValue.val / 1000.0)
2144
2146 if isinstance(val, datetime):
2147 self._obj.timeValue = rtime(long(time.mktime(val.timetuple())*1000))
2148 elif isinstance(val, omero.RTime):
2149 self._obj.timeValue = val
2150 else:
2151 self._obj.timeValue = rtime(long(val * 1000))
2152
2153 AnnotationWrapper._register(TimestampAnnotationWrapper)
2154
2155 from omero_model_BooleanAnnotationI import BooleanAnnotationI
2158 """
2159 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper.
2160 """
2161
2162 OMERO_TYPE = BooleanAnnotationI
2163
2165 return self._obj.boolValue.val
2166
2168 self._obj.boolValue = rbool(not not val)
2169
2170 AnnotationWrapper._register(BooleanAnnotationWrapper)
2171
2172 from omero_model_TagAnnotationI import TagAnnotationI
2175 """
2176 omero_model_BooleanAnnotationI class wrapper extends AnnotationWrapper.
2177 """
2178
2179 OMERO_TYPE = TagAnnotationI
2180
2182 return self._obj.textValue.val
2183
2185 self._obj.tectValue = rbool(not not val)
2186
2187 AnnotationWrapper._register(TagAnnotationWrapper)
2188
2189 from omero_model_CommentAnnotationI import CommentAnnotationI
2203
2204 AnnotationWrapper._register(CommentAnnotationWrapper)
2205
2206 from omero_model_LongAnnotationI import LongAnnotationI
2209 """
2210 omero_model_LongAnnotationI class wrapper extends AnnotationWrapper.
2211 """
2212 OMERO_TYPE = LongAnnotationI
2213
2215 return self._obj.longValue.val
2216
2218 self._obj.longValue = rlong(val)
2219
2220 AnnotationWrapper._register(LongAnnotationWrapper)
2223
2225 return self._obj.__class__
2226
2227 EnumerationWrapper = _EnumerationWrapper
2230 """
2231 omero_model_ExperimenterI class wrapper extends BlitzObjectWrapper.
2232 """
2233
2239
2241 rv = super(_ExperimenterWrapper, self).simpleMarshal(xtra=xtra, parents=parents)
2242 rv.update({'firstName': self.firstName,
2243 'middleName': self.middleName,
2244 'lastName': self.lastName,
2245 'email': self.email,
2246 'isAdmin': len(filter(lambda x: x.name.val == 'system', self._conn.getAdminService().containedGroups(self.getId()))) == 1,
2247 })
2248 return rv
2249
2251 """ Returns the experiments preferences annotation contents, as a ConfigParser instance """
2252 self._obj.unloadAnnotationLinks()
2253 cp = ConfigParser.SafeConfigParser()
2254 prefs = self.getAnnotation('TODO.changeme.preferences')
2255 if prefs is not None:
2256 prefs = prefs.getValue()
2257 if prefs is not None:
2258 cp.readfp(StringIO(prefs))
2259 return cp
2260
2262 """ Sets the experiments preferences annotation contents, passed in as a ConfigParser instance """
2263 ann = self.getAnnotation('TODO.changeme.preferences')
2264 t = StringIO()
2265 prefs.write(t)
2266 if ann is None:
2267 ann = CommentAnnotationWrapper()
2268 ann.setNs('TODO.changeme.preferences')
2269 ann.setValue(t.getvalue())
2270 self.linkAnnotation(ann)
2271 else:
2272 ann.setValue(t.getvalue())
2273 ann.save()
2274 self._obj.unloadAnnotationLinks()
2275
2277 if section is None:
2278 section = 'DEFAULT'
2279 try:
2280 return self.getRawPreferences().get(section, key)
2281 except ConfigParser.Error:
2282 return default
2283 return default
2284
2286 if section is None:
2287 section = 'DEFAULT'
2288 prefs = self.getRawPreferences()
2289 if prefs.has_section(section) or section == 'DEFAULT':
2290 return dict(prefs.items(section))
2291 return {}
2292
2301
2303 if not self._obj.details.owner:
2304 details = omero.model.DetailsI()
2305 details.owner = self._obj
2306 self._obj._details = details
2307 return DetailsWrapper(self._conn, self._obj.details)
2308
2311
2314
2316 """
2317 Gets full name of this experimenter.
2318
2319 @return: String or None
2320 """
2321
2322 try:
2323 if self.middleName is not None and self.middleName != '':
2324 name = "%s %s. %s" % (self.firstName, self.middleName[:1].upper(), self.lastName)
2325 else:
2326 name = "%s %s" % (self.firstName, self.lastName)
2327 except:
2328 logger.error(traceback.format_exc())
2329 name = self.omeName
2330 return name
2331
2333 try:
2334 if self.firstName is not None and self.lastName is not None:
2335 name = "%s. %s" % (self.firstName[:1], self.lastName)
2336 else:
2337 name = self.omeName
2338 except:
2339 logger.error(traceback.format_exc())
2340 name = self.omeName
2341 return name
2342
2344 for ob in self._obj.copyGroupExperimenterMap():
2345 if ob.parent.name.val == "system":
2346 return True
2347 return False
2348
2350 for ob in self._obj.copyGroupExperimenterMap():
2351 if ob.parent.name.val == "user":
2352 return True
2353 return False
2354
2356 for ob in self._obj.copyGroupExperimenterMap():
2357 if ob.parent.name.val == "guest":
2358 return True
2359 return False
2360
2361 ExperimenterWrapper = _ExperimenterWrapper
2364 """
2365 omero_model_ExperimenterGroupI class wrapper extends BlitzObjectWrapper.
2366 """
2367
2373
2374 ExperimenterGroupWrapper = _ExperimenterGroupWrapper
2377 """
2378 omero_model_DetailsI class wrapper extends BlitzObjectWrapper.
2379 """
2380
2387
2390
2393
2395 """
2396 omero_model_DatasetI class wrapper extends BlitzObjectWrapper.
2397 """
2398
2404
2406 super(_DatasetWrapper, self).__loadedHotSwap__()
2407 if not self._obj.isImageLinksLoaded():
2408 links = self._conn.getQueryService().findAllByQuery("select l from DatasetImageLink as l join fetch l.child as a where l.parent.id=%i" % (self._oid), None)
2409 self._obj._imageLinksLoaded = True
2410 self._obj._imageLinksSeq = links
2411
2412 DatasetWrapper = _DatasetWrapper
2415 """
2416 omero_model_ProjectI class wrapper extends BlitzObjectWrapper.
2417 """
2418
2424
2425 ProjectWrapper = _ProjectWrapper
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441 -class ColorHolder (object):
2442 """
2443 Stores color internally as (R,G,B,A) and allows setting and getting in multiple formats
2444 """
2445
2446 _color = {'red': 0, 'green': 0, 'blue': 0, 'alpha': 255}
2447
2449 self._color = {'red': 0, 'green': 0, 'blue': 0, 'alpha': 255}
2450 if colorname and colorname.lower() in self._color.keys():
2451 self._color[colorname.lower()] = 255
2452
2453 @classmethod
2461
2463 return self._color['red']
2464
2466 """
2467 Set red, as int 0..255
2468
2469 @param val: value of Red.
2470 """
2471
2472 self._color['red'] = max(min(255, int(val)), 0)
2473
2475 return self._color['green']
2476
2478 """
2479 Set green, as int 0..255
2480
2481 @param val: value of Green.
2482 """
2483
2484 self._color['green'] = max(min(255, int(val)), 0)
2485
2487 return self._color['blue']
2488
2490 """
2491 Set Blue, as int 0..255
2492
2493 @param val: value of Blue.
2494 """
2495
2496 self._color['blue'] = max(min(255, int(val)), 0)
2497
2499 return self._color['alpha']
2500
2502 """
2503 Set alpha, as int 0..255.
2504 @param val: value of alpha.
2505 """
2506
2507 self._color['alpha'] = max(min(255, int(val)), 0)
2508
2510 """
2511 @return: String. The html usable color. Dumps the alpha information.
2512 """
2513
2514 return "%(red)0.2X%(green)0.2X%(blue)0.2X" % (self._color)
2515
2517 """
2518 @return: String. rgba(r,g,b,a) for this color.
2519 """
2520
2521 c = self._color.copy()
2522 c['alpha'] /= 255.0
2523 return "rgba(%(red)i,%(green)i,%(blue)i,%(alpha)0.3f)" % (c)
2524
2526 """
2527 @return: list. A list of (r,g,b) values
2528 """
2529
2530 return (self._color['red'], self._color['green'], self._color['blue'])
2531
2533 """
2534 omero_model_LogicalChannelI class wrapper extends BlitzObjectWrapper.
2535 """
2536 _attrs = ('name',
2537 'pinHoleSize',
2538 '#illumination',
2539 'contrastMethod',
2540 'excitationWave',
2541 'emissionWave',
2542 'fluor',
2543 'ndFilter',
2544 'otf',
2545 'detectorSettings|DetectorSettingsWrapper',
2546 'lightSourceSettings|LightSettingsWrapper',
2547 'filterSet|FilterSetWrapper',
2548 'lightPath|LightPathWrapper',
2549 'samplesPerPixel',
2550 '#photometricInterpretation',
2551 'mode',
2552 'pockelCellSetting',
2553 'shapes',
2554 'version')
2555
2556 LogicalChannelWrapper = _LogicalChannelWrapper
2559 """
2560 base Light Source class wrapper, extends BlitzObjectWrapper.
2561 """
2562 _attrs = ('dichroic|DichroicWrapper')
2563
2564
2565
2568
2571
2574
2575 LightPathWrapper = _LightPathWrapper
2578 """
2579 omero_model_ChannelI class wrapper extends BlitzObjectWrapper.
2580 """
2581
2582 BLUE_MIN = 400
2583 BLUE_MAX = 500
2584 GREEN_MIN = 501
2585 GREEN_MAX = 600
2586 RED_MIN = 601
2587 RED_MAX = 700
2588 COLOR_MAP = ((BLUE_MIN, BLUE_MAX, ColorHolder('Blue')),
2589 (GREEN_MIN, GREEN_MAX, ColorHolder('Green')),
2590 (RED_MIN, RED_MAX, ColorHolder('Red')),
2591 )
2592
2595
2597 self._re = re
2598 self._idx = idx
2599 self._img = img
2600
2604
2607
2609 if self._obj.logicalChannel is not None:
2610 return LogicalChannelWrapper(self._conn, self._obj.logicalChannel)
2611
2613 lc = self.getLogicalChannel()
2614 rv = lc.name
2615 if rv is None:
2616 rv = lc.emissionWave
2617 if rv is None:
2618 rv = self._idx
2619 return rv
2620
2623
2625 return int(self._re.getChannelWindowStart(self._idx))
2626
2629
2631 return int(self._re.getChannelWindowEnd(self._idx))
2632
2635
2637 self._re.setChannelWindow(self._idx, float(minval), float(maxval))
2638
2640 return self._obj.getStatsInfo().getGlobalMin().val
2641
2643 return self._obj.getStatsInfo().getGlobalMax().val
2644
2645 ChannelWrapper = _ChannelWrapper
2648 def wrapped (self, *args, **kwargs):
2649 if not self._prepareRenderingEngine():
2650 return None
2651 return func(self, *args, **kwargs)
2652 return wrapped
2653
2655 def wrapped (self, *args, **kwargs):
2656 if not self._loadPixels():
2657 return None
2658 return func(self, *args, **kwargs)
2659 return wrapped
2660
2663 """
2664 omero_model_ImageI class wrapper extends BlitzObjectWrapper.
2665 """
2666
2667 _re = None
2668 _pd = None
2669 _rm = {}
2670 _pixels = None
2671
2672 _pr = None
2673
2674 PROJECTIONS = {
2675 'normal': -1,
2676 'intmax': omero.constants.projection.ProjectionType.MAXIMUMINTENSITY,
2677 'intmean': omero.constants.projection.ProjectionType.MEANINTENSITY,
2678 'intsum': omero.constants.projection.ProjectionType.SUMINTENSITY,
2679 }
2680
2681 PLANEDEF = omero.romio.XY
2682
2683 @classmethod
2685 q = conn.getQueryService()
2686 p = q.find('Pixels', pid)
2687 if p is None:
2688 return None
2689 return ImageWrapper(conn, p.image)
2690
2696
2699
2702
2704 i = self._obj.instrument
2705 if i is None:
2706 return None
2707 if not i.loaded:
2708 self._obj.instrument = self._conn.getQueryService().find('Instrument', i.id.val)
2709 i = self._obj.instrument
2710 meta_serv = self._conn.getMetadataService()
2711 for e in meta_serv.loadInstrument(i.id.val):
2712 if isinstance(e, omero.model.DetectorI):
2713 i._detectorSeq.append(e)
2714 elif isinstance(e, omero.model.ObjectiveI):
2715 i._objectiveSeq.append(e)
2716 elif isinstance(e, omero.model.LightSource):
2717 i._lightSourceSeq.append(e)
2718 elif isinstance(e, omero.model.FilterI):
2719 i._filterSeq.append(e)
2720 elif isinstance(e, omero.model.DichroicI):
2721 i._dichroicSeq.append(e)
2722 elif isinstance(e, omero.model.FilterSetI):
2723 i._filterSetSeq.append(e)
2724 elif isinstance(e, omero.model.OTFI):
2725 i._otfSeq.append(e)
2726 elif isinstance(e, omero.model.InstrumentI):
2727 pass
2728 else:
2729 logger.info("Unknown instrument entry: %s" % str(e))
2730 return InstrumentWrapper(self._conn, i)
2731
2733 if not self._obj.pixelsLoaded:
2734 self.__loadedHotSwap__()
2735 return self._obj.sizeOfPixels() > 0
2736
2738 re = self._conn.createRenderingEngine()
2739 pixels_id = self._obj.getPrimaryPixels().id.val
2740 re.lookupPixels(pixels_id)
2741 if re.lookupRenderingDef(pixels_id) == False:
2742 try:
2743 re.resetDefaults()
2744 except omero.ResourceError:
2745
2746 return False
2747 re.lookupRenderingDef(pixels_id)
2748 re.load()
2749 return re
2750
2760
2767
2769 rv = super(_ImageWrapper, self).simpleMarshal(xtra=xtra, parents=parents)
2770 rv.update({'author': self.getAuthor(),
2771 'date': time.mktime(self.getDate().timetuple()),})
2772 if xtra:
2773 if xtra.has_key('thumbUrlPrefix'):
2774 if callable(xtra['thumbUrlPrefix']):
2775 rv['thumb_url'] = xtra['thumbUrlPrefix'](str(self.id))
2776 else:
2777 rv['thumb_url'] = xtra['thumbUrlPrefix'] + str(self.id) + '/'
2778 return rv
2779
2781 if self._obj.stageLabel is None:
2782 return None
2783 else:
2784 return ImageStageLabelWrapper(self._conn, self._obj.stageLabel)
2785
2787 name = self.name
2788 if not name:
2789 return ""
2790 l = len(name)
2791 if l < length+hist:
2792 return name
2793 return "..." + name[l - length:]
2794
2796 q = self._conn.getQueryService()
2797 e = q.findByQuery("select e from Experimenter e where e.id = %i" % self._obj.details.owner.id.val,None)
2798 self._author = e.firstName.val + " " + e.lastName.val
2799 return self._author
2800
2802 try:
2803 q = """
2804 select ds from Image i join i.datasetLinks dl join dl.parent ds
2805 where i.id = %i
2806 """ % self._obj.id.val
2807 query = self._conn.getQueryService()
2808 ds = query.findByQuery(q,None)
2809 return ds and DatasetWrapper(self._conn, ds) or None
2810 except:
2811 logger.debug('on getDataset')
2812 logger.debug(traceback.format_exc())
2813 return None
2814
2816 try:
2817 q = """
2818 select p from Image i join i.datasetLinks dl join dl.parent ds join ds.projectLinks pl join pl.parent p
2819 where i.id = %i
2820 """ % self._obj.id.val
2821 query = self._conn.getQueryService()
2822 prj = query.findByQuery(q,None)
2823 return prj and ProjectWrapper(self._conn, prj) or None
2824 except:
2825 logger.debug('on getProject')
2826 logger.debug(traceback.format_exc())
2827 return None
2828
2830 try:
2831 query = self._conn.getQueryService()
2832 event = query.findByQuery("select e from Event e where id = %i" % self._obj.details.creationEvent.id.val, None)
2833 return datetime.fromtimestamp(event.time.val / 1000)
2834 except:
2835 logger.debug('on getDate')
2836 logger.debug(traceback.format_exc())
2837
2838 return datetime.fromtimestamp(event.time.val / 1000)
2839
2841 rv = self.objectiveSettings
2842 if self.objectiveSettings is not None:
2843 rv = ObjectiveSettingsWrapper(self._conn, self.objectiveSettings)
2844 if not self.objectiveSettings.loaded:
2845 self.objectiveSettings = rv._obj
2846 return rv
2847
2849 rv = self.imagingEnvironment
2850 if self.imagingEnvironment is not None:
2851 rv = ImagingEnvironmentWrapper(self._conn, self.imagingEnvironment)
2852 if not self.imagingEnvironment.loaded:
2853 self.imagingEnvironment = rv._obj
2854 return rv
2855
2856 @assert_pixels
2859
2860 @assert_pixels
2863
2865 pixels_id = self.getPixelsId()
2866 if pixels_id is None:
2867 return None
2868 tb = self._conn.createThumbnailStore()
2869 try:
2870 rv = tb.setPixelsId(pixels_id)
2871 except omero.InternalException:
2872 logger.error(traceback.print_exc())
2873 rv = False
2874 if not rv:
2875 tb.resetDefaults()
2876 tb.close()
2877 tb.setPixelsId(pixels_id)
2878 return tb
2879
2905
2907 try:
2908 tb = self._prepareTB()
2909 if tb is None:
2910 return None
2911 if isinstance(size, IntType):
2912 size = (size,)
2913 if z is not None and t is not None:
2914 pos = z,t
2915 else:
2916 pos = None
2917 if len(size) == 1:
2918 if pos is None:
2919 thumb = tb.getThumbnailByLongestSideDirect
2920 else:
2921 thumb = tb.getThumbnailForSectionByLongestSideDirect
2922 else:
2923 if pos is None:
2924 thumb = tb.getThumbnailDirect
2925 else:
2926 thumb = tb.getThumbnailForSectionDirect
2927 args = map(lambda x: rint(x), size)
2928 if pos is not None:
2929 args = list(pos) + args
2930 rv = thumb(*args)
2931 return rv
2932 except Exception:
2933 logger.error(traceback.print_exc())
2934 return None
2935
2936 @assert_pixels
2938 """ Returns (min, max) values for the pixels type of this image.
2939 TODO: Does not handle floats correctly, though."""
2940 pixels_id = self._obj.getPrimaryPixels().getId().val
2941 rp = self._conn.createRawPixelsStore()
2942 rp.setPixelsId(pixels_id, True)
2943 pmax = 2 ** (8 * rp.getByteWidth())
2944 if rp.isSigned():
2945 return (-(pmax / 2), pmax / 2 - 1)
2946 else:
2947 return (0, pmax-1)
2948
2949 @assert_re
2951 return [ChannelWrapper(self._conn, c, idx=n, re=self._re, img=self) for n,c in enumerate(self._re.getPixels().iterateChannels())]
2952
2954 for c in range(len(self.getChannels())):
2955 self._re.setActive(c, (c+1) in channels)
2956 if (c+1) in channels:
2957 if windows is not None and windows[c][0] is not None and windows[c][1] is not None:
2958 self._re.setChannelWindow(c, *windows[c])
2959 if colors is not None and colors[c]:
2960 rgba = splitHTMLColor(colors[c])
2961 if rgba:
2962 self._re.setRGBA(c, *rgba)
2963 return True
2964
2967
2970
2971 LINE_PLOT_DTYPES = {
2972 (4, True, True): 'f',
2973 (2, False, False): 'H',
2974 (2, False, True): 'h',
2975 (1, False, False): 'B',
2976 (1, False, True): 'b',
2977 }
2978
2979 - def getPixelLine (self, z, t, pos, axis, channels=None, range=None):
2980 """
2981 Grab a horizontal or vertical line from the image pixel data, for the specified channels
2982 (or all if not specified) and using the specified range (or 1:1 relative to the image size).
2983 Axis may be 'h' or 'v', for horizontal or vertical respectively.
2984
2985 @param z:
2986 @param t:
2987 @param pos:
2988 @param axis:
2989 @param channels:
2990 @param range:
2991 @return: rv
2992 """
2993
2994 if not self._loadPixels():
2995 logger.debug( "No pixels!")
2996 return None
2997 axis = axis.lower()[:1]
2998 if channels is None:
2999 channels = map(lambda x: x._idx, filter(lambda x: x.isActive(), self.getChannels()))
3000 if range is None:
3001 range = axis == 'h' and self.getHeight() or self.getWidth()
3002 if not isinstance(channels, (TupleType, ListType)):
3003 channels = (channels,)
3004 chw = map(lambda x: (x.getWindowMin(), x.getWindowMax()), self.getChannels())
3005 rv = []
3006 pixels_id = self._obj.getPrimaryPixels().getId().val
3007 rp = self._conn.createRawPixelsStore()
3008 rp.setPixelsId(pixels_id, True)
3009 for c in channels:
3010 bw = rp.getByteWidth()
3011 key = self.LINE_PLOT_DTYPES.get((bw, rp.isFloat(), rp.isSigned()), None)
3012 if key is None:
3013 logger.error("Unknown data type: " + str((bw, rp.isFloat(), rp.isSigned())))
3014 plot = array.array(key, axis == 'h' and rp.getRow(pos, z, c, t) or rp.getCol(pos, z, c, t))
3015 plot.byteswap()
3016
3017 offset = -chw[c][0]
3018 if offset != 0:
3019 plot = map(lambda x: x+offset, plot)
3020 normalize = 1.0/chw[c][1]*(range-1)
3021 if normalize != 1.0:
3022 plot = map(lambda x: x*normalize, plot)
3023 if isinstance(plot, array.array):
3024 plot = plot.tolist()
3025 rv.append(plot)
3026 return rv
3027
3028
3029 - def getRow (self, z, t, y, channels=None, range=None):
3031
3032 - def getCol (self, z, t, x, channels=None, range=None):
3034
3035 @assert_re
3037 if not len(self._rm):
3038 for m in [BlitzObjectWrapper(self._conn, m) for m in self._re.getAvailableModels()]:
3039 self._rm[m.value.lower()] = m
3040 return self._rm.values()
3041
3042 @assert_re
3045
3047 """
3048 Sets the Greyscale rendering model on this image's current renderer
3049 """
3050
3051 rm = self.getRenderingModels()
3052 self._re.setModel(self._rm.get('greyscale', rm[0])._obj)
3053
3055 """
3056 Sets the HSB rendering model on this image's current renderer
3057 """
3058
3059 rm = self.getRenderingModels()
3060 self._re.setModel(self._rm.get('rgb', rm[0])._obj)
3061
3064
3065 @assert_re
3067 self._pd.z = long(z)
3068 self._pd.t = long(t)
3069 try:
3070 if compression is not None:
3071 try:
3072 self._re.setCompressionLevel(float(compression))
3073 except omero.SecurityViolation:
3074 self._obj.clearPixels()
3075 self._obj.pixelsLoaded = False
3076 self._re = None
3077 return self.renderJpeg(z,t,None)
3078 projection = self.PROJECTIONS.get(self._pr, -1)
3079 if not isinstance(projection, omero.constants.projection.ProjectionType):
3080 rv = self._re.renderCompressed(self._pd)
3081 else:
3082 rv = self._re.renderProjectedCompressed(projection, self._pd.t, 1, 0, self.z_count()-1)
3083 return rv
3084 except omero.InternalException:
3085 logger.debug('On renderJpeg');
3086 logger.debug(traceback.format_exc())
3087 return None
3088 except Ice.MemoryLimitException:
3089
3090 self._obj.clearPixels()
3091 self._obj.pixelsLoaded = False
3092 self._re = None
3093 raise
3094
3096 e = self._conn.createExporter()
3097 e.addImage(self.getId())
3098 size = e.generateTiff()
3099 p = 0
3100 rv = ''
3101 while p < size:
3102 s = min(65536, size-p)
3103 rv += e.read(p,s)
3104 p += s
3105 e.close()
3106 return rv
3107
3109 rv = self.renderJpeg(z,t,compression)
3110 if rv is not None:
3111 i = StringIO(rv)
3112 rv = Image.open(i)
3113 return rv
3114
3116 """
3117 Prepares a jpeg representation of a 2d grid holding a render of each channel,
3118 along with one for all channels at the set Z and T points.
3119
3120 @param z:
3121 @param t:
3122 @param compression:
3123 @param border:
3124 @return: value
3125 """
3126
3127 img = self.renderSplitChannelImage(z,t,compression, border)
3128 rv = StringIO()
3129 img.save(rv, 'jpeg', quality=int(compression*100))
3130 return rv.getvalue()
3131
3133 c = self.c_count()
3134
3135 x = sqrt(c)
3136 y = int(round(x))
3137 if x > y:
3138 x = y+1
3139 else:
3140 x = y
3141 rv = {'g':{'width': self.getWidth()*x + border*(x+1),
3142 'height': self.getHeight()*y+border*(y+1),
3143 'border': border,
3144 'gridx': x,
3145 'gridy': y,}
3146 }
3147
3148 c += 1
3149 x = sqrt(c)
3150 y = int(round(x))
3151 if x > y:
3152 x = y+1
3153 else:
3154 x = y
3155 rv['c'] = {'width': self.getWidth()*x + border*(x+1),
3156 'height': self.getHeight()*y+border*(y+1),
3157 'border': border,
3158 'gridx': x,
3159 'gridy': y,}
3160 return rv
3161
3163 """
3164 Prepares a PIL Image with a 2d grid holding a render of each channel,
3165 along with one for all channels at the set Z and T points.
3166
3167 @param z:
3168 @param t:
3169 @param compression:
3170 @param border:
3171 @return: canvas
3172 """
3173
3174 dims = self.splitChannelDims(border=border)[self.isGreyscaleRenderingModel() and 'g' or 'c']
3175 canvas = Image.new('RGBA', (dims['width'], dims['height']), '#fff')
3176 cmap = [ch.isActive() and i+1 or 0 for i,ch in enumerate(self.getChannels())]
3177 c = self.c_count()
3178 pxc = 0
3179 px = dims['border']
3180 py = dims['border']
3181
3182
3183 w = self.getWidth()
3184 if w >= 640:
3185 fsize = (int((w-640)/128)*8) + 24
3186 if fsize > 64:
3187 fsize = 64
3188 elif w >= 512:
3189 fsize = 24
3190 elif w >= 384:
3191 fsize = 18
3192 elif w >= 298:
3193 fsize = 14
3194 elif w >= 256:
3195 fsize = 12
3196 elif w >= 213:
3197 fsize = 10
3198 elif w >= 96:
3199 fsize = 8
3200 else:
3201 fsize = 0
3202 if fsize > 0:
3203 font = ImageFont.load('%s/pilfonts/B%0.2d.pil' % (THISPATH, fsize) )
3204
3205
3206 for i in range(c):
3207 if cmap[i]:
3208 self.setActiveChannels((i+1,))
3209 img = self.renderImage(z,t, compression)
3210 if fsize > 0:
3211 draw = ImageDraw.ImageDraw(img)
3212 draw.text((2,2), "w=%s" % (str(self.getChannels()[i].getEmissionWave())), font=font, fill="#fff")
3213 canvas.paste(img, (px, py))
3214 pxc += 1
3215 if pxc < dims['gridx']:
3216 px += self.getWidth() + border
3217 else:
3218 pxc = 0
3219 px = border
3220 py += self.getHeight() + border
3221 if not self.isGreyscaleRenderingModel():
3222 self.setActiveChannels(cmap)
3223 img = self.renderImage(z,t, compression)
3224 if fsize > 0:
3225 draw = ImageDraw.ImageDraw(img)
3226 draw.text((2,2), "combined", font=font, fill="#fff")
3227 canvas.paste(img, (px, py))
3228 return canvas
3229
3230 LP_PALLETE = [0,0,0,0,0,0,255,255,255]
3231 LP_TRANSPARENT = 0
3232 LP_BGCOLOR = 1
3233 LP_FGCOLOR = 2
3235 """
3236 Common part of horizontal and vertical line plot rendering.
3237 @returns: (Image, width, height).
3238 """
3239 channels = filter(lambda x: x.isActive(), self.getChannels())
3240 width = self.getWidth()
3241 height = self.getHeight()
3242
3243 pal = list(self.LP_PALLETE)
3244
3245 for channel in channels:
3246 pal.extend(channel.getColor().getRGB())
3247
3248
3249 im = Image.new('P', (width, height))
3250 im.putpalette(pal)
3251 return im, width, height
3252
3253
3254 @assert_re
3256 self._pd.z = long(z)
3257 self._pd.t = long(t)
3258
3259 im, width, height = self.prepareLinePlotCanvas(z,t)
3260 base = height - 1
3261
3262 draw = ImageDraw.ImageDraw(im)
3263
3264 draw.rectangle([0, 0, width-1, base], fill=self.LP_TRANSPARENT, outline=self.LP_TRANSPARENT)
3265 draw.line(((0,y),(width, y)), fill=self.LP_FGCOLOR, width=linewidth)
3266
3267
3268 rows = self.getRow(z,t,y)
3269
3270 for r in range(len(rows)):
3271 chrow = rows[r]
3272 color = r + self.LP_FGCOLOR + 1
3273 last_point = base-chrow[0]
3274 for i in range(len(chrow)):
3275 draw.line(((i, last_point), (i, base-chrow[i])), fill=color, width=linewidth)
3276 last_point = base-chrow[i]
3277 del draw
3278 out = StringIO()
3279 im.save(out, format="gif", transparency=0)
3280 return out.getvalue()
3281
3282 @assert_re
3284 self._pd.z = long(z)
3285 self._pd.t = long(t)
3286
3287 im, width, height = self.prepareLinePlotCanvas(z,t)
3288
3289 draw = ImageDraw.ImageDraw(im)
3290
3291 draw.rectangle([0, 0, width-1, height-1], fill=self.LP_TRANSPARENT, outline=self.LP_TRANSPARENT)
3292 draw.line(((x,0),(x, height)), fill=self.LP_FGCOLOR, width=linewidth)
3293
3294
3295 cols = self.getCol(z,t,x)
3296
3297 for r in range(len(cols)):
3298 chcol = cols[r]
3299 color = r + self.LP_FGCOLOR + 1
3300 last_point = chcol[0]
3301 for i in range(len(chcol)):
3302 draw.line(((last_point, i), (chcol[i], i)), fill=color, width=linewidth)
3303 last_point = chcol[i]
3304 del draw
3305 out = StringIO()
3306 im.save(out, format="gif", transparency=0)
3307 return out.getvalue()
3308
3309 @assert_re
3312
3313 @assert_re
3316
3317 @assert_pixels
3319 rv = self._obj.getPrimaryPixels().getPhysicalSizeX()
3320 return rv is not None and rv.val or 0
3321
3322 @assert_pixels
3324 rv = self._obj.getPrimaryPixels().getPhysicalSizeY()
3325 return rv is not None and rv.val or 0
3326
3327 @assert_pixels
3329 rv = self._obj.getPrimaryPixels().getPhysicalSizeZ()
3330 return rv is not None and rv.val or 0
3331
3332 @assert_pixels
3335
3336 @assert_pixels
3339
3340 @assert_pixels
3343
3344 @assert_pixels
3347
3348 @assert_pixels
3351
3353 """
3354 Removes specific color settings from channels
3355
3356 @return: Boolean
3357 """
3358
3359 if not self.canWrite():
3360 return False
3361 for c in self.getChannels():
3362 c.unloadRed()
3363 c.unloadGreen()
3364 c.unloadBlue()
3365 c.unloadAlpha()
3366 c.save()
3367 self._conn.getDeleteService().deleteSettings(self.getId())
3368 return True
3369
3370 @assert_re
3372 """
3373 Limited support for saving the current prepared image rendering defs.
3374 Right now only channel colors are saved back.
3375
3376 @return: Boolean
3377 """
3378
3379 if not self.canWrite():
3380 return False
3381 self._re.saveCurrentSettings()
3382 return True
3383
3384 ImageWrapper = _ImageWrapper
3390
3391 ImageStageLabelWrapper = _ImageStageLabelWrapper
3395
3396 ImagingEnvironmentWrapper = _ImagingEnvironmentWrapper
3399 """
3400 omero_model_ImagingEnvironmentI class wrapper extends BlitzObjectWrapper.
3401 """
3402 _attrs = ('temperature',
3403 'airPressure',
3404 'humidity',
3405 'co2percent',
3406 'version')
3407
3410
3411 ImagingEnviromentWrapper = _ImagingEnviromentWrapper
3414 """
3415 omero_model_TransmittanceRangeI class wrapper extends BlitzObjectWrapper.
3416 """
3417 _attrs = ('cutIn',
3418 'cutOut',
3419 'cutInTolerance',
3420 'cutOutTolerance',
3421 'transmittance',
3422 'version')
3423
3426
3427 TransmittanceRangeWrapper = _TransmittanceRangeWrapper
3430 """
3431 omero_model_DetectorSettingsI class wrapper extends BlitzObjectWrapper.
3432 """
3433 _attrs = ('voltage',
3434 'gain',
3435 'offsetValue',
3436 'readOutRate',
3437 'binning',
3438 'detector|DetectorWrapper',
3439 'version')
3440
3443
3444 DetectorSettingsWrapper = _DetectorSettingsWrapper
3447 """
3448 omero_model_DetectorI class wrapper extends BlitzObjectWrapper.
3449 """
3450 _attrs = ('manufacturer',
3451 'model',
3452 'serialNumber',
3453 'voltage',
3454 'gain',
3455 'offsetValue',
3456 'zoom',
3457 'amplificationGain',
3458 '#type;detectorType',
3459 'version')
3460
3463
3464 DetectorWrapper = _DetectorWrapper
3467 """
3468 omero_model_ObjectiveI class wrapper extends BlitzObjectWrapper.
3469 """
3470 _attrs = ('manufacturer',
3471 'model',
3472 'serialNumber',
3473 'nominalMagnification',
3474 'calibratedMagnification',
3475 'lensNA',
3476 '#immersion',
3477 '#correction',
3478 'workingDistance',
3479 'iris',
3480 'version')
3481
3484
3485 ObjectiveWrapper = _ObjectiveWrapper
3488 """
3489 omero_model_ObjectiveSettingsI class wrapper extends BlitzObjectWrapper.
3490 """
3491 _attrs = ('correctionCollar',
3492 'medium',
3493 'refractiveIndex',
3494 'objective|ObjectiveWrapper',
3495 'version')
3496
3499
3501 rv = self.objective
3502 if self.objective is not None:
3503 rv = ObjectiveWrapper(self._conn, self.objective)
3504 if not self.objective.loaded:
3505 self.objective = rv._obj
3506 return rv
3507
3508 ObjectiveSettingsWrapper = _ObjectiveSettingsWrapper
3512 """
3513 omero_model_FilterI class wrapper extends BlitzObjectWrapper.
3514 """
3515 _attrs = ('manufacturer',
3516 'model',
3517 'lotNumber',
3518 'filterWheel',
3519 'type;filterType',
3520 'transmittanceRange|TransmittanceRangeWrapper',
3521 'version')
3522
3525
3526 FilterWrapper = _FilterWrapper
3529 """
3530 omero_model_DichroicI class wrapper extends BlitzObjectWrapper.
3531 """
3532 _attrs = ('manufacturer',
3533 'model',
3534 'lotNumber',
3535 'version')
3536
3539
3540 DichroicWrapper = _DichroicWrapper
3543 """
3544 omero_model_FilterSetI class wrapper extends BlitzObjectWrapper.
3545 """
3546 _attrs = ('manufacturer',
3547 'model',
3548 'lotNumber',
3549
3550
3551 'dichroic|DichroicWrapper',
3552 'version')
3553
3556
3559
3562
3563 FilterSetWrapper = _FilterSetWrapper
3566 """
3567 omero_model_OTFI class wrapper extends BlitzObjectWrapper.
3568 """
3569 _attrs = ('sizeX',
3570 'sizeY',
3571 'opticalAxisAveraged'
3572 'pixelsType',
3573 'path',
3574 'filterSet|FilterSetWrapper',
3575 'objective|ObjectiveWrapper',
3576 'version')
3577
3580
3581 OTFWrapper = _OTFWrapper
3584 """
3585 base Light Source class wrapper, extends BlitzObjectWrapper.
3586 """
3587 _attrs = ('attenuation',
3588 'wavelength',
3589 'lightSource|LightSourceWrapper',
3590 'microbeamManipulation',
3591 'version')
3592
3595
3596 LightSettingsWrapper = _LightSettingsWrapper
3599 """
3600 base Light Source class wrapper, extends BlitzObjectWrapper.
3601 """
3602 _attrs = ('manufacturer',
3603 'model',
3604 'power',
3605 'serialNumber',
3606 '#type;lightsourceType',
3607 'version')
3608
3609 _LightSourceClasses = {}
3615
3617 """
3618 omero_model_ArcI class wrapper extends LightSourceWrapper.
3619 """
3620
3624
3625 FilamentWrapper = _FilamentWrapper
3626 _LightSourceClasses[omero.model.FilamentI] = 'FilamentWrapper'
3629 """
3630 omero_model_ArcI class wrapper extends FilamentWrapper.
3631 """
3635
3636 ArcWrapper = _ArcWrapper
3637 _LightSourceClasses[omero.model.ArcI] = 'ArcWrapper'
3640 """
3641 omero_model_LaserI class wrapper extends LightSourceWrapper.
3642 """
3644 super(self.__class__, self).__bstrap__()
3645 self.OMERO_CLASS = 'Laser'
3646 self._attrs += (
3647 '#laserMedium',
3648 'frequencyMultiplication',
3649 'tuneable',
3650 'pulse',
3651 'wavelength',
3652 'pockelCell',
3653 'pump',
3654 'repetitionRate')
3655
3656 LaserWrapper = _LaserWrapper
3657 _LightSourceClasses[omero.model.LaserI] = 'LaserWrapper'
3660 """
3661 omero_model_LightEmittingDiodeI class wrapper extends LightSourceWrapper.
3662 """
3666
3667 LightEmittingDiodeWrapper = _LightEmittingDiodeWrapper
3668 _LightSourceClasses[omero.model.LightEmittingDiodeI] = 'LightEmittingDiodeWrapper'
3671 """
3672 omero_model_MicroscopeI class wrapper extends BlitzObjectWrapper.
3673 """
3674 _attrs = ('manufacturer',
3675 'model',
3676 'serialNumber',
3677 '#type;microscopeType',
3678 'version')
3679
3682
3683 MicroscopeWrapper = _MicroscopeWrapper
3686 """
3687 omero_model_InstrumentI class wrapper extends BlitzObjectWrapper.
3688 """
3689
3690
3691
3692 _attrs = ('microscope|MicroscopeWrapper',)
3693
3696
3698 if self._obj.microscope is not None:
3699 return MicroscopeWrapper(self._conn, self._obj.microscope)
3700 return None
3701
3703 return [DetectorWrapper(self._conn, x) for x in self._detectorSeq]
3704
3706 return [ObjectiveWrapper(self._conn, x) for x in self._objectiveSeq]
3707
3709 return [FilterWrapper(self._conn, x) for x in self._filterSeq]
3710
3712 return [DichroicWrapper(self._conn, x) for x in self._dichroicSeq]
3713
3715 return [FilterSetWrapper(self._conn, x) for x in self._filterSetSeq]
3716
3718 return [OTFWrapper(self._conn, x) for x in self._otfSeq]
3719
3722
3723
3737
3738 InstrumentWrapper = _InstrumentWrapper
3739