Skip to content

Capturing an Image from a WIA-compatible Digital Camera

We’ve had a research project requiring a fair amount of image acquisition and processing, requiring  higher resolutions than most industrial cameras can offer. As a result, we’ve tried at least three different digital cameras (Canon PowerShot S3is, Nikon D40, and Canon PowerShot SD780is). Each of them has their own advantages and disadvantages:

  • S3is advantages:  good control with Breezesys’ PSRemote, including a pretty complete DLL that we can call from our LabVIEW code. Disadvantages: larger aperture sizes reduce the depth of field, and PSRemote can’t toggle macro and super-macro modes.
  • D40 advantages: complete manual control when needed, huge range of apertures including ones that allow for good depth of field, easy to grab pictures in PTP mode from Windows Explorer. Disadvantages: Breezesys’ NKRemote for Nikon doesn’t support the D40.
  • SD780is advantages: ridiculously high resolution (12MP) in a tiny camera. Disadvantages: no PSRemote support, and little manual control of settings.

So it came down to needing LabVIEW to acquire images from whatever camera automatically. We had gotten it working with PSRemote some time back for a different class of pictures, but the ones we needed now went beyond PSRemote’s and the S3is’ ability to focus in on close distances. And the SD780is was out entirely. So that left the Nikon.

Previous testing with the Nikon generally consisted of putting it in PTP mode, opening up Windows Explorer, hitting the “Take a new picture” link, and then copying over the newest image to the local drive. Great, except for the clicking and dragging. The obvious solution would be to automate the process via Win32 COM programming. After a few hours with the Python docs and MSDN, a workable Python script was born:

import win32com.client, time, os

WIA_COM = "WIA.CommonDialog"




WIA_IMG_FORMAT_PNG = "{B96B3CAF-0728-11D3-9D7B-0000F81EF32E}"


def acquire_image_wia():
    wia = win32com.client.Dispatch(WIA_COM) # wia is a CommonDialog object
    dev = wia.ShowSelectDevice()
    for command in dev.Commands:
        if command.CommandID==WIA_COMMAND_TAKE_PICTURE:

    for item in dev.Items:
        if i==dev.Items.Count:

    fname = 'wia-test.jpg'
    if os.path.exists(fname):


Things I like about this:

  • snaps the camera shutter, grabs the last image from the card, and stashes it on the local drive, no questions asked. Since I’ll probably set the camera settings once and leave it on manual focus, this is all I needed.
  • easily converted into an executable with py2exe.
  • roughly 3.2 seconds to acquire and save the image, with around 2 seconds of that spent on the ExecuteCommand() line with a 0.25 second shutter speed.

Things I don’t like about this:

  • Windows COM programming makes my brain hurt.
  • To make things entirely hands-off, I had to disable my Webcam. I’m sure there’s a way to make WIA connect to a named device, but ShowSelectDevice() was all I found ready documentation for. With multiple cameras available, it always asked which one I wanted to acquire from. With only one camera available, it just went on and snapped the picture.
  • I couldn’t find a good way of jumping to the end of the list of items stored on the camera. I can count them, I can iterate over them, but I’m having to iterate over each element until I get to the last one, and then I can transfer it over.

Someone may have a better solution to the last two problems, but this should get people started.

Update — Leaner, meaner code to grab the last image off one specified camera — thanks to Janzert in the comments below:

import win32com.client, time, os

WIA_IMG_FORMAT_PNG = "{B96B3CAF-0728-11D3-9D7B-0000F81EF32E}"

def acquire_image_wia():
    # Find the camera
    for info in devman.DeviceInfos:
        for prop in info.Properties:
            if prop.Name=="Name" and prop.Value==MY_CAMERA:
                dev = info.Connect()

    # Snap picture
    # Transfer last image (doesn't actually use PNG format, but this
    # still is valid syntax).
    # Save into file
    fname = 'wia-test.jpg'
    if os.path.exists(fname):


{ 6 } Comments

  1. Janzert | September 9, 2009 at 1:44 pm | Permalink

    Thanks, I just started a project to automate some functions of a scanner which also uses WIA and this was quite helpful. Here is some stuff that might help solve the last two things you don’t like currently.

    Instead of using WIA.CommonDialog and the select device dialog, use WIA.DeviceManager and then DeviceInfos to find the device you want. Something like this:

    devman = win32com.client.Dispatch(“WIA.DeviceManager”)
    for info in devman.DeviceInfos:
    for prop in info.Properties:
    if prop.Name == “Name” and prop.Value == “Camera I Want”:
    device = info.Connect()

    Also instead of iterating through Items (or DeviceInfos or Properties) they can also be accessed directly by index (e.g. dev.Items[1] or dev.Items[dev.Items.Count]). The one thing to watch out for though is that Items and DeviceInfos seem to use a 1 based indexing and Properties use a 0(zero) based index at least for my scanner.

  2. Nathan Soliz | September 15, 2009 at 6:07 pm | Permalink

    Does the Nikon D40 allow you to plug the camera in and use the WIA-compatible Digital Camera? Which when tethered to the PC allow me to use the WIA window to take photo?

    Thanks for any information.

  3. Mike Renfro | September 16, 2009 at 8:07 am | Permalink

    Any camera that has a “Take a new picture” link on its Explorer window should work with this. And yes, we use a D40.

  4. ForestWander | August 26, 2010 at 8:17 am | Permalink

    Just to help understand. Would this code allow me to use my Canon G9 (for instance) to control the camera from my laptop and acquire an image in real time?

  5. Mike Renfro | September 25, 2010 at 9:27 am | Permalink

    (Sorry for the delay, just went back through the pending comments folder.)

    As long as the camera shows up in the “Scanners and Cameras” part of the My Computer folder, and has a “Take a picture” or similar menu item on the left pane, then you can at least take snaps from it. You may have to put the camera into PTP mode, but googling “g9 ptp” indicates that it’s supported. Check your manual.

    I won’t claim full control of all the camera features, but if you set all the exposures, apertures, and such ahead of time, you can definitely control the snapping of the shutter. The manual (or a forum for the g9) would say what else can be controlled remotely.

  6. JJS | June 25, 2011 at 10:52 am | Permalink

    Dear Mike,

    I tried your leaner version of your code with Python2.7 and the Win32 extensions for Python. I am using Windows XP, SP3. I get the following error when trying to compile:
    Traceback (most recent call last):
    File “”, line 26, in
    File “”, line 8, in acquire_image_wia
    File “C:\Python27\lib\site-packages\win32com\client\”, line 95, in Dispatch
    dispatch, userName = dynamic._GetGoodDispatchAndUserName(dispatch,userName,clsctx)
    File “C:\Python27\lib\site-packages\win32com\client\”, line 108, in _GetGoodDispatchAndUserName
    return (_GetGoodDispatch(IDispatch, clsctx), userName)
    File “C:\Python27\lib\site-packages\win32com\client\”, line 85, in _GetGoodDispatch
    IDispatch = pythoncom.CoCreateInstance(IDispatch, None, clsctx, pythoncom.IID_IDispatch)
    pywintypes.com_error: (-2147221005, ‘Invalid class string’, None, None)


    Please advise if you can. Thanks kindly.

Post a Comment

Your email is never published nor shared. Required fields are marked *