This is a code of a JPG/PNG(I don't know exactly)
Here's on google docs
I need to decode it in Python to complete image and show it using Pillow or something like that. Do you know any libraries or ways how to decode it? Thanks!
(for Python 3)
If the image is stored as a binary file, open it directly:
import PIL
# Create Image object
picture = PIL.Image.open('picture_code.dat')
#display image
picture.show()
# print whether JPEG, PNG, etc.
print(picture.format)
If the image is stored as hex in a plaintext file picture_code.dat similar to your Google Docs link, it needs to first be converted to binary data:
import binascii
import PIL
import io
# Open plaintext file with hex
picture_hex = open('picture_code.dat').read()
# Convert hex to binary data
picture_bytes = binascii.unhexlify(picture_hex)
# Convert bytes to stream (file-like object in memory)
picture_stream = io.BytesIO(picture_bytes)
# Create Image object
picture = PIL.Image.open(picture_stream)
#display image
picture.show()
# print whether JPEG, PNG, etc.
print(picture.format)
Related
Can someone help me turn this base64 data into image? I don't know if it's because the data was not decoded properly or anything else. Here is how I decoded the data:
import base64
c_data = { the data in the link (string type) }
c_decoded = base64.b64decode(c_data)
But it gave the error Incorrect Padding so I followed some tutorials and tried different ways to decode the data.
c_decoded = base64.b64decode(c_data + '=' * (-len(c_data) % 4))
c_decoded = base64.b64decode(c_data + '=' * ((4 - len(c_data) % 4) % 4)
Both ways decoded the data without giving the error Incorrect Padding but now I can't turn the decoded data into image.
I have tried creating an empty png then write the decoded data into it:
from PIL import Image
with open('c.png', 'wb') as f:
f.write(c_decoded)
image = Image.open('c.png')
image.show()
It didn't work and gave the error: cannot identify image file 'c.png'
I have tried using BytesIO:
from PIL import Image
import io
from io import BytesIO
image = Image.open(io.BytesIO(c_decoded))
image.show()
Now it gave the error: cannot identify image file <_io.BytesIO object at 0x0000024082B20270>
Please help me.
Not sure if you definitely need a Python solution, or you just want help decoding your image like the first line of your question says, and you thought Python might be needed.
If the latter, you can just use ImageMagick in the Terminal:
cat YOURFILE.TXT | magick inline:- result.png
Or equivalently and avoiding "Useless Use of cat":
magick inline:- result.png < YOURFILE.TXT
If the former, you can use something like this (untested):
from urllib import request
with request.urlopen('data:image/png;base64,iVBORw0...') as response:
im = response.read()
Now im contains a PNG-encoded [^1] image, so you can either save to disk as such:
with open('result.png','wb') as f:
f.write(im)
Or, you can wrap it in a BytesIO and open into a PIL Image:
from io import BytesIO
from PIL import Image
pilImage = Image.open(BytesIO(im))
[^1]: Note that I have blindly assumed it is a PNG, it may be JPEG, so you should ideally look at the start of the DataURI to determine a suitable extension for saving your file.
Credit to #jps for explaining why my code didn't work. Check out #Mark Setchell solution for the reliable way of decoding base64 data (his code fixes my mistake that #jps pointed out)
So basically remove the [data:image/png;base64,] at the beginning of the base64 string because it is just the format of the data.
Change this:
c = "data:image/png;base64,iVBORw0KGgoAAAANSUh..."
to this:
c = "iVBORw0KGgoAAAANSUh..."
and now we can use
c_decoded = base64.b64decode(c)
I could easily convert HEIC to JPEG in python with a pyheic library.
But the filesize gets larger when it's converted to JPEG. (About 4 times). Can I reduce the size of the file saving it?
How can I get base64-encoded string instead of saving JPEG image?
My code is as follows:
# -*- coding: utf-8 -*-
import sys
import os
from PIL import Image # pip3 install pillow
import pyheif # pip3 install pyheif
def call(oriPath, defPath):
try:
# if defPath is webp or heic
fileType = oriPath.split(".")[-1]
if fileType == "heic":
heif_file = pyheif.read(oriPath)
image = Image.frombytes(
heif_file.mode,
heif_file.size,
heif_file.data,
"raw",
heif_file.mode,
heif_file.stride,
)
image.save(defPath, "JPEG")
except:
print(False)
return
print(True)
Since you are converting from one data type to the other the format is changing. I am not too familiar with HEIC but it could be the case that it is simply a smaller file size with the compression parameters that you have set for the JPEG.
wikipedia has the following to say about it
A HEIF image using HEVC requires less storage space than the equivalent quality JPEG.
So unless you want to drop the quality it might not even be possible to get a smaller image (note: I have no idea what type the HEIC/HEIF is).
As for the base64 encoded string, you could just read the binary data and convert it to base64 per this question: Python: How do I convert from binary to base 64 and back?
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 create a Python dashboard in which a user uploads an image and then the image is analyzed. The uploaded image is received as a base64 string and it needs to be converted to an image. I have tried
decoded = BytesIO(base64.b64decode(base64_string))
image = Image.open(decoded)
but I received this error:
cannot identify image file <_io.BytesIO object at 0x00000268954E9888>
Image needs a file-like object, the sort of thing returned by an open. The easiest way to do this is using a with statement:
decoded = base64.b64decode(base64)
with BytesIO(decoded) as fh:
image = Image.open(fh)
# do stuff with image here: when the with block ends
# it's very likely the image will no longer be usable
See if that works better for you. :)
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