SIXTY-FOUR
MEGAPIXELS.
That's a lot of megapixels!
And you know what's better?
FULL TIME AUTOFOCUS on a Pi camera!
Well, maybe.
We'll have to see how this thing works.
It's Arducam's new Hawk-eye camera for the Raspberry Pi, and it cost $36 during their
Kickstarter campaign.
They sent me this early production unit, and I'm gonna see how it stacks up.
The camera's board layout is identical to the V1 and V2 Pi cameras, but the module on
the front is pretty hefty, so it won't fit everywhere a normal Pi camera does.
That's because inside the giant metal housing is an electromagnetic autofocus system.
That allows this camera to have full-time autofocus, but it also makes it more susceptible
to vibration, so use on a drone or certain robots might not be as good as a fixed-lens camera.
And because of that motor, this camera actually makes a tiny noise and moves in and out when it autofocuses.
It's not annoying, but definitely worth keeping in mind if you want to build a custom enclosure for it.
You can use up to four of these things together for quad imaging, but you have to have a Compute
Module 4 to do that.
You can get the full 64 megapixel resolution on a Pi 4 or Compute Module 4, but the resolution
drops to 16 megapixels on older Pis.
The actual sensor in here can get 60 fps at 1080p or 20 at 4K...but the Raspberry Pi
can't handle that much data, so you're limited to 30 fps at 1080p.
I think this sensor's a Sony IMX686, but ArduCam won't confirm the exact model.
If it is that sensor, it has a pixel pitch of 0.8 micrometers, which is half the HQ camera's
pixel pitch, and still a little smaller than the V2 camera.
So the big question is how well the optics and sensor work together, and if the camera
can still produce a great image with that small a pixel size.
But still, the sensor itself is pretty big.
The HQ camera used to be the champion, with a sensor that's 7.9mm diagonal, but now the
Hawk-Eye is the biggest, 9.2mm.
But to use the Hawk-Eye at all, you have to install ArduCam's custom driver.
That driver isn't compatible with the Pi cameras, so you can't mix and match or switch between
a Hawk-Eye and Pi Camera without reinstalling.
Hopefully the driver will be upstreamed at some point, but for now it requires a manual
install.
And before we get to testing, I have to make one thing clear: sensor size, megapixel count,
even specs like the lens aperture don't really matter at all in isolation.
For any camera system, the whole system makes the image.
There's a reason pros at the Olympics aren't running around with a Raspberry Pi 4 and one
of these Arducams shooting sports.
I have this old Nikon D700, and it only has a 12 megapixel sensor.
But the pictures I take with it will blow away the images I can get out of any Pi camera,
even the Hawk-Eye.
And that's ignoring every other feature that makes this camera legendary, like it's build
quality, weather sealing, battery life, and interface.
Under certain ideal lighting conditions, you could probably coax a pretty nice image out
of the Hawk-Eye, but don't expect to buy a Hawk-Eye and a Raspberry Pi and build something
on the level of even a cheap mirrorless camera.
The laws of physics really limit what you can do with such a tiny sensor, even if it's
the latest and greatest from Sony.
But the Hawk-Eye isn't meant to compete with a handheld mirrorless camera.
It's made to work for computational photography, for surveillance, or for other hobby projects.
It's basically a modern high-quality phone camera, but one you can control with your
own software.
Which is pretty powerful, if you think about it!
Like take for instance their stereo and quad-camera kits.
You could build an extremely high resolution 360° camera or some cool custom VR rigs.
There are definitely limitations with current-gen Pi hardware, but I'll talk a little more about
that later, when I get to testing.
With all that out of the way, I went ahead and plugged the camera into my Pi 4 model
B using the included camera cable, put Pi OS on a microSD card and put that in the Pi,
then mounted the little protective case to a little tripod arm on my desk.
I booted up the Pi and installed the custom Arducam drivers.
I put all the instructions for that in my blog post, linked below.
The first thing I wanted to test was image quality.
The user guide recommends shooting at a resolution around 16 megapixels, and at that resolution,
the camera looks great.
But that's leaving some performance on the table.
This camera goes up to 64 megapixels!
This is the same image, but taken at a resolution of 9248 by 6944.
Look at the detail in that screw; zoomed all the way in, there's a tiny bit of chromatic
aberration, but it's a lot sharper than the 16 megapixel image.
And it might look like someone added a tiny bit of haze to this picture, but that's not
haze, that's the result of diffraction.
I won't get into the physics of it, but basically, when you go for such a high resolution on
such a tiny sensor, the aperture actually gets in the way, causing light to bend a little.
And that means extreme detail gets a little fuzzy.
Even though this lens has an f/1.8 aperture, it's not big enough to prevent the loss of
some detail at 64 megapixels.
I can't measure it exactly at my house, but I'd guess the Hawk-Eye's lens is great up
to maybe 30 or 40 megapixels.
Past that, you'll get that slight haze from diffraction.
It's not all bad, though; you can usually sweeten up an image in post-processing and
the diffraction won't even be noticeable.
Let's take a look at the same picture taken with my iPhone 13 Pro.
Its camera only has a 12 megapixel sensor, but discounting the resolution loss, details
are still pretty well-defined.
But it is nice to have that additional resolution.
I kinda wish my iPhone had more resolution now.
But the Hawk-Eye isn't really competing against an iPhone.
It uses the Pi Camera form factor, so let's see how it stacks up against the V2 camera
module.
Here's a picture I took with the Hawk-Eye from where I normally record my videos.
The details are great, though it looks like Arducam's autofocus picked up on the background
in this shot, and not my face.
As I mentioned in my last video on Arducam's first autofocus camera, the driver that controls
autofocus has an algorithm that you can't really modify, so it's kind of a black box.
It's not like my mirrorless camera, where I can choose a focus point or use face detect.
Something like that could be possible with the right software, but it's not perfect out
of the box.
But here's the same shot on a Pi Camera V2.
The color and exposure are practically the same.
But there are a few interesting things: First, for some reason, there was a bit of
yellow banding going on on the Hawk-Eye's pictures.
It's easiest to spot in the background, where the vent cover is.
That wasn't visible at all on the Pi Camera, and it might have something to do with my
lighting, but it's just something I noticed more on the Hawk-Eye.
Second, the blacks especially are way less noisy on the Hawk-Eye than the Pi Camera.
The sensor and lens work together to make a much clearer image.
I mean, look at the name badges in the background, or at the top of my guitar, where you can
actually notice a missing string if you look at the Hawk-Eye shot.
Moving on to video, both the Pi Camera and the Hawk-Eye are limited by the Pi's bandwidth.
I took both of these side-by-side video clips using a similar setup, and they look a lot
like each other.
One thing to note is the cropping on the Hawk-Eye is much less severe, so you can get more in
frame when recording HD video than you can with the V2 camera.
But other than that, video works similar to other Pi cameras, and it tops out at 1080p
at 30 frames per second.
I tried 4K and some other higher resolutions, but it kept giving me a 'failed to output streaming'
warning.
The camera module on the Hawk-Eye supports higher frame rates and resolutions, but no
current Pi can take advantage.
I also used some of Arducam's custom driver features to test things like continuous autofocus
and digital zoom, but both of those features need a bit more time to come out of beta.
Continuous autofocus worked... but I have no clue what gets it to trigger a refocus.
You can use a "keypress" option to manually refocus, but I hope the continuous autofocus
algorithm can get a little better.
And digital zoom also worked, but the interface in the Hawk-Eye driver is a little tricky.
You use W and S to zoom in and out, the I, J, K, and L keys to move up, left, down, and
right, and M goes straight to 10x zoom.
This feature is sometimes called 'ePTZ', because you could have a camera set up over a wide
area, and 'digitally' zoom in and track a subject.
But it's never going to be as smooth or sharp as true PTZ.
It's still a neat trick, though, and I can imagine a few cases where some good custom
software could put it to use.
So, overall, what do I think about this camera?
Well, the Kickstarter price of $36 is a steal for a camera module this good.
The software's still half-baked, and many of the same gripes I had about the 16 megapixel
camera apply here,
and you can check out my video on that camera for a comparison with the Pi HQ camera, too.
The final retail price, though, looks like it'll be around $50, just out of my no-brainer range.
For some projects, it's perfect.
For others, you might consider the HQ camera and a good lens instead, unless you really
need that extra resolution.
I think a lot of people have a dream of building a pocketable point-and-shoot camera with this.
I mean, you can...but the software really holds this thing back.
Autofocus isn't predictable, exposure and color can be way off, and especially for video,
the Pi just doesn't have the power to make a compelling alternative to a cheap point-and-shoot.
But this camera is great for use cases where the Pi Camera already shines, like robot vision,
surveillance, and things like that.
It really depends on if you need that extra resolution and autofocus.
Until next time, I'm Jeff Geerling.