def _add_parameter():
parameter = widget_parameter.get_value()
if not parameter:
main_gui.show_information('Create dependencies',
'No parameter selected')
return
try:
current_par = self.combobox_widget_dependent_parameters.get_value(
)
# Add parameter to settings
self.settings_object.add_data('dependent_parameters',
parameter, [])
print(self.settings_object.get_data('dependent_parameters'))
# Set parameter list
self.combobox_widget_dependent_parameters.update_items(
self._get_dependent_parameters_from_settings())
if intvar_show_parameter.get():
self.combobox_widget_dependent_parameters.set_value(
parameter)
else:
self.combobox_widget_dependent_parameters.set_value(
current_par)
self._update_listbox_selection_widget_dependent_parameters()
except GUIException as e:
main_gui.show_error(
'Creating dependencies',
'{}\nSomething went wrong Try again!'.format(e.message))
popup_frame.destroy()
def show_exception(message, exception):
try:
details = traceback.format_exc()
import gui
gui.show_error(message , "Details:\n"+details)
except:
pass
def _create_user():
source_user = widget_source_user.get_value().strip()
new_user_name = widget_new_user_name.get_value().strip()
if not new_user_name:
gui.show_information('Create user', 'No user name given!')
return
if not source_user:
source_user = None
try:
self.user_manager.add_user(new_user_name, source_user)
if intvar_load_user.get():
self._change_user(new_user_name)
self._update_menubar_users()
except GUIExceptionUserError as e:
gui.show_error('Creating user', '{}\nUser not created. Try again!'.format(e.message))
popup_frame.destroy()
def manage_file(filename):
if filename == "archived":
return
extension = filename.split(".")[-1]
if extension.lower() not in ("jpg", "png", "jpeg"):
show_error(title="Несовместимый формат файла",
message=f"{extension} — несовместимый формат файла."
f" Допустимые: jpg, jpeg, png")
else:
image, classification_result = classify(f"scans/{filename}")
masked = make_mask_image(image, classification_result)
cv.imwrite("current_mask.jpg", masked)
h, w, _ = image.shape
pixel_area = scan_area / (h * w)
injured_pixels = 0
healthy_pixels = 0
for i in classification_result:
if i == 1:
healthy_pixels += 1
elif i == 2:
injured_pixels += 1
injured_area = injured_pixels * pixel_area
percentage = injured_pixels / (healthy_pixels + injured_pixels)
print(f"Поражённая площадь: {round(injured_area / 100, 2)} см2")
print(f"Поражено {round(percentage * 100, 2)} % листа")
print()
show_scan_info(filename=os.path.abspath(f"scans/{filename}"),
masked_filename=os.path.abspath("current_mask.jpg"),
injured_area=injured_area,
percentage=percentage,
w=w,
h=h)
new_path = f"scans\\archived\\{filename}"
if os.path.exists(new_path):
os.system(f"del /f {new_path}")
os.rename(f"scans\\{filename}", new_path)
def _save_file():
file_name = stringvar_entry.get()
if not file_name:
main_gui.show_information('Save file', 'No file name selected')
return
if file_name in self.settings_files.get_list():
from tkinter import messagebox
overwrite = messagebox.askyesno(
'Save file',
f'File name "{file_name}" exist. Would you like to overwrite this file?'
)
if not overwrite:
return
try:
self.settings_object.file_name = (file_name,
SETTINGS_FILES_DIRECTORY
) # Setter method
# Update Settings files object
self.settings_files.add_directory(
SETTINGS_FILES_DIRECTORY) # This will update files
self.settings_object.save()
# Update combobox
self._update_combobox_files()
self.combobox_files.set_value(file_name)
self.user.sampling_type_settings.setdefault(
'show_file', file_name)
except GISMOExceptionSaveNotAllowed:
main_gui.show_warning(
'Saving Sampling type settings',
f'Not allowed to overwrite file {self.settings_object.file_name}. '
f'Please save with a different name. ')
except GUIException as e:
main_gui.show_error(
'Save file',
'{}\nSomething went wrong Try again!'.format(e.message))
popup_frame.destroy()
def main():
parser = ArgumentParser(description = "Split a Patch")
parser.add_argument("input", metavar = "INPUT", type = str,
help = "either a patch file or a SVN Working Copy")
parser.add_argument("--gui", dest = "gui", action = "store_const",
const = True, default = "auto", help = "display GUI")
parser.add_argument("--no-gui", dest = "gui", action = "store_const",
const = False, help = "do not display GUI")
args = parser.parse_args()
if args.gui == "auto":
use_gui = detect_gui()
else:
use_gui = args.gui
if use_gui:
import gui as interface
else:
import cli as interface
try:
svn, patchset = get_patchset(args.input)
except Exception:
interface.show_error("Unable to read patchset from '%s'" % args.input)
sys.exit(1)
if not len(patchset):
interface.show_error("The patchset '%s' does not contain any patches" % args.input)
sys.exit(1)
try:
interface.show_patchset(svn, args.input, patchset)
except Exception:
interface.show_error("Unable to display patchset from '%s'" % args.input)
sys.exit(1)
sys.exit(0)
def _export_data(self):
directory = self.directory_widget_save_merge.get_value()
if not directory:
try:
gui.show_information(
'Missing input', 'Missing export directory. '
'Export canceled!')
except:
main_gui.show_information(
'Missing input', 'Missing export directory. '
'Export canceled!')
return
try:
# file_path = self.handler.save_merge_data(directory=directory, co2_types=selected_types)
# changed method name? @Johannes
# file_path = self.handler._save_merge_data(directory=directory, co2_types=selected_types)
# directory = self.directory_widget_save_merge.get_value()
if not directory:
main_gui.show_information(
'Missing input',
'Missing export directory. Export canceled!')
return
self.main_app.update_help_information(
'Exporting merge data. Please wait...', bg='red')
# Save data
deselected_types = self.handler.exclude_co2_types[:]
all_types = self.handler.get_types_in_merge_data()
selected_types = [''] + [
t for t in all_types if t not in deselected_types
]
try:
try:
save_directory = self.handler.save_data(
directory=directory, co2_types=selected_types)
except FileExistsError:
if not messagebox.askyesno(
'Save merge data',
'Merge data already exist. Do you want to overwrite files?'
):
return
save_directory = self.handler.save_data(
directory=directory,
co2_types=selected_types,
overwrite=True)
self.user.tavastland.set('deselected_types', deselected_types)
self.main_app.update_help_information('Export done!',
bg='green')
self.directory_widget_qc.set_value(self.handler.save_dir)
except PermissionError as e:
main_gui.show_error('PermissionError', e)
else:
main_gui.show_information(
'Export data',
f'Merged data has been exported:\n{save_directory}')
except Exception as e:
main_gui.show_internal_error(e)
def _merge_data(self):
"""
Merge data and export.
:return:
"""
try:
source = self.use_widget.get_value()
if 'time' in source:
time_start = self.time_widget_start.get_time_object()
time_end = self.time_widget_end.get_time_object()
# Have to add the day as well
time_end = time_end + datetime.timedelta(
days=1) - datetime.timedelta(seconds=1)
if not all([time_start, time_end]):
main_gui.show_information(
'Missing input',
'You have not made all required options to merge data. '
'Merge canceled!')
return
# Check time span
selected_time_delta = time_end - time_start
nr_days = self.user_manager.get_default_user_settings(
'tavastland', 'alert_t_delta_days')
if not nr_days:
nr_days = 60
if selected_time_delta.days > self.user.tavastland.setdefault(
'alert_t_delta_days', nr_days):
if not messagebox.askyesno(
'Time span warning!',
'Your selected time is {} days. '
'This might take som time to merge. '
'Do you want to continue?'.format(
selected_time_delta.days)):
self.main_app.update_help_information(
'Merge canceled by user do to long time span.')
return
# Set time range to work with
self.handler.set_time_range(time_start=time_start,
time_end=time_end)
elif 'month' in source:
year, month = self.month_widget.get() # year and month as int
time_start = datetime.datetime(year, month, 1)
time_end = datetime.datetime(year, month + 1,
1) - datetime.timedelta(seconds=1)
# Set time range to work with
self.handler.set_time_range(time_start=time_start,
time_end=time_end)
time_delta_seconds = self.time_widget_tolerance.get_value()
if not all([time_delta_seconds]):
main_gui.show_information(
'Missing input',
'You have not made all required options to merge data. '
'Merge canceled!')
return
self.main_app.update_help_information(
'Merging data. Please wait...', bg='red')
# Set timedelta
self.handler.set_time_delta(seconds=int(time_delta_seconds))
# Load data within time range
try:
self.handler.load_data()
except tavastland.TavastlandExceptionNoCO2data:
self.logger.debug('No CO2 data matches the given time!')
try:
gui.show_information(
'No match', 'No CO2 data matches the given time!')
except:
main_gui.show_information(
'No match', 'No CO2 data matches the given time!')
self.main_app.update_help_information('No co2 data found!')
return
# Merge data
self.handler.merge_data()
# Calculate pCO2
self.handler.calculate_pCO2()
all_types = self.handler.get_types_in_merge_data()
exclude_types = self.handler.exclude_co2_types
include_types = [t for t in all_types if t not in exclude_types]
self.stringvar_exclude_types.set(exclude_types)
self.stringvar_include_types.set(include_types)
self._enable_and_disable()
except tavastland.TavastlandExceptionNoMatchWhenMerging as e:
self.main_app.update_help_information(
'No match between mit and co2 files!')
main_gui.show_error('No match!', e.message)
except tavastland.TavastlandException as e:
self.main_app.update_help_information('Merge failed!')
main_gui.show_error('Could not merge data!', e.message)
except Exception as e:
main_gui.show_internal_error(e)
# self.main_app.update_help_information('Merge failed!')
# main_gui.show_error('Internal Error!', e)
# raise
else:
self.main_app.update_help_information('Merge done!', bg='green')
finally:
self._save_time_to_user()
def _load_file(self):
def load_file(data_file_path, **kwargs):
self.main_app.update_help_information('')
self.button_load_file.configure(state='disabled')
settings_file = self.combobox_widget_settings_file.get_value()
sampling_type = self.combobox_widget_sampling_type.get_value()
self.session.load_file(
sampling_type=sampling_type,
data_file_path=data_file_path,
settings_file=settings_file,
# settings_file_path=settings_file_path,
reload=False,
root_directory=self.root_directory,
**kwargs)
# self.reset_help_information()
data_file_path = self.stringvar_data_file.get()
settings_file = self.combobox_widget_settings_file.get_value()
settings_file_path = self.settings_files.get_path(settings_file)
# sampling_type = self.combobox_widget_sampling_type.get_value()
if not all([data_file_path, settings_file_path]):
self.main_app.update_help_information('No file selected!',
fg='red')
return
data_file_path = self.stringvar_data_file.get()
if ';' in data_file_path:
data_file_list = []
directory = None
for k, file_name in enumerate(data_file_path.split(';')):
file_name = file_name.strip()
if k == 0:
directory = os.path.dirname(file_name)
data_file_list.append(file_name)
else:
data_file_list.append(os.path.join(directory, file_name))
else:
data_file_list = [data_file_path]
for file_path in data_file_list:
# Load file
try:
load_file(file_path)
# self.run_progress(load_file, message='Loading file...please wait...')
except GISMOExceptionMissingPath as e:
self.logger.debug(e)
main_gui.show_information(
'Invalid path',
'The path "{}" given in i settings file "{} can not be found'
.format(e.message, settings_file_path))
self.main_app.update_help_information(
'Please try again with a different settings file.')
except GISMOExceptionMissingInputArgument as e:
self.logger.debug(e)
if 'depth' in e.message:
platform_depth = self.entry_widget_platform_depth.get_value(
)
if not platform_depth:
main_gui.show_information(
'No depth found!',
'You need to provide platform depth for this sampling type!'
)
return
load_file(file_path, depth=platform_depth)
except GISMOExceptionInvalidParameter as e:
self.logger.debug(e)
main_gui.show_information(
'Invalid parameter',
f'Could not find parameter {e}. Settings file might have wrong information.'
)
return
except GISMOExceptionQCfieldError:
main_gui.show_error(
'QC field error',
f'Something is wrong with the qf columns in file: {file_path}'
)
return
except Exception as e:
self.logger.debug(e)
main_gui.show_internal_error(e)
return
self.stringvar_data_file.set('')
self._update_loaded_files_widget()
self.update_all()
self.button_load_file.configure(state='normal')
self.main_app.update_help_information('File loaded! Please continue.',
bg='green')
def _callback_create_metadata_file(self, *args, **kwargs):
try:
# Check working path
working_directory = self._get_working_directory()
if not self._is_validate_working_directory(working_directory):
self.logger.debug(
f'Not a valid working directory: {working_directory}')
main_gui.show_information(
'Creating metadata file',
'You need to specify a valid working directory')
return
if not self.directory_exists(working_directory):
self.logger.debug(
f'Creating working directory: {working_directory}')
os.makedirs(working_directory)
delete_files = False
generate_subdir = False
if not self.directory_is_empty(working_directory):
if not messagebox.askyesno(
'Create metadata file',
'Working directory is not empty. Do you want to remove the old files and continue?'
):
if messagebox.askyesno(
'Create metadata file',
'Do you want to create a new subdirectory for your files instead?'
):
generate_subdir = True
else:
messagebox.showinfo('Create metadata file',
'Aborted by user')
return
else:
delete_files = True
if generate_subdir:
self._generate_subdirectory()
self._update_working_directory_information()
working_directory = self._get_working_directory()
self.logger.debug(
f'Subdirectory generated: {working_directory}')
self._update_working_directory_information()
elif delete_files:
ok = self._delete_files_in_directory(working_directory)
if not ok:
messagebox.showinfo(
'Create metadata file',
f'Could not remove files in directory {working_directory}'
)
return
self.logger.debug(f'Files deleted in: {working_directory}')
file_names = self.cnv_files_selection_widget.get_selected()
if not file_names:
self.logger.debug(f'No CNV files selected')
messagebox.showinfo('Create metadata file',
'No CNV files selected!')
return
file_paths = [
str(self.cnv_files_paths.get(file_name))
for file_name in file_names
]
session = ctdpy_session.Session(filepaths=file_paths,
reader='smhi')
start_time = time.time()
datasets = session.read()
self.logger.debug(
f'{len(file_paths)} CNV files loaded in {time.time()-start_time} seconds.'
)
# Check metadata
metadata = {}
for key, strvar in self.manual_metadata_stringvars.items():
value = strvar.get().strip()
if not value:
continue
metadata[key] = value
self.logger.debug(
f'{len(metadata)} metadata parameters selected for update')
# Update metadata in datasets
overwrite = self.boolean_overwrite_metadata.get()
self.logger.debug(f'Overwrite metadata is set to {overwrite}')
session.update_metadata(datasets=datasets[0],
metadata=metadata,
overwrite=overwrite)
self.logger.debug('Metadata updated in dataset')
# Save data
self._create_working_directory(working_directory)
start_time = time.time()
save_path = session.save_data(datasets[0],
writer='metadata_template',
return_data_path=True)
self.logger.debug(
f'Data saved in {time.time()-start_time} seconds at location {save_path}'
)
# Save options
self.user.create_options.set('overwrite_metadata', overwrite)
# Copy metadata file
source_path = Path(save_path)
target_path = Path(working_directory, source_path.name)
shutil.copy2(source_path, target_path)
# Copy cnv files
for file_path in file_paths:
source_path = Path(file_path)
target_path = Path(working_directory, source_path.name)
shutil.copy2(source_path, target_path)
self.main_app.update_help_information(
f'Data copied to: {working_directory}')
self.user.directory.set('working_directory', working_directory)
self.logger.info(f'Data moved to {working_directory}')
except ImportError as e:
self.logger.error(e)
main_gui.show_error('Internal error', e)
self._update_working_directory_information()
