def main(): logging.basicConfig(format='%(levelname)s: %(name)s: %(message)s', level=logging.WARNING) gp.check_result(gp.use_python_logging()) camera = gp.check_result(gp.gp_camera_new()) gp.check_result(gp.gp_camera_init(camera)) print('Getting list of files') files = list_files(camera) if not files: print('No files found') return 1 path = files[0] print('Copying %s to memory' % path) folder, name = os.path.split(path) camera_file = gp.check_result( gp.gp_camera_file_get(camera, folder, name, gp.GP_FILE_TYPE_NORMAL)) ## # read file data using 'slurp' and a buffer allocated in Python ## info = gp.check_result( ## gp.gp_camera_file_get_info(camera, folder, name)) ## file_data = bytearray(info.file.size) ## count = gp.check_result(gp.gp_file_slurp(camera_file, file_data)) ## print(count, 'bytes read') # or read data using 'get_data_and_size' which allocates its own buffer file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) data = memoryview(file_data) print(type(data), len(data)) print(data[:10].tolist()) image = Image.open(io.BytesIO(file_data)) image.show() print('After deleting camera_file and file_data') del camera_file, file_data print(type(data), len(data)) print(data[:10].tolist()) gp.check_result(gp.gp_camera_exit(camera)) return 0
async def capture_preview(self): """ Capture preview image (doesn't engage curtain) """ with (await self._lock): file = gp.check_result(gp.gp_camera_capture_preview(self._camera, self._context)) data = gp.check_result(gp.gp_file_get_data_and_size(file)) return bytes(data)
def main(): logging.basicConfig( format='%(levelname)s: %(name)s: %(message)s', level=logging.WARNING) gp.check_result(gp.use_python_logging()) camera = gp.check_result(gp.gp_camera_new()) context = gp.gp_context_new() gp.check_result(gp.gp_camera_init(camera, context)) print('Getting list of files') files = list_files(camera, context) if not files: print('No files found') return 1 path = files[0] print('Copying %s to memory' % path) folder, name = os.path.split(path) camera_file = gp.check_result(gp.gp_camera_file_get( camera, folder, name, gp.GP_FILE_TYPE_NORMAL, context)) data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) print(type(data), len(data)) if six.PY2: print(map(ord, data[0:10])) image = Image.open(StringIO.StringIO(data)) else: print(data[0:10]) image = Image.open(io.BytesIO(data)) image.show() print('After deleting camera_file') del camera_file print(type(data), len(data)) if six.PY2: print(map(ord, data[0:10])) else: print(data[0:10]) gp.check_result(gp.gp_camera_exit(camera, context)) return 0
def capture(self, filename=None): """Capture a picture in a file. If no filename given a PIL image is returned. """ camera_file = self._cam.capture_preview() file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) image = Image.open(io.BytesIO(memoryview(file_data))) image = image.resize(pictures.resize_keep_aspect_ratio(image.size, self.resolution, 'outer'), Image.ANTIALIAS) image = image.crop(pictures.resize_by_croping(image.size, self.resolution)) # Resize to the window rect (outer because rect already resized innner, see 'get_rect') rect = self.get_rect() size = pictures.resize_keep_aspect_ratio(image.size, (rect.width, rect.height), 'outer') if self._preview_hflip: self._window.show_image(image.transpose(Image.FLIP_LEFT_RIGHT).resize(size)) else: self._window.show_image(image.resize(size)) if self._capture_hflip: image = image.transpose(Image.FLIP_LEFT_RIGHT) if filename: image.save(filename) return filename else: return image
def _get_preview_capture(self): """Capture a new preview image. """ with timeit('Capturing new preview image'): camera_file = self._cam.capture_preview() file_data = gp.check_result( gp.gp_file_get_data_and_size(camera_file)) image = Image.open(io.BytesIO(memoryview(file_data))) if self._preview_hflip: image = image.transpose(Image.FLIP_LEFT_RIGHT) if self._rotation: image = image.rotate(self._rotation) image = image.resize( sizing.new_size_keep_aspect_ratio(image.size, self.resolution, 'outer')) image = image.crop( sizing.new_size_by_croping(image.size, self.resolution)) # Resize to the window rect (outer because rect already resized innner, see 'get_rect') rect = self.get_rect() return image.resize( sizing.new_size_keep_aspect_ratio(image.size, (rect.width, rect.height), 'outer'))
def __take_preview_pic(self): print 'camera.__take_preview_pic' image = QtGui.QImage() if not self.use_real_camera: image.load('./data/preview.jpg') else: camera_file = gp.check_result(gp.gp_camera_capture_preview(self.__camera, self.__context)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) image_data = io.BytesIO(file_data) self.__pub_image(image_data.getvalue()) image.loadFromData(image_data.getvalue()) if self.__count_down_start!=None and self.draw_countdown: p = QtGui.QPainter(image) p.setPen(Camera.countdown_pen) size = 180 p.setFont(QtGui.QFont("Arial",size)) p.drawText((image.width()+size)/2, (image.height()+size)/2, '%i'%(self.__count_down_n)) p.end() image = image.scaledToHeight(self.__preview_height, transformMode=QtCore.Qt.SmoothTransformation) self.new_preview_image.emit(image.transformed(self.__preview_transform))
def initializecamera(): global camera #相机 global back_path #背景图路径 global img_back1 #背景图 global image_width #相机预览图的宽 global image_height #相机预览图的高 global scale_factor #获取图像缩小的倍数 global screen_width, screen_height Killgphoto2Process() #先停止gphoto2 运行线程 camera = gp.check_result(gp.gp_camera_new()) gp.check_result(gp.gp_camera_init(camera)) camera_file = gp.check_result(gp.gp_camera_capture_preview(camera)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) image = Image.open(io.BytesIO(file_data)) frame = np.array(image) image_height, image_width = frame.shape[:2] # 获得相机预览图片大小 print('相机预览画面 宽/高=', image_width,'/', image_height) img_back1 = cv.imread(back_path) # 绿幕背景图片 img_back1 = cv.resize(img_back1,(image_width,image_height)) # 改变背景图片分辨率 if image_width > 900: scale_factor = 0.5 else: scale_factor = 1
def main(): logging.basicConfig( format='%(levelname)s: %(name)s: %(message)s', level=logging.WARNING) gp.check_result(gp.use_python_logging()) camera = gp.check_result(gp.gp_camera_new()) context = gp.gp_context_new() gp.check_result(gp.gp_camera_init(camera, context)) print('Getting list of files') files = list_files(camera, context) if not files: print('No files found') return 1 path = files[0] print('Copying %s to memory' % path) folder, name = os.path.split(path) camera_file = gp.check_result(gp.gp_camera_file_get( camera, folder, name, gp.GP_FILE_TYPE_NORMAL, context)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) data = memoryview(file_data) print(type(data), len(data)) print(data[:10].tolist()) image = Image.open(io.BytesIO(file_data)) image.show() print('After deleting camera_file and file_data') del camera_file, file_data print(type(data), len(data)) print(data[:10].tolist()) gp.check_result(gp.gp_camera_exit(camera, context)) return 0
def take_picture(camera: gp.camera, rotation_pos: int, declination_pos: int, queue: beanstalk.Connection) -> str: """take a picture and save it to the USB drive or the google drive, if specified""" # take the picture file_path = gp.check_result(gp.gp_camera_capture( camera, gp.GP_CAPTURE_IMAGE)) file_name = 'P{dec:02d}{rot:02d}_'.\ format(dec=declination_pos, rot=rotation_pos) + file_path.name # read the photo from the camera camera_file = gp.check_result(gp.gp_camera_file_get(camera, file_path.folder, file_path.name, gp.GP_FILE_TYPE_NORMAL)) # if a google drive isn't specified, write to the local USB drive # read the image from the camera into memory # and upload it file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) # okay, upload to the Google drive via a thread... byte_stream = io.BytesIO(file_data) camera_bytes = byte_stream.read(-1) job = {'task': 'photo', 'filename': file_name, 'data': base64.encodebytes(camera_bytes).decode('ascii')} # now send the photo to the Google Drive process queue.use(google_drive.GDRIVE_QUEUE) job_str = json.dumps(job) print("photo job size is {0} bytes".format(len(job_str))) queue.put(job_str) return file_name
def update(self): # keep looping infinitely until the thread is stopped while True: camera_file = gp.check_result( gp.gp_camera_capture_preview(self.camera)) file_data = gp.check_result( gp.gp_file_get_data_and_size(camera_file)) self.frame = memoryview(file_data) # if the capture indicator is set, grab full size pic if (self.shotRequested): file_path = self.camera.capture(gp.GP_CAPTURE_IMAGE) print('Camera file path: {0}/{1}'.format( file_path.folder, file_path.name)) print('Copying image to', '/tmp/still.jpg') camera_file = self.camera.file_get(file_path.folder, file_path.name, gp.GP_FILE_TYPE_NORMAL) camera_file.save('/tmp/still.jpg') #self.shot = memoryview(camera_file) self.shotRequested = False # if the thread indicator variable is set, stop the thread # and resource camera resources if self.stopped: self.camera.exit() return
def main(): logging.basicConfig( format='%(levelname)s: %(name)s: %(message)s', level=logging.WARNING) callback_obj = gp.check_result(gp.use_python_logging()) camera = gp.check_result(gp.gp_camera_new()) gp.check_result(gp.gp_camera_init(camera)) print('Getting list of files') files = list_files(camera) if not files: print('No files found') return 1 path = files[0] print('Copying %s to memory' % path) folder, name = os.path.split(path) camera_file = gp.check_result(gp.gp_camera_file_get( camera, folder, name, gp.GP_FILE_TYPE_NORMAL)) ## # read file data using 'slurp' and a buffer allocated in Python ## info = gp.check_result( ## gp.gp_camera_file_get_info(camera, folder, name)) ## file_data = bytearray(info.file.size) ## count = gp.check_result(gp.gp_file_slurp(camera_file, file_data)) ## print(count, 'bytes read') # or read data using 'get_data_and_size' which allocates its own buffer file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) data = memoryview(file_data) print(type(data), len(data)) print(data[:10].tolist()) image = Image.open(io.BytesIO(file_data)) image.show() print('After deleting camera_file and file_data') del camera_file, file_data print(type(data), len(data)) print(data[:10].tolist()) gp.check_result(gp.gp_camera_exit(camera)) return 0
def get_exif_extract_from_jpeg(self, folder: str, file_name: str) -> bytearray: """ Extract strictly the app1 (exif) section of a jpeg. Uses libgphoto2 to extract the exif header. Assumes jpeg on camera is straight from the camera, i.e. not modified by an exif altering program off the camera. :param folder: directory on the camera where the jpeg is stored :param file_name: name of the jpeg :return: first section of jpeg such that it can be read by exiv2 or similar """ camera_file = self._get_file(folder, file_name, None, gp.GP_FILE_TYPE_EXIF) try: exif_data = gp.check_result( gp.gp_file_get_data_and_size(camera_file)) except gp.GPhoto2Error as ex: logging.error( "Error getting exif info for %s from camera %s: %s", os.path.join(folder, file_name), self.display_name, gphoto2_named_error(ex.code), ) raise CameraProblemEx(code=CameraErrorCode.read, gp_exception=ex) return bytearray(exif_data)
def capture(self): with open_camera() as (camera, context): # Capture picture camera_path = self._trigger(camera, context) folder = camera_path.folder name = camera_path.name # Get picture file error, camera_file = gp.gp_camera_file_get(camera, folder, name, gp.GP_FILE_TYPE_NORMAL, context) file_data = gp.check_result( gp.gp_file_get_data_and_size(camera_file)) picture = Image.open(cStringIO.StringIO(file_data)) exif_dict = piexif.load(picture.info["exif"]) cropped = crop_to_square(picture) s, _ = cropped.size exif_dict["Exif"][piexif.ExifIFD.PixelXDimension] = s exif_bytes = piexif.dump(exif_dict) buf = cStringIO.StringIO() cropped.save(buf, "JPEG", exif=exif_bytes) cropped = buf.getvalue() buf.close() return cropped
def capture(): path = gp.check_result(gp.gp_camera_capture(self._camera, gp.GP_CAPTURE_IMAGE, self._context)) file = gp.check_result(gp.gp_camera_file_get( self._camera, path.folder, path.name, gp.GP_FILE_TYPE_NORMAL, self._context)) data = gp.check_result(gp.gp_file_get_data_and_size(file)) return bytes(data)
def take_preview_image(self): # self.log.debug("taking preview photo via GPhoto2") camera_file = gp.check_result(gp.gp_camera_capture_preview( self.camera)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) # decode image img = cv2.imdecode( np.fromstring(io.BytesIO(file_data).read(), np.uint8), 1) return resize(img, width=self.preview_width)
def captureImage(camera): if camera == None: print("Invalid camera instance") return None camera_file = gp.check_result(gp.gp_camera_capture_preview(camera)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) data = memoryview(file_data) image = Image.open(io.BytesIO(file_data)) image = np.array(image) return image
def capture_next_preview_as_np_array(self): try: preview_file = self.camera.capture_preview() preview_path = gp.check_result( gp.gp_file_get_data_and_size(preview_file)) img = self._convert_camera_to_np_array(preview_path) logging.debug(f"camera preview data: {img} ") return cv2.imdecode(img, cv2.IMREAD_COLOR) except Exception as ex: logging.error( f"Error while capturing the preview: {type(ex).__name__}", exc_info=ex)
def main(): logging.basicConfig(format='%(levelname)s: %(name)s: %(message)s', level=logging.ERROR) gp.check_result(gp.use_python_logging()) camera = gp.check_result(gp.gp_camera_new()) gp.check_result(gp.gp_camera_init(camera)) # required configuration will depend on camera type! print('Checking camera config') # get configuration tree config = gp.check_result(gp.gp_camera_get_config(camera)) # find the image format config item OK, image_format = gp.gp_widget_get_child_by_name(config, 'imageformat') if OK >= gp.GP_OK: # get current setting value = gp.check_result(gp.gp_widget_get_value(image_format)) # make sure it's not raw if 'raw' in value.lower(): print('Cannot preview raw images') return 1 # find the capture size class config item # need to set this on my Canon 350d to get preview to work at all OK, capture_size_class = gp.gp_widget_get_child_by_name( config, 'capturesizeclass') if OK >= gp.GP_OK: # set value value = gp.check_result(gp.gp_widget_get_choice(capture_size_class, 2)) gp.check_result(gp.gp_widget_set_value(capture_size_class, value)) # set config gp.check_result(gp.gp_camera_set_config(camera, config)) # capture preview image (not saved to camera memory card) print('Capturing preview image') for x in xrange(1,100): millis = int(round(time.time() * 1000)) camera_file = gp.check_result(gp.gp_camera_capture_preview(camera)) print("capture %d %s\n" % (int(round(time.time() * 1000)) - millis, camera_file)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) print("download %d\n" % (int(round(time.time() * 1000)) - millis)) data = memoryview(file_data) # display image #image = Image.open(io.BytesIO(file_data)) #image.show() gp.check_result(gp.gp_camera_exit(camera)) return 0
def wait_for_frame_gphoto2(prev_frame, wname, cam, size): ''' onionskin prev_frame while displaying gphoto2 version ''' key = 1 while key not in [13, 27]: key = cv2.waitKey(7) camera_file = gp.check_result(gp.gp_camera_capture_preview(cam)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) im = np.array(Image.open(io.BytesIO(file_data)))[:, :, ::-1] # display the current frame with the prev_frame onionskinned im2 = cv2.addWeighted(prev_frame, 0.5, im, 0.5, 0) cv2.imshow(wname, cv2.resize(im2, size)) exp = 5 imret = im return imret, key
def saveFrames_gphoto2(wname, cam, direc): ''' stupid thing trying to mimic FrameByFrame Save individual frames with Return, stop frame capture with Esc gphoto2 version--supports capture from a DSLR ''' camera_file = gp.check_result(gp.gp_camera_capture_preview(cam)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) im0 = np.array(Image.open(io.BytesIO(file_data))) size = (im0.shape[1], im0.shape[0]) key = 1 counter = 0 while key != 27: im0, key = wait_for_frame_gphoto2(im0, wname, cam, size) cv2.imwrite(os.path.join(direc, str(counter).zfill(4) + '.jpg'), im0) counter += 1
def take_a_pic(): logging.basicConfig(format='%(levelname)s: %(name)s: %(message)s', level=logging.WARNING) gp.check_result(gp.use_python_logging()) camera = gp.check_result(gp.gp_camera_new()) gp.check_result(gp.gp_camera_init(camera)) # required configuration will depend on camera type! print('Checking camera config') # get configuration tree config = gp.check_result(gp.gp_camera_get_config(camera)) # find the image format config item OK, image_format = gp.gp_widget_get_child_by_name(config, 'imageformat') if OK >= gp.GP_OK: # get current setting value = gp.check_result(gp.gp_widget_get_value(image_format)) # make sure it's not raw if 'raw' in value.lower(): print('Cannot preview raw images') return 1 # find the capture size class config item # need to set this on my Canon 350d to get preview to work at all OK, capture_size_class = gp.gp_widget_get_child_by_name( config, 'capturesizeclass') if OK >= gp.GP_OK: # set value value = gp.check_result( gp.gp_widget_get_choice(capture_size_class, 2)) gp.check_result( gp.gp_widget_set_value(capture_size_class, value)) # set config gp.check_result(gp.gp_camera_set_config(camera, config)) # capture preview image (not saved to camera memory card) print('Capturing preview image') camera_file = gp.check_result( gp.gp_camera_capture_preview(camera)) file_data = gp.check_result( gp.gp_file_get_data_and_size(camera_file)) # display image data = memoryview(file_data) print(type(data), len(data)) print(data[:10].tolist()) image = Image.open(io.BytesIO(file_data)) image.show() gp.check_result(gp.gp_camera_exit(camera)) return image
def get_preview(self): if self.use_cached is False: try: camera_file = gp.check_result( gp.gp_camera_capture_preview(self.camera)) except gp.GPhoto2Error: camera_file = self.file_cache else: camera_file = self.file_cache if camera_file is None: camera_file = gp.check_result( gp.gp_camera_capture_preview(self.camera)) self.file_cache = camera_file file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) return file_data
def show_preview(self): if(self.parent.canonCemara.isconnec): if self.isplay: if not self.ispreview : self.ispreview=True try: camera_file = gp.check_result(gp.gp_camera_capture_preview(self.parent.canonCemara.camera)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) image = Image.open(io.BytesIO(file_data)) self.pixmap=self.PILimageToQImage(image) self.imageLabel.setPixmap(self.pixmap) except Exception as e: print("Frame Read error") self.ispreview=False elif self.iscapture_image: self.iscapture_image=False self.pixmap=self.PILimageToQImage(self.capture_image) self.imageLabel.setPixmap(self.pixmap)
def main(): logging.basicConfig( format='%(levelname)s: %(name)s: %(message)s', level=logging.WARNING) gp.check_result(gp.use_python_logging()) context = gp.gp_context_new() camera = gp.check_result(gp.gp_camera_new()) gp.check_result(gp.gp_camera_init(camera, context)) # required configuration will depend on camera type! print('Checking camera config') # get configuration tree config = gp.check_result(gp.gp_camera_get_config(camera, context)) # find the image format config item OK, image_format = gp.gp_widget_get_child_by_name(config, 'imageformat') if OK >= gp.GP_OK: # get current setting value = gp.check_result(gp.gp_widget_get_value(image_format)) # make sure it's not raw if 'raw' in value.lower(): print('Cannot preview raw images') return 1 # find the capture size class config item # need to set this on my Canon 350d to get preview to work at all OK, capture_size_class = gp.gp_widget_get_child_by_name( config, 'capturesizeclass') if OK >= gp.GP_OK: # set value value = gp.check_result(gp.gp_widget_get_choice(capture_size_class, 2)) gp.check_result(gp.gp_widget_set_value(capture_size_class, value)) # set config gp.check_result(gp.gp_camera_set_config(camera, config, context)) # capture preview image (not saved to camera memory card) print('Capturing preview image') camera_file = gp.check_result(gp.gp_camera_capture_preview(camera, context)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) # display image data = memoryview(file_data) print(type(data), len(data)) print(data[:10].tolist()) image = Image.open(io.BytesIO(file_data)) image.show() gp.check_result(gp.gp_camera_exit(camera, context)) return 0
def preview(): OK, capture_size_class = gp.gp_widget_get_child_by_name( config, 'capturesizeclass') if OK >= gp.GP_OK: # set value value = gp.check_result(gp.gp_widget_get_choice(capture_size_class, 2)) gp.check_result(gp.gp_widget_set_value(capture_size_class, value)) # set config gp.check_result(gp.gp_camera_set_config(camera, config)) # capture preview image (not saved to camera memory card) print('Capturing preview image') camera_file = gp.check_result(gp.gp_camera_capture_preview(camera)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) # display image data = memoryview(file_data) print(type(data), len(data)) print(data[:10].tolist()) image = Image.open(io.BytesIO(file_data)) image.show() return 0
def get_thumbnail( self, dir_name: str, file_name: str, ignore_embedded_thumbnail=False, cache_full_filename: Optional[str] = None, ) -> Optional[bytes]: """ :param dir_name: directory on the camera :param file_name: the photo or video :param ignore_embedded_thumbnail: if True, do not retrieve the embedded thumbnail :param cache_full_filename: full path including filename where the thumbnail will be saved. If none, will not save it. :return: thumbnail in bytes format, which will be full resolution if the embedded thumbnail is not selected """ if self.can_fetch_thumbnails and not ignore_embedded_thumbnail: get_file_type = gp.GP_FILE_TYPE_PREVIEW else: get_file_type = gp.GP_FILE_TYPE_NORMAL camera_file = self._get_file(dir_name, file_name, cache_full_filename, get_file_type) try: thumbnail_data = gp.check_result( gp.gp_file_get_data_and_size(camera_file)) except gp.GPhoto2Error as ex: logging.error( "Error getting image %s from camera %s: %s", os.path.join(dir_name, file_name), self.display_name, gphoto2_named_error(ex.code), ) raise CameraProblemEx(code=CameraErrorCode.read, gp_exception=ex) if thumbnail_data: data = memoryview(thumbnail_data) return data.tobytes()
def slurpd(self, device, apply_state=True): if apply_state: self.apply_state(device) try: logger.info(device) context = gp.gp_context_new() camera = gp.Camera() cameras = gp.PortInfoList() cameras.load() camera_address = cameras.lookup_path(device['address']) camera.set_port_info(cameras[camera_address]) gp.check_result(gp.gp_camera_init(camera, context)) captured = gp.check_result( gp.gp_camera_capture(camera, gp.GP_CAPTURE_IMAGE, context)) captured_file = gp.check_result( gp.gp_camera_file_get(camera, captured.folder, captured.name, gp.GP_FILE_TYPE_NORMAL, context)) captured_file_data = gp.check_result( gp.gp_file_get_data_and_size(captured_file)) container = io.BytesIO(memoryview(captured_file_data)) container.seek(0) contents = container.read() gp.check_result(gp.gp_camera_exit(camera, context)) except Exception as ex: logger.warn(ex) self.broadcast(channel=self.channels['exception'], message=str(ex), subs=[{ "function": sys._getframe().f_code.co_name }]) return contents
def run(self): while not self.doStop: if self.picture is None: try: if self.doStop: self.idle=True return self.idle=False camera_file = gp.check_result(gp.gp_camera_capture_preview(self.camera, self.context)) if self.doStop: self.idle=True return file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) self.picture=file_data except: self.idle=True self.cameraError=True return self.idle=True time.sleep(0.005) self.idle=True
def get_THM_file(self, full_THM_name: str) -> Optional[bytes]: """ Get THM thumbnail from camera :param full_THM_name: path and file name of the THM file :return: THM in raw bytes """ dir_name, file_name = os.path.split(full_THM_name) camera_file = self._get_file(dir_name, file_name) try: thumbnail_data = gp.check_result( gp.gp_file_get_data_and_size(camera_file)) except gp.GPhoto2Error as ex: logging.error('Error getting THM file %s from camera %s: %s', os.path.join(dir_name, file_name), self.display_name, gphoto2_named_error(ex.code)) raise CameraProblemEx(code=CameraErrorCode.read, gp_exception=ex) if thumbnail_data: data = memoryview(thumbnail_data) return data.tobytes()
def preview_image(): callback_obj = gp.check_result(gp.use_python_logging()) camera = gp.check_result(gp.gp_camera_new()) gp.check_result(gp.gp_camera_init(camera)) # required configuration will depend on camera type! print('Checking camera config') # get configuration tree config = gp.check_result(gp.gp_camera_get_config(camera)) # find the image format config item # camera dependent - 'imageformat' is 'imagequality' on some OK, image_format = gp.gp_widget_get_child_by_name(config, 'imageformat') if OK >= gp.GP_OK: # get current setting value = gp.check_result(gp.gp_widget_get_value(image_format)) # make sure it's not raw if 'raw' in value.lower(): print('Cannot preview raw images') # return 1 # find the capture size class config item # need to set this on my Canon 350d to get preview to work at all OK, capture_size_class = gp.gp_widget_get_child_by_name( config, 'capturesizeclass') if OK >= gp.GP_OK: # set value value = gp.check_result(gp.gp_widget_get_choice(capture_size_class, 2)) gp.check_result(gp.gp_widget_set_value(capture_size_class, value)) # set config gp.check_result(gp.gp_camera_set_config(camera, config)) # capture preview image (not saved to camera memory card) print('Capturing preview image') camera_file = gp.check_result(gp.gp_camera_capture_preview(camera)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) # display image data = memoryview(file_data) image = cv2.imdecode(np.asarray(bytearray(data), dtype=np.uint8), 3) cv2.imshow("preview",image) cv2.waitKey() # image.show() gp.check_result(gp.gp_camera_exit(camera))
def run_preview(self): logging.info('run_preview: ++') rc = redis.Redis() while not self.quitEvent.is_set(): x = rc.get('camera.TP') if bool(x): x = x.decode('utf-8') camera = self.camera_find_by_serialnumber(x) if camera is not None: # self.get_ev(camera) # frame=0 while not self.quitEvent.is_set(): try: # if bool(self.new_ev): # err, ep = gp.gp_camera_get_single_config(camera, 'exposurecompensation') # if err >= gp.GP_OK: # v = ep.get_value() # ep.set_value(self.new_ev) # err = gp.gp_camera_set_single_config(camera, 'exposurecompensation', ep) # if err >= gp.GP_OK: # self.ev = self.new_ev # self.new_ev = None camera_file = camera.capture_preview() # frame += 1 # logging.info('frame: {}'.format(frame)) err, buf = gp.gp_file_get_data_and_size( camera_file) if err >= gp.GP_OK: image = Image.open(io.BytesIO(buf)) image = image.rotate(180) if self.cb is not None: self.cb(image) except: pass camera.exit() else: time.sleep(3) rc.close() logging.info('run_preview: --') pass
def capture(self, req): rospy.loginfo('Capturing panorama') if not self.single_capture(): rospy.logerr('Could not trigger Richo Theta, retrying in 1s') rospy.sleep(1) while not self.single_capture(): rospy.logerr( 'Could not trigger Richo Theta, resetting the usb driver. Is the camera switched on and set to still image capture mode?' ) reset_usb_driver() self.init_camera() rospy.sleep(2) # Construct image file_data = gp.check_result( gp.gp_file_get_data_and_size(self.camera_file)) img = Img.open(io.BytesIO(file_data)) rospy.loginfo('Panorama captured!') image = Image(height=img.height, width=img.width, encoding="rgb8", is_bigendian=False, step=img.width * 3, data=img.tobytes()) image.header.stamp = self.stamp image.header.frame_id = 'map' #TODO maybe add something sensible here self.pub_image.publish(image) rospy.loginfo('Panorama published!') # Avoid running out of space. Update: No need: Device holds approx 4,800 photos #try: # self.camera.file_delete(self.file_path.folder, self.file_path.name) #except: # rospy.logwarn('Delete photo on the Ricoh Theta failed. Camera may eventually run out of storage.') return TriggerResponse(success=True, message=self.file_path.folder + '/' + self.file_path.name)
def run(self): while not self.doStop: if self.picture is None: try: if self.doStop: self.idle = True return self.idle = False camera_file = gp.check_result( gp.gp_camera_capture_preview(self.camera, self.context)) if self.doStop: self.idle = True return file_data = gp.check_result( gp.gp_file_get_data_and_size(camera_file)) self.picture = file_data except: self.idle = True self.cameraError = True return self.idle = True time.sleep(0.005) self.idle = True
def slurpd(self, device): contents = b"" try: context = gp.gp_context_new() camera = gp.Camera() cameras = gp.PortInfoList() cameras.load() camera_address = cameras.lookup_path(device["address"]) camera.set_port_info(cameras[camera_address]) gp.check_result(gp.gp_camera_init(camera, context)) captured = gp.check_result( gp.gp_camera_capture(camera, gp.GP_CAPTURE_IMAGE, context)) captured_file = gp.check_result( gp.gp_camera_file_get( camera, captured.folder, captured.name, gp.GP_FILE_TYPE_NORMAL, context, )) captured_file_data = gp.check_result( gp.gp_file_get_data_and_size(captured_file)) container = io.BytesIO(memoryview(captured_file_data)) container.seek(0) contents = container.read() gp.check_result(gp.gp_camera_exit(camera, context)) except Exception as ex: print(ex) return contents
def capture(self): while True: try: for i in range(0,20): try: camera_file = gp.check_result(gp.gp_camera_capture_preview(self.camera, self.context)) break except gp.GPhoto2Error as ex: if i < 19: continue raise file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) pil_image = Image.open(io.BytesIO(file_data)) #pil_image.save("testimg2_" + str(i) + ".tif") im = np.array(pil_image) im = apply_gamma(im, 2.2) if self.fpshackiso > 0: self.set_config_value_checked('iso', 1600) self.set_config_value_checked('iso', 100) self.fpshackiso -= 1 return im, None except KeyboardInterrupt: break except gp.GPhoto2Error as ex: print "Unexpected error: " + sys.exc_info().__str__() print "code:", ex.code stacktraces() time.sleep(1) if ex.code == -7 or ex.code == -1: gp.gp_camera_exit(self.camera, self.context) self.prepare()
def main(): logging.basicConfig( format='%(levelname)s: %(name)s: %(message)s', level=logging.WARNING) gp.check_result(gp.use_python_logging()) print('Establishing communication with the camera (wait few seconds)') camera = gp.check_result(gp.gp_camera_new()) gp.check_result(gp.gp_camera_init(camera)) # required configuration will depend on camera type! config = gp.check_result(gp.gp_camera_get_config(camera)) print('Camera ready') # TODO get the list of 'gp_abilities_list_get_abilities' or something like that ? # --> find out how to set image format # --> also use it to set shutter and ISO def my_set(name, value): OK, widget = gp.gp_widget_get_child_by_name(config, name) if OK >= gp.GP_OK: widget_type = gp.check_result(gp.gp_widget_get_type(widget)) gp.check_result(gp.gp_widget_set_value(widget, value)) gp.check_result(gp.gp_camera_set_config(camera, config)) else: print("Error setting value %s for %s using widget %s" % (value, name, widget)) #my_set(name='imageformat', value='Large Fine JPEG') my_set(name='imageformat', value='RAW') my_set(name='shutterspeed', value='{}'.format(shutterspeed)) my_set(name='iso', value='{}'.format(iso)) # find the image format config item OK, image_format = gp.gp_widget_get_child_by_name(config, 'imageformat') if OK >= gp.GP_OK: imgformat = gp.check_result(gp.gp_widget_get_value(image_format)) # find the capture size class config item # need to set this on my Canon 350d to get preview to work at all OK, capture_size_class = gp.gp_widget_get_child_by_name(config, 'capturesizeclass') if OK >= gp.GP_OK: # set value value = gp.check_result(gp.gp_widget_get_choice(capture_size_class, 2)) gp.check_result(gp.gp_widget_set_value(capture_size_class, value)) # set config gp.check_result(gp.gp_camera_set_config(camera, config)) # capture preview image (not saved to camera memory card) print('Capturing preview image') camera_file = gp.check_result(gp.gp_camera_capture_preview(camera)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) print('01----------', type(file_data),file_data) # display image data = memoryview(file_data) print('02----------', type(data), data) print(' ', len(data)) print(data[:10].tolist()) if 'raw' in imgformat.lower(): #rawimage = open(io.BytesIO(file_data)) ## FIXME raw format would be more accurate than JPEG, but AttributeError: '_io.BytesIO' object has no attribute 'encode' #xx from rawkit import raw #xx raw_image_process = raw.Raw(io.BytesIO(file_data)) #import rawpy #raw = rawpy.imread(bytesio) #rgb = raw.postprocess() #bytesio = io.BytesIO(file_data) #print('bytesio', bytesio) raw_file_name = 'image_logs/output_debayered_{}s_ISO{}_{}.cr2'.format(shutterspeed.replace('/','div'), iso, comment) gp.gp_file_save(camera_file, raw_file_name) # Note that - if Canon cameras are used - the dependency on rawkit can be replaced with a dedicated parser #https://codereview.stackexchange.com/questions/75374/cr2-raw-image-file-parser-in-python-3 from rawkit.raw import Raw from rawkit.options import interpolation raw_image = Raw(filename=raw_file_name) # 'bayer_data', 'close', 'color', 'color_description', 'color_filter_array', 'data', # 'image_unpacked', 'libraw', 'metadata', 'options', 'process', 'raw_image', 'save', # 'save_thumb', 'thumb_unpacked', 'thumbnail_to_buffer', 'to_buffer', 'unpack', 'unpack_thumb' #raw_image.options.interpolation = interpolation.linear # or "amaze", see https://rawkit.readthedocs.io/en/latest/api/rawkit.html raw_image.options.interpolation = interpolation.amaze # or "amaze", see https://rawkit.readthedocs.io/en/latest/api/rawkit.html raw_image.save("output-test.ppm") ## FIXME - saved ppm image has auto-normalized brightness, why? raw_image_process = raw_image.process() if raw_image_process is raw_image: print("they are identical") ## FIXME - npimage = np.array(raw_image.raw_image(include_margin=False)) # returns: 2D np. array #print('bayer_data', raw_image.bayer_data()) # ? #print('as_array', raw_image.as_array()) # does not exist, although documented?? #print(type(raw_image.to_buffer())) # Convert the image to an RGB buffer. Return type: bytearray #npimage = np.array(flat_list).reshape(4) print(npimage) ## gives 1-d array of values print(npimage.shape) ## gives 1-d array of values plt.imshow(npimage) plt.hist(npimage.flatten(), 4096) #plt.plot([200,500], [300,-100], lw=5, c='r') #plt.show() ## Save the raw pixels try: import cPickle as pickle except: import pickle print('retrieved image as numpy array with dimensions:', npimage.shape) #scipy.ndimage. print('', ) print('', ) print(npimage.shape) else: image = Image.open(io.BytesIO(file_data)) npimage = np.array(image) return npimage print('retrieved image as numpy array with dimensions:', npimage.shape) #image.show() plt.imshow(npimage) plt.plot([200,500], [300,-100], lw=5, c='k') plt.show() # TODO http://www.scipy-lectures.org/advanced/image_processing/#blurring-smoothing # display with polynomially curved paths, # linear convolve, # linearize along the paths, (possibly subtract background?) # generate polynomial x-axis # stitch smoothly gp.check_result(gp.gp_camera_exit(camera)) return 0
def capture_bulb(self, test = False, callback = None): if test: sec = self.status['test-exp-sec'] self.set_config_value_checked('iso', self.status['test-iso']) try: self.status['test-iso'] = int(self.get_config_value('iso')) except: pass self.set_config_choice('capturetarget', 0) #mem self.set_config_choice('imageformat', 1) #Large Normal JPEG else: sec = self.status['exp-sec'] self.set_config_value_checked('iso', self.status['iso']) try: self.status['iso'] = int(self.get_config_value('iso')) except: pass self.set_config_choice('capturetarget', 1) #card #self.set_config_choice('imageformat', 24) #RAW self.set_config_choice('imageformat', 7) #RAW + Large Normal JPEG self.set_config_value('aperture', self.status['f-number']) self.status['f-number'] = self.get_config_value('aperture') if sec <= 30: bulbmode = None self.set_config_value_checked('autoexposuremode', 'Manual') self.set_config_value_checked('shutterspeed', sec) gp.check_result(gp.gp_camera_trigger_capture(self.camera, self.context)) else: self.set_config_value_checked('autoexposuremode', 'Manual') if not self.set_config_value_checked('shutterspeed', 'Bulb'): self.set_config_value_checked('autoexposuremode', 'Bulb') bulbmode = 'eosremoterelease' if not self.set_config_value_checked('eosremoterelease', 'Immediate'): self.set_config_value('bulb', 1) bulbmode = 'bulb' self.t_start = time.time() t = 0 self.status['exp_in_progress'] = True self.status['interrupt'] = False while True: if t < sec - 4 and not self.status['interrupt']: time.sleep(3) e, file_path = gp.check_result(gp.gp_camera_wait_for_event(self.camera, 1000,self.context)) t = time.time() - self.t_start print "camera event ", t, e, file_path if self.status['exp_in_progress']: self.status['cur_time'] = int(t) if self.status['exp_in_progress'] and (t > sec or self.status['interrupt']): if bulbmode == 'bulb': self.set_config_value('bulb', 0) elif bulbmode == 'eosremoterelease': self.set_config_value_checked('eosremoterelease', 'Release Full') self.status['exp_in_progress'] = False if e == gp.GP_EVENT_FILE_ADDED: print >> sys.stderr, "filepath:", file_path.folder, file_path.name filename, file_extension = os.path.splitext(file_path.name) if file_extension == ".jpg" or file_extension == ".JPG": break self.status['exp_in_progress'] = False self.status['cur_time'] = 0 self.status['interrupt'] = False target = os.path.join('/tmp', file_path.name) n = 20 while True: n -= 1 try: camera_file = gp.check_result(gp.gp_camera_file_get(self.camera, file_path.folder, file_path.name, gp.GP_FILE_TYPE_NORMAL, self.context)) file_data = gp.check_result(gp.gp_file_get_data_and_size(camera_file)) if callback is not None: callback(file_data) break except gp.GPhoto2Error as ex: if ex.code == gp.GP_ERROR_CAMERA_BUSY: time.sleep(1) if (n > 0): continue raise #stop review on display self.set_config_value_checked('eosremoterelease', 'Press Half') self.set_config_value_checked('eosremoterelease', 'Release Half') self.do_fps_hack()