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 align_affine(imgA, imgB, ptsA, ptsB): """ Aligns IMGB to IMGA, given that the points in PTSA correspond to the points in PTSB. Returns both the aligned IMGB and the affine transformation matrix. """ # 1.) Assume that transformation is 'rigid' (translation, rotation, # scaling). Solve the equation: # Mx = x' # where x is the coordinates in imgB: (x, y, 1) # x' is the coordinates in imgA: (x', y', 1) # and M is the affine transformation matrix, which is a 2x3 # matrix consisting of the affine-trans. coefficients: # M = | A B | = | a_00 a_01 b_0 | # | a_10 a_11 b_1 | # where A is the rotation+scaling matrix, B is the translation # matrix, and | A B | is the augmented matrix (that allows us to # apply an affine trans. to a point (x, y) with a single matrix # operation: # (x',y',1) = M * (x,y,1) mapMat = cv.CreateMat(2, 3, cv.CV_32F) # Note: Here, we use the three pairs of cooresponding points to # solve for the affine transformation matrix M. cv.GetAffineTransform(ptsB, ptsA, mapMat) # 2.) Now that we have the affine transformation matrix M, we # apply it to imgB to align it to imgA: outMat = cv.CreateMat(imgB.rows, imgB.cols, imgB.type) cv.WarpAffine(imgB, outMat, mapMat) return outMat, mapMat
def imtransform(I, H0, fillval=np.nan): # transform image using center as origin if len(I.shape) == 3: Iout = np.copy(I) Iout[:, :, 0] = imtransform(I[:, :, 0], H0, fillval=fillval) Iout[:, :, 1] = imtransform(I[:, :, 1], H0, fillval=fillval) Iout[:, :, 2] = imtransform(I[:, :, 2], H0, fillval=fillval) return Iout else: T0 = np.eye(3) T0[0, 2] = I.shape[1] / 2.0 T0[1, 2] = I.shape[0] / 2.0 T1 = np.eye(3) T1[0, 2] = -I.shape[1] / 2.0 T1[1, 2] = -I.shape[0] / 2.0 H = np.dot(np.dot(T0, H0), T1) # transform each channel separately if not I.flags.c_contiguous: I = np.copy(I) Icv = cv.fromarray(I) I1cv = cv.CreateMat(I.shape[0], I.shape[1], Icv.type) H = H[:2] H = cv.fromarray(H) # cv.WarpPerspective(Icv,I1cv,cv.fromarray(np.copy(H)),fillval=-1); cv.WarpAffine(Icv, I1cv, H) # ,fillval=fillval); I1 = np.asarray(I1cv) # I1[np.nonzero(I1<0)]=fillval return I1
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 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(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 get_image(camera, width, height, writer=None, s=None, rotate=True): im = cv.QueryFrame(camera) imrot = cv.CloneImage(im) if rotate: cv.WarpAffine(im, imrot, gMapping) if writer is not None: write_send(camera, imrot, writer, s) # im = Image.fromstring("RGB", cv.GetSize(im), im.tostring(), "raw", "BGR") return imrot
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 getattr(cv,'2DRotationMatrix')((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((h+cluster[0].dia*3.0, cluster[0].dia*1.5), cv.IPL_DEPTH_8U, 3) cv.GetRectSubPix(warp, ret, (cx,cy)) print cv.GetSize(ret) return ret
class image_converter: def __init__(self): self.image_pub = rospy.Publisher("image_topic_2", Image) cv.NamedWindow("Image window", 1) self.bridge = CvBridge() self.image_sub = rospy.Subscriber("usb_cam/image_raw", Image, self.callback) def callback(self, data): try: cv_image = self.bridge.imgmsg_to_cv(data, "bgr8") except CvBridgeError, e: print e (cols, rows) = cv.GetSize(cv_image) zcx = cols / 2 zcy = rows / 2 if cols > 60 and rows > 60: cv.Circle(cv_image, (zcx, zcy), 10, 255) zoom_value = 100 M = cv.CreateMat(2, 3, cv.CV_32FC1) M[0, 0] = zoom_value / 100. M[0, 1] = 0 M[0, 2] = -zcx * (zoom_value / 100. - 1) M[1, 0] = 0 M[1, 1] = zoom_value / 100. M[1, 2] = -zcy * (zoom_value / 100. - 1) cvi2 = cv_image cv.WarpAffine(cv_image, cvi2, M) cv.ShowImage("Image window", cv_image) cv.WaitKey(3) try: self.image_pub.publish(self.bridge.cv_to_imgmsg(cv_image, "bgr8")) except CvBridgeError, e: print e
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 vars().has_key('centery'): zcy = centery else: zcy = rows / 2 M = cv.CreateMat(2, 3, cv.CV_32FC1) M[0, 0] = zoom / 100. M[0, 1] = 0 M[0, 2] = -zcx * (zoom / 100. - 1) M[1, 0] = 0 M[1, 1] = zoom / 100. M[1, 2] = -zcy * (zoom / 100. - 1) cvi2 = cv_image cv.WarpAffine(cv_image, cvi2, M) return bridge.cv_to_imgmsg(cvi2, "bgr8") # compare_images # # Compares two images (/sensor_msgs/Image) and estimates first norm # of the difference between the pixel values by calculating the # average difference for the set of each <step>'th pixel. # # Output # Average pixel value difference # def compare_images(image1, image2, step=100): normdiff = 0.
# 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
r = 28 + j * 4 mr = r * math.sqrt(2) y += mr * 1.8 test += [(str(deg) + "abcdefgh"[j], (50 + deg * 11, y), math.pi * deg / 180, r) for deg in range(0, 90, 10)] for (msg, (x, y), angle, r) in test: map = cv.CreateMat(2, 3, cv.CV_32FC1) corners = [(x + r * math.cos(angle + th), y + r * math.sin(angle + th)) for th in [0, math.pi / 2, math.pi, 3 * math.pi / 4]] src = mkdmtx(msg) (sx, sy) = cv.GetSize(src) cv.GetAffineTransform([(0, 0), (sx, 0), (sx, sy)], corners[:3], map) temp = cv.CreateMat(bg.rows, bg.cols, cv.CV_8UC3) cv.Set(temp, cv.RGB(0, 0, 0)) cv.WarpAffine(src, temp, map) cv.Or(temp, bg, bg) cv.ShowImage("comp", bg) scribble = cv.CloneMat(bg) if 0: for i in range(10): df.find(bg) for (sym, coords) in df.find(bg).items(): print sym cv.PolyLine(scribble, [coords], 1, cv.CV_RGB(255, 0, 0), 1,
def apply_rot(I, H): Idst = cv.CreateImage(cv.GetSize(I), I.depth, I.channels) cv.WarpAffine(I, Idst, H, fillval=255.0) return Idst
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")
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__()) for i in pos_respuesta:
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
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
imageRotatedWidth = minMaxCorners[0] - minMaxCorners[1] + 1 imageRotatedHeight = minMaxCorners[2] - minMaxCorners[3] + 1 #adjust the shift of the rotation rotMat[0, 2] -= minMaxCorners[1] rotMat[1, 2] -= minMaxCorners[3] #create new image to save the rotated image (rows = height, cols = width) imageRotated = cv.CreateMat(imageRotatedHeight, imageRotatedWidth, image.type) #perform the rotation: cv.WarpAffine(image, imageRotated, rotMat, flags=interpolation_FLAG + cv.CV_WARP_FILL_OUTLIERS, fillval=(255, 255, 255)) #compute the new warped bounding box bb = [100000, 100000, 0, 0] for part in partsDict[imageNumber]: if part in partsToUse: currentPointX = partsDict[imageNumber][part][0] currentPointY = partsDict[imageNumber][part][1] warpedPointX = currentPointX * rotMat[ 0, 0] + currentPointY * rotMat[0, 1] + rotMat[0, 2] warpedPointY = currentPointX * rotMat[ 1, 0] + currentPointY * rotMat[1, 1] + rotMat[1, 2] finalPartLocsList.write(