def test_detect(self): modules.load_known_modules() detector = ImageObjectDetector.create("example_detector") image = Image() image_container = ImageContainer(image) detections = detector.detect(image_container) nose.tools.ok_(detections is not None, "Unexpected empty detections") nose.tools.assert_equal(len(detections), 1)
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 test_numpy_share_memory(self): # TODO: do pytest parametarize once we move to pytest np_img = np.arange(4 * 5 * 3, dtype=np.uint8).reshape(4, 5, 3) vital_img = Image(np_img) assert np.all(np_img == vital_img.asarray()), ( 'must be initially the same') np_img += 1 assert np.all(np_img != vital_img.asarray()), ( 'we do not share memory yet')
def add_data_from_disk(self, in_img): img = in_img.image().asarray().astype("uint16") mi = np.percentile(img, 1) ma = np.percentile(img, 100) normalized = (img - mi) / (ma - mi) normalized = normalized * 255 normalized[normalized < 0] = 0 output = ImageContainer(Image(normalized.astype("uint8"))) return
def get_image(self): """ Return a new pointer the to contained image. This instance shares the same internal memory as the contained image. :return: New ImageContainer instance :rtype: ImageContainer """ ic_getimg = self.VITAL_LIB['vital_image_container_get_image'] ic_getimg.argtypes = [self.C_TYPE_PTR] ic_getimg.restype = Image.C_TYPE_PTR return Image(from_cptr=ic_getimg(self))
def get_pil_image(img): """ Get image in python friendly format Assumptions are that the image has byte pixels. :return: array containing image :rtype: pil image """ def pil_mode_from_image(img): """ Determine image format from pixel properties May return None if our current encoding does not map to a PIL image mode. """ if img.pixel_type() == img.PIXEL_UNSIGNED and img.pixel_num_bytes( ) == 1: if img.depth() == 3 and img.d_step() == 1 and img.w_step() == 3: return "RGB" elif img.depth() == 4 and img.d_step() == 1 and img.w_step() == 4: return "RGBA" elif img.depth() == 1 and img.w_step() == 1: return "L" elif img.depth() == 1 and img.w_step() == 1: if img.pixel_type() == img.PIXEL_BOOL and img.pixel_num_bytes( ) == 1: return "1" elif img.pixel_type() == img.PIXEL_SIGNED and img.pixel_num_bytes( ) == 4: return "I" elif img.pixel_type() == img.PIXEL_FLOAT and img.pixel_num_bytes( ) == 4: return "F" return None mode = pil_mode_from_image(img) if not mode: # make a copy of this image using contiguous memory with interleaved channels new_img = Image(img.width(), img.height(), img.depth(), True, img.pixel_type(), img.pixel_num_bytes()) new_img.copy_from(img) img = new_img mode = pil_mode_from_image(img) if not mode: raise RuntimeError("Unsupported image format.") # get buffer from image img_pixels = buffer(bytearray(img)) return _pil_image_from_bytes(mode, (img.width(), img.height()), img_pixels, "raw", mode, img.h_step() * img.pixel_num_bytes(), 1)
def _test_numpy(dtype_name, nchannels, order='c'): if nchannels is None: shape = (5, 4) else: shape = (5, 4, nchannels) size = np.prod(shape) dtype = np.dtype(dtype_name) if dtype_name == 'bool': np_img = np.zeros(size, dtype=dtype).reshape(shape) np_img[0::2] = 1 else: np_img = np.arange(size, dtype=dtype).reshape(shape) if order.startswith('c'): np_img = np.ascontiguousarray(np_img) elif order.startswith('fortran'): np_img = np.asfortranarray(np_img) else: raise KeyError(order) if order.endswith('-reverse'): np_img = np_img[::-1, ::-1] vital_img = Image(np_img) recast = vital_img.asarray() if nchannels is None: # asarray always returns 3 channels np_img = np_img[..., None] pixel_type_name = vital_img.pixel_type_name() if dtype_name == 'float16': want = 'float16' if dtype_name == 'float32': want = 'float' elif dtype_name == 'float64': want = 'double' else: want = dtype_name assert pixel_type_name == want, 'want={} but got={}'.format( want, pixel_type_name) if not np.all(np_img == recast): raise AssertionError( 'Failed dtype={}, nchannels={}, order={}'.format( dtype_name, nchannels, order))
def _test_numpy(dtype_name, nchannels, order='c'): np_img = create_numpy_image(dtype_name, nchannels, order) vital_img = Image(np_img) recast = vital_img.asarray() # asarray always returns 3 channels np_img = np.atleast_3d(np_img) pixel_type_name = vital_img.pixel_type_name() want = map_dtype_name_to_pixel_type(dtype_name) assert pixel_type_name == want, 'want={} but got={}'.format( want, pixel_type_name) if not np.all(np_img == recast): raise AssertionError( 'Failed dtype={}, nchannels={}, order={}'.format( dtype_name, nchannels, order))
def _step(self): # grab image container from port using traits img_c = self.grab_input_using_trait('image') img = img_c.image().asarray().astype("uint16") mi = np.percentile(img, 1) ma = np.percentile(img, 100) normalized = (img - mi) / (ma - mi) normalized = normalized * 255 normalized[normalized < 0] = 0 output = ImageContainer(Image(normalized.astype("uint8"))) # push dummy image object (same as input) to output port self.push_to_port_using_trait('image', output) self._base_step()
def test_getitem_int32(self): img = Image(720, 480, 3, True, Image.PIXEL_SIGNED, 4) nose.tools.assert_equal(img.pixel_type_name(), "int32") val1 = img[0,0] val2 = img[0,0,0] nose.tools.assert_equal(val1, val2)
def test_getitem_uint8(self): img = Image(720, 480) nose.tools.assert_equal(img.pixel_type_name(), "uint8") val1 = img[0,0] val2 = img[0,0,0] nose.tools.assert_equal(val1, val2)
def test_size(self): img = Image() nose.tools.assert_equal(img.size(), 0) img = Image(720, 480) nose.tools.assert_equal(img.size(), 720*480)
def test_new_type(self): # allocated a uint32_t image img = Image(720, 480, 3, True, Image.PIXEL_UNSIGNED, 4)
def test_new_sized(self): img = Image(720, 480)
def test_pil_RGBA(self): # test RGBA image img = Image(720, 480, 4, True) pil_img = img.get_pil_image() img2 = Image.from_pil(pil_img) nose.tools.assert_equal(img.equal_content(img2), True)
def test_width(self): i = Image(720, 480) ic = ImageContainer(i) nose.tools.assert_equal(ic.width(), 720)
def test_pil_1(self): # test bool image img = Image(720, 480, 1, True, Image.PIXEL_BOOL, 1) pil_img = img.get_pil_image() img2 = Image.from_pil(pil_img) nose.tools.assert_equal(img.equal_content(img2), True)
def test_size(self): i = Image(720, 480) ic = ImageContainer(i) nose.tools.assert_equal(ic.size(), 720 * 480)
def test_new(self): image = Image() img_c = ImageContainer(image) image = Image(100, 100) img_c = ImageContainer(image)
def test_copy_from(self): img = Image(720, 480, 3, True, Image.PIXEL_FLOAT, 4) img2 = Image().copy_from(img) nose.tools.assert_equal(img.equal_content(img2), True)
def test_getitem_double(self): img = Image(720, 480, 3, True, Image.PIXEL_FLOAT, 8) nose.tools.assert_equal(img.pixel_type_name(), "double") val1 = img[0,0] val2 = img[0,0,0] nose.tools.assert_equal(val1, val2)
def test_pil_I(self): # test int image img = Image(720, 480, 1, True, Image.PIXEL_SIGNED, 4) pil_img = img.get_pil_image() img2 = Image.from_pil(pil_img) nose.tools.assert_equal(img.equal_content(img2), True)
def test_getitem_bool(self): img = Image(720, 480, 1, True, Image.PIXEL_BOOL, 1) nose.tools.assert_equal(img.pixel_type_name(), "bool") val1 = img[0,0] val2 = img[0,0,0] nose.tools.assert_equal(val1, val2)
def test_new(self): img = Image()
def test_height(self): i = Image(720, 480) ic = ImageContainer(i) nose.tools.assert_equal(ic.height(), 480)
def from_pil(pil_image): """ Construct Image from supplied PIL image object. :param pil_image: PIL image object :type pil_image: PIL.Image.Image :raises RuntimeError: If the PIL Image provided is not in a recognized mode. :returns: New Image instance using the given image's pixels. :rtype: Image """ (img_width, img_height) = pil_image.size mode = pil_image.mode # TODO(paul.tunison): Extract this logic out into a utility function. if mode == "1": # boolean img_depth = 1 img_w_step = 1 img_h_step = img_width img_d_step = 0 img_pix_num_bytes = 1 img_pix_type = Image.PIXEL_BOOL elif mode == "L": # 8-bit greyscale img_depth = 1 img_w_step = 1 img_h_step = img_width img_d_step = 0 img_pix_num_bytes = 1 img_pix_type = Image.PIXEL_UNSIGNED elif mode == "RGB": # 8-bit RGB img_depth = 3 img_w_step = 3 img_h_step = img_width * 3 img_d_step = 1 img_pix_num_bytes = 1 img_pix_type = Image.PIXEL_UNSIGNED elif mode == "RGBA": # 8-bit RGB with alpha img_depth = 4 img_w_step = 4 img_h_step = img_width * 4 img_d_step = 1 img_pix_num_bytes = 1 img_pix_type = Image.PIXEL_UNSIGNED elif mode == "I": # 32-bit signed int greyscale img_depth = 1 img_w_step = 1 img_h_step = img_width img_d_step = 0 img_pix_num_bytes = 4 img_pix_type = Image.PIXEL_SIGNED elif mode == "F": # 32-bit float greyscale img_depth = 1 img_w_step = 1 img_h_step = img_width img_d_step = 0 img_pix_num_bytes = 4 img_pix_type = Image.PIXEL_FLOAT else: raise RuntimeError("Unsupported image format.") img_data = _pil_image_to_bytes(pil_image) vital_img = Image(img_data, img_width, img_height, img_depth, img_w_step, img_h_step, img_d_step, img_pix_type, img_pix_num_bytes) return vital_img