def main(index_f, weight_f, config_f, consumerMode, th, fetchPrefix, publishPrefix): # The default Face will connect using a Unix socket, or to "localhost". instance_prefix = fetchPrefix.split("/")[-1] sl = SegmentLabel(index_f, weight_f, instance_prefix, th) if config_f != "": sl.readConfig(config_f) face = Face() keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) #stream_annConsumer_test = Namespace("/ndn/eb/stream/run/28/annotations") #stream_annConsumer_test.setFace(face) print(' > Will fetch from ' + str(fetchPrefix)) stream_annConsumer_show = Namespace(fetchPrefix) stream_annConsumer_show.setFace(face) log_f = open(str("seglab_log") + ".txt", "w") log_f.close() stream_segProducer = Namespace( Name(publishPrefix).append(Name(fetchPrefix)[-1]), keyChain) print(' > Will publish segments under ' + str(stream_segProducer.getName())) publish_handler = GeneralizedObjectStreamHandler() # publish_handler.setLatestPacketFreshnessPeriod(30) stream_segProducer.setHandler(publish_handler) stream_segProducer.setFace( face, lambda prefixName: dump("Register failed for prefix", prefixName), lambda prefixName, whatever: dump("Register success for prefix", prefixName)) def onNewAnnotation(sequenceNumber, contentMetaInfo, objectNamespace): ann = str(objectNamespace.obj) segment_result = [] jsonAnn = json.loads(ann) # print(jsonAnn["frameName"]) if not "error" in ann: jsonAnn = json.loads(ann) # print(jsonAnn["frameName"]) segment_result = sl.sceneDetection(jsonAnn) if segment_result and len(segment_result) > 0: print(segment_result) #dump("Got generalized object, sequenceNumber", sequenceNumber, # ", content-type", contentMetaInfo.getContentType(), ":", # str(jsonAnn["frameName"]), 'at', str(time.time())) publish_handler.addObject(Blob(json.dumps(segment_result)), "application/json") print(" > PUBLISHED SCENE " + str(publish_handler.getProducedSequenceNumber())) # # logging the result # if segment_result: with open(str("seglab_log") + ".txt", "w+") as f: f.write("PUBLISHED SCENE: %s" % str(publish_handler.getProducedSequenceNumber())) f.write("%s\r\n" % segment_result) pipelineSize = 0 #if consumerMode == 'default': # stream_annConsumer_default.setHandler( # GeneralizedObjectStreamHandler(pipelineSize, onNewAnnotation)).objectNeeded() stream_annConsumer_show.setHandler( GeneralizedObjectStreamHandler(pipelineSize, onNewAnnotation)).objectNeeded() #stream_annConsumer_test.setHandler( # GeneralizedObjectStreamHandler(pipelineSize, onNewAnnotation)).objectNeeded() while True: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(0.01)
def main(index_f, weight_f, consumerMode, k, query_interval, fetchPrefix, publishPrefix): # The default Face will connect using a Unix socket, or to "localhost". instance_prefix = fetchPrefix.split("/")[-1] pd = PlayDetect(index_f, weight_f, instance_prefix, k, query_interval) face = Face() keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) # sceneConsumer = Namespace("/ndn/eb/stream/run/28/annotation") engine = str(Name(fetchPrefix)[-1]) sceneFetchPrefix = Name('/eb/seglab').append(engine) print(' > Will fetch annotations from ' + fetchPrefix) print(' > Will fetch scenes from ' + sceneFetchPrefix.toUri()) sceneConsumer = Namespace(sceneFetchPrefix) sceneConsumer.setFace(face) annotationsConsumer = Namespace(fetchPrefix) #if consumerMode == "test": # annotationsConsumer = Namespace("/ndn/eb/stream/run/28/annotations") #elif consumerMode == "default": # annotationsConsumer = Namespace('/eb/proto/test/ml_processing/yolo_default') annotationsConsumer.setFace(face) log_f = open(str("playdetect_log") + ".txt", "w") log_f.close() playdetectProducer = Namespace( Name(publishPrefix).append(engine), keyChain) print(' > Will publish playdetect data under ' + playdetectProducer.getName().toUri()) playdSegmentsHandler = GeneralizedObjectStreamHandler() # set freshness to 30 # playdSegmentsHandler.setLatestPacketFreshnessPeriod(30) playdetectProducer.setHandler(playdSegmentsHandler) playdetectProducer.setFace( face, lambda prefixName: dump("Register failed for prefix", prefixName), lambda prefixName, whatever: dump("Register success for prefix", prefixName)) def onNewScene(sequenceNumber, contentMetaInfo, objectNamespace): dump("Got scene (segment) :", str(objectNamespace.getName())) if str(objectNamespace.obj): # Store scene segment AND scene segment NAME into a database sceneSegmentName = objectNamespace.getName() sceneSegment = json.loads(str(objectNamespace.obj)) pd.storeToDatabase(sceneSegmentName, sceneSegment) def onNewAnnotation(sequenceNumber, contentMetaInfo, objectNamespace): # dump("Got new annotation") stringObj = str(objectNamespace.obj) # print(stringObj) now = Common.getNowMilliseconds() if stringObj and pd.itIsTimeToQueryDatabase(): # TBD # query interval configurable itIsTimeToQueryDatabase = True if itIsTimeToQueryDatabase: # TBD # run query against the databse, using recevied annotation # the result should be a list that contains scene segment names (see above) # FOR NOW: let's have startFrame end endFrame in the results # most likely -- parameterize query, i.e. give argument maxResultNum result = pd.pickTops(json.loads(stringObj), k) if result: playdSegmentsHandler.addObject(Blob(json.dumps(result)), "application/json") print( "PUBLISH SIMILAR SCENES: %s" % str(playdSegmentsHandler.getProducedSequenceNumber())) #logging the result with open(str("playdetect_log") + ".txt", "w+") as f: f.write("PUBLISHED SCENE: %s" % str( playdSegmentsHandler.getProducedSequenceNumber())) f.write("%s\r\n" % result) pipelineSize_segConsume = 3 sceneConsumer.setHandler( GeneralizedObjectStreamHandler(pipelineSize_segConsume, onNewScene)).objectNeeded() pipelineSize_annoConsume = 3 annotationsConsumer.setHandler( GeneralizedObjectStreamHandler(pipelineSize_annoConsume, onNewAnnotation)).objectNeeded() while True: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(0.01)