I cringed when my wife told me her digital enlarger timer broke. Thankfully it didn’t cost us a lot at the time, but it should have. I was lucky enough to restore a broken one I bought off eBay, no such luck this time. But then I thought, a timer is a really simple thing. Why should buying a new one cost over $200? I decided to build my own, and now you can too for less than $60!
An enlarger timer is very simple, it just needs to turn on the power to the enlarger for an exact period of time and then turn it back off. I currently have it set to have tenth of second accuracy. I also went ahead and made the darkroom light switch off during the process, as the IoT relay has a built in negative gate logic for one plug.
A quick warning before we begin: I did all this over a year ago, and while it is still working flawlessly, I can’t promise I remember everything. If there is anything missing and you get it working, please leave a comment so I can update the post or code! Also standard disclaimer that I am not an electric engineer and I am not responsible for you hurting your equipment or yourself by trying to follow this guide.
Then before you plug all the toys into it, make sure the system is up to date. Next we need to enable SPI. Make sure to go through the pre-requisites and the install section. Then install the darkroom software.
Launch sudo raspi-config and into 3 Boot Options then B1 Desktop / CLI and set B2 Console Autologin
Add user to proper groups sudo usermod -a -G spi,gpio pi
Now turn off and unplug the raspberry pi, and lets connect stuff! Follow the luma guide to hook up the display, copied below for convenience.
Let’s take a look at the raspberry pin layout. The Pi 2 that I used only has the first 26 GPIO pins, and even if you have a 3 or 4, the first 26 pin layout is the same. Below is my PowerPpoint diagram reference. I am going to color the boxes the same as the wires in my pictures so they match up visually.
If you look closely at the image of mine, you’ll note I was naughty and put the +5v (pin 2) into +3.3v (pin 1) instead. I think I did it on purpose to make it not as bright. Though I can’t really remember if that or just mistake, either way, it works for me. Next we’re going to add in the IoT Relay.
So now it should look kinda look like how I have mine (just the two positives in different positions at the top).
Running the Enlarger Timer
Now it’s time to turn on the Pi and see if stuff works!
First, run through the example program provided by luma. For my 4×4 display I needed to run:
When that is working, plug in a light (or your enlarger) to the IoT relay, go back into the darkroom directory and give it a try!
cd darkroom
python -m darkroom
To use is pretty simple: press *, enter the time you want to set, and hit enter. View all the available commands and customizations (like changing the startup message) on the github project page.
To have the code run on startup, I simply added it to my .bashrc file to run as soon as the user logs in.
When interviewing Python programming candidates, my wife always likes to ask the simple question, “can you name ten Python standard library modules?” This is harder than most think, as many people will completely blank out and others will be dead wrong. “Requests?” one poor soul answered. It’s a good interview question, as it gives insight onto what people are familiar with and may use regularly. So I sat down and though of of which ones I use and enjoy the most. So here are my top ten(ish) useful, favorite and unordered standard modules.
pathlib
Back in the dark days, you would have to store your path as a string, and call obscure functions under os.path to figure anything out about it. Pathlib removes the headache.
from pathlib import Path
my_path = Path('text_file.txt')
if not my_path.exists():
my_path.write_text('File Content')
assert my_path.exists()
assert my_path.is_file()
There are a boatload of uses for a temporary file or directory. Hence why it’s in the standard library. I find myself using them together, inside context managers more often than not.
from pathlib import Path
from tempfile import TemporaryDirectory, TemporaryFile
with TemporaryDirectory(prefix='Code_', suffix='_Calamity') as temp_dir:
with TemporaryFile(dir=temp_dir) as temp_file:
temp_file.write(b'Test')
temp_file_path = Path(temp_file.name)
assert temp_file_path.exists()
# Make sure file only exists within the context
assert not temp_file_path.exists()
I usually end up using this when a tool or library wants to work with a file rather than standard input, so short lived files in a context manager make life a lot easier. Tempfile python docs.
subprocess
Python is pretty amazing, but sometimes you do need to call other programs. Subprocess makes it easy to execute and interact with other executable across operating systems. Check out my other post on it!
from subprocess import run, PIPE
response = run("echo 'Join the Dark Side!'", shell=True, stdout=PIPE)
print(response.stdout.decode('utf-8'))
# 'Join the Dark Side!'
logging
This is probably the most useful built in library for debugging there is, and I see it either unused or misused more than anything else.
Two very different things for widely different uses, but they have very similar interfaces and easy to talk about at the same time. Quick and dirty difference: Use threading for IO heavy tasks (writing to files, reading websites, etc) and multithreading for CPU heavy tasks.
from multiprocessing.pool import ThreadPool, Pool
def square_it(x):
return x*x
# On Windows, make sure that multiprocessing doesn't start
# until after "if __name__ == '__main__'"
# Pool and ThreadPool are interchangable in this example
with Pool(processes=5) as pool:
results = pool.map(square_it, [5, 4, 3, 2 ,1])
print(results)
# [25, 16, 9, 4, 1]
The Python world would not exist if we didn’t have all the power and functionality these built-ins bring. You really haven’t coded in Python if you haven’t used these yet, so I won’t even bother elaborating them here.
random and uuid
Maybe you’re making a game…
import random
random.choice(['Sneak Attack', 'High Kick', 'Low Kick'])
Or debugging a webserver…
from uuid import uuid4
# Bad example, but not writing out a whole webserver to prove a point
def get(*args):
request = uuid4()
logger.info(f'Request {request} called with args {args}')
Or turning your webserver into your own type of game…
if user_name == 'My Boss':
time.sleep(random.randint(1, 5))
No matter which you are doing, it’s always handy to have randomly generated or unique numbers.
socket
The internet runs because of sockets. Modern technology exists because of sockets. Sockets are life, sockets are….annoying low level at times but its good to know the basics so you can appreciate everything written on top of them.
Need to check a file’s integrity? Hashlib is there with md5 and sha hashes! I created a reusable function to easily reference when I need to do it.
Need to securly store people’s password hashes for a website? Hashlib now has scrypt support! Heck, here is my own function I always use to generate the scrypt hashes.
from collections import namedtuple
import hashlib
import os
Hashed = namedtuple('Hashed', ['hash', 'salt', 'n', 'r', 'p', 'key_length'])
def secure_hash(value: bytes, salt: bytes = None, key_length: int = 128, n: int = 2 ** 16, r: int = 8, p: int = 1):
maxmem = n * r * 2 * key_length
salt = salt or os.urandom(16)
hashed = hashlib.scrypt(value, salt=salt, n=n, r=r, p=p, maxmem=maxmem, dklen=key_length)
return Hashed(hash=hashed.hex(), salt=salt.hex(), n=n, r=r, p=p, key_length=key_length)
venv
You probably only think of it as a command when you run python -m venv python_virtual_env to create your environments, but it’s run that way because it’s a standard library. Every new project you start or Python program you install should be using this library, so it is used a lot!
Summary
There ya go, 10 or so can’t live without standard libraries! Isn’t it so nice that Python comes “batteries included”?
First, straight to the fun, download FastFlix here to try it out! FastFlix started out to be a small clip and GIF maker for myself, but quickly realized I could expand it for larger usage. And it just so happens that AV1 is an emerging codec that doesn’t have a lot of GUI options yet, it’s like it was meant to be!
Before going out and re-encoing everything with AV1, which will be the next standard codec as everyone is on board with it, there are a few catches, so make sure to read on.
What makes FastFlix unique?
AV1 Support for multiple libraries
FastFlix is designed as a FFmpeg wrapper, so it can support multiple different encoders. Right now it supports libaom-av1, rav1e and SVT-AV1 libraries for AV1, as well as x265, x264 and VP9.
Totally MIT open source code, reuse to your hearts content!
FastFlix has been designed in a way to keep it legal to re-use any of it’s core code in your own projects without forcing them to be open source. The catch is the binary itself is GPL.
Extensible
FastFlix was designed to have an easy to expand architecture for encoders. That way others can design their own encoder wrappers on top of what is already available to bring additional functionally.
What’s the catch?
New program using an experimental codec
There will be bugs. Both on the GUI side and on the codec side. Report anything weird you see and we’ll try to figure out it’s a GUI problem or needs to be passed along to the codec team.
I’m just one guy, and this is a side project
I don’t make any money (nor take donations. $10K+ bribes, please email me š) and FastFlix is not something I will spend all my free time on. So I am always looking for help and feedback!
There is currently a serious lack of data on compressing 4K HDR videos out there, so I took it upon myself to get learned in the ways of the x265 encoding world.
First things first, this is NOT a guide for Dolby Vision or HDR10. This is simply for videos using the BT.2020 color primaries. Please read the new article for saving HDR.
I have historically been using the older x264 mp4s for my videos, as it just works on everything. However most devices finally have some native h.265 decoding. (As a heads up h.265 is the specification, and x265 is encoder for it. I may mix it up myself in this article, don’t worry about the letter, just the numbers.)
Updated: 6/29/2020 – Please refer to the new guide
Updated: 4/14/2019 – New Preset Setting (tl;dr: use slow)
What are the best settings for me to use when encoding x265 videos?
The honest to god true answer is “it depends”, however I find that answer unsuitable for my own needs. I want a setting that I can use on any incoming 4K HDR video I buy.
I mainly use Handbrake now use ffmpeg because I learned Handbrake only has a 8-bit internal pipeline. In the past, I went straight to Handbrake’s documentation. It states that for 4K videos with x265 they suggest a Constant Rate Factor (CRF) encoding in the range of 22-28 (the larger the number the lower the quality).
Through some experimentation I found that I personally never can really see a difference between anything lower than 22 using a Slow present. Therefore I played it safe, bump it down a notch and just encode all of my stuff with x265 10-bit at CRF of 20 on Slow preset. That way I know I should never be disappointed.
Then I recently read YouTubes suggest guidelines for bitrates. They claim that a 4K video coming into their site should optimally be 35~45Mbps when encoded with the older x264 codecs.
Now I know that x265 can be around 50% more efficient than x264, and that YouTube needs it higher quality coming in so when they re-compress it it will still look good. But when I looked at the videos I was enjoying just fine at CRF 22, they were mostly coming out with less than a 10Mbps bitrate. So I had to ask myself:
How much better is x265 than x264?
To find out I would need a lot of comparable data. I started with a 4K HDR example video. First thing I did was to chop out a minute segment and promptly remove the HDR. Thus comparing the two encoders via their default 8-bit compressors.
I found this code to convert the 10-bit “HDR” yuv420p10le colorspace down to the standard yuv420p 8-bit colorspace from the colourspace blog so props to them for having a handy guide just for this.
Then I ran multiple two pass ABR runs using ffmpeg for both x264 and x265 using the same target bitrate. Afterwards compared them to the original using the Structural Similarity Index (SSIM). Put simply, the closer the result is to 1 the better. It means there is less differences between the original and the compressed one
Generated via Python and matplotlib (Click to view larger version)
The SSIM result is done frame by frame, so we have to average them all together to see which is best overall. On the section of video I chose, x264 needed considerably more bitrate to achieve the same score. The horizontal line shows this where x264 needs 14Mbps to match x265’s 9Mbps, a 5000kbps difference! If we wanted to go by YouTube’s recommendations for a video file that will be re-encoded again, you would only need a 25Mbps x265 file instead of a 35Mbps x264 video.
However the averages don’t tell the whole story. Because if every frame was that good, we shouldn’t need more than 6Mbps x265 or 10Mbps x264 4K video. So lets take a step back and look at the lowest 1% of the frames.
Generated via Python and matplotlib (Click to view larger version)
Here we can see x264 has a much harder time at lower bitrates. Also note that the highest marker on this chart is 0.98, compared the total average chart’s 0.995.
This information alone confirmed for me that I will only be using x265 or newer encodings (maybe AV1 in 2020) for storing videos going forward.
I have always read to use Constant Rate Factor over Average BitRate for stored video files (and especially over Constant Quality). CRF is the best of both worlds. If you have an easily compressible video, it won’t bloat the encoded video to meet some arbitrary bitrate. And bitrate directly correlates to file size. It also won’t be constrained to that limit if the video requires a lot more information to capture the complex scene.
But that is all hypothetical. We have some hard date, lets use it. So remember, Handbrake recommends a range of 22-28 CRF, and I personally cannot see any visual loss at CRF 20. So where does that show up on our chart?
Generated via Python and matplotlib (Click to view larger version)
Now this is an apples to oranges comparison. The CRF videos were done via Handbrake using x265 10-bit, whereas everything else was done via ffmpeg using x265 or x264 8-bit. Still, we get a good idea of where these show up. At both CRF 24 and CRF 22, even the lowest frames don’t dip below SSIM 0.95. I personally think the extra 2500kbps for the large jump in minimum quality from CRF 24 to CRF 22 is a must. To some, including myself, it could be worth the extra 4000kbps jump from CRF 22 to CRF 20.
So let’s get a little more apples to apples. In this test, I encoded all videos with ffmpeg using the default presents. I did three CRF videos first, at 22, 20, and 18, then using their resulting bitrates created three ABR videos.
Generated via Python and matplotlib (Click to view larger version)
Their overall average SSIM scores were near as identical. However, CRF shows its true edge on the lowest 1%, easily beating out ABR at every turn.
To 10-bit or not to 10-bit?
Thankfully there is a simple answer. If you are encoding to x264 or x265, encode to 10-bit if your devices support it. Even if your source video doesn’t use the HDR color space, it compresses better.
There is only one time to not use it. When the device you are going to watch it on doesn’t support it.
Which preset should I use?
The normal wisdom is to use the the slowest you can stand for the encoding time. Slower = better video quality and compression. However, that does not mean smaller file size at the same CRF.
Even though others have tackled this issue, I wanted to use the same material I was already testing and make sure it held true with 4K HDR video.
Generated via Python and matplotlib (Click to view larger version)
I used a three minute 4K HDR clip, using Handbrake to only modify which present was used. The results were surprising to me to be honest, I was expecting medium to have a better margin between fast and slow. But based on just the average, slow was the obvious choice, as even bumping up the CRF from 18 to 16 didn’t match the quality. Even thought the file size was much larger for the CRF 16 Medium encoding than it was than for the CRF 18 Slow! (We’ll get to that later.)
Okay, okay, lets back up a step and look at the bottom 1% again as well.
Generated via Python and matplotlib (Click to view larger version)
Well well wishing well, that is even more definitive. The jump from medium to slow is very significant in multiple ways. Even though it does cost double the time of medium it really delivers in the quality department. Easily beating out the lowest 1% of even CRF 16 medium, two entire steps away.
Generated via Excel (Click to view larger version)
The bitrates are as expected, the higher quality it gets the more bitrate it will need. What is interesting, is if we put CRF 16 - Medium encoding’s bitrate on this chart it would go shoot off the top at a staggering 15510kbps! Keep in mind that is while still being lesser quality than CRF 18 - Slow.
In this data set, slow is the clear winner in multiple ways. Which is very similar to other’s results as well, so I’m personally sticking too it. (And if I ran these tests first, I would have even used slow for all the other testing!)
Conclusion
If you want a single go to setting for encoding, based on my personal testing CRF 20 with Slow preset looks amazing (but may take too long if you are using older hardware).
Now, if I have a super computer and unlimited storage, I might lean towards CRF 18 or maybe even 16, but still wouldn’t feel the need to take it the whole way to CRF 14 and veryslow or anything crazy.
I hope you found this information as useful as I did, if you have any thoughts or feedback please let me know!
Iām an artist and a python developer, two things that rarely occupy the same worlds, let alone the same sentence. However, I have recently found a way to combine these two passions: Panoramas.
My current smartphone takes excellent pictures. It does a great job at figuring out colors, lighting, and focus, even in low lighting. As an artist, this is important to me because I often use my phone to snap quick pictures of a scene as a reference to take back to my studio. Itās a huge improvement in the technology I had in my hands even five years ago. There is one thing about my old phone that I miss though – its āpanoramaā photo mode, but not because it was better.
I miss how amazingly awful it used to be, and more importantly, the freedom to make awful pictures it allowed. Iād point the lens out the window of the car as it sped along (as a passenger of course) to make jagged and confusing images of tiny bits of the landscape that the phone struggled to hodgepodge together. Iād tilt and move the phone in random directions to make weird swirls of the horizon. Even when being used āas directedā, it would usually struggle with focus and lighting coming up with spontaneously and wonderfully terrible photos with abstract light glare or menacing dark patches. Itās hard to explain, but sometimes as an artist, a terrible photo can be just as inspiring as those picture perfect reference pics I take with me back to the studio.
My current phone is too smart for that though, and it snatches away any joy of bad photography by making consistently beautiful and seamless panoramas. Not only that, but it accomplishes this mostly by yelling at you (āYouāre going too fast!ā) or by using angry arrows to make sure you can only move the phone in one direction, and then abruptly ending the photograph when you donāt cooperate. So, I did what anyone does when they get nostalgic for awful photography – I made a python script to make my own terrible panoramas.
My plan was simple. First, I would shoot short videos where my phone wouldnāt yell at me for moving, tilting, and spinning the image as much as I wanted. Next, use Python to convert each frame of the video clip to an image, crop the image into a tiny sliver out of the center of the image and then glue them all together. The results are imperfect. And gloriously so.
Side note: Although I used my smartphone to shoot some video, this script could be applied to any video. Think of the wild panoramas you could create from some Russian dash cam footage, or a GoPro strapped to a fish, or a tiny clip from the Lord of the Rings. However, this script works best on videos that are less than 10 seconds long or else it produces mile long panoramic images. Currently, I donāt bother limiting the image size at all, but theoretically I could by using one out of every five frames for instance, or by cutting down the image slice size based on video length.
The Python Image Library is the only other requirement, installed with pip.
pip3 install pillow
The script works by pulling all videos out of a source directory based on file suffix and creating a panorama for each. This could easily be modified to convert just one video at a time by removing the loops and passing the path to the desired video directly to ffmpeg.
directory = Path('my\\videos\\dir')
vids = []
for vid in directory.iterdir():
if vid.suffix.lower() in ('.mp4', '.mkv'):
vids.append(vid)
Every frame pulled out by ffmpeg is stored in a file. I delete the directory and recreate it before ffmpeg runs to delete the old frames from the last run.
for vid in vids:
shutil.rmtree("pics", ignore_errors=True)
os.makedirs("pics", exist_ok=True)
print(f'Creating panoramic {vid.stem}')
result = run(
f'ffmpeg -i {vid.absolute()} '
f'-y pics\\thumb%04d.jpg -hide_banner',
shell=True, stderr=PIPE)
result.check_returncode()
print(result.stderr.decode('utf-8'))
After it finishes pulling out all the frames, I start the panorama by creating an empty image. I need to have the dimensions of the finished image to create it. To get the final width, I multiply the number of frames ffmpeg pulled out by the width of my image slice (40 pixels). For the height, I open up one of the frames and use it size as a reference. I also use the sample image’s dimensions to figure out the center of the image for cropping everything down later.
Then, I loop through all the frame images in reverse order (because ā¦ long story short, it usually looks better that way) and then work on slicing each image down to 40 pixels wide to glue into the panorama.
sample = Image.open("pics/{}".format(os.listdir("pics")[0]))
width, height = sample.size
center = width / 2
panoramic = Image.new('RGB', (len(os.listdir("pics")*40), height))
# This offset is so PIL knows where to start adding
# each image slice to the panorama
x_offset = 0
for i in reversed(os.listdir("pics")):
img = Image.open("pics/{}".format(i))
area = (center - 20, 0, center + 20, height)
cropped_img = img.crop(area)
panoramic.paste(cropped_img, (x_offset, 0))
x_offset += 40
panoramic.save(f'{vid.stem}.jpeg')
panoramic.close()
The Painting
So far, I am quite happy with the results of this adorable little script. It has definitely given me the creative inspiration I was missing. In the past two weeks, I have done three series of paintings based on panoramas I have created using it, with plans for many more. Hereās an example of how I used it to create some artwork!
I took this video:
turned it into this panorama:
played with some paint and smudged around some charcoal and pastels:
and came up with this:
Final Thoughts
It feels really amazing to apply Python to unusual problems, even if that challenge is finding a unique way of creating original art. Plus, if the inspiration ever dries up, I have some ideas for making this script even more fun:
grab each slice from a random spot rather than dead center of the image for something much more jumbled and abstract
options to not use every frame for longer videos
PIL ‘effects’, like a black and white mode, over saturation, or extra blurry images
an ‘up and down’ mode for tall panoramas
I hope you enjoyed! Feel free to check out my website or my instagram for more artwork if you are interested.
