def __init__(self): #load algorithm constants #how round a circle needs to be. Perfect circle = 1 self.eccentricity = VN_config.get_float('algorithm', 'eccentricity', 0.6) #Minimum ratio while comparing contour area to ellipse area self.area_ratio = VN_config.get_float('algorithm','area_ratio', 0.8) #Minimum ratio between outer and inner circle area in a ring self.ring_ratio = VN_config.get_float('algorithm','ring_ratio', 0.1) #The smallest span of min max pixels that get enhanced(Largest range is 255, Smaller numbers make image suspitable to noise) self.min_range = VN_config.get_integer('algorithm', 'min_range', 10) #reduce the grayscale resoltion(steps) by this multipler( 1 is full res, 2 is half res, 4 is quarter res ) self.res_reduction = VN_config.get_integer('algorithm', 'res_reduction', 32)
def __init__(self): #load algorithm constants #how round a circle needs to be. Perfect circle = 1 self.eccentricity = VN_config.get_float('algorithm', 'eccentricity', 0.6) #Minimum ratio while comparing contour area to ellipse area self.area_ratio = VN_config.get_float('algorithm', 'area_ratio', 0.8) #Minimum ratio between outer and inner circle area in a ring self.ring_ratio = VN_config.get_float('algorithm', 'ring_ratio', 0.1) #The smallest span of min max pixels that get enhanced(Largest range is 255, Smaller numbers make image suspitable to noise) self.min_range = VN_config.get_integer('algorithm', 'min_range', 10) #reduce the grayscale resoltion(steps) by this multipler( 1 is full res, 2 is half res, 4 is quarter res ) self.res_reduction = VN_config.get_integer('algorithm', 'res_reduction', 32)
def __init__(self): self.targetLocation = PositionVector() self.vehicleLocation = PositionVector() self.backgroundColor = (74,88,109) #define camera self.camera_width = VN_config.get_integer('camera', 'width', 640) self.camera_height = VN_config.get_integer('camera', 'height', 640) self.camera_vfov = VN_config.get_float('camera', 'vertical-fov',72.42 ) self.camera_hfov = VN_config.get_float('camera', 'horizontal-fov', 72.42) self.camera_fov = math.sqrt(self.camera_vfov**2 + self.camera_hfov**2) self.camera_frameRate = 30
def __init__(self): self.targetLocation = PositionVector() self.vehicleLocation = PositionVector() self.backgroundColor = (74, 88, 109) #define camera self.camera_width = VN_config.get_integer('camera', 'width', 640) self.camera_height = VN_config.get_integer('camera', 'height', 640) self.camera_vfov = VN_config.get_float('camera', 'vertical-fov', 72.42) self.camera_hfov = VN_config.get_float('camera', 'horizontal-fov', 72.42) self.camera_fov = math.sqrt(self.camera_vfov**2 + self.camera_hfov**2) self.camera_frameRate = 30
def __init__(self): # get which camera we will use self.camera_index = VN_config.get_integer('camera','index',0) # get image resolution self.img_width = VN_config.get_integer('camera','width',640) self.img_height = VN_config.get_integer('camera','height',480) # get image center self.img_center_x = self.img_width / 2 self.img_center_y = self.img_height / 2 # define field of view self.cam_hfov = VN_config.get_float('camera','horizontal-fov',70.42) self.cam_vfov = VN_config.get_float('camera','vertical-fov',43.3) #get camera distortion matrix and intrinsics. Defaults: logitech c920 mtx = np.array([[ 614.01269552,0,315.00073982], [0,614.43556296,237.14926858], [0,0,1.0]]) dist = np.array([0.12269303, -0.26618881,0.00129035, 0.00081791,0.17005303]) self.matrix = VN_config.get_array('camera','matrix', mtx) self.distortion = VN_config.get_array('camera', 'distortion', dist) self.newcameramtx, self.roi=cv2.getOptimalNewCameraMatrix(self.matrix,self.distortion,(self.img_width,self.img_height),1,(self.img_width,self.img_height)) #create a camera object self.camera = None #number of cores available for use desiredCores = VN_config.get_integer('processing', 'desired_cores', 4) self.cores_available = min(desiredCores, multiprocessing.cpu_count()) #does the user want to capture images in the background self.background_capture = VN_config.get_boolean('processing','background_capture', True) # background image processing variables self.proc = None # background process object self.parent_conn = None # parent end of communicatoin pipe self.img_counter = 0 # num images requested so far self.is_backgroundCap = False #state variable for background capture
def __init__(self): # add variable initialisation here self.api = None self.vehicle = None self.last_mode_call = 0 self.last_mode_state = 'STABILIZE' self.mode_update_rate = VN_config.get_float('vehicle control', 'mode_update_rate', 0.75) self.last_home_call = 0 self.last_home = None self.home_update_rate = VN_config.get_float('vehicle control', 'home_update_rate', 10) self.last_set_velocity = 0 self.vel_update_rate = VN_config.get_float('vehicle control', 'vel_update_rate', 0.1) self.last_report_landing_target = 0 self.landing_update_rate = VN_config.get_float('vehicle control', 'landing_update_rate', 0.02)
def __init__(self): #create sub driectory for logs and videos self.location = VN_config.get_string('logging', 'location', os.environ['HOME'] + '/visnav/') path = self.location + 'logs' if not os.path.exists(path): os.makedirs(path) path = self.location + 'vids' if not os.path.exists(path): os.makedirs(path) #set default startegy name self.strat_name = 'Smart_Camera' # get image resolution self.img_width = VN_config.get_integer('camera', 'width', 640) self.img_height = VN_config.get_integer('camera', 'height', 480) #####TEXT LOGGING###### #levels = 'debug' , 'general' , 'aircraft' , 'algorithm' , ' performance' #multiple message levels can be selected by concatination strings i.e. 'debug, aircraft' #what type of messages we print to the terminal self.print_level = VN_config.get_string('logging', 'print_level', 'debug, general') #what type of messages we log to a file self.log_level = VN_config.get_string('logging', 'log_level', 'aircraft, algorithm, general') #####VIDEO RECORDING###### #levels = 'frame' , 'gui' #multiple message levels can be selected at once by concatination strings i.e. 'frame, gui' #what type of images we display on the screen self.display_level = VN_config.get_string('logging', 'display_level', 'raw, gui') #what type of images we record self.record_level = VN_config.get_string('logging', 'record_level', 'raw') #Write a video or individual images self.record_type = VN_config.get_string('logging', 'record_type', 'image') #Note about useful logging practices: #Inorder to replay a flight through the program log_level must include 'aircraft' and 'algorithm' #record level must include 'frame' #all other logging levels are for user diagnostics #a list of video writers and their tag self.video_writers = [] #text logger self.logger = None
def __init__(self): #The number of core to be used while processing image data #This number may be less than the actaul number of cores on the CPU depending on the users specifications #cores = min(desiredCores, multiprocessing.cpu_count()) //dont allow more cores than the CPU has available and don;t run more than the user wants desired_cores = VN_config.get_integer('processing', 'desired_cores', 4) available_cores = min(desired_cores, multiprocessing.cpu_count()) #check if a core is already in use for background image capture cores_image_capture = int( VN_config.get_boolean('processing', 'background_capture', True)) self.cores_processing = max(available_cores - cores_image_capture, 1) #The time(in millis) is takes to capture an Image #Frame rate = 1000/captureTime #****On some cameras frame rate is dependent on camera exposure level #****i.e. dark = slower fps and light = fast frame rate #****Capture time is dependent on available CPU #This time will be dynamically calculated using an rolling average self.captureTime = 0 self.captureTimeSet = np.zeros(4) #The time(in millis) it takes to process an image #****Process time is dependent on available CPU and the image #This time will be dynamically calculated using an rolling average self.processTime = 0 self.processTimeSet = np.zeros(4) #How often a image is dispatched to be processed(in millis) #Determined by splitting up processTime among available number of cores #*****This will not be smaller than captureTime because we won't allow it to process frames more often than capturing frames; it will cause sync issues with Pipe() #*****If the CPU is slow and has limited cores, we may process everyother frame or every nth frame!!! #runTime = max(processTime/processing_cores,captureTime) self.runTime = 0 #set up a pipe to pass info between background processes and dispatcher self.parent_conn, self.child_conn = multiprocessing.Pipe() #last time we started to process an image self.lastDispatch = 0 #last time an image process completed self.lastRetreival = 0
def __init__(self): #The number of core to be used while processing image data #This number may be less than the actaul number of cores on the CPU depending on the users specifications #cores = min(desiredCores, multiprocessing.cpu_count()) //dont allow more cores than the CPU has available and don;t run more than the user wants desired_cores = VN_config.get_integer('processing', 'desired_cores', 4) available_cores = min(desired_cores, multiprocessing.cpu_count()) #check if a core is already in use for background image capture cores_image_capture = int(VN_config.get_boolean('processing','background_capture', True)) self.cores_processing = max(available_cores - cores_image_capture,1) #The time(in millis) is takes to capture an Image #Frame rate = 1000/captureTime #****On some cameras frame rate is dependent on camera exposure level #****i.e. dark = slower fps and light = fast frame rate #****Capture time is dependent on available CPU #This time will be dynamically calculated using an rolling average self.captureTime = 0 self.captureTimeSet = np.zeros(4) #The time(in millis) it takes to process an image #****Process time is dependent on available CPU and the image #This time will be dynamically calculated using an rolling average self.processTime = 0 self.processTimeSet = np.zeros(4) #How often a image is dispatched to be processed(in millis) #Determined by splitting up processTime among available number of cores #*****This will not be smaller than captureTime because we won't allow it to process frames more often than capturing frames; it will cause sync issues with Pipe() #*****If the CPU is slow and has limited cores, we may process everyother frame or every nth frame!!! #runTime = max(processTime/processing_cores,captureTime) self.runTime = 0 #set up a pipe to pass info between background processes and dispatcher self.parent_conn, self.child_conn = multiprocessing.Pipe() #last time we started to process an image self.lastDispatch = 0 #last time an image process completed self.lastRetreival = 0
def __init__(self): # get which camera we will use self.camera_index = VN_config.get_integer('camera', 'index', 0) # get image resolution self.img_width = VN_config.get_integer('camera', 'width', 640) self.img_height = VN_config.get_integer('camera', 'height', 480) # get image center self.img_center_x = self.img_width / 2 self.img_center_y = self.img_height / 2 # define field of view self.cam_hfov = VN_config.get_float('camera', 'horizontal-fov', 70.42) self.cam_vfov = VN_config.get_float('camera', 'vertical-fov', 43.3) #get camera distortion matrix and intrinsics. Defaults: logitech c920 mtx = np.array([[614.01269552, 0, 315.00073982], [0, 614.43556296, 237.14926858], [0, 0, 1.0]]) dist = np.array( [0.12269303, -0.26618881, 0.00129035, 0.00081791, 0.17005303]) self.matrix = VN_config.get_array('camera', 'matrix', mtx) self.distortion = VN_config.get_array('camera', 'distortion', dist) self.newcameramtx, self.roi = cv2.getOptimalNewCameraMatrix( self.matrix, self.distortion, (self.img_width, self.img_height), 1, (self.img_width, self.img_height)) #create a camera object self.camera = None #number of cores available for use desiredCores = VN_config.get_integer('processing', 'desired_cores', 4) self.cores_available = min(desiredCores, multiprocessing.cpu_count()) #does the user want to capture images in the background self.background_capture = VN_config.get_boolean( 'processing', 'background_capture', True) # background image processing variables self.proc = None # background process object self.parent_conn = None # parent end of communicatoin pipe self.img_counter = 0 # num images requested so far self.is_backgroundCap = False #state variable for background capture
def __init__(self): # add variable initialisation here self.api = None self.vehicle = None self.last_mode_call = 0 self.last_mode_state = 'STABILIZE' self.mode_update_rate = VN_config.get_float('vehicle control', 'mode_update_rate', 0.75) self.last_home_call = 0 self.last_home = None self.home_update_rate = VN_config.get_float('vehicle control', 'home_update_rate', 10) self.last_set_velocity = 0 self.vel_update_rate = VN_config.get_float('vehicle control', 'vel_update_rate', 0.1) self.last_report_landing_target = 0 self.landing_update_rate = VN_config.get_float('vehicle control', 'landing_update_rate', 0.02)
def __init__(self): # create sub driectory for logs and videos self.location = VN_config.get_string("logging", "location", os.environ["HOME"] + "/visnav/") path = self.location + "logs" if not os.path.exists(path): os.makedirs(path) path = self.location + "vids" if not os.path.exists(path): os.makedirs(path) # set default startegy name self.strat_name = "Smart_Camera" # get image resolution self.img_width = VN_config.get_integer("camera", "width", 640) self.img_height = VN_config.get_integer("camera", "height", 480) #####TEXT LOGGING###### # levels = 'debug' , 'general' , 'aircraft' , 'algorithm' , ' performance' # multiple message levels can be selected by concatination strings i.e. 'debug, aircraft' # what type of messages we print to the terminal self.print_level = VN_config.get_string("logging", "print_level", "debug, general") # what type of messages we log to a file self.log_level = VN_config.get_string("logging", "log_level", "aircraft, algorithm, general") #####VIDEO RECORDING###### # levels = 'frame' , 'gui' # multiple message levels can be selected at once by concatination strings i.e. 'frame, gui' # what type of images we display on the screen self.display_level = VN_config.get_string("logging", "display_level", "raw, gui") # what type of images we record self.record_level = VN_config.get_string("logging", "record_level", "raw") # Write a video or individual images self.record_type = VN_config.get_string("logging", "record_type", "image") # Note about useful logging practices: # Inorder to replay a flight through the program log_level must include 'aircraft' and 'algorithm' # record level must include 'frame' # all other logging levels are for user diagnostics # a list of video writers and their tag self.video_writers = [] # text logger self.logger = None
def __init__(self): #load config file VN_config.get_file('Smart_Camera') #get camera specs self.camera_index = VN_config.get_integer('camera','camera_index',0) self.camera_width = VN_config.get_integer('camera', 'camera_width', 640) self.camera_height = VN_config.get_integer('camera', 'camera_height', 480) self.camera_hfov = VN_config.get_float('camera', 'horizontal-fov', 72.42) self.camera_vfov = VN_config.get_float('camera', 'vertical-fov', 43.3) #use simulator self.simulator = VN_config.get_boolean('simulator','use_simulator',True) #Run the program no matter what mode or location; Useful for debug purposes self.always_run = VN_config.get_boolean('general', 'always_run', True) #how many frames have been captured self.frame_count = 0 #debugging: self.kill_camera = False
def __init__(self): #create sub driectory for logs and videos self.location = VN_config.get_string('logging','location','../../visnav/') path = self.location + 'logs' if not os.path.exists(path): os.makedirs(path) path = self.location + 'vids' if not os.path.exists(path): os.makedirs(path) #set default startegy name self.strat_name = 'Smart_Camera' # get image resolution self.img_width = VN_config.get_integer('camera','width',640) self.img_height = VN_config.get_integer('camera','height',480) #####TEXT LOGGING###### #levels = 'debug' , 'general' , 'aircraft' , 'algorithm' , ' performance' #multiple message levels can be selected by concatination strings i.e. 'debug, aircraft' #what type of messages we print to the terminal self.print_level = VN_config.get_string('logging','print_level','debug, general') #what type of messages we log to a file self.log_level = VN_config.get_string('logging','log_level','aircraft , algorithm, general') #####VIDEO RECORDING###### #levels = 'frame' , 'gui' #multiple message levels can be selected at once by concatination strings i.e. 'frame, gui' #what type of images we display on the screen self.display_level = VN_config.get_string('logging', 'display_level', 'raw, gui') #what type of images we record self.record_level = VN_config.get_string('logging', 'record_level', 'raw') #Note about useful logging practices: #Inorder to replay a flight through the program log_level must include 'aircraft' and 'algorithm' #record level must include 'frame' #all other logging levels are for user diagnostics #a list of video writers and their tag self.video_writers = [] #text logger self.logger = None
def __init__(self): self.targetLocation = PositionVector() self.vehicleLocation = PositionVector() self.backgroundColor = (74,88,109) #load target filename = VN_config.get_string('simulator', 'target_location', '../../visnav/target.jpg') target_size = VN_config.get_float('algorithm', 'outer_ring', 1.0) self.load_target(filename,target_size) #define camera self.camera_width = VN_config.get_integer('camera', 'width', 640) self.camera_height = VN_config.get_integer('camera', 'height', 640) self.camera_vfov = VN_config.get_float('camera', 'vertical-fov',72.42 ) self.camera_hfov = VN_config.get_float('camera', 'horizontal-fov', 72.42) self.camera_fov = math.sqrt(self.camera_vfov**2 + self.camera_hfov**2) self.camera_frameRate = 30
def __init__(self): self.targetLocation = PositionVector() self.vehicleLocation = PositionVector() self.backgroundColor = (74, 88, 109) #load target filename = VN_config.get_string('simulator', 'target_location', '../../visnav/target.jpg') target_size = VN_config.get_float('algorithm', 'outer_ring', 1.0) self.load_target(filename, target_size) #define camera self.camera_width = VN_config.get_integer('camera', 'width', 640) self.camera_height = VN_config.get_integer('camera', 'height', 640) self.camera_vfov = VN_config.get_float('camera', 'vertical-fov', 72.42) self.camera_hfov = VN_config.get_float('camera', 'horizontal-fov', 72.42) self.camera_fov = math.sqrt(self.camera_vfov**2 + self.camera_hfov**2) self.camera_frameRate = 30
def __init__(self): #load algorithm constants #how round a circle needs to be. Perfect circle = 1 self.eccentricity = VN_config.get_float('algorithm', 'eccentricity', 0.6) #acceptable distance(pixels) between cocentric circle centers self.distance_threshold = VN_config.get_integer( 'algorithm', 'distance_threshold', 15) # number of circles needed for a valid target(times 2); 2 circles are often overlayed self.min_circles = VN_config.get_integer('algorithm', 'min_circls', 5) #pixels: used to identify repeat circles(stacked circles). Problem caused by findContours() self.radius_tolerance = VN_config.get_integer('algorithm', 'radius_tolerance', 2) #Tolerance used in comparing actaul ratios and preceived ratios self.ratio_tolerance = VN_config.get_float('algorithm', 'ratio_tolerance', 0.015) #target specific data #target_code is the unique ratio between rings target_code_def = np.array([0.8, 0.91, 0.76, 0.84, 0.7, 0.66, 0.49]) self.target_code = VN_config.get_array('algorithm', 'target_code', target_code_def) #the outer_ring is a scaling factor for targets of various sizes; radius of outer ring in meters self.outer_ring = VN_config.get_float('algorithm', 'outer_ring', 0.08255) #define field of view self.cam_hfov = VN_config.get_float('camera', 'horizontal-fov', 70.42) self.cam_vfov = VN_config.get_float('camera', 'vertical-fov', 43.3)\ #define camera size self.cam_width = VN_config.get_integer('camera', 'width', 640) self.cam_height = VN_config.get_integer('camera', 'height', 480)
def __init__(self): # load config file VN_config.get_file("Smart_Camera") # get camera specs self.camera_index = VN_config.get_integer("camera", "camera_index", 0) self.camera_width = VN_config.get_integer("camera", "camera_width", 640) self.camera_height = VN_config.get_integer("camera", "camera_height", 480) self.camera_hfov = VN_config.get_float("camera", "horizontal-fov", 72.42) self.camera_vfov = VN_config.get_float("camera", "vertical-fov", 43.3) # simulator self.simulator = VN_config.get_boolean("simulator", "use_simulator", True) self.target_file = VN_config.get_string( "simulator", "target_location", os.environ["HOME"] + "/visnav/target.jpg" ) self.target_size = VN_config.get_float("algorithm", "outer_ring", 1.0) # Run the program no matter what mode or location; Useful for debug purposes self.always_run = VN_config.get_boolean("general", "always_run", True) # how many frames have been captured self.frames_captured = 0 # debugging: self.kill_camera = False
def __init__(self): #load algorithm constants #how round a circle needs to be. Perfect circle = 1 self.eccentricity = VN_config.get_float('algorithm', 'eccentricity', 0.6) #acceptable distance(pixels) between cocentric circle centers self.distance_threshold = VN_config.get_integer('algorithm','distance_threshold', 15) # number of circles needed for a valid target(times 2); 2 circles are often overlayed self.min_circles = VN_config.get_integer('algorithm','min_circls',5) #pixels: used to identify repeat circles(stacked circles). Problem caused by findContours() self.radius_tolerance = VN_config.get_integer('algorithm', 'radius_tolerance', 2) #Tolerance used in comparing actaul ratios and preceived ratios self.ratio_tolerance = VN_config.get_float('algorithm', 'ratio_tolerance', 0.015) #target specific data #target_code is the unique ratio between rings target_code_def = np.array([0.8,0.91,0.76,0.84,0.7,0.66,0.49]) self.target_code = VN_config.get_array('algorithm', 'target_code',target_code_def) #the outer_ring is a scaling factor for targets of various sizes; radius of outer ring in meters self.outer_ring = VN_config.get_float('algorithm', 'outer_ring', 0.08255) #define field of view self.cam_hfov = VN_config.get_float('camera', 'horizontal-fov', 70.42) self.cam_vfov = VN_config.get_float('camera', 'vertical-fov', 43.3) #define camera size self.cam_width = VN_config.get_integer('camera', 'width', 640) self.cam_height = VN_config.get_integer('camera', 'height', 480)
def __init__(self): #load config file VN_config.get_file('Smart_Camera') #get camera specs self.camera_index = VN_config.get_integer('camera', 'camera_index', 0) self.camera_width = VN_config.get_integer('camera', 'camera_width', 640) self.camera_height = VN_config.get_integer('camera', 'camera_height', 480) self.camera_hfov = VN_config.get_float('camera', 'horizontal-fov', 72.42) self.camera_vfov = VN_config.get_float('camera', 'vertical-fov', 43.3) #simulator self.simulator = VN_config.get_boolean('simulator', 'use_simulator', True) self.target_file = VN_config.get_string( 'simulator', 'target_location', os.environ['HOME'] + '/visnav/target.jpg') self.target_size = VN_config.get_float('algorithm', 'outer_ring', 1.0) #Run the program no matter what mode or location; Useful for debug purposes self.always_run = VN_config.get_boolean('general', 'always_run', True) #how many frames have been captured self.frames_captured = 0 #debugging: self.kill_camera = False
#!/usr/bin/python #SYSTEM IMPORTS import numpy as np #COMMOM IMPORTS from Common.VN_config import VN_config #####ALGORITHM####### #how round a circle needs to be. Perfect circle = 1 VN_config.set_float('algorithm', 'eccentricity', 0.6) #acceptable distance(pixels) between cocentric circle centers VN_config.set_integer('algorithm', 'distance_threshold', 15) # number of circles needed for a valid target(times 2); 2 circles are often overlayed VN_config.set_integer('algorithm', 'min_circles', 5) #pixels: used to identify repeat circles(stacked circles). Problem caused by findContours() VN_config.set_integer('algorithm', 'radius_tolerance', 2) #Tolerance used in comparing actaul ratios and preceived ratios VN_config.set_float('algorithm', 'ratio_tolerance', 0.015) #target specific data #target_code is the unique ratio between rings target_code_def = np.array([0.8, 0.91, 0.76, 0.84, 0.7, 0.66, 0.49]) VN_config.set_array('algorithm', 'target_code', target_code_def) #the outer_ring is a scaling factor for targets of various sizes; radius of outer ring in meters VN_config.set_float('algorithm', 'outer_ring', 0.08255) ####PROCESSING####### VN_config.set_integer('processing', 'desired_cores', 4) #check if a core is already in use for background image capture
#!/usr/bin/python #SYSTEM IMPORTS import numpy as np #COMMOM IMPORTS from Common.VN_config import VN_config #####ALGORITHM####### #how round a circle needs to be. Perfect circle = 1 VN_config.set_float('algorithm', 'eccentricity', 0.6) #acceptable distance(pixels) between cocentric circle centers VN_config.set_integer('algorithm','distance_threshold', 15) # number of circles needed for a valid target(times 2); 2 circles are often overlayed VN_config.set_integer('algorithm','min_circles',5) #pixels: used to identify repeat circles(stacked circles). Problem caused by findContours() VN_config.set_integer('algorithm', 'radius_tolerance', 2) #Tolerance used in comparing actaul ratios and preceived ratios VN_config.set_float('algorithm', 'ratio_tolerance', 0.015) #target specific data #target_code is the unique ratio between rings target_code_def = np.array([0.8,0.91,0.76,0.84,0.7,0.66,0.49]) VN_config.set_array('algorithm', 'target_code',target_code_def) #the outer_ring is a scaling factor for targets of various sizes; radius of outer ring in meters VN_config.set_float('algorithm', 'outer_ring', 0.08255)