Version 0.19 - April 2007

New stuff:

-Now with non-blocking callback functionality

-Ability to choose BGR or RGB for all you openCV heads

-Stop and restart devices

-New video formats supported

-Finds nearest matching size

-Much much cleaner - trust me you want to use this one!

Includes:

-source code

-basic demo project for Visual Studio / C++

-static compiled lib for Visual Studio / C++ and project

-openGL demo app for codewarrior

-static compiled lib for codewarrior and project

NOTE: The API has changed slightly so please read videoInput.h for correct usage!! :)

VISUAL STUDIO

This release has been tested with Visual Studio 2005 express - but it should work fine with the full version too!

You need to have the windows SDK installed - which is pretty normal. Please read the visual studio notes! It will make life easier. To get the windows sdk working in VS 2005 express - you have to jump through these hoops!

http://msdn.microsoft.com/vstudio/express/visualc/usingpsdk/

DEMO APPS

The CW demo app included is a simple openGL app that creates a window and grabs video from a capture device to a texture.

The Visual Studio demo app is a bit more basic but shows how to use videoInput in your project

Use the CW demo app to check if you camera is connecting okay.

Myron is the cross-platform, cross-language, open source, video capture and computer vision plugin. One core C++ object gets cross-compiled as a handful of high level language "wrapper" libraries. The wrapper for Java and Processing is called JMyron. The wrapper for Macromedia Director is called WebCamXtra. The aim of the project is to keep computer vision free and easy for the new media education and arts community.

Version 0025 Released.

getForcedWidth() + getForcedHeight() added to help PC users with scrambled video signals. I hope this solution is temporary. imageCopy() added to cut out high level memory allocation. Just pass your image object and Myron will fill it with pixels.

Version 0024 Released.

- PC Users, Say goodbye to Quicktime and WinVDig dependencies! Say hello to blazing fast frame rates.

- The limited dimensions bug should be fixed. Go wild with the larger resolutions and let us know.



Look what people are doing!



08/06 - Andrew Senior presents a workshop on "Computer Vision for Artists" at San Jose 01 / ISEA

06/05 - Shadow Monsters by Phil Worthington at the Royal College of Art

11/04 - Interactive Installation and Physical Computing - School of Creative Media, City University of Hong Kong

11/04 - Maurizio Piraccini creates Banabi, VR for children.

08/04 - Stephen Boyd uses Myron with Processing for installation at the Eastern Front Gallery in Toronto.

08/04 - (in)security camera by benjamin chang, silvia ruzanka and dmitry strakovsky

05/04 - Mixed Reality Platforms, by MediaLab Arts (University of Plymouth) and Dartington College of Art students.

05/04 - Used in Froggies by Josh Nimoy

06/04 - Used by Jinsil Seo and Eli Toyster in their MFA thesis projects in School of Visual Arts (SVA)

03/04 - Used by Rich Streitmatter-Tran in Body Frame/Video Frame, his first solo exhibition at L'ESpace in Hanoi, Vietnam

03/04 - Interaxity , a new project by Jan and Leiven of MnM in Gent, Belgium

05/03 - Jewish Politics, art piece by G.O.M. and Vaaler in Brussels, Belgium

03/03 - Archaeology Technologies Lab at NDSU - diabetes education game centered on Native American competitive powwow dancing

01/03 - Integrated into course material for UCLA Design Advanced Interactive Media 157B, taught by Jennifer Steinkamp

11/02 - Used as the official computer vision systems in student and researcher projects at the UCLA Creative Media Lab

09/02 - Catherine Herdlick - for 2003 Parsons MFADT thesis, Games for the Projected Playground .

08/02 - installations by SetPixel

06/02 - Jason Bader's MFA Thesis, Intersection (t) at UCLA Design | Media Arts

03/02 - UCLA Hypermedia Studio's Interactive Multimedia course - premiered as motion tracking for Nimoy's Garden of Lovers



Send yours!

Elphel, Inc.

CodeVis VidCapture (v0.30)

Table of Contents

• Overview
• Including VidCapture in a Project
• Using VidCapture Library
• Using VidCapDLL.dll
• VidCapture History
• Future Directions...
• Credits
• License Agreement
• Source Documentation (generated with doxygen)
  • Class Hierarchy
  • Alphabetical List
  • Compound List
  • File List
  • Compound Members
  • File Members
• Downloads and Support
  • Download latest CodeVis VidCapture library
  • VidCapture's SourceForge Page
  • Go to the CodeVis Public Forums
  • Go to CodeVis.

^Top

Overview

VidCapture provides a simple interface to capture images from web cameras or other supported video capture devices. All you have to do is initialize it, choose a device, and start capturing - no confusing filter graphs, input pins, or IUnknowns to deal with. VidCapture also returns the images in an easy to use but lightweight class so you can process them efficiently.

It is geared towards computer vision and image processing applications. As such, it does not directly provide support for previewing, capturing the video as an AVI, streaming the video to a VHS recorder while adding subtitles, or any of the multitude of other things people might want to do with video capture that make DirectShow so much fun to work with.

VidCapture just gives you the image data in the format you want as quickly and as painlessly as possible.

VidCapture may be used in commercial and non-commercial programs provided that you read and abide by the license agreement found at the end of this documentation.

If you need support for VidCapture, please first check the documentation, then check the project page on SourceForge to see if any information is available in the forums or documentation there. There may also be information available on the CodeVis Public Forums. If you can't find a solution in the above places, feel free to email me. If you'd like VidCapture integrated into an existing system or need any sort of vision system designed and built, I may be available for contracting or hire.

For the latest released version of VidCapture, click here. For the latest development version, you can use CVS to grab it directly from SourceForge. For help grabbing the source from CVS, click here.

Features at a glance

^Top

Including VidCapture in a Project

Originally (version 0.1), VidCapture was distributed as a set of C++ files that you added to your project. You can still do that - just grab the files from the ./Source/VidCapture directory from the install and you're ready to go.

Now, however, the recommend method for C++ programmers is to use the static library included with the install - VidCapLib.lib. This will give you the most control over the video capture library without having to recompile all the time.

For other languages, there is now a .DLL available (VidCapDll.dll) that you can use that has a C-style interface. The symbols in the DLL are undecorated and it uses Pascal (standard Windows API) calling conventions, so it should be useable from just about any serious language available on Windows. Instructions for using the DLL library are further down the page.

If you're using the files directly or compiling the static lib, you may define CVRES_VIDCAP_OFFSET to offset all of the result codes if you wish to use it alongside a similar error system without collisions. See CVRes.h for details. HOWEVER... If you're using the DLL, I'd recommend against this - if you do offset the error codes, you can not use future default releases of the DLL and your program may conflict with others using the VidCapDLL.

VidCapture is setup so that documentation can automatically be generated. To generate the documentation from the source, you'll need doxygen installed. Open a command prompt and go to the ./Project directory of the VidCapture install, then run:

doxygen Doxyfile.cfg

The output is placed in the ./Build/Docs/html folder.

Including the C++ Static Library...

This overview details using the static library (VidCapLib.lib) in a C++ project. If you want to use the .DLL, go here.

DirectX SDK

First, you'll need the latest DirectX SDK installed in order to compile. I've been using DirectX 9 for development. Make sure your #include directories are set up to let the SDK take precedent over any older versions you may have.

Multithreaded Runtime

You will need to use multithreaded runtime libraries when compiling.

In Visual Studio 6.0:

1. Go to Project->Settings on the menu bar.
2. Make sure your project is selected under Settings For.
3. Select the C++ tab
4. Select Code Generation from the Category pull down.
5. Select Win32 Debug from the Settings For: pull down.
6. Select Debug Multithreaded for the debug runtime library.
7. Select Win32 Release from the Settings For: pull down.
8. Select Multithreaded for the release mode runtime library.

Required Link Libraries

Required link libraries:

• VidCapLib.lib ( or VidCapLib_db.lib for debugging )
• kernel32.lib
• ole32.lib
• oleaut32.lib
• Strmiids.lib
• Quartz.lib
• and whatever multithreaded C++ runtime libraries your compiler uses...
  
  (tested with Visual C++ 6.0)

Includes

All of the necessary headers for using the VidCapture are included by the VidCapture.h header file. Just add the line:

#include "VidCapture.h"

at the top of your .cpp and you should be set. You may need to add the path to the file to your preprocessor's #include directories.

^Top

Using the VidCapture Library (VidCapLib.lib)

You may want to check out the Example.cpp sample program for a simple example of how to use the VidCapture library - most of the functionality is covered in it.

Steps required to capture video

1. Acquire a CVVidCapture object by calling CVPlatform::AcquireVideoCapture().
   
   To do this, use the code:

   CVVidCapture* vidCap = CVPlatform::GetPlatform()->AcquireVideoCapture();

   You can also just instantiate a CVVidCaptureDSWin32 object, but using the platform manager will make it easier to modify later on.
   
   
   
   

2. Call CVVidCapture::Init() to initialize the video capture subsystem.
   
   
   
   
3. Call CVVidCapture::GetNumDevices() to retrieve the number of devices available. Then call CVVidCapture::GetDeviceInfo() to retrieve the information for each device.
   
   
   
   
4. Call CVVidCapture::Connect() with the desired device name.
   
   
   
   
5. Call CVVidCapture::GetNumSupportedModes() to retrieve the number of video modes that are supported on the connected device. Then call CVVidCapture::GetModeInfo() for each index value to get information about the nodes.
   
   
   
   
6. Select the desired video mode by calling SetMode().
   
   
   
   
7. Call CVVidCapture::GetPropertyInfo() with the properties from CVVidCapture::CAMERA_PROPERTY to retrieve information about the properties the camera supports such as brightness, contrast, and hue. You can also modify the properties while capturing.
   
   
   
   
8. Set any properties you want to change by calling CVVidCapture::SetProperty().
   
   
   
   
9. Start capturing video by calling CVVidCapture::StartImageCap(). You'll need to supply it with a callback to be called on each frame - see CVVidCapture::CVVIDCAP_CALLBACK for the callback definition.
   
   
   
   
10. On each callback, first check the status code passed in. If it's an error, (e.g. CVSUCCESS(status) yields a false result), then you'll probably need to notify your main thread that it's halted so you can do an orderly shutdown on the capture (e.g. call CVVidCapture::Stop() and CVVidCapture::Disconnect() ), figure out what went wrong, and try again.

    You still most certainly need to call CVVidCapture::Stop() from the main thread - NOT from the callback. Calling it from the callback will result in a deadlock!

    Usually, if you get an error here, what's happened is that the camera's USB cable got yanked (status will be CVRES_VIDCAP_CAPTURE_DEVICE_DISCONNECTED in this case). Other possibilities include low memory conditions and hardware failure.
    
    
    
    

11. Process images as desired within the callback. By default, the CVImage object that the callback receives will be released when the callback exits. However, you can call CVImage::AddRef() on the image and keep it around for later processing outside of the callback - just make sure to call CVImage::ReleaseImage() on it when you are done.
    
    
    
    
12. Stop capturing by calling CVVidCapture::Stop().
    
    
    
    
13. Disconnect the capture device by calling CVVidCapture::Disconnect().
    
    
    
    
14. Uninitialize the video capture subsystem by calling CVVidCapture::Uninit().
    
    
    
    
15. Free the CVVidCapture object.
    
    If you allocated it with CVPlatform as recommended in step 1, then call:

    CVPlatform::GetPlatform()->Release(vidCap);

    If you constructed a CVVidCaptureDSWin32 object directly, just delete it.

Some things to watch out for...

• VidCapture uses COM (Common Object Model) to talk to DirectX. The CVVidCapture::Init() function initializes COM with CoInitializeEx(0, COINIT_MULTITHREADED). If you are using apartment mode, you may want to change this. See the MSDN documentation for CoInitializeEx() for more information.
• VidCapture is currently set up to only have one thread using a specific CVVidCapture object at a time. If you want to call into an object from multiple threads, I'd suggest serializing the calls. Calls into a single CVImage object should be serialized as well. In practice, I wouldn't expect either to be a problem, which is why the classes themselves aren't serialized.
  
  
• Check the result codes! There are lots of them, and they'll probably help quite a bit if you encounter an error. The CVRES result codes are defined in CVRes.h, and result codes for the various subsystems are enumerated in CVResFile.h, CVResImage.h, and CVResVidCap.h.
  
  
• Try not to put a lot of heavy processing or other lengthy code in the callback. If you need to take a lot of time for each image, create a thread-safe queue, call CVImage::AddRef() on the images in the callback and add them to the queue. Then pull them from the queue as you are ready for them from another thread. Remember to call CVImage::ReleaseImage() on the images when you're done with them if you use this method so you don't create a huge memory leak.

  Also, you'll probably want to place a size limit on your queue if your processing is slower than the capture speed and drop frames once you've hit your limit to avoid filling up all available memory with images.

  Alternatively, you can just use CVImage::Save() to save the images to disk and load them back in for processing later at your leisure.
  
  

• Do NOT call CVVidCapture::Stop() from within a capture callback to stop the image capture - it will cause a deadlock. Instead, just return 'false' from the callback and the capture will be stopped. You still need to call CVVidCapture::Stop() from another thread (not the capture callback) to free up the resources.

Using the VidCapture DLL (VidCapDll.dll)

The VidCapture DLL has a slightly different interface, as it is written to be used from C and other non-object oriented languages.

You may want to check out the VidCapDllTest.c sample program for a simple example of how to use the VidCapture DLL - most of the functionality is covered in it.

If you're using the DLL from C or C++, you'll want to link to the VidCapDll.lib (or VidCapDll_db.lib for debugging) library in your project. This will cause the DLL to implicitly load when you run your program.

You may also load the library manually using LoadLibrary() and retrieve the address of each function from the DLL by calling GetProcAddress() if you wish. If you do this - none of the functions names are decorated, and they do NOT have a preceding underscore (_). However, while this method is preferable in some cases it is otherwise beyond the scope of this documentation.

Steps required to capture video with the DLL

1. Load the DLL. If you linked against VidCapDLL.lib, this is automatic.
   
   
   
   
2. Acquire a video capture system handle (CVVIDCAPSYSTEM) by calling CVAcquireVidCap().
   
   
   
   
3. Get the number of devices available with CVGetNumDevices(), then find the one you want by calling CVGetDeviceName(). Remember to set the nameBufLen to the full size of the name buffer for each call to CVGetDeviceName(), as when it returns it will be set to the actual length of the last name returned.
   
   
   
   
4. Connect to the desired device by calling CVDevConnect() with the device name.
   
   
   
   
5. Retrieve parameters for any properties you may wish to modify with CVDevGetProperty(), and set them with CVDevSetProperty(). Note that this may also be done during video capture.
   
   
   
   
6. Get the number of available modes with CVDevGetNumModes(), then retrieve information about each mode by calling CVDevGetModeInfo().
   
   
   
   
7. Begin a grab by calling CVDevStartCap() with the desired mode index. Keep the capture handle it returns! This will begin a capture on a seperate thread - your callback will be called each time an image becomes available.
   
   
   
   
8. Process the images in your callback as it is called for each frame (see CVIMAGESTRUCT). The CVIMAGESTRUCT structures and their associated image data are ONLY valid during the callback. If you need to perform any processing that is too slow to place in the callback, you MUST copy the data out. Unlike the C++ VidCapLib, the DLL does not currently offer reference counting on images.
   
   
   
   
9. During the grab, you may prematurely terminate the capture from the callback by returning FALSE. However, you'll still need to call CVDevStopCap() to clean up.
   
   
   
   
10. Call CVDevStopCap() when you're finished grabbing images. This halts the capture if it is still going, then cleans up any memory or objects used by the capture.
    
    
    
    
11. Disconnect from the connected device by calling CVDevDisconnect().
    
    
    
    
12. Free the video capture system handle with CVReleaseVidCap().
    
    
    
    

Some things to watch out for...

• VidCapture is currently set up to only have one thread using a specific CVVIDCAPSYSTEM handle at a time. If you want to call into an object from multiple threads, I'd suggest serializing the calls.
  
  
• Check the result codes! There are lots of them, and they'll probably help quite a bit if you encounter an error. The CVRES result codes are defined in CVRes.h, and result codes for the various subsystems are enumerated in CVResFile.h, CVResImage.h, CVResVidCap.h, and CVResDll.h.
  
  
• Try not to put a lot of heavy processing or other lengthy code in the callback. If you need to take a lot of time for each image, copy the data out of the CVIMAGESTRUCT (including making a copy of the pixel data!) and queue it for processing.

  Alternatively, you can just use CVSaveImage()to save the images to disk and load them back in for processing later at your leisure.
  
  

• Do NOT call CVDevStopCap() from within a capture callback to stop the image capture - it will cause a deadlock. Instead, just return 'FALSE' from the callback and the capture will be stopped. You still need to call CVDevStopCap() from another thread (not the capture callback) to free up the resources.

VidCapture History

Version 0.30 (3/01/04)

• Added support for additional input video formats (YUV, I420, etc.)
• Changed enumeration/allocation of devices to allow use of multiple identical devices.
• Added framerate estimation to mode information
• Fixed disconnection bug that could cause a failure on reconnect.
• Added a GUI test project.

Version 0.21 (2/08/04)

No code changes, but now hosted on SourceForge! http://sourceforge.net/projects/vidcapture/

Version 0.21 (1/30/04)

• Fixed crash that could occur if no devices were attached.
  
  Thanks to John Janecek for finding it!
• Added this history to documentation.

Version 0.20 (1/26/04)

• Added VidCapDll and VidCapDllTest projects for C-style DLL
• Changed the VidCapture project to VidCapLib and built as static libary
• Implemented previously defined but unused calls: CVVidCapture::IsConnected(), CVVidCapture::IsStarted, and CVVidCapture::IsInitialized())
• Added VidCapDll documentation

Version 0.10

• Initial Release of C++ code

Future Directions...

I can't (and won't) make any promises about any future upgrades, support, or anything else regarding VidCapture. However, there are some directions I'm currently hoping to take it.

WARNING: In future versions the interface may change dramatically.

As of version 0.2, VidCapture also includes a .DLL version with a C-style interface. So at least one of the wishlist features is done :)

I'm still hoping to make it available as an ActiveX control and possibly as a .NET control as well - it all depends on my 'free' time.

At a later date, I hope to make a more complete CVImage library with image processing support similar to the ones I wrote for the 3D Scanner project. In fact, a large part of the reason I wrote VidCapture was to replace the old code used there. I also plan to make the library multiplatform, supporting at least Mac OSX and Linux. For now, if you want to do image processing using the images (beyond just capturing them) you might want to take a look at the CVImage::GetMaxPixel() function to see how it templates and handles the image processing generically while supporting the offsets and widths of sub images.

If you have any comments, suggestions, or want to lend a hand in the development, please email me at mike@codevis.com.

^Top

Credits

Many thanks to Blair MacIntyre of Georgia Tech for providing equipment and helpful suggestions!

I want to thank Dimitri van Heesch for writing an excellent documentation tool called doxygen. It is what has made the documentation you are reading possible, and I couldn't recommend it more highly for documenting new projects.

For installation of VidCapture, I'm using NullSoft's Scriptable Install System (NSIS).

The reference material used for developing VidCapture came mostly from MSDN and Microsoft's DirectShow Documentation.

Programming DirectShow for Digital Video and Television by Mark D. Pesce was also very helpful on a lot of the basic concepts for interfacing with DirectShow.

CodeVis VidCapture was written by Michael Ellison, mike@codevis.com.

^Top

License Agreement

Industrial video           

3 CCD colour cameras

Reference technical notes
Introduction to CCD cameras

•  Sentech cameras  •  Hitachi cameras  •  Sony cameras  •  Pulnix cameras  •  JVC cameras  •  TVI cameras  •

•  B/W industr.video  •  B/W progress.scan  •  Colour  • 3 CCD colour •  Colour progr.scan Sony  •

All cameras are supplied without lens, unless otherwise indicated

NTSC standard cameras available on request

DXC-C33P
1/3" 3 CCD colour imager with Exwave Had technology. High performance 3 CCD remote head camera with IEEE 1394 interface. Ultra small sized and lightweight 3 CCD camera head. User-friendly camera controlo unit (CCU). 10 bit DSP signal processor with extended features. Residual Pixel Noise (RPN) compensation. C mount. IEEE 1394 digital output, DV PAL format. Compatible with DSR seies digital recorders. 2 frame memory. Foot switch capability. Automatically adjust contrast corresponding to the brightness signal level of the entire image (DynaLatitude™). Clear images can be captured even if both bright and dark areas exist within an image. Gen-lock capability (VBS, Hd/Vd). Strobe function, hyper gain, WEN, Hd/Vd output, RGB sync. Medical safety standard  EN-60601-1. Remote control unit connecting capability. RS-232C interface. Horizontal resolution: 850 TV lines. S/N ratio: 62 dB (PAL).
Pick-up device	1/3" interline transfer CCD
Effective pixels	752(H) x 582(V)
Sensing area	4.8(H) x 3.6(V)mm
Scanning system	PAL 2:1 interlaced ,  625 lines (NTSC on request)
Horizontal frequency	15625 kHz
Vertical frequency	50 Hz
Sync system	internal/external (VBS or Hd/Vd)
Phase control	H/SC
Horizontal resolution	850 TV lines
Lens mount	C mount
Sensitivity	f8.0 at 2000 lux (3200°K)
Minimum illumination	4 lux (F2, gain:Hyper)
S/N ratio	61 dB (typical)
Gain	STEP/AGC/HYPER selectable STEP: 0 to 24 dB by 1 dB step AGC: 0 to 24 dB (limit value: 6dB, 12 dB, 18 dB, 24 dB selectable)
Electronic shutter	8.0 to 1/100.000 sec
Lens	manual iris
Automatic exposure area	multi/large/medium/spot/slit selectable
Automatic exposure level	variable
Automatic exposure speed	fast/medium/slow selectable
Automatic exposure detect	average/peak selectable
Contrast effect	manual/DynaLatitude/DCC+ selectable
Knee point	high/ normal/low selectable contrast effect: manual
Black stretch	variable (contrast effect : manual)
Gamma	ON/OFF (variable at ON)
Pedestal	master and R/B manual adjustable
Black balance	ABB
White balance	AWB/ATW normal/ATW wide/manual/3200 °K/5600°K selectable  AWB oR ATW paint manual R/B gain
ATW area	normal/manual selectable
ATW speed	fast/normal/slow selectable
Detail level	all/target/off (variable at all or target)
Detail frequency	high/medium/low selectable
Linear matrix	all/target/off
Linear matrix mode	standard/R enhance/G enhance/B enhance/manual
Partial enhance	All/In/Out selectable
CCD integration mode	Field/Frame selectable
Shading compensation	Off/On (manual control)
Trigger polarity	positive edge trigger/negative edge trigger selectable
Baud rate	19200/9600/4800/2400/1200 selectable
Sync	RGB/G/Off selectable
Strobe	slave
User file	A/B switchable (two pattern memories)
Scene file	standard/microscope/full auto/strobe/file A or B
Output signal	I.LINK: IEEE 1394 based VBS: 1.0 Vp-p 75 Ω sync negative RGB: 0.7Vp-p, 75Ω, sync switchable sync: 2 Vp-p 75Ω Y: 1.0 Vp-p 75Ω C: PAL 0.3 Vp-p 75Ω, without sync
Operating temperature	-5 to +45°C
Storage temperature	-20 to + 60°C
Power supply	100 to 240Vac, 50/60 Hz
Power consumption	18W max
Dimensions (W x H x D)	head: 32 x 38 x 40 mm dimensional drawing CCU: 200 x 88 x 242mm
Weight	head: 48g CCU: 2.5 kg
Control unit	CCU front panel
Connectors	DV Out:  6 pin jack RGB/SYNC; 9 pin D-sub Video Out:  BNC S-Video: 4 pin mini DIN FS/TRIG In: stereo mini jack Remote: 8 pin mini jack AC inlet Camera 20 pin
Pin configuration	pin configuration
Rear panel	remote head and CCU rear panel

DXC-390P
1/3" 3 CCD colour imager with Exwave Had technology. C mount. Strobe trigger function: realises full vertical resolution of fast moving objects. Full control of functions accessible from the side panel or through the optional RM-C590 remote control unit. Colour shading compensation and flange back adjustment. Automatically adjust contrast corresponding to the brightness signal level of the entire image (DynaLatitude™). Clear images can be captured even if both bright and dark areas exist within an image. Wide selection of Automatic Exposure (AE) modes: user defined light metering area, selectable AE speed, wide range. Hyper gain(+30 dB). Extended genlock (VBS genlock and Hd/Vd): allows syncronization with frame grabber boards. Scene files and user files: enables the user to set two custom parameters in the menu for constant recall. RS-232C interface. S/N ratio: 61 dB.
Pick-up device	1/3" interline transfer CCD
Effective pixels	752(H) x 582(V)
Sensing area	4.8(H) x 3.6(V)mm
Scanning system	PAL 2:1 interlaced ,  625 lines (NTSC on request)
Horizontal frequency	15625 kHz
Vertical frequency	50 Hz
Sync system	internal/external (VBS or Hd/Vd)
Phase control	H/SC
Horizontal resolution	800 TV lines
Lens mount	C mount
Sensitivity	f8.0 at 2000 lux
Minimum illumination	4 lux (F2, gain:Hyper)
S/N ratio	61 dB (typical)
Gain	STEP/AGC/HYPER selectable
Electronic shutter	OFF/STEP/Variable/CCD Iris selectable
Lens	Remote (Auto or Manual)/ Video selectable
Automatic exposure area	multi/large/medium/spot/slit/manual selectable
Automatic exposure level	variable
Automatic exposure speed	fast/medium/slow selectable
Automatic exposure detect	average/peak selectable
Contrast effect	manual/DynaLatitude/DCC+ selectable
Knee point	high/ normal/low selectable contrast effect: manual
Black stretch	variable (contrast effect : manual)
Gamma	ON/OFF (variable at ON)
Pedestal	master and R/B Manual adjustable
Black balance	ABB
White balance	AWB/ATW normal/ATW wide/manual/3200 °K/5600°K selectable  AWB oR ATW paint manual R/B gain
ATW area	normal/manual selectable
ATW speed	fast/normal/slow selectable
Detail level	On/Off (variable at On)
Detail frequency	high/medium/low selectable
Linear matrix	On/Off
Linear matrix mode	standard/R enhance/G enhance/B enhance/manual
Partial enhance	All/In/Out selectable
CCD integration mode	Field/Frame selectable
Shading compensation	Off/On (manual control)
Trigger polarity	positive edge trigger/negative edge trigger selectable
Baud rate	19200/9600/4800/2400/1200 selectable
Sync	RGB/G/Off selectable
Strobe	On/Off
User file	A/B switchable (two pattern memories)
Scene file	standard/microscope/full auto/strobe/file A or B
Output signal	VBS/ RGB/Y/C
Operating temperature	-5 to +45°C
Storage temperature	-20 to + 60°C
Power supply	10.5 to 15Vdc
Power consumption	approx 7.5W
Dimensions (W x H x D)	56 x 50 x 128 mm (excluding projecting parts) dimensional drawing
Weight	approx 370g
Connectors	Lens:  6 pin RGB/SYNC; 9 pin D-sub DC IN/VBS: 12 pin Video Out:  BNC Trigger In: BNC Remote: 8 pin mini DIN
Pin configuration	pin configuration
Supplied accessories	lens cap , tripod adapter, operation manual, panel sheet for RM-C390
Optional accessories	lens , remote control unit, camera adapter, microscope adapter, microscope coupler, camera cable
Rear panel

DXC-990P
1/2" 3-CCD colour imager with Exwave Had technology. Superior picture quality. Bayonet mount. 10 bit DSP signal processor with extended features. Automatically adjust contrast corresponding to the brightness signal level of the entire image (DynaLatitude™). Clear images can be captured even if both bright and dark areas exist within an image. Residual Pixel Noise (RPN) compensation. Scene File and User File. Colour shading compensation. Wide selection of Automatic Exposure (AE) modes: user defined light metering area, selectable AE speed, wide range. Abundant electronic shutter function. Versatile white balance. Genlock capability (VBS, Hd/Vd). Strobe function, hyper gain, WEN, Hd/Vd output, RGB sync. Flicker canceller. RS-232C interface. Medical approval EN-60601-1. On screen menu. Horizontal resolution: 850 TV lines. S/N ratio: 62 dB.
Pick-up device	1/2" Exwave Had interline transfer CCD
Effective pixels	752(H) x 582(V)
Sensing area	6.4(H) x 4.8(V)mm
Scanning system	PAL 2:1 interlaced ,  625 lines (NTSC on request)
Horizontal frequency	15625 kHz
Vertical frequency	50 Hz
Sync system	internal/external (VBS or Hd/Vd)
Horizontal resolution	850 TV lines
Sensitivity	f11 at 2000 lux
Minimum illumination	1 lux (F1.4, gain:Hyper)
S/N ratio	62 dB
Gain	STEP/AGC (0-24 dB)/HYPER selectable
Shutter speed	0.5 - 1/100.000 sec
Lens mount	bayonet mount
Automatic exposure area	multi/large/medium/spot/slit/manual selectable
Automatic exposure level	variable
Automatic exposure speed	fast/medium/slow selectable
Automatic exposure detect	average/peak selectable
Contrast effect	manual/DynaLatitude/DCC+ selectable
Knee point	high/ normal/low selectable
Black stretch	variable
Gamma	ON/OFF
Pedestal	master and R/B Manual adjustable
Black balance	ABB
White balance	AWB/ATW normal/ATW wide/manual/3200 °K/5600°K selectable  AWB oR ATW paint manual R/B gain
ATW area	normal/manual selectable
ATW speed	fast/normal/slow selectable
Detail level	On/Off (variable at On)
Detail frequency	high/medium/low selectable
Linear matrix	On/Off
Linear matrix mode	standard/R enhance/G enhance/B enhance/manual
Partial enhance	All/In/Out selectable
CCD integration mode	Field/Frame selectable
Shading compensation	Off/On (manual control)
Trigger polarity	positive edge trigger/negative edge trigger selectable
Baud rate	19200/9600/4800/2400/1200 selectable
Sync	RGB/G/Off selectable
Trigger	On/Off
User file	A/B switchable
Scene file	standard/microscope/full auto/strobe/file A or B
Output signal	VBS,  RGB/SYNC, Y/C, Y/R-Y/B-Y
Serial data	RS-232C
Operating temperature	-5 to +45°C
Storage temperature	-20 to + 60°C
Power supply	10.5 to 15Vdc
Power consumption	approx 7.5W
Dimensions (W x H x D)	70 x 72 x 123.5 mm dimensional drawing
Weight	630g
Connectors	RGB/SYNC; 9 pin D-sub DC IN/VBS: 12 pin Video Out:  BNC Trigger In: BNC Remote: 8 pin mini DIN Genlock In: BNC Lens:  6 pin
Pin configuration	pin configuration
Supplied accessories	lens cap , stopper mount, operation manual, panel sheet for RM-C390
Optional accessories	lens , lens mount adapter,  remote control unit, camera adapter, microscope adapter, microscope coupler, camera cable
Rear panel	rear panel drawing

Cliccate sulle  parole evidenziate in giallo per vedere collegamenti a figure o ad altre pagine.

Click on words highlighted in yellow to view links.



Cliccate sulle immagini miniaturizzate per vederle ingrandite.

Click on thumbnails to view enlarged images.

© Rapitron s.r.l.  -  1998-2006

Via Washington 59  -  20146 Milano ITALIA      Tel.: +39 02 659.82.82   Fax: +39 02 65.45.25

P.IVA/VAT No:  IT 04498890153



Queste pagine sono disegnate e aggiornate da Rapitron s.r.l.

I marchi citati sono di proprietà dei rispettivi proprietari.

Le specifiche dei prodotti sono esposte così come dichiarate dai singoli fabbricanti e sono soggette a cambiamenti senza preavviso .

Sito ospitato da Range s.a.s.- Genova

These pages are designed and updated esclusively by Rapitron s.r.l.

All trademarks are property of the respective owners.

All products specifications are shown as declared by manufacturers and are  subject to change without prior notice.

This Web Site is hosted by Range s.a.s. - Genova