def add_word(self):
name = self.lineEdit_Item.text()
if name != "" and len(self.treeViewLibrary.selectedIndexes()) > 0:
selected = self.vocabulary_model_library.itemFromIndex(self.treeViewLibrary.selectedIndexes()[0])
selected_item = selected.voc_object
item = None
if selected_item.get_type() == VOCABULARY_WORD:
word = selected_item.vocabulary.create_word(name, selected_item.name)
if word is not None:
item = VocabularyItem(word.name, word)
else:
msg = QMessageBox.warning(self, "Duplicate Word",
"Adding two words with the same name is not allowed.")
elif selected_item.get_type() == VOCABULARY:
word = selected_item.create_word(name)
if word is not None:
item = VocabularyItem(word.name, word)
else:
msg = QMessageBox.warning(self, "Duplicate Word",
"Adding two words with the same name is not allowed.")
else:
log_error("Failed to create word")
item = None
if item is not None:
index = self.add_to_tree(selected, item)
self.treeViewLibrary.scrollTo(index)
self.lineEdit_Item.setText("")
def on_remove_script(self):
for script in self.scripts:
try:
self.project.remove_script(script)
except Exception as e:
log_error("ContextMenu Error", e)
continue
def remove_project(self,
project: VIANProject = None,
file=None,
delete_from_disk=False):
"""
Removes a project from the corpus, can either be given by VIANProject object or file.
:param project:
:param file:
:param delete_from_disk:
:return:
"""
if project is None and file is None:
raise ValueError("Either project or file has to be given.")
if project is None:
project = VIANProject().load_project(file)
if project.uuid in self.project_paths:
self.project_paths.pop(project.uuid)
if project.uuid in self.projects_loaded:
self.projects_loaded.pop(project.uuid)
project.close()
print(self.projects_loaded, self.project_paths)
if delete_from_disk:
project.close()
pdir = project.folder
try:
if os.path.isdir(pdir):
rmtree(pdir)
except Exception as e:
log_error("Could not remove project", e)
self.onProjectRemoved.emit(project)
def remove_color(self, c):
try:
self.recent_colors.remove(c)
except Exception as e:
log_error(e)
self.update_widgets()
def on_ok(self):
if self.script is None:
with open("data/default_pipeline.py", "r") as f:
script = f.read()
script = script.replace("%PIPELINE_NAME%",
self.lineEdit_Name.text().replace(" ", ""))
script = script.replace(
"%AUTHOR%",
self.lineEdit_Author.text().replace(" ", ""))
script = script.replace("%UUID%", str(uuid4()))
else:
script = self.script
pipeline_script = self.main_window.project.create_pipeline_script(
name=self.lineEdit_Name.text().replace(" ", ""),
author=self.lineEdit_Author.text().replace(" ", ""),
script=script)
try:
self.parent().pipeline_script = pipeline_script
self.parent().editor.setPlainText(pipeline_script.script)
self.parent().reload()
self.close()
except Exception as e:
log_error("NewScriptDialog", e)
pass
def extract(self):
self.audioExtractingStarted.emit()
with HDF5_FILE_LOCK:
self._read(self.project.movie_descriptor.get_movie_path())
self.audio_samples = self._sample_audio(self.callback)
if self.audio_samples is None:
return
self.audio_volume = np.abs(np.mean(self.audio_samples, axis=1))
log_info("Size", self.audio_samples.nbytes / 10**6)
log_info("Size", self.audio_volume.nbytes / 10**6)
project_audio_path = os.path.join(self.project.data_dir,
"audio.mp3")
self.audioProcessed.emit(
TimelineDataset("Audio Volume",
self.audio_volume,
ms_to_idx=(self.resolution * 1000),
vis_type=TimelineDataset.VIS_TYPE_AREA))
try:
if not os.path.isfile(
project_audio_path) and self.export_audio:
self._audioclip.write_audiofile(
os.path.join(self.project.data_dir, "audio.mp3"))
except Exception as e:
log_error(e)
self._videoclip.close()
self._audioclip.close()
self.audioExtractingEnded.emit()
def on_set_main(self):
self.hide()
try:
self.segmentation[0].project.set_main_segmentation(self.segmentation[0])
except Exception as e:
log_error("ContextMenu Error", e)
self.close()
def on_delete(self):
try:
for obj in self.media_object:
obj.container.remove_media_object(obj)
except Exception as e:
log_error(e)
pass
def add_project(self,
project: VIANProject = None,
file=None,
merge_behaviour=MERGE_BEHAVIOUR_MERGE_KEEP):
"""
Adds a project to the corpus, can either be given by VIANProject object or file
:param project:
:param file:
:return:
"""
if project is None and file is None:
raise ValueError("Either project or file has to be given.")
if project is None:
results = None
try:
project = VIANProject().load_project(file)
t_exp_names = [e.name for e in self.template.experiments]
t_exp_unique_ids = [
e.unique_id for e in self.template.experiments
]
template_dict = self.template.get_template(segm=True,
voc=True,
ann=True,
scripts=False,
experiment=True,
pipeline=True)
if merge_behaviour == self.MERGE_BEHAVIOUR_DELETE_DELETE:
to_remove = [
e for e in project.experiments if e.name in t_exp_names
or e.unique_id in t_exp_unique_ids
]
for t in to_remove:
project.remove_experiment(t)
results = project.apply_template(template=template_dict)
elif merge_behaviour == self.MERGE_BEHAVIOUR_MERGE_DELETE:
results = project.apply_template(template=template_dict,
merge=True,
merge_drop=True)
elif merge_behaviour == self.MERGE_BEHAVIOUR_MERGE_KEEP:
results = project.apply_template(template=template_dict,
merge=True,
merge_drop=False)
except Exception as e:
log_error("Could not load project", e)
return
project.store_project()
project.close()
for l in results:
log_info(l)
self.projects_loaded[project.uuid] = project
self.project_paths[project.uuid] = project.path
self.onProjectAdded.emit(project)
def on_subs_changed(self, index):
try:
if len(self.subs) > 0:
self.main_window.player.set_subtitle(self.subs[index][0])
except Exception as e:
log_error(
"PlayerControls.on_subs_changed(): Could not set Subtitles:",
e)
def plot_time_palette(self, data):
try:
self.time_palette.set_palette(data[0], data[1])
self.time_palette.draw_palette()
except Exception as e:
log_error(
"Exception in ColorimetryLiveWidget::plot_time_palette()", e)
pass
def on_delete(self):
self.hide()
for s in self.segments:
try:
s.project.remove_segment(s)
except Exception as e:
log_error("ContextMenu Error", e)
continue
self.close()
def on_delete(self):
self.hide()
for a in self.annotation:
try:
a.project.remove_annotation(a)
except Exception as e:
log_error("ContextMenu Error", e)
continue
self.close()
def on_delete(self):
self.hide()
for l in self.layer:
try:
l.project.remove_annotation_layer(l)
except Exception as e:
log_error("ContextMenu Error", e)
continue
self.close()
def toggle_timeline_visiblity(self):
self.hide()
visibility = not self.segmentation[0].timeline_visibility
for s in self.segmentation:
try:
s.set_timeline_visibility(visibility)
except Exception as e:
log_error("ContextMenu Error", e)
continue
def on_visibility_changed(self, visibility):
if visibility:
if self.main_window.project is not None:
try:
data = self.main_window.project.colormetry_analysis.get_update(
self.main_window.player.get_media_time())
self.update_timestep(data, None)
except Exception as e:
log_error("Visibility Changed Exception", e)
def _run_task(self, task_id, analysis, args, on_progress):
log_info("Running Analysis", analysis.__class__)
try:
return analysis.process(args, on_progress)
except Exception as e:
traceback.print_exc()
exctype, value = sys.exc_info()[:2]
log_error(traceback.print_exc())
self.signals.sign_error.emit((exctype, value, traceback.format_exc()))
return None
def remove_keys(self):
self.hide()
for a in self.annotation:
try:
a.remove_keys()
except Exception as e:
log_error("ContextMenu Error", e)
continue
self.close()
def go_to(self):
try:
self.hide()
last = self.screenshots[len(self.screenshots) - 1]
self.main_window.player.pause()
self.main_window.player.set_media_time(last.movie_timestamp)
except Exception as e:
log_error("ContextMenu Error", e)
self.close()
def toggle_lock(self):
self.hide()
new_status = not self.segmentation[0].is_locked()
for s in self.segmentation:
try:
if new_status:
s.lock()
else:
s.unlock()
except Exception as e:
log_error("ContextMenu Error", e)
continue
def get_fields(self, path, delimiter = ";"):
self.delimiter = delimiter
try:
with open(path, 'r') as csvfile:
reader = csv.reader((line.replace('\0','') for line in csvfile) , delimiter=delimiter)
for row in reader:
return True, row
except Exception as e:
log_error(e)
return False, []
def run_selection(self):
if self.project is not None:
if self.main_window.vian_event_handler.current_pipeline is None:
return
container = self.project.selected
scrs = [s for s in container if isinstance(s, Screenshot)]
segments = [s for s in container if isinstance(s, Segment)]
annotations = [s for s in container if isinstance(s, Annotation)]
missing_info = self.project.get_missing_analyses(
self.main_window.vian_event_handler.current_pipeline.
requirements,
screenshots=scrs,
annotations=annotations,
segments=segments)
missing = dict()
log_info("## Missing Analyses in Pipeline ##")
for k in missing_info.keys():
# print(k, missing_info[k], missing.items())
missing[k] = missing_info[k][0]
log_info("## -- ", k, missing_info[k][2], missing_info[k][1],
missing_info[k][0])
experiment = self.main_window.vian_event_handler.current_pipeline.experiment
if experiment is None:
log_error("Experiment not found for RunAll")
return
for cl in missing.keys():
for priority in sorted(missing[cl].keys()):
for analysis_name in missing[cl][priority].keys():
analysis = self.main_window.eval_class(analysis_name)
for clobj_name, containers in missing[cl][priority][
analysis_name].items():
clobj = experiment.get_classification_object_by_name(
clobj_name)
if clobj is None:
log_warning("Classification Object not found")
continue
d = dict(analysis=analysis(),
targets=containers,
parameters=None,
classification_objs=clobj)
log_info("Pipeline Analysis: ", priority,
analysis_name, clobj_name)
self.onRunAnalysis.emit(d)
def on_selected(self, sender, selected):
try:
if not self.dock_widget_visible:
return
if len(selected) > 0:
if isinstance(selected[0], IAnalysisJobAnalysis):
self.activate_analysis(selected[0])
elif isinstance(selected[0], Experiment):
self.activate_classification(selected[0])
else:
self.activate_selector(selected)
except Exception as e:
log_error(e)
pass
def set_palettes(self, palettes):
try:
self.palette_tree = np.vstack(tuple(palettes.copy()))
except Exception as e:
log_error("Exception in set_palettes()", palettes)
return
layers = self.palette_tree[:, 1]
if self.slider is not None:
self.slider.setRange(0, len(np.unique(layers)) - 1)
if self.spbox_depth is not None:
self.spbox_depth.setRange(0, len(np.unique(layers)) - 1)
if not (0 <= self.depth <= len(np.unique(layers)) - 1):
self.depth = len(np.unique(layers)) - 1
self.draw_palette()
def on_settings_changed(self):
if self.checkBox_UseLocation.isChecked():
try:
splitted = self.preview_path.split(
self.lineEdit_Delimiter.text())
idx_h = self.sB_PositionTimeH.value() - 1
idx_m = self.sB_PositionTimeM.value() - 1
idx_s = self.sB_PositionTimeS.value() - 1
idx_ms = self.sB_PositionTimeMS.value() - 1
idx_segment = self.sB_PositionSegment.value() - 1
text = ""
text_full = ""
# IF has time location
if (idx_h >= 0 or idx_m >= 0 or idx_s >= 0 or idx_ms >= 0):
if (idx_h >= 0 and idx_h < len(splitted)):
text += "H = " + str(splitted[idx_h])
if (idx_m >= 0 and idx_m < len(splitted)):
text += " M = " + str(splitted[idx_m])
if (idx_s >= 0 and idx_s < len(splitted)):
text += " S = " + str(splitted[idx_s])
if (idx_ms >= 0 and idx_ms < len(splitted)):
text += " MS = " + str(splitted[idx_ms])
else:
if (idx_segment >= 0 and idx_h < len(splitted)):
text += " SEGM_ID = " + str(splitted[idx_segment])
for i, t in enumerate(splitted):
if i not in [idx_h, idx_s, idx_m, idx_ms, idx_segment]:
text_full += (str(t))
else:
text_full += ("[" + str(t) + "]")
if i < len(splitted) - 1:
text_full += " _ "
self.label_P0.setText(text)
self.label_P0.setVisible(True)
self.label_P1.setText(text_full)
self.label_P1.setVisible(True)
except Exception as e:
log_error(e)
else:
self.label_P0.setVisible(False)
self.label_P1.setVisible(False)
def set_project(self, project:VIANProject):
if project is not None:
self.lineEdit_Name.setText(project.name)
self.lbl_Location.setText(project.path)
self.goto_dir = project.folder
try:
self.spinBox_ItemID.setValue(int(project.movie_descriptor.movie_id.split("_")[0]))
self.spinBox_ManifestationID.setValue(int(project.movie_descriptor.movie_id.split("_")[1]))
self.spinBox_CopyID.setValue(int(project.movie_descriptor.movie_id.split("_")[2]))
except Exception as e:
log_error(e)
else:
self.lineEdit_Name.setText("")
self.lbl_Location.setText("")
self.goto_dir = None
self.spinBox_ItemID.setValue(0)
self.spinBox_ManifestationID.setValue(0)
self.spinBox_CopyID.setValue(0)
def work(self, data):
if data is not None:
self.is_drawing = True
try:
if self.palette.isVisible():
self.palette.set_palette(data['palette'])
self.palette.draw_palette()
if self.lab_palette.isVisible():
self.lab_palette.set_palette(data['palette'])
self.lab_palette.draw_palette()
if self.hilbert_vis.isVisible():
self.hilbert_vis.plot_color_histogram(data['histogram'])
except Exception as e:
log_error("Exception in ColormetryWidget.update_timestep()",
str(e))
self.is_drawing = False
def deserialize(self, serialization, project):
self.project = project
self.ID = serialization["scene_id"]
self.unique_id = serialization['unique_id']
self.start = serialization["start"]
self.end = serialization["end"]
self.duration = serialization["duration"]
self.notes = serialization['notes']
# Backwards Compatibility
if 'name' in serialization:
self.name = serialization['name']
else:
self.name = str(self.ID)
if 'locked' in serialization:
self.locked = serialization['locked']
else:
self.locked = False
if 'annotation_body' in serialization:
self.annotation_body = serialization['annotation_body']
else:
self.annotation_body = ""
try:
for w in serialization["media_objects"]:
o_type = w['dtype']
if o_type in [
MediaObjectType.HYPERLINK, MediaObjectType.SOURCE
]:
new = DataMediaObject(None, None, self,
None).deserialize(w)
else:
new = FileMediaObject(None, None, self,
None).deserialize(w)
new.set_project(self.project)
self.media_objects.append(new)
except Exception as e:
log_error(e)
return self
def load_pipelines(self, ddir="extensions/pipelines/"):
file_list = []
# print (os.path.abspath(os.path.curdir))
for root, dirs, files in os.walk(ddir, topdown=False):
for name in files:
if "py" in name:
path = os.path.join(root, name)
path = path.replace("\\", "/")
path = path.replace(".py", "")
path = path.replace("/", ".")
if not "__init__" in path and not "__pycache__" in path:
file_list.append(path)
for f in file_list:
try:
importlib.import_module(f)
except Exception as e:
log_error("Exception in load_pipelines():", e)
continue
def __init__(self):
super(ERCFilmColorsVIANPipeline, self).__init__()
try:
self.graph = tf.Graph()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True # dynamically grow the memory used on the GPU
config.gpu_options.per_process_gpu_memory_fraction = 0.4
with self.graph.as_default():
self.session = tf.Session(config=config)
KTF.set_session(self.session)
self.model = PSPNetModelVIAN(input_shape=(512, 512, 3))
self.model.load_weights(KERAS_LIP_WEIGHTS)
self.model_name = DATASET_NAME_LIP
except Exception as e:
log_error(e)
self.model = None
self.model_name = "LIP"
self.session = None
log_info(self.model, self.model_name)