Exemplo n.º 1
0
 def _predict_one(self, index, new_corners):
     '''
     predict position of corner index
     @param index:
     @param new_corners:
     '''
     # predicting by taking vectors form near corners along the sides
     # and solving linear equation for intersection
     L = len(new_corners)
     nb = (index + 1) % L
     b = new_corners[nb]
     nd = (index - 1 + L) % L
     d = new_corners[nd]
     assert isinstance(b, Corner)
     v1 = b.get_prediction_vector(True, self.corners[nb])
     v2 = d.get_prediction_vector(False, self.corners[nd])
     p1 = b.p
     p2 = d.p
     (p, _) = solve_linear(v1, v2, p1, p2)
     point = add(b.p, v1, p)
     cor = Corner([d.p, point, b.p], imgtime=b.time)
     cor.compute_change(self.corners[index])
     cor.is_predicted = True
     if cor.similarity < self.avg_sim * 2:
         new_corners[index] = cor
Exemplo n.º 2
0
 def test_get_prediction_vector(self):
     points = [(1, 5), (3, 0), (5, 6)]
     v1 = vector(points[1], points[0])
     v2 = vector(points[1], points[2])
     angle = vectorAngle(v1, v2)
     c = Corner(points, 1, imgtime=1)
     c1 = Corner(points, 1, imgtime=1)
     ans = c.get_prediction_vector(True, c1)
     self.assertAlmostEqual(ans[0], v1[0], 6)
     self.assertAlmostEqual(ans[1], v1[1], 6)
     ans = c.get_prediction_vector(False, c1)
     self.assertAlmostEqual(ans[0], v2[0], 6)
     self.assertAlmostEqual(ans[1], v2[1], 6)
Exemplo n.º 3
0
 def test_get_prediction_vector(self):
     points = [(1,5),(3,0),(5,6)]
     v1 = vector(points[1],points[0])
     v2 = vector(points[1],points[2])
     angle = vectorAngle(v1,v2)
     c= Corner(points,1,imgtime=1)
     c1= Corner(points,1,imgtime=1)
     ans= c.get_prediction_vector(True, c1)
     self.assertAlmostEqual(ans[0],v1[0],6)
     self.assertAlmostEqual(ans[1],v1[1],6)
     ans= c.get_prediction_vector(False, c1)
     self.assertAlmostEqual(ans[0],v2[0],6)
     self.assertAlmostEqual(ans[1],v2[1],6)
Exemplo n.º 4
0
 def test_append_candidates(self):
     c = Corner([(0,0),(0,1),(1,1)], 1, (0,0),imgtime=1)
     conts = [(1,1),(2,2),(3,2),(2,3)]
     data=[conts,list(reversed(conts)),\
           list(reversed(conts[2:]+conts[:2])),\
           conts[2:]+conts[:2]]
     cr= (0,0,5,6)
     for i in range(4):            
         result = [] 
         c._append_candidates_from_conts(cr, result, data[i],0)
         self.assertTrue(len(result)==1,result)
         cor = result[0]
         self.assertTrue(cor.p==(2,3) and cor.prev==(3,2),(cor.p,cor.prev))
Exemplo n.º 5
0
 def test_append_candidates(self):
     c = Corner([(0, 0), (0, 1), (1, 1)], 1, (0, 0), imgtime=1)
     conts = [(1, 1), (2, 2), (3, 2), (2, 3)]
     data=[conts,list(reversed(conts)),\
           list(reversed(conts[2:]+conts[:2])),\
           conts[2:]+conts[:2]]
     cr = (0, 0, 5, 6)
     for i in range(4):
         result = []
         c._append_candidates_from_conts(cr, result, data[i], 0)
         self.assertTrue(len(result) == 1, result)
         cor = result[0]
         self.assertTrue(cor.p == (2, 3) and cor.prev == (3, 2),
                         (cor.p, cor.prev))
Exemplo n.º 6
0
    def _predict_neighbours(self, a, b, new_corners):
        if a == b + 1 or (b == 3 and a == 0):
            a, b = b, a
        na = (a + 3) % 4
        v1 = new_corners[na].get_prediction_vector(False, self.corners[na])
        nb = (b + 1) % 4
        v2 = new_corners[nb].get_prediction_vector(True, self.corners[nb])
        ap = add(new_corners[na].p, v1)
        bp = add(new_corners[nb].p, v2)

        cor_a = Corner([new_corners[na].p, ap, bp], 1,
                                imgtime=new_corners[na].time)
        cor_b = Corner([ap, bp, new_corners[nb].p], 1,
                                imgtime=new_corners[na].time)
        cor_b.is_predicted = cor_a.is_predicted = True

        cor_a.compute_change(self.corners[a], self.image)
        cor_b.compute_change(self.corners[b], self.image)
        if cor_a.different:
            if cor_b.different: return
            else:
                new_corners[b] = cor_b
                self._predict_one(a, new_corners)
        else:
            new_corners[a] = cor_a
            if cor_b.different:
                self._predict_one(b, new_corners)
            else:
                new_corners[b] = cor_b
Exemplo n.º 7
0
    def _predict_from_one(self, a, new_corners):
        vec = new_corners[a].get_prediction_vector(True, self.corners[a])
        pa = (a + 3) % 4
        p1 = add(new_corners[a].p, vec)
        vec = (-vec[0],-vec[1])
        vec=rotateVec(vec, self.corners[pa].angle)
        pp1= add(p1,vec)
        cor_p = Corner([pp1, p1, new_corners[a].p], 1,
                                 imgtime=new_corners[a].time)

        vec = new_corners[a].get_prediction_vector(False, self.corners[a])
        na = (a + 1) % 4
        p2 = add(new_corners[a].p, vec)
        vec = (-vec[0],-vec[1])
        vec=rotateVec(vec, self.corners[na].angle)
        np2= add(p1,vec)
        cor_n = Corner([new_corners[a].p, p2, np2], 1,
                                 imgtime=new_corners[a].time)
        cor_p.is_predicted = cor_n.is_predicted = True
        cor_p.compute_change(self.corners[pa], self.image)
        cor_n.compute_change(self.corners[na], self.image)
        da= (a + 2) % 4
        if cor_p.different:
            if cor_n.different: return
            else:
                new_corners[na] = cor_n
                self._predict_neighbours(pa, da, new_corners)
        else:
            new_corners[pa] = cor_p
            if cor_n.different:
                self._predict_neighbours(na, da, new_corners)
            else:
                new_corners[na] = cor_n
                self._predict_one(da, new_corners)
Exemplo n.º 8
0
 def setUp(self):
     size = 100
     offset = 20
     so = size - offset
     angle = 45
     move = (0, 0)
     scale = 0.5
     center = (size / 2, size / 2)
     time = 1
     points = [(offset, offset), (so, offset), (so, so), (offset, so)]
     img = cv.CreateImage((size, size), 8, 1)
     cv.SetZero(img)
     points = rotate_points(points, center, angle)
     corners = [Corner(points, 0), Corner(points, 1), Corner(points, 2), Corner(points, 3)]
     npoints = rotate_points(points, center, 3)
     npoints = map(lambda x:add((2, 2), int_point(x)), npoints)
     npoints = standarize_contours(npoints)
     ncorners = [Corner(npoints, 0,imgtime=1), Corner(npoints, 1,imgtime=1), Corner(npoints, 2,imgtime=1), Corner(npoints, 3,imgtime=1)]
     for i, cor in enumerate(ncorners):
         cor.compute_change(corners[i])
     
     
     
             
     self.points = npoints
     self.old_corners = corners
     self.corners = ncorners
     self.size = size
     cv.AddS(img, 255, img)
     self.draw_img = img
     self.timg = cv.CloneImage(img)
     self.tmp_img = cv.CloneImage(img)
     pass
Exemplo n.º 9
0
    def getDuplicateSwayze(self):
        query = """
		  select url, count(*)
		  from swayze
		  group by url
		  having count(*) > 1
		"""

        corner = Corner()
        corner.cur.execute(query)
Exemplo n.º 10
0
def stats(points):
    global prop_max, prop_min, angle_max, angle_min, rot_max, angle_diff_max, angle_diff_min
    a = length(vector(points[0], points[1]))
    b = length(vector(points[1], points[2]))
    c = length(vector(points[2], points[3]))
    d = length(vector(points[3], points[0]))
    if a > c:
        a, c = c, a
    if b > d:
        b, d = d, b
    if c == 0.0:
        pass
    else:
        # print "sides a/c:", a/c
        if (c - a) / c > prop_max:
            prop_max = (c - a) / c
        if (c - a) / c < prop_min:
            prop_min = (c - a) / c
    if d == 0.0:
        pass
    else:
        # print "sides b/d", b/d
        if (d - b) / d > prop_max:
            prop_max = (d - b) / d
        if (d - b) / d < prop_min:
            prop_min = (d - b) / d
    corners = Corner.get_corners(points)
    for cor in corners:
        if cor.angle < angle_min:
            angle_min = cor.angle
        if cor.angle > angle_max:
            angle_max = cor.angle
        if cor.rotation > rot_max:
            rot_max = cor.rotation
    a, b, c, d = [c.angle for c in corners]
    if a > c:
        a, c = c, a
    if b > d:
        b, d = d, b
    if (c - a) / c > angle_diff_max:
        angle_diff_max = (c - a) / c
    if (c - a) / c < angle_diff_min:
        angle_diff_min = (c - a) / c
    # print "angle diff a/c", (c-a)/c
    if (d - b) / d > angle_diff_max:
        angle_diff_max = (d - b) / d
    if (d - b) / d < angle_diff_min:
        angle_diff_min = (d - b) / d
    # print "angle diff b/d", (d-b)/d
    if angle_diff_max > 0.90:
        pass
Exemplo n.º 11
0
 def setup_corners(self):
     self.corners = []
     for row in range(self.max_row + 1):
         for column in range(self.max_col + 1):
             lines = []
             if column > 0:
                 lines.append(self.horizontal_walls[row][column - 1])
             if row > 0:
                 lines.append(self.vertical_walls[row - 1][column])
             if column < self.max_col:
                 lines.append(self.horizontal_walls[row][column])
             if row < self.max_row:
                 lines.append(self.vertical_walls[row][column])
             self.corners.append(Corner(row, column, lines))
Exemplo n.º 12
0
    def _light_block(self,
                     x,
                     y,
                     ox=0,
                     oy=0,
                     intensity=ubyte(255),
                     is_corner=False,
                     iteration=0):
        """
        Recursive light function

        x, y - position
        ox, oy - offset by x and y
        intensity - light instensity from 0 to 255
        is_corner - is this a top-left, top-right, bottom-left or bottom-right
                    corner of a light layer
        iteration - iteration number to avoid endless recursion
        """

        if iteration >= LIGHT_RADIUS or intensity < 26:
            raise Exception  # Out of light range

        x += ox
        y += oy

        self.world.set_light(x, y, intensity)

        dropoff = 0.55 if self.world.get_light_source(
            self.world.get_block(x, y)) == 0 else 0.99
        #dropoff = self.world.blocks_data.get(getblock(x, y), {}).get('light_dropoff')

        if (ox != 0 or oy != 0) and is_corner:
            # One of corners
            for offset in corner_iters[Corner((ox, oy))]:
                self._light_offset(x, y, offset, dropoff, intensity, iteration,
                                   is_corner and all(offset))
        elif ox != 0 or oy != 0:
            # One of sides
            self._light_offset(x, y, (ox, oy), dropoff, intensity, iteration)
        else:
            # Initial point
            for corner in CORNERS:
                for offset in corner_iters[corner]:
                    self._light_offset(x, y, offset, dropoff, intensity,
                                       iteration, True)
            for side in SIDES:
                for offset in corner_iters[side]:
                    self._light_offset(x, y, offset, dropoff, intensity,
                                       iteration)
Exemplo n.º 13
0
    def make_graph(self):

        for h_line in self.horizon_lines:
            coeff_x, coeff_y, bias = h_line.eq
            for v_line in self.vertical_lines:
                cx, cy, b = v_line.eq
                A = np.array([[coeff_x, coeff_y], [cx, cy]])
                B = np.array([bias, b])
                root = Corner(np.linalg.solve(A, B).astype(int))
                h_line.corners.append(root)
                v_line.corners.append(root)
                self.corners.append(root)

        for line in self.lines:
            line.line_link()

        self.walker = Walker(self.corners)
Exemplo n.º 14
0
 def _prepare_corners(self, npoints):
     L = len(npoints)
     ncorners = []
     for i, point in enumerate(npoints):
         prev = vector(point, npoints[(i - 1 + L) % L])
         next = vector(point, npoints[(i + 1) % L])
         #prev= add(point,prev,3.0/random.randint(3,int(length(prev))))
         #next = add(point,next, 3.0/random.randint(3,int(length(next))))
         #prev=(int(prev[0])+random.randint(-1,1),int(prev[1])+random.randint(-1,1))
         #next = (int(next[0]+random.randint(-1,1)),int(next[1])+random.randint(-1,1))
         prev = add(point, prev, 0.3)
         next = add(point, next, 0.3)
         prev = (int(prev[0]), int(prev[1]))
         next = (int(next[0]), int(next[1]))
         
         ncorners.append(Corner([prev, point, next], 1,imgtime=2))
     return ncorners
Exemplo n.º 15
0
    def _unlight_block(self,
                       x,
                       y,
                       ix,
                       iy,
                       unlit_blocks,
                       ox=0,
                       oy=0,
                       is_corner=False):
        """
        Recursive light deletion function

        x, y - position
        ix, iy - initial position
        unlit_blocks - list of blocks which light was deleted (to relight them)
        ox, oy - offset by x and y
        is_corner - is this a top-left, top-right, bottom-left or bottom-right
                    corner of a light layer
        """
        if (abs(x - ix) >= LIGHT_RADIUS or abs(y - iy) >= LIGHT_RADIUS
                or (x, y) in unlit_blocks):
            raise Exception

        if (ox != 0 or oy != 0) and is_corner:
            # One of corners
            for offset in corner_iters[Corner((ox, oy))]:
                self._unlight_offset(x, y, ix, iy, offset, unlit_blocks,
                                     is_corner and all(offset))
        elif ox != 0 or oy != 0:
            # One of sides
            self._unlight_offset(x, y, ix, iy, (ox, oy), unlit_blocks)
        else:
            # Initial point
            for corner in CORNERS:
                for offset in corner_iters[corner]:
                    self._unlight_offset(x, y, ix, iy, offset, unlit_blocks,
                                         True)
            for side in SIDES:
                for offset in corner_iters[side]:
                    self._unlight_offset(x, y, ix, iy, offset, unlit_blocks)
        #"""

        self.world.set_light(x, y, 0)

        unlit_blocks.add((x, y))
Exemplo n.º 16
0
 def _predict(self,npoints):
     cv.FillConvexPoly(self.draw_img, npoints, (0,0,0))
     corners = Corner.get_corners(npoints)
     tcorners = list(corners)
     for i,cor in enumerate(corners):
         print cor.p
         if not(0<=cor.p[0]<self.size and 0<=cor.p[1]<self.size):
             tcorners[i]=None
     
     CP = CornerPredictor(self.corners, 1, self.tmp_img, self.timg, self.draw_img)
     print "predicting....",tcorners
     ncorners = CP.predict_corners(tcorners)
     print 'done'
     for i,cor in enumerate(ncorners):
         v=vector(corners[i].p,cor.p)
         print length(v), cor.toString()
         self.assertTrue(length(v)<5,"Wrong prediction!Corner: %d \
         Expected: (%d,%d) received (%d,%d)" \
         %(i,corners[i].p[0],corners[i].p[1],cor.p[0],cor.p[1]))
     print ncorners  
Exemplo n.º 17
0
 def test_validate_corners(self):
     print self.corners
     print self.old_corners
     ncorners = self._prepare_corners(self.points)
     c= ncorners[0]
     prev = add(c.prev,(2,0))
     p = add(c.p,(1,1))
     next= add(c.next,(2,0))
     ncorners[0] = Corner([prev,p,next],1,imgtime=2)
     ncorners[0].compute_change(self.corners[0])
     res = list(ncorners)
     res[0]=None
     print ncorners
     for i,cor in enumerate(ncorners):
         cor.draw(self.draw_img)
         cor.compute_change(self.corners[i])
     db.show(self.draw_img,"main")
     CP = CornerPredictor(self.corners, 1, self.tmp_img, self.timg, self.draw_img)
     CP.validate_corners(ncorners)
     self.assertEqual(ncorners,res,
                      "First corner is invalid:"+ncorners.__repr__())
Exemplo n.º 18
0
def stats(points):
    global prop_max, prop_min, angle_max, angle_min, rot_max, angle_diff_max, angle_diff_min
    a = length(vector(points[0], points[1]))
    b = length(vector(points[1], points[2]))
    c = length(vector(points[2], points[3]))
    d = length(vector(points[3], points[0]))
    if a > c:
        a, c = c, a
    if b > d:
        b, d = d, b
    if c == 0.0:
        pass
    else:
        #print "sides a/c:", a/c
        if (c - a) / c > prop_max: prop_max = (c - a) / c
        if (c - a) / c < prop_min: prop_min = (c - a) / c
    if d == 0.0:
        pass
    else:
        #print "sides b/d", b/d
        if (d - b) / d > prop_max: prop_max = (d - b) / d
        if (d - b) / d < prop_min: prop_min = (d - b) / d
    corners = Corner.get_corners(points)
    for cor in corners:
        if cor.angle < angle_min: angle_min = cor.angle
        if cor.angle > angle_max: angle_max = cor.angle
        if cor.rotation > rot_max: rot_max = cor.rotation
    a, b, c, d = [c.angle for c in corners]
    if a > c:
        a, c = c, a
    if b > d:
        b, d = d, b
    if (c - a) / c > angle_diff_max: angle_diff_max = (c - a) / c
    if (c - a) / c < angle_diff_min: angle_diff_min = (c - a) / c
    #print "angle diff a/c", (c-a)/c
    if (d - b) / d > angle_diff_max: angle_diff_max = (d - b) / d
    if (d - b) / d < angle_diff_min: angle_diff_min = (d - b) / d
    #print "angle diff b/d", (d-b)/d
    if angle_diff_max > 0.90:
        pass
Exemplo n.º 19
0
    def set_new_position(self, points_or_corners, offset=True, scale=1):
        '''
        Sets new position for this marker using points (in order)
        @param points_or_corners: list of points or corners
        @param offset: if true, image ROI is checked and points are shifted
        '''
        if len(points_or_corners) > 0 and type(points_or_corners[0]) == tuple:
            self.predicted = -1
            points = points_or_corners
            img = self.m_d.img
            (x, y, _, _) = rect = cv.GetImageROI(img)
            if offset and (x, y) <> (0, 0):
                points = map(lambda z: add((x, y), z), points)
            cv.ResetImageROI(img)
            crit = (cv.CV_TERMCRIT_EPS + cv.CV_TERMCRIT_ITER, 30, 0.1)
            if (scale > 1):
                points = cv.FindCornerSubPix(self.m_d.gray_img, points,
                                             (scale * 2 + 4, scale * 2 + 4),
                                             (-1, -1), crit)
            else:
                points = cv.FindCornerSubPix(self.m_d.gray_img, points, (3, 3),
                                             (-1, -1), crit)
            ncorners = Corner.get_corners(points, self.m_d.time)
            if len(self.corners) <> 0:
                for i, cor in enumerate(ncorners):
                    cor.compute_change(self.corners[i])
            cv.SetImageROI(img, rect)
        else:
            ncorners = points_or_corners
            self.predicted += len(filter(lambda x: x.is_predicted, ncorners))
        for i, c in enumerate(ncorners):
            c.black_inside = self.black_inside
#            if len(self.corners)==4:
#                if dist_points(c.p, self.corners[i].p)<4:
#                    c.p=self.corners[i].p
        self.corners = ncorners

        self.area = abs(cv.ContourArea(self.points))
        self.last_seen = self.m_d.time
        self.model_view = None
Exemplo n.º 20
0
    def set_new_position(self, points_or_corners, offset=True, scale=1):
        '''
        Sets new position for this marker using points (in order)
        @param points_or_corners: list of points or corners
        @param offset: if true, image ROI is checked and points are shifted
        '''
        if len(points_or_corners) > 0 and type(points_or_corners[0]) == tuple:
            self.predicted = -1
            points = points_or_corners
            img = self.m_d.img
            (x, y, _, _) = rect = cv.GetImageROI(img)
            if offset and (x, y) <> (0, 0):
                points = map(lambda z: add((x, y), z), points)
            cv.ResetImageROI(img)
            crit = (cv.CV_TERMCRIT_EPS + cv.CV_TERMCRIT_ITER, 30, 0.1)
            if (scale > 1):
                points = cv.FindCornerSubPix(self.m_d.gray_img, points, (scale * 2 + 4, scale * 2 + 4), (-1, -1), crit)
            else:
                points = cv.FindCornerSubPix(self.m_d.gray_img, points, (3, 3), (-1, -1), crit)
            ncorners = Corner.get_corners(points, self.m_d.time)
            if len(self.corners) <> 0:
                for i, cor in enumerate(ncorners):
                    cor.compute_change(self.corners[i])
            cv.SetImageROI(img, rect)
        else:
            ncorners = points_or_corners
            self.predicted += len(filter(lambda x:x.is_predicted, ncorners))
        for i,c in enumerate(ncorners):
            c.black_inside=self.black_inside
#            if len(self.corners)==4:
#                if dist_points(c.p, self.corners[i].p)<4:
#                    c.p=self.corners[i].p
        self.corners = ncorners

        self.area = abs(cv.ContourArea(self.points))
        self.last_seen = self.m_d.time
        self.model_view = None
Exemplo n.º 21
0
    def getRandSwayzeColors(self):
        # return ['http://home.comcast.net/~patrick.swayze/patrickcloseup.jpg', "#123456", "#223344", "445566"]
        corner = Corner()

        query = """
		SELECT swayze_id FROM colors WHERE fake = 0
		ORDER BY RAND()
		LIMIT 1
		"""

        corner.cur.execute(query)

        for row in corner.cur:
            swayze_id = row[0]

        query = "SELECT swayze.url, colors.color FROM swayze INNER JOIN colors ON swayze.id = colors.swayze_id WHERE swayze_id = " + str(
            swayze_id)

        corner.cur.execute(query)
        colors = []
        for row in corner.cur:
            url = row[0]
            colors.append(row[1])
        return [url, colors]
Exemplo n.º 22
0
#!/usr/bin/env python
from SwayzeBaby import SwayzeBaby
from corner import Corner
import urllib 

swayze = SwayzeBaby()
corner = Corner()
swaykeys = ["",  "Skatetown, U.S.A.", "The Outsiders","Uncommon Valor","Grandview, U.S.A. ","Red Dawn ","Youngblood ","Dirty Dancing ","Steel Dawn ","Tiger Warsaw ","Road House ","Next of Kin ","Ghost ","Point Break ","City of Joy ","Father Hood ","Tall Tale ","To Wong Foo Thanks for Everything, Julie Newmar ","Three Wishes ","Black Dog ","Letters from a Killer ","Forever Lulu ","Green Dragon ","Donnie Darko ","Waking Up in Reno ","One Last Dance ","11:14 ","Dirty Dancing: Havana Nights ","Keeping Mum ","The Fox and the Hound 2 ","Jump! ","Christmas in Wonderland ","Powder Blue "]
# swaykeys = ["Letters from a Killer ","Forever Lulu ","Green Dragon ","Donnie Darko ","Waking Up in Reno ","One Last Dance ","11:14 ","Dirty Dancing: Havana Nights ","Keeping Mum ","The Fox and the Hound 2 ","Jump! ","Christmas in Wonderland ","Powder Blue "]
# swaykeys = [""]
for keyword in swaykeys:
	query = "swayze " + keyword
	results = swayze.fetchAllSwayze(query)
	for key, value in results.iteritems():
		url = key
		title = value
		# url = urllib.unquote(url)
		try:
			title = urllib.unquote(title)
			title = title.encode('ascii', 'ignore')
			title = title.replace('"', '\\"')
			title = title.replace("'", "\\'")
			query = "INSERT INTO swayze (url, title) VALUES (%s, %s)"
			corner.cur.execute(query, (url, title ) )
		except(UnicodeEncodeError):
			continue

Exemplo n.º 23
0
#!/usr/bin/env python
import pymysql
from SwayzeBaby import SwayzeBaby
from corner import Corner
#Here's a counter to count how many images we've processed
x = 1

#instantiate our objects
swayze = SwayzeBaby()
selector = Corner()
insertor = Corner()
startId = 0
selector.query("SELECT id, url FROM swayze where fake=0 AND id >= " +
               repr(startId))
for row in selector.cur:
    swayze_id = row[0]
    url = row[1]
    colors = swayze.getColorScheme(url)
    if colors is None:
        print("f**k that image")
    else:
        for color in colors:
            query = "INSERT INTO colors (swayze_id, color) VALUES (%s, %s)"
            insertor.cur.execute(query, (swayze_id, color))
            print("Processed " + repr(x / 3) + " images. Last printed: " +
                  repr(swayze_id))
            x += 1
Exemplo n.º 24
0


if __name__ == '__main__':
    img = cv.CreateImage((100, 100), 8, 1)
    a = (50, -10)
    b = (85, 50)
    c = (50, 90)
    d = (5, 50)
    cv.FillConvexPoly(img, [a, b, c, d], (255, 255, 255))
    temp = 'temp'
    cv.NamedWindow(temp)

    oa, ob, oc, od = (48, -8), (80, 50), (48, 88), (0, 50)
    points = [oa, ob, oc, od]
    corners = [Corner(points, 0), Corner(points, 1), Corner(points, 2), Corner(points, 3)]
    CP = CornerPredictor(corners, 50, img)

    cv.PolyLine(img, [[oa, ob, oc, od]], 1, (150, 100, 100))

    dimg = cv.CreateImage((200, 200), 8, 1)
    cv.PyrUp(img, dimg)
    cv.ShowImage(temp, dimg)
    cv.WaitKey(10000)