def test_new_localization_workflow(self):
# Write a new localization.
article_dir = os.path.join(Article.LOCALIZED_ROOT, 'de')
os.makedirs(article_dir)
with open(os.path.join(article_dir, 'article1.html'), 'w') as f:
text = r'%s{%% tag %%}%sBeispiel' % (UNTRANSLATABLE_BEGIN,
UNTRANSLATABLE_END)
f.write(text)
l7r = Localizer(original_root=Article.ROOT,
localized_root=Article.LOCALIZED_ROOT)
self.assertEqual(1, len(l7r.articles))
# Test writing localizable HTML
l7r.GenerateLocalizableFiles()
self.assertTrue(os.path.exists(l7r.articles[0].localizable_file_path))
self.assertTrue(os.path.isfile(l7r.articles[0].localizable_file_path))
# Test importataion.
l7r.ImportLocalizedFiles()
self.assertEqual([], l7r.articles[0].new_localizations)
self.assertTrue(os.path.exists(l7r.articles[0].GetOriginalFilePath('en')))
self.assertTrue(os.path.isfile(l7r.articles[0].GetOriginalFilePath('en')))
self.assertTrue(os.path.exists(l7r.articles[0].GetOriginalFilePath('de')))
self.assertTrue(os.path.isfile(l7r.articles[0].GetOriginalFilePath('de')))
# Verify contents
with open(l7r.articles[0].GetOriginalFilePath('de'), 'r') as infile:
contents = infile.read()
self.assertEqual("{% tag %}Beispiel", contents)
def testSimple(self):
l7r = Localizer(original_root=os.path.join(TEST_ROOT, 'test_fixtures',
'localizer_simple'))
l7r.GenerateLocalizableFiles()
for article in l7r.articles:
self.__created_files.append(article.localizable_file_path)
self.assertTrue(os.path.exists(article.localizable_file_path))
self.assertTrue(os.path.isfile(article.localizable_file_path))
def testSimple(self):
l7r = Localizer(original_root=os.path.join(TEST_ROOT, 'test_fixtures',
'localizer_simple'))
self.assertEqual(3, len(l7r.articles))
self.assertEqual(
os.path.join(TEST_ROOT, 'test_fixtures', 'localizer_simple',
'article1'), l7r.articles[0].path)
self.assertEqual(
os.path.join(TEST_ROOT, 'test_fixtures', 'localizer_simple',
'article2'), l7r.articles[1].path)
self.assertEqual(
os.path.join(TEST_ROOT, 'test_fixtures', 'localizer_simple',
'article3'), l7r.articles[2].path)
def __init__(self):
# Initialize ROS node
rospy.init_node("Controller")
self.name = "Controller object"
self.rate = rospy.Rate(10) # allow node to 'spin' at 10hz
rospy.on_shutdown(self.shutdown) # calls this function when Ctrl+C
self.motion = Motion()
self.sensor = Sensor()
self.localizer = Localizer()
self.visited_highlights = []
# Boolean for reached goal
self.goalReached = False
def testDeeper(self):
l7r = Localizer(original_root=os.path.join(TEST_ROOT, 'test_fixtures',
'localizer_deeper'))
self.assertEqual(6, len(l7r.articles))
self.assertEqual(
os.path.join(TEST_ROOT, 'test_fixtures', 'localizer_deeper',
'path1', 'path2', 'article1'), l7r.articles[0].path)
self.assertEqual(
os.path.join(TEST_ROOT, 'test_fixtures', 'localizer_deeper',
'path1', 'path2', 'article2'), l7r.articles[1].path)
self.assertEqual(
os.path.join(TEST_ROOT, 'test_fixtures', 'localizer_deeper',
'path1', 'path2', 'article3'), l7r.articles[2].path)
self.assertEqual(
os.path.join(TEST_ROOT, 'test_fixtures', 'localizer_deeper',
'path3', 'path4', 'article4'), l7r.articles[3].path)
self.assertEqual(
os.path.join(TEST_ROOT, 'test_fixtures', 'localizer_deeper',
'path3', 'path4', 'article5'), l7r.articles[4].path)
self.assertEqual(
os.path.join(TEST_ROOT, 'test_fixtures', 'localizer_deeper',
'path3', 'path4', 'article6'), l7r.articles[5].path)
def __init__(self, test_run):
super(main_window, self).__init__()
self.lysing = True
# get our experiment variables
if test_run != 'True':
self.get_experiment_variables()
# Set up the user interface
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# set up the video classes
self.vid = ShowVideo(self.ui.verticalLayoutWidget.size())
self.screen_shooter = screen_shooter()
self.image_viewer = ImageViewer()
# self.autofocuser = autofocuser()
self.localizer = Localizer()
# add the viewer to our ui
self.ui.verticalLayout.addWidget(self.image_viewer)
# create our extra threads
self.screenshooter_thread = QThread()
self.screenshooter_thread.start()
self.screen_shooter.moveToThread(self.screenshooter_thread)
# self.autofocuser_thread = QThread()
# self.autofocuser_thread.start()
# self.autofocuser.moveToThread(self.autofocuser_thread)
self.localizer_thread = QThread()
self.localizer_thread.start()
self.localizer.moveToThread(self.localizer_thread)
self.video_input_thread = QThread()
self.video_input_thread.start()
self.vid.moveToThread(self.video_input_thread)
# connect the outputs to our signals
self.vid.VideoSignal.connect(self.image_viewer.setImage)
self.vid.vid_process_signal.connect(
self.screen_shooter.screenshot_slot)
# self.vid.vid_process_signal.connect(self.autofocuser.vid_process_slot)
self.vid.vid_process_signal.connect(self.localizer.vid_process_slot)
self.qswitch_screenshot_signal.connect(
self.screen_shooter.save_qswitch_fire_slot)
self.localizer.qswitch_screenshot_signal.connect(
self.screen_shooter.save_qswitch_fire_slot)
# self.start_focus_signal.connect(self.autofocuser.autofocus)
self.start_localization_signal.connect(self.localizer.localize)
# self.autofocuser.position_and_variance_signal.connect(self.plot_variance_and_position)
self.image_viewer.click_move_signal.connect(stage.click_move_slot)
self.localizer.localizer_move_signal.connect(stage.localizer_move_slot)
self.localizer.ai_fire_qswitch_signal.connect(
self.ai_fire_qswitch_slot)
self.localizer.start_laser_flash_signal.connect(
self.start_laser_flash_slot)
self.localizer.stop_laser_flash_signal.connect(
self.stop_laser_flash_slot)
self.vid.reticle_and_center_signal.connect(
stage.reticle_and_center_slot)
self.vid.reticle_and_center_signal.emit(self.vid.center_x,
self.vid.center_y,
self.vid.reticle_x,
self.vid.reticle_y)
# connect to the video thread and start the video
self.start_video_signal.connect(self.vid.startVideo)
self.start_video_signal.emit()
# Screenshot and comment buttons
self.ui.misc_screenshot_button.clicked.connect(
self.screen_shooter.save_misc_image)
self.ui.user_comment_button.clicked.connect(self.send_user_comment)
self.ui.noise_filter_checkbox.stateChanged.connect(
self.noise_filter_check_changed)
# Stage movement buttons
self.ui.step_size_doublespin_box.valueChanged.connect(
stage.set_step_size)
self.setup_combobox()
self.localizer.get_position_signal.connect(stage.get_position_slot)
stage.position_return_signal.connect(
self.localizer.position_return_slot)
# Laser control buttons
self.ui.qswitch_delay_doublespin_box.valueChanged.connect(
laser.set_delay)
self.ui.attenuator_doublespin_box.valueChanged.connect(
attenuator.set_attenuation)
self.ui.cells_to_lyse_doublespin_box.valueChanged.connect(
self.localizer.set_cells_to_lyse)
self.ui.process_well_pushButton.clicked.connect(
self.start_localization)
self.show()
comment('finished gui init')
# TODO: showcase localizer and goniometer
# create a picture
# load the best localizer and goniometer
# load an image
# make a b/w version
# use localizer to find resistors
# pass the subimages to goniometer to read the angles
# get the subimages from the color picture
# rotate the subimages back to 0º and output them.
# TODO: standarize what kind of arguments each object takes, and be coherent
# TODO: test_localizer converts to BW by itself
# TODO: goniometer.get_angle()
localizer = Localizer(filepath='datasets/dataset4/best_model')
goniometer = Goniometer(filepath='datasets/dataset5/best_model')
picture_bw = picture.convert('F')
resis_boxs = localizer.localize(np.asarray(picture_bw))
plt.show()
resis_pics = [] # cropped pictures of the resistors
for b in resis_boxs:
x1, y1 = b[0], b[1]
x2, y2 = b[2], b[3]
angle_ind = goniometer.predict(np.asarray(picture_bw)[y1:y2, x1:x2])
angle = goniometer.angle_list[angle_ind[0]]
sec = picture.crop((x1, y1, x2, y2))
print(angle)
'stores them in `./_unlocalized`. If `--yaml` is '
'also specified, then only the YAML template is '
'generated.'))
parser.add_option('--import', dest='import_html',
default=False, action='store_true',
help=('Generate Django templates from localized '
'HTML articles in `./_localized`.'))
parser.add_option('--yaml', dest='yaml_infile', default='',
help=('Generate localizable template from a specified YAML '
'file. Output is written to `./[filename].html`'))
options = parser.parse_args()[0]
if not (options.generate_html or options.import_html):
parser.error('You must specify either `--generate` or `--import`.')
l7r = Localizer(original_root=Article.ROOT,
localized_root=Article.LOCALIZED_ROOT)
if options.generate_html and options.yaml_infile:
try:
l7r.GenerateLocalizableYaml(options.yaml_infile)
except YamlProcessorException:
parser.error('`%s` couldn\'t be read.' % options.yaml_infile)
elif options.generate_html:
try:
os.mkdir(Article.UNLOCALIZED_ROOT)
except OSError:
pass
l7r.GenerateLocalizableFiles()
elif options.import_html:
try:
os.mkdir(Article.LOCALIZED_ROOT)
dataset = 4
imgs_loc = 'datasets/dataset{0}/dataset{0}_imgs.csv'.format(dataset)
boxs_loc = 'datasets/dataset{0}/dataset{0}_boxs.csv'.format(dataset)
pics = np.genfromtxt(imgs_loc, delimiter=',')
boxs = np.genfromtxt(boxs_loc, delimiter=',')
# Resize the box lists
boxs = boxs.reshape(boxs.shape[0], -1, 4)
# dimensions of the whole pictures, constant for now
picshape = 240, 240 # height and width
# Create the NN model
localizer = Localizer(picshape=(240, 240), hidden_layers=(42, 30, 10))
epochs = 20
batch_size = 20
localizer.train(pics, boxs, epochs, batch_size)
i = random.randint(0, pics.shape[0] - 1)
pic = pics[i, :].reshape(240, 240)
utils.test_localizer(localizer, pic, show_probs=True)
#print(localizer.predict(pic))
# a hard test, just for fun
resistors = Image.open('resistors.png', mode='r')
resistors = resistors.convert(mode='F')
def __init__(self):
'''Initializes the server.'''
self.mode = "server"
self.oP = OutPipe("Server", 0)
self.nC = None
self.cvars = {
"sv_addr": "0.0.0.0",
"sv_port": 7777,
"sv_netlog": 0,
"sv_level": "",
"sv_game": 0,
"sv_singleplayer": 0,
"sv_gamemode": "singleplayer",
"sv_startscript": "",
"sv_master": "",
"sv_dedicated": 0,
"sv_chat": 1,
"sv_background_red": 0,
"sv_background_green": 0,
"sv_background_blue": 0,
"sv_background_alpha": 0,
"sv_password": "",
"cl_language": "en",
"cl_subtitles": 1,
"cl_width": 1280,
"cl_height": 720,
"cl_fullscreen": 0,
"cl_motionblur": 0,
"cl_motionblur_amount": 0,
"cl_anisotropic": 1,
"cl_mipmap": "none",
"cl_vsync": "off",
"cl_musicvolume": 10,
"cl_dialogvolume": 10,
"cl_soundvolume": 10,
"cl_netping": 0,
}
self.netVars = {}
self.oldNetVars = self.netVars
self.oldcvars = self.cvars
self.gameMode = None
self.level = None
self.unassignedPlayers = []
self.entities = []
self.events = []
self.saveFile = None
self.chatMessages = []
self.eI = EngineInterface(True)
self.sE = ScriptExecuter()
self.pR = PhysicsReader(self)
self.sH = ShaderHandler()
self.l = Localizer(self)
self.updateNetwork()
self.forceUpdateCVars()
self.keepAliveTicker = 0
self.trackedProperties = []
loadServer(self)
self.oP("Initialized.")
def __init__(self):
'''Initializes the client.'''
self.mode = "client"
self.oP = OutPipe("Client", 0)
self.eI = EngineInterface(objectMode=True)
self.vP = VideoPlayer()
self.sE = ScriptExecuter()
self.iR = InputReceiver()
self.l = Localizer(self)
self.pA = PhysicsApplicator(self)
self.sH = ShaderHandler()
self.nC = None
self.sE.addContext("Client", self)
self.cvars = {
#Low level settings
"cl_update": 1,
"cl_synced": 0,
"cl_addr": "0.0.0.0",
"cl_oport": 7777,
"cl_iport": 7778,
"cl_netlog": 0,
"cl_game": 0,
"cl_startscript": "",
"cl_master": 0,
"cl_predict": 1,
"cl_smooth": 0,
"cl_name": "Player",
"cl_password": "",
"cl_camera": "",
"cl_lockcontrols": 1,
"cl_showmouse": 1,
"cl_xsens": 50,
"cl_ysens": 50,
"cl_inverted": 0,
"cl_netping": 0,
#High level settings
"cl_language": "en",
"cl_subtitles": 1,
"cl_width": 1280,
"cl_height": 720,
"cl_fullscreen": 0,
"cl_motionblur": 0,
"cl_motionblur_amount": 0,
"cl_anisotropic": 1,
"cl_mipmap": "none",
"cl_vsync": "off",
"cl_musicvolume": 10,
"cl_dialogvolume": 10,
"cl_soundvolume": 10,
"cl_mastervolume": 10,
#Server shared settings
"sv_level": "",
"sv_gamemode": "",
"sv_game": 0,
"sv_background_red": 0,
"sv_background_green": 0,
"sv_background_blue": 0,
"sv_background_alpha": 0,
}
self.netVars = {}
self.chatMessages = []
self.interfaces = []
self.entities = []
self.level = None
self.gameEvents = []
self.updateNetwork()
#self.startLoop()
self.forceUpdateCVars()
self.keepAliveTicker = 0
self.trackedProperties = []
loadClient(self)
self.oP("Initialized.")
# -*- coding: utf-8 -*-
import numpy as np
import random
from PIL import Image
import utils
from localizer import Localizer
from picture_generator import PictureGenerator
from keras.utils.np_utils import to_categorical
# Create the NN model
localizer = Localizer(input_shape=(48, 48), hidden_layers=(42, 30, 10))
# Create the data generator
generator = PictureGenerator(batch_size=15,
batches_per_epoch=500,
return_angles=False,
resistor_prob=0.5,
real_backgrounds=True,
angle_num=8,
flatten=False)
# Train the model
epochs = 10
def __init__(self, model_path):
self.model = np.load(open(model_path, 'r')).item()
self.head = 6
self.payload = 6
self.localizer = Localizer()
print('Inflation model loaded')
