def select(self, one=0.0, two=None):
c_output = ctypes.POINTER(DetectedObject.c_ptr_type())()
length = ctypes.c_size_t()
if two is None:
dos_st = self.VITAL_LIB.vital_detected_object_set_select_threshold
dos_st.argtypes = [
self.C_TYPE_PTR, ctypes.c_double,
ctypes.POINTER(ctypes.POINTER(DetectedObject.c_ptr_type())),
ctypes.POINTER(ctypes.c_size_t)
]
dos_st(self, one, ctypes.byref(c_output), ctypes.byref(length))
else:
dos_sct = self.VITAL_LIB.vital_detected_object_set_select_class_threshold
dos_sct.argtypes = [
self.C_TYPE_PTR, ctypes.c_char_p, ctypes.c_double,
ctypes.POINTER(ctypes.POINTER(DetectedObject.c_ptr_type())),
ctypes.POINTER(ctypes.c_size_t)
]
dos_sct(self, one, two, ctypes.byref(c_output),
ctypes.byref(length))
output = []
for i in range(length.value):
cptr = DetectedObject.c_ptr_type()(c_output[i].contents)
output.append(DetectedObject(from_cptr=cptr))
free_void_ptr(c_output)
return output
def detection(self):
d_ptr = self._call_cfunc("vital_object_track_state_detection",
[self.C_TYPE_PTR], [self],
DetectedObject.c_ptr_type())
# f_ptr may be null
if d_ptr:
return DetectedObject(from_cptr=d_ptr)
else:
return None
def detect( self, image_data ):
# Convert image to 8-bit numpy
input_image = image_data.asarray().astype( 'uint8' )
# TODO: do something with numpy image producing detections
bboxes = []
labels = []
# Convert detections to kwiver format
output = DetectedObjectSet()
for bbox, label in zip( bboxes, labels ):
bbox_int = bbox.astype( np.int32 )
bounding_box = BoundingBox( bbox_int[0], bbox_int[1],
bbox_int[2], bbox_int[3] )
detected_object_type = DetectedObjectType( label, 1.0 )
detected_object = DetectedObject( bounding_box,
np.max( class_confidence ),
detected_object_type )
output.add( detected_object )
return output
def _step(self):
print("[DEBUG] ----- start step")
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt.xml')
# grab image container from port using traits
frame_c = self.grab_input_using_trait('image')
# Get image from container
frame_in = frame_c.image()
#convert generic image to PIL
pil_image = get_pil_image(frame_in)
#convert to matrix
frame = np.array(pil_image)
detected_set = DetectedObjectSet()
gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray_frame = cv2.equalizeHist(gray_frame)
faces = face_cascade.detectMultiScale(gray_frame, 1.3, 5)
for (x, y, w, h) in faces:
bbox = BoundingBox(x, y, x + w, y + h)
# get new image handle
#new_ic = ImageContainer( frame )
dot = DetectedObjectType("face", 1.0)
detected_set.add(DetectedObject(bbox, 1.0, dot))
# push object to output port
self.push_to_port_using_trait('detected_object_set', detected_set)
self._base_step()
def _step(self):
print("[DEBUG] ----- start step")
# grab image container from port using traits
in_img_c = self.grab_input_using_trait("image")
imageHeight = in_img_c.height()
imageWidth = in_img_c.width()
if (self.normImageType):
print("Normalize image")
in_img = in_img_c.image().asarray().astype("uint16")
bottom, top = self.get_scaling_values(self.normImageType,
imageHeight)
in_img = self.lin_normalize_image(in_img, bottom, top)
in_img = np.tile(in_img, (1, 1, 3))
else:
in_img = np.array(get_pil_image(in_img_c.image()).convert("RGB"))
self.push_to_port_using_trait("image_norm",
ImageContainer(Image(in_img)))
startTime = time.time()
boxes, scores, classes = self.generate_detection(
self.detection_graph, in_img)
elapsed = time.time() - startTime
print("Done running detector in {}".format(
humanfriendly.format_timespan(elapsed)))
goodBoxes = []
detections = DetectedObjectSet()
for i in range(0, len(scores)):
if (scores[i] >= self.confidenceThresh):
bbox = boxes[i]
goodBoxes.append(bbox)
topRel = bbox[0]
leftRel = bbox[1]
bottomRel = bbox[2]
rightRel = bbox[3]
xmin = leftRel * imageWidth
ymin = topRel * imageHeight
xmax = rightRel * imageWidth
ymax = bottomRel * imageHeight
obj = DetectedObject(BoundingBox(xmin, ymin, xmax, ymax),
scores[i])
detections.add(obj)
print("Detected {}".format(len(goodBoxes)))
self.push_to_port_using_trait("detected_object_set", detections)
self._base_step()
def detect( self, image_data ):
input_image = image_data.asarray().astype( 'uint8' )
from mmdet.apis import inference_detector
gpu_string = 'cuda:' + str( self._gpu_index )
detections = inference_detector( self._model, input_image, self._cfg, device=gpu_string )
class_names = [ 'fish' ] * 10000
if isinstance( detections, tuple ):
bbox_result, segm_result = detections
else:
bbox_result, segm_result = detections, None
if np.size( bbox_result ) > 0:
bboxes = np.vstack( bbox_result )
else:
bboxes = []
sys.stdout.write( "Detected " + str( len( bbox_result ) ) + " objects" )
sys.stdout.flush()
# convert segmentation masks
masks = []
if segm_result is not None:
segms = mmcv.concat_list( segm_result )
inds = np.where( bboxes[:, -1] > score_thr )[0]
for i in inds:
masks.append( maskUtils.decode( segms[i] ).astype( np.bool ) )
# collect labels
labels = [
np.full( bbox.shape[0], i, dtype=np.int32 )
for i, bbox in enumerate( bbox_result )
]
if np.size( labels ) > 0:
labels = np.concatenate( labels )
else:
labels = []
# convert to kwiver format, apply threshold
output = []
for entry in []:
output.append( DetectedObject( BoundingBox( 1,1,2,2 ) ) )
if np.size( labels ) > 0:
mmcv.imshow_det_bboxes(
input_image,
bboxes,
labels,
class_names=class_names,
score_thr=-100.0,
show=True)
return DetectedObjectSet( output )
def _new(self, frame, detection):
"""
:param detection: Optional DetectedObject instance associated with this state.
:type detection: vital.types.DetectedObject
"""
return self._call_cfunc(
"vital_object_track_state_new",
[ctypes.c_int64, DetectedObject.c_ptr_type()], [frame, detection],
self.C_TYPE_PTR)
def _create_detected_object(self):
"""
Helper function to generate a detected object for the track state
:return: Detected object with bounding box coordinates of
(10, 10, 20, 20), confidence of 0.4 and "test" label
"""
bbox = BoundingBox(10, 10, 20, 20)
dot = DetectedObjectType("test", 0.4)
do = DetectedObject(bbox, 0.4, dot)
return do
def detect(self, image_data):
dot = DetectedObjectSet([
DetectedObject(
BoundingBox(
self.m_center_x + self.frame_ct * self.m_dx -
self.m_width / 2.0, self.m_center_y +
self.frame_ct * self.m_dy - self.m_height / 2.0,
self.m_center_x + self.frame_ct * self.m_dx +
self.m_width / 2.0, self.m_center_y +
self.frame_ct * self.m_dy + self.m_height / 2.0))
])
self.frame_ct += 1
return dot
def detect(self, in_img_c):
image_height = in_img_c.height()
image_width = in_img_c.width()
if (self.norm_image_type and self.norm_image_type != "none"):
print("Normalizing input image")
in_img = in_img_c.image().asarray().astype("uint16")
bottom, top = self.get_scaling_values(self.norm_image_type, in_img,
image_height)
in_img = self.lin_normalize_image(in_img, bottom, top)
in_img = np.tile(in_img, (1, 1, 3))
else:
in_img = np.array(get_pil_image(in_img_c.image()).convert("RGB"))
start_time = time.time()
boxes, scores, classes = self.generate_detection(
self.detection_graph, in_img)
elapsed = time.time() - start_time
print("Done running detector in {}".format(
humanfriendly.format_timespan(elapsed)))
good_boxes = []
detections = DetectedObjectSet()
for i in range(0, len(scores)):
if (scores[i] >= self.confidence_thresh):
bbox = boxes[i]
good_boxes.append(bbox)
top_rel = bbox[0]
left_rel = bbox[1]
bottom_rel = bbox[2]
right_rel = bbox[3]
xmin = left_rel * image_width
ymin = top_rel * image_height
xmax = right_rel * image_width
ymax = bottom_rel * image_height
dot = DetectedObjectType(self.category_name, scores[i])
obj = DetectedObject(BoundingBox(xmin, ymin, xmax, ymax),
scores[i], dot)
detections.add(obj)
print("Detected {}".format(len(good_boxes)))
return detections
def detect(self, image_c):
cascade_classifier = cv2.CascadeClassifier(self.classifier_file)
image = image_c.image().asarray().astype(np.uint8)
detected_object_set = DetectedObjectSet()
# NOTE: assarray() function return an rgb representation of the image
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
gray_image = cv2.equalizeHist(gray_image)
faces = cascade_classifier.detectMultiScale(gray_image,
self.scale_factor,
self.min_neighbor)
for (x, y, w, h) in faces:
bbox = BoundingBox(x, y, x + w, y + h)
dot = DetectedObjectType(self.classifier_name, 1.0)
detected_object_set.add(DetectedObject(bbox, 1.0, dot))
return detected_object_set
def detect(self, image_data):
input_image = image_data.asarray().astype('uint8')
from mmdet.apis import inference_detector
detections = inference_detector(self._model, input_image)
if isinstance(detections, tuple):
bbox_result, segm_result = detections
else:
bbox_result, segm_result = detections, None
if np.size(bbox_result) > 0:
bboxes = np.vstack(bbox_result)
else:
bboxes = []
# convert segmentation masks
masks = []
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
masks.append(maskUtils.decode(segms[i]).astype(np.bool))
# collect labels
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
if np.size(labels) > 0:
labels = np.concatenate(labels)
else:
labels = []
# convert to kwiver format, apply threshold
output = DetectedObjectSet()
for bbox, label in zip(bboxes, labels):
class_confidence = float(bbox[-1])
if class_confidence < self._thresh:
continue
bbox_int = bbox.astype(np.int32)
bounding_box = BoundingBox(bbox_int[0], bbox_int[1], bbox_int[2],
bbox_int[3])
class_name = self._labels[label]
detected_object_type = DetectedObjectType(class_name,
class_confidence)
detected_object = DetectedObject(bounding_box,
np.max(class_confidence),
detected_object_type)
output.add(detected_object)
if np.size(labels) > 0 and self._display_detections:
mmcv.imshow_det_bboxes(input_image,
bboxes,
labels,
class_names=self._labels,
score_thr=self._thresh,
show=True)
return output