def PopulateImages(self):
"""
Populate necessary images for opencv to use
:return: 0 if the video is done
"""
if self.csvFlag:
try:
points = self.PointsFromCSV()
except:
return 0
self.img0 = self.PointsForJointsCSV(points) # img0 is a list of lists of points. each sublist corresponds to a joint. The last sublist corresponds to roguepoints
else:
ret, frame = self.cam.read()
if frame is None:
return 0# video done streaming
if self.rotation != 0:
if self.rotation == 90:
frame = cv2.flip(cv2.transpose(frame), 1)
elif self.rotation == -90:
frame = cv2.flip(cv2.transpose(frame), 0)
elif abs(self.rotation) == 180:
frame = cv2.flip(cv2.flip(frame,0), 1)
else:
raise Exception("Improper rotation value passed.")
if prm.DEBUG:
self.vis = frame.copy()
self.frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
return 1#Good flag
def rotate_imgs(self): ''' Rotates left and right images to proper orientation. Note this is done with transpose and flip as opposed to cv2.warpAffine to improve speed. ''' self.rotated_image_left = cv2.flip(cv2.transpose(self.raw_image_left), 0) self.rotated_image_right = cv2.flip(cv2.transpose(self.raw_image_right), 1)
def update_pos_stats(self, cam_matrix, distortion_coefficients, object_points):
"""
Takes the square's corners found in the image, corresponding 3d
coordinates, and intrinsic camera information. Sets fields related to
extrinsic camera information: cam_rot, normal, cam_pos, location.
Note that the square might be bogus until you check its score, and
camera extrinsics are unaligned until align squares is called.
:param cam_matrix:
:param distortion_coefficients:
:param object_points:
:return: nothing
"""
temp_corners = self.corners.reshape(4, 2, 1).astype(float)
# Gets vector from camera to center of square
inliers, self.rvec, self.tvec = cv2.solvePnP(object_points, temp_corners,
cam_matrix, distortion_coefficients)
rot_matrix = cv2.Rodrigues(self.rvec)
cam_pos = np.multiply(cv2.transpose(rot_matrix[0]), -1).dot(self.tvec)
cam_to_grid_transform = np.concatenate((cv2.transpose(rot_matrix[0]), cam_pos), axis=1)
grid_to_cam_transform = np.linalg.inv(np.concatenate((cam_to_grid_transform, np.array([[0, 0, 0, 1]])), axis=0))
self.cam_rot = list(cam_to_grid_transform.dot(np.array([0, 0, 1, 0])))
self.normal = grid_to_cam_transform.dot(np.array([0, 0, 1, 0]))
self.cam_pos = cam_pos
self.location = [cam_pos[0][0],cam_pos[1][0],cam_pos[2][0]]
def grabFrames(): global imageLeft global imageRight # global filterStackLeft # global filterStackRight returnLeft, tempLeft = captureLeft.read() returnLeft, tempRight = captureRight.read() imageLeft = cv2.flip(cv2.transpose(tempLeft), 0) #imageLeft = cv2.flip(tempLeft, -1) imageRight = cv2.flip(cv2.transpose(tempRight), 0) #imageRight = tempRight# # grayL = cv2.cvtColor(imageLeft, cv2.COLOR_RGBA2GRAY) # grayR = cv2.cvtColor(imageRight, cv2.COLOR_RGBA2GRAY) # filterStackLeft = np.roll(filterStackLeft, 1, axis=0) # filterStackLeft[0] = grayL # filterStackRight = np.roll(filterStackRight, 1, axis=0) # filterStackRight[0] = grayR imageLeft = bilateralFilter(imageLeft) imageRight = bilateralFilter(imageRight)
def getGradientInfo(img):
sobelHorizontal = cv2.Sobel(img, ddepth = cv2.cv.CV_32F, dx = 1, dy = 0, ksize = 3)
sobelVertical = cv2.Sobel(img, ddepth = cv2.cv.CV_32F, dx = 0, dy = 1, ksize = 3)
magnitude, angle = cv2.cartToPolar(sobelHorizontal, sobelVertical)
# sobelHorizontal = cv2.convertScaleAbs(sobelHorizontal)
# sobelVertical = cv2.convertScaleAbs(sobelVertical)
# sobelHorizontal2 = cv2.convertScale(sobelHorizontal)
# sobelVertical2 = cv2.convertScale(sobelVertical)
# cv2.imshow("Threshold", cv2.addWeighted(sobelHorizontal, 0.5, sobelVertical, 0.5, 0))
# Quiver Plot
res = 10
N, M = img.shape
X, Y = np.meshgrid(np.arange(0, M, res), np.arange(0, N, res))
f = figure(1)
imshow(img, cmap=cm.gray)
# quiver(X, Y, sobelHorizontal[::res,::res], sobelVertical[::res,::res], units = "xy")
abc = cv2.addWeighted(sobelHorizontal, 0.5, sobelVertical, 0.5, 0)
print(abc.shape)
quiver(X, Y, cv2.transpose(sobelHorizontal)[::res,::res], cv2.transpose(sobelVertical)[::res,::res])
f.show()
return
def cv2rotateimage(image, angle):
"""Efficient rotation if 90 degrees rotations, slow otherwise.
Not a tensorflow function, using cv2 and scipy on numpy arrays.
Args:
image: a numpy array with shape [height, width, channels].
angle: the rotation angle in degrees in the range [-180, 180].
Returns:
The rotated image.
"""
# Limit angle to [-180, 180] degrees.
assert angle <= 180 and angle >= -180
if angle == 0:
return image
# Efficient rotations.
if angle == -90:
image = cv2.transpose(image)
image = cv2.flip(image, 0)
elif angle == 90:
image = cv2.transpose(image)
image = cv2.flip(image, 1)
elif angle == 180 or angle == -180:
image = cv2.flip(image, 0)
image = cv2.flip(image, 1)
else: # Slow rotation.
image = ndimage.interpolation.rotate(image, 270)
return image
def fix_orient(image,value): if value <= 1: #do nothing out = image.copy() elif value == 2: #flip image horizontally out = cv2.flip(image,1) elif value == 3: #flip vertically, horizontally or rotate 180 out = cv2.flip(image,-1) elif value == 4: #flip vertically out = cv2.flip(image,0) elif value == 5: # transpose out = cv2.transpose(image) elif value == 6: # flip vertically, transpose or rotate 90 temp = cv2.flip(image,0) out = cv2.transpose(temp) elif value == 7: # flip horizontally, vertically, transpose or transverse temp = cv2.flip(image,-1) out = cv2.transpose(temp) elif value == 8: # flip horizontally, transpose or rotate 270 temp = cv2.flip(image,1) out = cv2.transpose(temp) return out
def rotate(input_file,output_file,mode) : img = cv2.imread(input_file,cv2.IMREAD_GRAYSCALE) rows,cols= img.shape temp = np.zeros((cols,rows),np.uint8) cv2.transpose(img,temp) cv2.flip(temp,mode,temp) cv2.imwrite(output_file,temp)
def minervini(self, norm):
# Calculate texture response filter from Minervini 2013
# FIXME: radius, gaussian size and sigmas should be user defined.
falloff = 1.0 / 50.0
pillsize = 7
gaussize = 17
sdH = 4
sdL = 1
# pillbox feature (F1)
pillse = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,
(pillsize, pillsize))
pillse = pillse.astype(float)
pillse = pillse / sum(sum(pillse))
F1 = cv2.filter2D(self.imgLAB[:, :, 1], -1, pillse)
# Difference of Gaussian (DoG) featrue (F2)
G1 = cv2.getGaussianKernel(gaussize, sdH)
G2 = cv2.getGaussianKernel(gaussize, sdL)
G1 = G1 * cv2.transpose(G1)
G2 = G2 * cv2.transpose(G2)
F2 = cv2.filter2D(self.imgLAB[:, :, 0], -1, G1 - G2)
F = np.exp(-falloff * np.abs(F1 + F2))
# FIXME: We are ignoring norm for now.
F = self.normRange(F)
F = np.reshape(F, (F.shape[0], F.shape[1], 1))
return F
def get_difference_y_image(image):
kernel = numpy.array([[.5],[0],[-.5]])
result = cv2.transpose(image.copy())
cv2.filter2D(cv2.transpose(image.copy()), -1, kernel, result)
return cv2.transpose(result)
def rotate(self, degrees):
# see http://stackoverflow.com/a/23990392
if degrees == 90:
self.image = cv2.transpose(self.image)
cv2.flip(self.image, 0, self.image)
elif degrees == 180:
cv2.flip(self.image, -1, self.image)
elif degrees == 270:
self.image = cv2.transpose(self.image)
cv2.flip(self.image, 1, self.image)
else:
# see http://stackoverflow.com/a/37347070
# one pixel glitch seems to happen with 90/180/270
# degrees pictures in this algorithm if you check
# the typical github.com/recurser/exif-orientation-examples
# but the above transpose/flip algorithm is working fine
# for those cases already
width, height = self.size
image_center = (width / 2, height / 2)
rot_mat = cv2.getRotationMatrix2D(image_center, degrees, 1.0)
abs_cos = abs(rot_mat[0, 0])
abs_sin = abs(rot_mat[0, 1])
bound_w = int((height * abs_sin) + (width * abs_cos))
bound_h = int((height * abs_cos) + (width * abs_sin))
rot_mat[0, 2] += ((bound_w / 2) - image_center[0])
rot_mat[1, 2] += ((bound_h / 2) - image_center[1])
self.image = cv2.warpAffine(self.image, rot_mat, (bound_w, bound_h))
def rotate90(self, image): if self.angle == 1: # 90 deg return cv.transpose(cv.flip(image,1)) elif self.angle == 2: # 180 deg return cv.flip(image,-1) elif self.angle == 3: # 270 deg return cv.flip(cv.transpose(image),1) else: return image
def str2img(jpgstr, orientation=None):
import numpy as np
import cv2
arr = np.fromstring(jpgstr, np.uint8)
img = cv2.imdecode(arr, cv2.IMREAD_COLOR)
if orientation == 1:
return cv2.flip(cv2.transpose(img), 0) # counter-clockwise
if orientation == 3:
return cv2.flip(cv2.transpose(img), 1) # clockwise
return img
def rotateImage(self, img, angle=90):
"""+-90 degree rotations are fast and do not crop"""
if (angle == 90) :
return(cv2.flip(cv2.transpose(img),flipCode=0))
elif (angle == -90) :
return(cv2.flip(cv2.transpose(img),flipCode=1))
else :
center = (img.shape[1]/2.0,img.shape[0]/2.0)
rotate = cv2.getRotationMatrix2D(center, angle, 1.0)
return cv2.warpAffine(img, rotate, (img.shape[1], img.shape[0]))
def raycast(image, rays=4, resolution=1, ret_type="image", dist_delta=1, blur=False):
"""
:param image: must be grayscale
:param rays: number of rays to cast. must be 2, 4 or 8. 2 is left-right, 4 gives cardinal directions, 8 adds diagonal at 45 degrees.
:param ret_type: "image" for all of the things composited, "array" for a list of separate frames
:return: four or eight channel image of ray lengths, clockwise from up
"""
if not ret_type in ["image", "array"]:
print "invalid return type in raycast call"
return
init_im = image
lr_ray_im = left_right_ray(image, resolution, dist_delta)
image = cv2.flip(image, 1)
rl_ray_im = cv2.flip(left_right_ray(image, resolution), 1, dist_delta)
if rays in [2, 4, 8]:
if ret_type == "image":
ret = cv2.merge([lr_ray_im, rl_ray_im])
elif ret_type == "array":
ret = [lr_ray_im, rl_ray_im]
if rays in [4, 8]:
image = cv2.transpose(image)
down_ray_im = cv2.transpose(left_right_ray(image, resolution, dist_delta), 1)
image = cv2.flip(image, 1)
up_ray_im = cv2.flip(cv2.transpose(cv2.flip(left_right_ray(image, resolution, dist_delta), 1)), 1)
if ret_type == "image":
ret = cv2.merge([up_ray_im, lr_ray_im, down_ray_im, rl_ray_im])
elif ret_type == "array":
ret = [up_ray_im, lr_ray_im, down_ray_im, rl_ray_im]
if rays == 8:
skew_1, deskew_1 = skew(init_im)
sca_ne_sw = [deskew(x, reverse_affine=deskew_1) for x in raycast(skew_1, rays=2, ret_type="array", resolution=resolution, dist_delta=1.414)]
skew_2, deskew_2 = skew(cv2.flip(init_im, 0))
sca_se_nw = [cv2.flip(deskew(x, reverse_affine=deskew_2), 0) for x in raycast(skew_2, rays=2, ret_type="array", resolution=resolution, dist_delta=1.414)]
array = [up_ray_im, sca_ne_sw[0], lr_ray_im, sca_se_nw[0], down_ray_im, sca_ne_sw[1], rl_ray_im, sca_se_nw[1]]
if ret_type == "image":
ret = cv2.merge(array)
elif ret_type == "array":
ret = array
if blur:
box_size = (resolution, resolution)
if ret_type == "array":
print "printing ret for investigative purposes:"
print ret
print "len(ret)", len(ret)
print "ret[0]", type(ret[0]), ret[0]
print "ret[1]", type(ret[1]), ret[1]
ret = [cv2.boxFilter(x, -1, box_size, normalize=False) for x in ret]
if ret_type == "image":
ret = cv2.boxFilter(x, -1, box_size, normalize=False)
return ret
def RotateFrame(frame, theta_deg):
"""
Rotate frame in multiples of 90 degrees.
Arguments
----
frame : numpy uint8 array
Video frame to rotate.
theta_deg : integer
CCW rotation angle in degrees (math convention)
Integer multiples of 90 degrees are handled quickly.
Arbitrary rotation angles are slower.
Returns
----
new_frame : numpy uint8 array
rotated frame
Example
----
>>> frame_rot = RotateFrame(frame, 90)
"""
if theta_deg == 0:
# Do nothing
new_frame = frame.copy()
elif theta_deg == 90:
# Rotate CCW 90
new_frame = cv2.transpose(frame)
new_frame = cv2.flip(new_frame, flipCode = 0)
elif theta_deg == 270:
# Rotate CCW 270 (CW 90)
new_frame = cv2.transpose(frame)
new_frame = cv2.flip(new_frame, flipCode = 1)
elif theta_deg == 180:
# Rotate by 180
new_frame = cv2.flip(frame, flipCode = 0)
new_frame = cv2.flip(new_frame, flipCode = 1)
else: # Arbitrary rotation
new_frame = rotate(frame, theta_deg, resize=True)
# Scale and recast to uint8
new_frame = np.uint8(new_frame * 255.0)
return new_frame
def rotateImage(img, clockwise=True):
#timg = np.zeros(img.shape[1],img.shape[0]) # transposed image
if clockwise:
# rotate counter-clockwise
timg = cv2.transpose(img)
cv2.flip(timg,flipCode=0)
return timg
else:
# rotate clockwise
timg = cv2.transpose(img)
cv2.flip(timg,flipCode=1)
return timg
def hologram(infile, outfile, screen_below_pyramid=False):
'''Transform infile video to a hologram video with no audio track and save to outfile'''
capture = cv2.cv.CaptureFromFile(infile)
# nbFrames = int(cv2.cv.GetCaptureProperty(capture, cv2.cv.CV_CAP_PROP_FRAME_COUNT))
width = int(cv2.cv.GetCaptureProperty(capture, cv2.cv.CV_CAP_PROP_FRAME_WIDTH))
height = int(cv2.cv.GetCaptureProperty(capture, cv2.cv.CV_CAP_PROP_FRAME_HEIGHT))
fps = cv2.cv.GetCaptureProperty(capture, cv2.cv.CV_CAP_PROP_FPS)
# duration = (nbFrames / float(fps))
length = request.form['length']
d = request.form['d']
padding = request.form['padding']
assert 0 < int(length) <= 5000, 'Length is not in (0, 5000].'
assert 0 < int(d) < int(length) / 2, 'd is not in (0, length/2).'
assert 0 <= 2 * int(padding) < min(2 * int(d), int(length) / 2 - int(d)), 'Padding is too large.'
length, d, padding = map(int, [length, d, padding])
if length % 2:
length += 1 # Keep length even for convenience
cap = cv2.VideoCapture(infile)
bgd = np.zeros((length, length, 3), np.uint8) # Create a black background
new_wid = 2 * d - 2 * padding
new_hgt = int(float(new_wid) / width * height)
if new_hgt + d + 2 * padding > length / 2:
new_hgt = length / 2 - d - 2 * padding
new_wid = int(float(new_hgt) / height * width)
if new_wid % 2:
new_wid -= 1
if new_hgt % 2:
new_hgt -= 1
fourcc = cv2.cv.CV_FOURCC('m', 'p', '4', 'v')
out = cv2.VideoWriter(outfile, fourcc, fps, (length,length))
while(1):
ret, frame = cap.read()
if not ret:
break
resized_frame = cv2.resize(frame, (new_wid, new_hgt))
if screen_below_pyramid:
resized_frame = cv2.flip(resized_frame, 0)
bgd[length/2 + d + padding:length/2 + d + new_hgt + padding, length/2 - new_wid/2:length/2 + new_wid/2] =\
resized_frame
bgd[length/2 - d - padding - new_hgt:length/2 - d - padding, length/2 - new_wid/2:length/2 + new_wid/2] =\
cv2.flip(resized_frame, -1)
bgd[length/2 - new_wid/2:length/2 + new_wid/2, length/2 + d + padding:length/2 + d + new_hgt + padding] =\
cv2.flip(cv2.transpose(resized_frame), 0)
bgd[length/2 - new_wid/2:length/2 + new_wid/2, length/2 - d - padding - new_hgt:length/2 - d - padding] =\
cv2.flip(cv2.transpose(resized_frame), 1)
out.write(bgd)
cap.release()
out.release()
def crops(self, normalised, rotation=None):
"""Generator function that yields cropped images
Rotation should be None, an int or an iterable. If not None, crops will
be rotated by that many clockwise degrees.
"""
import cv2
import numpy as np
if not rotation:
rotation = repeat(0)
elif isinstance(rotation, int):
rotation = repeat(rotation)
h, w = self.array.shape[:2]
for box, rotate in zip(self.from_normalised(normalised), rotation):
x0, y0, x1, y1 = box.coordinates
x_in_bounds = [0 <= x0 <= w, 0 <= x1 <= w]
y_in_bounds = [0 <= y0 <= h, 0 <= y1 <= h]
if all(chain(x_in_bounds, y_in_bounds)):
# View
crop = self.array[y0:y1, x0:x1]
else:
# Box is out of bounds -create a new array, all zeroes (black)
crop_w, crop_h = x1-x0, y1-y0
crop = np.zeros((crop_h, crop_w, self.array.shape[2]),
dtype=self.array.dtype)
if any(x_in_bounds) and any(y_in_bounds):
# Partial overlap
overlapping = self.array[max(y0, 0):min(y1, h),
max(x0, 0):min(x1, w)]
dest_y, dest_x = max(0, 0-y0), max(0, 0-x0)
crop[dest_y:(dest_y + overlapping.shape[0]),
dest_x:(dest_x + overlapping.shape[1])] = overlapping
if 0 != rotate % 90:
msg = 'Rotation is not a multiple of 90: [{0}]'
raise ValueError(msg.format(rotate))
elif rotate:
n_rotations = (rotate % 360) / 90
# n_rotations will be 0, 1, 2 or 3 = the number of 90 degree
# clockwise rotations
if 1 == n_rotations:
# Rotate 90 clockwise
crop = cv2.flip(cv2.transpose(crop), 1)
elif 2 == n_rotations:
# Rotate 180 clockwise
crop = cv2.flip(crop, -1)
elif 3 == n_rotations:
# Rotate 90 counter-clockwise
crop = cv2.flip(cv2.transpose(crop), 0)
yield crop
def grab(self, index=0):
""" Actually read a new frame at given index.
Setting color flag to False will convert frames to greyscale.
"""
if index != self.index:
self.index = index
rv, frame = self.capture.read()
if rv:
if self.color:
self.current_frame = cv2.transpose(cv2.cvtColor(frame, code=cv2.COLOR_BGR2RGB))
else:
self.current_frame = cv2.transpose(cv2.cvtColor(frame, code=cv2.COLOR_BGR2GRAY))
return self.current_frame
def rotate_imgs(raw_image_right, raw_image_left): ''' Rotates left and right images to proper orientation. Note this is done with transpose and flip as opposed to cv2.warpAffine to improve speed. ''' # Rotate left image image_left = cv2.transpose(raw_image_left) image_left = cv2.flip(image_left, 0) # Rotate right image image_right = cv2.transpose(raw_image_right) image_right = cv2.flip(image_right, 1) return image_right, image_left
def main():
ip_cam_url = ''
capture_rate = default_capture_rate
argv_len = len(sys.argv)
if argv_len > 1:
ip_cam_url = sys.argv[1]
if argv_len > 2 and sys.argv[2].isdigit():
capture_rate = int(sys.argv[2])
else:
print("usage: video_cap_ipcam.py <ip-cam-url> [capture-rate]")
return
print("Capturing from '{}' at a rate of 1 every {} frames...".format(ip_cam_url, capture_rate))
stream = urllib.urlopen(ip_cam_url)
bytes = ''
pool = Pool(processes=3)
frame_count = 0
while True:
# Capture frame-by-frame
frame_jpg = ''
bytes += stream.read(16384*2)
b = bytes.rfind('\xff\xd9')
a = bytes.rfind('\xff\xd8', 0, b-1)
if a != -1 and b != -1:
#print 'Found JPEG markers. Start {}, End {}'.format(a,b)
frame_jpg_bytes = bytes[a:b+2]
bytes = bytes[b+2:]
if frame_count % capture_rate == 0:
#You can perform any image pre-processing here using OpenCV2.
#Rotating image 90 degrees to the left:
nparr = np.fromstring(frame_jpg_bytes, dtype=np.uint8)
#Simple and efficient rotation: 90 degrees left = flip + transpose
img_cv2_mat = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
rotated_img = cv2.transpose(cv2.flip(img_cv2_mat, 0))
#Computationally-intensive rotation
# (h,w) = img_cv2_mat.shape[:2]
# center = (w/2, h/2)
# rot_mat = cv2.getRotationMatrix2D(center, -90, 1.0)
# rotated = cv2.warpAffine(img_cv2_mat, rot_mat, (w, h))
retval, new_frame_jpg_bytes = cv2.imencode(".jpg", rotated_img)
#Send to Kinesis
result = pool.apply_async(send_jpg, (bytearray(new_frame_jpg_bytes), frame_count, True, False, False,))
frame_count += 1
def __init__(self, image, low, high):
self.image_name = image
self.low = low
self.high = high
self.filter = None
self.output = None
self.filter_type = None
self.padRows = None
self.padCols = None
original_input = cv2.imread(image,0)
rows, cols = original_input.shape
if(rows < cols):
original_input = cv2.transpose(original_input)
self.transposed = True
else:
self.transposed = False
rows, cols = original_input.shape
optimalRows = cv2.getOptimalDFTSize(rows)
optimalCols = cv2.getOptimalDFTSize(cols)
self.padRows = optimalRows - rows
self.padCols = optimalCols - cols
self.input = np.zeros((optimalRows,optimalCols))
self.input[:rows,:cols] = original_input
self.dftshift = get_dft_shift(self.input)
plt.subplots_adjust(left=0, bottom=0.05, right=1, top=1, wspace=0, hspace=0)
plt.subplot(131)
plt.axis('off')
plt.title('original image')
plt.imshow(self.input, cmap = 'gray',interpolation='nearest')
self.axslow = plt.axes([0.05, 0.01, 0.5, 0.02])
self.slow = Slider(self.axslow, 'low', 0.01, 1, valinit=self.low)
self.slow.on_changed(self.updateLow)
self.axhigh = plt.axes([0.05, 0.03, 0.5, 0.02])
self.shigh = Slider(self.axhigh, 'high', 0.01, 1, valinit=self.high)
self.shigh.on_changed(self.updateHigh)
self.slow.slidermax=self.shigh
self.shigh.slidermin=self.slow
self.axfilter = plt.axes([0.62, 0.01, 0.15, 0.04])
self.rfilter = RadioButtons(self.axfilter, ('Gaussian Filter', 'Ideal Filter'))
self.rfilter.on_clicked(self.updateFilterType)
self.filter_type = self.rfilter.value_selected
self.axprocess = plt.axes([0.8, 0.01, 0.08, 0.04])
self.bprocess = Button(self.axprocess, 'Process')
self.bprocess.on_clicked(self.process)
self.axsave = plt.axes([0.88, 0.01, 0.08, 0.04])
self.bsave = Button(self.axsave, 'Save')
self.bsave.on_clicked(self.save)
def save(self, unused):
filter_file_title = os.path.splitext(self.image_name)[0] + '_' + self.filter_type + '_' + str(self.low)+'_'+str(self.high)+'_filter'
processed_file_title = os.path.splitext(self.image_name)[0] + '_' + self.filter_type + '_' + str(self.low)+'_'+str(self.high)
if(self.padRows != 0 or self.padCols != 0):
rows, cols = self.output.shape
processed = self.output[:rows-self.padRows, :cols-self.padCols]
else:
processed = self.output
if(self.transposed):
save_filter(cv2.transpose(self.filter), filter_file_title)
save_image(cv2.transpose(processed), processed_file_title)
else:
save_filter(self.filter, filter_file_title)
save_image(processed, processed_file_title)
def rotateYlabel(label):
"""
Function to rotate y axis label
"""
label = cv2.transpose(label)
label = cv2.flip(label, 1)
return label
def makePortrait(img):
height = len(img)
width = len(img[0])
if width > height:
return cv2.transpose(img)
else:
return img
def captureImage(self, mirror=False, flush=False, flushValue=1): """ If mirror is set to True, the image will be displayed as a mirror, otherwise it will be displayed as the camera sees it """ if self.isConnected: self.reading = True if flush: for i in xrange(0, flushValue): self.capture.read() #grab() ret, image = self.capture.read() self.reading = False if ret: if self.useDistortion and \ self.cameraMatrix is not None and \ self.distortionVector is not None and \ self.distCameraMatrix is not None: mapx, mapy = cv2.initUndistortRectifyMap(self.cameraMatrix, self.distortionVector, R=None, newCameraMatrix=self.distCameraMatrix, size=(self.width, self.height), m1type=5) image = cv2.remap(image, mapx, mapy, cv2.INTER_LINEAR) image = cv2.transpose(image) if not mirror: image = cv2.flip(image, 1) self._success() return cv2.cvtColor(image, cv2.COLOR_BGR2RGB) else: self._fail() return None else: self._fail() return None
def set_cam_position(self):
while True:
ret, frame = self.capture.read()
if ret:
# Rotate and flip
if self.cf["inverse"]:
rot = cv2.flip(cv2.transpose(frame), 1)
else:
rot = frame
# Display raw
rot = self.rawWin.add_lines(rot, self.cf)
self.rawWin.display(rot, self.cf)
# Display grayscale image
gray = cv2.cvtColor(rot, cv2.COLOR_BGR2GRAY)
self.grayWin.display(gray, self.cf)
# Display trackbar
sw_old = self.barWin.win_set["laser"]
self.barWin.display(gray, self.cf)
sw_new = self.barWin.win_set["laser"]
# Update laser
laser_L_or_R(self.arduino, sw_old, sw_new)
# wait for esc key to exit
key = np.int16(cv2.waitKey(33))
if key == 27:
break
else:
print("Webcam is busy")
cv2.destroyAllWindows()
def _grabImage(self):
w = self.display.widget
rval, img = self.vc.read()
if rval:
# COLOR
if self.pGrayscale.value():
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
else:
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.transpose(img)
if self.pFloat.value():
img = toFloatArray(img)
i = w.image
b = self.pBuffer.value()
if b:
# BUFFER LAST N IMAGES
if i is None or len(i) < b:
self.display.addLayer(data=img)
else:
# TODO: implement as ring buffer using np.roll()
img = np.insert(i, 0, img, axis=0)
img = img[:self.pBuffer.value()]
w.setImage(img, autoRange=False, autoLevels=False)
else:
w.setImage(img, autoRange=False, autoLevels=False)
def resize_rotate_and_frame():
print "Rotate and Frame Images"
srcpp = "../data/dataset"
dstpp = "../data/framed"
imnames = imt.get_imlist(srcpp, ext = ".png")
s=320
i=0
for imname in imnames:
filename = imname.split('\\')[-1]
## === OPERATORS ===
if 'dept' in imname:
im = cv2.imread(imname, -1)
else:
im = cv2.imread(imname)
b = imt.shrinkIm(im, s)
#rotate the image:
if 'right' in imname:
b = np.fliplr(cv2.transpose(b))
elif 'head' in imname:
b = cv2.flip(b, -1)
#frame the image
a = imt.frameImage(b)
dst = ("/").join([dstpp,filename])
print i, dst, b.shape
i+=1
cv2.imshow('rotated', a)
cv2.waitKey(5)
0, 0, 0,
1, 5, 1] )
kernel2 = array( [ -1, 0, 1,
-5, 0, 5,
-1, 0, 1] )
gray_image = cv2.cvtColor(opencv_image, cv2.COLOR_BGR2GRAY)
filtered_image = cv2.filter2D(gray_image, -1, kernel1)#returns a 2d array
rows,cols = gray_image.shape
#print(gray_image.shape)
#print("==== Horizontal Histogram ====")
horz_hist = calculateHistogram(filtered_image, rows, cols)
horz_hist = removeModeAndLess(horz_hist)
gray_rot_90_image = cv2.transpose(gray_image)
gray_rot_90_image = cv2.flip(gray_rot_90_image, 1)
filtered_rot_90_image = cv2.filter2D(gray_rot_90_image, -1, kernel1)
rows,cols = gray_rot_90_image.shape
vert_hist = calculateHistogram(filtered_rot_90_image, rows, cols)
#vert_hist = removeModeAndLess(vert_hist)
horz_lines = findLines( horz_hist, 50 )
vert_lines = findLines( vert_hist, 50 )
print(horz_lines)
print(vert_lines)
'''
=====================================================================================================================
def main(args):
hp.check_directory_existence(args.out_path, exit_=False, create_=True)
img_filenames = hp.get_all_files_in_dir_path(args.img_path,
extensions=hp.IMG_EXTENSIONS)
img_filenames = sorted(img_filenames)
for img_filename in img_filenames:
img = hp.imread(img_filename)
print(" # {} image file processing...".format(img_filename))
pts1 = mg.define_quadrilateral(img)
if pts1 == -1:
sys.exit(1)
elif pts1 == 0:
continue
pts1 = np.float32(pts1)
h1_len = np.sqrt((pts1[0][0] - pts1[1][0])**2 +
(pts1[0][1] - pts1[1][1])**2)
h2_len = np.sqrt((pts1[2][0] - pts1[3][0])**2 +
(pts1[2][1] - pts1[3][1])**2)
v1_len = np.sqrt((pts1[0][1] - pts1[3][1])**2 +
(pts1[0][1] - pts1[3][1])**2)
v2_len = np.sqrt((pts1[1][1] - pts1[2][1])**2 +
(pts1[1][1] - pts1[2][1])**2)
h_len = int((h1_len + h2_len) / 2)
v_len = int((v1_len + v2_len) / 2)
pts2 = np.float32([[0, 0], [h_len, 0], [0, v_len], [h_len, v_len]])
mtx = cv2.getPerspectiveTransform(pts1, pts2)
warp_img = cv2.warpPerspective(img, mtx, (h_len, v_len))
out_img = np.zeros((v_len + args.boundary_margin * 2,
h_len + args.boundary_margin * 2, 3),
dtype=np.uint8)
out_img[args.boundary_margin:args.boundary_margin + v_len,
args.boundary_margin:args.boundary_margin + h_len] = warp_img
guide_on_ = False
while True:
if not guide_on_:
img_zoom, _ = hp.imresize_full(out_img)
disp_img = cv2.putText(
img_zoom, "Press \'r\', \'f\', \'m\', \'y\', or \'s\'",
(50, 60), CV2_FONT, 1, hp.RED, 4)
cv2.imshow('warping', cv2.cvtColor(disp_img,
cv2.COLOR_RGB2BGR))
in_key = cv2.waitKey(1) & 0xFF
if in_key == ord('y'):
# ans = input(" % Enter the image filename : ")
break
elif in_key == ord('m'):
out_img = cv2.flip(out_img, 1)
guide_on_ = False
elif in_key == ord('f'):
out_img = cv2.flip(out_img, 0)
guide_on_ = False
elif in_key == ord('r'):
out_img = cv2.transpose(out_img)
out_img = cv2.flip(out_img, 0)
guide_on_ = False
elif in_key == ord('s'):
continue
else:
pass
cv2.destroyAllWindows()
for i in range(10):
cv2.waitKey(1)
while True:
core_fname = os.path.splitext(os.path.basename(img_filename))[0]
out_img_fname = os.path.join(args.out_path,
core_fname + "--crop.jpg")
out_json_fname = os.path.join(args.out_path,
core_fname + "--crop.json")
out_info_dict = {
'image_filename': img_filename,
'vertices': pts1.astype(np.int16).tolist(),
}
print(" # Default filename is {}".format(out_img_fname))
ans = input(
" % Enter the image filename (Enter to use the default filename) : "
)
ans = out_img_fname if ans == '' else ans
if ans.split('.')[-1] in hp.IMG_EXTENSIONS:
if os.path.isfile(out_img_fname):
print(" @ Warning: the same filename exists, {}.".format(
out_img_fname))
else:
hp.imwrite(out_img, out_img_fname)
with open(out_json_fname, 'w') as f:
json.dump(out_info_dict, f)
break
else:
print(" @ Error: Image file extension required, {}".format(
ans.split('.')[-1]))
import cv2
import numpy as np
image = cv2.imread('images/input.jpg')
height, width = image.shape[:2]
# Divide by two to rototate the image around its centre
rotation_matrix = cv2.getRotationMatrix2D((width/2, height/2), 90, .5)
rotated_image = cv2.warpAffine(image, rotation_matrix, (width, height))
cv2.imshow('Rotated Image', rotated_image)
cv2.waitKey()
cv2.destroyAllWindows()
#Other Option to Rotate But 90° at a time
img = cv2.imread('images/input.jpg')
rotated_image = cv2.transpose(img)
cv2.imshow('Rotated Image - Method 2', rotated_image)
cv2.waitKey()
cv2.destroyAllWindows()
# Now to a horizontal flip.
flipped = cv2.flip(image, 1)
cv2.imshow('Horizontal Flip', flipped)
cv2.waitKey()
cv2.destroyAllWindows()
# -*- coding: utf-8 -*-
"""
Created on Fri Dec 28 14:01:55 2018
@author: 박진우
"""
import cv2
vidcap = cv2.VideoCapture('./hoi_01.mp4')
success, image = vidcap.read()
count = 0
while success:
# cv2.imwrite("frame%04d.png" % count, image) # save frame as JPEG file
# Image Rotate
image = cv2.transpose(image)
image = cv2.flip(image, 1)
cv2.imwrite('./inputs/' + str(count) + ".jpg",
image) # save frame as JPEG file
success, image = vidcap.read()
print('Read a new frame: ', success)
count += 1
def frm_pretreatment(self, ret, frame, crop, *preParam):
dst = self.pretreatment(frame, *preParam)
cropped = dst[crop[0][0]:crop[0][1], crop[1][0]:crop[1][1]]
transposed = cv2.flip(cv2.transpose(cropped), 0)
return transposed
##Rotation
# [
# [ cos - sin ],
# [ sin0 cos0 ]
# ]
#cv2.getRotationMatrix( rotation_centreX , Rotation_centre_y , angel , scale )
image = cv2.imread('image.jpg')
height, width = image.shape[:2]
R = cv2.getRotationMatrix2D((width / 2, height / 2), 90, 1)
RotatedImage = cv2.warpAffine(image, R, (width, height))
cv2.imshow("Rotated Image", RotatedImage)
cv2.waitKey()
cv2.destroyAllWindows()
## Another Method (short cut)
image = cv2.imread('image.jpg')
RotatedImage = cv2.transpose(image)
cv2.imshow("Transposed Image", RotatedImage)
cv2.waitKey()
cv2.destroyAllWindows()
def unrotate(original, debug=False):
mask = white_paper_mask(original, debug)
#
# scale down so that we can use consistent number of iterations for morphological ops
#
scale = 512 / original.shape[1]
thresh = cv2.resize(mask, (0, 0), fx=scale, fy=scale)
scaled = cv2.resize(original, (0, 0), fx=scale, fy=scale)
num_iter = 1
closed = cv2.dilate(cv2.erode(thresh, None, iterations=num_iter),
None,
iterations=num_iter)
if debug:
cv2.imshow(__file__, closed)
cv2.waitKey()
contours, _ = cv2.findContours(closed, cv.CV_RETR_EXTERNAL,
cv.CV_CHAIN_APPROX_SIMPLE)
if debug:
cv2.drawContours(scaled, contours, -1, (255, 0, 0))
cv2.imshow(__file__, scaled)
cv2.waitKey()
#
# Pick the quad with the largest area
#
quads = []
for contour in contours:
#
# TODO: check if the contour is rectangular enough
#
area = cv2.contourArea(contour)
#
# TODO: How to decide this threshold?
# TODO: order the vertices in the decided polygon in some predictable way
#
poly = cv2.approxPolyDP(contour, 50, True)
if len(poly) == 4:
quads.append((area, poly))
assert quads
#
# Pick the largest quad, by area
#
quad = sorted(quads, reverse=True)[0][1]
a_x = quad[0][0][0]
a_y = quad[0][0][1]
b_x = quad[1][0][0]
b_y = quad[1][0][1]
d_x = quad[2][0][0]
d_y = quad[2][0][1]
e_x = quad[3][0][0]
e_y = quad[3][0][1]
width = math.sqrt((a_x - b_x)**2 + (a_y - b_y)**2)
height = math.sqrt((b_x - d_x)**2 + (b_y - d_y)**2)
if debug:
cv2.circle(scaled, (int(a_x), int(a_y)), 5, (255, 0, 0), -1) # blue
cv2.putText(scaled, "A", (int(a_x), int(a_y)),
cv.CV_FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0))
cv2.circle(scaled, (int(b_x), int(b_y)), 5, (0, 255, 0), -1) # green
cv2.putText(scaled, "B", (int(b_x), int(b_y)),
cv.CV_FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0))
cv2.circle(scaled, (int(d_x), int(d_y)), 5, (0, 0, 255), -1) # red
cv2.putText(scaled, "D", (int(d_x), int(d_y)),
cv.CV_FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255))
cv2.circle(scaled, (int(e_x), int(e_y)), 5, (255, 255, 0), -1) # cyan
cv2.putText(scaled, "E", (int(e_x), int(e_y)),
cv.CV_FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0))
cv2.imshow(__file__, scaled)
cv2.waitKey()
#
# Scale up to the original image and calculate a perspective transform
#
A_x, A_y, B_x, B_y, D_x, D_y, E_x, E_y = map(
lambda x: x / scale, [a_x, a_y, b_x, b_y, d_x, d_y, e_x, e_y])
Width, Height = width / scale, height / scale
src = np.array([(A_x, A_y), (B_x, B_y), (D_x, D_y), (E_x, E_y)],
dtype="float32")
dst = np.array([(Width, 0), (0, 0), (0, Height), (Width, Height)],
dtype="float32")
perspective = cv2.getPerspectiveTransform(src, dst)
warped = cv2.warpPerspective(original, perspective, (0, 0))
warped = warped[:Height, :Width]
if width > height:
warped = cv2.flip(cv2.transpose(warped), 1)
return warped
def callback(msg_1, msg_2):
global i
global j
global outlist
j = j + 1
if j == 1:
i = i + 1
# resize and crop image for msg_1(left side)
cv2_msg_img = bridge.imgmsg_to_cv2(msg_1)
cv_imgc = bridge.cv2_to_imgmsg(cv2_msg_img, 'rgb8')
pil_img = encode(cv_imgc)
fg_img = PILImage.new('RGBA', pil_img.size, (0, 0, 0, 255))
draw = ImageDraw.Draw(fg_img)
draw.ellipse(XYc, fill=(0, 0, 0, 0)) # 中心を抜く
pil_img.paste(fg_img, (0, 0), fg_img.split()[3])
img_msg = decode(pil_img)
cv2_imgd = bridge.imgmsg_to_cv2(img_msg, 'rgb8')
cv_cutimg = cv2_imgd[yc - xyoffset:yc + xyoffset,
xc - xyoffset:xc + xyoffset]
cv_cutimg = cv2.transpose(cv_cutimg)
cv_cutimg = cv2.flip(cv_cutimg, 1)
#
cv_resize1 = cv2.resize(cv_cutimg, (rsizex, rsizey))
cv_resizex = cv_resize1.transpose(2, 0, 1)
in_imgcc1 = np.array([cv_resizex], dtype=np.float32)
in_img1 = (in_imgcc1 - 128) / 128
#
# resize and crop image for msg_2(right side)
cv2_msg_img = bridge.imgmsg_to_cv2(msg_2)
cv_imgc = bridge.cv2_to_imgmsg(cv2_msg_img, 'rgb8')
pil_img = encode(cv_imgc)
fg_img = PILImage.new('RGBA', pil_img.size, (0, 0, 0, 255))
draw = ImageDraw.Draw(fg_img)
draw.ellipse(XYc, fill=(0, 0, 0, 0)) # 中心を抜く
pil_img.paste(fg_img, (0, 0), fg_img.split()[3])
img_msg = decode(pil_img)
cv2_imgd = bridge.imgmsg_to_cv2(img_msg, 'rgb8')
cv_cutimg = cv2_imgd[yc - xyoffset:yc + xyoffset,
xc - xyoffset:xc + xyoffset]
cv_cutimg = cv2.transpose(cv_cutimg)
cv_cutimg = cv2.flip(cv_cutimg, 1)
#
cv_resize2 = cv2.resize(cv_cutimg, (rsizex, rsizey))
cv_resizex = cv_resize2.transpose(2, 0, 1)
in_imgcc2 = np.array([cv_resizex], dtype=np.float32)
in_img2 = (in_imgcc2 - 128) / 128
#concatenated image by left(in_img1) and right(in_img2)
in_img = np.concatenate((in_img1, in_img2), axis=1)
in_imgg = cuda.to_gpu(in_img) # to gpu
img_real = Variable(in_imgg)
#
with chainer.using_config('train', False), chainer.no_backprop_mode():
img_gen = gen(invg(img_real))
dis_real = dis(img_real)
dis_gen = dis(img_gen)
output = fl(img_real - img_gen, dis_real - dis_gen,
dis_real) #traversable probablity
out_gonogoc = cuda.to_cpu(output.data) # to cpu
gonet_out.publish(out_gonogoc) #publish
j = 0
cv.imshow("Blue",cv.merge([B,zeros,zeros]))
t_img = cv.merge([B,zeros,zeros])
elif choice=='9':
#Green mask
B,G,R=cv.split(img)
zeros = np.zeros((height,width),dtype="uint8")
cv.imshow("Blue",cv.merge([zeros,G,zeros]))
t_img = cv.merge([zeros,G,zeros])
elif choice=='10':
#Red mask
B,G,R=cv.split(img)
zeros = np.zeros((height,width),dtype="uint8")
cv.imshow("Blue",cv.merge([zeros,zeros,R]))
t_img = cv.merge([zeros,zeros,R])
elif choice=='11':
t_img = cv.transpose(img)
cv.imshow("Transformed Image",t_img)
elif choice=='12':
face_cascade=cv.CascadeClassifier("haarcascade_frontalface_alt.xml")
gray_img=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
faces=face_cascade.detectMultiScale(gray_img,scaleFactor=1.06,minNeighbors=6)
for x,y,w,h in faces:
img1=cv.rectangle(img,(x,y),(x+w,y+h),(0,0,255),3)
cv2.imshow("Gray",img1)
elif choice=='13':
cv.destroyAllWindows()
new_image = np.zeros(img.shape, img.dtype)
#g(x) = alpha*f(x) + beta
alpha = float(input('Enter alpha value [1.0-3.0]:\n'))
beta = int(input('Enter beta value [0-100]:\n'))
print('This may take a while....')
import cv2
import numpy as np
img = cv2.imread('..\\MasterOpenCV\\images\\IMG_7539.jpg')
image = cv2.resize(img, (960, 540))
height, width = image.shape[:2]
rotation_matrix = cv2.getRotationMatrix2D((width / 2, height / 2), 90, .5)
rotation_img = cv2.warpAffine(image, rotation_matrix, (width, height))
cv2.imshow("roatation image", rotation_img)
cv2.waitKey()
cv2.destroyAllWindows()
#alternate way
rotation_image = cv2.transpose(image)
cv2.imshow("alt rotation image", rotation_image)
cv2.waitKey()
cv2.destroyAllWindows()
def preprocess(files):
for path in files:
filename, file_extension = os.path.splitext(path)
print('file:', filename, file_extension)
img = cv2.imread(path)
height, width, channels = img.shape
img_t = np.zeros((width, height, channels), img.dtype)
cv2.transpose(img, img_t)
cv2.flip(img_t, 1, img_t)
img_gray = cv2.cvtColor(img_t, cv2.COLOR_BGR2GRAY)
min_sum = sys.maxint
opt_angle = 0
angle = -1.5
while angle < 1.6:
rot_m = cv2.getRotationMatrix2D((width / 2, height / 2), angle, 1)
img_gray_r = cv2.warpAffine(img_gray,
rot_m, (height, width),
borderMode=cv2.BORDER_CONSTANT,
borderValue=white_color)
sum = img_gray_r.sum(axis=1).min()
if sum < min_sum:
min_sum = sum
opt_angle = angle
angle += 0.1
print('opt_angle:', opt_angle)
rot_m = cv2.getRotationMatrix2D((width / 2, height / 2), opt_angle, 1)
img_r = cv2.warpAffine(img_t,
rot_m, (height, width),
borderMode=cv2.BORDER_CONSTANT,
borderValue=white_color)
img_gray = cv2.cvtColor(img_r, cv2.COLOR_BGR2GRAY)
# score_x = img_gray[0:width, 0:600].sum(axis=0).argmin() + score_x_shift
x_sums = img_gray.sum(axis=0)
sum_threshold = x_sums.mean() - 3 * x_sums.std()
score_x = score_x_shift + min_score_x
for x_sum in x_sums[min_score_x:]:
if x_sum < sum_threshold:
break
score_x += 1
print('score_x:', score_x)
if filename.split('/')[-1] == 'page-000':
label_width = label_first_width
else:
label_width = label_other_width
label_left_x = max(0, score_x - label_width)
cv2.imwrite('%s.png' % filename, img_r)
img_instr = cv2.copyMakeBorder(img_r[0:width, label_left_x:score_x],
0,
0,
label_left_x,
300,
borderType=cv2.BORDER_CONSTANT,
value=white_color)
cv2.imwrite('%s-instr.png' % filename, img_instr)
def RotateClockWise90(img):
trans_img = cv2.transpose( img )
new_img = cv2.flip(trans_img, 1)
return new_img
from dvs_msgs.msg import Event
from dvs_msgs.msg import EventArray
import cv2
import numpy as np
from sensor_msgs.msg import Image
from cv_bridge import CvBridge, CvBridgeError
import rosbag
import os
import time
rospy.init_node('dvsmsg')
t = rospy.Time.from_sec(1468939993.11)
bag = rosbag.Bag('/home/ubuntu/Documents/VINS/data/shapes_6dof_new2.bag', 'w')
num = 1
bridge = CvBridge()
for i in range(900):
path = '/home/ubuntu/Downloads/image900/%d.bmp' % (i + 1)
frame = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
img90 = cv2.transpose(frame)
# cv2.imshow('s',frame)
# cv2.waitKey(100)
msg = bridge.cv2_to_imgmsg(img90, encoding="mono8")
msgtime = t + rospy.Duration.from_sec(0.03 * (i + 1))
msg.header.stamp = msgtime
msg.header.seq = i
msg.header.frame_id = 'world'
print msgtime.to_sec()
bag.write("/dvs/image_new", msg, msg.header.stamp)
d2[i] = aux[0]
coluna = linha
for i in linha:
for j in coluna:
if i == j:
D[i][j] = d2[i]
T = D
#print 'T'
#print T
######################### Fazendo o hotf ###########3##############
T1 = numpy.linalg.inv(T)
print 1
Xt = cv2.transpose(matX)
print 2
ele = numpy.dot(Xt, T1)
print 3
paren = numpy.dot(ele, matX)
print 4
paren = numpy.linalg.inv(paren)
print 5
paren = numpy.dot(matX, paren)
print 6
hotf = numpy.dot(T1, paren)
print 7
hotf = numpy.dot(hotf, matC)
arq = open('hotf.txt', 'w')
linha = range(0, imgj, 1)
def outerRectangle(image):
height, width, channels = image.shape
if width > height:
image = cv2.transpose(image)
image = cv2.flip(image, 1)
# resize image so it can be processed
image = cv2.resize(image, (1600, 1200))
# creating copy of original image
orig = image.copy()
# convert to grayscale and blur to smooth
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
#blurred = cv2.medianBlur(gray, 5)
edged = cv2.Canny(blurred, 0, 50)
orig_edged = edged.copy()
# find the contours in the edged image, keeping only the
# largest ones, and initialize the screen contour
(_, contours, _) = cv2.findContours(edged, cv2.RETR_LIST,
cv2.CHAIN_APPROX_NONE)
contours = sorted(contours, key=cv2.contourArea, reverse=True)
# get approximate contour
for c in contours:
p = cv2.arcLength(c, True)
approx = cv2.approxPolyDP(c, 0.02 * p, True)
if len(approx) == 4:
target = approx
break
# mapping target points to 800x800 quadrilateral
approx = rectify(target)
(tl, tr, br, bl) = approx
# compute the width of the new image, which will be the
# maximum distance between bottom-right and bottom-left
# x-coordiates or the top-right and top-left x-coordinates
widthA = np.sqrt(((br[0] - bl[0])**2) + ((br[1] - bl[1])**2))
widthB = np.sqrt(((tr[0] - tl[0])**2) + ((tr[1] - tl[1])**2))
maxWidth = max(int(widthA), int(widthB))
# compute the height of the new image, which will be the
# maximum distance between the top-right and bottom-right
# y-coordinates or the top-left and bottom-left y-coordinates
heightA = np.sqrt(((tr[0] - br[0])**2) + ((tr[1] - br[1])**2))
heightB = np.sqrt(((tl[0] - bl[0])**2) + ((tl[1] - bl[1])**2))
maxHeight = max(int(heightA), int(heightB))
# now that we have the dimensions of the new image, construct
# the set of destination points to obtain a "birds eye view",
# (i.e. top-down view) of the image, again specifying points
# in the top-left, top-right, bottom-right, and bottom-left
# order
dst = np.array([[0, 0], [maxWidth - 1, 0], [maxWidth - 1, maxHeight - 1],
[0, maxHeight - 1]],
dtype="float32")
pts2 = np.float32([[0, 0], [800, 0], [800, 800], [0, 800]])
M = cv2.getPerspectiveTransform(approx, pts2)
dst = cv2.warpPerspective(orig, M, (800, 800))
mask = np.ones(orig.shape, np.uint8)
mask = cv2.bitwise_not(mask)
x_offset = y_offset = 50
mask[y_offset:y_offset + dst.shape[0],
x_offset:x_offset + dst.shape[1]] = dst
return mask
import numpy as np
import cv2
input_image = cv2.imread("./images/Trump.jpg")
width, height = input_image.shape[:2]
cv2.imshow("Trump", input_image)
cv2.waitKey()
cv2.destroyAllWindows()
rotation_matrix = cv2.getRotationMatrix2D((width/2, height/2), 90, 1)
rotated_image = cv2.warpAffine(input_image, rotation_matrix, (width, height))
cv2.imshow("Rotated Trump", rotated_image)
cv2.waitKey()
cv2.destroyAllWindows()
transposed_rotation = cv2.transpose(input_image)
cv2.imshow("Transposed Rotation ",transposed_rotation)
cv2.waitKey()
cv2.destroyAllWindows()
print("Usage: python3 video_feed.py phone_ip_addr [record]")
record_bool = sys.argv[2] if len(sys.argv) > 2 else False
FPS = cap.get(5) #ipcamera app locks this at 25
resolution = (int(cap.get(4)), int(cap.get(3))) #vert to horiz res
print("FPS", FPS)
print("resolution", resolution)
if record_bool:
fourcc = cv2.VideoWriter_fourcc(*"MJPG")
out = cv2.VideoWriter("./assets/output.avi", fourcc, FPS, resolution)
while cap.isOpened(): #Joshua's doc says while True but I think that's a typo
ret, frame = cap.read()
frame = cv2.flip(cv2.transpose(frame), 0)
if ret:
cv2.imshow("Feed", frame)
if record_bool:
out.write(frame)
key = cv2.waitKey(1) & 0xFF
if key == ord(" "): #save frame on spacebar
img_file = "./assets/" + str(time.time()) + ".jpg"
cv2.imwrite(img_file, frame)
print(img_file, "saved")
elif key == 27: #esc
break
else:
break
cap.release()
def update(self, frame):
self.frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
self.frame = cv2.transpose(self.frame)
def default_loop(self, usage):
# 프레임 읽어들여서 왼쪽만 HSV 색공간으로 변환하기
left_frame = self.frm_pretreatment(*self.video_left.read(),
*LaneCam.xreadParam_L)
right_frame = self.frm_pretreatment(*self.video_right.read(),
*LaneCam.xreadParam_R)
left_hsv = cv2.cvtColor(left_frame, cv2.COLOR_BGR2HSV)
# HSV, RGB 필터링으로 영상을 이진화 함
filtered_L = cv2.inRange(left_hsv, self.lower_yellow,
self.upper_yellow)
filtered_R = cv2.inRange(right_frame, self.lower_white,
self.upper_white)
# 좌, 우 영상을 붙임. 모니터링을 위한 부분.
both = np.vstack((right_frame, left_frame))
both_final = cv2.flip(cv2.transpose(both), 1)
self.lane_cam_raw_frame.write(both_final)
# ---------------------------------- 여기부터 왼쪽 차선 박스 쌓기 영역 ----------------------------------
if self.left_previous_points is None:
row_sum = np.sum(filtered_L[0:300, 200:300], axis=1)
start_point = np.argmax(row_sum)
# 차선의 실마리를 찾을 때, 길이가 7650 / 255 = 30픽셀 이상 될때만 차선으로 인정하고, 그렇지 않을 경우
# 차선이 없는 것으로 간주함
if (row_sum[start_point] > 7650):
self.left_current_points = np.array([0] * 10)
self.left_current_points[0] = start_point
for i in range(1, 10):
reference = self.left_current_points[i -
1] - self.BOX_WIDTH
x1, x2 = 300 - 30 * i, 330 - 30 * i
y1 = self.left_current_points[i - 1] - self.BOX_WIDTH
y2 = self.left_current_points[i - 1] + self.BOX_WIDTH
small_box = filtered_L[y1:y2, x1:x2]
center_of_mass = self.findCenterofMass(small_box)
# 박스가 비어 있는 경우 -1을 저장
if center_of_mass == -1:
self.left_current_points[i] = -1
else:
location = reference + center_of_mass
# 질량중심 결과가 전체 영상을 벗어나지 않았을 때만 저장하고
if 0 <= location < 300:
self.left_current_points[i] = location
# 벗어나면 -1을 저장함
else:
self.left_current_points[i] = -1
else:
self.left_current_points = None
else:
for i in range(0, 10):
if self.left_current_points[i] != -1:
reference = self.left_previous_points[i] - self.BOX_WIDTH
x1, x2 = 270 - 30 * i, 300 - 30 * i
y1 = self.left_previous_points[i] - self.BOX_WIDTH
y2 = self.left_previous_points[i] + self.BOX_WIDTH
small_box = filtered_L[y1:y2, x1:x2]
center_of_mass = self.findCenterofMass(small_box)
if center_of_mass == -1:
self.left_current_points[i] = -1
else:
location = reference + center_of_mass
if 0 <= location < 300:
self.left_current_points[i] = location
else:
self.left_current_points[i] = -1
else:
if i == 0:
reference = self.left_previous_points[
1] - self.BOX_WIDTH
x1, x2 = 270, 300
y1 = self.left_previous_points[1] - self.BOX_WIDTH
y2 = self.left_previous_points[1] + self.BOX_WIDTH
small_box = filtered_L[y1:y2, x1:x2]
center_of_mass = self.findCenterofMass(small_box)
if center_of_mass == -1:
self.left_current_points[0] = -1
else:
location = reference + center_of_mass
if 0 <= location < 300:
self.left_current_points[0] = location
else:
self.left_current_points[0] = -1
else:
reference = self.left_previous_points[
i - 1] - self.BOX_WIDTH
x1, x2 = 270 - 30 * i, 300 - 30 * i
y1 = self.left_previous_points[i - 1] - self.BOX_WIDTH
y2 = self.left_previous_points[i - 1] + self.BOX_WIDTH
small_box = filtered_L[y1:y2, x1:x2]
center_of_mass = self.findCenterofMass(small_box)
if center_of_mass == -1:
self.left_current_points[i] = -1
else:
location = reference + center_of_mass
if 0 <= location < 300:
self.left_current_points[i] = location
else:
self.left_current_points[i] = -1
if np.count_nonzero(
self.left_current_points == -1) >= 5 and usage == 0:
self.left_current_points = None
if np.count_nonzero(
self.left_current_points == -1) >= 9 and usage == 1:
self.left_current_points = None
self.left_previous_points = self.left_current_points
# ---------------------------------- 여기까지 왼쪽 차선 박스 쌓기 영역 ----------------------------------
# ---------------------------------- 여기부터 오른쪽 차선 박스 쌓기 영역 ----------------------------------
if self.right_previous_points is None:
row_sum = np.sum(filtered_R[0:300, 200:300], axis=1)
start_point = np.argmax(row_sum)
# 차선의 실마리를 찾을 때, 길이가 7650 / 255 = 30픽셀 이상 될때만 차선으로 인정하고, 그렇지 않을 경우
# 차선이 없는 것으로 간주함
if (row_sum[start_point] > 7650):
self.right_current_points = np.array([0] * 10)
self.right_current_points[0] = start_point
for i in range(1, 10):
reference = self.right_current_points[i -
1] - self.BOX_WIDTH
x1, x2 = 300 - 30 * i, 330 - 30 * i
y1 = self.right_current_points[i - 1] - self.BOX_WIDTH
y2 = self.right_current_points[i - 1] + self.BOX_WIDTH
small_box = filtered_R[y1:y2, x1:x2]
center_of_mass = self.findCenterofMass(small_box)
# 박스가 비어 있는 경우 -1을 저장
if center_of_mass == -1:
self.right_current_points[i] = -1
else:
location = reference + center_of_mass
# 질량중심 결과가 전체 영상을 벗어나지 않았을 때만 저장하고
if 0 <= location < 300:
self.right_current_points[i] = location
# 벗어나면 -1을 저장함
else:
self.right_current_points[i] = -1
else:
self.right_current_points = None
else:
for i in range(0, 10):
if self.right_current_points[i] != -1:
reference = self.right_previous_points[i] - self.BOX_WIDTH
x1, x2 = 270 - 30 * i, 300 - 30 * i
y1 = self.right_previous_points[i] - self.BOX_WIDTH
y2 = self.right_previous_points[i] + self.BOX_WIDTH
small_box = filtered_R[y1:y2, x1:x2]
center_of_mass = self.findCenterofMass(small_box)
if center_of_mass == -1:
self.right_current_points[i] = -1
else:
location = reference + center_of_mass
if 0 <= location < 300:
self.right_current_points[i] = location
else:
self.right_current_points[i] = -1
else:
if i == 0:
reference = self.right_previous_points[
1] - self.BOX_WIDTH
x1, x2 = 270, 300
y1 = self.right_previous_points[1] - self.BOX_WIDTH
y2 = self.right_previous_points[1] + self.BOX_WIDTH
small_box = filtered_L[y1:y2, x1:x2]
center_of_mass = self.findCenterofMass(small_box)
if center_of_mass == -1:
self.right_current_points[0] = -1
else:
location = reference + center_of_mass
if 0 <= location < 300:
self.right_current_points[0] = location
else:
self.right_current_points[0] = -1
else:
reference = self.right_previous_points[
i - 1] - self.BOX_WIDTH
x1, x2 = 270 - 30 * i, 300 - 30 * i
y1 = self.right_previous_points[i - 1] - self.BOX_WIDTH
y2 = self.right_previous_points[i - 1] + self.BOX_WIDTH
small_box = filtered_R[y1:y2, x1:x2]
center_of_mass = self.findCenterofMass(small_box)
if center_of_mass == -1:
self.right_current_points[i] = -1
else:
location = reference + center_of_mass
if 0 <= location < 300:
self.right_current_points[i] = location
else:
self.right_current_points[i] = -1
if np.count_nonzero(
self.right_current_points == -1) >= 5 and usage == 0:
self.right_current_points = None
if np.count_nonzero(
self.right_current_points == -1) >= 9 and usage == 1:
self.right_current_points = None
self.right_previous_points = self.right_current_points
# ---------------------------------- 여기까지 오른쪽 차선 박스 쌓기 영역 ----------------------------------
if usage == 0:
if self.left_current_points is not None:
xs_valid = []
ys_L_valid = []
for i in range(0, 10):
temp = self.left_current_points[i]
if temp != -1:
xs_valid.append(-30 * i)
ys_L_valid.append(-1 * temp)
cv2.line(filtered_L,
(300 - 30 * i, temp - self.BOX_WIDTH),
(300 - 30 * i, temp + self.BOX_WIDTH), 150)
self.left_coefficients = np.polyfit(xs_valid, ys_L_valid, 2)
xs_plot = np.array([1 * i for i in range(-299, 1)])
ys_plot_L = np.array([
self.left_coefficients[2] + self.left_coefficients[1] * v +
self.left_coefficients[0] * v**2 for v in xs_plot
])
transformed_x = xs_plot + 299
transformed_y_L = 0 - ys_plot_L
for i in range(0, 300):
cv2.circle(
filtered_L,
(int(transformed_x[i]), int(transformed_y_L[i])), 2,
150, -1)
else:
self.left_coefficients = None
if self.right_current_points is not None:
xs_valid = []
ys_R_valid = []
for i in range(0, 10):
temp = self.right_current_points[i]
if temp != -1:
xs_valid.append(-30 * i)
ys_R_valid.append(300 - temp)
cv2.line(filtered_R,
(300 - 30 * i, temp - self.BOX_WIDTH),
(300 - 30 * i, temp + self.BOX_WIDTH), 150)
self.right_coefficients = np.polyfit(xs_valid, ys_R_valid, 2)
xs_plot = np.array([1 * i for i in range(-299, 1)])
ys_plot_R = np.array([
self.right_coefficients[2] +
self.right_coefficients[1] * v +
self.right_coefficients[0] * v**2 for v in xs_plot
])
transformed_x = xs_plot + 299
transformed_y_R = 299 - ys_plot_R
for i in range(0, 300):
cv2.circle(
filtered_R,
(int(transformed_x[i]), int(transformed_y_R[i])), 2,
150, -1)
else:
self.right_coefficients = None
filtered_both = np.vstack((filtered_R, filtered_L))
final = cv2.flip(cv2.transpose(filtered_both), 1)
self.lane_cam_frame.write(final)
image_copy[50:150, 675:775] = image_rotated plt.imshow(image_copy) plt.show() # %% #' Tu sais, avec cv2, retourner verticalement, horizontalement et transposer l'image. vertically_flipped_image = cv2.flip(image_copy, 0) plt.imshow(vertically_flipped_image) plt.show() horizontally_flipped_image = cv2.flip(image_copy, 1) plt.imshow(horizontally_flipped_image) plt.show() transposed_image = cv2.transpose(image_copy) plt.imshow(transposed_image) plt.show() # %% #' ### Appliquer des filtres #' #' Je sais appliquer un filtre gaussien (de taille 11) à l'image. image_smoothed = cv2.GaussianBlur(image_copy, (11, 11), 1) plt.imshow(image_smoothed) plt.show() # %% #' #### Tu sais appliquer n'importe quel filtre à une image #'
# 1D ->>>> 2D
H2D = np.zeros((size_rows, size_cols, 2))
rows = 0
for j in xrange(0, size_cols):
for i in xrange(0, size_rows):
H2D[i, j, 0] = Hotf[rows, 0, 0]
H2D[i, j, 1] = Hotf[rows, 0, 1]
rows = rows + 1
# Filtragem
H2DTr = np.zeros((size_cols, size_rows, 2))
H2DTr[:, :, 0] = cv2.transpose(H2D[:, :, 0])
H2DTr[:, :, 1] = cv2.transpose(H2D[:, :, 1])
ImgFilt = cv2.gemm(H2DTr, ImgDFT, 1, 0, 0)
# ImgFilt = cv2.gemm(Hotf, ImgDFT, 1, 0, 0)
cv2.dft(ImgFilt, ImgFiltIDFT, cv2.DFT_INVERSE) # ?
#print('{}, c: {} '.format(name, ImgFilt[0, 0, 0]))
# Plot3D
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x = np.arange(0, 80, 1)
import numpy as np
from column_names import data
testData = pd.read_csv('../datasets/emnist-balanced-test.csv', names=data)
x_test = testData.loc[:, testData.columns != 'label']
y_test = testData['label']
x_test = x_test.to_numpy()
y_test = y_test.to_numpy()
temp = np.reshape(x_test[1], (28, 28))
temp = np.uint8(temp)
print(temp.shape)
print(temp)
cv2.imshow('image', temp)
cv2.waitKey(2000)
temp = cv2.transpose(temp)
cv2.imshow('image', temp)
cv2.waitKey(2000)
temp = cv2.transpose(temp)
cv2.imshow('image', temp)
cv2.waitKey(2000)
x_test = np.reshape(x_test, (-1, 28, 28, 1))
model = tf.keras.models.load_model("logs/modelsBalancedFinal/model1.hdf5")
for i in range(len(x_test)):
y = model.predict_classes(np.reshape(x_test[i], (-1, 28, 28, 1)))
print("Predicted: {} Actual: {}".format(y, y_test[i]))
if i == 1:
break
def TestFlappyBird(video_record = True):
# Test AI for the Flappy Bird game
# Initialize Flappy Bird game
flappybird = game.GameState()
# Load AI for the game
num_actions = 2
AI_player = DQN_AI(num_actions = num_actions, mode = 'test')
AI_player.Load_Model()
# AI starts to play the game
# Initialize the first state of AI with the first observation from the game
action = np.array([1,0]) # idle
observation, reward, terminal = flappybird.frame_step(action)
# Initialize video result log
image_index = 0
if video_record == True:
if not os.path.exists(TEST_DIR + 'video/'):
os.makedirs(TEST_DIR + 'video/')
Clear_PNGs(folder_path = TEST_DIR + 'video/')
cv2.imwrite(TEST_DIR + 'video/' + str(image_index) + '.png', cv2.cvtColor(cv2.transpose(observation), cv2.COLOR_BGR2RGB))
if not os.path.exists(TEST_DIR + 'video_best/'):
os.makedirs(TEST_DIR + 'video_best/')
Clear_PNGs(folder_path = TEST_DIR + 'video_best/')
observation = Preprocess(observation)
AI_player.Current_State_Initialze(observation = observation)
# Record score of each test
test_round = 0
score = 0
score_highest = 0
reward = 0
terminal = False
# Initialize test result log
if not os.path.exists(TEST_DIR):
os.makedirs(TEST_DIR)
fhand = open(TEST_DIR + 'test_log.txt', 'w')
fhand.write('TEST_ROUND\tSCORE')
fhand.write('\n')
fhand.close()
# AI starts playing
while True:
# Keep playing until hitting 'ctrl + c'
# print('time step: %d' % AI_player.time_step)
if reward == 1:
score += 1
if terminal == True:
# Save test result log
print('test round: %d, score: %d' % (test_round, score))
fhand = open(TEST_DIR + 'test_log.txt', 'a')
fhand.write(str(test_round) + '\t' + str(score))
fhand.write('\n')
fhand.close()
# Check if this round of test is best
if video_record == True:
if score > score_highest:
score_highest = score
# Clear video_best folder
Clear_PNGs(folder_path = TEST_DIR + 'video_best/')
# Copy all the images in the video folder to video_best folder
Copy_PNGs(source_path = TEST_DIR + 'video/', destination_path = TEST_DIR + 'video_best/')
# Clear video folder
Clear_PNGs(folder_path = TEST_DIR + 'video/')
# Reset score
score = 0
# Reset image index
image_index = 0
# Increase test_round value
test_round += 1
action = AI_player.AI_Action()
next_observation, reward, terminal = flappybird.frame_step(action)
# Save animated images
if video_record == True:
cv2.imwrite(TEST_DIR + 'video/' + str(image_index) + '.png', cv2.cvtColor(cv2.transpose(next_observation), cv2.COLOR_BGR2RGB))
image_index += 1
next_observation = Preprocess(next_observation)
AI_player.Current_State_Update(observation = next_observation)
def process(self, inframe, outframe):
# Get the next camera image (may block until it is captured) and here convert it to OpenCV BGR. If you need a
# grayscale image, just use getCvGRAY() instead of getCvBGR(). Also supported are getCvRGB() and getCvRGBA():
# self.currentloopcount=self.currentloopcount+1
# if self.currentloopcount==self.maxloopcount:
# self.currentimagecount=self.currentimagecount+1
# self.currentloopcount=0
# if self.currentimagecount>self.maximagecount:
# self.currentimagecount=self.minimagecount
# self.currentimagecount=242
imagefilename="practice"+str(self.currentimagecount)+".png"
# inimg = cv2.imread(imagefilename+)
inimg=cv2.imread("practice45719.png")
#
# inimg=inframe.getCvBGR()
self.currentimagecount+=1
# cv2.imwrite(imagefilename,inimg)
inimg=cv2.transpose(inimg)
inimg=cv2.flip(inimg, 1)
# Start measuring image processing time (NOTE: does not account for input conversion time):
self.timer.start()
lowColor=np.array([53,20,211])
highColor=np.array([86,255,255])
imghls = cv2.cvtColor(inimg, cv2.COLOR_BGR2HLS)
mask=cv2.inRange(imghls,lowColor,highColor)
contours, hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
#now filter the contours
biggestIndex=-1;
secondIndex=-1;
biggestSize=0;
secondSize=0;
index=0
backtorgb=cv2.cvtColor(mask,cv2.COLOR_GRAY2BGR)
if len(contours)>0:
for c in contours:
if cv2.contourArea(c)>biggestSize:
secondSize=biggestSize
secondIndex=biggestIndex
biggestSize=cv2.contourArea(c)
biggestIndex=index
# cv2.putText(backtorgb, str(cv2.contourArea(c)),(3, 233), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
elif cv2.contourArea(c)>secondSize:
secondSize=cv2.contourArea(c)
secondIndex=index
index=index+1
if biggestIndex>-1:
cv2.drawContours(backtorgb, contours, biggestIndex, (0,255,0), 1)
brect1=cv2.minAreaRect(contours[biggestIndex])
brectPoints=cv2.boxPoints(brect1)
brectPoints=np.int0(brectPoints)
cv2.drawContours(backtorgb,[brectPoints],0,(0,0,255),1)
boxText="("+str(brectPoints[0][0])+","+str(brectPoints[0][1])+")"+"("+str(brectPoints[1][0])+","+str(brectPoints[1][1])+")""("+str(brectPoints[2][0])+","+str(brectPoints[2][1])+")""("+str(brectPoints[3][0])+","+str(brectPoints[3][1])+")"
#cv2.putText(backtorgb, boxText,(3, 233), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
if self.written==False:
self.datafile.write(boxText)
self.datafile.write("\n")
if secondIndex>-1:
cv2.drawContours(backtorgb, contours, secondIndex, (0,255,0), 1)
brect2=cv2.minAreaRect(contours[secondIndex])
brectPoints2=cv2.boxPoints(brect2)
brectPoints2=np.int0(brectPoints2)
boxText="("+str(brectPoints2[0][0])+","+str(brectPoints2[0][1])+")"+"("+str(brectPoints2[1][0])+","+str(brectPoints2[1][1])+")""("+str(brectPoints2[2][0])+","+str(brectPoints2[2][1])+")""("+str(brectPoints2[3][0])+","+str(brectPoints2[3][1])+")"
cv2.putText(backtorgb, boxText,(3, 233), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
cv2.drawContours(backtorgb,[brectPoints2],0,(0,0,255),1)
if self.written==False:
self.datafile.write(boxText)
self.datafile.write("\n")
#if you are here, there must be two contours. Find the appropriate
#corners
topmost=321 #there ought to be an easier way, but......
secondmost=321
toppointindex=-1
secondpointindex=-1
for index in range(0,4):
if brectPoints[index][1]<topmost:
secondpointindex=toppointindex
toppointindex=index
secondmost=topmost
topmost=brectPoints[index][1]
if self.written==False:
self.datafile.write("Topmost index is now "+str(index)+"\n")
elif brectPoints[index][1]<secondmost:
secondpointindex=index
secondmost=brectPoints[index][1]
if self.written==False:
self.datafile.write("Secondmost index is now "+str(index)+"\n")
topcorner1=brectPoints[toppointindex]
secondcorner1=brectPoints[secondpointindex]
topmost=321 #there ought to be an easier way, but......
secondmost=321
toppointindex=-1
secondpointindex=-1
if self.written==False:
self.datafile.write("Next set of points \n")
for index in range(0,4):
if self.written==False:
self.datafile.write(str(topmost)+" "+str(secondmost)+" "+str(brectPoints2[index][1])+"\n")
if brectPoints2[index][1]<topmost:
secondpointindex=toppointindex
toppointindex=index
secondmost=topmost
topmost=brectPoints2[index][1]
if self.written==False:
self.datafile.write("Topmost index is now "+str(index)+"\n")
elif brectPoints2[index][1]<secondmost:
secondpointindex=index
secondmost=brectPoints2[index][1]
if self.written==False:
self.datafile.write("Secondmost index is now "+str(index)+"\n")
topcorner2=brectPoints2[toppointindex]
secondcorner2=brectPoints2[secondpointindex]
#Almost there - set up the arrays of object and image points
#cv2.putText(backtorgb, str(topcorner2[0])+" "+str(topcorner2[1]),(3, 45), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
objpoints=np.array(((-5.94,0.5,0),(-4,0,0),(4,0,0),(5.94,0.5,0)),dtype=np.float)
x1=topcorner1[0]
x2=topcorner2[0]
if x1<x2:
imagepoints=np.array([[topcorner1[0],topcorner1[1]],[secondcorner1[0],secondcorner1[1]],[secondcorner2[0],secondcorner2[1]],[topcorner2[0],topcorner2[1]]],dtype=np.float)
else:
imagepoints=np.array([[topcorner2[0],topcorner2[1]],[secondcorner2[0],secondcorner2[1]],[secondcorner1[0],secondcorner1[1]],[topcorner1[0],topcorner1[1]]],dtype=np.float)
# imagepoints=np.array(((50*(-5.94)+320,50*0.5+240),(50*(-4)+320,0+240),(50*4+320,0+240),(50*5.94+320,50*0.5+240)),dtype=np.float)
#imagepoints=np.array(((186,220),(188,212),(187,171),(186,164)),dtype=np.float)
cv2.putText(backtorgb, str(imagepoints[0][0])+" "+str(imagepoints[0][1]),(3, 65), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
cv2.putText(backtorgb, str(imagepoints[1][0])+" "+str(imagepoints[1][1]),(3, 85), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
cv2.putText(backtorgb, str(imagepoints[2][0])+" "+str(imagepoints[2][1]),(3, 105), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
cv2.putText(backtorgb, str(imagepoints[3][0])+" "+str(imagepoints[3][1]),(3, 125), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
cv2.putText(backtorgb, str(topcorner1[0])+" "+str(topcorner1[1]),(160,65), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
cv2.putText(backtorgb, str(secondcorner1[0])+" "+str(secondcorner1[1]),(160,85), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
cv2.putText(backtorgb, str(topcorner2[0])+" "+str(topcorner2[1]),(160,105), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
cv2.putText(backtorgb, str(secondcorner2[0])+" "+str(secondcorner2[1]),(160,125), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
#The moment of truth?
errorestimate,rvec,tvec=cv2.solvePnP(objpoints,imagepoints,self.cameraMatrix,self.distcoeff)
#cv2.putText(backtorgb, str(tvec[0])+" "+str(tvec[1])+" "+str(tvec[2]),(3, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
cv2.putText(backtorgb, "%.2f" % tvec[0]+" "+"%.2f" % tvec[1]+" "+"%.2f" % tvec[2],(3, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
cv2.putText(backtorgb, "%.2f" % (rvec[0]*180/3.14159)+" "+ "%.2f" % (rvec[1]*180/3.14159)+" "+"%.2f" % (rvec[2]*180/3.14159),(3, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
#spit things out on the serial port, but first, do some testing. Print stuff out.
# cv2.putText(outimg, fps, (3, height - 6), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255))
# Convert our output image to video output format and send to host over USB:
outframe.sendCv(backtorgb)
self.written=True
import numpy as np
import os
from helper import detector_helper as helper
image_dir = "../622data/test/businessRuleTask/"
def format_text(text):
res = text.strip()
res = res.replace("\n", " ")
res = res.replace(" ", " ")
return res
for name in os.listdir(image_dir)[25:30]:
print(name)
image_path = image_dir + name
image = cv.imread(image_path)
# text = pytesseract.image_to_string(Image.fromarray(image_mat))
# text = format_text(text)
#
# print(text)
# print("=" * 30)
cv.imshow("img", helper.dilate_drawing(image))
rotated_img = cv.transpose(image)
rotated_img = cv.flip(rotated_img, 1)
cv.imshow("rotated", helper.dilate_drawing(rotated_img))
cv.waitKey(0)
# np.rot
def rotate_image_counter_clockwise(image):
image = cv2.transpose(image)
image = cv2.flip(image, 0)
return image
#참고한 코드 https://webnautes.tistory.com/577 , https://goo.gl/NNBStM
import cv2
from PIL import Image
cam = cv2.VideoCapture('video.mp4')
cntvid = 0
while (cam.isOpened()):
ret, image = cam.read()
image_rotate = cv2.transpose(image)
image_rotate = cv2.flip(image_rotate, 1)
fps = cam.get(cv2.CAP_PROP_FPS)
if (int(cam.get(1)) % 5 == 0):
cv2.imwrite("frames/frame%d.png" % cntvid, image_rotate)
cntvid += 1
if cntvid == 12: break
#작업 종료시키기
cam.release()
cv2.destroyAllWindows()
#이미지 변환
for i in range(cntvid):
#print (i)
path = 'frames/frame' + str(i) + '.png'
save_path = 're_frames/re_' + str(i) + '.png'
im_r = Image.open(path)
size = (28, 28)
im_r.thumbnail(size)
im_r.save(save_path)
def rot90(img):
timg = cv2.transpose(img)
timg = cv2.flip(timg, 0)
return timg
import cv2
import numpy as np
from src.basic import imageInfo
image = cv2.imread(imageInfo.photographyImage)
height, width = image.shape[:2]
#divide by rwo to rate the image around its center
rotationMatrix = cv2.getRotationMatrix2D((width / 2, height / 2), 45, 0.5)
print(rotationMatrix)
rotatedImage = cv2.warpAffine(image, rotationMatrix, (width, height))
rotatedByTranspose = cv2.transpose(image)
cv2.imshow("Rotated image", rotatedImage)
cv2.imshow("Rotated image by transpose", rotatedByTranspose)
cv2.waitKey()
cv2.destroyAllWindows()
#cv2.imshow("img", paper)
#cv2.waitKey(0)
#cv2.destroyAllWindows()
#################################################################################################################################
############################################# STEP 4 :Correct orientation of page ##############################################
height = paper.shape[0]
width = paper.shape[1]
# Rotate the image such that the page is correctly oriented
paper = rgb_paper.copy()
for c in range(rotation_count):
paper = cv2.transpose(paper)
paper = cv2.flip(paper, flipCode=1)
warped = cv2.transpose(warped)
warped = cv2.flip(warped, flipCode=1)
# display the result
#cv2.imshow("rotated page", cv2.resize(paper,(620,620)))
#cv2.waitKey(0)
#########################################################################################################################################
############################################### STEP 5 :Template matching for find our page #############################################
paper_gray = cv2.cvtColor(paper, cv2.COLOR_BGR2GRAY)
