def cycle_(self):
# NOTE: enable this to see if your multiprocess is alive
self.logger.debug("cycle_ starts")
index, meta = self.client.pullFrame()
if (index is None):
self.logger.debug("cycle_ : client timed out..")
return
self.logger.debug("cycle_ : client index = %s", index)
if meta.size < 1:
return
data = self.client.shmem_list[index][0:meta.size]
img = data.reshape((meta.height, meta.width, 3))
""" # WARNING: the x-server doesn't like this, i.e., we're creating a window from a separate python multiprocess, so the program will crash
print(self.pre,"Visualizing with OpenCV")
cv2.imshow("openCV_window",img)
cv2.waitKey(1)
"""
self.logger.debug("cycle_ : got frame %s", img.shape)
result = self.analyzer(img)
img_ = img.copy()
if self.parameters:
# what we have in parameters, depends on the
# analyzer video widget class, i.e. on the widget that
# interacts with the user for defining the machine vision parameters
# the class is defined in the class member "analyzer_video_widget_class"
# and instantiated by MVisionContainer
# here we're using
# valkka.live.qt.widget.LineCrossingVideoWidget
if "line" in self.parameters:
line = self.parameters["line"]
# print("line",line)
start = (int(line[0][0] * img_.shape[1]),
int((line[0][1]) * img_.shape[0]))
end = (int(line[1][0] * img_.shape[1]),
int((line[1][1]) * img_.shape[0]))
# print("start", start)
# print("end",end)
# # cross-check the line defined in the interactive qt widget
cv2.line(img_, start, end, (0, 255, 0), 8)
if self.qt_server is not None:
self.logger.info("cycle_ : pushing frame to server")
# print(">>", img_[0:10])
self.qt_server.pushFrame(img_, meta.slot, meta.mstimestamp)
# NOTE: you could use and combine several analyzers here, say first see if there is movement and then do the rest
# print(self.pre,">>>",data[0:10])
if (result == MovementDetector.state_same):
pass
elif (result == MovementDetector.state_start):
self.send_out__(MessageObject("start_move"))
elif (result == MovementDetector.state_stop):
self.send_out__(MessageObject("stop_move"))
def activate(self, **kwargs):
# save values to front-end also:
self.shmem_name = kwargs["shmem_name"]
self.n_buffer = kwargs["n_buffer"]
self.image_dimensions = kwargs["image_dimensions"]
# this sets the values at back-end:
self.sendMessageToBack(MessageObject("activate", **kwargs))
def cycle_(self):
# NOTE: enable this to see if your multiprocess is alive
self.logger.info("cycle_ starts")
"""
index, isize = self.client.pull()
if (index is None):
self.logger.info("Client timed out..")
pass
else:
self.logger.info("Client index, size =",index, isize)
data = self.client.shmem_list[index]
img = data.reshape(
(self.image_dimensions[1], self.image_dimensions[0], 3))
result = self.analyzer(img)
"""
index, meta = self.client.pullFrame()
if (index is None):
self.logger.debug("Client timed out..")
return
self.logger.debug("Client index = %s", index)
if meta.size < 1:
return
data = self.client.shmem_list[index][0:meta.size]
img = data.reshape((meta.height, meta.width, 3))
self.logger.debug("got frame %s", img.shape)
result = self.analyzer(img) # does something .. returns something ..
if self.qt_server is not None:
self.logger.info("pushing frame to server")
self.qt_server.pushFrame(img, meta.slot, meta.mstimestamp)
if (result != ""):
self.send_out__(MessageObject("text", message=result))
def unregisterClient(self, **kwargs):
self.n_clients -= 1
if self.n_clients < 1:
self.n_clients = 0
self.sendMessageToBack(MessageObject("unregisterClient", **kwargs))
self.logger.debug(
"unregisterClient: frontend: number of clients is %s",
self.n_clients)
def unsetMasterProcess(self): # , master_process):
if self.master_process is None:
self.logger.warning("unsetMasterProcess: none set")
return
self.sendMessageToBack(MessageObject("unsetMasterProcess"))
self.master_process.unregisterClient(ipc_index=self.ipc_index)
singleton.ipc.release(self.ipc_index)
self.ipc_index = None
self.master_process = None
def registerClient(self, **kwargs):
# keep the books on number of clients at frontend as well
self.n_clients += 1
if self.n_clients > self.max_clients:
self.logger.warning("no more clients available: max is %s",
self.max_clients)
self.n_clients = self.max_clients
return
self.sendMessageToBack(MessageObject("registerClient", **kwargs))
self.logger.debug("registerClient: frontend: number of clients is %s",
self.n_clients)
def setMasterProcess(self, master_process=None):
# ipc_index, n_buffer, image_dimensions, shmem_name # TODO
self.master_process = master_process
self.ipc_index = singleton.ipc.reserve()
# first, create the server
self.sendMessageToBack(
MessageObject("setMasterProcess", ipc_index=self.ipc_index))
# this will create the client:
# self.n_buffer etc. have been set by call to self.activate
master_process.registerClient(ipc_index=self.ipc_index,
n_buffer=self.n_buffer,
image_dimensions=self.image_dimensions,
shmem_name=self.shmem_name_server)
def c__requestQtShmemServer(self, **kwargs):
self.logger.debug("shmem server requested")
# should be called only after the shmem client has been instantiated
self.shmem_name_qt_server = self.shmem_name + "_qt_server"
self.qt_server = ShmemRGBServer(
name=self.shmem_name_qt_server,
n_ringbuffer=self.n_buffer, # size of ring buffer
width=self.image_dimensions[0],
height=self.image_dimensions[1],
verbose=self.shmem_verbose)
# inform frontend & widgets that the shmem server is available:
self.send_out__(
MessageObject(
"shmem_server", # this is routed to the qt signal with the same name
shmem_name=self.shmem_name_qt_server,
shmem_n_buffer=self.n_buffer,
width=self.image_dimensions[0],
height=self.image_dimensions[1],
verbose=self.shmem_verbose))
def releaseQtShmemServer(self):
kwargs = {}
self.sendMessageToBack(MessageObject("releaseQtShmemServer", **kwargs))
def updateAnalyzerParameters(self, kwargs):
self.parameters = kwargs
self.logger.debug("updateAnalyzerParameters %s", kwargs)
self.sendMessageToBack(
MessageObject("updateAnalyzerParameters", **kwargs))
def c__ping(self, message=""):
print("c__ping:", message)
self.send_out__(MessageObject("pong", lis=[1, 2, 3]))
def ping(self, message=""):
"""Test call
"""
self.sendMessageToBack(MessageObject("ping", message=message))
def deactivate(self):
self.sendMessageToBack(MessageObject("deactivate"))
def cycle_(self):
lis=[]
self.logger.debug("cycle_ starts")
""" old API
index, isize = self.client.pull()
if (index is None):
self.logger.debug("Client timed out..")
pass
else:
self.logger.debug("Client index, size = %s, %s", index, isize)
data = self.client.shmem_list[index]
img = data.reshape(
(self.image_dimensions[1], self.image_dimensions[0], 3))
"""
index, meta = self.client.pullFrame()
if (index is None):
self.logger.debug("Client timed out..")
return
self.logger.debug("Client index = %s", index)
if (meta.size < 1) or (self.analyzer is None):
return
data = self.client.shmem_list[index][0:meta.size]
img = data.reshape(
(meta.height, meta.width, 3))
lis = self.analyzer(img)
if self.qt_server is not None:
self.logger.info("pushing frame to server")
self.qt_server.pushFrame(
img,
meta.slot,
meta.mstimestamp
)
"""
print("img.shape=",img.shape)
for l in lis:
print(l)
"""
""" # list looks like this:
[ ('dog', 99, 134, 313, 214, 542),
('truck', 91, 476, 684, 81, 168),
('bicycle', 99, 99, 589, 124, 447)
]
"""
object_list=[]
bbox_list=[]
for l in lis:
object_list.append(l[0])
# """
bbox_list.append((
l[2]/img.shape[1], # from pixels to fractional coordinates
l[3]/img.shape[1],
l[4]/img.shape[0],
l[5]/img.shape[0]
))
# """
if (hasattr(self, "warning_message")):
object_list.append(self.warning_message)
# print("YoloV3",bbox_list)
#if (len(lis)>0):
# self.sendSignal_(name="objects", object_list=object_list)
# self.sendSignal_(name="bboxes", bbox_list=bbox_list)
self.send_out__(MessageObject("objects", object_list = object_list))
self.send_out__(MessageObject("bboxes", bbox_list = bbox_list))
def cycle_(self):
lis = []
self.logger.debug("cycle_ starts")
index, meta = self.client.pullFrame()
if (index is None):
self.logger.debug("Client timed out..")
return
self.logger.debug("Client index = %s", index)
if meta.size < 1:
return
data = self.client.shmem_list[index][0:meta.size]
img = data.reshape((meta.height, meta.width, 3))
scale = numpy.array([meta.height, meta.width])
self.logger.debug("cycle_: got frame %s", img.shape)
img_ = img.copy()
if self.server is not None:
self.logger.debug("cycle_ : pushing to server")
self.server.pushFrame(img, meta.slot, meta.mstimestamp)
# receive results from master process
replies = self.master_pipe.recv()
self.logger.debug("reply from master process: %s", replies)
if replies is not None:
object_list = []
bbox_list = []
for reply in replies:
if isinstance(reply, str):
object_list.append(reply)
else:
tag = reply[0]
x0 = reply[1]
x1 = reply[2]
y0 = reply[3]
y1 = reply[4]
object_list.append(tag)
bbox_list.append((x0, x1, y0, y1))
# yolo: origo at left lower corner
y0 = 1 - y0 # numpy / opencv: origo at left upper corner
y1 = 1 - y1
# start: lower left corner of the box
start = (int(x0 * meta.width), int(y0 * meta.height))
# end: upper right corner of the box
end = (int(x1 * meta.width), int(y1 * meta.height))
linew = 3 # object box linewidth
label = (int(x0 * meta.width), int(y1 * meta.height) +
self.baseline + linew + 2
) # object label coordinates
"""
print(">", x0, x1, y0, y1)
print("width, height", meta.width, meta.height)
print("start", start)
print("end", end)
"""
color = (255, 0, 0)
img_ = cv2.rectangle(img_, start, end, color, linew)
cv2.putText(img_, tag, label, cv2.FONT_HERSHEY_SIMPLEX,
1, color, 2, cv2.LINE_AA)
self.send_out__(
MessageObject("objects", object_list=object_list))
self.send_out__(MessageObject("bboxes", bbox_list=bbox_list))
"""
reply can be:
- None
- A list
- a tuple
(nametag, x, y, w, h)
- string
"""
if self.qt_server is not None:
self.logger.info("pushing frame to server")
self.qt_server.pushFrame(img_, meta.slot, meta.mstimestamp)
def resetAnalyzerState(self):
print(">resetAnalyzerState")
self.sendMessageToBack(MessageObject("resetAnalyzerState", **{}))