def process(self, inframe, outframe): jevois.LINFO("process with usb") # Get the next camera image (may block until it is captured): inimg = inframe.get() jevois.LINFO("Input image is {} {}x{}".format(jevois.fccstr(inimg.fmt), inimg.width, inimg.height)) # Get the next available USB output image: outimg = outframe.get() jevois.LINFO("Output image is {} {}x{}".format(jevois.fccstr(outimg.fmt), outimg.width, outimg.height)) # Example of getting pixel data from the input and copying to the output: jevois.paste(inimg, outimg, 0, 0) # We are done with the input image: inframe.done() # Example of in-place processing: jevois.hFlipYUYV(outimg) # Example of simple drawings: jevois.drawCircle(outimg, int(outimg.width/2), int(outimg.height/2), int(outimg.height/4), 2, jevois.YUYV.White) jevois.writeText(outimg, "Hi from Python - @MODULE@", 20, 20, jevois.YUYV.White, jevois.Font.Font10x20) # We are done with the output, ready to send it to host over USB: outframe.send() # Send a string over serial (e.g., to an Arduino). Remember to tell the JeVois Engine to display those messages, # as they are turned off by default. For example: 'setpar serout All' in the JeVois console: jevois.sendSerial("DONE frame {}".format(self.frame)); self.frame += 1
def __init__(self): jevois.LINFO("Preseason2019 Constructor") # Instantiate a JeVois Timer to measure our processing framerate: self.timer = jevois.Timer("sandbox", 100, jevois.LOG_INFO) """initializes all values to presets or None if need to be set """ self.__hsl_threshold_hue = [0, 255.0] self.__hsl_threshold_saturation = [0, 255.0] self.__hsl_threshold_luminance = [0, 255.0] self.hsl_threshold_output = None self.__find_contours_input = self.hsl_threshold_output self.__find_contours_external_only = False self.find_contours_output = None self.__filter_contours_contours = self.find_contours_output self.__filter_contours_min_area = 0.0 self.__filter_contours_min_perimeter = 0 self.__filter_contours_min_width = 0 self.__filter_contours_max_width = 1000 self.__filter_contours_min_height = 0 self.__filter_contours_max_height = 1000 self.__filter_contours_solidity = [0, 100] self.__filter_contours_max_vertices = 1000000 self.__filter_contours_min_vertices = 0 self.__filter_contours_min_ratio = 0 self.__filter_contours_max_ratio = 1000 self.filter_contours_output = None try: fInit = open("modules/Lightning/Template/vals.txt", "r") if(fInit.mode == "r"): valsInit = fInit.read().split('[')[1].split(',') self.__hsl_threshold_hue[0] = float(valsInit[0]) self.__hsl_threshold_hue[1] = float(valsInit[1]) self.__hsl_threshold_saturation[0] = float(valsInit[2]) self.__hsl_threshold_saturation[1] = float(valsInit[3]) self.__hsl_threshold_luminance[0] = float(valsInit[4]) self.__hsl_threshold_luminance[1] = float(valsInit[5]) self.__filter_contours_min_area = float(valsInit[6]) fInit.close() except: jevois.LINFO("Error loading parameters from file") self.sendFrames = True jevois.LINFO("END CONSTRUCTOR")
def parseSerial(self, str): jevois.LINFO("parseserial received command [{}]".format(str)) cmd, args = str.split(" ", maxsplit=1) if cmd == "armothy_pos": pass return self.parsePosMsg(args) return "ERR Unsupported command: {}".format(str)
def parseSerial(self, input): jevois.LINFO('parseserial received command [{}]'.format(input)) command = input.split(' ', 1)[0] if command == 'getVals': return self.getVals() if command == 'setHMin': return self.setHMin(input) if command == 'setHMax': return self.setHMax(input) if command == 'setSMin': return self.setSMin(input) if command == 'setSMax': return self.setSMax(input) if command == 'setLMin': return self.setLMin(input) if command == 'setLMax': return self.setLMax(input) if command == 'setMinArea': return self.setMinArea(input) if command == 'saveParams': return self.saveParams(input) if command == 'stopSendFrames': return self.stopPrintFrames() if command == 'sendFrames': return self.printFrames() if command == 'showHSL': self.displayHSLOutput = True; return 'Showing HSL output' if command == 'showContour': self.displayHSLOutput = False; return 'Showing contour output' return 'ERR: Unknown command'
def parseSerial(self, str): jevois.LINFO("parseserial received command [{}]".format(str)) if str == "hello": return self.hello() elif str == "Geevoooice": return self.hi() return "ERR: Unsupported command"
def loadCameraCalibration(self, w, h): cpf = "/jevois/share/camera/calibration{}x{}.yaml".format(w, h) fs = cv2.FileStorage(cpf, cv2.FILE_STORAGE_READ) if (fs.isOpened()): self.camMatrix = fs.getNode("camera_matrix").mat() self.distCoeffs = fs.getNode("distortion_coefficients").mat() jevois.LINFO("Loaded camera calibration from {}".format(cpf)) else: jevois.LFATAL("Failed to read camera parameters from file [{}]".format(cpf))
def parseSerial(self, str): jevois.LINFO("parseserial received command [{}]".format(str)) #Command to reset previous target if str == "latch": self.prevlcent=0 self.prevrcent=0 self.resetcounter+=1 return "Reset Completed" return "ERR Unsupported command"
def parseSerial(self, command): if command.strip() == "": # For some reason, the jevois engine sometimes sends empty strings. # Just do nothing in this case. return "" jevois.LINFO("parseserial received command [{}]".format(command)) if command == "target": return self.target() return "ERR: Unsupported command."
def processNoUSB(self, inframe): # Get the next camera image (may block until it is captured) and here convert it to OpenCV BGR. If you need a # grayscale image, just use getCvGRAY() instead of getCvBGR(). Also supported are getCvRGB() and getCvRGBA(): inimg = inframe.getCvBGR() # Start measuring image processing time (NOTE: does not account for input conversion time): self.timer.start() pucks_circles = self.find_pucks(inimg) jevois.LINFO("FUUUUCK") jevois.sendSerial("{}".format(self.serialize_puck_list(pucks_circles)))
def parseSerial(self, str): global x #the threshold pixels to trigger a change jevois.LINFO("parseserial received command [{}]".format(str)) if str == "hello": return self.hello() elif "setthresh" in str: inputline=str.split(" ") x=int(inputline[1]) return self.setthresh() else: return "ERR Unsupported command"
def loadCameraCalibration(self, w, h): """Loads the camera calibration from disk for the given width and height of the image""" calibFile = '/jevois/share/camera/calibration{}x{}.yaml'.format(w, h) fs = cv2.FileStorage(calibFile, cv2.FILE_STORAGE_READ) if fs.isOpened(): self.camMatrix = fs.getNode("camera_matrix").mat() self.distCoeffs = fs.getNode("distortion_coefficients").mat() jevois.LINFO(f"Loaded camera calibration from {calibFile}") else: jevois.LFATAL( f"Failed to read camera calibration parameters from {calibFile}" )
def parseSerial(self, str): jevois.LINFO("parseSerial received command [{}]".format(str)) parts = str.split() try: if parts[0] == "setHSVMin": self.HSVmin, response = self.parseHSVValues(parts) return response if parts[0] == "setHSVMax": self.HSVmax, response = self.parseHSVValues(parts) return response except Exception as e: return "ERR {}".format(e) return "ERR Unsupported command {}".format(parts[0])
def parseSerial(self, str): if (str.strip() == ""): #For some reason, the jevois engine sometimes sends empty strings. # Just do nothing in this case. return "" jevois.LINFO("parseserial received command [{}]".format(str)) if str == "hello": return self.hello() elif str == "Geevoooice": return self.hi() return "ERR: Unsupported command. "
def __init__(self): jevois.LINFO("CasseroleVision Constructor...") #Frame Index self.frame = 0 #USB send frame decimation #Reduces send rate by this factor to limit USB bandwidth at high process rates self.frame_dec_factor = 6 #At 60FPS, this still delivers 10FPS to the driver #Processing tune constants #TODO - Pick better constants self.hsv_thres_lower = np.array([0, 0, 220]) self.hsv_thres_upper = np.array([255, 255, 255]) #Target Information self.tgtAngle = "0.0" self.tgtRange = "0.0" self.tgtAvailable = "f" #Timer and Variables to track statistics we care about self.timer = jevois.Timer("CasseroleVisionStats", 25, jevois.LOG_DEBUG) #regex for parsing info out of the status returned from the jevois Timer class self.pattern = re.compile( '([0-9]*\.[0-9]+|[0-9]+) fps, ([0-9]*\.[0-9]+|[0-9]+)% CPU, ([0-9]*\.[0-9]+|[0-9]+)C,' ) #Tracked stats self.framerate_fps = "0" self.CPULoad_pct = "0" self.CPUTemp_C = "0" self.pipelineDelay_us = "0" #data structure object to hold info about the present data processed from the image fram self.curTargets = [] jevois.LINFO("CasseroleVision construction Finished")
def process(self, inframe, outframe): #jevois.drawRect(inframe,50,50,50,50,5,0) inimg = inframe.getCvBGR() self.frame += 1 # Send processed data jevois.LINFO("{-35,20,105,234}") jevois.sendSerial("DONE frame {} \n".format(self.frame)) # We are done with the output, ready to send it to host over USB: outframe.sendCvBGR(inimg)
def __init__(self): jevois.LINFO("LancerVision Constructor...") # Frame Index self.frame = 0 # USB send frame decimation # Reduces send rate by this factor to limit USB bandwidth at high process rates self.frame_dec_factor = 6 # At 60FPS, this still delivers 10FPS to the driver # Tuning constants self.hsv_thresh_lower = np.array([65, 195, 96]) self.hsv_thresh_upper = np.array([92, 255, 255]) # Target Information self.tgtAngle = "0.0" self.tgtRange = "0.0" self.tgtAvailable = "f" # Data structure object to hold info about the present data processed from the image frame self.curTargets = [] self.sortedArray = [] jevois.LINFO("LancerVision construction Finished")
def process(self, inframe, outframe): jevois.LINFO("process with usb") # Get the next camera image (may block until it is captured): source0 = inimg = inframe.getCvBGR() outimg = inimg = inframe.getCvBGR() # Example of getting pixel data from the input and copying to the output: outimg = inimg # Example of simple drawings: #jevois.drawCircle(outimg, int(outimg.width/2), int(outimg.height/2), int(outimg.height/2.2), 2, jevois.YUYV.White) #jevois.writeText(outimg, "Hi from Python!", 20, 20, jevois.YUYV.White, jevois.Font.Font10x20) # We are done with the output, ready to send it to host over USB: outframe.sendCvBGR(outimg)
def processNoUSB(self, inframe): # Get the next camera image (may block until it is captured) and here convert it to OpenCV BGR. If you need a # grayscale image, just use getCvGRAY() instead of getCvBGR(). Also supported are getCvRGB() and getCvRGBA(): inimg = inframe.getCvBGR() # Start measuring image processing time (NOTE: does not account for input conversion time): self.timer.start() jevois.LINFO("Processing video frame {} now...".format(self.frame)) # TODO: you should implement some processing. # Once you have some results, send serial output messages: # Get frames/s info from our timer: fps = self.timer.stop() # Send a serial output message: jevois.sendSerial("DONE frame {} - {}".format(self.frame, fps)); self.frame += 1
def processImage(self, img): ''' process a single image return a dict with detected featured ''' if self.save is not None: cv2.imwrite(self.save, img) jevois.LINFO(self.save) self.save = None detect = {} # dict of detected objects size_factor = None if self.alt > 1000: size_factor = self.focal[0] * self.focal[1] / (self.alt * self.alt) # red ret = self.mailbox_red.detect(img, size_factor) if ret is not None: detect[MARK_RED] = ret self.send_message(MARK_RED, ret) # blue ret = self.mailbox_blue.detect(img, size_factor) if ret is not None: detect[MARK_BLUE] = ret self.send_message(MARK_BLUE, ret) # yellow ret = self.mailbox_yellow.detect(img, size_factor) if ret is not None: detect[MARK_YELLOW] = ret self.send_message(MARK_YELLOW, ret) # orange (assuming only one in image) ret = self.mailbox_orange.detect(img, size_factor) if ret is not None: detect[MARK_ORANGE] = ret self.send_message(MARK_ORANGE, ret) return detect
def findDistBetweenCenters(median, thresh): #creates a circle at the center of the image cv2.circle(median,(int(getWidth(median)/2), int(getHeight(median)/2)), 5, (255,255,255), -1) #finds the moments of the threshold image M = cv2.moments(thresh) #if statement prevents a divide by zero error try: if(M["m00"] !=0): #Finds the x and y cordinates of the center of the two vision targets cX = int(M["m10"]/M["m00"]) cY = int(M["m01"]/M["m00"]) #creates a circle at the center of the vision targets #cv2.circle(median,(cX, cY), 5, (255,255,255), -1) #draws a line between the center of the screen and the center of the targets #cv2.line(median, (cX,cY),(int(getWidth(median)/2), int(getHeight(median)/2)), (255,0,0),5) #finds the distance between the center of the screen and the center of the targets (pixels) dist = math.sqrt(math.pow((cX-(getWidth(median)/2)),2)+math.pow((cY-(getHeight(median)/2)),2)) #puts text on the screen regarding distance between the center of the screen and the vision targets (pixels) #cv2.putText(median,'Distance: ' + str(int(dist))+ ' (pixels)' ,(0,int(getHeight(median))-35), font, .5,(255,255,255),1,cv2.LINE_AA) except: jevois.LINFO("Failed to get X,Y coordinates of the vision targets")
def parseSerial(self, str): global errode global dilate global approx global area global solidity global ratio jevois.LINFO("parseserial received command [{}]".format(str)) if str == "hello": return self.hello() cal = str.split("=") if cal[0] == "errode": errode = int(cal[1]) return cal[1] if cal[0] == "dilate": dilate = int(cal[1]) return cal[1] if cal[0] == "approx": approx = int(cal[1]) return cal[1] if cal[0] == "area": area = int(cal[1]) return cal[1] if cal[0] == "solidity": solidity = int(cal[1]) / 100 return cal[1] if cal[0] == "ratio": ratio = float(cal[1]) return cal[1] return "ERR: Fat Fingered that command"
def __init__(self): jevois.LINFO("PythonTest Constructor") jevois.LINFO(dir(jevois)) self.frame = 0 # a simple frame counter used to demonstrate sendSerial()
def __init__(self): jevois.LINFO("PythonTest Constructor")
def __init__(self): self.framecount = 0 jv.LINFO("VulcanVoit ctor, sendTargets {}".format( VulcanVoit.sendTargets)) jv.LINFO("VulcanVoit ctor, curDir {}".format(os.getcwd()))
def detect(self, imggray, outimg=None): h, w = imggray.shape hlist = [] # Create a keypoint detector if needed: if not hasattr(self, 'detector'): self.detector = cv2.ORB_create() # Load training image and detect keypoints on it if needed: if not hasattr(self, 'refkp'): refimg = cv2.imread(self.fname, 0) self.refkp, self.refdes = self.detector.detectAndCompute( refimg, None) # Also store corners of reference image and of window for homography mapping: refh, refw = refimg.shape self.refcorners = np.float32([[0.0, 0.0], [0.0, refh], [refw, refh], [refw, 0.0]]).reshape(-1, 1, 2) self.wincorners = np.float32( [[ self.winleft * refw / self.owm, self.wintop * refh / self.ohm ], [ self.winleft * refw / self.owm, (self.wintop + self.winh) * refh / self.ohm ], [(self.winleft + self.winw) * refw / self.owm, (self.wintop + self.winh) * refh / self.ohm], [(self.winleft + self.winw) * refw / self.owm, self.wintop * refh / self.ohm]]).reshape(-1, 1, 2) jevois.LINFO( "Extracted {} keypoints and descriptors from {}".format( len(self.refkp), self.fname)) # Compute keypoints and descriptors: kp, des = self.detector.detectAndCompute(imggray, None) str = "{} keypoints".format(len(kp)) # Create a matcher if needed: if not hasattr(self, 'matcher'): self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) # Compute matches between reference image and camera image, then sort them by distance: matches = self.matcher.match(des, self.refdes) matches = sorted(matches, key=lambda x: x.distance) str += ", {} matches".format(len(matches)) # Keep only good matches: lastidx = 0 for m in matches: if m.distance < self.distth: lastidx += 1 else: break matches = matches[0:lastidx] str += ", {} good".format(len(matches)) # If we have enough matches, compute homography: corners = [] wincorners = [] if len(matches) >= 10: obj = [] scene = [] # Localize the object (see JeVois C++ class ObjectMatcher for details): for m in matches: obj.append(self.refkp[m.trainIdx].pt) scene.append(kp[m.queryIdx].pt) # compute the homography hmg, mask = cv2.findHomography(np.array(obj), np.array(scene), cv2.RANSAC, 5.0) # Check homography conditioning using SVD: u, s, v = np.linalg.svd(hmg, full_matrices=False) # We need the smallest eigenvalue to not be too small, and the ratio of largest to smallest eigenvalue to be # quite large for our homography to be declared good here. Note that linalg.svd returns the eigenvalues in # descending order already: if s[-1] > 0.001 and s[0] / s[-1] > 100: # Project the reference image corners to the camera image: corners = cv2.perspectiveTransform(self.refcorners, hmg) wincorners = cv2.perspectiveTransform(self.wincorners, hmg) # Display any results requested by the users: if outimg is not None and outimg.valid(): if len(corners) == 4: jevois.drawLine(outimg, int(corners[0][0, 0] + 0.5), int(corners[0][0, 1] + 0.5), int(corners[1][0, 0] + 0.5), int(corners[1][0, 1] + 0.5), 2, jevois.YUYV.LightPink) jevois.drawLine(outimg, int(corners[1][0, 0] + 0.5), int(corners[1][0, 1] + 0.5), int(corners[2][0, 0] + 0.5), int(corners[2][0, 1] + 0.5), 2, jevois.YUYV.LightPink) jevois.drawLine(outimg, int(corners[2][0, 0] + 0.5), int(corners[2][0, 1] + 0.5), int(corners[3][0, 0] + 0.5), int(corners[3][0, 1] + 0.5), 2, jevois.YUYV.LightPink) jevois.drawLine(outimg, int(corners[3][0, 0] + 0.5), int(corners[3][0, 1] + 0.5), int(corners[0][0, 0] + 0.5), int(corners[0][0, 1] + 0.5), 2, jevois.YUYV.LightPink) jevois.writeText(outimg, str, 3, h + 4, jevois.YUYV.White, jevois.Font.Font6x10) # Return window corners if we did indeed detect the object: hlist = [] if len(wincorners) == 4: hlist.append(wincorners) return hlist
def parseSerial(self, str): jevois.LINFO("parseserial received command [{}]".format(str)) if str =="GRATERTTT": self.GraterActivation=1 else: return "ERR: Unsupported command"
def __init__(self): jevois.LINFO("@MODULE@ Constructor") self.frame = 0 # a simple frame counter used to demonstrate sendSerial()
def process(self, inframe): jevois.LINFO("{-35,20,105,234}") jevois.sendSerial("test3\n")
def __init__(self): jevois.LINFO("PythonTest Constructor") # Instantiate a JeVois Timer to measure our processing framerate: self.timer = jevois.Timer("sandbox", 100, jevois.LOG_INFO) """initializes all values to presets or None if need to be set """ self.__blur_input = None self.__blur_type = BlurType.Gaussian_Blur self.__blur_radius = 1.8867924528301883 self.blur_output = None self.__hsl_threshold_input = self.blur_output #Original values self.__hsl_threshold_input = self.blur_output self.__hsl_threshold_hue = [32.203389830508456, 45.240641711229955] self.__hsl_threshold_saturation = [60.02824858757062, 255.0] self.__hsl_threshold_luminance = [ 14.406779661016945, 243.63636363636363 ] self.hsl_threshold_output = None self.__cv_erode_0_src = self.hsl_threshold_output self.__cv_erode_0_kernel = None self.__cv_erode_0_anchor = (-1, -1) self.__cv_erode_0_iterations = 3.0 self.__cv_erode_0_bordertype = cv2.BORDER_CONSTANT self.__cv_erode_0_bordervalue = (-1) self.cv_erode_0_output = None self.__cv_dilate_src = self.cv_erode_0_output self.__cv_dilate_kernel = None self.__cv_dilate_anchor = (-1, -1) self.__cv_dilate_iterations = 5.0 self.__cv_dilate_bordertype = cv2.BORDER_CONSTANT self.__cv_dilate_bordervalue = (-1) self.cv_dilate_output = None self.__cv_erode_1_src = self.cv_dilate_output self.__cv_erode_1_kernel = None self.__cv_erode_1_anchor = (-1, -1) self.__cv_erode_1_iterations = 2.0 self.__cv_erode_1_bordertype = cv2.BORDER_CONSTANT self.__cv_erode_1_bordervalue = (-1) self.cv_erode_1_output = None self.__find_contours_input = self.cv_erode_1_output self.__find_contours_external_only = False self.find_contours_output = None self.__filter_contours_contours = self.find_contours_output self.__filter_contours_min_area = 500.0 self.__filter_contours_min_perimeter = 0.0 self.__filter_contours_min_width = 0.0 self.__filter_contours_max_width = 1.0E16 self.__filter_contours_min_height = 0.0 self.__filter_contours_max_height = 1.0E21 self.__filter_contours_solidity = [84.74576271186443, 100] self.__filter_contours_max_vertices = 1000000.0 self.__filter_contours_min_vertices = 0.0 self.__filter_contours_min_ratio = 0.0 self.__filter_contours_max_ratio = 1000.0 #Attempt to load above values from file try: fInit = open("vals.txt", "r") if (fInit.mode == "r"): valsInit = fInit.read().split('[')[1].split(',') self.__hsl_threshold_hue[0] = float(valsInit[0]) self.__hsl_threshold_hue[1] = float(valsInit[1]) self.__hsl_threshold_saturation[0] = float(valsInit[2]) self.__hsl_threshold_saturation[1] = float(valsInit[3]) self.__hsl_threshold_luminance[0] = float(valsInit[4]) self.__hsl_threshold_luminance[1] = float(valsInit[5]) self.__filter_contours_min_area = float(valsInit[6]) fInit.close() except: jevois.LINFO("Error loading parameters from file") self.filter_contours_output = None self.__convex_hulls_contours = self.filter_contours_output self.convex_hulls_output = None self.convex_hulls_filled = None self.frame = 0 self.sendFrames = True self.displayHSLOutput = False self.momentAvg = [ 0.171877167, 0.002900258788, 3.97E-05, 2.71E-06, 3.38E-10, 2.16E-07, 3.79E-11 ] self.stdv = [ 0.01501932812, 0.006138597897, 0.0001147442133, 0.00001223416618, 0.000000003403410003, 0.000001767205694, 0.0000000009515363047 ] self.covarianceMtrx = [[self.stdv[0] * self.stdv[0], 0, 0, 0, 0, 0, 0], [0, self.stdv[1] * self.stdv[1], 0, 0, 0, 0, 0], [0, 0, self.stdv[2] * self.stdv[2], 0, 0, 0, 0], [0, 0, 0, self.stdv[3] * self.stdv[3], 0, 0, 0], [0, 0, 0, 0, self.stdv[4] * self.stdv[4], 0, 0], [0, 0, 0, 0, 0, self.stdv[5] * self.stdv[5], 0], [0, 0, 0, 0, 0, 0, self.stdv[6] * self.stdv[6]]] #self.covarMtrx = [] #self.invCovarMtrx = cv2.invert(cv2.calcCovarMatrix(self.stdv), DECOMP_SVD) self.invCovarMtrx = np.linalg.inv(self.covarianceMtrx) self.recordVideo = False self.videoWriter = None self.rawVideoWriter = None self.hslVideoWriter = None jevois.LINFO("END CONSTRUCTOR")
def __init__(self): jevois.LINFO("PythonTest Constructor...") self.frame = 0 # a simple frame counter used to demonstrate sendSerial() jevois.LINFO("PythonTest construction Finished")