def test_basic():
dataSample = DataSample(b"Hello", "String", 38)
assert dataSample.getContent().data() == b'Hello'
# get the content and modify it
c = dataSample.getContent()
c[:] = b'a' * c.size()
assert c.data() == b'aaaaa'
# but the modification is not affecting the original data
assert dataSample.getContent().data() == b'Hello'
def onPortDataChanged(self, port):
"""
Overloaded from Filter base class. The method is called whenever new data arrives at an input port.
:param port: the port which has new data.
:return:
"""
if port.getData().getDatatype() == "example/image":
# we don't (want to) have scipy or opencv in the dependency list, so we do that by hand, it is just a
# showcase
ks = self.propertyCollection().getProperty("kernelSize")
# assert odd kernel size
ks = (ks // 2) * 2 + 1
if ks > 1: # non-trivial size ?
# efficient (zero-copy) conversion
in_img = byteArrayToNumpy(port.getData().getContent())
# apply the filter
res = boxFilter(in_img, ks)
# create a DataSample instance to be transferred over the port
sample = DataSample(numpyToByteArray(res), "example/image",
port.getData().getTimestamp())
else:
# filter is no-op, we reuse the input data in this case
sample = port.getData()
# finally transmit the result
self.outPort.transmit(sample)
def test_create():
class EnvironmentMockup(object):
def addStaticPort(self, port):
pass
env = EnvironmentMockup()
filter = SimpleStaticFilter(env)
inData = DataSample(b'Hello', "bytes", 1)
filter.onPortDataChanged(filter.inPort)
def test_currentTime():
shortestDelta = math.inf
ts = time.time()
lastT = DataSample.currentTime()
factor = round(DataSample.TIMESTAMP_RES / 1e-9)
deltas = []
while time.time() - ts < 3:
t = DataSample.currentTime()
# assert that the impementation is consistent with time.time()
deltas.append(
abs(t - (time.time_ns() // factor)) * DataSample.TIMESTAMP_RES)
if t != lastT:
shortestDelta = min(t - lastT, shortestDelta)
lastT = t
# make sure that the average delta is smaller than 1 millisecond
assert sum(deltas) / len(deltas) < 1e-3
shortestDelta = shortestDelta * DataSample.TIMESTAMP_RES
# we want at least 10 microseconds resolution
print("shortestDelta: %s" % shortestDelta)
assert shortestDelta <= 1e-5
def onPortDataChanged(self, inputPort):
dataSample = inputPort.getData()
self.afterReceive(dataSample)
if dataSample.getDatatype() == "text/utf8":
logging.getLogger(__name__).info(
"received: %s",
dataSample.getContent().data().decode("utf8"))
newSample = DataSample.copy(dataSample)
time.sleep(self.sleep_time)
self.beforeTransmit(dataSample)
self.outPort.transmit(dataSample)
self.afterTransmit()
def _transmit(self, pname):
idx = self._portToIdx[pname]
# read data sample from HDF5 file
content, dataType, dataTimestamp, rcvTimestamp = self._currentFile["streams"][pname][idx]
# create sample to transmit
sample = DataSample(content.tobytes(), dataType, dataTimestamp)
res = time.perf_counter_ns()
# transmit sample over corresponding port
self._ports[[p.name() for p in self._ports].index(pname)].transmit(sample)
self._currentTimestampChanged(QDateTime.fromMSecsSinceEpoch(rcvTimestamp//1000))
if self._untilStream is not None:
if self._untilStream == pname or self._untilStream == '':
self.pausePlayback()
return res
def newDataEvent(self):
t = time.monotonic()
if self.lastSendTime is not None:
if t - self.lastSendTime < self.timeout_ms * 1e-3:
# we are still earlier than the requested framerate
return
self.lastSendTime = t
self.counter += 1
c = "Sample %d" % self.counter
s = DataSample(c.encode("utf8"), "text/utf8", int(time.time() / DataSample.TIMESTAMP_RES))
logging.getLogger(__name__).info("transmit: %s", c)
self.beforeTransmit(s)
self.outPort.transmit(s)
self.afterTransmit()
def onPortDataChanged(self, inputPort):
dataSample = inputPort.getData()
newSample = DataSample.copy(dataSample)
for p in self.dynOutPorts + [self.outPort]:
p.transmit(dataSample)
def onPortDataChanged(self, inputPort):
dataSample = inputPort.getData()
newSample = DataSample.copy(dataSample)
self.outPort.transmit(dataSample)