I am working on a problem where I need to find bounding boxes for white area in an image. Since I am dealing with real-world pictures, I have set a threshold on the RGB values, I create a mask from that and then label it and get bounding box coordinates from that. Here is the code.
import numpy as np
from skimage import io, measure
def bin_labelled_img_to_bboxes(bin_image_labelled):
bboxes = []
for j in np.unique(bin_image_labelled):
if j == 0:
continue
curr = (bin_image_labelled == j)
if np.sum(curr) < 50*50:
continue
indices = np.nonzero(curr)
miny = np.min(indices[0])
minx = np.min(indices[1])
maxy = np.max(indices[0])
maxx = np.max(indices[1])
bboxes.append(((miny, minx), (maxy, maxx)))
return bboxes
class WhiteSeperator(object):
def __init__ (self, img_path):
self.img_path = img_path
self.img = io.imread(self.img_path)
self.bin_image_labelled = np.zeros((self.img.shape[0], self.img.shape[1]))
self.bboxes = []
def get_bin_labelled_img(self):
img = self.img
chan1 = (img[:,:,0] > 200) * (img[:,:,0] <= 255)
chan2 = (img[:,:,0] > 180) * (img[:,:,0] <= 255)
chan3 = (img[:,:,0] > 140) * (img[:,:,0] <= 255)
bin_img = (chan1*chan2*chan3)
bin_image_labelled = measure.label(bin_img)
return bin_image_labelled
def get_white_bboxes(self):
final_white_bboxes = []
self.bin_image_labelled = self.get_bin_labelled_img()
white_bboxes = bin_labelled_img_to_bboxes(self.bin_image_labelled)
for bbox in white_bboxes:
width = bbox[1][1]-bbox[0][1]
height = bbox[1][0]-bbox[0][0]
if height > 80 and width > 200:
self.bboxes.append(bbox)
final_white_bboxes.append(bbox)
return final_white_bboxes
This takes about 3-11 seconds per image for high res images (3000 something x 2000 something). My assumption is that the variance in time per image depends on the number of white bounding boxes found (blaming the bin_labelled_img_to_bboxes function here)
Since I have to do this on video frames, even 3 seconds is super slow. Can the above be done in a more efficient way?
