def rotate(img, angle):
center = (img.width / 2.0, img.height / 2.0)
rot_mat = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.GetRotationMatrix2D(center, angle, 1.0, rot_mat)
dst = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 1)
cv.WarpAffine(img, dst, rot_mat, fillval=255)
return dst
def rotacion_y_posicion_robot(self,robo_x=200,robo_y=100,robo_th=80): """ \brief graficar el robot en el lienzo de mapa \param self no se necesita incluirlo al utilizar la funcion ya que se lo pone solo por ser la definicion de una clase \param robo_x coordenada x de la odometria del robot \param robo_y coordenada y de la odometria del robot \param robo_th Valor Th del robot \return Nada """ image_mapa=cv.LoadImage(self.nombre_archivo1, cv.CV_LOAD_IMAGE_COLOR) dimensiones_robot=self.dimensiones_robot image1=cv.CreateImage(dimensiones_robot,8,3) image_mascara=cv.CreateImage(dimensiones_robot,8,1) ##rotacion #Rotar el robot src_center=dimensiones_robot[0]/2,dimensiones_robot[1]/2 rot_mat=cv.CreateMat( 2, 3, cv.CV_32FC1 ) cv.GetRotationMatrix2D(src_center, robo_th, 1.0,rot_mat); cv.WarpAffine(self.robot,image1,rot_mat) #crear filtro para negro cv.InRangeS(image1,cv.RGB(0,0,0),cv.RGB(14,14,14),image_mascara) cv.Not(image_mascara,image_mascara) #cv.ReleaseImage(image1) #reducir y posicion cv.SetImageROI(image_mapa,(robo_x,robo_y, dimensiones_robot[0], dimensiones_robot[1])); cv.Copy(image1,image_mapa,mask=image_mascara) cv.ResetImageROI(image_mapa); cv.SaveImage(self.nombre_archivo, image_mapa) #Saves the image#
def rotate(im, angle):
"""
Rotates image by angle degrees clockwise.
**Parameters:**
* im (cvArr) - The source image.
* angle (float) - Angle in degrees.
**Returns:**
The rotated image.
.. todo::
* Arguments to specifcy background colour and clockwise/anti-clockwise.
* Enclosed rectangle formula.
"""
centre = ((im.width - 1) / 2, (im.height - 1) / 2)
rot = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.GetRotationMatrix2D(centre, -angle, 1.0, rot)
dst = create(im)
cv.WarpAffine(im, dst, rot)
# Code in progress to return the new rectangle contained in the rotated image
# w = float(im.width)
# h = float(im.height)
# angle = (angle/360.0)*2*math.pi
# width = w/(math.sin(angle)*(h/w + (math.cos(angle)/math.sin(angle))))
# height = (w/h)*width
# pt1 = (centre[0]-int(width/2), centre[1]-int(height/2))
# pt2 = (centre[0]+int(width/2)-1, centre[1]+int(height/2)-1)
# cv.Rectangle(dst, pt1, pt2, 255)
return dst
def rotate(src, center, angle):
mapMatrix = cv.CreateMat(2,3,cv.CV_64F)
#cv.GetRotationMatrix2D( center, 450 - angle, 1.0, mapMatrix)
cv.GetRotationMatrix2D( center, 270 - angle, 1.0, mapMatrix)
dst = cv.CreateImage( cv.GetSize(src), src.depth, src.nChannels)
cv.SetZero(dst)
cv.WarpAffine(src, dst, mapMatrix)
return dst
def rotateImage(image, angle):
image_center = tuple(numpy.array(cv.GetSize(image))/2)
rot_mat = cv.CreateMat(2, 3, cv.CV_32F)
cv.GetRotationMatrix2D(image_center, angle, 1.0, rot_mat)
result = cv.CreateImage(cv.GetSize(image), image.depth, image.nChannels)
cv.WarpAffine(image, result, rot_mat)
return result
def rotate_image(self, image, angle, around=None):
if around is None:
around = (0, 0)
rotate = cv.CreateImage(cv.GetSize(image), image.depth, 1)
rotate = cv.CloneImage(image)
mapping = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.GetRotationMatrix2D(around, angle, 1, mapping)
cv.WarpAffine(image, rotate, mapping)
return rotate
def scaleRot(self, im_small, d_scale, d_heading):
cv.GetRotationMatrix2D((self.P1[0, 2] / self.performance.small_factor,
self.P1[1, 2] / self.performance.small_factor),
-d_heading, d_scale, self.rotscale_map)
#cv.GetRotationMatrix2D((self.size_small[1]/2, self.size_small[0]/2), -d_heading, d_scale, self.rotscale_map)
#self.rotscale_map = cv.fromarray(cv2.getRotationMatrix2D((np.float32(self.size_small[1])/2,np.float32(self.size_small[0])/2), -d_heading, d_scale))
#alpha = d_scale * np.cos(-d_heading * np.pi/180)
#beta = d_scale * np.sin(-d_heading * np.pi/180)
#self.rotscale_map[0,2] = (1-alpha)*680 - beta*512
#self.rotscale_map[1,2] = beta*680 + (1-alpha)*512
cv.WarpAffine(im_small, im_small, self.rotscale_map)
def img(self):
'''return a cv image for the icon'''
SlipThumbnail.img(self)
if self.rotation:
# rotate the image
mat = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.GetRotationMatrix2D((self.width / 2, self.height / 2),
-self.rotation, 1.0, mat)
self._rotated = cv.CloneImage(self._img)
cv.WarpAffine(self._img, self._rotated, mat)
else:
self._rotated = self._img
return self._rotated
def extract_plate(image, cluster):
"""De-skew and extract a detected plate from an image."""
cluster = list(cluster)
cluster.sort(cmp=lambda x, y: cmp(x.cx, y.cx))
o = cluster[-1].cy - cluster[0].cy
h = cluster[0].dist_to(cluster[-1])
angle = math.asin(o / h)
matrix = cv.CreateMat(2, 3, cv.CV_32FC1)
cx = (cluster[0].cx + cluster[-1].cx) / 2.0
cy = (cluster[0].cy + cluster[-1].cy) / 2.0
cv.GetRotationMatrix2D((cx, cy), angle * 180.0 / math.pi, 1, matrix)
warp = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_8U, 3)
cv.WarpAffine(image, warp, matrix)
ret = cv.CreateImage(
(int(h + cluster[0].dia * 3.0), int(cluster[0].dia * 1.5)),
cv.IPL_DEPTH_8U, 3)
cv.GetRectSubPix(warp, ret, (cx, cy))
print cv.GetSize(ret)
return ret
def doRotate(image,
alpha,
fillval=0,
resize=True,
interpolation=cv.CV_INTER_CUBIC):
matrix = cv.CreateMat(2, 3, cv.CV_32FC1)
w, h = cv.GetSize(image)
center = ((w - 1) / 2.0, (h - 1) / 2.0)
cv.GetRotationMatrix2D(center, alpha, 1.0, matrix)
if resize:
d = sqrt(w * w + h * h)
d2 = d / 2.0
matrix[0, 2] += d2 - center[0]
matrix[1, 2] += d2 - center[1]
d = int(d)
size = (d, d)
else:
size = cv.GetSize(image)
result = cv.CreateImage(size, image.depth, image.nChannels)
cv.WarpAffine(image, result, matrix,
interpolation + cv.CV_WARP_FILL_OUTLIERS, fillval)
return result
def rotate(self, degrees):
if (degrees > 180):
# Flip around both axes
cv.Flip(self.image, None, -1)
degrees = degrees - 180
img = self.image
size = cv.GetSize(img)
if (degrees / 90 % 2):
new_size = (size[1], size[0])
center = ((size[0] - 1) * 0.5, (size[0] - 1) * 0.5)
else:
new_size = size
center = ((size[0] - 1) * 0.5, (size[1] - 1) * 0.5)
mapMatrix = cv.CreateMat(2, 3, cv.CV_64F)
cv.GetRotationMatrix2D(center, degrees, 1.0, mapMatrix)
dst = cv.CreateImage(new_size, self.image_depth, self.image_channels)
cv.SetZero(dst)
cv.WarpAffine(img, dst, mapMatrix)
self.image = dst
def doRotate(image,
alpha,
fillval=0,
resize=True,
interpolation=cv.CV_INTER_CUBIC):
matrix = cv.CreateMat(2, 3, cv.CV_32FC1)
w, h = cv.GetSize(image)
center = ((w - 1) / 2.0, (h - 1) / 2.0)
cv.GetRotationMatrix2D(center, alpha, 1.0, matrix)
if resize:
angle = rad(abs(alpha))
nw = w * cos(angle) + h * sin(angle)
nh = w * sin(angle) + h * cos(angle)
ncenter = (nw / 2.0, nh / 2.0)
matrix[0, 2] += ncenter[0] - center[0]
matrix[1, 2] += ncenter[1] - center[1]
size = (int(ceil(nw)), int(ceil(nh)))
else:
size = cv.GetSize(image)
result = cv.CreateImage(size, image.depth, image.nChannels)
cv.WarpAffine(image, result, matrix,
interpolation + cv.CV_WARP_FILL_OUTLIERS, fillval)
return result
if __name__ == "__main__":
fps = 25.0
target_dur = 1.0 / fps
camera = cv.CreateCameraCapture(0)
width = cv.GetCaptureProperty(camera, cv.CV_CAP_PROP_FRAME_WIDTH)
height = cv.GetCaptureProperty(camera, cv.CV_CAP_PROP_FRAME_HEIGHT)
cv.SetCaptureProperty(camera, cv.CV_CAP_PROP_FRAME_WIDTH, 640)
cv.SetCaptureProperty(camera, cv.CV_CAP_PROP_FRAME_HEIGHT, 480)
width = 640
height = 480
print("WEBCAM: Initialized camera with", width, "x", height)
global gMapping
gMapping = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.GetRotationMatrix2D((width / 2.0, height / 2.0), 180.0, 1.0, gMapping)
cv.NamedWindow("Webcam")
cv.MoveWindow("Webcam", 1280, 0)
im = get_image(camera, width, height)
cv.ShowImage("Webcam", im)
time.sleep(0.2)
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
connected = False
while not connected:
try:
s.connect("\0vidsocket")
connected = True
except:
pass
puntos_horizontales = puntosParaTemplate (marcado, itemH) print "horizontales: " + str (puntos_horizontales .__len__()) x1 = puntos_horizontales[0][0] y1 = marcado.height-puntos_horizontales[0][1] x2 = puntos_horizontales[1][0] y2 = marcado.height-puntos_horizontales[1][1] rot_mat = cv.CreateMat(2, 3, cv.CV_32F) ang_rad = math.atan((y2-y1)/(x2-x1)) degrees = - (180 * ang_rad / math.pi) cv.GetRotationMatrix2D( (marcado.width/2,marcado.height/2), degrees, 1, rot_mat ); cv.WarpAffine( marcado, marcadog, rot_mat ); opencv.cvReleaseImage(marcado) puntos_horizontales = puntosParaTemplate (marcado, itemH) pos_respuesta = puntosParaTemplate (marcadog, itemP) print "respuestas: " + str (pos_respuesta.__len__()) #print "horizontal: " + str (pos_horizontal.__len__()) #print "sin marcar: " + str (sin_marcar.__len__())
# coding: utf-8
import cv, commands, sys, os
FOLDER_PATH = "/Users/satokazuki/Desktop/zikken5/G1_kirinuki/"
OUTPUT_PATH = "/Users/satokazuki/Desktop/zikken5/G1_database/"
img_list = os.listdir(FOLDER_PATH)
print img_list
count = 0
for img_name in img_list:
angle = (0, 90, 180, 270)
item = img_name.split(".")
if item[1] == "png":
im_in = cv.LoadImage(FOLDER_PATH + img_name)
im_ro = cv.CreateImage(cv.GetSize(im_in), cv.IPL_DEPTH_8U, 3)
rotate_mat = cv.CreateMat(2, 3, cv.CV_32FC1)
count += 1
for i in range(0, 4):
cv.GetRotationMatrix2D((im_in.height / 2, im_in.width / 2),
angle[i], 1, rotate_mat)
cv.WarpAffine(im_in, im_ro, rotate_mat)
cv.SaveImage(OUTPUT_PATH + item[0] + "_" + str(i) + ".png", im_ro)
count += 1
print count
w = -1
h = -1
bb = [100000, 100000, 0, 0]
#skip rotation, if arg is given
if (rotateArg != "rotate"):
rotate = False
# if we have more than one part, do the transformation
if (rotate):
#OpenCV needs rotation angle in degrees
r = math.degrees(r)
#get rotation matrix
rotMat = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.GetRotationMatrix2D((centerX, centerY), -r, 1.0, rotMat)
#get maximal Dimension of imageRotated, such that the rotated image fully fits
warpedCornersX = [
warpPointX(0, 0, rotMat),
warpPointX(0, imageHeight - 1, rotMat),
warpPointX(imageWidth - 1, 0, rotMat),
warpPointX(imageWidth - 1, imageHeight - 1, rotMat)
]
warpedCornersY = [
warpPointY(0, 0, rotMat),
warpPointY(0, imageHeight - 1, rotMat),
warpPointY(imageWidth - 1, 0, rotMat),
warpPointY(imageWidth - 1, imageHeight - 1, rotMat)
]
minMaxCorners = [
def rotateImage(image, angle, center):
rot_mat = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.GetRotationMatrix2D(center, angle * 180 / 3.14159, 1.0, rot_mat)
result = cv.CloneImage(image)
cv.WarpAffine(image, result, rot_mat)
return result
def get_rotmat(I, degrees):
w, h = cv.GetSize(I)
rotmat = cv.CreateMat(2, 3, cv.CV_32F)
cv.GetRotationMatrix2D((w / 2, h / 2), degrees, 1.0, rotmat)
return rotmat
def processInput():
print inputArgs.sessionFolder
scriptDir = os.path.dirname(os.path.abspath(__file__))
os.system("touch /run/shm/attitude2video_opencv.lock")
data_yaw = []
data_pitch = []
data_roll = []
data_speed = []
data_altitude = []
data_climb = []
sourceFile_yaw = open(
inputArgs.sessionFolder[0] + "/logs/interpolated_yaw_30fps.txt", 'r')
for line in sourceFile_yaw:
data_yaw.append(float(line))
sourceFile_yaw.close()
sourceFile_pitch = open(
inputArgs.sessionFolder[0] + "/logs/interpolated_pitch_30fps.txt", 'r')
for line in sourceFile_pitch:
data_pitch.append(float(line))
sourceFile_pitch.close()
sourceFile_roll = open(
inputArgs.sessionFolder[0] + "/logs/interpolated_roll_30fps.txt", 'r')
for line in sourceFile_roll:
data_roll.append(float(line))
sourceFile_roll.close()
sourceFile_speed = open(
inputArgs.sessionFolder[0] + "/logs/interpolated_speed_30fps.txt", 'r')
for line in sourceFile_speed:
data_speed.append(float(line) * 3600 / 1000)
sourceFile_speed.close()
sourceFile_altitude = open(
inputArgs.sessionFolder[0] + "/logs/interpolated_altitude_30fps.txt",
'r')
for line in sourceFile_altitude:
data_altitude.append(float(line))
sourceFile_altitude.close()
sourceFile_climb = open(
inputArgs.sessionFolder[0] +
"/logs/interpolated_altitude_speed_30fps.txt", 'r')
for line in sourceFile_climb:
data_climb.append(float(line))
sourceFile_climb.close()
# create working directory in shared memmory
if not os.path.exists("/dev/shm/attitude2video_opencv"):
os.makedirs("/dev/shm/attitude2video_opencv")
# prepare image templates
os.system(
"cp " + scriptDir +
"/resources_opencv/speed.png /dev/shm/attitude2video_opencv/speed.png"
)
os.system(
"cp " + scriptDir +
"/resources_opencv/climb.png /dev/shm/attitude2video_opencv/climb.png"
)
os.system(
"cp " + scriptDir +
"/resources_opencv/center.png /dev/shm/attitude2video_opencv/center.png"
)
os.system(
"cp " + scriptDir +
"/resources_opencv/horizon.png /dev/shm/attitude2video_opencv/horizon.png"
)
os.system(
"cp " + scriptDir +
"/resources_opencv/terrain.png /dev/shm/attitude2video_opencv/terrain.png"
)
os.system(
"cp " + scriptDir +
"/resources_opencv/compass.png /dev/shm/attitude2video_opencv/compass.png"
)
os.system(
"cp " + scriptDir +
"/resources_opencv/altitude.png /dev/shm/attitude2video_opencv/altitude.png"
)
os.system(
"cp " + scriptDir +
"/resources_opencv/background.png /dev/shm/attitude2video_opencv/background.png"
)
# create working directory
if not os.path.exists(inputArgs.sessionFolder[0] + "/media/work"):
os.makedirs(inputArgs.sessionFolder[0] + "/media/work")
if not os.path.exists(inputArgs.sessionFolder[0] +
"/media/work/attitude_opencv"):
os.makedirs(inputArgs.sessionFolder[0] + "/media/work/attitude_opencv")
## Apptly named MAGIC
# But before that, let's load the templates
originalSpeed = cv.LoadImage("/dev/shm/attitude2video_opencv/speed.png")
originalClimb = cv.LoadImage("/dev/shm/attitude2video_opencv/climb.png")
originalCenter = cv.LoadImage("/dev/shm/attitude2video_opencv/center.png")
originalHorizon = cv.LoadImage("/dev/shm/attitude2video_opencv/horizon.png"
) # -1 to load with alpha channel
originalTerrain = cv.LoadImage(
"/dev/shm/attitude2video_opencv/terrain.png")
originalCompass = cv.LoadImage(
"/dev/shm/attitude2video_opencv/compass.png")
originalAltitude = cv.LoadImage(
"/dev/shm/attitude2video_opencv/altitude.png")
for x in range(0, len(data_speed)):
progressbar(((x * 1.0 + 1) / len(data_speed)), "Rendering openCV:",
"(" + str(x + 1) + "/" + str(len(data_speed)) + ") " +
"attitude_%07d.jpg" % (x + 1), 20)
#for x in range(0,1):
currentSpeed = cv.CloneImage(originalSpeed)
currentClimb = cv.CloneImage(originalClimb)
currentCenter = cv.CloneImage(originalCenter)
currentHorizon = cv.CloneImage(originalHorizon)
currentTerrain = cv.CloneImage(originalTerrain)
currentCompass = cv.CloneImage(originalCompass)
currentAltitude = cv.CloneImage(originalAltitude)
# 0 ------------------------------------------------
# Rotate center
picCenter = (originalHorizon.width / 2.0, originalHorizon.height / 2.0)
outputMatrix = cv.CreateMat(2, 3, cv.CV_32F)
cv.GetRotationMatrix2D(
picCenter, (data_roll[x]), 1.0, outputMatrix
) # Positive number goes counter-clockwise, counter to what the original code did. Ergo, do * away with -1
cv.WarpAffine(originalHorizon,
currentHorizon,
outputMatrix,
cv.CV_WARP_FILL_OUTLIERS + cv.CV_INTER_LINEAR,
fillval=(0, 0, 0, 0))
# Rotate horizon
picCenter = (originalCenter.width / 2.0, originalCenter.height / 2.0)
outputMatrix = cv.CreateMat(2, 3, cv.CV_32F)
cv.GetRotationMatrix2D(picCenter, (data_roll[x]), 1.0, outputMatrix)
cv.WarpAffine(originalCenter,
currentCenter,
outputMatrix,
cv.CV_WARP_FILL_OUTLIERS + cv.CV_INTER_LINEAR,
fillval=(0, 0, 0, 0))
# 1 ------------------------------------------------
odmik = data_pitch[x] * 3.0 * -1.0 # Reverse it again.
width = 640
height = 360
picCenter = (currentHorizon.width / 2.0, currentHorizon.height / 2.0)
regionOfInterest = (int(picCenter[0] - (width / 2.0)),
int(picCenter[1] - (height / 2.0) + (odmik)),
int(width), int(height))
thirdHorizon = cv.GetSubRect(currentHorizon, regionOfInterest)
# Instead of copy-ing we do subtraction. Works, since we're using (mostly) black for displaying things. Templates need to be alpha-less and inverted.
cv.Sub(thirdHorizon, originalTerrain, thirdHorizon)
cv.Sub(thirdHorizon, currentCenter, thirdHorizon)
# 2 ------------------------------------------------
zacetnaPozicija = width / 2.0
if data_yaw[x] <= 180:
zacetnaPozicija = zacetnaPozicija + 3.9 * data_yaw[x]
else:
zacetnaPozicija = zacetnaPozicija + 3.9 * (360 - data_yaw[x])
# Speed imporvement. Which isn't faster. Yay.
compassHeight = 50
regionOfInterest = (int(currentCompass.width / 2.0 - zacetnaPozicija),
int(0), int(width), int(compassHeight))
currentCompass = cv.GetSubRect(currentCompass, regionOfInterest)
regionOfInterest = (int(0), int(0), int(width), int(compassHeight))
pointerToSpace = cv.GetSubRect(thirdHorizon, regionOfInterest)
cv.Sub(pointerToSpace, currentCompass, pointerToSpace)
# 3 ------------------------------------------------
speedCenter = (originalSpeed.width / 2.0, originalSpeed.height / 2.0)
speedWidth = originalSpeed.width
speedHeight = originalSpeed.height
zacetnaPozicija = speedHeight / 2.0
if data_speed[x] < 0:
zacetnaPozicija = zacetnaPozicija - 210
elif data_speed[x] >= 100:
zacetnaPozicija = zacetnaPozicija + 210
else:
zacetnaPozicija = zacetnaPozicija + (200 - (data_speed[x] * 4))
doDol = speedHeight - zacetnaPozicija
if (doDol > 130):
doDol = 130
doGor = zacetnaPozicija
if (doGor > 130):
doGor = 130
regionOfInterest = (int(0), int(zacetnaPozicija - doGor),
int(speedWidth), int(doDol + doGor))
currentSpeed = cv.GetSubRect(originalSpeed, regionOfInterest)
regionOfInterest = (int(width / 2.0 - 190 - currentSpeed.width / 2.0),
int(height / 2.0 - doGor), int(speedWidth),
int(doGor + doDol))
pointerToWhereToCopySpeed = cv.GetSubRect(thirdHorizon,
regionOfInterest)
cv.Sub(pointerToWhereToCopySpeed, currentSpeed,
pointerToWhereToCopySpeed)
# 4 ------------------------------------------------
lokalniOdmik = 0
if data_altitude[x] < 0:
lokalniOdmik = 2010
elif data_altitude[x] >= 1000:
lokalniOdmik = -2010
else:
lokalniOdmik = -(2000 - (data_altitude[x] * 4))
temp = currentAltitude.height / 2.0
doDol = (temp + lokalniOdmik)
if (doDol > 130):
doDol = 130
doGor = temp - lokalniOdmik
if (doGor > 130):
doGor = 130
regionOfInterest = (int(0),
int(currentAltitude.height / 2.0 - lokalniOdmik -
doGor), int(speedWidth), int(doGor + doDol))
cutAltitude = cv.GetSubRect(currentAltitude, regionOfInterest)
regionOfInterest = (int(width / 2.0 + 160), int(height / 2.0 - doGor),
int(70), int(doGor + doDol))
pointerToWhereToCopyAltitude = cv.GetSubRect(thirdHorizon,
regionOfInterest)
cv.Sub(pointerToWhereToCopyAltitude, cutAltitude,
pointerToWhereToCopyAltitude)
# ------------------------------------------------
lokalniOdmik = 0
if data_climb[x] < -10:
lokalniOdmik = -410
elif data_climb[x] >= 10:
lokalniOdmik = 410
else:
lokalniOdmik = ((data_climb[x] * 4 * 10))
temp = currentClimb.height / 2.0
doDol = (temp + lokalniOdmik)
if (doDol > 130):
doDol = 130
doGor = temp - lokalniOdmik
if (doGor > 130):
doGor = 130
regionOfInterest = (int(0),
int(currentClimb.height / 2.0 - lokalniOdmik -
doGor), int(speedWidth), int(doGor + doDol))
cutClimb = cv.GetSubRect(currentClimb, regionOfInterest)
regionOfInterest = (int(width / 2.0 + 245), int(height / 2.0 - doGor),
int(70), int(doGor + doDol))
pointerToWhereToCopyClimb = cv.GetSubRect(thirdHorizon,
regionOfInterest)
cv.Sub(pointerToWhereToCopyClimb, cutClimb, pointerToWhereToCopyClimb)
# 5 ------------------------------------------------
cv.SaveImage("/dev/shm/attitude2video_opencv/composed.png",
thirdHorizon)
os.system("cp /dev/shm/attitude2video_opencv/composed.png " +
inputArgs.sessionFolder[0] +
"/media/work/attitude_opencv/attitude_" + "%07d.png" %
(x + 1, ))
# CLEAR ALL VARIABLES! You know, memory leaks and such.
# 6 ------------------------------------------------
# KONEC
os.system("avconv -r 30 -i " + inputArgs.sessionFolder[0] +
"/media/work/attitude_opencv/attitude_" +
"%07d.png -qscale 1 -b 1300k -vcodec libx264 " +
inputArgs.sessionFolder[0] + "/media/attitude.mp4")
# remove working directory with temporary files
fileList = os.listdir(inputArgs.sessionFolder[0] +
"/media/work/attitude_opencv")
for fileName in fileList:
os.remove(inputArgs.sessionFolder[0] + "/media/work/attitude_opencv" +
"/" + fileName)
os.rmdir(inputArgs.sessionFolder[0] + "/media/work/attitude_opencv")
#os.rmdir(inputArgs.sessionFolder[0]+"/media/work")
# remove working directory with temporary files in shared memmory
fileList = os.listdir("/dev/shm/attitude2video_opencv")
for fileName in fileList:
os.remove("/dev/shm/attitude2video_opencv" + "/" + fileName)
os.rmdir("/dev/shm/attitude2video_opencv")
os.system("rm -f /run/shm/attitude2video_opencv.lock")
framecounter = 0
w = 5
cv.NamedWindow("camera", cv.CV_WINDOW_AUTOSIZE)
capture = cv.CaptureFromCAM(0)
img = cv.QueryFrame(capture)
(r, c) = cv.GetSize(img)
imgGray = cv.CreateImage((r, c), cv.IPL_DEPTH_8U, 1)
imgRotate = cv.CreateImage((r, c), cv.IPL_DEPTH_8U, 1)
imgAvg = cv.CreateImage((r, c), cv.IPL_DEPTH_8U, 1)
rotMat = cv.CreateMat(2, 3, cv.CV_32FC1)
while True:
img = cv.QueryFrame(capture)
framecounter = framecounter + 1
cv.CvtColor(img, imgGray, cv.CV_RGB2GRAY)
cv.GetRotationMatrix2D((r / 2, c / 2), w * framecounter, 1.0, rotMat)
cv.WarpAffine(imgGray, imgRotate, rotMat)
alpha = 0.1
cv.AddWeighted(imgAvg, 1.0 - alpha, imgRotate, alpha, 0.0, imgAvg)
cv.ShowImage("camera", imgAvg)
if cv.WaitKey(10) == 27:
break
