Add goodfeatures python test and cleanup in test directory
This commit is contained in:
Vladislav Sovrasov
parent
947307baae
commit
fd61978795
@ -1,53 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# Calculating and displaying 2D Hue-Saturation histogram of a color image
|
||||
import sys
|
||||
import cv2.cv as cv
|
||||
|
||||
def hs_histogram(src):
|
||||
# Convert to HSV
|
||||
hsv = cv.CreateImage(cv.GetSize(src), 8, 3)
|
||||
cv.CvtColor(src, hsv, cv.CV_BGR2HSV)
|
||||
|
||||
# Extract the H and S planes
|
||||
h_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1)
|
||||
s_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1)
|
||||
cv.Split(hsv, h_plane, s_plane, None, None)
|
||||
planes = [h_plane, s_plane]
|
||||
|
||||
h_bins = 30
|
||||
s_bins = 32
|
||||
hist_size = [h_bins, s_bins]
|
||||
# hue varies from 0 (~0 deg red) to 180 (~360 deg red again */
|
||||
h_ranges = [0, 180]
|
||||
# saturation varies from 0 (black-gray-white) to
|
||||
# 255 (pure spectrum color)
|
||||
s_ranges = [0, 255]
|
||||
ranges = [h_ranges, s_ranges]
|
||||
scale = 10
|
||||
hist = cv.CreateHist([h_bins, s_bins], cv.CV_HIST_ARRAY, ranges, 1)
|
||||
cv.CalcHist([cv.GetImage(i) for i in planes], hist)
|
||||
(_, max_value, _, _) = cv.GetMinMaxHistValue(hist)
|
||||
|
||||
hist_img = cv.CreateImage((h_bins*scale, s_bins*scale), 8, 3)
|
||||
|
||||
for h in range(h_bins):
|
||||
for s in range(s_bins):
|
||||
bin_val = cv.QueryHistValue_2D(hist, h, s)
|
||||
intensity = cv.Round(bin_val * 255 / max_value)
|
||||
cv.Rectangle(hist_img,
|
||||
(h*scale, s*scale),
|
||||
((h+1)*scale - 1, (s+1)*scale - 1),
|
||||
cv.RGB(intensity, intensity, intensity),
|
||||
cv.CV_FILLED)
|
||||
return hist_img
|
||||
|
||||
if __name__ == '__main__':
|
||||
src = cv.LoadImageM(sys.argv[1])
|
||||
cv.NamedWindow("Source", 1)
|
||||
cv.ShowImage("Source", src)
|
||||
|
||||
cv.NamedWindow("H-S Histogram", 1)
|
||||
cv.ShowImage("H-S Histogram", hs_histogram(src))
|
||||
|
||||
cv.WaitKey(0)
|
||||
@ -1,360 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import sys
|
||||
import math
|
||||
import time
|
||||
import random
|
||||
|
||||
import numpy
|
||||
import transformations
|
||||
import cv2.cv as cv
|
||||
|
||||
def clamp(a, x, b):
|
||||
return numpy.maximum(a, numpy.minimum(x, b))
|
||||
|
||||
def norm(v):
|
||||
mag = numpy.sqrt(sum([e * e for e in v]))
|
||||
return v / mag
|
||||
|
||||
class Vec3:
|
||||
def __init__(self, x, y, z):
|
||||
self.v = (x, y, z)
|
||||
def x(self):
|
||||
return self.v[0]
|
||||
def y(self):
|
||||
return self.v[1]
|
||||
def z(self):
|
||||
return self.v[2]
|
||||
def __repr__(self):
|
||||
return "<Vec3 (%s,%s,%s)>" % tuple([repr(c) for c in self.v])
|
||||
def __add__(self, other):
|
||||
return Vec3(*[self.v[i] + other.v[i] for i in range(3)])
|
||||
def __sub__(self, other):
|
||||
return Vec3(*[self.v[i] - other.v[i] for i in range(3)])
|
||||
def __mul__(self, other):
|
||||
if isinstance(other, Vec3):
|
||||
return Vec3(*[self.v[i] * other.v[i] for i in range(3)])
|
||||
else:
|
||||
return Vec3(*[self.v[i] * other for i in range(3)])
|
||||
def mag2(self):
|
||||
return sum([e * e for e in self.v])
|
||||
def __abs__(self):
|
||||
return numpy.sqrt(sum([e * e for e in self.v]))
|
||||
def norm(self):
|
||||
return self * (1.0 / abs(self))
|
||||
def dot(self, other):
|
||||
return sum([self.v[i] * other.v[i] for i in range(3)])
|
||||
def cross(self, other):
|
||||
(ax, ay, az) = self.v
|
||||
(bx, by, bz) = other.v
|
||||
return Vec3(ay * bz - by * az, az * bx - bz * ax, ax * by - bx * ay)
|
||||
|
||||
|
||||
class Ray:
|
||||
|
||||
def __init__(self, o, d):
|
||||
self.o = o
|
||||
self.d = d
|
||||
|
||||
def project(self, d):
|
||||
return self.o + self.d * d
|
||||
|
||||
class Camera:
|
||||
|
||||
def __init__(self, F):
|
||||
R = Vec3(1., 0., 0.)
|
||||
U = Vec3(0, 1., 0)
|
||||
self.center = Vec3(0, 0, 0)
|
||||
self.pcenter = Vec3(0, 0, F)
|
||||
self.up = U
|
||||
self.right = R
|
||||
|
||||
def genray(self, x, y):
|
||||
""" -1 <= y <= 1 """
|
||||
r = numpy.sqrt(x * x + y * y)
|
||||
if 0:
|
||||
rprime = r + (0.17 * r**2)
|
||||
else:
|
||||
rprime = (10 * numpy.sqrt(17 * r + 25) - 50) / 17
|
||||
print "scale", rprime / r
|
||||
x *= rprime / r
|
||||
y *= rprime / r
|
||||
o = self.center
|
||||
r = (self.pcenter + (self.right * x) + (self.up * y)) - o
|
||||
return Ray(o, r.norm())
|
||||
|
||||
class Sphere:
|
||||
|
||||
def __init__(self, center, radius):
|
||||
self.center = center
|
||||
self.radius = radius
|
||||
|
||||
def hit(self, r):
|
||||
# a = mag2(r.d)
|
||||
a = 1.
|
||||
v = r.o - self.center
|
||||
b = 2 * r.d.dot(v)
|
||||
c = self.center.mag2() + r.o.mag2() + -2 * self.center.dot(r.o) - (self.radius ** 2)
|
||||
det = (b * b) - (4 * c)
|
||||
pred = 0 < det
|
||||
|
||||
sq = numpy.sqrt(abs(det))
|
||||
h0 = (-b - sq) / (2)
|
||||
h1 = (-b + sq) / (2)
|
||||
|
||||
h = numpy.minimum(h0, h1)
|
||||
|
||||
pred = pred & (h > 0)
|
||||
normal = (r.project(h) - self.center) * (1.0 / self.radius)
|
||||
return (pred, numpy.where(pred, h, 999999.), normal)
|
||||
|
||||
def pt2plane(p, plane):
|
||||
return p.dot(plane) * (1. / abs(plane))
|
||||
|
||||
class Plane:
|
||||
|
||||
def __init__(self, p, n, right):
|
||||
self.D = -pt2plane(p, n)
|
||||
self.Pn = n
|
||||
self.right = right
|
||||
self.rightD = -pt2plane(p, right)
|
||||
self.up = n.cross(right)
|
||||
self.upD = -pt2plane(p, self.up)
|
||||
|
||||
def hit(self, r):
|
||||
Vd = self.Pn.dot(r.d)
|
||||
V0 = -(self.Pn.dot(r.o) + self.D)
|
||||
h = V0 / Vd
|
||||
pred = (0 <= h)
|
||||
|
||||
return (pred, numpy.where(pred, h, 999999.), self.Pn)
|
||||
|
||||
def localxy(self, loc):
|
||||
x = (loc.dot(self.right) + self.rightD)
|
||||
y = (loc.dot(self.up) + self.upD)
|
||||
return (x, y)
|
||||
|
||||
# lena = numpy.fromstring(cv.LoadImage("../samples/c/lena.jpg", 0).tostring(), numpy.uint8) / 255.0
|
||||
|
||||
def texture(xy):
|
||||
x,y = xy
|
||||
xa = numpy.floor(x * 512)
|
||||
ya = numpy.floor(y * 512)
|
||||
a = (512 * ya) + xa
|
||||
safe = (0 <= x) & (0 <= y) & (x < 1) & (y < 1)
|
||||
if 0:
|
||||
a = numpy.where(safe, a, 0).astype(numpy.int)
|
||||
return numpy.where(safe, numpy.take(lena, a), 0.0)
|
||||
else:
|
||||
xi = numpy.floor(x * 11).astype(numpy.int)
|
||||
yi = numpy.floor(y * 11).astype(numpy.int)
|
||||
inside = (1 <= xi) & (xi < 10) & (2 <= yi) & (yi < 9)
|
||||
checker = (xi & 1) ^ (yi & 1)
|
||||
final = numpy.where(inside, checker, 1.0)
|
||||
return numpy.where(safe, final, 0.5)
|
||||
|
||||
def under(vv, m):
|
||||
return Vec3(*(numpy.dot(m, vv.v + (1,))[:3]))
|
||||
|
||||
class Renderer:
|
||||
|
||||
def __init__(self, w, h, oversample):
|
||||
self.w = w
|
||||
self.h = h
|
||||
|
||||
random.seed(1)
|
||||
x = numpy.arange(self.w*self.h) % self.w
|
||||
y = numpy.floor(numpy.arange(self.w*self.h) / self.w)
|
||||
h2 = h / 2.0
|
||||
w2 = w / 2.0
|
||||
self.r = [ None ] * oversample
|
||||
for o in range(oversample):
|
||||
stoch_x = numpy.random.rand(self.w * self.h)
|
||||
stoch_y = numpy.random.rand(self.w * self.h)
|
||||
nx = (x + stoch_x - 0.5 - w2) / h2
|
||||
ny = (y + stoch_y - 0.5 - h2) / h2
|
||||
self.r[o] = cam.genray(nx, ny)
|
||||
|
||||
self.rnds = [random.random() for i in range(10)]
|
||||
|
||||
def frame(self, i):
|
||||
|
||||
rnds = self.rnds
|
||||
roll = math.sin(i * .01 * rnds[0] + rnds[1])
|
||||
pitch = math.sin(i * .01 * rnds[2] + rnds[3])
|
||||
yaw = math.pi * math.sin(i * .01 * rnds[4] + rnds[5])
|
||||
x = math.sin(i * 0.01 * rnds[6])
|
||||
y = math.sin(i * 0.01 * rnds[7])
|
||||
|
||||
x,y,z = -0.5,0.5,1
|
||||
roll,pitch,yaw = (0,0,0)
|
||||
|
||||
z = 4 + 3 * math.sin(i * 0.1 * rnds[8])
|
||||
print z
|
||||
|
||||
rz = transformations.euler_matrix(roll, pitch, yaw)
|
||||
p = Plane(Vec3(x, y, z), under(Vec3(0,0,-1), rz), under(Vec3(1, 0, 0), rz))
|
||||
|
||||
acc = 0
|
||||
for r in self.r:
|
||||
(pred, h, norm) = p.hit(r)
|
||||
l = numpy.where(pred, texture(p.localxy(r.project(h))), 0.0)
|
||||
acc += l
|
||||
acc *= (1.0 / len(self.r))
|
||||
|
||||
# print "took", time.time() - st
|
||||
|
||||
img = cv.CreateMat(self.h, self.w, cv.CV_8UC1)
|
||||
cv.SetData(img, (clamp(0, acc, 1) * 255).astype(numpy.uint8).tostring(), self.w)
|
||||
return img
|
||||
|
||||
#########################################################################
|
||||
|
||||
num_x_ints = 8
|
||||
num_y_ints = 6
|
||||
num_pts = num_x_ints * num_y_ints
|
||||
|
||||
def get_corners(mono, refine = False):
|
||||
(ok, corners) = cv.FindChessboardCorners(mono, (num_x_ints, num_y_ints), cv.CV_CALIB_CB_ADAPTIVE_THRESH | cv.CV_CALIB_CB_NORMALIZE_IMAGE)
|
||||
if refine and ok:
|
||||
corners = cv.FindCornerSubPix(mono, corners, (5,5), (-1,-1), ( cv.CV_TERMCRIT_EPS+cv.CV_TERMCRIT_ITER, 30, 0.1 ))
|
||||
return (ok, corners)
|
||||
|
||||
def mk_object_points(nimages, squaresize = 1):
|
||||
opts = cv.CreateMat(nimages * num_pts, 3, cv.CV_32FC1)
|
||||
for i in range(nimages):
|
||||
for j in range(num_pts):
|
||||
opts[i * num_pts + j, 0] = (j / num_x_ints) * squaresize
|
||||
opts[i * num_pts + j, 1] = (j % num_x_ints) * squaresize
|
||||
opts[i * num_pts + j, 2] = 0
|
||||
return opts
|
||||
|
||||
def mk_image_points(goodcorners):
|
||||
ipts = cv.CreateMat(len(goodcorners) * num_pts, 2, cv.CV_32FC1)
|
||||
for (i, co) in enumerate(goodcorners):
|
||||
for j in range(num_pts):
|
||||
ipts[i * num_pts + j, 0] = co[j][0]
|
||||
ipts[i * num_pts + j, 1] = co[j][1]
|
||||
return ipts
|
||||
|
||||
def mk_point_counts(nimages):
|
||||
npts = cv.CreateMat(nimages, 1, cv.CV_32SC1)
|
||||
for i in range(nimages):
|
||||
npts[i, 0] = num_pts
|
||||
return npts
|
||||
|
||||
def cvmat_iterator(cvmat):
|
||||
for i in range(cvmat.rows):
|
||||
for j in range(cvmat.cols):
|
||||
yield cvmat[i,j]
|
||||
|
||||
cam = Camera(3.0)
|
||||
rend = Renderer(640, 480, 2)
|
||||
cv.NamedWindow("snap")
|
||||
|
||||
#images = [rend.frame(i) for i in range(0, 2000, 400)]
|
||||
images = [rend.frame(i) for i in [1200]]
|
||||
|
||||
if 0:
|
||||
for i,img in enumerate(images):
|
||||
cv.SaveImage("final/%06d.png" % i, img)
|
||||
|
||||
size = cv.GetSize(images[0])
|
||||
corners = [get_corners(i) for i in images]
|
||||
|
||||
goodcorners = [co for (im, (ok, co)) in zip(images, corners) if ok]
|
||||
|
||||
def checkerboard_error(xformed):
|
||||
def pt2line(a, b, c):
|
||||
x0,y0 = a
|
||||
x1,y1 = b
|
||||
x2,y2 = c
|
||||
return abs((x2 - x1) * (y1 - y0) - (x1 - x0) * (y2 - y1)) / math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
|
||||
errorsum = 0.
|
||||
for im in xformed:
|
||||
for row in range(6):
|
||||
l0 = im[8 * row]
|
||||
l1 = im[8 * row + 7]
|
||||
for col in range(1, 7):
|
||||
e = pt2line(im[8 * row + col], l0, l1)
|
||||
#print "row", row, "e", e
|
||||
errorsum += e
|
||||
|
||||
return errorsum
|
||||
|
||||
if True:
|
||||
from scipy.optimize import fmin
|
||||
|
||||
def xf(pt, poly):
|
||||
x, y = pt
|
||||
r = math.sqrt((x - 320) ** 2 + (y - 240) ** 2)
|
||||
fr = poly(r) / r
|
||||
return (320 + (x - 320) * fr, 240 + (y - 240) * fr)
|
||||
def silly(p, goodcorners):
|
||||
# print "eval", p
|
||||
|
||||
d = 1.0 # - sum(p)
|
||||
poly = numpy.poly1d(list(p) + [d, 0.])
|
||||
|
||||
xformed = [[xf(pt, poly) for pt in co] for co in goodcorners]
|
||||
|
||||
return checkerboard_error(xformed)
|
||||
|
||||
x0 = [ 0. ]
|
||||
#print silly(x0, goodcorners)
|
||||
print "initial error", silly(x0, goodcorners)
|
||||
xopt = fmin(silly, x0, args=(goodcorners,))
|
||||
print "xopt", xopt
|
||||
print "final error", silly(xopt, goodcorners)
|
||||
|
||||
d = 1.0 # - sum(xopt)
|
||||
poly = numpy.poly1d(list(xopt) + [d, 0.])
|
||||
print "final polynomial"
|
||||
print poly
|
||||
|
||||
for co in goodcorners:
|
||||
scrib = cv.CreateMat(480, 640, cv.CV_8UC3)
|
||||
cv.SetZero(scrib)
|
||||
cv.DrawChessboardCorners(scrib, (num_x_ints, num_y_ints), [xf(pt, poly) for pt in co], True)
|
||||
cv.ShowImage("snap", scrib)
|
||||
cv.WaitKey()
|
||||
|
||||
sys.exit(0)
|
||||
|
||||
for (i, (img, (ok, co))) in enumerate(zip(images, corners)):
|
||||
scrib = cv.CreateMat(img.rows, img.cols, cv.CV_8UC3)
|
||||
cv.CvtColor(img, scrib, cv.CV_GRAY2BGR)
|
||||
if ok:
|
||||
cv.DrawChessboardCorners(scrib, (num_x_ints, num_y_ints), co, True)
|
||||
cv.ShowImage("snap", scrib)
|
||||
cv.WaitKey()
|
||||
|
||||
print len(goodcorners)
|
||||
ipts = mk_image_points(goodcorners)
|
||||
opts = mk_object_points(len(goodcorners), .1)
|
||||
npts = mk_point_counts(len(goodcorners))
|
||||
|
||||
intrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
|
||||
distortion = cv.CreateMat(4, 1, cv.CV_64FC1)
|
||||
cv.SetZero(intrinsics)
|
||||
cv.SetZero(distortion)
|
||||
# focal lengths have 1/1 ratio
|
||||
intrinsics[0,0] = 1.0
|
||||
intrinsics[1,1] = 1.0
|
||||
cv.CalibrateCamera2(opts, ipts, npts,
|
||||
cv.GetSize(images[0]),
|
||||
intrinsics,
|
||||
distortion,
|
||||
cv.CreateMat(len(goodcorners), 3, cv.CV_32FC1),
|
||||
cv.CreateMat(len(goodcorners), 3, cv.CV_32FC1),
|
||||
flags = 0) # cv.CV_CALIB_ZERO_TANGENT_DIST)
|
||||
print "D =", list(cvmat_iterator(distortion))
|
||||
print "K =", list(cvmat_iterator(intrinsics))
|
||||
mapx = cv.CreateImage((640, 480), cv.IPL_DEPTH_32F, 1)
|
||||
mapy = cv.CreateImage((640, 480), cv.IPL_DEPTH_32F, 1)
|
||||
cv.InitUndistortMap(intrinsics, distortion, mapx, mapy)
|
||||
for img in images:
|
||||
r = cv.CloneMat(img)
|
||||
cv.Remap(img, r, mapx, mapy)
|
||||
cv.ShowImage("snap", r)
|
||||
cv.WaitKey()
|
||||
@ -1,25 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import sys
|
||||
import cv2.cv as cv
|
||||
|
||||
def findstereocorrespondence(image_left, image_right):
|
||||
# image_left and image_right are the input 8-bit single-channel images
|
||||
# from the left and the right cameras, respectively
|
||||
(r, c) = (image_left.rows, image_left.cols)
|
||||
disparity_left = cv.CreateMat(r, c, cv.CV_16S)
|
||||
disparity_right = cv.CreateMat(r, c, cv.CV_16S)
|
||||
state = cv.CreateStereoGCState(16, 2)
|
||||
cv.FindStereoCorrespondenceGC(image_left, image_right, disparity_left, disparity_right, state, 0)
|
||||
return (disparity_left, disparity_right)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
(l, r) = [cv.LoadImageM(f, cv.CV_LOAD_IMAGE_GRAYSCALE) for f in sys.argv[1:]]
|
||||
|
||||
(disparity_left, disparity_right) = findstereocorrespondence(l, r)
|
||||
|
||||
disparity_left_visual = cv.CreateMat(l.rows, l.cols, cv.CV_8U)
|
||||
cv.ConvertScale(disparity_left, disparity_left_visual, -16)
|
||||
cv.SaveImage("disparity.pgm", disparity_left_visual)
|
||||
@ -1,36 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import cv2.cv as cv
|
||||
import unittest
|
||||
|
||||
class TestGoodFeaturesToTrack(unittest.TestCase):
|
||||
def test(self):
|
||||
arr = cv.LoadImage("../samples/c/lena.jpg", 0)
|
||||
original = cv.CloneImage(arr)
|
||||
size = cv.GetSize(arr)
|
||||
eig_image = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
|
||||
temp_image = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
|
||||
threshes = [ x / 100. for x in range(1,10) ]
|
||||
|
||||
results = dict([(t, cv.GoodFeaturesToTrack(arr, eig_image, temp_image, 20000, t, 2, useHarris = 1)) for t in threshes])
|
||||
|
||||
# Check that GoodFeaturesToTrack has not modified input image
|
||||
self.assert_(arr.tostring() == original.tostring())
|
||||
|
||||
# Check for repeatability
|
||||
for i in range(10):
|
||||
results2 = dict([(t, cv.GoodFeaturesToTrack(arr, eig_image, temp_image, 20000, t, 2, useHarris = 1)) for t in threshes])
|
||||
self.assert_(results == results2)
|
||||
|
||||
for t0,t1 in zip(threshes, threshes[1:]):
|
||||
r0 = results[t0]
|
||||
r1 = results[t1]
|
||||
|
||||
# Increasing thresh should make result list shorter
|
||||
self.assert_(len(r0) > len(r1))
|
||||
|
||||
# Increasing thresh should monly truncate result list
|
||||
self.assert_(r0[:len(r1)] == r1)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,9 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import cv2.cv as cv
|
||||
import numpy as np
|
||||
cv.NamedWindow('Leak')
|
||||
while 1:
|
||||
leak = np.random.random((480, 640)) * 255
|
||||
cv.ShowImage('Leak', leak.astype(np.uint8))
|
||||
cv.WaitKey(10)
|
||||
@ -1,12 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import cv2.cv as cv
|
||||
import numpy as np
|
||||
import time
|
||||
|
||||
while True:
|
||||
for i in range(4000):
|
||||
a = cv.CreateImage((1024,1024), cv.IPL_DEPTH_8U, 1)
|
||||
b = cv.CreateMat(1024, 1024, cv.CV_8UC1)
|
||||
c = cv.CreateMatND([1024,1024], cv.CV_8UC1)
|
||||
print "pause..."
|
||||
@ -1,8 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import cv2.cv as cv
|
||||
import math
|
||||
import time
|
||||
|
||||
while True:
|
||||
h = cv.CreateHist([40], cv.CV_HIST_ARRAY, [[0,255]], 1)
|
||||
@ -1,11 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import cv2.cv as cv
|
||||
import math
|
||||
import time
|
||||
|
||||
N=50000
|
||||
print "leak4"
|
||||
while True:
|
||||
seq=list((i*1., i*1.) for i in range(N))
|
||||
cv.Moments(seq)
|
||||
@ -1,16 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import cv2.cv as cv
|
||||
|
||||
def precornerdetect(image):
|
||||
# assume that the image is floating-point
|
||||
corners = cv.CloneMat(image)
|
||||
cv.PreCornerDetect(image, corners, 3)
|
||||
|
||||
dilated_corners = cv.CloneMat(image)
|
||||
cv.Dilate(corners, dilated_corners, None, 1)
|
||||
|
||||
corner_mask = cv.CreateMat(image.rows, image.cols, cv.CV_8UC1)
|
||||
cv.Sub(corners, dilated_corners, corners)
|
||||
cv.CmpS(corners, 0, corner_mask, cv.CV_CMP_GE)
|
||||
return (corners, corner_mask)
|
||||
36
modules/python/test/test_goodfeatures.py
Normal file
36
modules/python/test/test_goodfeatures.py
Normal file
@ -0,0 +1,36 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# Python 2/3 compatibility
|
||||
from __future__ import print_function
|
||||
|
||||
import cv2
|
||||
import numpy as np
|
||||
|
||||
from tests_common import NewOpenCVTests
|
||||
|
||||
class TestGoodFeaturesToTrack_test(NewOpenCVTests):
|
||||
def test_goodFeaturesToTrack(self):
|
||||
arr = self.get_sample('samples/data/lena.jpg', 0)
|
||||
original = arr.copy(True)
|
||||
threshes = [ x / 100. for x in range(1,10) ]
|
||||
numPoints = 20000
|
||||
|
||||
results = dict([(t, cv2.goodFeaturesToTrack(arr, numPoints, t, 2, useHarrisDetector=True)) for t in threshes])
|
||||
# Check that GoodFeaturesToTrack has not modified input image
|
||||
self.assertTrue(arr.tostring() == original.tostring())
|
||||
# Check for repeatability
|
||||
for i in range(1):
|
||||
results2 = dict([(t, cv2.goodFeaturesToTrack(arr, numPoints, t, 2, useHarrisDetector=True)) for t in threshes])
|
||||
for t in threshes:
|
||||
self.assertTrue(len(results2[t]) == len(results[t]))
|
||||
for i in range(len(results[t])):
|
||||
self.assertTrue(cv2.norm(results[t][i][0] - results2[t][i][0]) == 0)
|
||||
|
||||
for t0,t1 in zip(threshes, threshes[1:]):
|
||||
r0 = results[t0]
|
||||
r1 = results[t1]
|
||||
# Increasing thresh should make result list shorter
|
||||
self.assertTrue(len(r0) > len(r1))
|
||||
# Increasing thresh should monly truncate result list
|
||||
for i in range(len(r1)):
|
||||
self.assertTrue(cv2.norm(r1[i][0] - r0[i][0])==0)
|
||||
@ -1,78 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import urllib
|
||||
import cv2.cv as cv
|
||||
import Image
|
||||
import unittest
|
||||
|
||||
class TestLoadImage(unittest.TestCase):
|
||||
def setUp(self):
|
||||
open("large.jpg", "w").write(urllib.urlopen("http://www.cs.ubc.ca/labs/lci/curious_george/img/ROS_bug_imgs/IMG_3560.jpg").read())
|
||||
|
||||
def test_load(self):
|
||||
pilim = Image.open("large.jpg")
|
||||
cvim = cv.LoadImage("large.jpg")
|
||||
self.assert_(len(pilim.tostring()) == len(cvim.tostring()))
|
||||
|
||||
class Creating(unittest.TestCase):
|
||||
size=(640, 480)
|
||||
repeat=100
|
||||
def test_0_Create(self):
|
||||
image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
|
||||
cnt=cv.CountNonZero(image)
|
||||
self.assertEqual(cnt, 0, msg="Created image is not black. CountNonZero=%i" % cnt)
|
||||
|
||||
def test_2_CreateRepeat(self):
|
||||
cnt=0
|
||||
for i in range(self.repeat):
|
||||
image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
|
||||
cnt+=cv.CountNonZero(image)
|
||||
self.assertEqual(cnt, 0, msg="Created images are not black. Mean CountNonZero=%.3f" % (1.*cnt/self.repeat))
|
||||
|
||||
def test_2a_MemCreated(self):
|
||||
cnt=0
|
||||
v=[]
|
||||
for i in range(self.repeat):
|
||||
image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
|
||||
cv.FillPoly(image, [[(0, 0), (0, 100), (100, 0)]], 0)
|
||||
cnt+=cv.CountNonZero(image)
|
||||
v.append(image)
|
||||
self.assertEqual(cnt, 0, msg="Memorized images are not black. Mean CountNonZero=%.3f" % (1.*cnt/self.repeat))
|
||||
|
||||
def test_3_tostirng(self):
|
||||
image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
|
||||
image.tostring()
|
||||
cnt=cv.CountNonZero(image)
|
||||
self.assertEqual(cnt, 0, msg="After tostring(): CountNonZero=%i" % cnt)
|
||||
|
||||
def test_40_tostringRepeat(self):
|
||||
cnt=0
|
||||
image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
|
||||
cv.Set(image, cv.Scalar(0,0,0,0))
|
||||
for i in range(self.repeat*100):
|
||||
image.tostring()
|
||||
cnt=cv.CountNonZero(image)
|
||||
self.assertEqual(cnt, 0, msg="Repeating tostring(): Mean CountNonZero=%.3f" % (1.*cnt/self.repeat))
|
||||
|
||||
def test_41_CreateToStringRepeat(self):
|
||||
cnt=0
|
||||
for i in range(self.repeat*100):
|
||||
image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
|
||||
cv.Set(image, cv.Scalar(0,0,0,0))
|
||||
image.tostring()
|
||||
cnt+=cv.CountNonZero(image)
|
||||
self.assertEqual(cnt, 0, msg="Repeating create and tostring(): Mean CountNonZero=%.3f" % (1.*cnt/self.repeat))
|
||||
|
||||
def test_4a_MemCreatedToString(self):
|
||||
cnt=0
|
||||
v=[]
|
||||
for i in range(self.repeat):
|
||||
image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
|
||||
cv.Set(image, cv.Scalar(0,0,0,0))
|
||||
image.tostring()
|
||||
cnt+=cv.CountNonZero(image)
|
||||
v.append(image)
|
||||
self.assertEqual(cnt, 0, msg="Repeating and memorizing after tostring(): Mean CountNonZero=%.3f" % (1.*cnt/self.repeat))
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,91 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import unittest
|
||||
import random
|
||||
import time
|
||||
import math
|
||||
import sys
|
||||
import array
|
||||
import os
|
||||
|
||||
import cv2.cv as cv
|
||||
|
||||
def find_sample(s):
|
||||
for d in ["../samples/c/", "../doc/pics/"]:
|
||||
path = os.path.join(d, s)
|
||||
if os.access(path, os.R_OK):
|
||||
return path
|
||||
return s
|
||||
|
||||
class TestTickets(unittest.TestCase):
|
||||
|
||||
def test_2542670(self):
|
||||
xys = [(94, 121), (94, 122), (93, 123), (92, 123), (91, 124), (91, 125), (91, 126), (92, 127), (92, 128), (92, 129), (92, 130), (92, 131), (91, 132), (90, 131), (90, 130), (90, 131), (91, 132), (92, 133), (92, 134), (93, 135), (94, 136), (94, 137), (94, 138), (95, 139), (96, 140), (96, 141), (96, 142), (96, 143), (97, 144), (97, 145), (98, 146), (99, 146), (100, 146), (101, 146), (102, 146), (103, 146), (104, 146), (105, 146), (106, 146), (107, 146), (108, 146), (109, 146), (110, 146), (111, 146), (112, 146), (113, 146), (114, 146), (115, 146), (116, 146), (117, 146), (118, 146), (119, 146), (120, 146), (121, 146), (122, 146), (123, 146), (124, 146), (125, 146), (126, 146), (126, 145), (126, 144), (126, 143), (126, 142), (126, 141), (126, 140), (127, 139), (127, 138), (127, 137), (127, 136), (127, 135), (127, 134), (127, 133), (128, 132), (129, 132), (130, 131), (131, 130), (131, 129), (131, 128), (132, 127), (133, 126), (134, 125), (134, 124), (135, 123), (136, 122), (136, 121), (135, 121), (134, 121), (133, 121), (132, 121), (131, 121), (130, 121), (129, 121), (128, 121), (127, 121), (126, 121), (125, 121), (124, 121), (123, 121), (122, 121), (121, 121), (120, 121), (119, 121), (118, 121), (117, 121), (116, 121), (115, 121), (114, 121), (113, 121), (112, 121), (111, 121), (110, 121), (109, 121), (108, 121), (107, 121), (106, 121), (105, 121), (104, 121), (103, 121), (102, 121), (101, 121), (100, 121), (99, 121), (98, 121), (97, 121), (96, 121), (95, 121)]
|
||||
|
||||
#xys = xys[:12] + xys[16:]
|
||||
pts = cv.CreateMat(len(xys), 1, cv.CV_32SC2)
|
||||
for i,(x,y) in enumerate(xys):
|
||||
pts[i,0] = (x, y)
|
||||
storage = cv.CreateMemStorage()
|
||||
hull = cv.ConvexHull2(pts, storage)
|
||||
hullp = cv.ConvexHull2(pts, storage, return_points = 1)
|
||||
defects = cv.ConvexityDefects(pts, hull, storage)
|
||||
|
||||
vis = cv.CreateImage((1000,1000), 8, 3)
|
||||
x0 = min([x for (x,y) in xys]) - 10
|
||||
x1 = max([x for (x,y) in xys]) + 10
|
||||
y0 = min([y for (y,y) in xys]) - 10
|
||||
y1 = max([y for (y,y) in xys]) + 10
|
||||
def xform(pt):
|
||||
x,y = pt
|
||||
return (1000 * (x - x0) / (x1 - x0),
|
||||
1000 * (y - y0) / (y1 - y0))
|
||||
|
||||
for d in defects[:2]:
|
||||
cv.Zero(vis)
|
||||
|
||||
# First draw the defect as a red triangle
|
||||
cv.FillConvexPoly(vis, [xform(p) for p in d[:3]], cv.RGB(255,0,0))
|
||||
|
||||
# Draw the convex hull as a thick green line
|
||||
for a,b in zip(hullp, hullp[1:]):
|
||||
cv.Line(vis, xform(a), xform(b), cv.RGB(0,128,0), 3)
|
||||
|
||||
# Draw the original contour as a white line
|
||||
for a,b in zip(xys, xys[1:]):
|
||||
cv.Line(vis, xform(a), xform(b), (255,255,255))
|
||||
|
||||
self.snap(vis)
|
||||
|
||||
def test_2686307(self):
|
||||
lena = cv.LoadImage(find_sample("lena.jpg"), 1)
|
||||
dst = cv.CreateImage((512,512), 8, 3)
|
||||
cv.Set(dst, (128,192,255))
|
||||
mask = cv.CreateImage((512,512), 8, 1)
|
||||
cv.Zero(mask)
|
||||
cv.Rectangle(mask, (10,10), (300,100), 255, -1)
|
||||
cv.Copy(lena, dst, mask)
|
||||
self.snapL([lena, dst, mask])
|
||||
m = cv.CreateMat(480, 640, cv.CV_8UC1)
|
||||
print "ji", m
|
||||
print m.rows, m.cols, m.type, m.step
|
||||
|
||||
def snap(self, img):
|
||||
self.snapL([img])
|
||||
|
||||
def snapL(self, L):
|
||||
for i,img in enumerate(L):
|
||||
cv.NamedWindow("snap-%d" % i, 1)
|
||||
cv.ShowImage("snap-%d" % i, img)
|
||||
cv.WaitKey()
|
||||
cv.DestroyAllWindows()
|
||||
|
||||
if __name__ == '__main__':
|
||||
random.seed(0)
|
||||
if len(sys.argv) == 1:
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TestTickets)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
else:
|
||||
suite = unittest.TestSuite()
|
||||
suite.addTest(TestTickets(sys.argv[1]))
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user