class Seismometer(object):
stats = None
def __init__(self, seismometer_id, directory):
self.seismometer_id = seismometer_id
self.directory = directory
self.last_saved_hour = datetime.today().hour
self.last_saved_minute = datetime.today().minute
self.stream_manager = StreamManager(self.directory /
MSEED_FILES_DIRECTORY)
self.stream_plotter = StreamPlotter(self.directory /
IMAGE_FILES_DIRECTORY)
def create_folders(self):
mseed_path = self.directory / MSEED_FILES_DIRECTORY
image_path = self.directory / IMAGE_FILES_DIRECTORY
if not mseed_path.exists():
mseed_path.mkdir(parents=True)
if not image_path.exists():
image_path.mkdir(parents=True)
async def handle_data(self, values, stats):
self.stats = stats
await self.stream_manager.append_values(values)
await self.save_plots_and_mseed()
async def get_last_seconds_of_data(self, seconds):
stream = await self.stream_manager.get_wrapped_stream()
endtime = stream[0].stats.endtime
starttime = endtime - seconds
slice = stream.slice(starttime, endtime)
return slice[0].data.tolist() if slice.count() > 0 else []
async def save_plots_and_mseed(self):
current_minute = datetime.today().minute
current_hour = datetime.today().hour
if self.last_saved_minute != current_minute:
await self.stream_plotter.save_last_10_minutes_plot(
await self.stream_manager.get_wrapped_stream())
await self.stream_plotter.save_last_60_minutes_plot(
await self.stream_manager.get_wrapped_stream())
await self.stream_manager.save_to_file()
self.last_saved_minute = current_minute
if self.last_saved_hour != current_hour:
await self.stream_plotter.save_hour_plot(
await self.stream_manager.get_wrapped_stream(),
self.last_saved_hour)
self.last_saved_hour = current_hour
if not self.stream_manager.is_valid_for_current_date():
await self.stream_plotter.save_day_plot(
await self.stream_manager.get_wrapped_stream())
self.stream_manager.begin_new_stream()
await self.stream_manager.save_to_file()
def __init__(self, seismometer_id, directory):
self.seismometer_id = seismometer_id
self.directory = directory
self.last_saved_hour = datetime.today().hour
self.last_saved_minute = datetime.today().minute
self.stream_manager = StreamManager(self.directory /
MSEED_FILES_DIRECTORY)
self.stream_plotter = StreamPlotter(self.directory /
IMAGE_FILES_DIRECTORY)
def quit(self, button, userdata=None):
self.dialog.hide()
Gtk.main_quit()
manager = StreamManager.get_stream_manager()
manager.unsubscribe(self.stream_update)
if manager.is_running():
manager.stop()
class Translator(object):
def __init__(self, asm_file):
self.stream_manager = StreamManager(asm_file)
def get_machine_code(self):
symbol_table = SymbolTableFactory.get_symbol_table(self.stream_manager)
result = ""
self.stream_manager.reset()
command = self.stream_manager.advance()
while True:
if Parser.command_type(command) == Parser.A_TYPE:
addr = Parser.addr(command)
if addr.isdigit():
code = Encoder.encode_addr(addr)
elif addr in symbol_table.keys():
addr = symbol_table[addr]
code = Encoder.encode_addr(addr)
else:
raise InvalidCommendType()
result += (code + '\n')
elif Parser.command_type(command) == Parser.C_TYPE:
dest = Parser.dest(command)
comp = Parser.comp(command)
jump = Parser.jump(command)
code_dest = Encoder.encode_dest(dest)
code_comp = Encoder.encode_comp(comp)
code_jump = Encoder.encode_jump(jump)
c_prefix = "111"
code = c_prefix + code_comp + code_dest + code_jump
result += (code + '\n')
elif Parser.command_type(command) in [
Parser.L_TYPE, Parser.IGNORE
]:
pass
else:
raise InvalidCommendType()
if not self.stream_manager.has_more_commands():
break
command = self.stream_manager.advance()
return result
MODEL_DIR = 'model'
UPLOAD_INTERVAL = 1 # sec
DETECTION_TYPE_NOTHING = 'nothing'
DETECTION_TYPE_SUCCESS = 'success'
DETECTION_TYPE_UNIDENTIFIED = 'unidentified'
DETECTION_BUFFER_SIZE = 10000
IMG_WIDTH = 960
IMG_HEIGHT = 540
# Main thread
onnx = ONNXRuntimeModelDeploy()
stream_manager = StreamManager(onnx)
app = Flask(__name__)
@app.route('/prediction', methods=['GET'])
def prediction():
# print(onnx.last_prediction)
# onnx.last_prediction
cam_id = request.args.get('cam_id')
s = stream_manager.get_stream_by_id(cam_id)
return json.dumps(s.last_prediction)
@app.route('/metrics', methods=['GET'])
def __init__(self):
handlers = {
"onLiveActivate": self.stream,
"onCancelActivate": self.quit,
"audio-source-changed": self.audio_source_changed,
"save-settings": self.save_settings,
"delete-event": self.quit,
"overlay-add": self.overlay_add,
"overlay-delete": self.overlay_delete,
"save-overlay-dialog": self.save_overlay_dialog,
"hide-overlay-dialog": self.hide_overlay_dialog
}
builder = Gtk.Builder()
builder.add_from_file("xml/stream_dialog.glade")
self.dialog = builder.get_object("dialog1")
self.username_entry = builder.get_object("username_entry")
self.stream_key_entry = builder.get_object("stream_key_entry")
self.remember_me = builder.get_object("remember_box")
self.stream_button = builder.get_object("stream_button")
# Settings
self.options_notebook = builder.get_object("options_notebook")
self.framerate_scale = builder.get_object("framerate_scale")
self.fps_adjustment = builder.get_object("fps_adjustment")
self.output_width = builder.get_object("output_width")
self.output_height = builder.get_object("output_height")
self.capture_x = builder.get_object("capture_x")
self.capture_y = builder.get_object("capture_y")
self.capture_width = builder.get_object("capture_width")
self.capture_height = builder.get_object("capture_height")
# Audio
self.audio_source_box = builder.get_object("audio_source_box")
self.audio_youtube_url = builder.get_object("audio_youtube_url")
self.audio_custom_file = builder.get_object("audio_filechooser")
# Overlay
self.overlay_dialog = builder.get_object("overlay_dialog")
self.overlay_dialog_image = builder.get_object("overlay_dialog_image")
self.overlay_dialog_x = builder.get_object("overlay_dialog_x")
self.overlay_dialog_y = builder.get_object("overlay_dialog_y")
self.overlay_dialog_anchor = builder.get_object("overlay_dialog_anchor")
self.overlay_store = builder.get_object("overlay_store")
self.overlay_selection = builder.get_object("overlay_selection")
self.load_settings()
# Show stream in WebKit frame
frame = builder.get_object('web_box')
self.webview = WebKit2.WebView()
self.webview.set_hexpand(True)
self.webview.set_vexpand(True)
self.webview.load_html(ALPHA_TEXT, "")
frame.add(self.webview)
builder.connect_signals(handlers)
# Monitor for vlc and jtvlc process changes
manager = StreamManager.get_stream_manager()
manager.subscribe(self.stream_update)
def stop_stream(self):
StreamManager.get_stream_manager().stop()
def start_stream(self):
StreamManager.get_stream_manager().start()
if self.webview.get_uri() != ("http://www.twitch.tv/%s" % self.username_entry.get_text()):
self.webview.load_uri("http://www.twitch.tv/%s" % self.username_entry.get_text())
def stream(self, button, userdata=None):
if StreamManager.get_stream_manager().is_running() is False:
self.start_stream()
else:
self.stop_stream()
import asyncio
import logging
import signal
import threading
import cv2
import requests
import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel
from stream_manager import StreamManager
logger = logging.getLogger(__name__)
stream_manager = StreamManager()
app = FastAPI()
class Stream(BaseModel):
stream_id: str
rtsp: str
fps: float
endpoint: str
@app.get("/")
async def index():
# FIXME
number_of_streams = 0
infos = []
for stream in stream_manager.get_streams():
def __init__(self, asm_file):
self.stream_manager = StreamManager(asm_file)
from stream_manager import StreamManager
sm = StreamManager()
from flask import Flask, request, render_template, jsonify
import json
app = Flask(__name__)
@app.route('/')
def main_page():
return render_template('index.html')
@app.route('/control', methods=['POST'])
def radio_control():
ret = {}
if request.method == 'POST':
data = request.get_json()
if data['submit'] == 'Play':
print('play')
sm.play_stream()
print(sm.get_current_radio())
ret['response'] = sm.get_current_radio()
elif data['submit'] == 'Stop':
print('stop')
sm.stop_stream()
ret['response'] = sm.get_current_radio()
if data['submit'] == 'Previous':
print('previous')
sm.select_stream(False)
import time
# initialize the output frame and a lock used to ensure thread-safe
# exchanges of the output frames (useful when multiple browsers/tabs are viewing the stream)
camera_id = 1
lock = threading.Lock()
# Initialize a flask object
app = Flask(__name__)
# Init Stream Manager
camera_streams_urls = [
"rtmp://62.113.210.250/medienasa-live/rbw_high",
"rtmp://62.113.210.250/medienasa-live/rbw_high"
]
stream_manager = StreamManager(camera_streams_urls)
class CameraStream:
def __init__(self, id, url):
self.id = id
self.vcap = cv2.VideoCapture(url)
# Function thaat takes in frame and proccess frames
def process_frame(camera, frame):
#TODO - Run Yolo model here
# Right now displaying frame for testing purposes
if camera == 1:
