def get_plot(hvf_image_gray, y_ratio, y_size, x_ratio, x_size, plot_type, icon_type): plot_image = Image_Utils.slice_image(hvf_image_gray, y_ratio, y_size, x_ratio, x_size) hvf_image_gray_process = Image_Utils.preprocess_image( hvf_image_gray.copy()) plot_image_process = Image_Utils.slice_image(hvf_image_gray_process, y_ratio, y_size, x_ratio, x_size) # Get bounding box from processed image: top_left, w, h = Hvf_Plot_Array.get_bounding_box(plot_image_process) bottom_right = (top_left[0] + w, top_left[1] + h) # Need to specifically handle raw value plot - can have a discontinuity in the # x axis (with triangle icon), which causes a mis-fit. So need to fill in x-axis # and try again cv2.line(plot_image_process, (top_left[0], top_left[1] + int(h / 2)), (top_left[0] + w, top_left[1] + int(h / 2)), (0), max(int(h * 0.015), 1)) top_left, w, h = Hvf_Plot_Array.get_bounding_box(plot_image_process) bottom_right = (top_left[0] + w, top_left[1] + h) # For debugging: Draw rectangle around the plot - MUST BE COMMENTED OUT, BECAUSE # IT WILL INTERFERE WITH LATER PLOT EXTRACTIONS #cv2.rectangle(plot_image, top_left, bottom_right, 0, 2) # Debug function for showing the plot: #show_plot_func = (lambda : cv2.imshow("Bound rect for plot " + plot_type, plot_image)) #Logger.get_logger().log_function(Logger.DEBUG_FLAG_DEBUG, show_plot_func); #cv2.waitKey(); # Slice out the axes plot on the original: tight_plot = plot_image[top_left[1]:(top_left[1] + h), top_left[0]:(top_left[0] + w)] # And extract the values from the array: plot_array = Hvf_Plot_Array.extract_values_from_plot( tight_plot, plot_type, icon_type) # Return the array: return plot_array, tight_plot
def is_pattern_not_shown(hvf_image_gray, y_ratio, y_size, x_ratio, x_size): # Calculate height/width for calculation later: height = np.size(hvf_image_gray, 0) width = np.size(hvf_image_gray, 1) # Slice image: hvf_image_gray = Image_Utils.preprocess_image(hvf_image_gray) sliced_img = Image_Utils.slice_image(hvf_image_gray, y_ratio, y_size, x_ratio, x_size) # Try to detect a bounding box: top_left, w, h = Hvf_Plot_Array.get_bounding_box(sliced_img) # Calculate the relative (percentage) size of the bounding box compared to slice: box_ratio_w = w / (x_size * width) box_ratio_h = h / (y_size * height) # Define a threshold below which if the size ratio is, we declare that the pattern # is not detected: threshold_size = 0.3 return (box_ratio_w < threshold_size or box_ratio_h < threshold_size)
def clean_slice(slice): # Clean up borders - sometimes straggler pixels come along slice_w = np.size(slice, 1) slice = slice[:, 1:slice_w - 1] slice = cv2.copyMakeBorder(slice, 0, 0, 1, 1, cv2.BORDER_REPLICATE) # Crop the characters to remove excess white: x0, x1, y0, y1 = Image_Utils.crop_white_border(slice) # Possible we have a fully blank slice, so only crop if there is something if (x0 < x1 and y0 < y1): slice = slice[y0:y1, x0:x1] return slice
def perform_ocr(img): # First, preprocessor the image: img = Image_Utils.preprocess_image(img) # Next, convert image to python PIL (because pytesseract using PIL): img_pil = Image.fromarray(img) if not Ocr_Utils.OCR_API_HANDLE: Ocr_Utils.OCR_API_HANDLE = PyTessBaseAPI(psm=PSM.SINGLE_COLUMN) #Ocr_Utils.OCR_API_HANDLE = PyTessBaseAPI(psm=PSM.SINGLE_BLOCK) Ocr_Utils.OCR_API_HANDLE.SetImage(img_pil) text = Ocr_Utils.OCR_API_HANDLE.GetUTF8Text() # Return extracted text: return text
def delete_plot_axes(plot_image): w = np.size(plot_image, 1) h = np.size(plot_image, 0) # Mask out all but central ~5% of horizontal and vertical, to prepare to # remove axes_size mask = np.zeros((h, w, 1), np.uint8) mask = np.full(plot_image.shape, 255, np.uint8) # Draw axes in the middle (to allow mask to match template on) cv2.line(mask, (int(w / 2), 0), (int(w / 2), h), (0), int(w * 0.03)) cv2.line(mask, (0, int(h / 2)), (w, int(h / 2)), (0), int(h * 0.03)) # Mask out all but central 5%: masked_axes = cv2.bitwise_or(plot_image, mask) masked_axes = Image_Utils.delete_stray_marks(masked_axes, 0.0001, 0.001) return_image = cv2.bitwise_or(cv2.bitwise_not(masked_axes), plot_image) return return_image
def get_perc_plot_element(plot_element): # Declare our return value: ret_val = Hvf_Perc_Icon.PERC_NO_VALUE # What is the total plot size? plot_area = np.size(plot_element, 0) * np.size(plot_element, 1) # Delete stray marks; filters out specks based on size compared to global element # and relative to largest contour plot_threshold = 0.005 relative_threshold = 0.005 plot_element = Image_Utils.delete_stray_marks(plot_element, plot_threshold, relative_threshold) # First, crop the white border out of the element to get just the core icon: x0, x1, y0, y1 = Image_Utils.crop_white_border(plot_element) # Calculate height and width: h = y1 - y0 w = x1 - x0 # If our bounding indices don't catch any borders (ie, x0 > x1) then its must be an # empty element: if (w < 0): ret_val = Hvf_Perc_Icon.PERC_NO_VALUE # Finding 'normal' elements is tricky because the icon is small (scaling doesn't # work as easily for it) and it tends to get false matching with other icons # However, its size is very different compared to the other icons, so just detect # it separately # If the cropped bounding box is less than 20% of the overall box, highly likely # normal icon elif ((h / np.size(plot_element, 0)) < 0.20): ret_val = Hvf_Perc_Icon.PERC_NORMAL else: # Grab our element icon: element_cropped = plot_element[y0:1 + y1, x0:1 + x1] # Now, we template match against all icons and look for best fit: best_match = None best_perc = None for ii in range(len(Hvf_Perc_Icon.template_perc_list)): # Scale up the plot element or perc icon, whichever is smaller # (meaning, scale up so they're equal, don't scale down - keep as much # data as we can) # Grab our perc icon: perc_icon = Hvf_Perc_Icon.template_perc_list[ii] min_val, max_val, min_loc, max_loc = Hvf_Perc_Icon.do_template_matching( plot_element, w, h, perc_icon) # Check to see if this is our best fit yet: if (best_match is None or min_val < best_match): # This is best fit - record the value and the icon type best_match = min_val best_perc = Hvf_Perc_Icon.enum_perc_list[ii] # Debug strings for matching the enum: debug_string = "Matching enum " + str( Hvf_Perc_Icon.enum_perc_list[ii]) + "; match : " + str( min_val) Logger.get_logger().log_msg(Logger.DEBUG_FLAG_DEBUG, debug_string) ret_val = best_perc # Now we need to ensure that all declared 5-percentile icons are true, because # this program often mixes up between 5-percentile and half-percentile if (ret_val == Hvf_Perc_Icon.PERC_5_PERCENTILE): # Check for contours here - we know that the 5 percentile has multiple small contours plot_element = cv2.bitwise_not(plot_element) # Find contours. Note we are using RETR_EXTERNAL, meaning no children contours (ie # contours within contours) contours, hierarchy = cv2.findContours(plot_element, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # Now add up all the contour area total_cnt_area = 0 for cnt in contours: total_cnt_area = total_cnt_area + cv2.contourArea(cnt) # Now compare to our cropped area # In optimal scenario, 5-percentile takes up 25% of area; half-percentile essentially 100% # Delineate on 50% AREA_PERCENTAGE_CUTOFF = 0.5 area_percentage = total_cnt_area / (w * h) Logger.get_logger().log_msg( Logger.DEBUG_FLAG_DEBUG, "Recheck matching betwen 5-percentile and half-percentile") Logger.get_logger().log_msg( Logger.DEBUG_FLAG_DEBUG, "Total contour area percentage: " + str(area_percentage)) # Check to see which is better. Because we are inverting, check max value if (area_percentage > AREA_PERCENTAGE_CUTOFF): # Half percentile is a better fit - switch our match ret_val = Hvf_Perc_Icon.PERC_HALF_PERCENTILE # Declare as such: debug_string = "Correction: switching from 5-percentile to half-percentile" Logger.get_logger().log_msg(Logger.DEBUG_FLAG_DEBUG, debug_string) # Debug strings for bounding box: debug_bound_box_string = "Bounding box: " + str(x0) + "," + str( y0) + " ; " + str(x1) + "," + str(y1) Logger.get_logger().log_msg(Logger.DEBUG_FLAG_DEBUG, debug_bound_box_string) debug_bound_box_dim_string = "Bounding box dimensions: " + str( w) + " , " + str(h) Logger.get_logger().log_msg(Logger.DEBUG_FLAG_DEBUG, debug_bound_box_dim_string) # And debug function for showing the cropped element: show_cropped_element_func = (lambda: cv2.imshow( 'cropped ' + str(Hvf_Perc_Icon.i), element_cropped)) Logger.get_logger().log_function(Logger.DEBUG_FLAG_DEBUG, show_cropped_element_func) Hvf_Perc_Icon.i = Hvf_Perc_Icon.i + 1 return ret_val
def get_value_plot_element(plot_element, plot_element_backup, plot_type): # Declare return value return_val = 0 # CV2 just slices images and returns the native image. We mess with the pixels so # for cleanliness, just copy it over: plot_element = plot_element.copy() # First, clean up any small noisy pixels by eliminating small contours # Tolerance for stray marks is different depending on plot type # Relative to largest contour: plot_threshold = 0 relative_threshold = 0 if (plot_type == "raw"): plot_threshold = 0.005 relative_threshold = 0.1 else: plot_threshold = 0.005 relative_threshold = 0.01 plot_element = Image_Utils.delete_stray_marks(plot_element, plot_threshold, relative_threshold) plot_element_backup = Image_Utils.delete_stray_marks( plot_element_backup, plot_threshold, relative_threshold) # Now, crop out the borders so we just have the central values - this allows us # to standardize size x0, x1, y0, y1 = Image_Utils.crop_white_border(plot_element) # Now we have bounding x/y coordinates # Calculate height and width: h = y1 - y0 w = x1 - x0 # Sometimes in low quality images, empty cells may have noise - also need to filter # based on area of element #THRESHOLD_AREA_FRACTION = 0.03; #fraction_element_area = (w*h)/(np.size(plot_element, 0)*np.size(plot_element, 1)); # If this was an empty plot, (or element area is below threshold) we have no value #if ((w <= 0) or (h <= 0) or fraction_element_area < THRESHOLD_AREA_FRACTION): if (w <= 0) or (h <= 0): Logger.get_logger().log_msg( Logger.DEBUG_FLAG_DEBUG, "Declaring no value because cell is empty/below threshold marks" ) return_val = Hvf_Value.VALUE_NO_VALUE Hvf_Value.i = Hvf_Value.i + 1 else: # First, split the slice into a character list: list_of_chars = Hvf_Value.chop_into_char_list( plot_element[y0:1 + y1, x0:1 + x1]) list_of_chars_backup = Hvf_Value.chop_into_char_list( plot_element[y0:1 + y1, x0:1 + x1]) # Check for special cases (ie, non-numeric characters) # Check if <0 value # Can optimize detection accuracy by limiting check to only raw plot values with 2 chars: if (plot_type == "raw" and len(list_of_chars) == 2 and (Hvf_Value.is_less_than(list_of_chars[0]) or Hvf_Value.is_less_than(list_of_chars_backup[0]))): Logger.get_logger().log_msg(Logger.DEBUG_FLAG_DEBUG, "Detected less-than sign") return_val = Hvf_Value.VALUE_BELOW_THRESHOLD # Check if the above detection worked: if (return_val == 0): # No, so continue detection for number # Determine if we have a minus sign is_minus = 1 # First, look for minus sign - if we have 2 or 3 characters # Negative numbers are not present in raw plot if not (plot_type == "raw"): if (len(list_of_chars) == 2 and Hvf_Value.is_minus(list_of_chars[0])): # Detected minus sign: Logger.get_logger().log_msg(Logger.DEBUG_FLAG_DEBUG, "Detected minus sign") # Set our multiplier factor (makes later numeric correction easier) is_minus = -1 # Remove the character from the list list_of_chars.pop(0) list_of_chars_backup.pop(0) elif (len(list_of_chars) == 3): # We know there must be a minus sign, so just raise flag Logger.get_logger().log_msg(Logger.DEBUG_FLAG_DEBUG, "Assuming minus sign") is_minus = -1 # Remove the character from the list list_of_chars.pop(0) list_of_chars_backup.pop(0) # Now, look for digits, and calculate running value running_value = 0 for jj in range(len(list_of_chars)): # Pull out our digit to detect, and clean it digit = Hvf_Value.clean_slice(list_of_chars[jj]) show_element_func = (lambda: cv2.imshow( 'Sub element ' + str(Hvf_Value.i) + "_" + str(jj), digit)) Logger.get_logger().log_function(Logger.DEBUG_FLAG_DEBUG, show_element_func) Hvf_Value.j = Hvf_Value.j + 1 # Search for 0 if it is the trailing 0 of a multi-digit number, or if lone digit and not a minus allow_search_zero = ((jj == len(list_of_chars) - 1) and (len(list_of_chars) > 1)) or ( (len(list_of_chars) == 1) and (is_minus == 1)) Logger.get_logger().log_msg( Logger.DEBUG_FLAG_DEBUG, "Allow 0 search: " + str(allow_search_zero)) Logger.get_logger().log_msg(Logger.DEBUG_FLAG_DEBUG, "jj: " + str(jj)) Logger.get_logger().log_msg( Logger.DEBUG_FLAG_DEBUG, "list_of_chars length: " + str(len(list_of_chars))) best_value, best_loc, best_scale_factor, best_match = Hvf_Value.identify_digit( digit, allow_search_zero) # If not a good match, recheck with alternatively processed image -> may increase yield threshold_match_digit = 0.5 if (best_match > 0 and best_match < threshold_match_digit): digit_backup = Hvf_Value.clean_slice( list_of_chars_backup[jj]) best_value, best_loc, best_scale_factor, best_match = Hvf_Value.identify_digit( digit_backup, allow_search_zero) running_value = (10 * running_value) + best_value Hvf_Value.i = Hvf_Value.i + 1 Hvf_Value.j = 0 return_val = running_value * is_minus # Debug info string for the best matched value: debug_best_match_string = "Best matched value: " + Hvf_Value.get_string_from_value( return_val) Logger.get_logger().log_msg(Logger.DEBUG_FLAG_INFO, debug_best_match_string) return return_val
def identify_digit(plot_element, allow_search_zero): # We template match against all icons and look for best fit: best_match = None best_val = None best_loc = None best_scale_factor = None height = np.size(plot_element, 0) width = np.size(plot_element, 1) # Can skip 0 if flag tells us to. This can help maximize accuracy in low-res cases # Do this when we know something about the digit (it is a leading digit, etc) start_index = 0 if not allow_search_zero: start_index = 1 for ii in range(start_index, len(Hvf_Value.value_icon_templates.keys())): for dir in Hvf_Value.value_icon_templates[ii]: # First, scale our template value: val_icon = Hvf_Value.value_icon_templates[ii][dir] plot_element_temp = plot_element.copy() scale_factor = 1 # Use the smaller factor to make sure we fit into the element icon if (height < np.size(val_icon, 0)): # Need to upscale plot_element scale_factor = np.size(val_icon, 0) / height plot_element_temp = cv2.resize(plot_element_temp, (0, 0), fx=scale_factor, fy=scale_factor) else: # Need to upscale val_icon scale_factor = height / (np.size(val_icon, 0)) val_icon = cv2.resize(val_icon, (0, 0), fx=scale_factor, fy=scale_factor) # In case the original is too small by width compared to value_icon, need # to widen - do so by copymakeborder replicate if (np.size(plot_element_temp, 1) < np.size(val_icon, 1)): border = np.size(val_icon, 1) - np.size( plot_element_temp, 1) #plot_element_temp = cv2.copyMakeBorder(plot_element_temp,0,0,0,border,cv2.BORDER_CONSTANT,0); # Apply template matching: temp_matching = cv2.matchTemplate(plot_element_temp, val_icon, cv2.TM_CCOEFF_NORMED) # Grab our result min_val, max_val, min_loc, max_loc = cv2.minMaxLoc( temp_matching) Logger.get_logger().log_msg( Logger.DEBUG_FLAG_DEBUG, "Matching against " + str(ii) + ": " + str(max_val)) # Check to see if this is our best fit yet: if (best_match is None or max_val > best_match): # This is best fit - record the match value and the actual value best_match = max_val best_val = ii best_loc = max_loc best_scale_factor = scale_factor # TODO: refine specific cases that tend to be misclassified # 1 vs 4 if (best_val == 4 or best_val == 1): # Cut number in half and take bottom half -> find contours # If width of contour is most of element --> 4 # otherwise, 1 bottom_half = Image_Utils.slice_image(plot_element, 0.5, 0.5, 0, 1) cnts, hierarchy = cv2.findContours( cv2.bitwise_not(bottom_half.copy()), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # Sort contours by width largest_contour = sorted(cnts, key=Hvf_Value.contour_width, reverse=True)[0] if (Hvf_Value.contour_width(largest_contour) > width * 0.8): best_val = 4 else: best_val = 1 return best_val, best_loc, best_scale_factor, best_match
def extract_values_from_plot(plot_image, plot_type, icon_type): # First, image process for best readability: #plot_image = cv2.GaussianBlur(plot_image, (5,5), 0) plot_image_backup = plot_image.copy() # Perform image processing depending on plot type: if (icon_type == Hvf_Plot_Array.PLOT_PERC): plot_image = cv2.bitwise_not( cv2.adaptiveThreshold(plot_image, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 5)) elif (icon_type == Hvf_Plot_Array.PLOT_VALUE): #plot_image = cv2.GaussianBlur(plot_image, (5,5), 0) ret2, plot_image = cv2.threshold( plot_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) kernel_size = 31 mean_offset = 15 plot_image_backup = cv2.bitwise_not( cv2.adaptiveThreshold(plot_image_backup, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, kernel_size, mean_offset)) kernel = np.ones((3, 3), np.uint8) # For readability, grab our height/width: plot_width = np.size(plot_image, 1) plot_height = np.size(plot_image, 0) # The elements are laid out roughly within a 10x10 grid NUM_CELLS_ROW = Hvf_Plot_Array.NUM_OF_PLOT_ROWS NUM_CELLS_COL = Hvf_Plot_Array.NUM_OF_PLOT_COLS # Delete triangle icon, if we can find it: if (plot_type == Hvf_Plot_Array.PLOT_RAW): if not (Hvf_Plot_Array.find_and_delete_triangle_icon( plot_image, "v1")): Hvf_Plot_Array.find_and_delete_triangle_icon(plot_image, "v2") # Mask out corners: corner_mask = Hvf_Plot_Array.generate_corner_mask( plot_width, plot_height) plot_image = cv2.bitwise_or(plot_image, cv2.bitwise_not(corner_mask)) # First, declare our return value array, no need to really initialize bc we'll # iterate through it plot_values_array = 0 if (icon_type == Hvf_Plot_Array.PLOT_PERC): plot_values_array = np.zeros((NUM_CELLS_COL, NUM_CELLS_ROW), dtype=Hvf_Perc_Icon) elif (icon_type == Hvf_Plot_Array.PLOT_VALUE): plot_values_array = np.zeros((NUM_CELLS_COL, NUM_CELLS_ROW), dtype=Hvf_Value) plot_image = Hvf_Plot_Array.delete_plot_axes(plot_image) # Grab the grid lines: grid_line_dict = Hvf_Plot_Array.get_plot_grid_lines( plot_image, plot_type, icon_type) plot_image_debug_copy = plot_image.copy() # Debug code - draws out slicing for the elements on the plot: for c in range(Hvf_Plot_Array.NUM_OF_PLOT_COLS + 1): x = int(grid_line_dict['col_list'][c] * plot_width) #cv2.line(plot_image_debug_copy, (x, 0), (x, plot_height), (0), 1); for r in range(Hvf_Plot_Array.NUM_OF_PLOT_ROWS + 1): y = int(grid_line_dict['row_list'][r] * plot_height) #cv2.line(plot_image_debug_copy, (0, y), (plot_width, y), (0), 1); # Debug function for showing the plot: show_plot_func = ( lambda: cv2.imshow("plot " + icon_type, plot_image_debug_copy)) Logger.get_logger().log_function(Logger.DEBUG_FLAG_DEBUG, show_plot_func) #cv2.imshow("plot " + icon_type, plot_image_debug_copy) #cv2.waitKey(); # We iterate through our array, then slice out the appropriate cell from the plot for x in range(0, NUM_CELLS_COL): for y in range(0, NUM_CELLS_ROW): # Debug info for indicating what cell we're computing: Logger.get_logger().log_msg(Logger.DEBUG_FLAG_INFO, "Cell " + str(x) + "," + str(y)) # Grab our cell slice for the plot element # (remember arguments: slice_image(image, y_ratio, y_size, x_ratio, x_size): # The height of the axes tends to extend ~2.5% past the elements on top, bottom # The width of the axes tends to extend # So we take that into account when we take the slice row_grid_val = grid_line_dict['row_list'][y] row_grid_val_size = grid_line_dict['row_list'][ y + 1] - grid_line_dict['row_list'][y] col_grid_val = grid_line_dict['col_list'][x] col_grid_val_size = grid_line_dict['col_list'][ x + 1] - grid_line_dict['col_list'][x] cell_slice = Image_Utils.slice_image(plot_image, row_grid_val, row_grid_val_size, col_grid_val, col_grid_val_size) cell_slice_backup = Image_Utils.slice_image( plot_image_backup, row_grid_val, row_grid_val_size, col_grid_val, col_grid_val_size) cell_object = 0 # Then, need to analyze to figure out what element is in this position # What we look for depends on type of plot - perc vs value if (icon_type == Hvf_Plot_Array.PLOT_PERC): if (Hvf_Plot_Array.PLOT_ELEMENT_BOOLEAN_MASK[y][x]): # This element needs to be detected # Because this step relies on many things going right, possible that our # slices are not amenable to template matching and cause an error # So, try it under a try-except clause. If failure, we place a failure # placeholder try: cell_object = Hvf_Perc_Icon.get_perc_icon_from_image( cell_slice) Logger.get_logger().log_msg( Logger.DEBUG_FLAG_INFO, "Percentile Icon detected: " + cell_object.get_display_string()) except: Logger.get_logger().log_msg( Logger.DEBUG_FLAG_WARNING, "Cell " + str(x) + "," + str(y) + ": Percentile icon detection failure") cell_object = Hvf_Perc_Icon.get_perc_icon_from_char( Hvf_Perc_Icon.PERC_FAILURE_CHAR) raise Exception(str(e)) else: # This is a no-detect element, so just instantiate a blank: cell_object = Hvf_Perc_Icon.get_perc_icon_from_char( Hvf_Perc_Icon.PERC_NO_VALUE_CHAR) Logger.get_logger().log_msg( Logger.DEBUG_FLAG_INFO, "Masking element - generating NO VALUE element") elif (icon_type == Hvf_Plot_Array.PLOT_VALUE): if (Hvf_Plot_Array.PLOT_ELEMENT_BOOLEAN_MASK[y][x]): # This element needs to be detected # Because this step relies on many things going right, possible that our # slices are not amenable to template matching and cause an error # So, try it under a try-except clause. If failure, we place a failure # placeholder to fix later try: cell_object = Hvf_Value.get_value_from_image( cell_slice, cell_slice_backup, plot_type) Logger.get_logger().log_msg( Logger.DEBUG_FLAG_INFO, "Value detected: " + cell_object.get_display_string()) except Exception as e: Logger.get_logger().log_msg( Logger.DEBUG_FLAG_WARNING, "Cell " + str(x) + "," + str(y) + ": Value detection failure") cell_object = Hvf_Value.get_value_from_display_string( Hvf_Value.VALUE_FAILURE) raise Exception(str(e)) else: # This is a no-detect element, so just instantiate a blank: cell_object = Hvf_Value.get_value_from_display_string( Hvf_Value.VALUE_NO_VALUE) Logger.get_logger().log_msg( Logger.DEBUG_FLAG_INFO, "Masking element - generating NO VALUE element") Logger.get_logger().log_msg(Logger.DEBUG_FLAG_INFO, "=====") # Lastly, store into array: plot_values_array[x, y] = cell_object wait_func = (lambda: cv2.waitKey(0)) Logger.get_logger().log_function(Logger.DEBUG_FLAG_DEBUG, wait_func) destroy_windows_func = (lambda: cv2.destroyAllWindows()) Logger.get_logger().log_function(Logger.DEBUG_FLAG_DEBUG, destroy_windows_func) # Return our array: return plot_values_array
def get_plot_grid_lines(plot_image, plot_type, icon_type): Logger.get_logger().log_msg(Logger.DEBUG_FLAG_INFO, "Finding grid lines") plot_w = np.size(plot_image, 1) plot_h = np.size(plot_image, 0) horizontal_img = plot_image.copy() vertical_img = plot_image.copy() # [Horizontal] # Specify size on horizontal axis horizontal_size = horizontal_img.shape[1] # Create structure element for extracting horizontal lines through morphology operations horizontalStructure = cv2.getStructuringElement( cv2.MORPH_RECT, (horizontal_size, 1)) # Apply morphology operations horizontal_img = cv2.morphologyEx(horizontal_img, cv2.MORPH_OPEN, horizontalStructure, iterations=2) #horizontal_img = cv2.erode(horizontal_img, horizontalStructure) #horizontal_img = cv2.dilate(horizontal_img, horizontalStructure) # Then, take a slice from the middle of the plot, and find contours # We will use this to help find grid lines horizontal_slice = Image_Utils.slice_image(horizontal_img, 0, 1, 0.475, 0.05) horizontal_slice = cv2.copyMakeBorder(horizontal_slice, 0, 0, 1, 1, cv2.BORDER_CONSTANT, 0) # Then, find contours (of the blank spaces) and convert to their respective centroid: horizontal_cnts, hierarchy = cv2.findContours(horizontal_slice, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) centroid_horizontal = list( map((lambda c: Hvf_Plot_Array.get_contour_centroid(c)[1] / plot_h), horizontal_cnts)) # [Vertical] # Specify size on vertical axis vertical_size = vertical_img.shape[1] # Create structure element for extracting vertical lines through morphology operations verticalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (1, vertical_size)) # Apply morphology operations vertical_img = cv2.morphologyEx(vertical_img, cv2.MORPH_OPEN, verticalStructure, iterations=2) #vertical_img = cv2.erode(vertical_img, verticalStructure) #vertical_img = cv2.dilate(vertical_img, verticalStructure) # Then, take a slice from the middle of the plot, and find contours # We will use this to help find grid lines vertical_slice = Image_Utils.slice_image(vertical_img, 0.475, 0.05, 0, 1) vertical_slice = cv2.copyMakeBorder(vertical_slice, 1, 1, 0, 0, cv2.BORDER_CONSTANT, 0) # Then, find contours (of the blank spaces) and convert to their respective centroid: vertical_cnts, hierarchy = cv2.findContours(vertical_slice, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) centroid_vertical = list( map((lambda c: Hvf_Plot_Array.get_contour_centroid(c)[0] / plot_w), vertical_cnts)) # Now, we need to find the grid lines # We assume grid lines are centered in the middle of plot image (since they # are detected that way). Have prelim grid lines, and move then accordingly # to fit into empty spaces # Columns: col_list = [] # Pre-calculate some values: slice_w = np.size(vertical_slice, 1) slice_h = np.size(vertical_slice, 0) for c in range(Hvf_Plot_Array.NUM_OF_PLOT_COLS + 1): # Get our prelim column value: col_val = 0.5 - (0.097 * (5 - c)) # Precalculate our coordinates to check: y = int(slice_h * 0.5) x = int(col_val * slice_w) if (x >= slice_w): x = slice_w - 1 # If this grid line does not coincide with a plot element area, then its good if (vertical_slice[y, x] == 255): # Grid line falls into blank area - we can record value Logger.get_logger().log_msg( Logger.DEBUG_FLAG_INFO, "Prelim column {} grid line works".format(c)) col_list.append(col_val) else: # It coincides -> convert it to the closest centroid of a blank area Logger.get_logger().log_msg( Logger.DEBUG_FLAG_INFO, "Shifting column grid line {} to nearest centroid".format( c)) closest_centroid = list( sorted(centroid_vertical, key=(lambda x: abs(x - col_val))))[0] col_list.append(closest_centroid) # Rows: row_list = [] # Pre-calculate some values: slice_w = np.size(horizontal_slice, 1) slice_h = np.size(horizontal_slice, 0) for r in range(Hvf_Plot_Array.NUM_OF_PLOT_ROWS + 1): # Get our prelim row value: row_val = 0.5 - (0.095 * (5 - r)) # Precalculate our coordinates to check: y = int(row_val * slice_h) x = int(slice_w * 0.5) if (y >= slice_h): y = slice_h - 1 # If this grid line does not coincide with a plot element area, then its good if (horizontal_slice[y, x] == 255): # Grid line falls into blank area - we can record value Logger.get_logger().log_msg( Logger.DEBUG_FLAG_INFO, "Prelim row {} grid line works".format(r)) row_list.append(row_val) else: # It coincides -> convert it to the closest centroid of a blank area Logger.get_logger().log_msg( Logger.DEBUG_FLAG_INFO, "Shifting row grid line {} to nearest centroid".format(r)) closest_centroid = list( sorted(centroid_horizontal, key=(lambda y: abs(y - row_val))))[0] row_list.append(closest_centroid) # Collect our two lists and return them together: return_dict = {} return_dict['row_list'] = row_list return_dict['col_list'] = col_list return return_dict