class NewGame(AnchorLayout):
app = ObjectProperty(None)
config = ObjectProperty(None)
settings = ObjectProperty(None)
def __init__(self, **kwargs):
super(NewGame, self).__init__(**kwargs)
self.config = ConfigParser()
self.config.read(tttraders_user_conf('tttraders.ini'))
self.settings.register_type("int", TTSettingInt)
for tab in TradersGame.ConfigTabs:
lst = TradersGame.Config[tab]
for c in lst:
if c.get("key", None):
self.config.adddefaultsection(c['section'])
self.config.setdefault(c['section'], c['key'], c.get("default", None))
self.settings.add_json_panel(tab, self.config, data=json.dumps(lst))
def get_config():
config = ConfigParser()
config.read('config.ini')
config.adddefaultsection('game')
config.setdefault('game', 'outside_coordinates', True)
config.setdefault('game', 'show_pieces', True)
config.setdefault('game', 'square_coordinates', False)
return config
from kivy.app import App
from kivy.properties import StringProperty
from kivy.lang import Builder
import csv
import os
import json
app = App.get_running_app()
from kivy.config import ConfigParser
config = ConfigParser()
config.read('myconfig.ini')
config.adddefaultsection('pycon2018')
config.setdefault('pycon2018', 'register_data_dir', 'data')
class ScreenRegister(Factory.Screen):
_data = {}
'''Holds the data in :attr:`data_file_dir` was processed or not.
:attr:`_data` is a :type:`String`, defaults to False.
'''
data_file_dir = StringProperty(config.get(
'pycon2018', 'register_data_dir'))
'''This is the data dir where the registeration data is stored.
All csv files should be present in this folder.
:attr:`data_file_dir` is a :class:`~kivy.properties.StringProperty`
class UserPrefs(EventDispatcher):
'''
A class to manage user preferences for the RaceCapture app
'''
DEFAULT_DASHBOARD_SCREENS = ['5x_gauge_view', 'laptime_view', 'tach_view', 'rawchannel_view']
DEFAULT_PREFS_DICT = {'range_alerts': {},
'gauge_settings':{},
'screens':DEFAULT_DASHBOARD_SCREENS,
'alerts': {}}
DEFAULT_ANALYSIS_CHANNELS = ['Speed']
prefs_file_name = 'prefs.json'
def __init__(self, data_dir, user_files_dir, save_timeout=0.2, **kwargs):
self._prefs_dict = UserPrefs.DEFAULT_PREFS_DICT
self.config = ConfigParser()
self.data_dir = data_dir
self.user_files_dir = user_files_dir
self.prefs_file = path.join(self.data_dir, self.prefs_file_name)
self.register_event_type("on_pref_change")
self.load()
def on_pref_change(self, section, option, value):
pass
def set_range_alert(self, key, range_alert):
'''
Sets a range alert with the specified key
:param key the key for the range alert
:type string
:param range_alert the range alert
:type object
'''
self._prefs_dict["range_alerts"][key] = range_alert
self.save()
def get_range_alert(self, key, default=None):
'''
Retrives a range alert for the specified key
:param key the key for the range alert
:type key string
:param default the default value, optional
:type default user specified
:return the range alert, or the default value
'''
return self._prefs_dict["range_alerts"].get(key, default)
def get_alertrules(self, channel):
'''
Retrieve the alert_rules for the specified channel. If the
alertrules do not exist for the specified channel, return an empty
default AlertRuleCollection
:return AlertRuleCollection
'''
alertrules = self._prefs_dict['alerts'].get(channel)
if alertrules is None:
alertrules = AlertRuleCollection(channel, [])
self._prefs_dict['alerts'][channel] = alertrules
return alertrules
def set_alertrules(self, channel, alertrules):
self._prefs_dict['alerts'][channel] = alertrules
self.save()
def set_gauge_config(self, gauge_id, config_value):
'''
Stores a gauge configuration for the specified gauge_id
:param gauge_id the key for the gauge
:type gauge_id string
:param config_value the configuration value to set
:type config_value string
'''
self._prefs_dict["gauge_settings"][gauge_id] = config_value
self.save()
def get_gauge_config(self, gauge_id):
'''
Get the gauge configuration for the specified gauge_id
:param gauge_id the key for the gauge
:type string
:return the gauge configuration
'''
return self._prefs_dict["gauge_settings"].get(gauge_id, False)
def get_dashboard_screens(self):
return copy(self._prefs_dict['screens'])
def set_dashboard_screens(self, screens):
self._prefs_dict['screens'] = copy(screens)
self.save()
# Regular preferences below here
def get_last_selected_track_id(self):
return self.get_pref('track_detection', 'last_selected_track_id')
def get_last_selected_track_timestamp(self):
return self.get_pref_int('track_detection', 'last_selected_track_timestamp')
def get_user_cancelled_location(self):
return self.get_pref('track_detection', 'user_cancelled_location')
def set_last_selected_track(self, track_id, timestamp, user_cancelled_location='0,0'):
self.set_pref('track_detection', 'last_selected_track_id', track_id)
self.set_pref('track_detection', 'last_selected_track_timestamp', timestamp)
self.set_pref('track_detection', 'user_cancelled_location', user_cancelled_location)
self.save()
@property
def datastore_location(self):
return os.path.join(self.data_dir, 'datastore.sq3')
def save(self, *largs):
'''
Saves the current configuration
'''
Logger.info('UserPrefs: Saving preferences')
with open(self.prefs_file, 'w+') as prefs_file:
data = self.to_json()
prefs_file.write(data)
def set_config_defaults(self):
'''
Set defaults for preferences
'''
# Base system preferences
self.config.adddefaultsection('help')
self.config.adddefaultsection('preferences')
self.config.setdefault('preferences', 'distance_units', 'miles')
self.config.setdefault('preferences', 'temperature_units', 'Fahrenheit')
self.config.setdefault('preferences', 'show_laptimes', 1)
self.config.setdefault('preferences', 'startup_screen', 'Home Page')
default_user_files_dir = self.user_files_dir
self.config.setdefault('preferences', 'config_file_dir', default_user_files_dir)
self.config.setdefault('preferences', 'export_file_dir', default_user_files_dir)
self.config.setdefault('preferences', 'firmware_dir', default_user_files_dir)
self.config.setdefault('preferences', 'import_datalog_dir', default_user_files_dir)
self.config.setdefault('preferences', 'send_telemetry', '0')
self.config.setdefault('preferences', 'record_session', '1')
self.config.setdefault('preferences', 'global_help', True)
# Connection type for mobile
if is_mobile_platform():
if is_android():
self.config.setdefault('preferences', 'conn_type', 'Bluetooth')
elif is_ios():
self.config.setdefault('preferences', 'conn_type', 'WiFi')
else:
self.config.setdefault('preferences', 'conn_type', 'Serial')
# Dashboard preferences
self.config.adddefaultsection('dashboard_preferences')
self.config.setdefault('dashboard_preferences', 'last_dash_screen', '5x_gauge_view')
self.config.setdefault('dashboard_preferences', 'pitstoptimer_enabled', 1)
self.config.setdefault('dashboard_preferences', 'pitstoptimer_trigger_speed', 5)
self.config.setdefault('dashboard_preferences', 'pitstoptimer_alert_speed', 25)
self.config.setdefault('dashboard_preferences', 'pitstoptimer_exit_speed', 55)
# Track detection pref
self.config.adddefaultsection('track_detection')
self.config.setdefault('track_detection', 'last_selected_track_id', 0)
self.config.setdefault('track_detection', 'last_selected_track_timestamp', 0)
self.config.setdefault('track_detection', 'user_cancelled_location', '0,0')
self.config.adddefaultsection('analysis_preferences')
self.config.setdefault('analysis_preferences', 'selected_sessions_laps', '{"sessions":{}}')
self.config.setdefault('analysis_preferences', 'selected_analysis_channels', ','.join(UserPrefs.DEFAULT_ANALYSIS_CHANNELS))
self.config.adddefaultsection('setup')
self.config.setdefault('setup', 'setup_enabled', 1)
def load(self):
Logger.info('UserPrefs: Data Dir is: {}'.format(self.data_dir))
self.config.read(os.path.join(self.data_dir, 'preferences.ini'))
self.set_config_defaults()
try:
with open(self.prefs_file, 'r') as data:
content = data.read()
content_dict = json.loads(content)
if content_dict.has_key("gauge_settings"):
for id, channel in content_dict["gauge_settings"].iteritems():
self._prefs_dict["gauge_settings"][id] = channel
if content_dict.has_key('screens'):
self._prefs_dict['screens'] = content_dict['screens']
if content_dict.has_key('alerts'):
for channel, alertrules in content_dict['alerts'].iteritems():
self._prefs_dict['alerts'][channel] = AlertRuleCollection.from_dict(alertrules)
except Exception as e:
Logger.error('Error loading preferences, using defaults. {}'.format(e))
def init_pref_section(self, section):
'''
Initializes a preferences section with the specified name.
if the section already exists, there is no effect.
:param section the name of the preference section
:type string
'''
self.config.adddefaultsection(section)
def get_pref_bool(self, section, option, default=None):
'''
Retrieve a preferences value as a bool.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default bool
:return bool preference value
'''
try:
return self.config.getboolean(section, option)
except (NoOptionError, ValueError):
return default
def get_pref_float(self, section, option, default=None):
'''
Retrieve a preferences value as a float.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default float
:return float preference value
'''
try:
return self.config.getfloat(section, option)
except (NoOptionError, ValueError):
return default
def get_pref_int(self, section, option, default=None):
'''
Retrieve a preferences value as an int.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default user specified
:return int preference value
'''
try:
return self.config.getint(section, option)
except (NoOptionError, ValueError):
return default
def get_pref(self, section, option, default=None):
'''
Retrieve a preferences value as a string.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default user specified
:return string preference value
'''
try:
return self.config.get(section, option)
except (NoOptionError, ValueError):
return default
def get_pref_list(self, section, option, default=[]):
"""
Retrieve a preferences value as a list.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default user specified
:return list of string values
"""
try:
return self.config.get(section, option).split(',')
except (NoOptionError, ValueError):
return default
def set_pref(self, section, option, value):
'''
Set a preference value
:param section the configuration section for the preference
:type string
:param option the option for the section
:type string
:param value the preference value to set
:type value user specified
'''
current_value = None
try:
current_value = self.config.get(section, option)
except NoOptionError:
pass
self.config.set(section, option, value)
self.config.write()
if value != current_value:
self.dispatch('on_pref_change', section, option, value)
def set_pref_list(self, section, option, value):
"""
Set a preference value by list
:param section the configuration section for the preference
:type string
:param option the option for the section
:type string
:param value the preference value to set
:type value list (list of strings)
"""
try:
self.set_pref(section, option, ','.join(value))
except TypeError:
Logger.error('UserPrefs: failed to set preference list for {}:{} - {}'.format(section, option, value))
def to_json(self):
'''
Serialize preferences to json
'''
data = {'range_alerts': {}, 'gauge_settings':{}, 'screens': [], 'alerts': {}}
for name, range_alert in self._prefs_dict["range_alerts"].iteritems():
data["range_alerts"][name] = range_alert.to_dict()
for id, channel in self._prefs_dict["gauge_settings"].iteritems():
data["gauge_settings"][id] = channel
for name, alertrules in self._prefs_dict['alerts'].iteritems():
data['alerts'][name] = alertrules.to_dict()
data['screens'] = self._prefs_dict['screens']
return json.dumps(data, sort_keys=True, indent=2, separators=(',', ': '))
class mainApp(App):
def build(self):
Window.clearcolor = (228. / 255., 228. / 255., 228. / 255., 1)
self.title = "GrunwaldCalc"
Window.minimum_width = 300
Window.minimum_height = 200
self.config = ConfigParser()
self.config.read("config.ini")
self.config.adddefaultsection("Settings")
self.config.setdefault("Settings", "Language",
locale.getdefaultlocale()[0])
self.language = self.config.getdefault("Settings", "Language",
locale.getdefaultlocale()[0])
self.settings = Settings()
self.day_calc = DayCalc.Calculate()
self.date_finder = DateFinder.WikiScrape()
self.day_calc.changeLanguage(self.language)
self.date_finder.changeLanguage(self.language)
self.container = BoxLayout(orientation="vertical")
self.search_layout = BoxLayout(orientation="horizontal",
size_hint=(1, 0.25),
height=100)
self.results_layout = AnchorLayout(anchor_y="top")
self.container.add_widget(self.search_layout)
self.container.add_widget(self.results_layout)
try:
with open("./languages/" + self.language + ".lang",
encoding="UTF-8") as language_file:
self.language_file = json.load(language_file)
except FileNotFoundError:
self.language = "en_US"
with open("./languages/" + self.language + ".lang",
encoding="UTF-8") as language_file:
self.language_file = json.load(language_file)
self.search_box = TextInput(hint_text=(self.language_file["hint"]),
size_hint=(0.7, None),
height=50,
multiline=False)
self.search_button = Button(text=self.language_file["button-text"],
size_hint=(0.3, None),
height=50)
self.search_layout.add_widget(self.search_box)
self.search_layout.add_widget(self.search_button)
self.search_box.bind(on_text_validate=self.start_main)
self.search_button.bind(on_press=self.start_main)
return self.container
def start_main(self, instance):
text_value = ''.join(char for char in self.search_box.text
if char.isnumeric())
if 4 < len(text_value) < 9:
self.results_layout.clear_widgets()
self.date = self.day_calc.findWeekday(text_value)
self.result_label = Label(
text=self.language_file["single-date"].format(self.date),
markup=True)
self.results_layout.add_widget(self.result_label)
else:
self.results_layout.clear_widgets()
try:
self.event_dates = (self.date_finder.findEventDate(
self.search_box.text))
self.event_weekdays = []
for date in self.event_dates:
self.event_weekdays.append(
self.day_calc.findWeekday(self.event_dates[date]))
if len(self.event_dates) == 2:
self.result_label = Label(
text=self.language_file["from-to-date"].format(
self.event_dates['from'], self.event_weekdays[0],
self.event_dates['to'], self.event_weekdays[1]),
markup=True,
size_hint=(1, None))
self.result_label.text_size = (self.results_layout.width -
40,
self.results_layout.height)
self.results_layout.add_widget(self.result_label)
else:
self.result_label = Label(
text=self.language_file["from-to-date"].format(
self.event_dates['date'], self.event_weekdays[0]),
markup=True,
size_hint=(1, None))
self.result_label.text_size = (self.results_layout.width -
40,
self.results_layout.height)
self.results_layout.add_widget(self.result_label)
except LookupError:
self.result_label = Label(
text=self.language_file["lookup-error"], markup=True)
self.results_layout.add_widget(self.result_label)
class Settings:
def __init__(self):
self.Config = ConfigParser()
self.Config.add_section('Input')
self.Config.add_section('Processor')
self.Config.add_section('Output')
# default values
self.cfgfilename = 'default.conf'
self.helpfile = 'doc/PyFSPro_dataflow.jpg'
self.numframes = 255 # No. of frames in stack
self.color_mode = -1 # Greyscale output
self.video_src = 0 # Default camera
self.video_width = 1024
self.video_height = 768
self.show_inp = True
self.show_out = True
self.show_vec = False
self.show_help = False
# settings for video and image sequence recording
self.recordi = False
self.recordv = False
self.novfile = True
self.imgindx = 0
self.output_path = './output/'
self.image_dst = self.output_path
self.video_dst = self.output_path
# switches for image filters and tools
self.blr_inp = False
self.blr_out = False
self.blr_strength = 7
self.equ_inp = 0
self.equ_out = 0
self.dnz_inp = False
self.dnz_out = False
self.dnz_inp_str = 33
self.dnz_out_str = 33
self.flt_inp = 0
self.flt_out = 0
self.flt_inp_strength = 0
self.flt_out_strength = 0
self.flt_inp_kernel = None
self.flt_out_kernel = None
self.flip_x = False
self.flip_y = False
self.inp_kernel = None
self.out_kernel = None
#self.mode_in = 0
self.mode_prc = 0
#self.mode_out = 0
self.pseudoc = False
self.dyn_dark = True
self.gain_inp = 1.0
self.gain_out = 1.0
self.offset_inp = 0
self.offset_out = 0
self.vec_zoom = 0.1
self.loop = False
self.stb_inp = False
self.stb_out = False
self.osd_txtline = 2
self.green = (0, 255, 0)
self.red = (0, 0, 255)
self.blue = (255, 0, 0)
self.black = (0, 0, 0)
self.colormaps = [
'AUTUMN', 'BONE', 'JET', 'WINTER', 'RAINBOW', 'OCEAN', 'SUMMER',
'SPRING', 'COOL', 'HSV', 'PINK', 'HOT'
]
self.set_defaults()
def gettime(self):
self.timestring = time.strftime("%Y%m%d-%H%M%S", time.gmtime())
return self.timestring
def set_defaults(self):
# Section 'Input'
self.Config.setdefault('Input', 'video_src', self.video_src)
self.Config.setdefault('Input', 'video_width', self.video_width)
self.Config.setdefault('Input', 'video_height', self.video_height)
self.Config.setdefault('Input', 'loop', self.loop)
self.Config.setdefault('Input', 'flip_x', self.flip_x)
self.Config.setdefault('Input', 'flip_y', self.flip_y)
self.Config.setdefault('Input', 'blr_inp', self.blr_inp)
self.Config.setdefault('Input', 'equ_inp', self.equ_inp)
self.Config.setdefault('Input', 'dnz_inp', self.dnz_inp)
self.Config.setdefault('Input', 'dnz_inp_str', self.dnz_inp_str)
self.Config.setdefault('Input', 'flt_inp', self.flt_inp)
self.Config.setdefault('Input', 'flt_inp_strength',
self.flt_inp_strength)
#self.Config.setdefault('Input','mode_in', self.mode_in)
self.Config.setdefault('Input', 'gain_inp', self.gain_inp)
self.Config.setdefault('Input', 'offset_inp', self.offset_inp)
self.Config.setdefault('Input', 'stb_inp', self.stb_inp)
# Section 'Processor'
self.Config.setdefault('Processor', 'mode_prc', self.mode_prc)
self.Config.setdefault('Processor', 'dyn_dark', self.dyn_dark)
self.Config.setdefault('Processor', 'blr_strength', self.blr_strength)
self.Config.setdefault('Processor', 'numframes', self.numframes)
# Section 'Output'
self.Config.setdefault('Output', 'video_dst', self.video_dst)
self.Config.setdefault('Output', 'image_dst', self.image_dst)
self.Config.setdefault('Output', 'recordv', self.recordv)
self.Config.setdefault('Output', 'recordi', self.recordi)
self.Config.setdefault('Output', 'blr_out', self.blr_out)
self.Config.setdefault('Output', 'equ_out', self.equ_out)
self.Config.setdefault('Output', 'dnz_out', self.dnz_out)
self.Config.setdefault('Output', 'dnz_out_str', self.dnz_out_str)
self.Config.setdefault('Output', 'flt_out', self.flt_out)
self.Config.setdefault('Output', 'flt_out_strength',
self.flt_out_strength)
#self.Config.setdefault('Output','mode_out', self.mode_out)
self.Config.setdefault('Output', 'gain_out', self.gain_out)
self.Config.setdefault('Output', 'offset_out', self.offset_out)
self.Config.setdefault('Output', 'color_mode', self.color_mode)
self.Config.setdefault('Output', 'pseudoc', self.pseudoc)
self.Config.setdefault('Output', 'vec_zoom', self.vec_zoom)
self.Config.setdefault('Output', 'stb_out', self.stb_out)
def write_config(self, filename):
if filename is None:
filename = self.cfgfilename
self.cfgfile = open(filename, 'w')
# Section 'Input'
self.Config.set('Input', 'video_src', self.video_src)
self.Config.set('Input', 'video_width', self.video_width)
self.Config.set('Input', 'video_height', self.video_height)
self.Config.set('Input', 'loop', self.loop)
self.Config.set('Input', 'flip_x', self.flip_x)
self.Config.set('Input', 'flip_y', self.flip_y)
self.Config.set('Input', 'blr_inp', self.blr_inp)
self.Config.set('Input', 'equ_inp', self.equ_inp)
self.Config.set('Input', 'dnz_inp', self.dnz_inp)
self.Config.set('Input', 'dnz_inp_str', self.dnz_inp_str)
self.Config.set('Input', 'flt_inp', self.flt_inp)
self.Config.set('Input', 'flt_inp_strength', self.flt_inp_strength)
#self.Config.set('Input','mode_in', self.mode_in)
self.Config.set('Input', 'gain_inp', self.gain_inp)
self.Config.set('Input', 'offset_inp', self.offset_inp)
self.Config.set('Input', 'stb_inp', self.stb_inp)
# Section 'Processor'
self.Config.set('Processor', 'mode_prc', self.mode_prc)
self.Config.set('Processor', 'dyn_dark', self.dyn_dark)
self.Config.set('Processor', 'blr_strength', self.blr_strength)
self.Config.set('Processor', 'numframes', self.numframes)
# Section 'Output'
self.Config.set('Output', 'video_dst', self.video_dst)
self.Config.set('Output', 'image_dst', self.image_dst)
self.Config.set('Output', 'recordv', self.recordv)
self.Config.set('Output', 'recordi', self.recordi)
self.Config.set('Output', 'blr_out', self.blr_out)
self.Config.set('Output', 'equ_out', self.equ_out)
self.Config.set('Output', 'dnz_out', self.dnz_out)
self.Config.set('Output', 'dnz_out_str', self.dnz_out_str)
self.Config.set('Output', 'flt_out', self.flt_out)
self.Config.set('Output', 'flt_out_strength', self.flt_out_strength)
#self.Config.set('Output','mode_out', self.mode_out)
self.Config.set('Output', 'gain_out', self.gain_out)
self.Config.set('Output', 'offset_out', self.offset_out)
self.Config.set('Output', 'color_mode', self.color_mode)
self.Config.set('Output', 'pseudoc', self.pseudoc)
self.Config.set('Output', 'vec_zoom', self.vec_zoom)
self.Config.set('Output', 'stb_out', self.stb_out)
self.Config.write(self.cfgfile)
self.cfgfile.close()
def read_config(self, filename):
if os.path.isfile(filename):
self.Config.read(filename)
self.video_src = self.Config.get('Input', 'video_src')
self.video_width = int(self.Config.get('Input', 'video_width'))
self.video_height = int(self.Config.get('Input', 'video_height'))
self.loop = self.Config.getboolean('Input', 'loop')
self.flip_x = self.Config.getboolean('Input', 'flip_x')
self.flip_y = self.Config.getboolean('Input', 'flip_y')
self.blr_inp = self.Config.getboolean('Input', 'blr_inp')
self.equ_inp = int(self.Config.get('Input', 'equ_inp'))
self.dnz_inp = self.Config.getboolean('Input', 'dnz_inp')
self.dnz_inp_str = float(self.Config.get('Input', 'dnz_inp_str'))
self.flt_inp = int(self.Config.get('Input', 'flt_inp'))
self.flt_inp_strength = float(
self.Config.get('Input', 'flt_inp_strength'))
self.gain_inp = float(self.Config.get('Input', 'gain_inp'))
self.offset_inp = float(self.Config.get('Input', 'offset_inp'))
self.stb_inp = self.Config.getboolean('Input', 'stb_inp')
self.mode_prc = int(self.Config.get('Processor', 'mode_prc'))
self.dyn_dark = self.Config.getboolean('Processor', 'dyn_dark')
self.blr_strength = int(
self.Config.get('Processor', 'blr_strength'))
self.numframes = int(self.Config.get('Processor', 'numframes'))
self.video_dst = self.Config.get('Output', 'video_dst')
self.image_dst = self.Config.get('Output', 'image_dst')
self.recordv = self.Config.getboolean('Output', 'recordv')
self.recordi = self.Config.getboolean('Output', 'recordi')
self.blr_out = self.Config.getboolean('Output', 'blr_out')
self.equ_out = int(self.Config.get('Output', 'equ_out'))
self.dnz_out = self.Config.getboolean('Output', 'dnz_out')
self.dnz_out_str = float(self.Config.get('Output', 'dnz_out_str'))
self.flt_out = int(self.Config.get('Output', 'flt_out'))
self.flt_out_strength = float(
self.Config.get('Output', 'flt_out_strength'))
self.gain_out = float(self.Config.get('Output', 'gain_out'))
self.offset_out = float(self.Config.get('Output', 'offset_out'))
self.color_mode = int(self.Config.get('Output', 'color_mode'))
self.pseudoc = self.Config.getboolean('Output', 'pseudoc')
self.vec_zoom = float(self.Config.get('Output', 'vec_zoom'))
self.stb_out = self.Config.getboolean('Output', 'stb_out')
else:
print('File ' + str(filename) + ' does not exist.')
