Assuming one has a base64 encoded image.
How can one extract the image dimensions from the string, preferably without storing the string to disc as an image?
For PNG files, I can get this from bytes 16-24 of the string which are part of the PNG header, but for JPEG images, it appears no such hack exists.
What are some nice ways of getting the image dimensions in this case?
Using the pillow library one can do:
import io
import PIL
from PIL import Image
imgdata = base64.b64decode(base64_str)
im = Image.open(io.BytesIO(imgdata))
width, height = im.size
Related
Sorry for my english but it's not my first language.
I would like to create a program that:
Transform a jpeg or png image into an array (very important: I would like an array composed only of the values that the pixels of the image have and not metadata or other information. Where I can select each specific pixel of the image).
Save this array in a txt file.
Transform this array composed of only the pixel values of the image back into jpg or png image and save it in a file.
Requests:
Is the array I created with the program I wrote composed only of the pixel values of the image? is there also metadata or other information?
Is this a valid way to remove metadata from an image?
Is this a valid way to create the array representing that image pixel by pixel?
Is this a valid way to convert png images to jpeg or jpeg to png?
Thank you!
This is the program I created, any opinion?
import numpy as np
from PIL import Image
import sys
img_data = Image.open("imagea.jpeg")
img_arr = np.array(img_data)
np.set_printoptions(threshold=sys.maxsize)
print(img_arr.shape)
new_img = Image.fromarray(img_arr)
new_img.save("imageb.jpeg")
print("Image saved!")
file = open("file1.txt", "w+")
content = str(img_arr)
file.write(content)
file.close()
print("Finished!")
Loading an image and converting it to a Numpy array is a perfectly legitimate way of discarding all metadata including:
EXIF data, copyright data,
IPTC and XMP data,
ICC colour profile data
You can tell it's all gone by thinking about the Numpy array you hold and its dimensions and data type.
Note that you need to be careful with PNG palette images and images with an alpha channel.
Note that you can achieve this more simply on the command-line with ImageMagick using:
magick mogrify -strip IMAGE.JPG
Or with exiftool.
Note that you can achieve this by using a format that doesn't support metadata, such as NetPBM, with extension .ppm e.g.:
magick INPUT.JPG -strip -compress none RESULT.PPM # gives P3/plain ASCII file
magick INPUT.JPG -strip RESULT.PPM # gives P6/binary file
You can also read/write PPM files with PIL.
I have an image in memory (downloaded from an online source) and I want to convert it to a different format before sending it on to a different online location.
The conversion is .webp to .jpg but that's not really relevant.
With Pillow I can easily convert local images and save them back to disc, but I can't get it to work with an image in memory.
I don't necessarily need to use Pillow. Any way to convert the image without having to save anything to disc is fine.
I am new to BytesIO with PIL, so just check my code attempt, with my test image it works, let me know
from PIL import Image
from io import BytesIO
img = Image.open('test.webp')
print('image : ', img.format)
img.show()
# Write PIL Image to in-memory PNG
membuf = BytesIO()
img.save(membuf, format="png")
img = Image.open(membuf)
print('image : ', img.format)
img.show()
I am using tinytags module in python to get the cover art of a mp3 file and want to display or store it. The return type of the variable is showing to be bytes. I have tried fumbling around with PIL using frombytes but to no avail. Is there any method to convert the bytes to image?
from tinytag import TinyTag
tag = TinyTag.get("03. Me, Myself & I.mp3", image=True)
img = tag.get_image()
I actually got a PNG image when I called tag.get_image() but I guess you might get a JPEG. Either way, you can wrap it in a BytesIO and open it with PIL/Pillow or display it. Carrying on from your code:
from PIL import Image
import io
...
im = tag.get_image()
# Make a PIL Image
pi = Image.open(io.BytesIO(im))
# Save as PNG, or JPEG
pi.save('cover.png')
# Display
pi.show()
Note that you don't have to use PIL/Pillow. You could look at the first few bytes and if they are a PNG signature (\x89PNG) save data as binary with PNG extension. If the signature is JPEG (\xff \xd8) save data as binary with JPEG extension.
I am trying to convert 8 bit images to 10 bit. I thought it would be as easy as changing the bin values. I've tried to pillow and cv-python:
from PIL import Image
from numpy import asarray
import cv2
path = 'path/to/image'
img = Image.open(path)
data = asarray(img)
newdata = (data/255)*1023 #2^10 is 1024
img2 = Image.fromarray(newdata) #this fails
cv2.imwrite('path/newimage.png, newdata)
While cv2.imwrite successfully writes the new file, it is still encoded as an 8bit image even though bin goes up to 1023.
$ file newimage.png
newimage.png: PNG Image data, 640 x 480, 8-bit/color RGB, non-interlaced
Is there another way in either python or linux that can convert 8-bit to 10-bit?
Lots of things going wrong here.
You are mixing OpenCV (cv2.imwrite) with PIL (Image.open) for no good reason. Don't do that, you will confuse yourself as they use different RGB/BGR orderings and conventions,
You are trying to store 10-bit numbers in 8-bit vectors,
You are trying to hold 3 16-bit RGB pixels in a PIL Image which will not work as RGB images must be 8-bit in PIL.
I would suggest:
import cv2
import numpy as np
# Load image
im = cv2.imread(IMAGE, cv2.IMREAD_COLOR)
res = im.astype(np.uint16) * 4
cv2.imwrite('result.png', res)
I found a solution using pgmagick wrapper for python
import pgmagick as pgm
imagePath = 'path/to/image.png'
saveDir = '/path/to/save'
img = pgm.Image(imagePath)
img.depth(10) #sets to 10 bit
save_path = os.path.join(saveDir,'.'.join([filename,'dpx']))
img.write(save_path)
How i can save or download this picture with python
data:image/jpeg;base64,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
Well, the start of the string (this part data:image/jpeg;base64,) tells you it is base64 encoded. So, you need to strip all that off and find the start the image, which is /9j, and just grab the image part which is the rest of the string.
b = b'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD...'
z = b[b.find(b'/9'):]
Then you need base64 decode the result, and make it into a BytesIO object that PIL can read. Then read it into a PIL Image and save it:
im = Image.open(io.BytesIO(base64.b64decode(z))).save('result.jpg')
So, the entire code will look like:
import base64
import io
from PIL import Image
# Initialise your data
b = b'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD...'
z = b[b.find(b'/9'):]
im = Image.open(io.BytesIO(base64.b64decode(z))).save('result.jpg')
Keywords: image, image processing, base64, b64, encode, encoded, decode, decoded, PIL, Pillow, Python