script = GifConverter(ffmpeg_bin, out_dir) while self.running(): with self.filters_lock: script.change_settings(\ self.get_parameter("smudge_length"), self.get_parameter("smudge_opacity") ) data = video_input.read() print data try: data = json.loads(data) req_keys = ['path', 'w', 'h', 'frames'] if not all(k in data for k in req_keys): raise Exception('Incorrect json keys') # print '>> OK !' file_path, w, h, frames = data['path'], int(data['w']), int( data['h']), int(data['frames']) print[file_path, w, h, frames] script(file_path, w, h, frames) except Exception as e: print 'Read/parse error %s: "%s"' % (type(e), e) if __name__ == "__main__": if len(sys.argv) < 2: print 'Please provide ffmpeg executable path as first argument' exit() config_name = os.path.join(os.path.dirname(__file__), "service.json") sc = ServiceController(GifConvertService, config_name) sc.start()
def declare_inputs(self): """deklaracja wejść""" #deklaracja wejścia "videoInput" będącego interfejsem wyjściowym konektora msg_stream_connector self.declare_input("videoInput", InputMessageConnector(self)) def run(self): """główna metoda usługi""" video_input = self.get_input( "videoInput") #obiekt interfejsu wejściowego video_output = self.get_output( "videoOutput") #obiekt interfejsu wyjściowego #pętla główna usługi while self.running(): frame_obj = video_input.read( ) #odebranie danych z interfejsu wejściowego frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy frame_luv = cv2.cvtColor(frame, cv2.COLOR_RGB2LUV) video_output.send(frame_luv.dumps( )) #przesłanie ramki za pomocą interfejsu wyjściowego if __name__ == "__main__": #utworzenie obiektu kontrolera usługi config_name = os.path.join( os.path.dirname(__file__), "service.json") # f.e. src\mark_frame_service\service.json sc = ServiceController(ColorspaceToLuvService, config_name) sc.start() #uruchomienie usługi
) #uruchomienie wątku obsługującego strumień sterujący video_input = self.get_input( "videoInput") #obiekt interfejsu wejściowego video_output_master = self.get_output( "videoOutputMaster") #obiekt interfejsu wyjściowego video_output_output = self.get_output( "videoOutputOutput") #obiekt interfejsu wyjściowego while self.running(): #pętla główna usługi frame_obj = video_input.read( ) #odebranie danych z interfejsu wejściowego frame = np.loads(frame_obj) # załadowanie ramki do obiektu NumPy frame = cv2.flip(frame, 1) # odwrócenie ramki w poziomie frame = cv2.cvtColor( frame, cv2.COLOR_BGR2RGBA) # przywrocenie naturalnych kolorów frame = frame.dumps() video_output_output.send(frame) # przesłąnie obrazu na wyjście video_output_master.send( frame ) # przesłanie obrazu do mastera do kolejnego przetwarzania if __name__ == "__main__": sc = ServiceController( PreprocessingService, "preprocessingService.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
) #odebranie danych z interfejsu wejściowego self.frame = np.loads( frame_obj) #załadowanie ramki do obiektu NumPy if self.authorization == 1: # Detect faces in the image faces = self.faceCascade.detectMultiScale( self.frame, scaleFactor=1.2, minNeighbors=5, minSize=(100, 100), flags=cv2.cv.CV_HAAR_SCALE_IMAGE) if len(faces) > 0: self.face = faces[0] (x, y, w, h) = self.face cv2.rectangle(self.frame, (x, y), (x + w, y + h), (0, 255, 0), 2) else: self.face = None video_output.send(self.frame.dumps( )) #przesłanie ramki za pomocą interfejsu wyjściowego if __name__ == "__main__": sc = ServiceController( FaceRecognitionService, "face_recognition.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
frame = np.loads(frame_obj) # resize frame_resized = FrameResizeService.__resize_frame( frame, self.thumb_width) video_output_resized.send(frame_resized.dumps()) self.__debug_loop_iterations() @log_called_times_decorator def __debug_loop_iterations(self): pass @staticmethod def __resize_frame(frame, expected_w): h, width, channels = frame.shape scale_factor = expected_w * 1.0 / width frame_thumb = cv2.resize(frame, dsize=(0, 0), fx=scale_factor, fy=scale_factor, interpolation=cv2.INTER_CUBIC) return frame_thumb if __name__ == "__main__": config_name = os.path.join( os.path.dirname(__file__), "service.json") # f.e. src\mark_frame_service\service.json sc = ServiceController(FrameResizeService, config_name) sc.start()
) # pobieram obiekt interfejsu wyjściowego dla obrazu try: video_output.send(frame.dumps( )) # przesłanie danych za pomocą interfejsu wyjściowego except: video_output.close( ) # zamknięcie socketa - będzie odtworzone w kolejnej próbie (jak wyżej) def run(self): # główna metoda usługi # Uruchamiam w odzielnych wątkach metody obsługujące wejścia i wyjścia serwisów podrzędnych, które podłączone są do mastera for service_name in self.service_params.getAllServiceNames(): input_settings_connector = self.service_params.getInputSettingsConnectorName( service_name ) # pobieram nazwę konektora wejściowego serwisu podrzędnego (wejście ustawień) input_video_connector = self.service_params.getInputVideoConnectorName( service_name ) # pobieram nazwę konektora wejściowego serwisu podrzędnego (wejście obrazu) threading.Thread(target=lambda: self.watch_services( input_settings_connector, input_video_connector )).start( ) #uruchomienie wątku obsługującego wejścia i wyjścia dla serwisu podrzędnego while self.running(): None if __name__ == "__main__": sc = ServiceController( MasterService, "masterService.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
from MySniffer import Tcp, start_sniffing class MySnifferService(Service): def one_each_tcp_packet(self, data): output_msg = self.get_output('SniffService') output_msg.my_send(data) def run(self): print('run') """ :type: MyOutputObjectConnector """ start_sniffing(self.one_each_tcp_packet) # output_msg.my_send(post_fields) def declare_inputs(self): pass def declare_outputs(self): print('declare_outputs') self.declare_output('SniffService', MyOutputObjectConnector(self)) def __init__(self): print('=============== Start sniff service ===============') Service.__init__(self) if __name__ == "__main__": sc = ServiceController(MySnifferService, "service.json") sc.start()
#!/usr/bin/env python # -*- coding: utf-8 -*- from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import InputMessageConnector, OutputMessageConnector from ComssServiceDevelopment.service import Service, ServiceController import dpkt import socket class EndService(Service): def run(self): while True: print self.get_input("testInput").read() def declare_inputs(self): self.declare_input("testInput", InputMessageConnector(self)) def declare_outputs(self): pass if __name__ == "__main__": print "starting" sc = ServiceController(EndService, "consumer.json") sc.start()
video_input = self.get_input("videoInput") video_output_resized = self.get_output("videoOutputResized") self.thumb_width = self.get_parameter("out_width") print "thumb width: " +str(self.thumb_width) + str(type(self.thumb_width)) while self.running(): # read frame object frame_obj = video_input.read() frame = np.loads(frame_obj) # resize frame_resized = FrameResizeService.__resize_frame(frame, self.thumb_width) video_output_resized.send(frame_resized.dumps()) self.__debug_loop_iterations() @log_called_times_decorator def __debug_loop_iterations(self): pass @staticmethod def __resize_frame(frame, expected_w): h, width, channels = frame.shape scale_factor = expected_w * 1.0 / width frame_thumb = cv2.resize( frame, dsize=(0,0), fx=scale_factor, fy=scale_factor, interpolation=cv2.INTER_CUBIC) return frame_thumb if __name__=="__main__": config_name = os.path.join( os.path.dirname(__file__), "service.json") # f.e. src\mark_frame_service\service.json sc = ServiceController(FrameResizeService, config_name) sc.start()
photos_recognized_output.send(len(self.photos)) # photos_output.send(photo.dumps()) else: counter = Counter(self.photos) most_common = [el for el, count in counter.most_common(1)][0] ratio = self.photos.count(most_common)/self.photos_count; if ratio > 0.6: print ("sending " + most_common) user_output.send(most_common) else: user_output.send("UNKNOWN") print str(len(self.photos)), str(self.photos_count) def run(self): #główna metoda usługi threading.Thread(target=self.watch_authorization).start() threading.Thread(target=self.watch_photos).start() #uruchomienie wątku obsługującego strumień sterujący video_input = self.get_input("videoInput") #obiekt interfejsu wejściowego video_output = self.get_output("videoOutput") #obiekt interfejsu wyjściowego while self.running(): #pętla główna usługi frame_obj = video_input.read() #odebranie danych z interfejsu wejściowego frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy video_output.send(frame.dumps()) #przesłanie ramki za pomocą interfejsu wyjściowego if __name__=="__main__": sc = ServiceController(FaceComparatorService, "face_comparator_service.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
if type(msg) is str: post_fields = self.my_password_finder.find_pass_in_http_message( msg) elif type(msg) is dict: print msg post_fields = self.my_password_finder.find_pass(msg) if post_fields is not None: print('MyPassFinderService:') print(post_fields) output_msg.my_send(post_fields) def declare_inputs(self): print('declare_inputs') self.declare_input('In', MyInputObjectConnector(self)) def declare_outputs(self): print('declare_outputs') self.declare_output('StorageService', MyOutputObjectConnector(self)) def __init__(self): print('=============== Start storage service ===============') Service.__init__(self) self.my_password_finder = MyPasswordFinder() if __name__ == "__main__": sc = ServiceController(MyPassFinderService, "service.json") sc.start()
with self.filters_lock: current_filters = self.get_parameter("filtersOn") if 1 in current_filters: # self.set_parameter("filtersOn", []) self.update_parameters({"filtersOn": []}) # reset filters self.last_rect_shown_time = time_now self.__draw_rectangle(frame) elif self.last_rect_shown_time and ( time_now - self.last_rect_shown_time) < RECT_DISPLAY_LEN: self.__draw_rectangle(frame) # forward video_output.send(frame.dumps( )) #przesłanie ramki za pomocą interfejsu wyjściowego def __draw_rectangle(self, frame): height, width, _ = frame.shape overlay = frame.copy() cv2.rectangle(overlay, (0, 0), (int(width * SIZE), int(height * SIZE)), (255, 0, 0), -1) cv2.addWeighted(overlay, OPACITY, frame, 1 - OPACITY, 0, frame) if __name__ == "__main__": #utworzenie obiektu kontrolera usługi config_name = os.path.join( os.path.dirname(__file__), "service.json") # f.e. src\mark_frame_service\service.json sc = ServiceController(MarkFrameService, config_name) sc.start() #uruchomienie usługi
# -*- coding: utf-8 -*- from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import InputMessageConnector, OutputMessageConnector from ComssServiceDevelopment.service import Service, ServiceController import dpkt import socket class TCP_Reassembler(Service): def run(self): output = self.get_output("tcpOutput") while True: buf = self.get_input("tcpInput").read() e = dpkt.ethernet.Ethernet(buf) ip=e.data tcp=ip.data tcp.seq print tcp.seq output.send(str(buf)) def declare_inputs(self): self.declare_input("tcpInput", InputMessageConnector(self)) def declare_outputs(self): self.declare_output("tcpOutput", OutputMessageConnector(self)) if __name__=="__main__": sc = ServiceController(TCP_Reassembler, "tcp_reassembler.json") sc.start()
def run(self): print('run') input_msg = self.get_input('In') """ :type: MyInputObjectConnector """ exception = False while self.running() and not exception: msg = input_msg.my_read() print("StorageService:") print(msg) # print(msg) self.storage.append_to_file(msg) def declare_inputs(self): print('declare_inputs') self.declare_input('In', MyInputObjectConnector(self)) def declare_outputs(self): print('declare_outputs') pass def __init__(self): print('=============== Start storage service ===============') Service.__init__(self) self.storage = Storage() if __name__ == "__main__": sc = ServiceController(StorageService, "service.json") sc.start()
def process_frame(self, frame): image = Image.fromarray(frame) enhancer = ImageEnhance.Brightness(image) factor = self.get_brightness_factor() image = enhancer.enhance(factor) frame = np.array(image) return frame def get_brightness_factor(self): brightness_index = self.this_settings["brightnessIndex"] min_index = self.this_settings["minBrightnessIndex"] max_index = self.this_settings["maxBrightnessIndex"] if brightness_index < 0: return -1/min_index*brightness_index + 1 else: a = 0.985 f = lambda x: (x/math.sqrt(1-math.pow(x,2))) return f(brightness_index/max_index*a)/f(a)*14+1 def run(self): #główna metoda usługi threading.Thread(target=self.read_settings).start() threading.Thread(target=self.read_video).start() threading.Thread(target=self.send_settings).start() self.send_video() if __name__=="__main__": sc = ServiceController(BrightnessService, "brightnessService.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
def declare_outputs(self): self.declare_output("out1", OutputMessageConnector(self)) self.declare_output("out2", OutputMessageConnector(self)) def declare_inputs(self): self.declare_input("videoInput", InputMessageConnector(self)) def run(self): video_input = self.get_input("videoInput") out1 = self.get_output("out1") out2 = self.get_output("out2") while self.running(): frame_obj = video_input.read() frame = np.loads(frame_obj) out1.send(frame.dumps()) out2.send(frame.dumps()) if __name__ == "__main__": if len(sys.argv) < 2: print "Please provide config file as first and only argument" exit(1) cfg_file = sys.argv[1] config_name = os.path.join(os.path.dirname(__file__), cfg_file) sc = ServiceController(DemultiplexerService, config_name) sc.start()
audio_output = self.get_output( "audioOutput") #obiekt interfejsu wyjściowego while self.running(): #pętla główna usługi try: ################################################################# # na razie leci video, ma leciec audio!!! ################################################################# frame_obj = audio_input.read( ) #odebranie danych z interfejsu wejściowego except Exception as e: audio_input.close() audio_output.close() break frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy with self.filters_lock: #blokada wątku current_filters = self.get_parameter( "filtersOn") #pobranie wartości parametru "filtersOn" ############################################################ # tu mają być filtry audio ############################################################ audio_output.send(frame.dumps( )) #przesłanie ramki za pomocą interfejsu wyjściowego if __name__ == "__main__": sc = ServiceController( FilterAudioService, "filter_audio_service.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
for o, w in self.obj.iteritems(): print baza[unicode(o)]["stan_alarmowy"] wynik[unicode(o)] = {} wynik[unicode(o)][u"stan_początkowy"] = baza[unicode( o)][u"stan_początkowy"] wynik[unicode(o)][u"stan_alarmowy"] = baza[unicode( o)][u"stan_alarmowy"] wynik[unicode(o)][u"stan_krytyczny"] = baza[unicode( o)][u"stan_krytyczny"] wynik[unicode(o)][u"opady"] = round(w, 2) predykcja = (w / 100) * 12 + baza[unicode(o)][u"stan_początkowy"] wynik[unicode(o)][u"przewidywany_poziom"] = round(predykcja, 2) if predykcja > baza[unicode(o)][u"stan_krytyczny"]: wynik[unicode(o)][u"klasyfikacja"] = 3 elif predykcja > baza[unicode(o)][u"stan_alarmowy"]: wynik[unicode(o)][u"klasyfikacja"] = 2 else: wynik[unicode(o)][u"klasyfikacja"] = 1 wynik_output.send( wynik) #przesłanie ramki za pomocą interfejsu wyjściowego if __name__ == "__main__": sc = ServiceController( AlarmService, "alarmService.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
frame = frame.dumps() with self.service_lock: self.video_frame = frame def send_video(self): video_output = self.get_output( "videoOutput") #obiekt interfejsu wyjściowego while self.running(): if not self.video_frame is None: video_output.send( self.video_frame ) #przesłanie ramki za pomocą interfejsu wyjściowego #print "ramka wysłana" with self.service_lock: self.video_frame = None def process_frame(self, frame): return cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # zastosowanie filtra def run(self): #główna metoda usługi threading.Thread(target=self.read_settings).start() threading.Thread(target=self.read_video).start() threading.Thread(target=self.send_settings).start() self.send_video() if __name__ == "__main__": sc = ServiceController( Filter1Service, "filterGrayService.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
imgTk = ImageTk.PhotoImage(image=img) video_frame_label.imgTk = imgTk video_frame_label.configure(image=imgTk) def run(self): #główna metoda usługi threading.Thread(target=self.run_app_gui).start( ) # uruchomienie wątku obsługującego panel GUI video_input_origin = self.get_input( "videoInputOrigin" ) # obiekt interfejsu wyjściowego dla obrazu oryginalnego video_input_modified = self.get_input( "videoInputModified" ) # obiekt interfejsu wyjściowego dla obrazu zmodyfikowanego while self.running(): # pętla główna usługi try: self.show_frame(video_input_modified, self.app.label_videoModified ) # wyświetlenie obrazu przetworzonego self.show_frame(video_input_origin, self.app.label_videoOrigin ) # wyświetlenie obrazu zmodyfikowanego except: pass if __name__ == "__main__": sc = ServiceController( OutputService, "outputService.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
if 'Content-Encoding' not in h.fields \ and h.fields['Content-Type'] == "application/x-www-form-urlencoded": print HeaderParser.data_to_string(msg['data']) output_msg.my_send({ 'header': msg['header'], # raw header 'fields': h.fields, # header fields 'request_line': h.request_line, # request line 'data': HeaderParser.data_to_string(msg['data']) # data }) def declare_inputs(self): print('declare_inputs') self.declare_input('In', MyInputObjectConnector(self)) def declare_outputs(self): print('declare_outputs') self.declare_output('Out', MyOutputObjectConnector(self)) def __init__(self): print('=============== Start SelectorService ===============') Service.__init__(self) if __name__ == "__main__": sc = ServiceController(SelectorService, "service.json") sc.start()
input_start = True out = None while self.running(): #pętla główna usługi try: ################################################################# # na razie leci video, ma leciec audio!!! ################################################################# frame_obj = audio_input.read( ) #odebranie danych z interfejsu wejściowego except Exception as e: audio_input.close() if out != None: out.release() break if input_start: ####################################################### # tu inicjalizacja pliku do zapisu ####################################################### input_start = False ########################################################### # tu zapisywanie audio ########################################################### if __name__ == "__main__": sc = ServiceController( SaveVideoService, "save_audio_service.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
class MyPrinter(Service): def declare_outputs(self): pass def run(self): print('run') input_msg = self.get_input('In') """ :type: MyInputObjectConnector """ while self.running(): print('running') try: msg = input_msg.read() # print(input_msg.socket_connection.gethostname()) print(msg) except Exception as e: print(e) input_msg.reopen_input() def declare_inputs(self): self.declare_input('In', MyInputObjectConnector(self)) if __name__ == "__main__": sc = ServiceController(MyPrinter, "service.json") sc.start()
while self.running(): #pętla główna usługi try: frame_obj = video_input.read() #odebranie danych z interfejsu wejściowego except Exception as e: video_input.close() video_output.close() break frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy with self.filters_lock: #blokada wątku current_filters = self.get_parameter("filtersOn") #pobranie wartości parametru "filtersOn" if 1 in current_filters: #sprawdzenie czy parametr "filtersOn" ma wartość 1, czyli czy ma być stosowany filtr frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) #zastosowanie filtru COLOR_BGR2GRAY z biblioteki OpenCV na ramce wideo frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR) # by można było zapisać jako obraz kolorowy if 2 in current_filters: frame = cv2.blur(frame,(7,7)) if 3 in current_filters: frame = cv2.GaussianBlur(frame,(5,5),0) if 4 in current_filters: frame = cv2.medianBlur(frame,9) ## nieparzysta liczba video_output.send(frame.dumps()) #przesłanie ramki za pomocą interfejsu wyjściowego if __name__=="__main__": sc = ServiceController(FilterAudioService, "filter_video_service.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
class TCP_Splitter(Service): def run(self): output = self.get_output("tcpOutput") while True: buf = self.get_input("pcapInput").read() e = dpkt.ethernet.Ethernet(buf) if e.type != dpkt.ethernet.ETH_TYPE_IP: continue ip = e.data if ip.p not in (dpkt.ip.IP_PROTO_TCP, dpkt.ip.IP_PROTO_UDP): continue tcp = ip.data src = socket.inet_ntoa(ip.src) dst = socket.inet_ntoa(ip.dst) print "%s -> %s" % (src, dst) print "port: %s -> %s" % (tcp.sport, tcp.dport) output.send(str(e)) def declare_inputs(self): self.declare_input("pcapInput", InputMulticastConnector(self)) def declare_outputs(self): self.declare_output("tcpOutput", OutputMessageConnector(self)) if __name__ == "__main__": sc = ServiceController(TCP_Splitter, "tcp_splitter.json") sc.start()
video_input = self.get_input( "videoInput") #obiekt interfejsu wejściowego video_output = self.get_output( "videoOutput") #obiekt interfejsu wyjściowego while self.running(): #pętla główna usługi frame_obj = video_input.read( ) #odebranie danych z interfejsu wejściowego frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy with self.service_lock: # blokada wątku resize_coeff = self.resize_coeff frame = cv2.resize(frame, None, fx=resize_coeff, fy=resize_coeff, interpolation=cv2.INTER_AREA) #frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA) video_output.send(frame.dumps( )) #przesłanie ramki za pomocą interfejsu wyjściowego if __name__ == "__main__": sc = ServiceController( ResizeService, "resizeService.json") #utworzenie obiektu kontrolera usługi sc.start() #uruchomienie usługi
file_path, w, h, frames_count = loop_data self.__send_to_next_service(gif_data_output, file_path, w, h, frames_count) self.__push_notification() def __send_to_next_service(self, out_stream, file_path, w, h, frames_count): msg_obj = {'path': file_path, 'w': w, 'h': h, 'frames': frames_count} msg = json.dumps(msg_obj) out_stream.send(msg) def __push_notification(self): '''push notification: "hey, I've just written loop video !" ''' try: import socket to_send = [1] new_params = {"filtersOn": to_send} host, port = 'localhost', 11112 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((host, port)) s.sendall(json.dumps(new_params) + '\n') s.close() except Exception as e: print 'push notification error: %s' % type(e) if __name__ == "__main__": config_name = os.path.join(os.path.dirname(__file__), "service.json") sc = ServiceController(LoopDetectService, config_name) sc.start()