python类BORDER_REPLICATE的实例源码

def affine_skew(self, tilt, phi, img, mask=None):
        h, w = img.shape[:2]
        if mask is None:
            mask = np.zeros((h, w), np.uint8)
            mask[:] = 255
        A = np.float32([[1, 0, 0], [0, 1, 0]])
        if phi != 0.0:
            phi = np.deg2rad(phi)
            s, c = np.sin(phi), np.cos(phi)
            A = np.float32([[c, -s], [s, c]])
            corners = [[0, 0], [w, 0], [w, h], [0, h]]
            tcorners = np.int32(np.dot(corners, A.T))
            x, y, w, h = cv2.boundingRect(tcorners.reshape(1, -1, 2))
            A = np.hstack([A, [[-x], [-y]]])
            img = cv2.warpAffine(img, A, (w, h), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REPLICATE)
        if tilt != 1.0:
            s = 0.8*np.sqrt(tilt * tilt - 1)
            img = cv2.GaussianBlur(img, (0, 0), sigmaX=s, sigmaY=0.01)
            img = cv2.resize(img, (0, 0), fx=1.0 / tilt, fy=1.0, interpolation=cv2.INTER_NEAREST)
            A[0] /= tilt
        if phi != 0.0 or tilt != 1.0:
            h, w = img.shape[:2]
            mask = cv2.warpAffine(mask, A, (w, h), flags=cv2.INTER_NEAREST)
        Ai = cv2.invertAffineTransform(A)
        return img, mask, Ai

def distort_affine_cv2(image, alpha_affine=10, random_state=None):
    if random_state is None:
        random_state = np.random.RandomState(None)

    shape = image.shape
    shape_size = shape[:2]

    center_square = np.float32(shape_size) // 2
    square_size = min(shape_size) // 3
    pts1 = np.float32([
        center_square + square_size,
        [center_square[0] + square_size, center_square[1] - square_size],
        center_square - square_size])
    pts2 = pts1 + random_state.uniform(-alpha_affine, alpha_affine, size=pts1.shape).astype(np.float32)

    M = cv2.getAffineTransform(pts1, pts2)
    distorted_image = cv2.warpAffine(
        image, M, shape_size[::-1], borderMode=cv2.BORDER_REPLICATE) #cv2.BORDER_REFLECT_101)

    return distorted_image

def test_box_filter_edge(self):
        I = np.array(range(1, 50)).reshape(7, 7).astype(np.float32)
        r = 2
        ret1 = cv.smooth.box_filter(I, r, normalize=True, border_type='edge')
        ret2 = cv2.blur(I, (5,5), borderType=cv2.BORDER_REPLICATE)
        self.assertTrue(np.array_equal(ret1, ret2))

def get_normalized_image(img, rr, debug = False):

  box = cv2.boxPoints(rr)
  extbox = cv2.boundingRect(box)

  if extbox[2] *  extbox[3] > img.shape[0] * img.shape[1]:
    print("Too big proposal: {0}x{1}".format(extbox[2], extbox[3]))
    return None, None
  extbox = [extbox[0], extbox[1], extbox[2], extbox[3]]
  extbox[2] += extbox[0]
  extbox[3] += extbox[1]
  extbox = np.array(extbox, np.int)

  extbox[0] = max(0, extbox[0])
  extbox[1] = max(0, extbox[1])
  extbox[2] = min(img.shape[1], extbox[2])
  extbox[3] = min(img.shape[0], extbox[3])

  tmp = img[extbox[1]:extbox[3], extbox[0]:extbox[2]]
  center = (tmp.shape[1] / 2,  tmp.shape[0] / 2)
  rot_mat = cv2.getRotationMatrix2D( center, rr[2], 1 )

  if tmp.shape[0] == 0 or tmp.shape[1] == 0:
    return None, rot_mat

  if debug:
    vis.draw_box_points(img,  np.array(extbox, dtype="int"), color = (0, 255, 0))
    cv2.imshow('scaled', img)

  rot_mat[0,2] += rr[1][0] /2.0 - center[0]
  rot_mat[1,2] += rr[1][1] /2.0 - center[1]
  try:
    norm_line = cv2.warpAffine( tmp, rot_mat, (int(rr[1][0]), int(rr[1][1])), borderMode=cv2.BORDER_REPLICATE )
  except:
    return None, rot_mat
  return norm_line, rot_mat

def remap_image(name, img, small, page_dims, params):

    height = 0.5 * page_dims[1] * OUTPUT_ZOOM * img.shape[0]
    height = round_nearest_multiple(height, REMAP_DECIMATE)

    width = round_nearest_multiple(height * page_dims[0] / page_dims[1],
                                   REMAP_DECIMATE)

    print '  output will be {}x{}'.format(width, height)

    height_small = height / REMAP_DECIMATE
    width_small = width / REMAP_DECIMATE

    page_x_range = np.linspace(0, page_dims[0], width_small)
    page_y_range = np.linspace(0, page_dims[1], height_small)

    page_x_coords, page_y_coords = np.meshgrid(page_x_range, page_y_range)

    page_xy_coords = np.hstack((page_x_coords.flatten().reshape((-1, 1)),
                                page_y_coords.flatten().reshape((-1, 1))))

    page_xy_coords = page_xy_coords.astype(np.float32)

    image_points = project_xy(page_xy_coords, params)
    image_points = norm2pix(img.shape, image_points, False)

    image_x_coords = image_points[:, 0, 0].reshape(page_x_coords.shape)
    image_y_coords = image_points[:, 0, 1].reshape(page_y_coords.shape)

    image_x_coords = cv2.resize(image_x_coords, (width, height),
                                interpolation=cv2.INTER_CUBIC)

    image_y_coords = cv2.resize(image_y_coords, (width, height),
                                interpolation=cv2.INTER_CUBIC)

    img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

    remapped = cv2.remap(img_gray, image_x_coords, image_y_coords,
                         cv2.INTER_CUBIC,
                         None, cv2.BORDER_REPLICATE)

    thresh = cv2.adaptiveThreshold(remapped, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
                                   cv2.THRESH_BINARY, ADAPTIVE_WINSZ, 25)

    pil_image = Image.fromarray(thresh)
    pil_image = pil_image.convert('1')

    threshfile = name + '_thresh.png'
    pil_image.save(threshfile, dpi=(OUTPUT_DPI, OUTPUT_DPI))

    if DEBUG_LEVEL >= 1:
        height = small.shape[0]
        width = int(round(height * float(thresh.shape[1])/thresh.shape[0]))
        display = cv2.resize(thresh, (width, height),
                             interpolation=cv2.INTER_AREA)
        debug_show(name, 6, 'output', display)

    return threshfile

def frame(image, top=2, bottom=2, left=2, right=2, borderType=cv.BORDER_CONSTANT, color=[255, 0, 0]):
  '''
  add borders around :image:
  :param image: has to be in RBG color scheme. Use `convert_to_rgb` if it's in opencv BGR scheme.
  :param color: array representing an RGB color.
  :param borderType: Other options are:
                                    cv.BORDER_REFLECT,
                                    cv.BORDER_REFLECT_101,
                                    cv.BORDER_DEFAULT,
                                    cv.BORDER_REPLICATE,
                                    cv.BORDER_WRAP
  '''
  return cv.copyMakeBorder(image, top, bottom, left, right, borderType, value=color)

def add_border(src):
    dst = np.empty(shape=(src.shape[0], src.shape[1] + 2 * image_border, src.shape[2] + 2 * image_border))

    for c in xrange(src.shape[0]):
        dst[c] = cv2.copyMakeBorder(src[c], top=image_border, bottom=image_border, left=image_border, right=image_border, borderType=cv2.BORDER_REPLICATE)

    return dst

def __call__(self, image, *args):
        size=self.size
        if self.type=='constant':
            image = cv2.copyMakeBorder(image, size, size, size, size, cv2.BORDER_CONSTANT, value=self.constant_color)
        elif self.type=='reflect':
            image = cv2.copyMakeBorder(image, size, size, size, size, cv2.BORDER_REFLECT)
        elif self.type=='replicate':
            image = cv2.copyMakeBorder(image, size, size, size, size, cv2.BORDER_REPLICATE)

        if len(args):
            return (image, *args)
        else:
            return image

def _augment(self, img, s):
        return cv2.GaussianBlur(img, s, sigmaX=0, sigmaY=0,
                borderType=cv2.BORDER_REPLICATE)

def __init__(self, max_deg, center_range=(0,1),
            interp=cv2.INTER_CUBIC,
            border=cv2.BORDER_REPLICATE):
        """
        :param max_deg: max abs value of the rotation degree
        :param center_range: the location of the rotation center
        """
        super(Rotation, self).__init__()
        self._init(locals())

def random_zoom_out(self, img, boxes):
        '''
        Randomly zoom out the image and adjust the bbox locations.

        For bbox (xmin, ymin, xmax, ymax), the zoomed out bbox is:
        coef -- zoom out coefficient
        ((1-coef)*w/2 + coef*xmin, (1-coef)*h/2 + coef*ymin,
         (1-coed)*w/2 + coef*xmax, (1-coef)*h/2 + coef*ymax)

        Args:
           img: (PIL.Image) image.
           boxes: (tensor) bbox locations, sized [#obj, 4].

        Return:
          img: (PIL.Image) randomly zoomed out image.
          boxes: (tensor) randomly zoomed out bbox locations, sized [#obj, 4].
        '''
        coef = random.uniform(0.5, 1)
        w = img.width
        h = img.height

        xmin = (1-coef)*w/2 + coef*boxes[:,0]
        xmax = (1-coef)*w/2 + coef*boxes[:,2]
        ymin = (1-coef)*h/2 + coef*boxes[:,1]
        ymax = (1-coef)*h/2 + coef*boxes[:,3]
        boxes[:,0] = xmin
        boxes[:,1] = ymin
        boxes[:,2] = xmax
        boxes[:,3] = ymax

        top = int(h/2*(1-coef)/coef)
        bottom = int(h/2*(1-coef)/coef)
        left = int(w/2*(1-coef)/coef)
        right = int(w/2*(1-coef)/coef)

        img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_REPLICATE)
        img = cv2.resize(img, (w, h))
        return img, boxes

def align_face_3(im, key_points):
    '''
    Align face image by affine transfromation. The transformation matrix is computed by 
    3 pairs of points

    input:
        im: input image
        key_points: [(xi, yi)], list of 21-key-point or 106-key-point

    output:
        im_out
    '''

    key_points = np.array(key_points, dtype = np.float32)
    dst_points = np.array([[70.745, 112.0], [108.237, 112.0], [89.4324, 153.514]], dtype = np.float32)
    dst_sz = (178, 218)

    src_points = np.zeros((3, 2), dtype = np.float32)

    if key_points.shape[0] == 21:
        src_points[0] = key_points[16]
        src_points[1] = key_points[17]
        src_points[2] = (key_points[19] + key_points[20]) / 2.0
    elif key_points[0] == 106:
        src_points[0] = key_points[104]
        src_points[1] = key_points[105]
        src_points[2] = (key_points[84] + key_points[90]) / 2.0
    else:
        raise Exception('invalid number of face keypoints')

    trans_mat = cv2.getAffineTransform(src_points, dst_points)

    im_out = cv2.warpAffine(im, trans_mat, dsize = dst_sz, borderMode = cv2.BORDER_REPLICATE)

    return im_out

def align_face_21(im, key_points):
    '''
    Align face image by affine transfromation. The transformation matrix is computed by 
    21 pairs of points

    input:
        im: input image
        key_points: [(xi, yi)], list of 21-key-point or 106-key-point

    output:
        im_out
    '''
    dst_sz = (178, 218)
    src_points = np.array(key_points, dtype = np.float32)

    assert src_points.shape[0] == 21, 'invalid number of face keypoints (21)'

    dst_points = mean_pose_21

    X = np.zeros((42, 4), dtype = np.float32)
    U = np.zeros((42, 1), dtype = np.float32)

    X[0:21, 0:2] = src_points
    X[0:21, 2] = 1
    X[21::, 0] = src_points[:, 1]
    X[21::, 1] = -src_points[:, 0]
    X[21::, 3] = 1

    U[0:21, 0] = dst_points[:,0]
    U[21::, 0] = dst_points[:,1]

    M = np.linalg.pinv(X).dot(U).flatten()

    trans_mat = np.array([[M[0], M[1], M[2]],
                          [-M[1], M[0], M[3]]], dtype = np.float32)

    im_out = cv2.warpAffine(im, trans_mat, dsize = dst_sz, borderMode = cv2.BORDER_REPLICATE)

    return im_out

def align_face_19(im, key_points):
    '''
    For AFLW

    Align face image by affine transfromation. The transformation matrix is computed by 
    19 pairs of points
    '''

    dst_sz = (178, 218)
    src_points = np.array(key_points, dtype = np.float32)
    assert src_points.shape[0] == 19, 'invalid number of face keypoints (19)'

    src_points = src_points[0:18, :]
    dst_points = mean_pose_19

    X = np.zeros((36, 4), dtype = np.float32)
    U = np.zeros((36, 1), dtype = np.float32)

    X[0:18, 0:2] = src_points
    X[0:18, 2] = 1
    X[18::, 0] = src_points[:, 1]
    X[18::, 1] = -src_points[:, 0]
    X[18::, 3] = 1

    U[0:18, 0] = dst_points[:,0]
    U[18::, 0] = dst_points[:,1]

    M = np.linalg.pinv(X).dot(U).flatten()

    trans_mat = np.array([[M[0], M[1], M[2]],
                          [-M[1], M[0], M[3]]], dtype = np.float32)

    im_out = cv2.warpAffine(im, trans_mat, dsize = dst_sz, borderMode = cv2.BORDER_REPLICATE)

    return im_out

def compute_derivs_through_H(I, H):
    """ Compute derivatives after additional homography step.

    For J(x,y) = I( H (x,y) ), compute dJ/dx and dJ/dy.
    """

    h,w = I.shape[:2]

    Hinv = np.linalg.inv(H)
    H_xp1_only = np.array([[1.0,0,-1.0],[0.0,1.0,0.0],[0.0,0.0,1.0]])
    H_xm1_only = np.array([[1.0,0,1.0],[0.0, 1.0, 0.0], [0.0, 0.0, 1.0]])
    H_yp1_only = np.array([[1.0, 0, 0], [0.0, 1.0, -1.0], [0.0, 0.0, 1.0]])
    H_ym1_only = np.array([[1.0, 0, 0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]])

    H_only_array = [H_xp1_only, H_xm1_only, H_yp1_only, H_ym1_only]
    [H_xp1, H_xm1, H_yp1, H_ym1] = [Hinv.dot(H_).dot(H) for H_ in H_only_array]

    y,x = np.mgrid[:h,:w]
    xy_ar = np.c_[x.flatten(), y.flatten()].astype('float')

    # Compute displacements of finite difference samples.
    xy_ar_xp1 = ptransform(xy_ar, H_xp1)
    xy_ar_xm1 = ptransform(xy_ar, H_xm1)
    xy_ar_yp1 = ptransform(xy_ar, H_yp1)
    xy_ar_ym1 = ptransform(xy_ar, H_ym1)

    d_xp1 = np.linalg.norm(xy_ar - xy_ar_xp1, axis=1).reshape((h,w))
    d_xm1 = np.linalg.norm(xy_ar - xy_ar_xm1, axis=1).reshape((h,w))
    d_yp1 = np.linalg.norm(xy_ar - xy_ar_yp1, axis=1).reshape((h,w))
    d_ym1 = np.linalg.norm(xy_ar - xy_ar_ym1, axis=1).reshape((h,w))

    if I.ndim > 2:
        d_xp1 = d_xp1[:,:,np.newaxis]
        d_xm1 = d_xm1[:,:,np.newaxis]
        d_yp1 = d_yp1[:,:,np.newaxis]
        d_ym1 = d_ym1[:,:,np.newaxis]

    I_xp1 = cv2.warpPerspective(I, H_xp1, (w,h), borderMode=cv2.BORDER_REPLICATE)
    I_xm1 = cv2.warpPerspective(I, H_xm1, (w,h), borderMode=cv2.BORDER_REPLICATE)
    I_yp1 = cv2.warpPerspective(I, H_yp1, (w,h), borderMode=cv2.BORDER_REPLICATE)
    I_ym1 = cv2.warpPerspective(I, H_ym1, (w,h), borderMode=cv2.BORDER_REPLICATE)

    dx = 0.5 * ((I_xp1 - I) * d_xp1 + (I - I_xm1) * d_xm1)
    dy = 0.5 * ((I_yp1 - I) * d_yp1 + (I - I_ym1) * d_ym1)
    return dx,dy

def interp_lin(I, xn, yn, compute_derivs=True):
    """ Perform linear interpolation of I.

    I is evaluated at xn, yn.

    Returns
    -------
    I_warped : array_like
        Warped image
    dI_warped_dx : array_like
        Derivative of warped image in x direction
    dI_warped_dy : array_like
        Derivative of warped image in y direction
    """

    I_warped = cv2.remap(I.astype('float32'),
                         xn.astype('float32'),
                         yn.astype('float32'),
                         borderMode=cv2.BORDER_REPLICATE,
                         interpolation=cv2.INTER_CUBIC)

    if compute_derivs:
        if True:
            dI_dy, dI_dx = np.gradient(I)[:2]
            dI_warped_dy = cv2.remap(dI_dy.astype('float32'),
                                xn.astype('float32'),
                                yn.astype('float32'),
                                borderMode=cv2.BORDER_REPLICATE,
                                interpolation=cv2.INTER_CUBIC)

            dI_warped_dx = cv2.remap(dI_dx.astype('float32'),
                                xn.astype('float32'),
                                yn.astype('float32'),
                                borderMode=cv2.BORDER_REPLICATE,
                                interpolation=cv2.INTER_CUBIC)
        else:
            dI_warped_dy, dI_warped_dx = np.gradient(I_warped)[:2]

        return I_warped, dI_warped_dx, dI_warped_dy

    # If we don't want to compute the derivatives
    return I_warped

def __image_generator(self):
        def id_generator(size=16, max_letter=6):
            _str = ''
            _letter_cnt = 0
            for i in range(size):
                if _letter_cnt < max_letter:
                    _c = random.choice(string.ascii_uppercase + string.digits)
                    if _c in string.ascii_uppercase:
                        _letter_cnt += 1
                else:
                    _c = random.choice(string.digits)
                _str += _c
            return _str
        def blur_method(_im, m):
            if m == 0:
                return _im
            elif m == 1:
                return cv2.GaussianBlur(_im, (5, 5), 0)
            elif m == 2:
                return cv2.blur(_im, (5,5))
            elif m == 3:
                return cv2.medianBlur(_im, 5)
            else:
                return _im
        def brightness(_im):
            _brightness_offset = np.random.randint(-50, 50)
            return cv2.convertScaleAbs(_im, alpha=1, beta=_brightness_offset)

        _dmtx = DMTX(shape=3)# shape=3 is 16x16
        while True:
            # 022RDXBTH4001093
            _str = id_generator(16, 2)
            _dmtx.encode(_str)
            _im = np.array(_dmtx.image)# [:,:,::-1]
            _im = cv2.cvtColor(_im, cv2.COLOR_RGB2GRAY)
            _im = cv2.resize(_im, (self.im_shape[1]-12, self.im_shape[0]-12))
            _h, _w = _im.shape[:2]
            # random mirco rotation
            _angle = np.random.randint(-6, 6) / 2.0
            _rot_mat = cv2.getRotationMatrix2D((_w / 2, _h / 2), _angle, 1)
            _im = cv2.warpAffine(_im, _rot_mat, (_w, _h))
            # get label
            _label = cv2.resize(_im, (self.la_shape[1], self.la_shape[0]))
            # low-resolution
            _scale = np.random.choice(range(1, 6))
            _im = cv2.resize(_im, (0,0), fx=1/float(_scale), fy=1/float(_scale))
            _im = cv2.resize(_im, (self.im_shape[1]-12, self.im_shape[0]-12))
            # add border. Need by net. 112 -> 100
            _im = cv2.copyMakeBorder(_im, 6, 6, 6, 6, cv2.BORDER_REPLICATE)
            # add noise
            _im = blur_method(_im, np.random.choice(range(0, 4)))
            _im = brightness(_im)
            # to caffe data format
            _im = _im.astype(np.float32, copy=False)
            _label = _label.astype(np.float32, copy=False)
            _im *= 0.0039215684
            _label *= 0.0039215684

            yield _im, _label