def main():
configuration.load_components_info()
configuration.load_default_config()
import cliargparse
cliargs = cliargparse.parse_cli_args()
# This must be done *before* checking for existing processes, because a
# configuration file may haven't been set in the command arguments
configfile = configuration.set_configuration_file(cliargs)
configuration.set_update_only(cliargs)
if dbus:
check_existing_processes(configfile)
configuration.load_configuration()
import logger
logger.set_logger(cliargs)
# Make sure the main thread has a known name
threading.current_thread().setName(configuration.MAIN_THREAD_NAME)
sys.excepthook = handle_uncaught_exception
# The application must crash also if an exception is raised in a secondary
# thread, for example because if the thread has blocked the databases, it
# won't release them otherwise; yes, they could be released in a finally
# clause, but that would leave the database in an unknown state, which is
# pretty bad
install_thread_excepthook()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-i", "--input_path", type=str, required=True)
parser.add_argument("-o", "--output_path", type=str, required=True)
args = parser.parse_args()
dirs = ["trainval/", "test/"]
dirs = [args.output_path + d for d in dirs]
utils.make_dirs(dirs)
conf = configuration.load_configuration()
images = utils.collect_images(os.path.dirname(args.input_path))
# reproducible datasets
random.seed(1337)
random.shuffle(images)
rois = roi_metadata.read_metadata(args.input_path)
features_train = set(
os.path.basename(i)
for i in images[0:int(len(images) * conf.split_ratio)])
generate_dataset(rois, os.path.dirname(args.input_path), features_train,
dirs[0])
features_test = set(
os.path.basename(i)
for i in images[int(len(images) * conf.split_ratio):])
generate_dataset(rois, os.path.dirname(args.input_path), features_test,
dirs[1])
def main( argv ):
"""
Script execution entry point
@param argv Arguments passed to the script
@return Exit code (0 = success)
"""
config = configuration.load_configuration( 'aptaskd.json' )
address = ( 'localhost', config.get_address()[ 1 ] )
client = Client( address, config.keys[ 'users' ][ 0 ] )
pp = {
'indent' : 4,
'separators' : ( ',', ' : ' )
}
# example of fetching the task index
#index = client.get_task_index()
#print json.dumps( index, **pp )
#devtask = index[ 'index' ][ 0 ][ 'name' ]
devtask = 'DevTask'
if len( argv ) > 1:
start = int( argv[ 1 ] )
for devarg in range( start ):
result = client.start_task( devtask, ( devarg, ) )
active = client.get_active_tasks()
print json.dumps( active, **pp )
# return success
return 0
def main():
environment.configure_logging(logging.INFO)
environment_instance = environment.load_environment()
configuration_instance = configuration.load_configuration(environment_instance)
artifact_repository = os.path.normpath(environment_instance["artifact_repository"])
artifact_repository = os.path.join(artifact_repository, configuration_instance["project"], configuration_instance["project_version"]["branch"])
upload(artifact_repository, configuration_instance["distribution"], configuration_instance["project_version"], False)
def main( argv ):
"""
Script execution entry point
@param argv Arguments passed to the script
@return Exit code (0 = success)
"""
# imports when using this as a script
import argparse
import json
# install some signal handlers to override what Python installed
signal.signal( signal.SIGTERM, signal_handler )
signal.signal( signal.SIGINT, signal_handler )
# create and configure an argument parser
parser = argparse.ArgumentParser(
description = 'Asynchronous Parallel Task Execution Daemon Script'
)
parser.add_argument(
'-c',
'--config',
default = 'aptaskd.json',
help = 'Load configuration file from this location.'
)
parser.add_argument(
'-v',
'--version',
default = False,
help = 'Display script version.',
action = 'store_true'
)
# parse the arguments
args = parser.parse_args( argv[ 1 : ] )
# check for version request
if args.version == True:
print 'Version', __version__
return 0
# load configuration
config = configuration.load_configuration( args.config )
# check configuration
if config is None:
print 'invalid configuration'
return -1
# run the daemon until shut down
exit_code = start( config )
# return exit code
return exit_code
def main():
import argparse
parser = argparse.ArgumentParser(description='Generate pixel art dxf for input image.')
parser.add_argument('configuration_file', metavar='config', help='configurations for processing')
parser.add_argument('input_files', metavar='image', nargs='+', help='input images for processing')
parser.add_argument('--show', action='store_true', help='should show generated pixelated image (default false)')
parser.add_argument('--imgsave', action='store_true', help='save intermediate images (default false)')
parser.add_argument('--nodxf', action='store_true', help='do not generate dxf file (default false)')
args = parser.parse_args()
configurations = load_configuration(args.configuration_file)
for configuration in configurations:
variant = configuration.variant
print(f'### using configuration {variant} producing {configuration.width} x {configuration.height} pixels with pixel size {configuration.mmPerPixel}mm ###')
for input_file in args.input_files:
output_file = f'{os.path.splitext(input_file)[0]}_{variant}.dxf'
print(f'generating pixel art on input image {input_file} writing output dxf file')
(img_original, img_grayscale, img_pixelated) = prepare_images(input_file, args.imgsave, configuration)
if variant == 'circle':
circles = calculate_circles(img_pixelated, configuration)
if not args.nodxf:
generate_dxf_circles(circles, output_file, configuration)
if args.show == True:
show_output_images(img_original, img_grayscale, img_pixelated, circles, configuration)
if variant == 'band':
circles = calculate_circles(img_pixelated, configuration)
if not args.nodxf:
generate_dxf_horizontal_bands(circles, output_file, configuration)
if args.show == True:
show_output_images(img_original, img_grayscale, img_pixelated, circles, configuration)
if variant == 'stick':
sticks = calculate_sticks(img_pixelated, configuration)
if not args.nodxf:
output_file_stick_lengths = f'{os.path.splitext(input_file)[0]}_stick.txt'
generate_dxf_stick_circles(sticks, output_file, configuration)
write_stick_length_file(sticks, output_file_stick_lengths)
# if args.show == True:
# show_output_images(img_original, img_grayscale, img_pixelated, circles, configuration)
print()
def main():
script_path = os.path.realpath(__file__)
workspace_directory = os.path.dirname(os.path.dirname(script_path))
os.chdir(workspace_directory)
environment_instance = environment.load_environment()
configuration_instance = configuration.load_configuration(
environment_instance)
arguments = parse_arguments(environment_instance, configuration_instance)
environment.configure_logging(
logging.getLevelName(arguments.verbosity.upper()))
show_project_information(configuration_instance, arguments.simulate)
arguments.func(environment_instance, configuration_instance, arguments)
def main( argv ):
"""
Script execution entry point
@param argv Arguments passed to the script
@return Exit code (0 = success)
"""
import configuration
import log
conf = configuration.load_configuration( 'aptaskd.json' )
logger = log.Log( conf.get_log_file() )
m = Manager( conf, logger )
print m.handle_request( '{"request":"index"}' )
# return success
return 0
def main():
log_util.config(__file__)
logger = logging.getLogger(__name__)
logger.info('Prepare classification')
parser = argparse.ArgumentParser()
parser.add_argument("-i", "--input_path", type=str, required=True)
parser.add_argument("-o", "--output_path", type=str, required=True)
args = parser.parse_args()
conf = configuration.load_configuration()
dirs = [str(v) for _, v in conf.type2class_id.items()] + ["false_pos"]
dirs = [args.output_path + "/" + d for d in dirs]
utils.make_dirs(dirs)
rois = dataset.load_all_rois(args.input_path, dataset.no_false_positives)
generate_rois(os.path.dirname(args.input_path), rois, args.output_path)
rois = dataset.load_all_rois(args.input_path, dataset.only_false_positives)
generate_rois(os.path.dirname(args.input_path), rois, args.output_path)
import io
import random
import hashlib
import PIL.Image as Image
import tensorflow as tf
import configuration
import utils
from object_detection.utils import dataset_util
DetObject = collections.namedtuple(
"DetObject", ["name", "xmin", "ymin", "xmax", "ymax"])
conf = configuration.load_configuration()
def parse_voc(line):
elems = [e.strip() for e in line.split()]
return DetObject(
name=elems[0],
xmin=int(elems[4]),
ymin=int(elems[5]),
xmax=int(elems[6]),
ymax=int(elems[7]))
def get_image(img_path):
if os.path.exists(img_path + ".jpg"):
return img_path + ".jpg"
import logging
from pathlib import Path
from speedControl.speedController import build_controller as build_speed_controller
from sectionControl.sectionController import build_controller as build_section_controller
from switchControl.switchController import build_controller as build_switch_controller
app = Flask(__name__)
GPIO.setmode(GPIO.BCM)
logging.basicConfig(level=logging.INFO)
LOGGER = logging.getLogger("app")
LOGGER.info("Using flask version %s", __version__)
configuration = load_configuration()
sqlite_connection = sqliteConnectionProvider.get_sqlite_connection(
configuration)
switch_dao = SwitchDao(sqlite_connection)
section_dao = SectionDao(sqlite_connection)
atexit.register(GPIO.cleanup)
if Path(configuration['arduino_port']).is_char_device():
app.register_blueprint(build_speed_controller(configuration))
else:
LOGGER.warning(
"Configured arduino port {} is not a char device. Impacted resources will not be available."
.format(configuration['arduino_port']))
def create(self, arg):
if arg == 'config':
conf = configuration.load_configuration()
configuration.save_configuration(conf)
else:
raise ValueError('Unkonwn argument for create!' + str(arg))
args = []
else:
command = sys.argv[1]
args = sys.argv[2:]
# separate arguments with commans instead whitespace
args = ' '.join(args)
args = args.split(',') if args else []
try:
cal = Calendar.load()
except FileNotFoundError:
print('No calendar file found! Create new ´.planner/cal´.')
cal = Calendar()
conf = configuration.load_configuration()
cali = CalendarInterface(cal, conf['CalendarInterface'])
func = cali.__class__.__dict__[command]
#import ipdb; ipdb.set_trace()
params = parse_command_parameters(args, func.__code__.co_varnames[1:])
func(cali, **params)
cal.save()
"""
if command == 'add':
cali.add(**paras)
elif command == 'do':
cali.do(**paras)
elif command == 'undo':
cali.undo(' '.join(args))
elif command == 'edit':
