def __init__(self, name):
model.Detector.__init__(self, name, "fakedet", parent=None)
self.data = model.DataFlow()
self._shape = (2**16, )
def __init__(self, name, role, **kwargs):
super(TimeCorrelator, self).__init__(name, role, **kwargs)
self.data = model.DataFlow()
# Data depth is 0, as we don't get the data
self._shape = (0, )
def __init__(self,
name,
role,
image,
children=None,
daemon=None,
**kwargs):
'''
children (dict string->kwargs): parameters setting for the children.
The only possible child is "focus".
They will be provided back in the .children VA
image (str or None): path to a file to use as fake image (relative to
the directory of this class)
'''
# TODO: support transpose? If not, warn that it's not accepted
# fake image setup
image = unicode(image)
# change to this directory to ensure relative path is from this file
os.chdir(os.path.dirname(unicode(__file__)))
exporter = dataio.find_fittest_exporter(image)
self._img = exporter.read_data(image)[0] # can be RGB or greyscale
# we will fill the set of children with Components later in ._children
model.DigitalCamera.__init__(self, name, role, daemon=daemon, **kwargs)
if self._img.ndim > 3: # remove dims of length 1
self._img = numpy.squeeze(self._img)
imshp = self._img.shape
if len(imshp) == 3 and imshp[0] in {3, 4}:
# CYX, change it to YXC, to simulate a RGB detector
self._img = numpy.rollaxis(self._img, 2) # XCY
self._img = numpy.rollaxis(self._img, 2) # YXC
imshp = self._img.shape
# For RGB, the colour is last dim, but we still indicate it as higher
# dimension to ensure shape always starts with X, Y
if len(imshp) == 3 and imshp[-1] in {3, 4}:
# resolution doesn't affect RGB dim
res = imshp[-2::-1]
self._shape = res + imshp[-1::] # X, Y, C
# indicate it's RGB pixel-per-pixel ordered
self._img.metadata[model.MD_DIMS] = "YXC"
else:
res = imshp[::-1]
self._shape = res # X, Y,...
# TODO: handle non integer dtypes
depth = 2**(self._img.dtype.itemsize * 8)
self._shape += (depth, )
# TODO: don't provide range? or don't make it readonly?
self.resolution = model.ResolutionVA(res,
[res, res]) # , readonly=True)
# TODO: support (simulated) binning
self.binning = model.ResolutionVA((1, 1), [(1, 1), (1, 1)])
exp = self._img.metadata.get(model.MD_EXP_TIME, 0.1) # s
self.exposureTime = model.FloatContinuous(exp, [1e-3, 1e3], unit="s")
# Some code care about the readout rate to know how long an acquisition will take
self.readoutRate = model.FloatVA(1e9, unit="Hz", readonly=True)
pxs = self._img.metadata.get(model.MD_PIXEL_SIZE, (10e-6, 10e-6))
mag = self._img.metadata.get(model.MD_LENS_MAG, 1)
spxs = tuple(s * mag for s in pxs)
self.pixelSize = model.VigilantAttribute(spxs, unit="m", readonly=True)
self._metadata = {
model.MD_HW_NAME: "FakeCam",
model.MD_SENSOR_PIXEL_SIZE: spxs
}
try:
kwargs = children["focus"]
except (KeyError, TypeError):
logging.info("Will not simulate focus")
self._focus = None
else:
self._focus = CamFocus(parent=self, daemon=daemon, **kwargs)
self.children.value = self.children.value | {self._focus}
# Simple implementation of the flow: we keep generating images and if
# there are subscribers, they'll receive it.
self.data = model.DataFlow(self)
self._generator = util.RepeatingTimer(exp, self._generate,
"SimCam image generator")
self._generator.start()