I'm working with structured light, and I have QCamera
and QProjector
classes I wrote. When the projector projects a pattern, it must wait for all attached cameras to capture that pattern before it moves on to the next one.
My current model is this:
QProjector
projects an image and emits signal patternProjected(Pattern*)
.QCamera
s receive the signal and connect to the projector's hold()
signal (see below). The cameras then begin to capture the image asynchronously and emit frameCaptured(cv::Mat)
when done.Previously I had a hold()
slot in QProjector
. A camera who wanted the projector to wait for it would call
connect(projector,SIGNAL(hold()),camera,SLOT(wait()))`
where camera->wait()
is a dummy function. Then, in projector->disconnectNotify()
, the projector checks to see if receivers(SIGNAL(hold()))
is zero. If it is, the projector moves on to the next pattern in its queue; if not it waits some more.
This approach is a hot mess, and it doesn't even work--there is no guarantee that the projector won't move on to the next pattern between emitting patternProjected()
and receiving the connection from the camera.
Anyone have a cleaner approach, ideally one more in line with the QObject
philosophy?
You could initialize a member variable in your QProjector
with receivers(SIGNAL(hold()))
, and every time the slot is called, you decrement it. When the counter reaches 0
, you reinitialize with receivers(SIGNAL(hold()))
and projects another pattern.
Of course, in this scenario hold()
is a terrible (non-semantic) name, you should rename it to patternRead()
or something like that.