def __init__(self): threading.Thread.__init__(self) #MQTT IP for widefind self.broker_url = "130.240.114.24" self.broker_port = 1883 #DATA must be sent inside an event object self.event = {} self.pos = {} self.ids = [] self.debug = False self.person = [0, 0, 0] self.p1 = [0, 0, 0] #self.cameraRoof = [3141, -3812, 1220] self.camera = [3261, -3800, 740] self.cameraFloor = [3635, -4074, 418] # Object controlling the camera self.c = Camera() self.following = False self.rotation = 0 self.client = mqtt.Client() self.client.on_connect = self.on_connect self.client.on_message = self.on_message
def __init__(self, url, id, token, save_record, default_mode): self.cam = Camera() self.detector = detector(self.cam) self.detector_thread = None self.save_record = save_record self.default_mode = default_mode self.running = False self.state = { "server": { "mode": default_mode }, "client": { "mode": default_mode }, } self.mode_change = False self.last_mode_check = 0 self.save_path = "/dev/shm/" self.disk_space = {} self.url = url self.id = id self.token = token self.mask_image = (np.ones((100, 100)), 0, [])
def set_pixel_array(self, pixel_array, **kwargs): Camera.set_pixel_array(self, pixel_array, **kwargs) for shifted_camera in self.shifted_cameras: shifted_camera.camera.set_pixel_array( pixel_array[shifted_camera.start_y:shifted_camera.end_y, shifted_camera.start_x:shifted_camera.end_x], **kwargs)
def __init__(self, frame, **kwargs): """ frame is a Mobject, (should be a rectangle) determining which region of space the camera displys """ self.frame = frame Camera.__init__(self, **kwargs)
def main(): # Clear the screen subprocess.call('clear', shell=True) config_object = Config(os.getcwd() + '/config/config.ini').raw_config_object transport = UdpSocket(config_object) camera = Camera(config_object) if config_object['COMPRESSION']['switch'] == 'On': compressor = Compressor(config_object) transport.add_compression(compressor) if config_object['ENCRYPTION']['switch'] == 'On': # encryptor = Encryptor(config_object) # transport.add_encryption(encryptor) pass try: while True: time.sleep(float(config_object['QUALITY']['delay'])) image = camera.get_frame() transport.send_data(image) except LookupError as e: print(e) sys.exit(2) except KeyboardInterrupt: print('keyboard interruption') sys.exit(1)
class MainLoop(Thread): def __init__(self): Thread.__init__(self) self.camera = Camera() self.detector = Detector() self.stop_loop = False self.telemetry = Telemetry() self.position_calculator = PositionCalculator() self.frame = None def run(self): if Values.PRINT_FPS: last_time = time.time() ind = 0 while True: try: if self.stop_loop: break #self.frame = cv2.imread("images/pole_new.jpg") self.frame = self.camera.get_frame() #self.frame = cv2.resize(self.frame, (Values.CAMERA_WIDTH, Values.CAMERA_HEIGHT)) if self.frame is None: continue detections = self.detector.detect(self.frame) self.telemetry.update_telemetry() self.position_calculator.update_meters_per_pixel( self.telemetry.altitude) self.position_calculator.calculate_max_meters_area() for d in detections: lat, lon = self.position_calculator.calculate_point_lat_long( d.middle_point, self.telemetry.latitude, self.telemetry.longitude, self.telemetry.azimuth) d.update_lat_lon(lat, lon) d.area_m = self.position_calculator.calculate_area_in_meters_2( d.area) d.draw_detection(self.frame) cv2.imshow("frame", self.frame) if cv2.waitKey(1) & 0xFF == ord('q'): break if Values.PRINT_FPS: ind += 1 if time.time() - last_time > 1: print("FPS:", ind) ind = 0 last_time = time.time() except Exception as e: print("Some error accrued: ", str(e)) self.close() def close(self): self.camera.close() self.stop_loop = True
def __init__(self): Thread.__init__(self) self.camera = Camera() self.detector = Detector() self.stop_loop = False self.telemetry = Telemetry() self.position_calculator = PositionCalculator() self.frame = None
def __init__(self): self.distance = Echo() self.camera = Camera() self.imageMod = ImageMod() self.img = None self.cm = -1 self.rec = ('None', 0) self.counter = 0
def __init__(self, *args, **kwargs): Camera.__init__(self, *args, **kwargs) self.phi_tracker = ValueTracker(self.phi) self.theta_tracker = ValueTracker(self.theta) self.distance_tracker = ValueTracker(self.distance) self.gamma_tracker = ValueTracker(self.gamma) self.light_source = Point(self.light_source_start_point) self.frame_center = Point(self.frame_center) self.reset_rotation_matrix()
def set_pixel_array(self, pixel_array, **kwargs): Camera.set_pixel_array(self, pixel_array, **kwargs) for shifted_camera in self.shifted_cameras: shifted_camera.camera.set_pixel_array( pixel_array[ shifted_camera.start_y:shifted_camera.end_y, shifted_camera.start_x:shifted_camera.end_x], **kwargs )
def __init__(self, *args, **kwargs): Camera.__init__(self, *args, **kwargs) self.unit_sun_vect = self.sun_vect / np.linalg.norm(self.sun_vect) ## rotation_mobject lives in the phi-theta-distance space self.rotation_mobject = VectorizedPoint() ## moving_center lives in the x-y-z space ## It representes the center of rotation self.moving_center = VectorizedPoint(self.space_center) self.set_position(self.phi, self.theta, self.distance)
def __init__(self, frame=None, **kwargs): """ frame is a Mobject, (should be a rectangle) determining which region of space the camera displys """ if frame is None: frame = ScreenRectangle(height=FRAME_HEIGHT) frame.fade(1) self.frame = frame Camera.__init__(self, **kwargs)
def __init__(self, *cameras_with_start_positions, **kwargs): self.shifted_cameras = [ DictAsObject( { "camera" : camera_with_start_positions[0], "start_x" : camera_with_start_positions[1][1], "start_y" : camera_with_start_positions[1][0], "end_x" : camera_with_start_positions[1][1] + camera_with_start_positions[0].pixel_shape[1], "end_y" : camera_with_start_positions[1][0] + camera_with_start_positions[0].pixel_shape[0], }) for camera_with_start_positions in cameras_with_start_positions ] Camera.__init__(self, **kwargs)
def display_multiple_vectorized_mobjects(self, vmobjects, pixel_array): rot_matrix = self.get_rotation_matrix() def z_key(vmob): # Assign a number to a three dimensional mobjects # based on how close it is to the camera if vmob.shade_in_3d: return np.dot(vmob.get_center(), rot_matrix.T)[2] else: return np.inf Camera.display_multiple_vectorized_mobjects( self, sorted(vmobjects, key=z_key), pixel_array)
def __init__(self, *cameras_with_start_positions, **kwargs): self.shifted_cameras = [ DictAsObject( { "camera": camera_with_start_positions[0], "start_x": camera_with_start_positions[1][1], "start_y": camera_with_start_positions[1][0], "end_x": camera_with_start_positions[1][1] + camera_with_start_positions[0].get_pixel_width(), "end_y": camera_with_start_positions[1][0] + camera_with_start_positions[0].get_pixel_height(), }) for camera_with_start_positions in cameras_with_start_positions ] Camera.__init__(self, **kwargs)
def add(self, model): if self.is_exist(model.manage_url): return False camera = Camera(model, notifier=self.notifier, object_detector_queue=self.object_detector_queue) camera.add_to_homekit(self.homekit_bridge) self.cameras[camera.id] = camera return camera
def __init__(self, frame=None, **kwargs): """ frame is a Mobject, (should almost certainly be a rectangle) determining which region of space the camera displys """ digest_config(self, kwargs) if frame is None: frame = ScreenRectangle(height=FRAME_HEIGHT) frame.set_stroke( self.default_frame_stroke_color, self.default_frame_stroke_width, ) self.frame = frame Camera.__init__(self, **kwargs)
def capture_mobjects(self, mobjects, **kwargs): mobjects = self.get_mobjects_to_display(mobjects, **kwargs) if self.allow_object_intrusion: mobject_copies = mobjects else: mobject_copies = [mobject.copy() for mobject in mobjects] for mobject in mobject_copies: if isinstance(mobject, VMobject) and \ 0 < mobject.get_num_anchor_points() < self.min_anchor_points: mobject.insert_n_anchor_points(self.min_anchor_points) Camera.capture_mobjects( self, mobject_copies, include_submobjects=False, excluded_mobjects=None, )
def capture_mobjects(self, mobjects, **kwargs): mobjects = self.get_mobjects_to_display(mobjects, **kwargs) if self.allow_object_intrusion: mobject_copies = mobjects else: mobject_copies = [mobject.copy() for mobject in mobjects] for mobject in mobject_copies: if isinstance(mobject, VMobject) and \ 0 < mobject.get_num_anchor_points() < self.min_anchor_points: mobject.insert_n_anchor_points(self.min_anchor_points) Camera.capture_mobjects( self, mobject_copies, include_submobjects = False, excluded_mobjects = None, )
def video_stream(): def gen(camera): while True: frame = camera.get_frame() yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n') return Response(gen(Camera()), mimetype='multipart/x-mixed-replace; boundary=frame')
def main(): # Clear the screen subprocess.call("clear", shell=True) config_object = Config(os.getcwd() + "/config/config.ini").raw_config_object try: """ need to spin the threads and get all the jazz up and running probably need a separate config parser and starter classes...? """ mic = Mic(config_object) camera = Camera(config_object) archiver = Archiver(config_object) mailer = Mailer(config_object) while True: mic_response = mic.send({"action": "listen"}) print(".", end="", flush=True) if mic_response == mic.MIC_DONE: camera_res = camera.send({"action": "photos"}) print("taking photos") if camera_res == camera.CAMERA_DONE: archiver_res = archiver.send({"action": "archive"}) print("archiving...") if archiver_res == archiver.ARCHIVER_DONE and archiver.zfilename is not None: print("sending mail") mailer_done = mailer.send({"action": "last", "last_archive_name": archiver.zfilename}) if mailer_done == mailer.MAILER_DONE: print("...cleaning up") archiver.send({"action": "clearup"}) print("cycle done...") except LookupError as e: print(e) sys.exit(2) except KeyboardInterrupt: print("keyboard interruption") camera.close() mic.close() archiver.close() mailer.close() sys.exit(1)
def points_to_pixel_coords(self, points): distance_ratios = np.divide(self.camera_distance, self.camera_distance - points[:, 2]) scale_factors = interpolate(0, 1, distance_ratios) adjusted_points = np.array(points) for i in 0, 1: adjusted_points[:, i] *= scale_factors return Camera.points_to_pixel_coords(self, adjusted_points)
class CVProcess(multiprocessing.Process): def __init__(self, results): super().__init__() print("DEBUG: CVProcess spawned") self.results = results self.camera = Camera(verbose=True) self.lane_recognizer = LaneRecognizer(self.camera) def replace_none(self, val): return val if val is not None else float("nan") def retrieve_state(self): self.results[0] = self.replace_none(self.lane_recognizer.curve_radius) self.results[1] = self.replace_none(self.lane_recognizer.lateral_deviation) self.results[2] = self.replace_none(self.lane_recognizer.last_valid) def stop(self): self.camera.stop_measuring() self.lane_recognizer.stop_measuring()
def __init__(self, mob, iterations=5, radius=10, alpha=30, camera=None): if camera is None: from camera.camera import Camera camera = Camera() arr = mob.get_binary_array() arr = ndimage.binary_dilation( arr, structure=circular_binary_structure(radius), iterations=iterations, ) pixel_list = np.column_stack(np.where(arr == 1)).astype("float64") concave_hull = list( alpha_shape(pixel_list, alpha=alpha, only_outer=True)) # sort edges for i, first in enumerate(concave_hull): loop = True for j, second in enumerate(concave_hull[i + 1:]): j += i + 1 if first[1] == second[0]: loop = False concave_hull[i + 1], concave_hull[j] = \ concave_hull[j], concave_hull[i + 1] if loop and i != len(concave_hull) - 1: warnings.warn( "the alpha shape in split into different parts. This can " "be fixed by increasing alpha.") print(i, len(concave_hull)) # breakpoint(context=9) pass temp = np.zeros((len(concave_hull) + 1, 2)) for i, pair in enumerate(concave_hull): temp[i] = pixel_list[pair[0]] temp[-1] = pixel_list[concave_hull[0][0]] pixel_list = temp point_list = np.zeros((pixel_list.shape[0], pixel_list.shape[1] + 1)) point_list[:, 0] = pixel_list[:, 0] * camera.frame_height / camera.pixel_height point_list[:, 1] = -pixel_list[:, 1] * camera.frame_width / camera.pixel_width # TODO: figure out optimal num_anchor_points ParametricFunction.__init__( self, lambda t, point_list=point_list: point_list[int(t)], t_min=0, t_max=len(point_list) - 1, scale_handle_to_anchor_distances_after_applying_functions=False, ) self.move_to(mob.get_center())
def get_mobjects_to_display(self, *args, **kwargs): mobjects = Camera.get_mobjects_to_display(self, *args, **kwargs) rot_matrix = self.get_rotation_matrix() def z_key(mob): if not (hasattr(mob, "shade_in_3d") and mob.shade_in_3d): return np.inf # Assign a number to a three dimensional mobjects # based on how close it is to the camera return np.dot(mob.get_center(), rot_matrix.T)[2] return sorted(mobjects, key=z_key)
def display_multiple_vectorized_mobjects(self, vmobjects): camera_point = self.spherical_coords_to_point( *self.get_spherical_coords()) def z_cmp(*vmobs): # Compare to three dimensional mobjects based on # how close they are to the camera # return cmp(*[ # -np.linalg.norm(vm.get_center()-camera_point) # for vm in vmobs # ]) three_d_status = map(should_shade_in_3d, vmobs) has_points = [vm.get_num_points() > 0 for vm in vmobs] if all(three_d_status) and all(has_points): cmp_vect = self.get_unit_normal_vect(vmobs[1]) return cmp( *[np.dot(vm.get_center(), cmp_vect) for vm in vmobs]) else: return 0 Camera.display_multiple_vectorized_mobjects( self, sorted(vmobjects, cmp=z_cmp))
def test(): server = CameraServer() camera = Camera() tracker = ObjectTracker() def update(time): frame = camera.update() masked, pos, radius = tracker.find_object(frame, draw_circle=True) server.put_images(frame, masked) updater = Updater(0.01) updater.add(update) while updater.timer < 120: updater.update() server.stop()
def __init__(self, config_path): self.config = configparser.ConfigParser() self.config.read(config_path) self.config_path = config_path self.instantiating_time = time.time() self.picture_interval = self.config['SCHEDULE'].getfloat('PictureInterval') self.start_time = self.convert_time_str(self.config['SCHEDULE'].get('StartTime')) self.end_time = self.convert_time_str(self.config['SCHEDULE'].get('EndTime')) - self.start_time self.w_capture = self.config['SCHEDULE'].get('WithCapture') self.w_prediction = self.config['SCHEDULE'].get('WithPrediction') self.buffer_time = self.config['SCHEDULE'].getint('PictureBufferTime') self.camera_output_dir = self.config['CAMERA'].get('CameraOutputDirectory') self.prediction_output_dir = self.config['PREDICTION'].get('PredictionOutputDirectory') self.compiler = Compiler(config_path) self.camera = Camera(config_path) self.schedule = sched.scheduler(time.time, time.sleep)
def get_binary_array(self, camera=None): if camera is None: from camera.camera import Camera camera = Camera() camera.capture_mobject(self) camera.get_image().save("lmao.png") # why the transpose? arr = np.int16(np.all(camera.pixel_array[:, :, :3] == 0, axis=2)).T return arr
def __init__(self): self.Serial = ArduinoSerial('/dev/ttyACM0', 115200) # TODO: Riconoscere seriale self.Color = Color(self.Serial) self.Distance = [Distance(self.Serial, i) for i in range(1, 4)] self.Gyroscope = Gyroscope(self.Serial) self.Temperature = [Temperature(self.Serial, i) for i in range(1, 4)] self.Camera = Camera() self.Motor = Motor(self.Serial) self.Servo = Servo(self.Serial) self.Sensors = [self.Color, self.Distance, self.Gyroscope, self.Temperature] self.Maze = Maze(self.Sensors, self.Servo, self.Camera) self.ActualX = self.Maze.StartX self.ActualY = self.Maze.StartY self.ActualZ = self.Maze.StartZ self.StartTime = 0 self.StartHeading = 0 self.stop()
def __init__(self): gpio = pigpio.pi() self.Color = Color(7) self.Distance = [Distance(2), Distance(3), Distance(0), Distance(1)] self.Gyroscope = Gyroscope('/dev/ttyAMA0') self.Temperature = [Temperature(i) for i in range(85, 89)] self.Camera = Camera() self.LedRed = Led(gpio, 20) self.LedYellow = Led(gpio, 21) self.LedRed.off() self.LedYellow.off() self.ButtonStart = Button(gpio, 9) self.ButtonStop = Button(gpio, 10) self.Motor = [Motor(19, 11, 26), Motor(13, 6, 5)] self.Servo = Servo(gpio, 12) self.Sensors = [ self.Color, self.Distance, self.Gyroscope, self.Temperature ] self.Actuators = [self.LedRed, self.Servo] self.Maze = Maze(self.Sensors, self.Actuators, self.Camera) self.ActualX = self.Maze.StartX self.ActualY = self.Maze.StartY self.ActualZ = self.Maze.StartZ self.StartTime = 0 self.StartHeading = 0 self._stop()
import sys from PyQt4 import QtGui from gui.gui import Gui from gui.threadgui import ThreadGui from camera.camera import Camera from camera.threadcamera import ThreadCamera import signal signal.signal(signal.SIGINT, signal.SIG_DFL) if __name__ == '__main__': camera = Camera() print(camera) app = QtGui.QApplication(sys.argv) window = Gui() window.setCamera(camera) window.show() t1 = ThreadCamera(camera) t1.start() t2 = ThreadGui(window) t2.start() sys.exit(app.exec_())
def video(request): return StreamingHttpResponse( gen(Camera()), content_type="multipart/x-mixed-replace; boundary=frame")
def __init__(self, frame_retrieval, index=0, manager=None): Camera.__init__(self, frame_retrieval) self.index = index self.manager = manager
def init_background(self): Camera.init_background(self) for shifted_camera in self.shifted_cameras: shifted_camera.camera.init_background()
class GameCore: def __init__(self, _main): self.main = _main ## Set parent nodes in the scenegraph self.physicsParentNode = render.attachNewNode("physicsParentNode") self.levelParentNode = render.attachNewNode("levelParentNode") self.objectsParentNode = render.attachNewNode("objectsParentNode") self.lightsParentNode = render.attachNewNode("lightsParentNode") self.aiParentNode = render.attachNewNode("aiParentNode") ## Start Event Manager self.eventMgr = EventMgr(self) def startGame(self, _playerName="DefaultPlayer"): self.autoShader() self.eventMgr.start() print "---> Started EventSystem" self.loadPhysicsSystem() print "---> Loaded Physics System" self.loadInputSystem() print "---> Loaded Input System" self.loadLevelSystem() print "---> Loaded Level System" self.loadPlayerSystem() print "---> Loaded Player System" self.loadCameraSystem() print "---> Loaded Camera System" def stopGame(self): pass ##------- SUB SYSTEMS -------## def loadPhysicsSystem(self): self.physicsMgr = PhysicsMgr(self) self.physicsMgr.startPhysics() self.physicsMgr.setPhysicsDebug() def loadInputSystem(self): self.input = Input(self) #self.input.start() def loadLevelSystem(self): self.level = Level(self) self.level.buildLevel("assets/level/intro") self.level.start() def loadPlayerSystem(self): self.player = Player(self, "Main Man") self.player.start() def loadCameraSystem(self): self.camera = Camera(self) self.camera.start() def autoShader(self): render.setShaderAuto()
def loadCameraSystem(self): self.camera = Camera(self) self.camera.start()
def get_image(self, camera=None): if camera is None: from camera.camera import Camera camera = Camera() camera.capture_mobject(self) return camera.get_image()
def points_to_pixel_coords(self, points): return Camera.points_to_pixel_coords(self, np.apply_along_axis(self.mapping_func, 1, points))