def capture(self, path): # NOTE: To obtain the "real" Canon ISO value, we multiply the # "market" value from the config by 0.65. # See core/shooting.c#~l150 in the CHDK source for more details if self._can_remote: cmd = ("remoteshoot -tv={0} -sv={1} {2} \"{3}\"" .format(self._shutter_speed, self._sensitivity*0.65, "-dng" if self._shoot_raw else "", path)) else: cmd = ("shoot -tv={0} -sv={1} -dng={2} -rm -dl \"{3}\"" .format(self._shutter_speed, self._sensitivity*0.65, int(self._shoot_raw), path)) try: self._run(cmd) except CHDKPTPException as e: if 'not in rec mode' in e.message: self.prepare_capture(None) self.capture(path) else: self.logger.warn("Capture command failed.") raise e extension = 'dng' if self._shoot_raw else 'jpg' local_path = "{0}.{1}".format(path, extension) # Set EXIF orientation self.logger.debug("Setting EXIF orientation on captured image") img = JPEGImage(local_path) if self.target_page == 'odd': img.exif_orientation = 6 # -90° else: img.exif_orientation = 8 # 90° img.save(local_path)
def scale_image_to_fit_size(path: str, size: Size): desired_width, desired_height = size img = JPEGImage(path) if img.width < desired_width and img.height < desired_height: return bytes(img.data) downscaled_image = img.downscale(*proportionally_scale_dimensions(img, size), quality=90) return bytes(downscaled_image.data)
def get_image(self, p_id): ''' Function that returns a image asociate to a page of the document Input: p_id - Number of the asociated page Return a HTTP response with the image in .jpg format ''' path = os.environ["LS_PROJECT_PATH"]+'/processed/' l = glob.glob(path + '*.tif') l.sort() image_name = l[int(p_id)] temp = image_name.split('.') new_image = temp[0] new_image = new_image + ".jpg" if not os.path.isfile(new_image): self.image_service.convert_image(image_name) headers = { 'Content-Type': 'image/jpg' } image = JPEGImage(new_image) body = image.as_blob() return HTTPResponse(body, **headers)
def scale_image(img_name, width=None, height=None): if width is None and height is None: raise ValueError("Please specify either width or height") img = JPEGImage(img_name) aspect = img.width/img.height width = width if width else int(aspect*height) height = height if height else int(width/aspect) return img.downscale(width, height).as_blob()
def _get_img_response(self, id, thumb=True): path = "{0}/raw/{1}.jpg".format(self.scanner_service.working_dir, id) headers = { 'Content-Type': 'image/jpg' } image = JPEGImage(path) if thumb: image = image.downscale(500, 375) body = image.as_blob() return HTTPResponse(body, **headers)
def autorotate_image(path): img = JPEGImage(path) if img.exif_orientation is None: logger.warn("Image {0} did not have any EXIF rotation, did not rotate." .format(path)) return elif img.exif_orientation == 1: logger.info("Image {0} is already rotated.".format(path)) return rotated = img.exif_autotransform() rotated.save(path)
def autorotate_image(path): img = JPEGImage(path) if img.exif_orientation is None: logger.warn( "Image {0} did not have any EXIF rotation, did not rotate.".format( path)) return elif img.exif_orientation == 1: logger.info("Image {0} is already rotated.".format(path)) return rotated = img.exif_autotransform() rotated.save(path)
def capture(self, path): imgdata = self._camera.capture() # Set EXIF orientation self.logger.debug("Setting EXIF orientation on captured image") img = JPEGImage(blob=imgdata) upside_down = self.config["upside_down"].get(bool) if self.target_page == 'odd': img.exif_orientation = 8 if upside_down else 6 # -90° else: img.exif_orientation = 6 if upside_down else 8 # 90° img.save(unicode(path))
def resize_image(orig_filename, new_filename, size): if os.path.realpath(orig_filename) == os.path.realpath(new_filename): raise IOException('Original and resized filename can not be the same: %s' % orig_filename) if not os.path.exists(new_filename): logging.debug("Generating %s image for %s" % (size, orig_filename)) orig_img = JPEGImage(orig_filename) orig_img.downscale(*size).save(new_filename) logging.debug("Resizing complete") return True return False
def autorotate_image(in_path, out_path): img = JPEGImage(in_path) if img.exif_orientation is None: logger.warn( "Image {0} did not have any EXIF rotation, did not rotate." .format(in_path)) return elif img.exif_orientation == 1: logger.info("Image {0} is already rotated.".format(in_path)) shutil.copyfile(in_path, out_path) else: rotated = img.exif_autotransform() rotated.save(out_path)
def autorotate_image(in_path, out_path): img = JPEGImage(in_path) if img.exif_orientation is None: logger.warn( "Image {0} did not have any EXIF rotation, did not rotate.". format(in_path)) return elif img.exif_orientation == 1: logger.info("Image {0} is already rotated.".format(in_path)) shutil.copyfile(in_path, out_path) else: rotated = img.exif_autotransform() rotated.save(out_path)
def capture(self, path): self.logger.info("Capturing image into '{0}'".format(path)) self.logger.debug(self.config['test'].get()) with Drawing() as draw: fpath = unicode(self._test_imgs[self.target_page]) with Image(filename=fpath) as img: draw.font_size = 240 draw.text(img.width/2, img.height/2, path.name) draw(img) img.save(filename=unicode(path)) img = JPEGImage(fname=unicode(path)) aspect = float(img.width)/img.height img.exif_thumbnail = img.downscale(320, int(320/aspect)) img.save(unicode(path))
def do_crop(fname, left, top, width, height): if HAS_JPEGTRAN: img = JPEGImage(fname) else: img = Image(filename=fname) width = (img.width - left) if width is None else width height = (img.height - top) if height is None else height if width > (img.width - left): width = img.width - left if height > (img.height - top): width = img.height - top if (left, top, width, height) == (0, 0, img.width, img.height): self._logger.warn("No-op crop parameters, skipping!") return self._logger.debug("Cropping \"{0}\" to x:{1} y:{2} w:{3} h:{4}" .format(fname, left, top, width, height)) try: cropped = img.crop(left, top, width=width, height=height) if HAS_JPEGTRAN: cropped.save(fname) else: img.save(filename=fname) img.close() except Exception as e: self._logger.error("Cropping failed") self._logger.exception(e)
def rotate(self, request, pk=None): check_request_data_for(request, ['rotation']) rotation = int(request.data['rotation']) acceptable_rotations = [90, 180, 270] if rotation not in acceptable_rotations: raise ParseError('Can only rotate by {} degrees.'.format(', '.join(map(str, acceptable_rotations)))) photo = Photo.objects.get(id=pk) img = JPEGImage(photo.path) img = img.rotate(rotation) img.save(photo.path) photo.landscape_orientation = (img.width > img.height) photo.save() return Response(PhotoSerializer(photo, context={'request': None}).data)
def crop_an_imageset(imageset_n): print(CROPDIM) print(os.getcwd()) os.makedirs(imageset_n, exist_ok=True) images_n = os.listdir("../dataset/" + imageset_n) isovals = get_iso_vals(images_n) for isoval in isovals: os.makedirs(imageset_n + "/" + isoval, exist_ok=True) images_in = [None] * len(images_n) for i in range(0, len(images_n)): images_in[i] = JPEGImage("../dataset/" + imageset_n + "/" + images_n[i]) print(imageset_n) image_width = math.floor(images_in[0].width / CROPDIM) * CROPDIM image_height = math.floor(images_in[0].height / CROPDIM) * CROPDIM curx = cury = cnt = 0 while cury < image_height: for i in range(0, len(images_n)): if not os.path.exists(imageset_n + "/" + isovals[i] + "/" + rename_img(images_n[i], cnt)): images_in[i].crop(curx, cury, CROPDIM, CROPDIM).save(imageset_n + "/" + isovals[i] + "/" + rename_img(images_n[i], cnt)) cnt += 1 curx += CROPDIM if curx == image_width: curx = 0 cury += CROPDIM return 1
def hashcalc(path, pool, method="MD5", havejpeginfo=False): rots = [0, 90, 180, 270] # Check file integrity using jpeginfo if available if havejpeginfo: try: devnull = open(os.devnull, 'w') check_call(["jpeginfo", "-c", path], stdout=devnull, stderr=devnull) except: sys.stderr.write(" Corrupt JPEG, skipping\n") return ["ERR"] try: img = JPEGImage(path) lista = [] for rot in rots: lista.append((img, rot, method)) except IOError: sys.stderr.write( " *** Error opening file %s, file will be ignored\n" % path) return ["ERR"] try: results = pool.map(phash, lista) except: sys.stderr.write( " *** Error reading image data, it will be ignored\n") return ["ERR"] return results
def rotate_with_jpegtran(context): image = context.image data = image.data from jpegtran import JPEGImage jpeg_image = JPEGImage(blob=data) try: image.data = jpeg_image.exif_autotransform().as_blob() except Exception as e: if 'Could not find EXIF orientation' in e.args: pass else: raise else: context.reindexObject()
def create_thumbnail(url, fp, width, height): blob = requests.get(url).content image = JPEGImage(blob=blob) """Check if downscaling image is possible with requested width and height. """ if image.width < width: width = width/2 if image.height < height: height = height/2 image.downscale(width, height, 90).save(fp) with open(fp, 'r') as f: thumbnail = f.read() return thumbnail
def crop_image(fname, left, top, width=None, height=None): if HAS_JPEGTRAN: img = JPEGImage(fname) else: img = Image(filename=fname) width = (img.width - left) if width is None else width height = (img.height - top) if height is None else height if width > img.width: width = img.width if height > img.height: width = img.height logger.debug("Cropping \"{0}\" to x:{1} y:{2} w:{3} h:{4}" .format(fname, left, top, width, height)) cropped = img.crop(left, top, width=width, height=height) if HAS_JPEGTRAN: cropped.save(fname) else: img.save(filename=fname)
def scale_image(img_path, width=None, height=None): def get_target_size(srcwidth, srcheight): aspect = srcwidth/srcheight target_width = width if width else int(aspect*height) target_height = height if height else int(width/aspect) return target_width, target_height if width is None and height is None: raise ValueError("Please specify either width or height") if HAS_JPEGTRAN and img_path.suffix.lower() in ('.jpg', '.jpeg'): img = JPEGImage(unicode(img_path)) width, height = get_target_size(img.width, img.height) return img.downscale(width, height).as_blob() else: with Image(filename=unicode(img_path)) as img: width, height = get_target_size(img.width, img.height) img.resize(width, height) return img.make_blob(format='jpg')
def autorotate_image(in_path, out_path): """ Rotate an image according to its EXIF orientation tag. :param in_path: Path to image that should be rotated :type in_path: unicode :param out_path: Path where rotated image should be written to :type out_path: unicode """ img = JPEGImage(in_path) if img.exif_orientation is None: logger.warn( "Image {0} did not have any EXIF rotation, did not rotate." .format(in_path)) return elif img.exif_orientation in (0, 1): logger.info("Image {0} is already rotated.".format(in_path)) shutil.copyfile(in_path, out_path) else: rotated = img.exif_autotransform() rotated.save(out_path)
def callback(self, left_image, left_info, right_image, right_info): #flip image in lossless fashion #rospy.logwarn( "callback called") img = JPEGImage(blob=right_image.data) rotatedImg = img.flip('vertical') rotatedImg = rotatedImg.flip('horizontal') right_image.data = rotatedImg.as_blob() #self.stamp = (left_image.header.stamp + left_info.header.stamp + right_image.header.stamp + right_info.header.stamp)/4.0 self.stamp = rospy.Time.now() left_image.header.stamp = self.stamp left_info.header.stamp = self.stamp right_image.header.stamp = self.stamp right_info.header.stamp = self.stamp self.left_image_pub.publish(left_image) self.left_info_pub.publish(left_info) self.right_image_pub.publish(right_image) self.right_info_pub.publish(right_info)
def autorotate_image(in_path, out_path): """ Rotate an image according to its EXIF orientation tag. :param in_path: Path to image that should be rotated :type in_path: unicode :param out_path: Path where rotated image should be written to :type out_path: unicode """ img = JPEGImage(in_path) if img.exif_orientation is None: logger.warn( "Image {0} did not have any EXIF rotation, did not rotate.". format(in_path)) return elif img.exif_orientation in (0, 1): logger.info("Image {0} is already rotated.".format(in_path)) shutil.copyfile(in_path, out_path) else: rotated = img.exif_autotransform() rotated.save(out_path)
def capture(self, path): shoot_raw = self.config['shoot_raw'].get(bool) # TODO: support choosing jpg size # TODO: support choosing sraw vs raw # TODO: support capturing raw + jpeg # TODO: choose raw extension based on camera vendor extension = 'cr2' if shoot_raw else 'jpg' local_path = "{0}.{1}".format(path, extension) self._camera.capture_image(local_path) # Set EXIF orientation self.logger.debug("Setting EXIF orientation on captured image") img = JPEGImage(local_path) if self.target_page == 'odd': img.exif_orientation = 6 # -90° else: img.exif_orientation = 8 # 90° img.save(local_path)
def capture(self, path): # NOTE: To obtain the "real" Canon ISO value, we multiply the # "market" value from the config by 0.65. # See core/shooting.c#~l150 in the CHDK source for more details sensitivity = int(self.config["sensitivity"].get()) shutter_speed = float( Fraction(self.config["shutter_speed"].get(unicode))) shoot_raw = self.config['shoot_raw'].get(bool) if self._can_remote: cmd = ("remoteshoot -tv={0} -sv={1} {2} \"{3}\"".format( shutter_speed, sensitivity * 0.65, "-dng" if shoot_raw else "", path)) else: cmd = ("shoot -tv={0} -sv={1} -dng={2} -rm -dl \"{3}\"".format( shutter_speed, sensitivity * 0.65, int(shoot_raw), path)) try: self._run(cmd) except CHDKPTPException as e: if 'not in rec mode' in e.message: self.prepare_capture(None) self.capture(path) else: self.logger.warn("Capture command failed.") raise e extension = 'dng' if shoot_raw else 'jpg' local_path = "{0}.{1}".format(path, extension) # Set EXIF orientation self.logger.debug("Setting EXIF orientation on captured image") img = JPEGImage(local_path) if self.target_page == 'odd': img.exif_orientation = 6 # -90° else: img.exif_orientation = 8 # 90° img.save(local_path)
def hashcalc(path,pool,method="MD5"): rots=[0,90,180,270] try: img=JPEGImage(path) lista=[] for rot in rots: lista.append((img,rot,method)) except IOError: sys.stderr.write(" *** Error opening file %s, file will be ignored\n" % path) return ["ERR"] results=pool.map(phash,lista) return results
def take(self): #print "taking photo" command = "raspistill " + "-n " + "-q " + self.settings['quality'] + "-t " + "50 " loc = self.ap.getLocation() att = self.ap.getAttitude() alt = self.ap.getAltitude() bear = self.ap.getHeading() if self.exif['on/off'] == True:#if save exif data option enabled if self.exif['location'] == True: #print 'loc',loc lat = self.ddtodms(loc['lat']) lon = self.ddtodms(loc['lon'])#save lat/lon with photo command = command + "-x GPS.GPSLatitude=" + str(lat['deg']) + "/1," + str(lat['min']) + "/1," + str(lat['sec']) + "/100 " command = command + "-x GPS.GPSLongitude=" + str(lon['deg']) + "/1," + str(lon['min']) + "/1," + str(lon['sec']) + "/100 " #Do these later------------------------------------------------------ #if self.exif['time'] == True: #save system time to exif #else if self.exif['GPS time'] == True: #save GPS time to exif #if self.exif['satellite count'] == True: #save satellite count to exif #if self.exif['GPS speed'] == True: #save GPS speed to exif #-------------------------------------------------------------------- name = "x" if self.settings['name format'] == 0: name = str(loc['lat']) + "_" + str(loc['lon'])#name as lat lon command = command + "-o " + self.settings['photo directory'] + name + ".jpg" #"calling:" + command subprocess.call(command,shell=True) #subprocess.call("convert " + self.settings['photo directory'] + name + ".jpg " + "-resize 1200x900 " + self.settings['photo directory'] + name + ".jpg", shell = True) #j = time.time() pic = JPEGImage(self.settings['photo directory'] + name + ".jpg") pic.downscale(1200,900).save(self.settings['photo directory'] + name + ".jpg") #print "resize time: ", time.time() - j return (loc, att,alt, bear, name)
def get_thumbnail(img_path): """ Return thumbnail for image. :param img_path: Path to image :type img_path: pathlib.Path :return: The thumbnail :rtype: bytestring """ thumb = JPEGImage(unicode(img_path)).exif_thumbnail.as_blob() if thumb: logger.debug("Using EXIF thumbnail for {0}".format(img_path)) return thumb else: logger.debug("Generating thumbnail for {0}".format(img_path)) return scale_image(unicode(img_path), width=160)
def get_thumbnail(img_path): """ Return thumbnail for image. :param img_path: Path to image :type img_path: pathlib.Path :return: The thumbnail :rtype: bytestring """ if HAS_JPEGTRAN and img_path.suffix.lower() in ('.jpg', '.jpeg'): img = JPEGImage(unicode(img_path)) thumb = img.exif_thumbnail if thumb: logger.debug("Using EXIF thumbnail for {0}".format(img_path)) return thumb.as_blob() logger.debug("Generating thumbnail for {0}".format(img_path)) return scale_image(img_path, width=160)
def rotate_photos(self, p_left_photo, p_right_photo): pictures_found = False tries = 0 while not pictures_found: try: save_path = self.working_dir + '/raw/' left = JPEGImage(save_path + p_left_photo + ".jpg") right = JPEGImage(save_path + p_right_photo + ".jpg") left.rotate(270).save(save_path + p_left_photo + ".jpg") right.rotate(90).save(save_path + p_right_photo + ".jpg") pictures_found = True except: print('Pictures not found yet') time.sleep(0.5) if tries > 20: raise Exception tries += 1
def capture(self, path): self.logger.info("Capturing image into '{0}'".format(path)) self.logger.debug(self.config['test'].get()) with Drawing() as draw: fpath = unicode(self._test_imgs[self.target_page]) with Image(filename=fpath) as img: draw.font_size = 240 draw.text(img.width / 2, img.height / 2, path.name) draw(img) img.save(filename=unicode(path)) img = JPEGImage(fname=unicode(path)) aspect = float(img.width) / img.height upside_down = self.config["upside_down"].get(bool) if self.target_page == 'odd': img.exif_orientation = 8 if upside_down else 6 else: img.exif_orientation = 6 if upside_down else 8 img.exif_thumbnail = img.downscale(320, int(320 / aspect)) img.save(unicode(path))
def crop_image(fname, left, top, width=None, height=None): if HAS_JPEGTRAN: img = JPEGImage(fname) else: img = Image(filename=fname) width = (img.width - left) if width is None else width height = (img.height - top) if height is None else height if width > img.width: width = img.width if height > img.height: width = img.height logger.debug("Cropping \"{0}\" to x:{1} y:{2} w:{3} h:{4}".format( fname, left, top, width, height)) cropped = img.crop(left, top, width=width, height=height) if HAS_JPEGTRAN: cropped.save(fname) else: img.save(filename=fname)
def scale_image(img_path, width=None, height=None): def get_target_size(srcwidth, srcheight): aspect = srcwidth / srcheight target_width = width if width else int(aspect * height) target_height = height if height else int(width / aspect) return target_width, target_height if width is None and height is None: raise ValueError("Please specify either width or height") if HAS_JPEGTRAN and img_path.suffix.lower() in ('.jpg', '.jpeg'): img = JPEGImage(unicode(img_path)) width, height = get_target_size(img.width, img.height) return img.downscale(width, height).as_blob() else: with Image(filename=unicode(img_path)) as img: width, height = get_target_size(img.width, img.height) img.sample(width, height) return img.make_blob(format='jpg')
def update_exif_orientation(fpath, orientation): img = JPEGImage(fpath) img.exif_orientation = orientation img.save(fpath)
def test_get_exif_thumbnail_no_compression(): thumb = JPEGImage(fname='test/test_thumb.jpg').exif_thumbnail assert thumb assert thumb.width == 196 assert thumb.height == 130
def image(): with open('test/test.jpg', 'rb') as fp: return JPEGImage(blob=fp.read())
def update_exif_orientation(data, orientation): img = JPEGImage(blob=data) img.exif_orientation = orientation return img.as_blob()
def rotate_image(self, filename, data): img = JPEGImage(filename) try: img.exif_autotransform().save(filename) except: pass
#pip install jpegtran-cffi from jpegtran import JPEGImage img = JPEGImage( '/home/ekmek/intership_project/video_parser_v1/_videos_to_test/RuzickaDataset/input/five/0001.jpg' ) import requests # JPEGImage can also be initialized from a bytestring #blob = requests.get("http://example.com/image.jpg").content #from_blob = JPEGImage(blob=blob) # Reading various image parameters print(img.width, img.height) # "640 480" print(img.exif_orientation) # "1" (= "normal") """ # If present, the JFIF thumbnail can be obtained as a bytestring thumb = img.exif_thumbnail # Transforming the image img.scale(320, 240).save('scaled.jpg') img.rotate(90).save('rotated.jpg') img.crop(0, 0, 100, 100).save('cropped.jpg') # Transformations can be chained data = (img.scale(320, 240) .rotate(90) .flip('horizontal') .as_blob())
def main(args=None): parser = OptionParser() parser.add_option("-i", "--input", dest="input", default=None, help='specify the path of the input bag file') parser.add_option("-o", "--output", dest="output", default=None, help='specify the path of the output bag file') parser.add_option("-r", "--do-not-rotate-right-camera", action="store_true", dest="doNotRotateRightCamera", default=False, help='specify to rotate right camera image stream') (options, args) = parser.parse_args(args=args) rosBagInPath = os.path.abspath(options.input) logger.info('Using input rosbag file: %s' % (rosBagInPath)) rosBagOutPath = os.path.abspath(options.output) logger.info('Using output rosbag file: %s' % (rosBagOutPath)) if options.doNotRotateRightCamera: logger.info( 'Image stream from right camera will not be rotated (vertically and horizontally)' ) nbTotalMessageProcessed = 0 with rosbag.Bag(rosBagOutPath, 'w') as outbag: with rosbag.Bag(rosBagInPath, 'r') as inbag: # Read all messages for topic, msg, timestamp in inbag.read_messages(): # Replace rosbag timestamps with the ones from the headers, if available if msg._has_header: timestamp = msg.header.stamp else: logger.warn( 'Topic %s provides messages than have no header: using timestamps from rosbag' % (topic)) # Rename topic of imu barometer sensor # NOTE: this is to properly handle the old topic name if topic == '/imu/baro': topic = '/imu/pressure' # Rotate right camera images (lossless) if topic == '/video/right/compressed' and not options.doNotRotateRightCamera: img = JPEGImage(blob=msg.data) rotatedImg = img.flip('vertical').flip('horizontal') msg.data = rotatedImg.as_blob() outbag.write(topic, msg, timestamp) nbTotalMessageProcessed += 1 elif msg.__class__.__name__.endswith('ImuBatch'): # Unbatch messages of type ImuBatch into individual Imu messages. # Use the timestamps from the individual messages. for m in unbatchImu(msg): outbag.write(topic, m, m.header.stamp) nbTotalMessageProcessed += 1 elif msg.__class__.__name__.endswith('MagneticFieldBatch'): # Unbatch messages of type MagneticFieldBatch into individual MagneticField messages. # Use the timestamps from the individual messages. for m in unbatchMagneticField(msg): outbag.write(topic, m, m.header.stamp) nbTotalMessageProcessed += 1 else: outbag.write(topic, msg, timestamp) nbTotalMessageProcessed += 1 if nbTotalMessageProcessed % 100 == 0: logger.info('Processed %d messages' % (nbTotalMessageProcessed)) logger.info('Processed %d messages' % (nbTotalMessageProcessed))
os.chdir('images/' + ['RTTY','APRS','LORA0','LORA1','FULL'][i]) camera.downloadLastMedia(camera.take_photo(0)) os.chdir('../..') filename = 'convert_' + str(i) if os.path.isfile(filename): # Read and delete conversion file file = open(filename, 'r') lines = file.read().splitlines() file.close() if os.path.isfile('ssdv.jpg'): os.remove('ssdv.jpg') # resize selected image file image=JPEGImage(lines[3]) image.downscale(int(lines[4]), int(lines[5])).save('ssdv.jpg') # run SSDV conversion os.system('ssdv ' + lines[1] + ' -e -c ' + lines[0] + ' -i ' + lines[2] + ' ssdv.jpg ' + lines[6]) # Move all images that werre considered folder1 = "images/" + ['RTTY','APRS','LORA0','LORA1','FULL'][i] folder2 = folder1 + "/" + time.strftime("%d_%m_%y") if not os.path.isdir(folder2): os.mkdir(folder2) os.system("mv " + folder1 + "/*.JPG " + folder2) os.remove(filename) os.system("echo DONE > ssdv_done_" + str(i))
os.chdir('images/' + ['RTTY', 'APRS', 'LORA0', 'LORA1', 'FULL'][i]) camera.downloadLastMedia(camera.take_photo(0)) os.chdir('../..') filename = 'convert_' + str(i) if os.path.isfile(filename): # Read and delete conversion file file = open(filename, 'r') lines = file.read().splitlines() file.close() if os.path.isfile('ssdv.jpg'): os.remove('ssdv.jpg') # resize selected image file image = JPEGImage(lines[3]) image.downscale(int(lines[4]), int(lines[5])).save('ssdv.jpg') # run SSDV conversion os.system('ssdv ' + lines[1] + ' -e -c ' + lines[0] + ' -i ' + lines[2] + ' ssdv.jpg ' + lines[6]) # Move all images that werre considered folder1 = "images/" + ['RTTY', 'APRS', 'LORA0', 'LORA1', 'FULL'][i] folder2 = folder1 + "/" + time.strftime("%d_%m_%y") if not os.path.isdir(folder2): os.mkdir(folder2) try: os.system("mv " + folder1 + "/*.JPG " + folder2) os.remove(filename) finally: