Exemple #1
0
def test_LandmarkGroup_str():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('all', np.ones(3, dtype=np.bool))])

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    out_str = lgroup.__str__()
    assert (len(out_str) > 0)
def test_LandmarkGroup_str():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('all', np.ones(3, dtype=np.bool))])

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    out_str = lgroup.__str__()
    assert (len(out_str) > 0)
Exemple #3
0
def test_LandmarkGroup_str():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    target = PointCloud(points)
    mask_dict = {'all': np.ones(3, dtype=np.bool)}

    lgroup = LandmarkGroup(target, 'label', pcloud, mask_dict, copy=False)

    out_str = lgroup.__str__()
    assert (len(out_str) > 0)
Exemple #4
0
def test_landmarkgroup_copy_method():
    points = np.ones((10, 3))
    mask_dict = OrderedDict([('all', np.ones(10, dtype=np.bool))])
    pcloud = PointCloud(points, copy=False)

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)
    lgroup_copy = lgroup.copy()

    assert (not is_same_array(lgroup_copy.lms.points, lgroup.lms.points))
    # Check the mask dictionary is deepcopied properly
    assert (lgroup._labels_to_masks is not lgroup_copy._labels_to_masks)
    masks = zip(lgroup_copy._labels_to_masks.values(),
                lgroup._labels_to_masks.values())
    for ms in masks:
        assert (ms[0] is not ms[1])
def predict_in_frame(frame_name, clip, img_type):
    global detector
    im = im_read_greyscale(frame_name,
                           clip.path_frames,
                           img_type,
                           normalise=False)

    res_dlib = detector(im)
    # in the following lines a hack to figure out whether there are more than
    # 10 detections returned. In such a case, there should be two digits in
    # each group.
    num_res = len(res_dlib)
    if num_res == 0:
        return
    num1 = 1  # num1 and s1: Values if there are more than 10 detections in the image
    if num_res > 9:
        num1 = 2
    s1 = '%0' + str(num1)
    im_pili = np.array(im.as_PILImage())
    # loop over the returned detections.
    # By restricting the range below, we can choose the
    # k first (more confident) bounding boxes.
    # num_res to keep all, here keeping ONLY the most confident one
    for kk in range(0, 1):
        pts_end = im.path.stem + '_' + str(kk) + pts_type_out
        ln = im.landmarks['ffld2_' + (s1 + 'd') % kk]
        mio.export_landmark_file(ln,
                                 clip.path_write_ln[0] + pts_end,
                                 overwrite=True)
        # convert to landmarks
        det_frame = predictor_dlib(im_pili, pointgraph_to_rect(ln.lms))
        init_pc = detection_to_pointgraph(det_frame)
        mio.export_landmark_file(LandmarkGroup.init_with_all_label(init_pc),
                                 clip.path_write_ln[1] + pts_end,
                                 overwrite=True)
Exemple #6
0
def test_landmarkgroup_copy_method():
    points = np.ones((10, 3))
    mask_dict = OrderedDict([('all', np.ones(10, dtype=np.bool))])
    pcloud = PointCloud(points, copy=False)

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)
    lgroup_copy = lgroup.copy()

    assert (not is_same_array(lgroup_copy.lms.points,
                              lgroup.lms.points))
    # Check the mask dictionary is deepcopied properly
    assert (lgroup._labels_to_masks is not lgroup_copy._labels_to_masks)
    masks = zip(lgroup_copy._labels_to_masks.values(),
                lgroup._labels_to_masks.values())
    for ms in masks:
        assert (ms[0] is not ms[1])
Exemple #7
0
def lan_importer(filepath, asset=None, **kwargs):
    r"""
    Importer for the LAN file format for the GOSH dataset. This is a 3D
    landmark type and so it is assumed it only applies to meshes.

    Landmark set label: LAN

    Note that the exact meaning of each landmark in this set varies,
    so all we can do is import all landmarks found under the label 'LAN'

    Parameters
    ----------
    filepath : `Path`
        Absolute filepath of the file.
    asset : `object`, optional
        An optional asset that may help with loading. This is unused for this
        implementation.
    \**kwargs : `dict`, optional
        Any other keyword arguments.

    Returns
    -------
    landmarks : :map:`LandmarkGroup`
        The landmarks including appropriate labels if available.
    """
    with open(str(filepath), 'r') as f:
        landmarks = np.fromfile(f, dtype=np.float32)[3:].reshape(
            [-1, 3]).astype(np.double)

    pointcloud = PointCloud(landmarks)
    labels_to_masks = OrderedDict([('all',
                                    np.ones(landmarks.shape[0],
                                            dtype=np.bool))])
    return LandmarkGroup(pointcloud, labels_to_masks)
def test_LandmarkGroup_del_unlabelled():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('all', np.ones(3, dtype=np.bool)),
                             ('lower', np.array([1, 1, 0], dtype=np.bool))])
    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    del lgroup['all']
def test_LandmarkGroup_in():
    points = np.ones((3, 2))
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('all', np.ones(3, dtype=np.bool))])

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    assert ('all' in lgroup)
def test_LandmarkGroup_create_with_all_label():
    points = np.ones((10, 3))
    pcloud = PointCloud(points, copy=False)

    lgroup = LandmarkGroup.init_with_all_label(pcloud, copy=False)

    assert lgroup.n_labels == 1
    assert 'all' in lgroup
def test_LandmarkGroup_copy_false():
    points = np.ones((10, 3))
    mask_dict = OrderedDict([('all', np.ones(10, dtype=np.bool))])
    pcloud = PointCloud(points, copy=False)
    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)
    assert (is_same_array(lgroup._pointcloud.points, points))
    assert (lgroup._labels_to_masks is mask_dict)
    assert (lgroup.lms is pcloud)
Exemple #12
0
def test_LandmarkGroup_without_labels():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('lower', np.array([1, 1, 0], dtype=np.bool)),
                             ('upper', np.array([0, 0, 1], dtype=np.bool))])
    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    new_lgroup = lgroup.without_labels('upper')

    assert_equal(new_lgroup.n_labels, 1)
    assert_equal(new_lgroup.n_landmarks, 2)
    assert ('lower' in new_lgroup)

    new_lgroup = lgroup.without_labels(['upper'])

    assert_equal(new_lgroup.n_labels, 1)
    assert_equal(new_lgroup.n_landmarks, 2)
    assert ('lower' in new_lgroup)
def test_LandmarkGroup_without_labels():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('lower', np.array([1, 1, 0], dtype=np.bool)),
                             ('upper', np.array([0, 0, 1], dtype=np.bool))])
    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    new_lgroup = lgroup.without_labels('upper')

    assert_equal(new_lgroup.n_labels, 1)
    assert_equal(new_lgroup.n_landmarks, 2)
    assert ('lower' in new_lgroup)

    new_lgroup = lgroup.without_labels(['upper'])

    assert_equal(new_lgroup.n_labels, 1)
    assert_equal(new_lgroup.n_landmarks, 2)
    assert ('lower' in new_lgroup)
def test_LandmarkGroup_get_None():
    points = np.ones((10, 3))
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('all', np.ones(10, dtype=np.bool))])

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    assert lgroup[None] is not pcloud
    assert_allclose(lgroup[None].points, pcloud.points)
def test_LandmarkGroup_iterate():
    points = np.ones((10, 3))
    mask_dict = OrderedDict([('all', np.ones(10, dtype=np.bool))])
    pcloud = PointCloud(points, copy=False)
    target = PointCloud(points)

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    for l in lgroup:
        assert_equal(l, 'all')
Exemple #16
0
def test_LandmarkGroup_without_labels():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    target = PointCloud(points)
    mask_dict = {'lower': np.array([1, 1, 0], dtype=np.bool),
                 'upper': np.array([0, 0, 1], dtype=np.bool)}
    lgroup = LandmarkGroup(target, 'label', pcloud, mask_dict, copy=False)

    new_lgroup = lgroup.without_labels('upper')

    assert_equal(new_lgroup.n_labels, 1)
    assert_equal(new_lgroup.n_landmarks, 2)
    assert ('lower' in new_lgroup)

    new_lgroup = lgroup.without_labels(['upper'])

    assert_equal(new_lgroup.n_labels, 1)
    assert_equal(new_lgroup.n_landmarks, 2)
    assert ('lower' in new_lgroup)
Exemple #17
0
def test_LandmarkGroup_get():
    points = np.ones((3, 2))
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('lower', np.array([1, 1, 0], dtype=np.bool)),
                             ('upper', np.array([0, 0, 1], dtype=np.bool))])

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    assert_allclose(lgroup['lower'].n_points, 2)
    assert_allclose(lgroup['upper'].n_points, 1)
def test_LandmarkManager_get():
    points = np.ones((10, 3))
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('all', np.ones(10, dtype=np.bool))])

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    man = LandmarkManager()
    man._landmark_groups['test_set'] = lgroup

    assert(man['test_set'] is lgroup)
Exemple #19
0
def test_LandmarkManager_set_LandmarkGroup():
    points = np.ones((10, 3))
    mask_dict = OrderedDict([('all', np.ones(10, dtype=np.bool))])
    pcloud = PointCloud(points, copy=False)
    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    man = LandmarkManager()
    man['test_set'] = lgroup
    assert (not is_same_array(man['test_set'].lms.points, lgroup.lms.points))
    assert_allclose(man['test_set']['all'].points, np.ones([10, 3]))
    assert (man['test_set']._labels_to_masks is not lgroup._labels_to_masks)
def test_LandmarkGroup_set_ordered_labels():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('all', np.ones(3, dtype=np.bool))])

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    lgroup['lower'] = [0, 1]

    assert_allclose(lgroup['lower'].n_points, 2)
    assert_allclose(lgroup['lower'].points[0, :], [0, 1])
    assert_allclose(lgroup['lower'].points[1, :], [2, 3])
def test_LandmarkManager_set():
    points = np.ones((10, 3))
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('all', np.ones(10, dtype=np.bool))])

    lgroup = LandmarkGroup(pcloud, mask_dict, copy=False)

    man = LandmarkManager()
    man['test_set'] = lgroup

    assert_allclose(man._landmark_groups['test_set'].lms.points,
                    lgroup.lms.points)
    assert_equal(man._landmark_groups['test_set'].n_labels, 1)
Exemple #22
0
def test_register_landmark_importer(is_file):
    from menpo.shape import PointCloud
    from menpo.landmark import LandmarkGroup
    lmark = LandmarkGroup.init_with_all_label(PointCloud.init_2d_grid((1, 1)))

    def foo_importer(filepath, **kwargs):
        return lmark

    is_file.return_value = True

    with patch.dict(mio.input.extensions.image_landmark_types, {}, clear=True):
        mio.register_landmark_importer('.foo', foo_importer)
        new_lmark = mio.import_landmark_file('fake.foo')
    assert lmark is new_lmark
def detect_in_frame(frame_name, clip, img_type):
    # if normalise=True in im_read_greyscale: before calling dlib detector, image should be converted to uint8
    im = im_read_greyscale(frame_name, clip.path_frames, img_type, normalise=False)
    if not im:
        print(frame_name, clip.path_frames)
        return
    res_dlib = dlib_init_detector(im, group_prefix='dlib')  # call dlib detector
    im_pili = np.array(im.as_PILImage())
    for kk, g in enumerate(im.landmarks.group_labels):
        pts_end = im.path.stem + '_' + str(kk) + pts_type_out  # define the ending of each pts that will be exported
        export_landmark_file(im.landmarks[g], clip.path_write_ln[0] + pts_end, overwrite=True)
        # from bounding box to points (dlib predictor)
        init_pc = detection_to_pointgraph(predictor_dlib(im_pili, pointgraph_to_rect(im.landmarks[g].lms)))
        export_landmark_file(LandmarkGroup.init_with_all_label(init_pc), clip.path_write_ln[1] + pts_end, overwrite=True)
Exemple #24
0
def test_register_landmark_importer(is_file):
    from menpo.shape import PointCloud
    from menpo.landmark import LandmarkGroup
    lmark = LandmarkGroup.init_with_all_label(PointCloud.init_2d_grid((1, 1)))

    def foo_importer(filepath, **kwargs):
        return lmark

    is_file.return_value = True

    with patch.dict(mio.input.extensions.image_landmark_types, {}, clear=True):
        mio.register_landmark_importer('.foo', foo_importer)
        new_lmark = mio.import_landmark_file('fake.foo')
    assert lmark is new_lmark
Exemple #25
0
def save_bounding_boxes(pattern, detector_type, group=None,
                        sythesize_problematic=False, overwrite=False):
    import menpo.io as mio
    from menpo.landmark import LandmarkGroup
    from menpo.model import PCAModel
    try:
        detector = _DETECTORS[detector_type]()
    except KeyError:
        detector_list = ', '.join(list(_DETECTORS.keys()))
        raise ValueError('Valid detector types are: {}'.format(detector_list))
    print('Running {} detector on {}'.format(detector_type, pattern))
    bboxes = {img.path: detect_and_check(img, detector, group=group)
              for img in mio.import_images(pattern, normalise=False,
                                           verbose=True)}

    # find all the detections that failed
    problematic = filter(lambda x: x[1]['d'] is None, bboxes.items())
    print('Failed to detect {} objects'.format(len(problematic)))
    if len(problematic) > 0 and sythesize_problematic:
        print('Learning detector traits and sythesizing fits for {} '
              'images'.format(len(problematic)))
        # get the good detections
        detections = filter(lambda x: x['d'] is not None, bboxes.values())
        # normalize these to size [1, 1], centred on origin
        normed_detections = [normalize(r['gt']).apply(r['d'])
                             for r in detections]
        # build a PCA model from good detections
        pca = PCAModel(normed_detections)

        for p, r in problematic:
            # generate a new bbox offset in the normalized space by using
            # our learnt PCA basis
            d = random_instance(pca)
            # apply an inverse transform to place it on the image
            bboxes[p]['d'] = normalize(r['gt']).pseudoinverse().apply(d)
    to_save = len(bboxes)
    if not sythesize_problematic:
        to_save = to_save - len(problematic)
    print('Saving out {} {} detections'.format(to_save, detector_type))
    # All done, save out results
    for p, r in bboxes.items():
        if r['d'] is not None:
            lg = LandmarkGroup.init_with_all_label(r['d'])
            mio.export_landmark_file(lg, p.parent /
                                     (p.stem + '_{}.ljson'.format(detector_type)),
                                     overwrite=overwrite)
Exemple #26
0
def check_label_func(func, input_n_points, output_n_points):
    # Could be any dimensionality
    array = np.zeros(input_n_points)
    pcloud = PointCloud(array)
    lmark_g = LandmarkGroup.init_with_all_label(pcloud)

    array_result = func(array)
    assert isinstance(array_result, PointCloud)
    assert array_result.n_points == output_n_points

    pcloud_result = func(pcloud)
    assert isinstance(pcloud_result, PointCloud)
    assert pcloud_result.n_points == output_n_points

    lmark_g_result = func(lmark_g)
    assert isinstance(lmark_g_result, LandmarkGroup)
    assert lmark_g_result.lms.n_points == output_n_points
Exemple #27
0
def check_label_func(func, input_n_points, output_n_points):
    # Could be any dimensionality
    array = np.zeros([input_n_points, 2])
    pcloud = PointCloud(array)
    lmark_g = LandmarkGroup.init_with_all_label(pcloud)

    array_result = func(array)
    assert isinstance(array_result, PointCloud)
    assert array_result.n_points == output_n_points

    pcloud_result = func(pcloud)
    assert isinstance(pcloud_result, PointCloud)
    assert pcloud_result.n_points == output_n_points

    lmark_g_result = func(lmark_g)
    assert isinstance(lmark_g_result, LandmarkGroup)
    assert lmark_g_result.lms.n_points == output_n_points
def predict_in_frame(frame_name, clip, img_type):
    global detector
    im = im_read_greyscale(frame_name, clip.path_frames, img_type, normalise=False)

    res_dlib = detector(im)
    num_res = len(res_dlib)
    if num_res == 0:
        return
    num1 = 1                # num1 and s1: Values if there are more than 10 detections in the image
    if num_res > 9:
        num1 = 2
    s1 = '%0' + str(num1)
    im_pili = np.array(im.as_PILImage())
    for kk in range(0, 1):   # num_res to keep all, here keeping ONLY the most confident one
        pts_end = im.path.stem + '_' + str(kk) + pts_type_out
        ln = im.landmarks['ffld2_' + (s1 + 'd') % kk]
        mio.export_landmark_file(ln, clip.path_write_ln[0] + pts_end, overwrite=True)
        # convert to landmarks
        det_frame = predictor_dlib(im_pili, pointgraph_to_rect(ln.lms))
        init_pc = detection_to_pointgraph(det_frame)
        mio.export_landmark_file(LandmarkGroup.init_with_all_label(init_pc),
                                 clip.path_write_ln[1] + pts_end, overwrite=True)
Exemple #29
0
def lm3_importer(filepath, asset=None, **kwargs):
    r"""
    Importer for the LM3 file format from the bosphorus dataset. This is a 3D
    landmark type and so it is assumed it only applies to meshes.

    Landmark set label: LM3

    Landmark labels:

    +------------------------+
    | label                  |
    +========================+
    | outer_left_eyebrow     |
    | middle_left_eyebrow    |
    | inner_left_eyebrow     |
    | inner_right_eyebrow    |
    | middle_right_eyebrow   |
    | outer_right_eyebrow    |
    | outer_left_eye_corner  |
    | inner_left_eye_corner  |
    | inner_right_eye_corner |
    | outer_right_eye_corner |
    | nose_saddle_left       |
    | nose_saddle_right      |
    | left_nose_peak         |
    | nose_tip               |
    | right_nose_peak        |
    | left_mouth_corner      |
    | upper_lip_outer_middle |
    | right_mouth_corner     |
    | upper_lip_inner_middle |
    | lower_lip_inner_middle |
    | lower_lip_outer_middle |
    | chin_middle            |
    +------------------------+

    Parameters
    ----------
    filepath : `Path`
        Absolute filepath of the file.
    asset : `object`, optional
        An optional asset that may help with loading. This is unused for this
        implementation.
    \**kwargs : `dict`, optional
        Any other keyword arguments.

    Returns
    -------
    landmarks : :map:`LandmarkGroup`
        The landmarks including appropriate labels if available.
    """
    with open(str(filepath), 'r') as f:
        landmarks = f.read()

    # Remove comments and blank lines
    landmark_text = [
        l for l in landmarks.splitlines() if (l.rstrip() and not '#' in l)
    ]

    # First line says how many landmarks there are: 22 Landmarks
    # So pop it off the front
    num_points = int(landmark_text.pop(0).split()[0])
    xs = []
    ys = []
    zs = []
    labels = []

    # The lines then alternate between the labels and the coordinates
    for i in xrange(num_points * 2):
        if i % 2 == 0:  # label
            # Lowercase, remove spaces and replace with underscores
            l = landmark_text[i]
            l = '_'.join(l.lower().split())
            labels.append(l)
        else:  # coordinate
            p = landmark_text[i].split()
            xs.append(float(p[0]))
            ys.append(float(p[1]))
            zs.append(float(p[2]))

    xs = np.array(xs, dtype=np.float).reshape((-1, 1))
    ys = np.array(ys, dtype=np.float).reshape((-1, 1))
    zs = np.array(zs, dtype=np.float).reshape((-1, 1))

    pointcloud = PointCloud(np.hstack([xs, ys, zs]))
    # Create the mask whereby there is one landmark per label
    # (identity matrix)
    masks = np.eye(num_points).astype(np.bool)
    masks = np.vsplit(masks, num_points)
    masks = [np.squeeze(m) for m in masks]
    labels_to_masks = OrderedDict(zip(labels, masks))
    return LandmarkGroup(pointcloud, labels_to_masks)
Exemple #30
0
def bnd_importer(filepath, asset=None, **kwargs):
    r"""
    Importer for the BND file format for the BU-3DFE dataset. This is a 3D
    landmark type and so it is assumed it only applies to meshes.

    Landmark set label: BND

    Landmark labels:

    +---------------+
    | label         |
    +===============+
    | left_eye      |
    | right_eye     |
    | left_eyebrow  |
    | right_eyebrow |
    | nose          |
    | mouth         |
    | chin          |
    +---------------+

    Parameters
    ----------
    filepath : `Path`
        Absolute filepath of the file.
    asset : `object`, optional
        An optional asset that may help with loading. This is unused for this
        implementation.
    \**kwargs : `dict`, optional
        Any other keyword arguments.

    Returns
    -------
    landmarks : :map:`LandmarkGroup`
        The landmarks including appropriate labels if available.
    """
    with open(str(filepath), 'r') as f:
        landmarks = f.read()

    # Remove blank lines
    landmark_text = [l for l in landmarks.splitlines() if l.rstrip()]
    landmark_text = [l.split() for l in landmark_text]

    n_points = len(landmark_text)
    landmarks = np.zeros([n_points, 3])
    for i, l in enumerate(landmark_text):
        # Skip the first number as it's an index into the mesh
        landmarks[i, :] = np.array(
            [float(l[1]), float(l[2]), float(l[3])], dtype=np.float)

    pointcloud = PointCloud(landmarks)
    labels_to_masks = OrderedDict([
        ('left_eye', _indices_to_mask(n_points, np.arange(8))),
        ('right_eye', _indices_to_mask(n_points, np.arange(8, 16))),
        ('left_eyebrow', _indices_to_mask(n_points, np.arange(16, 26))),
        ('right_eyebrow', _indices_to_mask(n_points, np.arange(26, 36))),
        ('nose', _indices_to_mask(n_points, np.arange(36, 48))),
        ('mouth', _indices_to_mask(n_points, np.arange(48, 68))),
        ('chin', _indices_to_mask(n_points, np.arange(68, 83)))
    ])
    return LandmarkGroup(pointcloud, labels_to_masks)
Exemple #31
0
def landmarkgroup_view_widget_test():
    LandmarkGroup.init_with_all_label(PointCloud(pcloud2d)).view_widget()
def test_LandmarkManager_set_None_key():
    pcloud = PointCloud(np.ones((10, 3)), copy=False)
    lgroup = LandmarkGroup.init_with_all_label(pcloud)

    man = LandmarkManager()
    man[None] = lgroup
def test_LandmarkGroup_has_nan_values():
    points = np.ones((10, 3))
    points[0, 0] = np.nan
    pcloud = PointCloud(points, copy=False)
    lgroup = LandmarkGroup.init_with_all_label(pcloud, copy=False)
    assert lgroup.has_nan_values()
Exemple #34
0
def landmark3d_viewer_test():
    LandmarkGroup(PointCloud(fake_triangle),
                  OrderedDict([('all', np.ones(3, dtype=np.bool))]),
                  copy=False).view()
Exemple #35
0
from nose.tools import raises
import numpy as np
import menpo.io as mio
from mock import patch, PropertyMock
from collections import OrderedDict
from menpo.landmark import LandmarkGroup
from menpo.shape import PointCloud
from menpo.image import Image

pc = PointCloud(np.random.random([100, 3]))
test_lg = LandmarkGroup(
    pc, OrderedDict([('all', np.ones(pc.n_points, dtype=np.bool))]))
test_img = Image(np.random.random([100, 100]))
fake_path = '/tmp/test.fake'


@patch('menpo.io.output.base.landmark_types')
@patch('menpo.io.output.base.Path.exists')
@patch('menpo.io.output.base.Path.open')
def test_export_filepath_overwrite_exists(mock_open, exists, landmark_types):
    exists.return_value = True
    mio.export_landmark_file(fake_path, test_lg, overwrite=True)
    mock_open.assert_called_once_with('wb')
    landmark_types.__getitem__.assert_called_once_with('.fake')
    export_function = landmark_types.__getitem__.return_value
    export_function.assert_called_once()


@patch('menpo.io.output.base.landmark_types')
@patch('menpo.io.output.base.Path.exists')
@patch('menpo.io.output.base.Path.open')
def test_LandmarkGroup_create_incorrect_shape():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict(['all', np.ones(5, dtype=np.bool)])

    LandmarkGroup(pcloud, mask_dict, copy=False)
def test_LandmarkGroup_create_no_mask():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)

    LandmarkGroup(pcloud, None, copy=False)
def test_LandmarkGroup_pass_non_ordered_dict():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    mask_dict = {'all': np.ones(3, dtype=np.bool)}

    LandmarkGroup(pcloud, mask_dict, copy=False)
def test_LandmarkGroup_create_unlabelled():
    points = np.array([[0, 1], [2, 3], [4, 5]])
    pcloud = PointCloud(points, copy=False)
    mask_dict = OrderedDict([('all', np.zeros(3, dtype=np.bool))])

    LandmarkGroup(pcloud, mask_dict, copy=False)