I'm trying to extract a set of photos from a zip file using python
and then saving those pictures to an image list to do some work on each.
I tried a lot, but nothing was useful to me.
Try this:
import zipfile
path = 'path_to_zip.zip'
input_zip = zipfile.ZipFile(path)
l = [input_zip.read(name) for name in input_zip.namelist()]
To Display one of the images you can do:
import io
import matplotlib.pyplot as plt
from PIL import Image
image = Image.open(io.BytesIO(l[0]))
plt.imshow(image)
Related
I want to store my image directory in memory, then load the images into a numpy array.
The normative way to load images that are not in memory is as follows:
import PIL.Image
import numpy as np
image = PIL.Image.open("./image_dir/my_image_1.jpg")
image = np.array(image)
However, I am not sure how to do this when the images are in memory. So far, I have been able to setup the following starter code:
import fs
import fs.memoryfs
import fs.osfs
image_dir = "./image_dir"
mem_fs = fs.memoryfs.MemoryFS()
drv_fs = fs.osfs.OSFS(image_path)
fs.copy.copy_fs(drv_fs, mem_fs)
print(mem_fs.listdir('.'))
Returns:
['my_image_1.jpg', 'my_image_2.jpg']
How do I load images that are in memory into numpy?
I am also open to alternatives to the fs package.
As per the documentation, Pillow's Image.open accepts a file object instead of a file name, so as long as your in-memory file package provides Python file objects (which it most likely does), you can just use them. If it doesn't, you could even just wrap them in a class that provides the required methods. Assuming you are using PyFilesystem, according to its documentation you should be fine.
So, you want something like:
import numpy as np
import PIL.Image
import fs.memoryfs
import fs.osfs
import fs.copy
mem_fs = fs.memoryfs.MemoryFS()
drv_fs = fs.osfs.OSFS("./image_dir")
fs.copy.copy_file(drv_fs, './my_image_1.jpg', mem_fs, 'test.jpg')
with mem_fs.openbin('test.jpg') as f:
image = PIL.Image.open(f)
image = np.array(image)
(note I just used copy_file because I tested with a single file, you can use copy_fs if you need to copy the entire tree - it's the same principle)
I want to pick a random image from the desktop and pass that image into imread() function. Currently, I have added a predefined image into imread(). How can I enter a randomly selected image into that function?
img = cv2.imread("floor_plan_02.png", 0)
If you are running with the Desktop as your current directory, it is as simple as this:
import random
from glob import glob
# Get name of a random PNG file
filename = random.choice(glob('*.png'))
If you are running with a different current directory, you can simply change directory to the desktop first. Or you can use the rather nice pathlib to load a random PNG from your Desktop:
from pathlib import Path
import random
import cv2
# Choose random filename from all PNG files on Desktop
filename = random.choice( list((Path.home() / 'Desktop').glob('*.png')) )
# Open that file with OpenCV
im = cv2.imread(str(filename))
The easiest way to do this is to use glob and numpy
The code below will search your directory for png images & put them in a list called img_files. Then using numpy.random.randint() an index for an image in the list of images is chosen at random.
import glob
import cv2
import numpy as np
# Read in all *.png file names
img_files = []
for file in glob.glob("*.png"):
img_files.append(file)
print(img_files)
# Choose an image at random & read it in
random_image = img_files[np.random.randint(0, len(img_files))]
print(random_image)
img = cv2.imread(random_image, cv2.IMREAD_COLOR)
# Display image
cv2.namedWindow("Random image")
cv2.imshow("Random image", img)
cv2.waitKey()
cv2.destroyAllWindows()
I am trying to read an image using skimage package, then crop it and then save it.
Till cropping it works fine. While saving, it throws the below error
ValueError: Could not find a format to write the specified file in
single-image mode
Below is my code. Any help is highly appreciated.
thanks
import os
import numpy as np
import matplotlib.pyplot as plt
import skimage
import dataloader
from utility import To_csv
path='D:\\beantech_Data\\objtect_detection'
def crop(img):
return skimage.util.crop(img, ((0,500),(0,0),(0,0)))
images, boxes, labels = dataloader.train_loader(path)
os.makedirs(os.path.join(path, 'train','cropped'), exist_ok=True)
for i in range(len(images)):
croped_image = crop(images[i])
skimage.io.imsave(os.path.join(path, 'train','cropped',f'img{str(i)}'), croped_image)
box = boxes[i]
To_csv(box, i,os.path.join(path, 'train','cropped'), Aug= True )
The problem is, no file format is given in the code i.e. (.png, .jpeg etc).
By correcting this line the code works fine-
skimage.io.imsave(os.path.join(path, 'train','cropped',f'img{str(i)}.png'), croped_image)
thanks
Hello i need help with a very simple Python 3 script. In the script i try open a png image file from a folder with this:
png = Image.open('img/image.png', + 'r')
It's work good, but now i need get random .png images from same folder, but after some unsuccessful try, I'll like know how do it, actually i use in my script
from random import randint
import uuid
from PIL import Image
Any help will be appreciated, thank you all
import glob
import random
from PIL import Image
img = random.choice(glob.glob('img/*.png'))
png = Image.open(img, + 'r')
import os,random
from PIL import Image
random_image = random.choice(os.listdir("img"))
Image.open(random_image)
I have about 200 grayscale PNG images stored within a directory like this.
1.png
2.png
3.png
...
...
200.png
I want to import all the PNG images as NumPy arrays.
How can I do this?
According to the doc, scipy.misc.imread is deprecated starting SciPy 1.0.0, and will be removed in 1.2.0. Consider using imageio.imread instead.
Example:
import imageio
im = imageio.imread('my_image.png')
print(im.shape)
You can also use imageio to load from fancy sources:
im = imageio.imread('http://upload.wikimedia.org/wikipedia/commons/d/de/Wikipedia_Logo_1.0.png')
Edit:
To load all of the *.png files in a specific folder, you could use the glob package:
import imageio
import glob
for im_path in glob.glob("path/to/folder/*.png"):
im = imageio.imread(im_path)
print(im.shape)
# do whatever with the image here
Using just scipy, glob and having PIL installed (pip install pillow) you can use scipy's imread method:
from scipy import misc
import glob
for image_path in glob.glob("/home/adam/*.png"):
image = misc.imread(image_path)
print image.shape
print image.dtype
UPDATE
According to the doc, scipy.misc.imread is deprecated starting SciPy 1.0.0, and will be removed in 1.2.0. Consider using imageio.imread instead. See the answer by Charles.
This can also be done with the Image class of the PIL library:
from PIL import Image
import numpy as np
im_frame = Image.open(path_to_file + 'file.png')
np_frame = np.array(im_frame.getdata())
Note: The .getdata() might not be needed - np.array(im_frame) should also work
Using a (very) commonly used package is prefered:
import matplotlib.pyplot as plt
im = plt.imread('image.png')
If you are loading images, you are likely going to be working with one or both of matplotlib and opencv to manipulate and view the images.
For this reason, I tend to use their image readers and append those to lists, from which I make a NumPy array.
import os
import matplotlib.pyplot as plt
import cv2
import numpy as np
# Get the file paths
im_files = os.listdir('path/to/files/')
# imagine we only want to load PNG files (or JPEG or whatever...)
EXTENSION = '.png'
# Load using matplotlib
images_plt = [plt.imread(f) for f in im_files if f.endswith(EXTENSION)]
# convert your lists into a numpy array of size (N, H, W, C)
images = np.array(images_plt)
# Load using opencv
images_cv = [cv2.imread(f) for f in im_files if f.endswith(EXTENSION)]
# convert your lists into a numpy array of size (N, C, H, W)
images = np.array(images_cv)
The only difference to be aware of is the following:
opencv loads channels first
matplotlib loads channels last.
So a single image that is 256*256 in size would produce matrices of size (3, 256, 256) with opencv and (256, 256, 3) using matplotlib.
To read in one image:
import PIL.Image
im = PIL.Image.open('path/to/your/image')
im = np.array(im)
Iterate to read in multiple images.
This answer is similar to this but simpler (no need for .getdata()).
I changed a bit and it worked like this, dumped into one single array, provided all the images are of same dimensions.
png = []
for image_path in glob.glob("./train/*.png"):
png.append(misc.imread(image_path))
im = np.asarray(png)
print 'Importing done...', im.shape
I like the build-in pathlib libary because of quick options like directory= Path.cwd()
Together with opencv it's quite easy to read pngs to numpy arrays.
In this example you can even check the prefix of the image.
from pathlib import Path
import cv2
prefix = "p00"
suffix = ".png"
directory= Path.cwd()
file_names= [subp.name for subp in directory.rglob('*') if (prefix in subp.name) & (suffix == subp.suffix)]
file_names.sort()
print(file_names)
all_frames= []
for file_name in file_names:
file_path = str(directory / file_name)
frame=cv2.imread(file_path)
all_frames.append(frame)
print(type(all_frames[0]))
print(all_frames[0] [1][1])
Output:
['p000.png', 'p001.png', 'p002.png', 'p003.png', 'p004.png', 'p005.png', 'p006.png', 'p007.png', 'p008.png', 'p009.png']
<class 'numpy.ndarray'>
[255 255 255]
If you prefer the standard library:
#IMPORTANT: This Code only works with Python>=3.6
Directory="."#Your directory
import os
import tkinter
import numpy
tk=tkinter.Tk()
tk.overrideredirect(1)
tk.geometry("0x0")
Items=[]
for i in os.listdir(Directory):
fn=Directory+os.sep+i
imgArray=[]
image=tkinter.PhotoImage(file=fn)
for w in range(image.width()):
entry=[]
for h in range(image.height()):
entry.append(image.get(w,h))
imgArray.append(entry)
imgArray=numpy.array(imgArray)
Items.append(imgArray)
tk.destroy()