def procVideo(s, tweet_json, outputDir):
if 'extended_entities' in tweet_json:
media = tweet_json['extended_entities'].get('media', [])
vid_type = media[0]['type']
if vid_type == "video":
title = None
if 'title' in media[0]['additional_media_info']:
title = media[0]['additional_media_info']['title']
duration = None
if 'duration_millis' in media[0]['video_info']:
duration = media[0]['video_info']['duration_millis']
url = ''
for v in media[0]['video_info']['variants']:
if 'bitrate' in v:
if v['bitrate'] > 0:
url = v['url']
if url != '':
file_name = str(s.tweet_id) + '.mp4'
file = outputDir + file_name
s.video = Video(s.tweet_id, file, url, title, duration,
vid_type)
elif vid_type == "animated_gif":
title = None
duration = None
url = media[0]['video_info']['variants'][0]['url']
file_name = str(s.tweet_id) + '.gif'
file = outputDir + file_name
s.video = Video(s.tweet_id, file, url, title, duration,
vid_type)
def videos_by_pl(self, youtube, pl_id):
plvideos_response = youtube.playlistItems().list(
part="snippet", playlistId=pl_id, maxResults=50).execute()
Videos = []
for item in plvideos_response["items"]:
snippet = item["snippet"]
if snippet is not None:
plid = item["id"]
title = snippet["title"]
desc = snippet["description"]
resourceId = snippet["resourceId"]
if resourceId is not None:
vidId = resourceId["videoId"]
try:
thumbnails = snippet["thumbnails"]
defUrl = thumbnails["default"]["url"]
medUrl = thumbnails["medium"]["url"]
Videos.append(
Video(vidId, title, desc, plid, defUrl, medUrl))
except KeyError, e:
defUrl = "/static/images/404.jpg"
Videos.append(Video(vidId, title, desc, plid, defUrl,
None))
pass
except:
pass
def main():
# set command argument
parser = argparse.ArgumentParser(description="Convertion between Video,\
Image and Ascii")
parser.add_argument('--file', dest = 'file', required = True, help = \
"Default path in Video2Ascii/files")
parser.add_argument('--mode', dest = 'mode', required = True, help = \
"Video2Image or Video2Ascii or Image2Ascii")
parser.add_argument('--output', dest = 'outFile', required = False, help = \
"Default path in Video2Ascii/output", default = 'output')
parser.add_argument('--cols', dest = 'cols', required = False, help = \
"Numbers of Ascii column", default = 200)
parser.add_argument('--scale', dest = 'scale', required = False, help = \
"vertical scaling factor - higher leads a longer face", default = 0.5)
# parser.add_argument('--morelevels', dest='moreLevels', action='store_true')#default:False(less levels)
# get command argument
args = parser.parse_args()
if args.mode == 'Video2Image':
video = Video(args.file, args.outFile, args.cols, args.scale)
video.Video2Image()
elif args.mode == 'Video2Ascii':
video = Video(args.file, args.outFile, args.cols, args.scale)
video.Video2Ascii()
elif args.mode == 'Image2Ascii':
image = Image(args.file, args.outFile, args.cols, args.scale)
image.Image2Ascii()
else:
print("Arguments not found!")
def read_fovs(file):
data = np.genfromtxt(file, dtype=None, unpack=True, delimiter='\t')
prev_vid = data[0][0]
fovs = []
idx = 0
videos = []
for d in data:
vid = d[0]
# print str(vid), str(prev_vid)
if vid == prev_vid:
# lat, lon, compass, R, alpha
fov = FOV(data[idx][2], data[idx][3], data[idx][4], data[idx][5],
data[idx][6])
fovs.append(fov)
else:
# new video
v = Video(fovs)
v.id = prev_vid
videos.append(v)
# print v.to_str()
# new fovs
fovs = []
fov = FOV(data[idx][2], data[idx][3], data[idx][4], data[idx][5],
data[idx][6])
fovs.append(fov)
idx = idx + 1
prev_vid = vid
print "number of videos", len(videos)
return videos
def getListofVideos(self):
"""
This method is used to get a list of all available videos in the VHH-MMSI system.
:return: This method returns a list of video objects (Class-type: Video) which holds all video specific meta-data.
"""
print("load list of videos ... ")
print("send request: " + str(self.API_VIDEO_SEARCH_ENDPOINT))
res = requests.get(self.API_VIDEO_SEARCH_ENDPOINT
) #, verify=self.__pem_path) # params=params,
print("receive response")
res_json = res.json()
video_instance_list = []
for i in range(0, len(res_json)):
entry = res_json[i]
vid = int(entry['id'])
originalFileName = entry['originalFileName']
url = entry['url']
processed_flag = entry['processed']
# filter frame_counter videos and amX videos
if not "video-framecounter" in originalFileName and not "eyeland" in originalFileName and not "am-" in originalFileName:
video_instance = Video(self.__core_config)
video_instance.create_video(
vid=vid,
originalFileName=originalFileName,
url=url,
download_path=self.__video_download_path,
processed_flag=processed_flag)
video_instance_list.append(video_instance)
return video_instance_list
def setVideo(self, dataPoint, storage):
if self.dataPoint is not None:
self.dataPoint.clearFeatures()
dataPoint.loadFeatures(storage)
self.dataPoint = dataPoint
self.video = Video(dataPoint.videoPath)
self.setFullTimeLabel()
def _retrieve_videos(self,
limit=20,
offset=0,
session=None,
order=None,
private=0):
from Video import Video
album_id = self._get_safe('album_id')
if album_id:
videos = api.request('/album/' + album_id + '/videos',
method="GET",
params=dict(private=private,
order=order,
session=session,
offset=offset,
limit=limit,
album=album_id))
if videos:
return [
Video(meta={'video': video}) for video in videos['videos']
]
else:
return False
else:
return False
def main():
# Disable OAuthlib's HTTPS verification when running locally.
# *DO NOT* leave this option enabled in production.
os.environ["OAUTHLIB_INSECURE_TRANSPORT"] = "1"
vid = Video(TITLE, CATEGORYID, STATUS)
youtube = get_authenticated_service()
request = youtube.videos().insert(
part="snippet,status",
body={
"snippet": {
"categoryId": vid.getCategoryId(),
"description": "Description of uploaded video.",
"title": vid.getTitle()
},
"status": {
"privacyStatus": vid.getStatus()
}
},
# Pointer to video file
media_body=MediaFileUpload("vid.mp4"))
response = request.execute()
print(response)
def set_webcam(self, device):
u"""webcamの設定."""
self.settei.settings["webcam"] = True
self.settei.settings["device"] = device
self.video = None
outdir = self.settei.settings["outdir"]
playfile = self.playfile = device
logfunc = self.main_view.write_log
self.video = Video(playfile, outdir, logfunc, webcam=True)
# webcamが接続されていれば初期設定
if self.video.check_webcam() is True:
self.video.set_bounding(self.settei.settings["bounding"])
self.video.set_verbose(self.settei.settings["verbose"])
self.video.set_detecttype(self.settei.settings["detecttype"])
self.main_view.set_webcam_view()
top = self.settei.settings["detectionTop"]
bottom = self.settei.settings["detectionBottom"]
left = self.settei.settings["detectionLeft"]
right = self.settei.settings["detectionRight"]
self.set_detectionarea(top, bottom, left, right)
self.set_imgscale()
self.set_speed()
self.control_video("START")
else:
self.main_view.set_webcam_view(webcam=False)
def make_movie_list(self):
files = os.listdir('.')
suffix_list = ['avi', 'mp4']
# print(files)
for item in files:
s = item
if s.split('.')[-1] in suffix_list:
description_name = s[0] + '_des.txt'
#print(description_name)
if os.path.exists(description_name):
f = open(description_name, 'r')
description = f.read()
f.close()
else:
description = ''
bullet_name = s[0] + '_bullet.txt'
#print(bullet_name)
if os.path.exists(bullet_name):
f = open(bullet_name, 'r')
bullet = f.read()
f.close()
else:
bullet = ''
video = Video(item)
length = video.get_time()
full_item = (item, description, bullet, length)
self.movie_list.append(full_item)
for item in self.movie_list:
file_path = os.path.join(self.base_cache, item[0])
if not os.path.exists(file_path):
os.makedirs(file_path)
make_cache(item[0], file_path)
def openImage(self, *args):
self.openDialog.set_current_folder(path.expanduser("~"))
self.openDialog.set_select_multiple(False)
self.openDialog.set_filter(self.builder.get_object("imageFilter"))
response = self.openDialog.run()
self.openDialog.hide()
if (response == Gtk.ResponseType.OK):
self.disableUI()
g.file = self.openDialog.get_filename()
try:
self.video = Video()
img = cv2.imread(g.file)
h, w = img.shape[:2]
if (not self.checkMemory(w, h)):
raise MemoryError()
self.window.set_title(path.split(g.file)[1] + " - " + UI.TITLE)
self.saveDialog.set_current_name("")
self.sharpen = Sharpen(g.file, True)
self.builder.get_object("alignTab").set_sensitive(False)
self.builder.get_object("stackTab").set_sensitive(False)
self.builder.get_object("processTab").set_sensitive(True)
self.tabs.set_current_page(UI.SHARPEN_TAB)
self.frame.set_from_file(g.file)
except MemoryError as error:
pass
except: # Open Failed
self.showErrorDialog(
"There was an error opening the image, make sure it is a valid image."
)
self.enableUI()
def readConfiguration(self):
theFile = open(self.theFile)
values = theFile.readline().split(' ')
self.numberOfVideos = int(values[0])
self.numberOfEndpoints = int(values[1])
self.numberOfRequestDescription = int(values[2])
self.numberOfCacheServer = int(values[3])
self.cacheServerCapacity = int(values[4])
values = theFile.readline().split(' ')
self.videos = [Video(int(el)) for el in values]
for i in range(0, self.numberOfEndpoints):
values = theFile.readline().split(' ')
latency = int(values[0])
n = int(values[1])
theList = []
for j in range(0, n):
values = theFile.readline().split(' ')
theList.append([int(values[0]), int(values[1])])
self.endpoints.append(Endpoint(latency, theList))
for i in range(0, self.numberOfRequestDescription):
values = theFile.readline().split(' ')
self.requests.append(
EndpointRequests(int(values[2]), int(values[0]),
int(values[1])))
theFile.close()
def __init__(self, parent=None):
super(StreamingWindow, self).__init__(parent)
super().setTitleName("Streaming Window")
super().basicUI()
self.initUi()
self.video = Video(self, QSize(self.frm.width(), self.frm.height()))
def read_data(file):
data = np.genfromtxt(file, unpack=True, delimiter='\t')
prev_vid = 1
fovs = []
idx = 0
videos = []
for vid in data[1]:
if vid == prev_vid:
#lat, long, compass, R, alpha
fov = FOV(data[2][idx], data[3][idx], data[4][idx], data[5][idx],
data[6][idx])
fovs.append(fov)
else:
# new video
v = Video(fovs)
v.id = vid
videos.append(v)
# print v.to_str()
# new fovs
fovs = []
fov = FOV(data[2][idx], data[3][idx], data[4][idx], data[5][idx],
data[6][idx])
fovs.append(fov)
idx += 1
prev_vid = vid
return videos
def getTrendingData():
url = "https://www.youtube.com/feed/trending"
response = requests.get(url)
soup = BeautifulSoup(response.text, features="lxml")
#list that will store Video objects
videos_list = []
#finds all the videos in the html
videos_in_html = soup.findAll("div", class_="yt-lockup-content")
#for every video get title, desc and tags then store in a list
for content in videos_in_html:
try:
title = getTitle(content)
description = getDesc(content)
video_href = getHref(content)
video_url = "https://www.youtube.com{}".format(video_href)
tags = getTags(video_url)
curr_video = Video(title, description, tags)
videos_list.append(curr_video)
except Exception as e:
...
return videos_list
def __init__(self):
inf = open('book.txt', 'r')
if inf.closed:
print("Error opening file.")
for i in inf.readlines():
mystring = i.strip().split('|')
CardCatalog.append(Book(*mystring))
inf.close()
inf = open('periodic.txt', 'r')
if inf.closed:
print("Error opening file.")
for i in inf.readlines():
mystring = i.strip().split('|')
CardCatalog.append(Periodical(*mystring))
inf.close()
inf = open('video.txt', 'r')
if inf.closed:
print("Error opening file.")
for i in inf.readlines():
mystring = i.strip().split('|')
CardCatalog.append(Video(*mystring))
inf.close()
inf = open('film.txt', 'r')
if inf.closed:
print("Error opening file.")
for i in inf.readlines():
mystring = i.strip().split('|')
CardCatalog.append(Film(*mystring))
inf.close()
def _get_videos(videos_type, **kwargs):
videos = api.request('/videos/' + videos_type, method="GET", params=kwargs)
if videos and 'videos' in videos:
return [Video(meta={'video': video}) for video in videos['videos']]
else:
return False
def download(self, index, **kwargs):
'''
Resumes the download of item at index 'index' from the playlist
'''
vobj = self.res[index - 1]
video = Video(vobj)
return video.download(**kwargs) # params
def read_Video():
file_names = []
path = "F:\\Desktop\\opencv_detection\\"
for i in range(0,50):
label = random.randint(0,11)
video = Video(i,path+"video"+str(i%3+1)+".mp4","label"+str(label),label,0)
file_names.append(video)
return file_names
def __init__(self):
self.root = Tk.Tk()
self.view = View(self.root, self)
self.video_model = Video()
self.user_input = ''
self.recording = False
self.video_data = ''
self.output = ''
def __init__(self, frames):
self.frames = frames
self.tmats = [] # (frame, M, diff)
self.count = 0
self.total = 0
self.minX = 0
self.minY = 0
self.maxX = 0
self.maxY = 0
video = Video()
self.height, self.width = video.getFrame(g.file, 0).shape[:2]
def generate_video_traffic(job):
''' Generate traffic file for the whole video.
Args:
in_db_file - should have all the images for which traffic is generated
job - the same as for process_video
'''
assertParamIsThere(job, 'in_db_file')
assertParamIsThere(job, 'out_video_dir')
setParamUnlessThere(job, 'frame_range', '[::]')
assertParamIsThere(job, 'video_dir')
video = Video(video_dir=job['video_dir'])
camera = video.build_camera()
assert op.exists(atcity(job['in_db_file'])), \
'in db %s does not exist' % atcity(job['in_db_file'])
conn_in = sqlite3.connect(atcity(job['in_db_file']))
c_in = conn_in.cursor()
c_in.execute('SELECT time FROM images')
timestamps = c_in.fetchall()
conn_in.close()
cad = Cad()
if 'speed_kph' in job:
model = TrafficModel(camera,
video,
cad=cad,
speed_kph=job['speed_kph'])
elif 'num_cars' in job:
model = TrafficModelRandom(camera,
video,
cad=cad,
num_cars_mean=job['num_cars'])
else:
assert False
diapason = Diapason(len(timestamps), job['frame_range'])
traffic = {'in_db_file': job['in_db_file']}
traffic['frames'] = []
for frame_id in diapason.frame_range:
logging.info('generating traffic for frame %d' % frame_id)
timestamp = timestamps[frame_id][0]
time = parseTimeString(timestamp)
traffic_frame = model.get_next_frame(time)
traffic_frame['frame_id'] = frame_id # for validating
traffic['frames'].append(traffic_frame)
return traffic
def blendAverage(frames, file, ref, minX, maxX, minY, maxY, drizzleFactor,
drizzleInterpolation, conn):
video = Video()
stackedImage = None
for frame, M, diff in frames:
image = video.getFrame(file, frame)
image = transform(image, ref, M, minX, maxX, minY, maxY, drizzleFactor,
drizzleInterpolation).astype(np.float64)
if stackedImage is None:
stackedImage = image
else:
stackedImage += image
conn.send("Stacking Frames")
return stackedImage
def __init__(self):
self.data_container = []
book_file = open("book.txt", 'r')
for line in book_file:
data = []
parsed_line = line.split('|')
for i in range(0, 10):
data.append(parsed_line[i])
new_book = Book("Book", data[0], data[1], data[2], data[3],
data[4], data[5], data[6], data[7], data[8],
data[9])
del data[:]
self.data_container.append(new_book)
periodical_file = open("periodical.txt", 'r')
for line in periodical_file:
data = []
parsed_line = line.split('|')
for i in range(0, 12):
data.append(parsed_line[i])
new_periodical = Periodical("Periodical", data[0], data[1],
data[2], data[3], data[4], data[5],
data[6], data[7], data[8], data[9],
data[10], data[11])
del data[:]
self.data_container.append(new_periodical)
video_file = open("video.txt", 'r')
for line in video_file:
data = []
parsed_line = line.split('|')
for i in range(0, 8):
data.append(parsed_line[i])
new_video = Video("Video", data[0], data[1], data[2], data[3],
data[4], data[5], data[6], data[7])
del data[:]
self.data_container.append(new_video)
film_file = open("film.txt", 'r')
for line in film_file:
data = []
parsed_line = line.split('|')
for i in range(0, 6):
data.append(parsed_line[i])
new_film = Film("Film", data[0], data[1], data[2], data[3],
data[4], data[5])
del data[:]
self.data_container.append(new_film)
def openImageSequence(self, *args):
self.openDialog.set_current_folder(path.expanduser("~"))
self.openDialog.set_select_multiple(True)
self.openDialog.set_filter(self.builder.get_object("imageFilter"))
response = self.openDialog.run()
self.openDialog.hide()
if (response == Gtk.ResponseType.OK):
try:
g.file = self.openDialog.get_filenames()
self.video = Video()
self.video.checkMemory()
thread = Thread(target=self.video.run, args=())
thread.start()
self.disableUI()
except MemoryError as error:
self.enableUI()
def add_video(self, session, video_id):
album_id = self._get_safe('album_id')
if album_id:
video_action = api.request('/album/' + album_id + '/video/' +
video_id,
params=dict(session=session))
if video_action:
from Video import Video
self.videos.append(
Video(video_id=video_action['albumVideo']['video_id']))
return True
else:
return False
return False
def inputVideo(self, startTime=0, endTime=0):
WebDriverWait(self.bot, 10).until(
EC.presence_of_element_located(
(By.CLASS_NAME, "upload-btn-input")))
file_input_element = self.bot.find_elements_by_class_name(
"upload-btn-input")[0]
# Check if file has correct .mp4 extension, else throw error.
self.video = Video(self.userRequest["dir"], self.userRequest["vidTxt"])
self.video.createVideo()
if not startTime == 0 and endTime == 0:
self.video.customCrop(startTime, endTime)
while not os.path.exists(
self.userRequest["dir"]): # Wait for path to exist
time.sleep(1)
abs_path = os.path.join(os.getcwd(), self.userRequest["dir"])
file_input_element.send_keys(abs_path)
def upload():
target = os.path.join(APP_ROOT, 'videos/')
print(target)
if not os.path.isdir(target):
os.mkdir(target)
for file in request.files.getlist("file"):
print(file)
filename = file.filename
destination = "/".join([target, filename])
print(destination)
file.save(destination)
video = Video(filename, destination)
videoHandler.addVideo(video)
return render_template("complete.html", variable=video.path)
def get_videos_details(youtube, video_id):
results = youtube.videos().list(
part="snippet,contentDetails,statistics",
id=video_id,
).execute()
video_url = "https://www.youtube.com/watch?v=" + video_id
title = results["items"][0]["snippet"]["title"]
thumbnail_url = results["items"][0]["snippet"]["thumbnails"]["default"][
"url"]
original_image_url = results["items"][0]["snippet"]["thumbnails"]["high"][
"url"]
duration = results["items"][0]["contentDetails"]["duration"]
views = results["items"][0]["statistics"]["viewCount"]
video = Video(video_id, views, duration, title, video_url, thumbnail_url,
original_image_url)
updates_list.append(video.add_video())
def predict_video(self, vname):
self.video = Video(vname)
self.verbosity = self.video.N / 20
self.super_label, self.super_score = self.smodel.predict(vname)
self.frame_label, self.frame_score = self.fmodel.predict(vname)
cutlist = self.video.cutlist
superlist = []
for i in range(len(cutlist) - 1):
start = cutlist[i]
end = cutlist[i + 1]
s = {}
s['start'] = start
s['end'] = end
s['score'] = self.super_score[i]
s['img'] = self.video.frame_imgs[i]
superlist.append(s)
return superlist, self.video
