def __init__(self):
super(Code1, self).__init__()
# Do what is necessary to start the process
# and to leave gloriously
self.arm()
self.sub = subs.Subs()
self.pub = pubs.Pubs()
self.pub.subscribe_topic('/act', Custom)
self.pub.subscribe_topic('/mavros/rc/override', OverrideRCIn)
self.pub.subscribe_topic('/mavros/setpoint_velocity/cmd_vel',
TwistStamped)
self.pub.subscribe_topic('/BlueRov2/body_command', JointState)
self.pub.subscribe_topic('/Location2', Odometry)
self.sub.subscribe_topic('/joy', Joy)
self.sub.subscribe_topic('/odom', Odometry)
self.sub.subscribe_topic('/mavros/battery', BatteryState)
self.sub.subscribe_topic('/mavros/rc/in', RCIn)
self.sub.subscribe_topic('/mavros/rc/out', RCOut)
self.sub.subscribe_topic('/mavros/imu/static_pressure', FluidPressure)
self.sub.subscribe_topic('/mavros/imu/diff_pressure', FluidPressure)
self.sub.subscribe_topic('/mavros/imu/data', Imu)
self.sub.subscribe_topic('/depth', Float32)
self.sub.subscribe_topic('/odometry/filtered', Odometry)
self.cam = None
try:
video_udp_port = rospy.get_param("/user_node/video_udp_port")
rospy.loginfo("video_udp_port: {}".format(video_udp_port))
self.cam = video.Video(video_udp_port)
except Exception as error:
rospy.loginfo(error)
self.cam = video.Video()
def __init__(self):
super(ROV_control, self).__init__()
# Do what is necessary to start the process
# and to leave gloriously
self.arm()
self.sub = subs.Subs()
self.pub = pubs.Pubs()
self.pub.subscribe_topic('/mavros/rc/override', OverrideRCIn)
self.pub.subscribe_topic('/mavros/setpoint_velocity/cmd_vel', TwistStamped)
self.pub.subscribe_topic('/BlueRov2/body_command', JointState)
self.sub.subscribe_topic('/joy', Joy)
self.sub.subscribe_topic('/mavros/battery', BatteryState)
self.sub.subscribe_topic('/mavros/rc/in', RCIn)
self.sub.subscribe_topic('/mavros/rc/out', RCOut)
self.cam = None
try:
video_udp_port = rospy.get_param("/user_node/video_udp_port")
rospy.loginfo("video_udp_port: {}".format(video_udp_port))
self.cam = video.Video(video_udp_port)
except Exception as error:
rospy.loginfo(error)
self.cam = video.Video()
def __init__(self):
super(Code, self).__init__()
# Do what is necessary to start the process
# and to leave gloriously
rospy.wait_for_service('/mavros/cmd/arming')
self.arm_service = rospy.ServiceProxy('/mavros/cmd/arming', CommandBool)
self.disarm()
self.is_armed = False
self.sub = subs.Subs()
self.pub = pubs.Pubs()
self.pub.subscribe_topic('/mavros/rc/override', OverrideRCIn)
self.pub.subscribe_topic('/mavros/setpoint_velocity/cmd_vel', TwistStamped)
self.pub.subscribe_topic('/BlueRov2/body_command', JointState)
self.sub.subscribe_topic('/joy', Joy)
self.sub.subscribe_topic('/mavros/battery', BatteryState)
self.sub.subscribe_topic('/mavros/rc/in', RCIn)
self.sub.subscribe_topic('/mavros/rc/out', RCOut)
self.sub.subscribe_topic('/imu_pose', Pose)
self.cam = None
self.bridge = CvBridge()
self.image_pub = rospy.Publisher("BlueRov2/image",Image)
try:
video_udp_port = rospy.get_param("/user_node/video_udp_port")
rospy.loginfo("video_udp_port: {}".format(video_udp_port))
self.cam = video.Video(video_udp_port)
except Exception as error:
rospy.loginfo(error)
self.cam = video.Video()
def save_video_attributes(inputFilepath="video_search.txt",
outputFilepath="videos.csv",
overwrite=True):
"""
TODO: C++ pandas integration?
:param inputFilepath:
:param outputFilepath:
"""
attributeList = vi.Video.getAttributeList()
videos = pd.read_csv(inputFilepath,
sep=',',
names=['filePath'],
index_col=None).head(10)
videos = pd.DataFrame(videos, columns=['filePath'].extend(attributeList))
(totalRows, _) = videos.shape
if ((os.path.exists(outputFilepath) and overwrite)
or not os.path.exists(outputFilepath)):
file = open(outputFilepath, 'wb')
attributesHeader = ','.join(['filePath'].extend(attributeList))
file.write(attributesHeader + '\n')
else:
file = open(outputFilepath, 'ab')
for index, videoLine in videos.iterrows():
print videoLine['filePath']
video = vi.Video(videoLine['filePath'], videos=videos)
for attributeName in attributeList:
# print '\t' + str(video[attribute])
read = video[attributeName]
file.write(','.join([
str(video[attributeName])
for attributeName in ['filePath'].extend(attributeList)
]) + '\n')
def openMedia(self):
#if hasattr(self, "player"):#Удаляет медиаплеер
#self.player.deleteLater()
#del self.player
if hasattr(self, "hbox"): #Удаляет отрисовку
self.hbox.deleteLater()
del self.hbox
self.pathSourceObject = self.path[:self.path.rfind(".")]
self.fileType = self.path[self.path.rfind(".") + 1:]
if self.fileType in {"png", "jpg", "JPG"}:
self.mediaObject = photo.Photo(self.path)
self.mediaQt.MediaStackedWidget.setCurrentIndex(1)
self.mediaQt.editPanelStacked.setCurrentIndex(3)
self.mediaQt.controlPanelStacked.setCurrentIndex(2)
self.startMedia()
if self.fileType in {"mp4"}:
self.mediaObject = video.Video(self.path)
self.mediaQt.MediaStackedWidget.setCurrentIndex(0)
self.mediaQt.editPanelStacked.setCurrentIndex(0)
self.mediaQt.controlPanelStacked.setCurrentIndex(0)
self.startMedia()
elif self.fileType in {"mp3"}:
self.mediaObject = audio.Audio(self.path)
self.mediaQt.MediaStackedWidget.setCurrentIndex(2)
self.mediaQt.editPanelStacked.setCurrentIndex(1)
self.mediaQt.controlPanelStacked.setCurrentIndex(0)
self.startMedia()
def test(vid_filename):
video_capture = video.Video(vid_filename)
video_capture.start()
detector = face_detection_modified.FaceDetection()
facecount = 0
framecount = 0
while True:
frame = video_capture.get_frame()
framecount += 1
if frame is None:
print("facecount:" + str(facecount))
print("framecount:" + str(framecount))
break
frame, face_frame, ROI1, ROI2, status, mask = detector.face_detect(frame)
if status:
facecount += 1
# Display the resulting image
cv2.imshow('Video', frame)
# Hit 'q' on the keyboard to quit!
if cv2.waitKey(1) & 0xFF == ord('q'):
break
video_capture.stop()
cv2.destroyAllWindows()
def __init__(self):
#On prépare un fichier temporaire tant que le script est lancé
#pid = str(os.getpid())
#pidfile = "/tmp/controleur.pid"
#try:
# #On teste si le fichier existe déja
# if os.path.isfile(pidfile):
# os.link(pidfile,"daemon_python")
# else:
# file(pidfile, 'w').write(pid)
# os.link(pidfile,"daemon_python")
#except IOError as e:
# message = "I/O error("+str(e.errno)+"): "+str(e.strerror)
# print(message)
#On effectue le vrai travail ici
#On instancie les classes principales
self.stop_event = threading.Event()
self.surveillance_serveur = surveillance_serveur.Surveillance_serveur(
self, self.stop_event)
self.surveillance_serie = surveillance_serie.Surveillance_serie(
self, self.stop_event)
self.traitement = traitement.Traitement(self, self.stop_event)
self.video = video.Video(self.stop_event)
self.led = LED.LED(self.stop_event)
#On met les threads en mode daemon, quand le controleur est tué, on tue tous les threads
self.surveillance_serveur.daemon = True
self.surveillance_serie.daemon = True
self.traitement.daemon = True
self.video.daemon = True
self.led.daemon = True
def from_video(cap, out=None):
"""Read data from a video file
Arguments:
cap {cv2.VideoCapture} -- The video capture from CV2
Keyword Arguments:
out {string} -- The output location if recording (default: {None})
"""
frame = 0
log.debug("resolution: %s", (int(cap.get(3)), int(cap.get(4))))
if out:
out = cv2.VideoWriter(out, cv2.VideoWriter_fourcc('D', 'I', 'V', 'X'),
10, (int(cap.get(3)), int(cap.get(4))))
vid = video.Video(cap, out)
ret = 1
while (vid.cap.isOpened and ret == 1):
start = time.perf_counter()
log.info("frame: %s", frame)
ret = vid.shoelace_finding(frame)
log.info(ret)
if ret == 0:
exit()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
frame += 1
end = time.perf_counter()
log.info("Current Total time is %s resulting in frame rate of %s",
end - start, 1 / (end - start))
cap.release()
cv2.destroyAllWindows()
def test_diff_weights(self):
fs = frame_grabber.FrameGrabber(mode=video_mode.VideoMode.DHGR)
v = video.Video(fs,
ticks_per_second=10000.,
mode=video_mode.VideoMode.DHGR)
frame = screen.MemoryMap(screen_page=1)
frame.page_offset[0, 0] = 0b1111111
frame.page_offset[0, 1] = 0b1010101
target_pixelmap = screen.DHGRBitmap(palette=palette.Palette.NTSC,
main_memory=v.memory_map,
aux_memory=frame)
self.assertEqual(0b0000000000101010100000001111111000,
target_pixelmap.packed[0, 0])
pal = palette.NTSCPalette
diff = target_pixelmap.diff_weights(v.pixelmap, is_aux=True)
# Expect byte 0 to map to 0b0001111111000
expect0 = target_pixelmap.edit_distances(pal.ID)[0][0b0001111111000]
# Expect byte 2 to map to 0b0001010101000
expect2 = target_pixelmap.edit_distances(pal.ID)[2][0b0001010101000]
self.assertEqual(expect0, diff[0, 0])
self.assertEqual(expect2, diff[0, 1])
# Update aux frame
v.aux_memory_map.page_offset = frame.page_offset
v.pixelmap._pack()
self.assertEqual(0b0000000000101010100000001111111000,
v.pixelmap.packed[0, 0])
# Encode new aux frame
frame = screen.MemoryMap(screen_page=1)
frame.page_offset[0, 0] = 0b1101101
frame.page_offset[0, 1] = 0b0110110
target_pixelmap = screen.DHGRBitmap(main_memory=v.memory_map,
aux_memory=frame,
palette=pal.ID)
self.assertEqual(0b0000000000011011000000001101101000,
target_pixelmap.packed[0, 0])
diff = target_pixelmap.diff_weights(v.pixelmap, is_aux=True)
# Masked offset 0 changes from 0001111111000 to 0001101101000
expect0 = target_pixelmap.edit_distances(
pal.ID)[0][0b00011111110000001101101000]
# Masked offset 2 changes from 0001010101000 to 0000110110000
expect2 = target_pixelmap.edit_distances(
pal.ID)[2][0b00010101010000000110110000]
self.assertEqual(expect0, diff[0, 0])
self.assertEqual(expect2, diff[0, 1])
def __init__(self):
load = loader.Loader("TETRIS")
load.read()
memory = mmu.MMU(load.data)
processor = cpu.CPU(memory)
display = video.Video()
display.mainloop(processor.step)
def generate_video_list(items):
# returns list of video objects
video_list = []
for item in items:
title = item['snippet']['title']
v = video.Video(title)
video_list.append(v)
return video_list
def record(self):
if self._RECORDING:
self.video.close()
self._RECORDING = False
self.rec_action.setIcon(
QtGui.QIcon(ICONPATH + "button_black_rec.png"))
else:
w, h = self.view.proi._w, self.view.proi._h
self.video = video.Video(w, h)
self._RECORDING = True
self.rec_action.setIcon(
QtGui.QIcon(ICONPATH + "button_red_rec.png"))
def submit():
form = SubmitForm(csrf_enabled = False)
if form.validate_on_submit():
vid = video.Video()
vid.title = form.title.data
vid.link = form.link.data
vid.submitter = form.submitter.data
vid.author = form.author.data
mongo.db.test_data.insert(vid.__dict__)
return redirect(url_for('videos'))
else:
return render_template('submit.htmljinja', form=form)
def video_processing(self):
if not os.path.exists(r'C:\Temp\afr'):
self.infopopup_class.open_popup(self.info1)
return None
if int(self.interval.text) <= 0:
self.interval.text = ''
self.infopopup_class.open_popup(self.info2)
return None
vid = video.Video(int(self.fps.text), int(self.start.text), int(self.interval.text), self.to_num.text, self.pdftitle.text)
vid.main(self.mainpath)
self.files.markup = True
self.files.text = "[b]Done![/b]"
self.files.font_size = '50sp'
self.run_time += 1
def videoStart():
myvideo = video.Video()
time.sleep(1)
myvideo.nextFrame()
myvideo.testBackgroundFrame()
while 1:
myvideo.nextFrame()
myvideo.testBackgroundFrame()
myvideo.updateBackground()
myvideo.compare()
myvideo.showFrame()
myvideo.testSettings()
if myvideo.testDestroy():
sys.exit()
def recvid(self, Nframes, fps):
self.pause()
self.framerate(fps)
t = [] #list for frametimes:
w, h = self.view.proi._w, self.view.proi._h
self.vid = video.Video(w, h, fps=fps)
self.stream()
for i in range(Nframes):
f = self.capture()
self.vid.append(f.data)
t += [f.time]
self.stop()
dt = (diff(array(t)) / self.cps())
fps_real = round(1. / dt.mean())
print "fps achieved: " + str(fps_real)
self.vid.close()
def video_test():
issues = list()
passed = True
correctNumberOfFrames = 162
correctNumberOfRows = 368
correctNumberOfColumns = 640
pathToTestVideo = r"testFiles\SampleVideo_640x360_1mb.mp4"
videoTest = video.Video(pathToTestVideo)
if videoTest.numberOfFrames != correctNumberOfFrames:
issues.append("Number of frames is not correct")
if videoTest.numberOfRows != correctNumberOfRows:
issues.append("Number of rows is not correct")
if videoTest.numberOfColumns != correctNumberOfColumns:
issues.append("Number of columns is not correct")
if len(issues) > 0:
passed = False
return (passed, issues)
def from_camera(cap, out=None):
"""Take input from webcam
Arguments:
cap {cv2.VideoCapture} -- The input videon stream in this case
a webcam
Keyword Arguments:
out {string} -- An output video file location (default: {None})
"""
vid = video.Video(cap, out)
frame = 0
while True:
vid.shoelace_finding(frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
frame += 1
cap.release()
cv2.destroyAllWindows()
def demo():
# Inicializar video para mostrado en pantalla
v = video.Video()
v.set_mode_2d()
# Inicializar webcam
video_capture = cv2.VideoCapture(prm["camera_device_index"])
cam_width = video_capture.get(cv2.CAP_PROP_FRAME_WIDTH)
cam_height = video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT)
# Inicializar detector de cara
face_detector = FaceDetector()
def loop(screen, delta_t, window_w, window_h):
# Obtener frame de video
_, cam_frame = video_capture.read()
# No se bien por que pero hay que espejar la imagen para que las
# coordenadas sean las que esperamos
cam_frame = cv2.flip(cam_frame, 1)
# Detectar caras
face_rect = face_detector.detect(cam_frame)
# Dibujar rectangulos sobre caras
if face_rect is not None:
face_rect_draw(cam_frame, face_rect)
# Convertir color, necesario para dibujado en pygame
cam_frame = cv2.cvtColor(cam_frame, cv2.COLOR_BGR2RGB)
# Intercambiar filas por columnas de la imagen, necesario para dibujado
# en pygame
cam_frame = cam_frame.swapaxes(0,1)
# Dibujar en pantalla de pygame
surf = pygame.surfarray.make_surface(cam_frame)
surf = pygame.transform.scale(surf, (window_w, window_h))
screen.blit(surf, (0, 0))
v.start_loop(loop)
video_capture.release()
def editor_setup(self, source):
self.source = source
# load the video
self.video = video.Video(source)
# destroy the placeholder text since we have the video
if self.placeholder:
self.placeholder.destroy()
# create a canvas to put the loaded video
self.video_canvas = tkinter.Canvas(self.window,
width=self.video.width,
height=self.video.height)
self.video_canvas.pack()
# create a slider to control the preview of the video
self.scale = tkinter.Scale(self.window,
from_=0,
to=1,
resolutio=-1,
orient=tkinter.HORIZONTAL,
length=self.video.width,
sliderlength=10)
self.scale.pack()
# create a canvas to show when is marked
self.marker_canvas_height = 15
self.marker_canvas = tkinter.Canvas(self.window,
width=self.video.width,
height=self.marker_canvas_height,
background='black')
self.marker_canvas.pack()
# the actual storage of all markers
self.markers = []
# create a button to mark the current time
self.button = tkinter.Button(self.window,
text='Mark',
command=self.mark)
self.button.pack()
self.update(10)
def main():
vid = video.Video()
start_button = button.InputButton(pin_number=INPUT_PINS[0])
# all of the lights
light_manager = light.LightManager(pins=OUTPUT_PINS)
twit = twitter.Twitter()
# map the creating a gif
def light_show(channel):
light_manager.final_countdown()
gif_path = vid.make_gif()
light_manager.flash()
twit.post_image(gif_path)
print('cycle complete')
start_button.add_onclick_callback(light_show)
print('waiting forever...')
while True:
time.sleep(1)
def calling_handler(self, nick, dst_udp_port):
"""
Nombre: calling_handler
Descripcion: Funcion que responde a una solicitud de llamada.
Argumentos:
-nick: nick del usuario
-dst_udp_port: puerto udp destino
Retorno: Ninguno
"""
# Hallamos la informacion del usuario
user_info = self.users_descubrimiento.query(nick)
dst_ip = user_info[1]
dst_port = user_info[2]
# Si no estamos en llamada
if not self.video_client.flag_en_llamada:
# Pregunta si quieres aceptar la llamada
res = self.gui.yesNoBox("Llamada entrante", nick)
if res:
msg = "CALL_ACCEPTED {} {}".format(self.video_client.nick, self.udp_port)
self.send_msg(msg, dst_ip, dst_port)
self.gui.setStatusbar("En llamada.", 0)
# Actualizamos la informacion necesaria en la app
self.video_client.flag_en_llamada = True
self.video_client.dst_ip = dst_ip
self.video_client.dst_port = dst_port
# Comenzamos la llamada
self.video_client.video = video.Video(self.video_client, dst_ip,
int(self.udp_port), int(dst_udp_port))
self.video_client.video.llamada()
else:
msg = "CALL_DENIED {}".format(nick)
self.send_msg(msg, dst_ip, dst_port)
else:
msg = "CALL_BUSY"
self.send_msg(msg, dst_ip, dst_port)
def __init__(
self, filename: str,
every_n_video_frames: int = 1,
audio_bitrate: int = 14700,
audio_normalization: float = None,
max_bytes_out: int = None,
video_mode: VideoMode = VideoMode.HGR,
palette: Palette = Palette.NTSC,
):
self.filename = filename # type: str
self.every_n_video_frames = every_n_video_frames # type: int
self.max_bytes_out = max_bytes_out # type: int
self.video_mode = video_mode # type: VideoMode
self.palette = palette # type: Palette
self.audio = audio.Audio(
filename, bitrate=audio_bitrate,
normalization=audio_normalization) # type: audio.Audio
self.frame_grabber = frame_grabber.FileFrameGrabber(
filename, mode=video_mode, palette=self.palette)
self.video = video.Video(
self.frame_grabber,
ticks_per_second=self.audio.sample_rate,
mode=video_mode,
palette=self.palette
) # type: video.Video
# Byte offset within TCP stream
self.stream_pos = 0 # type: int
# Current audio tick opcode count within movie stream.
self.ticks = 0 # type: int
# Tracks internal state of player virtual machine
self.state = machine.Machine()
# Currently operating on AUX memory bank?
self.aux_memory_bank = False
def _Calculate(self):
video_capture = video.Video(self._VIDEO_FILE_NAME)
histograms = [(time,
bmp.ColorHistogram(ignore_color=self._WHITE,
tolerance=8))
for time, bmp in video_capture.GetVideoFrameIter()]
start_histogram = histograms[0][1]
final_histogram = histograms[-1][1]
total_distance = start_histogram.Distance(final_histogram)
def FrameProgress(histogram):
if total_distance == 0:
if histogram.Distance(final_histogram) == 0:
return 1.0
else:
return 0.0
return 1 - histogram.Distance(final_histogram) / total_distance
time_completeness_list = [(time, FrameProgress(hist))
for time, hist in histograms]
return time_completeness_list
def save_video_attribute(inputFilepath="video_search.txt",
outputFilepath="videos.csv",
overwrite=True,
inputAttributeName=None):
"""
TODO: C++ pandas integration?
:param inputFilepath:
:param outputFilepath:
"""
if (inputAttributeName is None):
attributeList = vi.Video.getAttributeList()
else:
attributeList = [inputAttributeName]
for attributeName in attributeList:
videos = pd.read_csv(inputFilepath,
sep=',',
names=['filePath'],
index_col=None)
videos = pd.DataFrame(videos,
columns=['filePath'].extend(attributeList))
(totalRows, _) = videos.shape
outputFilepathPerAttribute = os.path.join(
os.path.dirname(outputFilepath),
os.path.splitext(outputFilepath)[0] + "_" + attributeName + ".csv")
if (os.path.exists(outputFilepathPerAttribute) and overwrite):
file = open(outputFilepathPerAttribute, 'wb')
attributesHeader = 'filePath,' + attributeName
file.write(attributesHeader + '\n')
else:
file = open(outputFilepathPerAttribute, 'ab')
for index, videoLine in videos.iterrows():
print videoLine['filePath']
video = vi.Video(videoLine['filePath'], videos=videos)
read = video[attributeName]
file.write(','.join(
[str(videoLine['filePath']),
str(video[attributeName])]) + '\n')
def call_accepted_handler(self, nick, dst_udp_port):
"""
Nombre: call_end_handler
Descripcion: Funcion que comienza una llamada tras ser aceptada.
Argumentos:
-nick: nick del usuario
-dst_udp_port: puerto udp destino
Retorno: Ninguno
"""
if not self.video_client.flag_en_llamada:
user_info = self.users_descubrimiento.query(nick)
dst_ip = user_info[1]
self.gui.infoBox("Información de llamada", "{} ha aceptado tu llamada.".format(nick))
self.gui.setStatusbar("En llamada.", 0)
# Actualizamos la informacion necesaria en la app
self.video_client.flag_en_llamada = True
self.video_client.dst_ip = dst_ip
self.video_client.dst_port = user_info[2]
# Comenzamos la llamada
self.video_client.video = video.Video(self.video_client, dst_ip, int(self.udp_port), int(dst_udp_port))
self.video_client.video.llamada()
def generate_h5(input_video, input_users, output):
with h5py.File(output + '.h5', "w") as file:
videos = get_videos_names(input_video)
for video_name in videos:
actual_video = video.Video(os.path.join(input_video, video_name))
group = file.create_group(actual_video.name)
asciiList = [
n.encode("ascii", "ignore") for n in actual_video.name
]
group.create_dataset(
'video_name', (len(asciiList), 1), "|S3",
asciiList) #For python 2 = |S3, for python 3 = <U3
asciiList = [
n.encode("ascii", "ignore") for n in actual_video.path
]
group.create_dataset('video_path', (len(asciiList), 1), "|S3",
asciiList)
asciiList = [
n.encode("ascii", "ignore") for n in actual_video.extension
]
group.create_dataset('video_extension', (len(asciiList), 1), "|S3",
asciiList)
group.create_dataset('fps', (1, ), 'f', actual_video.fps)
group.create_dataset('frames', (1, ), 'i', actual_video.frames)
user_frames = users_frames_to_list(
os.path.join(input_users, actual_video.name))
#print (user_frames)
if np.amax(user_frames) > 1: #is csv with frame ID
if actual_video.frames < np.amax(user_frames):
print(actual_video.name, "\t", actual_video.frames, "\t",
np.amax(user_frames), "\t", actual_video.fps,
"\tPROBLEM!!!!!!!\tPROBLEM!!!!!!!")
else:
print(actual_video.name, "\t", actual_video.frames, "\t",
np.amax(user_frames), "\t", actual_video.fps)
group.create_dataset('user_frames', (user_frames.shape),
'i', user_frames)
user_summary = user_picks_expand(user_frames,
actual_video.frames)
group.create_dataset('user_summary', (user_summary.shape),
'i', user_summary)
else: #is csv without frame ID, vector_len = video_frames
if actual_video.frames * 0.2 < len(
user_frames[0]): #Summe dataset case
print(actual_video.name, "\t", actual_video.frames, "\t",
len(user_frames[0]), "\t", actual_video.fps)
#debug_count_ones(user_frames)
#print (actual_video.name)
#user_summary=expand_zeros(user_frames,actual_video.frames)
#user_summary=
#debug_count_ones(user_frames)
group.create_dataset('user_summary', (user_frames.shape),
'i', user_frames)
user_frames_with_ID = user_picks_contract(user_frames)
group.create_dataset('user_frames',
(user_frames_with_ID.shape), 'i',
user_frames_with_ID)
else:
print(actual_video.name, "\t", actual_video.frames, "\t",
len(user_frames[0]), "\t", actual_video.fps,
"\tPROBLEM!!!!!!!\tPROBLEM!!!!!!!")
# Fall detector main # Kim Salmi, kim.salmi(at)iki(dot)fi # http://tunn.us/arduino/falldetector.php # License: GPLv3 import video import time import sys video = video.Video(0) time.sleep(1.0) # let camera autofocus + autosaturation settle video.nextFrame() video.testBackgroundFrame() while 1: video.nextFrame() video.testBackgroundFrame() video.updateBackground() video.compare() video.showFrame() video.testSettings() if video.testDestroy(): sys.exit()
def ParseCreateVideoParam(data):
v = video.Video()
try:
jdata = json.loads(data)
# 校验参数合法性
# 英文名称
if not jdata.has_key("name_en") or (0 == len(jdata["name_en"])):
logging.error("[%s][%d] Get name_en failed! data:%s" %
(__file__, sys._getframe().f_lineno, data))
return (None, comm.ERR_PARAM_INVALID, "Get name_en failed!")
v.name_en = jdata["name_en"]
# 中文名称
if not jdata.has_key("name_ch") or (0 == len(jdata["name_ch"])):
logging.error("[%s][%d] Get name_ch failed! data:%s" %
(__file__, sys._getframe().f_lineno, data))
return (None, comm.ERR_PARAM_INVALID, "Get name_ch failed!")
v.name_ch = jdata["name_ch"]
# 缩略图URL
if not jdata.has_key("poster") or (0 == len(jdata["poster"])):
logging.error("[%s][%d] Get poster failed! data:%s" %
(__file__, sys._getframe().f_lineno, data))
return (None, comm.ERR_PARAM_INVALID, "Get poster failed!")
v.poster = jdata["poster"]
# 视频时长(秒)
if not jdata.has_key("duration") or (0 == jdata["duration"]):
logging.error("[%s][%d] Get duration failed! data:%s" %
(__file__, sys._getframe().f_lineno, data))
return (None, comm.ERR_PARAM_INVALID, "Get duration failed!")
v.duration = jdata["duration"]
# 播放地址
if not jdata.has_key("url") or (0 == len(jdata["url"])):
logging.error("[%s][%d] Get url failed! data:%s" %
(__file__, sys._getframe().f_lineno, data))
return (None, comm.ERR_PARAM_INVALID, "Get url failed!")
v.url = jdata["url"]
# 字幕内容
if not jdata.has_key("words_script") or (0 == len(
jdata["words_script"])):
logging.error("[%s][%d] Get words_script failed! data:%s" %
(__file__, sys._getframe().f_lineno, data))
return (None, comm.ERR_PARAM_INVALID, "Get words_script failed!")
v.words_script = jdata["words_script"]
# 视频清晰度
if not jdata.has_key("definition") or (0 == len(jdata["definition"])):
logging.error("[%s][%d] Get definition failed! data:%s" %
(__file__, sys._getframe().f_lineno, data))
return (None, comm.ERR_PARAM_INVALID, "Get definition failed!")
v.definition = jdata["definition"]
return (v, comm.OK, "Ok")
except Exception as e:
logging.error("[%s][%d] Create video failed! data:%s e:%s" %
(__file__, sys._getframe().f_lineno, data, str(e)))
return (None, comm.ERR_UNKNOWN, str(e))
return (None, comm.ERR_UNKNOWN, "Parse create video parameter failed!")
# Fall detector main # Kim Salmi, kim.salmi(at)iki(dot)fi # http://tunn.us/arduino/falldetector.php # License: GPLv3 import video import time import sys import numpy as np import cv2 import time video = video.Video() time.sleep(1.0) # let camera autofocus + autosaturation settle video.nextFrame() video.testBackgroundFrame() while 1: video.nextFrame() video.testBackgroundFrame() video.updateBackground() video.compare() video.showFrame() video.testSettings() if video.testDestroy(): sys.exit()
