def random_rotate(w,h,angle,scale,*all_inputs):
if type(angle)==float:
angle=(-angle,angle)
if type(scale)==float:
scale=(1-scale,1+scale)
cx=(np.random.rand(len(all_inputs[0])).astype(floatX))*w
cy=(np.random.rand(len(all_inputs[0])).astype(floatX))*h
actions=(np.random.rand(len(all_inputs[0]),4,1,1)).astype(floatX)
actions2=np.zeros_like(actions)
actions2[:,0]=(actions[:,0]*(angle[1]-angle[0])+angle[0]).astype(floatX)
actions2[:,1]=(actions[:,1]*(scale[1]-scale[0])+scale[0]).astype(floatX)
actions2[:,2,0,0]=cx
actions2[:,3,0,0]=cy
all_outputs=[]
for inputs in all_inputs:
outputs=np.zeros(inputs.shape,dtype=floatX)
for i in range(len(inputs)):
mat = cv2.getRotationMatrix2D((cx[i],cy[i]),actions2[i,0,0,0],actions2[i,1,0,0])
tmp = cv2.warpAffine(inputs[i].transpose(1,2,0),mat,inputs[i].shape[1:]).transpose(2,0,1)
#tmp=np.pad(inputs[i:i+1],((0,0),(0,0),(n,n),(n,n)),mode='constant',constant_values=0)
#tmp=np.roll(tmp,actions2[i,0,0,0],2)
#tmp=np.roll(tmp,actions2[i,1,0,0],3)
outputs[i]=tmp
all_outputs+=[outputs]
return all_outputs+[actions2.reshape(len(inputs),4)]
python类warpAffine()的实例源码
def dumpRotateImage(img,degree,pt1,pt2,pt3,pt4):
height,width=img.shape[:2]
heightNew = int(width * fabs(sin(radians(degree))) + height * fabs(cos(radians(degree))))
widthNew = int(height * fabs(sin(radians(degree))) + width * fabs(cos(radians(degree))))
matRotation=cv2.getRotationMatrix2D((width/2,height/2),degree,1)
matRotation[0, 2] += (widthNew - width) / 2
matRotation[1, 2] += (heightNew - height) / 2
imgRotation = cv2.warpAffine(img, matRotation, (widthNew, heightNew), borderValue=(255, 255, 255))
pt1 = list(pt1)
pt3 = list(pt3)
[[pt1[0]], [pt1[1]]] = np.dot(matRotation, np.array([[pt1[0]], [pt1[1]], [1]]))
[[pt3[0]], [pt3[1]]] = np.dot(matRotation, np.array([[pt3[0]], [pt3[1]], [1]]))
imgOut=imgRotation[int(pt1[1]):int(pt3[1]),int(pt1[0]):int(pt3[0])]
height,width=imgOut.shape[:2]
return imgOut
step2_train_mass_segmenter.py 文件源码
项目：kaggle_ndsb2017
作者: juliandewit
项目源码
文件源码
阅读 39
收藏 0
点赞 0
评论 0
def random_translate_img(img, xy_range, border_mode="constant"):
if random.random() > xy_range.chance:
return img
import cv2
if not isinstance(img, list):
img = [img]
org_height, org_width = img[0].shape[:2]
translate_x = random.randint(xy_range.x_min, xy_range.x_max)
translate_y = random.randint(xy_range.y_min, xy_range.y_max)
trans_matrix = numpy.float32([[1, 0, translate_x], [0, 1, translate_y]])
border_const = cv2.BORDER_CONSTANT
if border_mode == "reflect":
border_const = cv2.BORDER_REFLECT
res = []
for img_inst in img:
img_inst = cv2.warpAffine(img_inst, trans_matrix, (org_width, org_height), borderMode=border_const)
res.append(img_inst)
if len(res) == 1:
res = res[0]
xy_range.last_x = translate_x
xy_range.last_y = translate_y
return res
step2_train_mass_segmenter.py 文件源码
项目：kaggle_ndsb2017
作者: juliandewit
项目源码
文件源码
阅读 26
收藏 0
点赞 0
评论 0
def random_rotate_img(img, chance, min_angle, max_angle):
import cv2
if random.random() > chance:
return img
if not isinstance(img, list):
img = [img]
angle = random.randint(min_angle, max_angle)
center = (img[0].shape[0] / 2, img[0].shape[1] / 2)
rot_matrix = cv2.getRotationMatrix2D(center, angle, scale=1.0)
res = []
for img_inst in img:
img_inst = cv2.warpAffine(img_inst, rot_matrix, dsize=img_inst.shape[:2], borderMode=cv2.BORDER_CONSTANT)
res.append(img_inst)
if len(res) == 0:
res = res[0]
return res
def create_rotated_sub_image(image, centre, search_width, angle_rad):
# Rotation transform requires x then y.
M = cv2.getRotationMatrix2D((centre[1], centre[0]), np.rad2deg(angle_rad), 1.0)
w = image.shape[1]
h = centre[0] + int((image.shape[0] - centre[0]) * abs(math.sin(angle_rad)))
rotated = cv2.warpAffine(image, M, (w, h))
# Centre the last white centroid into the centre of the image.
half_sub_image_width = int(min(min(search_width, centre[1]),
min(rotated.shape[1] - centre[1], search_width)))
sub_image = rotated[centre[0]:,
centre[1] - half_sub_image_width: centre[1] + half_sub_image_width]
return sub_image
def create_affine_transform_augmentation(img, random_limits=(0.8, 1.1)):
'''
Creates an augmentation by computing a homography from three
points in the image to three randomly generated points
'''
y, x = img.shape[:2]
fx = float(x)
fy = float(y)
src_point = np.float32([[fx/2, fy/3,],
[2*fx/3, 2*fy/3],
[fx/3, 2*fy/3]])
random_shift = (np.random.rand(3,2) - 0.5) * 2 * (random_limits[1]-random_limits[0])/2 + np.mean(random_limits)
dst_point = src_point * random_shift.astype(np.float32)
transform = cv2.getAffineTransform(src_point, dst_point)
borderValue = 0
if img.ndim == 3:
borderValue = np.median(np.reshape(img, (img.shape[0]*img.shape[1],-1)), axis=0)
else:
borderValue=np.median(img)
warped_img = cv2.warpAffine(img, transform, dsize=(x,y), borderValue=borderValue)
return warped_img
def rotate_bound(image, angle):
# grab the dimensions of the image and then determine the
# center
(h, w) = image.shape[:2]
(cX, cY) = (w // 2, h // 2)
# grab the rotation matrix (applying the negative of the
# angle to rotate clockwise), then grab the sine and cosine
# (i.e., the rotation components of the matrix)
M = cv2.getRotationMatrix2D((cX, cY), -angle, 1.0)
cos = np.abs(M[0, 0])
sin = np.abs(M[0, 1])
# compute the new bounding dimensions of the image
nW = int((h * sin) + (w * cos))
nH = int((h * cos) + (w * sin))
# adjust the rotation matrix to take into account translation
M[0, 2] += (nW / 2) - cX
M[1, 2] += (nH / 2) - cY
# perform the actual rotation and return the image
return cv2.warpAffine(image, M, (nW, nH))
def _random_roate(self, images, labels, degree):
if(images.shape[0] != labels.shape[0]):
raise Exception("Batch size Error.")
degree = degree * math.pi / 180
rand_degree = np.random.uniform(-degree, degree, images.shape[0])
o_images = np.zeros_like(images)
o_labels = np.zeros_like(labels)
for idx in xrange(images.shape[0]):
theta = rand_degree[idx]
# labels
for ii in xrange(self.points_num):
o_labels[idx, 2*ii: 2*ii+2] = self._rotate(labels[idx, ii*2: 2*ii+2], theta)
# image
M = cv2.getRotationMatrix2D((self.img_width/2,self.img_height/2),-theta*180/math.pi,1)
o_images[idx] = np.expand_dims(cv2.warpAffine(images[idx],M,(self.img_width,self.img_height)), axis=2)
return o_images, o_labels
def _batch_random_roate(self, images, labels, degree):
if(images.shape[0] != labels.shape[0]):
raise Exception("Batch size Error.")
degree = degree * math.pi / 180
rand_degree = np.random.uniform(-degree, degree)
o_images = np.zeros_like(images)
o_labels = np.zeros_like(labels)
for idx in xrange(images.shape[0]):
theta = rand_degree
# labels
for ii in xrange(self.points_num):
o_labels[idx, 2*ii: 2*ii+2] = self._rotate(labels[idx, ii*2: 2*ii+2], theta)
# image
M = cv2.getRotationMatrix2D((self.img_width/2,self.img_height/2),-theta*180/math.pi,1)
o_images[idx] = np.expand_dims(cv2.warpAffine(images[idx],M,(self.img_width,self.img_height)), axis=2)
return o_images, o_labels
def Transform(self, PointTop, PointRight, PointBottom):
Point1 = [PointTop[0], PointTop[1]]
Point2 = [PointRight[0], PointRight[1]]
Point3 = [PointBottom[0], PointBottom[1]]
src = np.float32([Point1, Point2, Point3])
dest_pointTop = [40, 40]
dest_pointRight = [140, 40]
dest_pointBottom = [40, 140]
destination = np.float32(
[dest_pointTop, dest_pointRight, dest_pointBottom])
affineTrans = cv.getAffineTransform(src, destination)
self.TransformImage = cv.warpAffine(
self.OriginalImage, affineTrans, self.OriginalImage.shape[:2])
self.TransformImage = self.TransformImage[0:200, 0:200]
#cv.imshow("TransformImage",self.TransformImage) #uncomment to debug
#cv.waitKey(0)
#cv.destroyAllWindows()
return self.TransformImage
def generate_im(char_ims, num_bg_images):
bg = generate_bg(num_bg_images)
plate, plate_mask, code = generate_plate(FONT_HEIGHT, char_ims)
M, out_of_bounds = make_affine_transform(
from_shape=plate.shape,
to_shape=bg.shape,
min_scale=0.6,
max_scale=0.875,
rotation_variation=1.0,
scale_variation=1.5,
translation_variation=1.2)
plate = cv2.warpAffine(plate, M, (bg.shape[1], bg.shape[0]))
plate_mask = cv2.warpAffine(plate_mask, M, (bg.shape[1], bg.shape[0]))
out = plate * plate_mask + bg * (1.0 - plate_mask)
out = cv2.resize(out, (OUTPUT_SHAPE[1], OUTPUT_SHAPE[0]))
out += numpy.random.normal(scale=0.05, size=out.shape)
out = numpy.clip(out, 0., 1.)
return out, code, not out_of_bounds
def warp_image(img, tM, shape):
out = np.zeros(shape, dtype=img.dtype)
# cv2.warpAffine(img,
# tM[:2],
# (shape[1], shape[0]),
# dst=out,
# borderMode=cv2.BORDER_TRANSPARENT,
# flags=cv2.WARP_INVERSE_MAP)
cv2.warpPerspective(img, tM, (shape[1], shape[0]), dst=out,
borderMode=cv2.BORDER_TRANSPARENT,
flags=cv2.WARP_INVERSE_MAP)
return out
# TODO: Modify this method to get a better face contour mask
def align(self, imgDim, rgbImg, bb,
landmarks=None, landmarkIndices=INNER_EYES_AND_BOTTOM_LIP, scale=1.0):
r"""align(imgDim, rgbImg, bb=None, landmarks=None, landmarkIndices=INNER_EYES_AND_BOTTOM_LIP)
Transform and align a face in an image.
:param imgDim: The edge length in pixels of the square the image is resized to.
:type imgDim: int
:param rgbImg: RGB image to process. Shape: (height, width, 3)
:type rgbImg: numpy.ndarray
:param bb: Bounding box around the face to align. \
Defaults to the largest face.
:type bb: dlib.rectangle
:param landmarks: Detected landmark locations. \
Landmarks found on `bb` if not provided.
:type landmarks: list of (x,y) tuples
:param landmarkIndices: The indices to transform to.
:type landmarkIndices: list of ints
:param scale: Scale image before cropping to the size given by imgDim.
:type scale: float
:return: The aligned RGB image. Shape: (imgDim, imgDim, 3)
:rtype: numpy.ndarray
"""
assert imgDim is not None
assert rgbImg is not None
assert landmarkIndices is not None
assert bb is not None
bb_dlib = dlib.rectangle(left=bb[0], top=bb[1], right=bb[2], bottom=bb[3])
if landmarks is None:
landmarks = self.findLandmarks(rgbImg, bb_dlib)
npLandmarks = np.float32(landmarks)
npLandmarkIndices = np.array(landmarkIndices)
#pylint: disable=maybe-no-member
H = cv2.getAffineTransform(npLandmarks[npLandmarkIndices],
imgDim * MINMAX_TEMPLATE[npLandmarkIndices]*scale + imgDim*(1-scale)/2)
thumbnail = cv2.warpAffine(rgbImg, H, (imgDim, imgDim))
return thumbnail
def align(self, imgDim, rgbImg, bb,
landmarks=None, landmarkIndices=INNER_EYES_AND_BOTTOM_LIP, scale=1.0):
r"""align(imgDim, rgbImg, bb=None, landmarks=None, landmarkIndices=INNER_EYES_AND_BOTTOM_LIP)
Transform and align a face in an image.
:param imgDim: The edge length in pixels of the square the image is resized to.
:type imgDim: int
:param rgbImg: RGB image to process. Shape: (height, width, 3)
:type rgbImg: numpy.ndarray
:param bb: Bounding box around the face to align. \
Defaults to the largest face.
:type bb: dlib.rectangle
:param landmarks: Detected landmark locations. \
Landmarks found on `bb` if not provided.
:type landmarks: list of (x,y) tuples
:param landmarkIndices: The indices to transform to.
:type landmarkIndices: list of ints
:param scale: Scale image before cropping to the size given by imgDim.
:type scale: float
:return: The aligned RGB image. Shape: (imgDim, imgDim, 3)
:rtype: numpy.ndarray
"""
assert imgDim is not None
assert rgbImg is not None
assert landmarkIndices is not None
assert bb is not None
bb_dlib = dlib.rectangle(left=bb[0], top=bb[1], right=bb[2], bottom=bb[3])
if landmarks is None:
landmarks = self.findLandmarks(rgbImg, bb_dlib)
npLandmarks = np.float32(landmarks)
npLandmarkIndices = np.array(landmarkIndices)
#pylint: disable=maybe-no-member
H = cv2.getAffineTransform(npLandmarks[npLandmarkIndices],
imgDim * MINMAX_TEMPLATE[npLandmarkIndices]*scale + imgDim*(1-scale)/2)
thumbnail = cv2.warpAffine(rgbImg, H, (imgDim, imgDim))
return thumbnail
def apply_affine(img, mat):
return cv.warpAffine(img, mat, img.shape, flags=cv.INTER_LINEAR)
def findCorners(contour):
"""blank_image = np.zeros((img.shape[0],img.shape[1],3), np.uint8)
cv2.drawContours(blank_image, contour, -1, (255, 255, 255))
rows,cols = img.shape[0], img.shape[1]
M = cv2.getRotationMatrix2D((cols/2,rows/2),-45,0.5)
dst = cv2.warpAffine(blank_image,M,(cols,rows))
cv2.imshow("rotatio", dst)
cv2.waitKey()"""
rect = cv2.minAreaRect(contour)
box = cv2.boxPoints(rect)
box = np.int0(box)
height_px_1 = box[0][1] - box[3][1]
height_px_2 = box[1][1] - box[2][1]
print height_px_1, height_px_2
if height_px_1 < height_px_2:
close_height_px = height_px_2
far_height_px = height_px_1
else:
close_height_px = height_px_1
far_height_px = height_px_2
return close_height_px, far_height_px
def rotate_bound(image, angle):
# grab the dimensions of the image and then determine the
# center
(h, w) = image.shape[:2]
(cX, cY) = (w // 2, h // 2)
# grab the rotation matrix (applying the negative of the
# angle to rotate clockwise), then grab the sine and cosine
# (i.e., the rotation components of the matrix)
M = cv2.getRotationMatrix2D((cX, cY), -angle, 1.0)
cos = np.abs(M[0, 0])
sin = np.abs(M[0, 1])
# compute the new bounding dimensions of the image
nW = int((h * sin) + (w * cos))
nH = int((h * cos) + (w * sin))
# adjust the rotation matrix to take into account translation
M[0, 2] += (nW / 2) - cX
M[1, 2] += (nH / 2) - cY
# perform the actual rotation and return the image
return cv2.warpAffine(image, M, (nW, nH))
def create_design_data_set(labeled_designs,design_crop_dir,image_dir,test):
labels = ['heads','tails']
if test:
pixels_to_jitter = 0
angles = 1
else:
pixels_to_jitter = 2
angles = 100
for label in labels:
dir = image_dir + label + '/'
if not os.path.exists(dir):
os.makedirs(dir)
for coin_id, label in labeled_designs.iteritems():
before_rotate_size = 56
for image_id in range(0,56):
#dir = design_crop_dir + str(coin_id / 100) + '/'
class_dir = image_dir + label + '/'
#for angle in range(0,10):
filename = str(coin_id).zfill(5) + str(image_id).zfill(2) + '.png'
image = cv2.imread(design_crop_dir + filename)
image = cv2.resize(image, (before_rotate_size, before_rotate_size), interpolation=cv2.INTER_AREA)
for count in range(0,angles):
angle = random.random() * 360
center_x = before_rotate_size / 2 + (random.random() * pixels_to_jitter * 2) - pixels_to_jitter
center_y = before_rotate_size / 2 + (random.random() * pixels_to_jitter * 2) - pixels_to_jitter
rot_image = image.copy()
m = cv2.getRotationMatrix2D((center_x, center_y), angle, 1)
cv2.warpAffine(rot_image, m, (before_rotate_size, before_rotate_size), rot_image, cv2.INTER_CUBIC)
# This is hard coded for 28x28.
rot_image = cv2.resize(rot_image, (41, 41), interpolation=cv2.INTER_AREA)
rot_image = rot_image[6:34, 6:34]
rotated_filename = filename.replace('.png', str(count).zfill(2) + '.png')
cv2.imwrite(class_dir + rotated_filename,rot_image)
sys.exit()
def get_rotated_crop(crop_dir, crop_id, crop_size, angle):
filename = get_filename_from(crop_id,crop_dir)
crop = cv2.imread(filename)
if crop == None:
print crop_id, 'None'
return None
crop = cv2.resize(crop, (crop_size, crop_size), interpolation=cv2.INTER_AREA)
if angle == None:
angle = 0
print crop_dir, crop_id, crop_size, angle
m = cv2.getRotationMatrix2D((crop_size / 2, crop_size / 2), angle, 1)
cv2.warpAffine(crop, m, (crop_size, crop_size), crop, cv2.INTER_CUBIC)
return crop
def align_2p(img, left_eye, right_eye):
width = 256
eye_width = 70
transform = np.matrix([
[1, 0, left_eye[0]],
[0, 1, left_eye[1]],
[0, 0, 1]
], dtype='float')
th = np.pi + -np.arctan2(left_eye[1] - right_eye[1], left_eye[0] - right_eye[0])
transform *= np.matrix([
[np.cos(th), np.sin(th), 0],
[-np.sin(th), np.cos(th), 0],
[0, 0, 1]
], dtype='float')
scale = np.sqrt((left_eye[1] - right_eye[1]) ** 2 + (left_eye[0] - right_eye[0]) ** 2) / eye_width
transform *= np.matrix([
[scale, 0, 0],
[0, scale, 0],
[0, 0, 1]
], dtype='float')
transform *= np.matrix([
[1, 0, -(width - eye_width) / 2],
[0, 1, -width / 2.42],
[0, 0, 1]
], dtype='float')
transform = np.linalg.inv(transform)
jmg = cv2.warpAffine(img, transform[:2], (width, width))
return jmg
