Example #1
2
def SplitCards(img):
    global NUM
    global START_NUM
    global CARD_NAME
    global MY_CARDS
    global SAVE_IMG
    img_crop = img[605:2105, 60:1830]
    img_crop = cv2.resize(img_crop, (0, 0), fx=0.5, fy=0.5)

    #cv2.imshow("crop", img_crop)

    H = img_crop.shape[0] / 4
    W = img_crop.shape[1] / 3
    for i in range(3):
        for j in range(4):
            D = 5
            icard = img_crop[((j * H) + D):(((j + 1) * H) - D),
                             ((i * W) + D):(((i + 1) * W) - D)]
            cv2.imshow(str(NUM), icard)
            cv2.moveWindow(str(NUM), 200, 600)
            CARD_NAME = 'card%03d' % (NUM)
            if (SAVE_IMG):
                cv2.imwrite("./DataBase/%s.jpg" % (CARD_NAME), icard)
            if (NUM >= START_NUM):
                MY_CARDS[CARD_NAME] = {}
                UserInput()
            NUM += 1
            print "Next..."
            cv2.destroyAllWindows()
Example #2
0
def main():
    img = cv2.imread("text.bmp", cv2.CV_LOAD_IMAGE_COLOR)  # Read image file
    img = cv2.GaussianBlur(img, (3, 3), 0)
    img = cv2.Laplacian(img, 0)
    cv2.threshold(img, 70, 255, cv2.THRESH_BINARY, img)
    kernel = np.ones((4, 6), np.uint8)
    img = cv2.dilate(img, kernel, iterations = 1)
    img = cv2.erode(img, kernel, iterations = 1)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    contours, hierarchy = cv2.findContours(gray, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

    color = (255, 255, 255)
    drawing = np.zeros(img.shape, np.uint8)
    for cnt in contours:
        x, y, w, h = cv2.boundingRect(cnt)
        cv2.rectangle(drawing, (x, y), (x + w, y + h), color)

    drawing = cv2.cvtColor(drawing, cv2.COLOR_RGB2GRAY)
    h, w = img.shape[:2]
    outpImg = np.zeros((h-2, w-2), np.uint8)
    cv2.floodFill(outpImg, drawing, (0, 0), color)

    cv2.threshold(outpImg, 254, 255, cv2.THRESH_BINARY_INV, outpImg)

    cv2.imwrite("outputTask3.jpg", outpImg)
    cv2.namedWindow('Display Window', cv2.WINDOW_NORMAL)        # Create window for display
    cv2.imshow('Display Window', outpImg)         # Show image in the window
    cv2.moveWindow('Display Window', 1, 1)
    print ("size of image: ", img.shape)      # print size of image
    cv2.waitKey(0)                           # Wait for keystroke
    cv2.destroyAllWindows()                  # Destroy all windows
Example #3
0
def main():
    files = glob.glob("./scans/*.jpg")
    files += glob.glob("./scans/*.jpeg")
    for f in files:
        reset_stats()
        print "Processing: " + f.split("/")[len(f.split("/")) - 1]

        schedule = Schedule()
        schedule.load_data()
        if schedule.get_has_schedule():
            scan_image(f, schedule)

            print "Sheet ok? ",
            while True:
                cv2.imshow("image", cv2.resize(img, (446, 578)))
                cv2.moveWindow("image", 0, 0)
                # user_in = raw_input()
                key = cv2.waitKey(-1)
                if key == ord("y"):
                    print "Sheet ok... Dumping data"
                    dump_stats()
                    os.remove(f)
                    break
                elif key == ord("n"):
                    print "Marking to redo"
                    #os.rename(f, "./scans/redo/" + f.split("/")[len(f.split("/")) - 1])
                    break
                elif key == ord("q"):
                    exit(0)
                else:
                    continue
            cv2.destroyAllWindows()
        else:
            print "Unable to load schedule... Aborting"
Example #4
0
	def alignCamera(self):
		
		# Capture frame
		_, frame = self.cap.read()

		# self.findColor(frame)

		# Prepare frame with Gaussian blurring, HSV conversion, and Canny edge detection
		preppedFrame = self.prepFrame(frame)

		# Find the all contours 
		contours, hierarchy = cv2.findContours(preppedFrame.copy(), cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)

		# If contours exist
		if contours:

			# Define bounding box
			maxContour, maxRectangle, maxContourArea = self.detectBoundary(frame, contours)

			if not maxRectangle and not self.shapeSets:
				
				self.flipColor()

		if self.mode == 'debug':

			# Display final image
			cv2.namedWindow('Shape Detection', cv2.WINDOW_NORMAL)
			cv2.imshow('Shape Detection', frame)
			cv2.moveWindow('Shape Detection', 360, 0)

		cv2.waitKey(1)
Example #5
0
def get_info_part(li):
    li_info = li.get_information_part()
    if li_info is not None:
        li_info = cv2.resize(li_info, (info_size, info_size))
        cv2.imshow('li_info', li_info)
        cv2.moveWindow('li_info', int(1280*FRAME_SIZE_FACTOR), 0)
    return li_info
Example #6
0
def show_img(data, suffix, show):
    global wnd_x
    global wnd_y

    if data == None:
        return

    image = data.astype(np.uint8)

    if image.shape[0] == 6:
        img = image.transpose(1,2,0)
        img1 = img[:,:,:3]
        img2 = img[:,:,3:]
    else:
        img1 = image[0]
        img2 = image[1]

    filename = 'img-1-'+suffix+'.jpg'
    cv2.imwrite(filename, img1)
    if show:
       cv2.imshow("IMG 1", img1)
       cv2.moveWindow("IMG 1", wnd_x, wnd_y)

    filename = 'img-2-'+suffix+'.jpg'
    cv2.imwrite(filename, img2)
    if show:
       cv2.imshow("IMG 2", img2)
       wnd_x+=300
       cv2.moveWindow("IMG 2",  wnd_x, wnd_y)
       wnd_x=10 
       wnd_y+=300
Example #7
0
def get_start_points(image):
    window = cv2.namedWindow(MAZE_NAME, cv2.WINDOW_NORMAL)
    cv2.resizeWindow(MAZE_NAME, 900,900)
    cv2.imshow(MAZE_NAME,image)
    cv2.moveWindow(MAZE_NAME,100,100)
    imageProcessor = ImageProcessor(image)
    start_x,start_y = imageProcessor.getDefaultStart(image)
    end_x, end_y = imageProcessor.getDefaultEnd(image)
    print("Please \'A\' to use default start and end points, or press \'S\' to choose your own)")
    key = cv2.waitKey(2000)
    print key
    if key == ord('a') or key == -1:
        print("Using Default Start and End Points")
        imageProcessor = ImageProcessor(image)
        start_x,start_y = imageProcessor.getDefaultStart(image)
        end_x, end_y = imageProcessor.getDefaultEnd(image)
        print("Start Point: {0}, End Point: {1}".format((start_x,start_y),(end_x,end_y)))
    elif key == ord ('s'):
        print("Please select a start point")
        start_x,start_y = get_user_selected_point(image)
        print ("Start Point: {0}, please select an end point".format((start_x,start_y)))
        end_x,end_y = get_user_selected_point(image)
        print("End Pont: {0}".format((end_x,end_y)))
    cv2.destroyAllWindows()
    return start_x,start_y,end_x,end_y
def find_hottest_points(cv_image):
  
  clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(3,3))
  #gray = clahe.apply(img)
  gray = clahe.apply(cv_image)
  gray = cv2.GaussianBlur (gray, (21,21), 0)

  min_thresh = cv2.threshold(gray, min_th, 255, cv2.THRESH_BINARY)[1]
  max_thresh = cv2.threshold(gray, max_th, 255, cv2.THRESH_BINARY_INV)[1]

  thresh = cv2.bitwise_and(min_thresh, max_thresh)

  thresh = cv2.dilate(thresh, None, iterations = 2)
  (cnts, _) = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
    cv2.CHAIN_APPROX_SIMPLE)

  for c in cnts:
    if cv2.contourArea(c) > min_area and cv2.contourArea(c) < max_area:
      
      (x,y,w,h) = cv2.boundingRect(c)
#      cv2.rectangle(cv_image, (x, y), (x+w, y+h), (0, 255, 0), 2)
      cv2.rectangle(cv_image, (x, y), (x+w, y+h), 0, 2)
      continue


  cv2.imshow("region_detector", cv_image)
  cv2.moveWindow("region_detector",900,0)
  cv2.imshow("band_threshold_image", thresh)
  cv2.moveWindow("band_threshold_image",900,400)
  cv2.waitKey(1)
Example #9
0
  def plot(self):
    # plot current sdf
    # curr_obs_inds = self.sdf.to_inds(self.curr_obs[:,0], self.curr_obs[:,1])
    # print 'obs inds', curr_obs_inds
    # print 'sdf\n', self.sdf.data()

    cmap = np.zeros((256, 3), dtype='uint8')
    cmap[:128,0] = 255
    cmap[:128,1] = np.linspace(0, 255, 128).astype(int)
    cmap[:128,2] = np.linspace(0, 255, 128).astype(int)
    cmap[128:,0] = np.linspace(255, 0, 128).astype(int)
    cmap[128:,1] = np.linspace(255, 0, 128).astype(int)
    cmap[128:,2] = 255

    # cmap[:,0] = range(256)
    # cmap[:,2] = range(256)[::-1]
    colors = np.clip((self.sdf.to_image_fmt()*100 + 128), 0, 255).astype(int)
    flatland.show_2d_image(cmap[colors], "sdf")
    cv2.moveWindow("sdf", 550, 0)

    # plot flow field
    # print 'curr flow\n', self.curr_u.data()
    self.curr_u.show_as_vector_field("u")
    cv2.moveWindow("u", 0, 600)

    total, costs = solvers._eval_cost(PIXEL_AREA, self.curr_obs, self.prev_sdf, self.sdf, self.curr_u, ignore_obs=self.curr_obs is None, return_full=True)
    print 'total cost', total
    print 'individual costs', costs
Example #10
0
def setupWindow():
    filename = getUserSelectedImage()
    imageProcessor = ImageProcessor(cv2.imread(filename,0))
    colourImage = cv2.imread(filename,1)
    image = imageProcessor.getThresholdedImage(False)
    granularity = imageProcessor.get_granularity(image, 100)
    print("Granularity: {0}".format(granularity))
    start_x,start_y,end_x,end_y = get_start_points(image)
    image = imageProcessor.encloseMaze(image)
    pg = PolicyGenerator(image)
    rows,cols = pg.get_critical_grid()
    graph,mapping = pg.get_reduced_graph([rows,cols])
    policy = pg.generate_policy((end_x,end_y))
    solution = solve_using_policy(policy,(start_x,start_y),(end_x,end_y))
    imageProcessor.draw_policy(colourImage,policy)
    imageProcessor.mark_point((end_x,end_y),3,(255,0,0),colourImage)
    #cv2.imshow(MAZE_NAME,policy_image)
    mazerunner = MazeSolver(image,granularity)
    #solution = mazerunner.solveMaze(start_x,start_y,end_x,end_y)
    if(not solution):
        cv2.imshow(MAZE_NAME,image)
    else:
        solvedImage = draw_solution(solution, colourImage)
        solvedImage = imageProcessor.mark_point((start_x,start_y),3,(255,0,0),solvedImage)
        window = cv2.namedWindow("Solved Image", cv2.WINDOW_NORMAL)
        cv2.resizeWindow("Solved Image", 900,900)
        cv2.moveWindow("Solved Image",100,100)
        cv2.imshow("Solved Image",solvedImage)
    print("Press any key to exit")
    cv2.waitKey(0)
    cv2.destroyAllWindows
Example #11
0
def liczenie(crop_img):

    while(True):
        #crop_img = cv2.imread("6.png",1)
        #gray = cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY)
        lower_white = np.array([0,0,150], dtype=np.uint8)
        upper_white = np.array([200,100,255], dtype=np.uint8)
        hsv = cv2.cvtColor(crop_img, cv2.COLOR_BGR2HSV)
        white = cv2.inRange(hsv, lower_white, upper_white)
        #img = cv2.erode(white, None, 1)
        #img1 = cv2.dilate(img,None,1)
        #mask = cv2.dilate(white,None,1)
        mask=white
        # Bitwise-AND mask and original image
        #res = cv2.bitwise_and(crop, crop, mask= mask)
        cv2.imshow('Kostka', mask)
        cv2.moveWindow('Kostka', 2200, 0)
        #image = cv2.Canny(res,50,50)
        #ret,thresh = cv2.threshold(imgg,200,200,0)

        contours ,  hierarchy  =  cv2 . findContours ( mask , cv2.RETR_TREE , cv2.CHAIN_APPROX_SIMPLE )
        #cv2.drawContours(crop, contours, -1, (0,255,0), 1)
        liczba=0
        for i in contours[1:]:
            (x,y),radius = cv2.minEnclosingCircle(i)
            center = (int(x),int(y))
            radius = int(radius)
            #print(radius)
            #cv2.circle(crop_img,center,radius,(0,255,0),2)
            liczba=liczba+1

        #cv2.imshow("cropped", crop_img)
        #cv2.moveWindow('cropped', 1500, 0)
        return liczba
Example #12
0
def main():
    '''main function'''
    WIN_NAME = 'foobar'
    cv2.namedWindow(WIN_NAME)
    cv2.moveWindow(WIN_NAME, 50, 50)
    if len(sys.argv) > 1:   # has argument
        for ff in sys.argv[1:]:
            print('imread {}'.format(ff))
            img = cv2.imread(ff)
            cv2.imshow(WIN_NAME, img)
            cv2.waitKey(0)
    else:
        setting_fn = 'setting.json'
        if not myutil.isfile(setting_fn):
            print('[ERROR] cannot find setting: {}'.format(setting_fn))
            print('[INFO] may use argument')
        else:
            app_name = 'readim.py'
            data = myutil.read_setting(setting_fn)
            home = os.environ['HOME']
            picpath = home + '/' + data[app_name]['path']
            print(picpath)

        for img_file in data[app_name]['images']:
            pic1 = picpath + '/' + img_file
            print(pic1)
            if os.path.isfile(pic1):
                cv_test(pic1)
            else:
                print("file not found: {}".format(pic1))

    #cv_drawline()
    cv2.destroyAllWindows()
Example #13
0
def wykrywanie_kwadratowych_kostek():
    video_capture = cv2.VideoCapture(0)
    while True:
        ret, frame = video_capture.read()

        squares = find_squares(frame)
        x=0
        for sq in squares:
            print(sq)
            ix= np.min([sq[0][0],sq[1][0],sq[2][0],sq[3][0]])
            iy= np.min([sq[0][1],sq[1][1],sq[2][1],sq[3][1]])
            ix1=np.max([sq[0][0],sq[1][0],sq[2][0],sq[3][0]])
            iy1=np.max([sq[0][1],sq[1][1],sq[2][1],sq[3][1]])
            crop_img = frame[iy:iy1, ix:ix1]
            x = liczenie(crop_img)
        cv2.drawContours( frame, squares, -1, (0, 255, 0), 2 )

        cv2.putText(frame,str(x),(10,50), cv2.FONT_HERSHEY_DUPLEX, 1,(0,255,0),2,)
        # Display the resulting frame
        cv2.imshow('Wykrywanie liczby oczek na kostce',frame)
        cv2.moveWindow('Wykrywanie liczby oczek na kostce', 1500, 200)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    # When everything is done, release the capture
    video_capture.release()
    cv2.destroyAllWindows()
def runPdf(path, filename):
    pdf = PyPDF2.PdfFileReader(file(path+'/'+filename, "rb"))

    cv2.namedWindow('img')
    cv2.moveWindow('img', 0, 0)

    cv2.namedWindow('undistorted')
    cv2.moveWindow('undistorted', IMAGE_WIDTH, 0)

    for n in xrange(0, pdf.getNumPages()):
        img, structure_data = runPage(pdf, n)
        print '<page>'
        print structure_data
        print '</page>'
        cv2.imwrite(path+'/'+str(n)+'.jpg', img)

        key = cv2.waitKey(1)
        if(key == 113):
             quit()

    cv2.destroyAllWindows()

    convert = 'convert'
    if os.name == 'nt':
        convert = 'convert2' # avoid collision with windows' convert.exe
    param = [convert, path+'/*.jpg', path+'/merged.pdf']

    ret = subprocess.call(param,stdout=subprocess.PIPE)
 def run(self):
     i = 0
     while True:
         p = self.get_next_image_file()
         if p is None:
             break
         img = cv2.imread(p)
         if i >= self.skip:
             rect = self.label_file.readline()
             try:
                 box = map(lambda x: int(x), rect.split("\t"))
                 B = BoundingRegion(image_shape=img.shape, box=np.array(box))
             except:
                 try:
                     box = map(lambda x: int(x), rect.split(","))
                     B = BoundingRegion(image_shape=img.shape, box=np.array(box))
                 except:
                     print "No more bounding boxes!"
                     B = BoundingRegion()
         else:
             B = BoundingRegion()
         F = LabeledMovieFrame(internal_storage_method='jpg', compression_level=90)
         F.set_image(img)
         F.set_label(B)
         B.draw_box(img)
         cv2.imshow("image", img)
         cv2.moveWindow("image", 50, 50)
         cv2.waitKey(1)
         i += 1
         self.frame_collection.append(F)
     self.frame_collection.write_to_file(self.output_file)
Example #16
0
    def streaming(self):    
        ''' streaming '''

        # initialize the camera and grab a reference to the raw camera capture
        with picamera.PiCamera() as self.camera:
            self.camera.resolution = (int(640), int(480))
            fps = 15
            self.camera.framerate = fps
            # allow the camera to warmup
            time.sleep(0.1)

            # use the memory stream, may be faster?
            stream = io.BytesIO()
            self.update_camera_setting()

            ''' camera ''' 
            self.camera.start_recording(stream, format='bgr')

            # move the imshow window to centre
            cv2.namedWindow('stream')        # Create a named window
            cv2.moveWindow('stream', 0, 200)  # Move it to (40,30)

            # a default step size
            #focuser = focuser_class()
            while True:
                
                while True:
                    # reset stream for next frame
                    stream.seek(0)
                    stream.truncate()
                    # this delay has to be faster than generating
                    time.sleep(1/fps*0.1)

                    # return current frame, which is just a string
                    frame = stream.getvalue()
                    ''' ensure the size of package is right''' 
                    if len(frame) != 0:
                        break
                    else:
                        pass
                        
                
                # convert the stream string into np.arrry
                ncols, nrows = self.camera.resolution
                data = np.fromstring(frame, dtype=np.uint8).reshape(nrows, ncols, 3)
                # no need to decode (it is already bgr)
                self.image = data
                
                # place to run some filters, calculations
                for library in self.cv_libraries:
                    library()

                # show the frame
                cv2.imshow('stream', self.image)


                key = cv2.waitKey(1) & 0xFF
                # if the `x` key was pressed, break from the loop
                if key == ord("x"):
                    break
def init():
    rospy.init_node('perspective_correction_test')
    global CALC_TRANSFORM
    CALC_TRANSFORM = bool(rospy.get_param('~recalc'))
    print "recalculating transform?", CALC_TRANSFORM

    prev_time = rospy.get_time()

    cv2.namedWindow('Plain')
    cv2.moveWindow('Plain', 0, WINDOW_HEIGHT)

    cv2.namedWindow('Transformed')
    cv2.moveWindow('Transformed', EXPECTED_WIDTH, WINDOW_HEIGHT)

    rospy.loginfo("Now, move the chessboard into view to get a correct perspective transformation!")

    sub = rospy.Subscriber('usb_cam/image_raw', Image, callback )

    r = rospy.Rate(10)
    while not rospy.is_shutdown():
        global curImg
        if curImg != None:
            rospy.loginfo("processing image")
            dispImages(curImg)
            cv2.waitKey(30)

        r.sleep()
def main():
    #orig_imgs = ['photoset/cleaned/7,49/IMG_2654.JPG'] # Square, slight angle
    orig_imgs = glob.glob('photoset/cleaned/*/*.JPG')
    
    def img_onchange(x):
        filename = orig_imgs[cv2.getTrackbarPos('img', 'config')]
        img = cv2.imread(filename)
    
        print filename
        ret = get_white_rectangles(img, DEBUG=True)
        for r in ret:
            print r[1] # just the quads
    
    img_windows = ['img', 'blur', 'thresh', 'debug_display']
    for i in range(len(img_windows)):
        w = img_windows[i]
        cv2.resizeWindow(w, WINDOW_WIDTH, WINDOW_HEIGHT)
        cv2.moveWindow(w, WINDOW_X_OFFSET + WINDOW_WIDTH * i, WINDOW_Y_OFFSET)
        
    cv2.namedWindow('config', cv2.WINDOW_AUTOSIZE)
    cv2.resizeWindow('config', 600, 60)
    cv2.createTrackbar('img', 'config', 0, len(orig_imgs), img_onchange)
 
 
    img_onchange(0)
    cv2.waitKey()
Example #19
0
    def SelectArea(self, winName="Select an area", winPos=(400, 400)):
        """This method returns the corners of the selected area as: [(UpLeftcorner), (DownRightCorner)]."""
        # Reset the selected points.
        self.__ResetPoints()

        # Define the window name.
        self.__winName = winName

        # Update and show the input image.
        cv2.namedWindow(winName, cv2.WINDOW_AUTOSIZE)
        cv2.setMouseCallback(winName, self.__OnMouseOver)
        cv2.moveWindow(winName, winPos[0], winPos[1])
        self.__Update()

        # Main while condition
        while True:
            # Read the keyboard selection.
            ch = cv2.waitKey(1)

            if ch is 27 or ch is ord("q"):
                cv2.destroyWindow(winName)
                return None, False
            elif ch is 13 or ch is 32:
                corners = self.__SetCorners()
                if corners is None:
                    continue
                cv2.destroyWindow(winName)
                return corners, True
Example #20
0
def main():
    
    rospy.init_node(node_name) # check to see if launch file remaps this
    try:
        cv2.namedWindow(win1_name, flags=cv2.cv.WINDOW_NORMAL) #see if flag is necessary
        # cv2.NamedWindow(win2_name, flags=WINDOW_NORMAL)
        cv2.moveWindow(win1_name,200,0)
        # cv2.MoveWindow(win2_name,200,300)
        cv2.resizeWindow(win1_name,100,300)
        # cv2.ResizeWindow(win2_name,100,300)

        cv2.startWindowThread()
        rospy.on_shutdown(cleanup)
        
        
        # rate = rospy.Rate(freq)
        sub_RBG = rospy.Subscriber("/camera/rgb/image_color", Image, callback_rbg)
        # sub_depth = rospy.Subscriber("/camera/depth/image_raw", Image, callback_depth)

        print('==========Initializing Subscribers=====')
        rospy.sleep(1)

        # while not rospy.is_shutdown():
        #     rospy.rate=1
        #     rospy.wait_for_message("/camera/rgb/image_color", Image, timeout=None)
        #     k = cv2.waitKey(0) & 0xFF
        #     if k==27:
        #         cleanup()
        #     # rate.sleep()
        rospy.spin()

    except KeyboardInterrupt:
        print "Shutting down"
        cleanup()
def capture_video(i11, i12, i13, i21, i22, i23, i31, i32, i33):
    if SHOW_SCREEN: # shows processed image on screen
        cv2.imshow('Video Capture', np.vstack((np.hstack((i11, i12, i13)), np.hstack((i21, i22, i23)), np.hstack((i31, i32, i33)))))
    if CAPTURE_VIDEO: # writes frame to video file
        vid.write(np.vstack((np.hstack((i11, i12, i13)), np.hstack((i21, i22, i23)), np.hstack((i31, i32, i33)))))
    if not MOVE_WINDOW: # resets window location to prevent movement
        cv2.moveWindow('Video Capture', ((1280-(CAPTURE_WIDTH*3))/2), 25) # 1280x1024
Example #22
0
	def findShapes(self):

		# Capture frame-by-frame
		_, frame = self.cap.read()

		# Prepare frame with Gaussian blurring, HSV conversion, and Canny edge detection
		preppedFrame = self.prepFrame(frame)
	
		# Find the all contours 
		contours, hierarchy = cv2.findContours(preppedFrame.copy(), cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)

		# If contours exist
		if contours:

			# Define bounding box
			maxContour, maxRectangle, maxContourArea = self.detectBoundary(frame, contours)

			# If a bounding box has been found
			if maxRectangle:

				# Identify all nested shapes
				self.detected = self.detectNestedShapes(frame, contours, hierarchy, maxContour, maxRectangle, maxContourArea)

		if self.mode == 'debug':

			# Display final image
			cv2.namedWindow('Shape Detection', cv2.WINDOW_NORMAL)
			cv2.imshow('Shape Detection', frame)
			cv2.moveWindow('Shape Detection', 360, 0)

		cv2.waitKey(1)
Example #23
0
 def Create_Window(self, State):
     '''
     create window with window name and current state.
     '''
     cv2.namedWindow(State, flags=0)
     cv2.resizeWindow(State, self.VisualParamDict['resolutionWid'], self.VisualParamDict['resolutionHgt'])
     cv2.moveWindow(State, 50, 50)
Example #24
0
 def get_state(self,img):
     img = cv2.GaussianBlur(img, (3, 3), 1) 
     t, img = cv2.threshold(img,0,255,cv2.THRESH_OTSU)
     cv2.imshow("otsu",img)
     w = img.shape[1]
     h = img.shape[0]
     grids=9
     gaph=h//grids
     gapw=w//grids
     margin=8
     ans=""
     for i in xrange(9):
         for j in xrange(9):
             s=img[i*gapw+margin+5:i*gapw+gapw-margin+5,j*gapw+margin+3:j*gapw+gapw-margin+3]
             mask = cv2.bitwise_not(s)
             kernel = np.ones((5,5), np.uint8)
             mask = cv2.dilate(mask, kernel)
             mask = cv2.erode(mask, kernel)
             cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
             cnt = sorted(cnts, key=cv2.contourArea, reverse=True)
             if len(cnt)>0 and cv2.contourArea(cnt[0])>50:
                 x, y, w, h = cv2.boundingRect(cnt[0])
                 sub = cv2.resize(s[y:y + h,x:x + w],(30,30))
                 t,sub=cv2.threshold(sub,0,255,cv2.THRESH_OTSU)
                 cv2.imshow("%d"%(i*9+j),sub)
                 cv2.moveWindow("%d"%(i*9+j),j*200,i*100)
                 ans+=find(sub)
             else:
                 ans+="0"
         ans+=" "
     print ans
     #cv2.imshow("after", img)
     return ans
Example #25
0
def convert_to_pickle(infilename, outfilename, dsize, channel, rotate, format, quality, flip_vert, flip_hor):
    cam = cv2.VideoCapture(infilename)
    fc = lm.FrameCollection()
    cv2.namedWindow("Image")
    cv2.moveWindow("Image", 50, 50)
    while True:
        (ret, im) = cam.read()
        if not ret:
            break
        if dsize is not None:
            osize = tuple(map(lambda x: int(x), dsize.split("x")))
            im=cv2.resize(im, dsize=osize, interpolation=cv2.INTER_CUBIC)
        if rotate is not None and rotate in ["90", "180", "270"]:
            im = np.rot90(im)
            if rotate in ["180", "270"]:
                im = np.rot90(im)
            if rotate in ["270"]:
                im = np.rot90(im)
        if flip_vert:
            im = cv2.flip(im, 0)
        if flip_hor:
            im = cv2.flip(im, 1)
        cv2.imshow("Image", im)
        key = cv2.waitKey(1)
        if key == 27:
            quit()
        f = lm.LabeledMovieFrame(internal_storage_method=format, compression_level=int(quality))
        f.create_channel(channel=channel)
        f.set_image(im, channel=channel)
        f.set_default_channel(channel=channel)
        fc.append(f)
    fc.write_to_file(outfilename)
Example #26
0
def find_blob(im):    
    im[:30, :] = 0
    im[-30:, :] = 0
    im[:, :10] = 0
    im[:, -10:] = 0
    
#    thresh, im_bw = cv2.threshold(im, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
#    print thresh
    thresh, im_bw = cv2.threshold(im, 100, 255, cv2.THRESH_BINARY)
    contours, hierarchy = cv2.findContours(im_bw.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
#    moments = [cv2.moments(i).nu20 for i in contours]
#    all_bbox = [cv2.boundingRect(i) for i in contours]
    all_area = np.array([cv2.contourArea(c) for c in contours])
#    all_aspect_ratio = np.array([float(b[2]) / b[3] for b in all_bbox])    
    print all_area
    
    big_indices = np.nonzero(all_area > config.AREA_THRESH)[0]
    print big_indices
    
    ellipses = [cv2.fitEllipse(contours[i]) for i in big_indices]
    color = [0, 255, 0]
    im_rgb = cv2.cvtColor(im_bw, cv2.COLOR_GRAY2RGB)
    for ell in ellipses:
        center, dimension, angle = ell
        h, w = dimension
        print h, w
        cv2.ellipse(im_rgb, ell, color, 2, 8)
        
    cv2.namedWindow('threshold')
    cv2.moveWindow('threshold', 800, 100)
    cv2.imshow('threshold', im_rgb)
    cv2.waitKey()
    cv2.destroyAllWindows()
Example #27
0
 def displayFeaturePics(self, windowName, startX, startY):
     """Given a window name and a starting location on the screen, this creates
     an image that represents the color signature and displays it."""
     # Override this in the child class
     displayPic = self.image.copy()
     cv2.imshow(windowName, displayPic)
     cv2.moveWindow(windowName, startX, startY)
 def update(self):
     if self.img is not None:
         img = self.img.copy()  # avoid overwriting original
         self.detector.calculate_best_position(img, max_iters=1)
         cv2.imshow('mask', self.detector.mask)
         cv2.moveWindow('mask', img.shape[1] + 2, 0)
         cv2.imshow(self.window, img)
Example #29
0
	def classifyEyes(self,img,bBox):
		"""Run Eyes Cascade Classifier on Image"""
		EYE_MIN_SIZE = 0.15;
		bBoxScaled = bBox*EYE_SCALE;
		eyesROI = img[bBoxScaled[1]:bBoxScaled[3], bBoxScaled[0]:bBoxScaled[2]];
		
		eyesROI = cv2.equalizeHist(eyesROI);
		
#		print 'eyesROI dimensions: ',eyesROI.shape;
		minEyeSize = eyesROI.shape[1]*EYE_MIN_SIZE;
#		print 'minEyeSize:',minEyeSize;
		cv2.imshow("eyesROI",eyesROI);
		cv2.moveWindow("eyeROI",150,300);
		rectsScaled = self.classify(eyesROI, self.eyeClassifier, 
									minEyeSize);
		
#		print rectsScaled;
# Scale back to full size
		rects = rectsScaled / EYE_SCALE;
		
# Loop over each eye
		for eye in rects:
			# Adjust coordinates to be in faceRect's coordinate space
			eye += numpy.array([bBox[0],bBox[1],bBox[0],bBox[1]]);

		return rects;
Example #30
0
 def run(self):
     i = 0
     cv2.namedWindow("image")
     cv2.moveWindow("image", 50, 50)
     while True:
         p = self.get_next_image_file()
         if p is None:
             break
         img = np.memmap(p, dtype=np.uint8, mode="r", shape=self.shape)
         F = LabeledMovieFrame(internal_storage_method=self.format, compression_level=int(self.quality))
         if self.rotate is not None and self.rotate in ["90", "180", "270"]:
             img = np.rot90(img)
             if self.rotate in ["180", "270"]:
                 img = np.rot90(img)
             if self.rotate in ["270"]:
                 img = np.rot90(img)
         if self.flip_vert:
             img = cv2.flip(img, 0)
         if self.flip_hor:
             img = cv2.flip(img, 1)
         if self.dsize.count("x") == 1:
             osize = tuple(map(lambda x: int(x), self.dsize.split("x")))
         else:
             factor = float(self.dsize)
             osize = int(img.shape[1]*factor), int(img.shape[0]*factor)
         img = cv2.resize(img, dsize=osize, interpolation=cv2.INTER_CUBIC)
         F.set_image(img)
         cv2.imshow("image", img)
         cv2.waitKey(40)
         i += 1
         self.frame_collection.append(F)
     self.frame_collection.write_to_file(self.output_file)
    cv2.rectangle(frame, (0, 500), (650, 750), (0, 0, 0), cv2.FILLED)

    ## add text to frame
    font = cv2.FONT_HERSHEY_SIMPLEX
    cv2.putText(frame, "User Chose: ", (0, 600), font, 1, (0, 0, 255), 2,
                cv2.LINE_AA)
    cv2.putText(frame, user_choice, (200, 600), font, 1, (0, 0, 255), 2,
                cv2.LINE_AA)
    cv2.putText(frame, "Computer Chose: ", (0, 650), font, 1, (0, 0, 255), 2,
                cv2.LINE_AA)
    cv2.putText(frame, cpu_choice, (300, 650), font, 1, (0, 0, 255), 2,
                cv2.LINE_AA)
    cv2.putText(frame, text_result, (0, 700), font, 1, (0, 0, 255), 2,
                cv2.LINE_AA)
    cv2.putText(frame, "Show Rock, Paper or Scissors in Box", (0, 40), font, 1,
                (0, 0, 255), 2, cv2.LINE_AA)
    cv2.putText(frame, "PRESS 'c' TO PLAY", (0, 90), font, 1, (0, 0, 255), 2,
                cv2.LINE_AA)

    ## show frame and mask optimazed for 13" macbook screen
    ## suggested to put terminal window in bottom left corner of screen
    cv2.namedWindow('frame', cv2.WINDOW_NORMAL)
    cv2.resizeWindow('frame', (800, 1200))
    cv2.imshow('mask', mask)
    cv2.imshow('frame', frame)
    cv2.moveWindow("mask", 20, 20)
    cv2.moveWindow("frame", 500, 0)

## release and destroy windows
cap.release()
cv2.destroyAllWindows()
Example #32
0
        cv2.drawContours(frame, contours, index, lightblue, 8)
        table.putValue('rectFound', isRect)
        table.putValue('crossFound', isCross)
        if (isRect):
            print("rectangle")
            proc.calculate(focalLength, rectActualWidth, Imagewidth,
                           Xmid - imgXcenter, imgYcenter - Ymid)
            table.putValue('rectAzi', proc.getAzimuth())
        else:
            table.putValue('rectAzi', -1.0)
        if (isCross):
            print("cross")
            proc.calculate(focalLength, crossActualWidth, Imagewidth,
                           Xmid - imgXcenter, imgYcenter - Ymid)
            table.putValue('crossAzi', proc.getAzimuth())
        else:
            table.putValue('crossAzi', -1.0)
    contoured = cv2.resize(frame, None, fx=0.5, fy=0.5)
    threshed = cv2.resize(threshold, None, fx=0.5, fy=0.5)

    displayValues()  # method displays values in terminal
    cv2.imshow("contoured", contoured)
    cv2.imshow("threshed", threshed)
    cv2.moveWindow("contoured", 0, 20)
    cv2.moveWindow("threshed", 650, 20)
    key = cv2.waitKey(10)

    if key == 27:
        cv2.destroyAllWindows()
        break
Example #33
0
    # define range of yellow color in HSV
    lower_color = np.array([20, 65, 80])
    upper_color = np.array([65, 255, 255])

    # Threshold the HSV image to get only yellow colors
    binary_mask = cv2.inRange(hsvImageInput, lower_color, upper_color)

    # mask the image to only show yellow or green images
    # Bitwise-AND mask and original image
    yellow_mask = cv2.bitwise_and(imgImageInput,
                                  imgImageInput,
                                  mask=binary_mask)

    # display the masked images to screen
    cv2.imshow('hsvImageInput', hsvImageInput)
    cv2.moveWindow('hsvImageInput', 100, 50)

    #cv2.imshow('binary_mask',binary_mask)

    cv2.imshow('yellow_masked', yellow_mask)
    cv2.moveWindow('yellow_masked', 200, 650)

    ### wait for user to press any key
    #while (True):
    #    k = cv2.waitKey(0)
    #    break

    # generate the contours and display
    imgFindContourReturn, contours, hierarchy = cv2.findContours(
        binary_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    imgContours = yellow_mask.copy()
def showPositionedWindow(window_name, img_name, coords):
   cv2.namedWindow(window_name)
   cv2.moveWindow(window_name, coords[0], coords[1])
   cv2.imshow(window_name, img_name)
Example #35
0
import numpy as np
import sys
import cv2 as cv

cam = cv.VideoCapture(0)

while True:
    if cv.waitKey(1) == ord('q'):
        break

    ret, frame = cam.read()
    cv.imshow("SOURCE", frame)
    cv.moveWindow('SOURCE', 0, 0)

    #imScale = 50 # percent of original size
    #width = int(frame.shape[1]*imScale/100)
    #height = int(frame.shape[0]*imScale/100)
    #dim = (width,height)
    #resizedFrame = cv.resize(frame,dim,interpolation = cv.INTER_AREA)
    ##print("Resized Dimansions: ", resizedFrame.shape)
    ##cv.imshow("Resized", resizedFrame)

    roi = frame[0:50, 0:300]
    roiGray = cv.cvtColor(roi, cv.COLOR_BGR2GRAY)

    #gray = cv.cvtColor(Frame, cv.COLOR_BGR2GRAY)
    #gray = cv.cvtColor(resizedFrame, cv.COLOR_BGR2GRAY)

    # Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
    # gray = cv.bitwise_not(gray)
    gray = cv.bitwise_not(roiGray)
Example #36
0
import numpy as np
import cv2

src = cv2.imread(
    '/Users/hyunsul/Desktop/ai-room/OpenCV2_python/ch03/candies.png')
#src = cv2.imread('candies2.png')

if src is None:
    print('Image load failed!')
    sys.exit()

src_hsv = cv2.cvtColor(src, cv2.COLOR_BGR2HSV)
# (B,R,G)
dst1 = cv2.inRange(src, (0, 128, 0), (100, 255, 100))
dst2 = cv2.inRange(src_hsv, (50, 150, 0), (80, 255, 255))

cv2.imshow('src', src)
cv2.moveWindow('src', 20, 50)

#RGB 밝은 영상이 들어왔을떄는 좋고
cv2.imshow('dst1', dst1)
cv2.moveWindow('dst1', 700, 30)

#HSV 흑백영상을 받았을때는 밝기정보를 함께받는 HSV가 좋음.
cv2.imshow('dst2', dst2)
cv2.moveWindow('dst2', 700, 500)

cv2.waitKey()

cv2.destroyAllWindows()
Example #37
0
    predictor = create_vgg_ssd_predictor(net, candidate_size=200)

cap = cv2.VideoCapture(args.input)
if (cap.isOpened() == False):
    print("Unable to read camera feed")

frame_width = int(cap.get(3))
frame_height = int(cap.get(4))

frameCount = 0
frameWait = 1400  # Wait this many frames before looking for next truck
frameFound = -frameWait

if args.show:
    cv2.namedWindow('Result', cv2.WINDOW_AUTOSIZE)
    cv2.moveWindow('Result', 0, 0)

# Output of recording file
out = None
fourcc = cv2.VideoWriter_fourcc(*'MPEG')
fgbg = cv2.createBackgroundSubtractorMOG2(300, 400, False)

recording = False
startedRecordingFrame = 0

MIN_BG_COUNT = 3000  # Minimum amount of pixels that need to be found in order to start recording
FRAMES_TO_RECORD = frameWait  # Will record the next frames until

triggered = False  # Allow only one trigger per application

        if matches[best_match_index]:
            name = Names[best_match_index]

        top = int(top / scaleFactor)
        right = int(right / scaleFactor)
        bottom = int(bottom / scaleFactor)
        left = int(left / scaleFactor)

        cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)
        cv2.putText(frame, name, (left, top - 6), font, .75, (0, 0, 255), 2)
        print("Day la mat cua: ", name)
        recogName = name

    data = (1, recogName)
    db.updateStudentsStatus(myDB, cursor, data)
    dt = time.time() - timeStamp
    fps = 1 / dt
    fpsReport = .90 * fpsReport + .1 * fps
    print('fps is:', round(fpsReport, 1))
    timeStamp = time.time()
    cv2.rectangle(frame, (0, 0), (100, 40), (0, 0, 255), -1)
    cv2.putText(frame,
                str(round(fpsReport, 1)) + 'fps', (0, 25), font, .75,
                (0, 255, 255, 2))
    cv2.imshow('Picture', frame)
    cv2.moveWindow('Picture', 0, 0)
    if cv2.waitKey(1) == ord('q'):
        break
cam.release()
cv2.destroyAllWindows()
Example #39
0
print("Diretório de trabalho: ", os.getcwd())


def substitui_x_por_branco(gray): 
    """
        Localiza todas as posições em que há um X 3x3 na imagem de entrada e pinta estas posições com tom de cinza 127. 
        Na saída deve ficar um quadrado cinza onde havia X 
    """
    res = gray.copy()
    return res


if __name__ == "__main__":
    img = cv2.imread("black_white_dots_cross_80_60.png")
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # Faz o processamento
    saida = substitui_x_por_branco(gray)
    cv2.imwrite("ex6_troca_x.png", saida)


    # NOTE que a OpenCV terminal trabalha com BGR
    cv2.imshow('entrada', img)
    cv2.moveWindow('entrada',200,200)
    cv2.imshow('saida', saida)
    cv2.moveWindow('saida',800,200)

    cv2.waitKey()
    cv2.destroyAllWindows()

Example #40
0
        line = file.readlines()
        prerect = line[0].split(' ')
        prerect = list(map(int, prerect))
        print(prerect)
    else:
        filename = sys.argv[1]

    img = cv.imread(filename)
    img2 = img.copy()
    mask = np.zeros(img.shape[:2], dtype=np.uint8)
    output = np.zeros(img.shape, np.uint8)

    cv.namedWindow('output')
    cv.namedWindow('input')
    cv.setMouseCallback('input', onmouse)
    cv.moveWindow('input', img.shape[1] + 10, 90)

    def reset():
        print("resetting \n")
        rect = (0, 0, 1, 1)
        drawing = False
        rectangle = False
        rect_or_mask = 100
        rect_over = False
        value = DRAW_FG

    while (1):
        cv.imshow('output', output)
        cv.imshow('input', img)
        k = cv.waitKey(1)
        if k == 27:
    def calibrate(self,
                  calibImagePathsList,
                  showDebugImages=False,
                  nx=9,
                  ny=6):
        """
        `calibImagePathsList` Input vector of paths to calibration files
        `showDebugImages` Input to show debug images while calibration if True
        `nx` Input number of corners in X direction
        `ny` Input number of corners in Y direction

        Calibrates the camera based on the given calibration filename list and
        the number of chessboard corners in x and y direction

        returns if the calibration has been successful
        """

        print("Camera Calibrating...")

        # start uncalibrated when running calibration routine
        self.calibrated = False

        if calibImagePathsList and (nx > 0) and (ny > 0):
            # build vectors for imagepoints and objectpoints
            imgpoints = []  # 2D points in image plane
            objpoints = []  # 3D points in real world

            # prepare the object points according to the parameters (z stays 0
            # as the chessboards are on a flat surface)
            objp = np.zeros((nx * ny, 3), np.float32)
            objp[:, :2] = np.mgrid[0:nx, 0:ny].T.reshape(-1,
                                                         2)  # x, y coordinates

            if showDebugImages == True:
                cv2.namedWindow("Calibration Debug", cv2.WINDOW_AUTOSIZE)
                cv2.moveWindow("Calibration Debug", 0, 0)

            for path in calibImagePathsList:

                # load the image
                image = mpimg.imread(path)

                # convert image to grayscale
                gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

                # find chessboard corners for further detection
                ret, corners = cv2.findChessboardCorners(gray, (nx, ny), None)

                if ret == True:
                    imgpoints.append(corners)
                    objpoints.append(objp)

                    # draw the corners on debug
                    if showDebugImages == True:
                        cv2.drawChessboardCorners(image, (nx, ny), corners,
                                                  ret)
                        cv2.imshow("Calibration Debug", image)
                        cv2.waitKey(1000)

                # calibrate the camera if valid points have been found
                if len(objpoints) > 0:
                    ret, self.mtx, self.distCoeffs, rvecs, tvecs = \
                        cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], \
                         None, None)

                    self.calibrated = True

            if showDebugImages == True:
                cv2.destroyWindow("Calibration Debug")

        return self.calibrated
        print(len(example_contour))
    elif key & 0xFF == ord('1'):
        example_contour.append(hand)
        images.append(temp)
        labels.append(1)
        print(len(example_contour))
    elif key & 0xFF == ord('2'):
        example_contour.append(hand)
        images.append(temp)
        labels.append(2)
        print(len(example_contour))
    elif key & 0xFF == ord('3'):
        example_contour.append(hand)
        images.append(temp)
        labels.append(3)
        print(len(example_contour))
    elif key & 0xFF == ord('4'):
        example_contour.append(hand)
        images.append(temp)
        labels.append(4)
        print(len(example_contour))
    elif key & 0xFF == ord('5'):
        example_contour.append(hand)
        images.append(temp)
        labels.append(5)
        print(len(example_contour))

    cv2.imshow('Place your hand in the rectangle', img)
    cv2.imshow('Contour', temp)
    cv2.moveWindow('Contour', 600, 0)
def showResults(data_path, anno_path, results=None):
    # img = cv2.imread(data_path)

    data_expr = os.path.join(
        data_path, "*.jpg"
    )
    data_paths = glob.glob(data_expr)
    image_ids = [str(i) for i in range(len(data_paths))]

    maxArea = 50

    for ids, path in enumerate(data_paths):
        imgname = os.path.basename(os.path.splitext(path)[0])

        annotation_dir = os.path.join(anno_path, "annotation_%s" % imgname)
        # information output dir
        os.makedirs(annotation_dir, exist_ok=True)
        # txt file output
        annotation_path = os.path.join(annotation_dir, "%s.txt" % imgname)

        img = cv2.imread(path)
        img_nxt = img.copy()  # the copy of the original img for processing
        img_now = img.copy()  # the copy of the original img for processing

        print('The image is %s' % imgname)

        cv2.namedWindow(window_name, 0)
        cv2.imshow(window_name, img)
        cv2.moveWindow(window_name, move_x, move_y)
        print('press any key to start, \'p\' to pass :  '******'press any key to start, p to pass :  '******'p':
            continue

        img_bor = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
        img_bor = accessBinary(img_bor)
        _, contours, _ = cv2.findContours(img_bor, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
        borders = []
        for contour in contours:
            # 将边缘拟合成一个边框
            x, y, w, h = cv2.boundingRect(contour)
            if w * h > maxArea:
                border = [(x, y), (x + w, y + h)]
                borders.append(border)

        new_str = ''

        for i, border in enumerate(borders):

            cv2.rectangle(img_nxt, border[0], border[1], (255, 0, 0))  # box in blue to label
            cv2.namedWindow(window_name, 0)
            cv2.imshow(window_name, img_nxt)
            cv2.moveWindow(window_name, move_x, move_y)
            label = chr(cv2.waitKey(0))

            while label != 'u' and label_class.get(label, None) is None:
                print('The input is invalide, re-print the label:')
                label = chr(cv2.waitKey(0))

            # if the label is 'u', then drop the box
            if label == 'u':
                img_nxt = img_now.copy()
                cv2.namedWindow(window_name, 0)
                cv2.imshow(window_name, img_nxt)
                cv2.moveWindow(window_name, move_x, move_y)
                print("drop")
                continue

            label_tran = label_transfer(label)
            print('The %d rectangle labeld: %s [%s]' % (i + 1, label, label_tran))

            cv2.rectangle(img_now, border[0], border[1], (0, 0, 255))  # save the labeled box in red
            img_nxt = img_now.copy()
            cv2.namedWindow(window_name, 0)
            cv2.imshow(window_name, img_nxt)
            cv2.moveWindow(window_name, move_x, move_y)

            xmin = str(border[0][0])
            ymin = str(border[0][1])
            xmax = str(border[1][0])
            ymax = str(border[1][1])
            new_str += " " + ",".join(
                [xmin, ymin, xmax, ymax, str(label_tran)]
            )

        if os.path.exists(annotation_path):
            os.remove(annotation_path)
            # print(new_str)
        with open(annotation_path, "a") as f:

            annotation = path  # path of the img
            annotation += new_str  # label info
            annotation += "\n"  # next line
            print(annotation)
            f.write(annotation)