Merge pull request #32 from FireDynamics/dev_sven

some more refactoring

Author: O-Sven

ledsa/__main__.py

@@ -50,8 +50,7 @@
         ledsa.find_search_areas(ledsa.config['find_search_areas']['reference_img'])
         ledsa.plot_search_areas(ledsa.config['find_search_areas']['reference_img'])
     if args.s2:
-        ledsa.analyse_positions()
-        ledsa.plot_lines()
+        ledsa.match_leds_to_led_arrays()
 
 if args.s3:
     ledsa = LEDSA(build_experiment_infos=True)

ledsa/analysis/plot_functions.py

@@ -147,8 +147,8 @@ def plot_model(fig, channel, img_id, led_id, window_radius):
     # load model
     model_params = load_model(img_id, led_id, channel, window_radius)
 
-    led_model = ledsa.core.model.led_fit(mesh[0], mesh[1], model_params[0], model_params[1], model_params[2], model_params[3],
-                                         model_params[4], model_params[5], model_params[6], model_params[7])
+    led_model = ledsa.core.model.led_model(mesh[0], mesh[1], model_params[0], model_params[1], model_params[2], model_params[3],
+                                           model_params[4], model_params[5], model_params[6], model_params[7])
 
     current_fig = plt.gcf()
 
@@ -220,8 +220,8 @@ def fit_led(img_id, led_id, channel):
     ledsa.load_search_areas()
     ledsa.config['analyse_photo']['channel'] = str(channel)
     filename = led.get_img_name(img_id)
-    fit_res = led.process_file(filename, ledsa.search_areas, ledsa.line_indices, ledsa.config['analyse_photo'], True,
-                               led_id)
+    fit_res = led.generate_analysis_data(filename, ledsa.search_areas, ledsa.line_indices, ledsa.config['analyse_photo'], True,
+                                         led_id)
     return fit_res
 
 

ledsa/core/_led_helper_functions.py

@@ -1,12 +1,10 @@
 import os
 from datetime import timedelta, datetime
-import re
 
-import numpy as np
 from PIL import Image
 from PIL.ExifTags import TAGS
 
-# os path separator
+
 sep = os.path.sep
 
 
@@ -58,129 +56,6 @@ def find_img_number_list(first, last, increment, number_string_length=4):
     return num_list
 
 
-def remove_led(im_set, ix, iy, window_radius):
-    im_set[ix - window_radius:ix + window_radius, iy - window_radius:iy + window_radius] = 0
-
-
-def find_led_pos(image, ix, iy, window_radius):
-    s_radius = window_radius // 2
-    s = np.index_exp[ix - s_radius:ix + s_radius, iy - s_radius:iy + s_radius]
-    res = np.unravel_index(np.argmax(image[s]), image[s].shape)
-    max_x = ix - s_radius + res[0]
-    max_y = iy - s_radius + res[1]
-    return max_x, max_y
-
-
-def match_leds_to_arrays_with_min_dist(dists_led_arrays_search_areas, edge_indices, config, search_areas):
-    ignore_indices = get_indices_of_ignored_leds(config)
-
-    xs = search_areas[:, 1]
-    ys = search_areas[:, 2]
-
-    num_leds = search_areas.shape[0]
-
-    # construct 2D array for LED indices sorted by line
-    led_arrays = []
-    for edge_idx in edge_indices:
-        led_arrays.append([])
-
-    for iled in range(num_leds):
-        if iled in ignore_indices:
-            continue
-
-        idx_nearest_array = np.argmin(dists_led_arrays_search_areas[iled, :])
-        # TODO: ask Lukas for need of following code
-
-        # for il_repeat in range(len(edge_indices)):
-        #     i1 = edge_indices[idx_nearest_array][0]
-        #     i2 = edge_indices[idx_nearest_array][1]
-        #
-        #     x_outer_led1 = xs[i1]
-        #     y_outer_led1 = ys[i1]
-        #     x_outer_led2 = xs[i2]
-        #     y_outer_led2 = ys[i2]
-        #
-        #     x_led = xs[iled]
-        #     y_led = ys[iled]
-        #
-        #     dist_led_outer_led1 = np.sqrt((x_outer_led1 - x_led) ** 2 + (y_outer_led1 - y_led) ** 2)
-        #     dist_led_outer_led2 = np.sqrt((x_outer_led2 - x_led) ** 2 + (y_outer_led2 - y_led) ** 2)
-        #     dist_outer_leds = np.sqrt((x_outer_led1 - x_outer_led2) ** 2 + (y_outer_led1 - y_outer_led2) ** 2) + 1e-8
-        #
-        #     if dist_led_outer_led1 < dist_outer_leds and dist_led_outer_led2 < dist_outer_leds:
-        #         break
-        #
-        #     dists_led_arrays_search_areas[iled, idx_nearest_array] *= 2
-
-        led_arrays[idx_nearest_array].append(iled)
-    return led_arrays
-
-
-def calc_dists_between_led_arrays_and_search_areas(line_edge_indices, search_areas):
-    distances_led_arrays_search_areas = np.zeros((search_areas.shape[0], len(line_edge_indices)))
-
-    xs = search_areas[:, 1]
-    ys = search_areas[:, 2]
-
-    for line_edge_idx in range(len(line_edge_indices)):
-        i1 = line_edge_indices[line_edge_idx][0]
-        i2 = line_edge_indices[line_edge_idx][1]
-
-        p1x = xs[i1]
-        p1y = ys[i1]
-        p2x = xs[i2]
-        p2y = ys[i2]
-
-        pd = np.sqrt((p1x - p2x) ** 2 + (p1y - p2y) ** 2)
-        d = np.abs(((p2y - p1y) * xs - (p2x - p1x) * ys
-                    + p2x * p1y - p2y * p1x) / pd)
-
-        distances_led_arrays_search_areas[:, line_edge_idx] = d
-    return distances_led_arrays_search_areas
-
-
-def get_indices_of_outer_leds(config):
-    if config['analyse_positions']['line_edge_indices'] == 'None':
-        config.in_line_edge_indices()
-        with open('config.ini', 'w') as configfile:
-            config.write(configfile)
-    line_edge_indices = config.get2dnparray('analyse_positions', 'line_edge_indices')
-    # makes sure that line_edge_indices is a 2d list
-    if len(line_edge_indices.shape) == 1:
-        line_edge_indices = [line_edge_indices]
-    return line_edge_indices
-
-
-def get_indices_of_ignored_leds(config):
-    if config['analyse_positions']['ignore_indices'] != 'None':
-        ignore_indices = np.array([int(i) for i in config['analyse_positions']['ignore_indices'].split(' ')])
-    else:
-        ignore_indices = np.array([])
-    return ignore_indices
-
-
-# switch to Lib/logging at some point
-def log_warnings(img_filename, fit_res, iled, line_number, data, s, cx, cy, conf):
-    res = ' '.join(np.array_str(fit_res.x).split()).replace('[ ', '[').replace(' ]', ']').replace(' ', ',')
-    img_file_path = conf['img_directory'] + img_filename
-    window_radius = int(conf['window_radius'])
-
-    x, y, _ = fit_res.x
-
-    im_x = x + cx - window_radius
-    im_y = y + cy - window_radius
-
-    log = f'Irregularities while fitting:\n    {img_file_path} {iled} {line_number} {res} {fit_res.success} ' \
-          f'{fit_res.fun} {fit_res.nfev} {data[s].shape[0]} {data[s].shape[1]} {im_x} {im_y} {window_radius} {cx} ' \
-          f'{cy} {conf["channel"]}'
-    if not os.path.exists('.{}logfiles'.format(sep)):
-        os.makedirs('.{}logfiles'.format(sep))
-    logfile = open('.{}logfiles{}warnings.log'.format(sep, sep), 'a')
-    logfile.write(log)
-    logfile.write('\n')
-    logfile.close()
-
-
 def build_img_data_string(build_type, config):
     img_data = ''
     img_idx = 1
@@ -198,18 +73,6 @@ def build_img_data_string(build_type, config):
     return img_data
 
 
-def append_fit_res_to_img_data(cx, cy, fit_res, iled, img_data, led_array_idx, mean_color_value, sum_color_value,
-                               window_radius):
-    x, y, dx, dy, A, alpha, wx, wy = fit_res.x
-    im_x = x + cx - window_radius
-    im_y = y + cy - window_radius
-    led_data = (f'{iled:4d},{led_array_idx:2d},{im_x:10.4e},{im_y:10.4e},{dx:10.4e},{dy:10.4e},{A:10.4e},'
-                f'{alpha:10.4e},{wx:10.4e},{wy:10.4e},{fit_res.success:12d},{fit_res.fun:10.4e},'
-                f'{fit_res.nfev:9d},{sum_color_value:10.4e},{mean_color_value:10.4e}')
-    img_data += led_data + '\n'
-    return img_data
-
-
 def save_analysis_infos(img_data):
     out_file = open('.{}analysis{}image_infos_analysis.csv'.format(sep, sep), 'w')
     out_file.write("#ID,Name,Time[s],Experiment_Time[s]\n")
@@ -224,18 +87,3 @@ def save_experiment_infos(img_data):
     out_file.close()
 
 
-def find_analysed_img_ids(config):
-    processed_imgs = []
-    directory_content = os.listdir('.{}analysis{}channel{}'.format(sep, sep, config['channel']))
-    for file_name in directory_content:
-        img = re.search(r"([0-9]+)_led_positions.csv", file_name)
-        if img is not None:
-            processed_imgs.append(int(img.group(1)))
-    return processed_imgs
-
-
-def save_list_of_remaining_imgs_needed_to_be_processed(remaining_imgs):
-    out_file = open('images_to_process.csv', 'w')
-    for i in list(remaining_imgs):
-        out_file.write('{}\n'.format(i))
-    out_file.close()

ledsa/core/_led_helper_functions_s1.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+
+def generate_mask_of_led_areas(image):
+    im_mean = np.mean(image)
+    im_max = np.max(image)
+    th = 0.25 * (im_max - im_mean)
+    print("mean pixel value:", im_mean)
+    print("max pixel value:", im_max)
+    im_set = np.zeros_like(image)
+    im_set[image > th] = 1
+    return im_set
+
+
+def find_pos_of_max_col_val_per_area(image, led_mask, skip, window_radius):
+    search_areas_list = []
+    led_id = 0
+    for ix in range(window_radius, image.shape[0] - window_radius, skip):
+        for iy in range(window_radius, image.shape[1] - window_radius, skip):
+            if led_mask[ix, iy] != 0:
+                max_x, max_y = find_led_pos(image, ix, iy, window_radius)
+                search_areas_list.append([led_id, max_x, max_y])
+                led_id += 1
+                remove_led_from_mask(led_mask, ix, iy, window_radius)
+
+                print('.', end='', flush=True)
+    search_areas_array = np.array(search_areas_list)
+    return search_areas_array
+
+
+def find_led_pos(image, ix, iy, window_radius):
+    s_radius = window_radius // 2
+    s = np.index_exp[ix - s_radius:ix + s_radius, iy - s_radius:iy + s_radius]
+    res = np.unravel_index(np.argmax(image[s]), image[s].shape)
+    max_x = ix - s_radius + res[0]
+    max_y = iy - s_radius + res[1]
+    return max_x, max_y
+
+
+def remove_led_from_mask(im_set, ix, iy, window_radius):
+    im_set[ix - window_radius:ix + window_radius, iy - window_radius:iy + window_radius] = 0

ledsa/core/_led_helper_functions_s2.py

@@ -0,0 +1,89 @@
+import numpy as np
+
+
+def get_indices_of_outer_leds(config):
+    if config['analyse_positions']['line_edge_indices'] == 'None':
+        config.in_line_edge_indices()
+        with open('config.ini', 'w') as configfile:
+            config.write(configfile)
+    line_edge_indices = config.get2dnparray('analyse_positions', 'line_edge_indices')
+    # makes sure that line_edge_indices is a 2d list
+    if len(line_edge_indices.shape) == 1:
+        line_edge_indices = [line_edge_indices]
+    return line_edge_indices
+
+
+def calc_dists_between_led_arrays_and_search_areas(line_edge_indices, search_areas):
+    distances_led_arrays_search_areas = np.zeros((search_areas.shape[0], len(line_edge_indices)))
+
+    xs = search_areas[:, 1]
+    ys = search_areas[:, 2]
+
+    for line_edge_idx in range(len(line_edge_indices)):
+        i1 = line_edge_indices[line_edge_idx][0]
+        i2 = line_edge_indices[line_edge_idx][1]
+
+        p1x = xs[i1]
+        p1y = ys[i1]
+        p2x = xs[i2]
+        p2y = ys[i2]
+
+        pd = np.sqrt((p1x - p2x) ** 2 + (p1y - p2y) ** 2)
+        d = np.abs(((p2y - p1y) * xs - (p2x - p1x) * ys
+                    + p2x * p1y - p2y * p1x) / pd)
+
+        distances_led_arrays_search_areas[:, line_edge_idx] = d
+    return distances_led_arrays_search_areas
+
+
+def match_leds_to_arrays_with_min_dist(dists_led_arrays_search_areas, edge_indices, config, search_areas):
+    ignore_indices = get_indices_of_ignored_leds(config)
+
+    xs = search_areas[:, 1]
+    ys = search_areas[:, 2]
+
+    num_leds = search_areas.shape[0]
+
+    # construct 2D array for LED indices sorted by line
+    led_arrays = []
+    for edge_idx in edge_indices:
+        led_arrays.append([])
+
+    for iled in range(num_leds):
+        if iled in ignore_indices:
+            continue
+
+        idx_nearest_array = np.argmin(dists_led_arrays_search_areas[iled, :])
+        # TODO: ask Lukas for need of following code
+
+        # for il_repeat in range(len(edge_indices)):
+        #     i1 = edge_indices[idx_nearest_array][0]
+        #     i2 = edge_indices[idx_nearest_array][1]
+        #
+        #     x_outer_led1 = xs[i1]
+        #     y_outer_led1 = ys[i1]
+        #     x_outer_led2 = xs[i2]
+        #     y_outer_led2 = ys[i2]
+        #
+        #     x_led = xs[iled]
+        #     y_led = ys[iled]
+        #
+        #     dist_led_outer_led1 = np.sqrt((x_outer_led1 - x_led) ** 2 + (y_outer_led1 - y_led) ** 2)
+        #     dist_led_outer_led2 = np.sqrt((x_outer_led2 - x_led) ** 2 + (y_outer_led2 - y_led) ** 2)
+        #     dist_outer_leds = np.sqrt((x_outer_led1 - x_outer_led2) ** 2 + (y_outer_led1 - y_outer_led2) ** 2) + 1e-8
+        #
+        #     if dist_led_outer_led1 < dist_outer_leds and dist_led_outer_led2 < dist_outer_leds:
+        #         break
+        #
+        #     dists_led_arrays_search_areas[iled, idx_nearest_array] *= 2
+
+        led_arrays[idx_nearest_array].append(iled)
+    return led_arrays
+
+
+def get_indices_of_ignored_leds(config):
+    if config['analyse_positions']['ignore_indices'] != 'None':
+        ignore_indices = np.array([int(i) for i in config['analyse_positions']['ignore_indices'].split(' ')])
+    else:
+        ignore_indices = np.array([])
+    return ignore_indices