Monday, May 09, 2016 6:41:11 PM
The CVL 8.0 Release Notes contain the following sections:
This section lists open bugs in this release.
This section describes open issues concerning image acquisition in CVL 8.0.
The cfRGBPack() function does not copy the transform correctly if the destination pel buffer is preallocated and not the same size as the source pel buffer.
Do either of the following:
Copy the transform manually after calling cfRGBPack(), or
Ensure the destination pel buffer you pass to cfRGBPack() is unbound.
Calling the ccLightProp::lightsOff() function has no effect. You can work around this bug using the following code:
fifo->properties().lightPower(0.0); fifo->properties().auxLightPower(0.0); fifo->prepare(0.0);
This section describes open issues concerning MVS-8500 acquisition in CVL 8.0.
If a video signal containing color information (like NTSC or PAL) is supplied to the 8500 frame grabber, ExtSync acquisition can fail depending upon the type of scene the camera is looking at. The problem is due to the color burst and the color information that is encoded as a carrier with a frequency of ~3.58 MHz(NTSC) and 4.43MHz(PAL) as part of the RS170 or CCIR signal. This color information can interfere with the 8500 detecting HSync pulses correctly and causes incorrect lock.
The workaround is to remove the color information from the video signal before feeding it into the 8500. One easy way to do this is to get a converter from composite video to S-Video (Y/C). Once converted, the Y component does not have any color information.
Assertions can occur when using an external sync source, if the camera cable is disconnected while acquisitions are underway.
Under certain specific system configurations, the MVS-8500e frame grabber may experience occasional isAbormal() acquisition failures. These failures, which occur in approximately 1 out of 250,000 to 1,000,000 acquisitions, occur when all of the following conditions are met:
The application is running on a quad-core CPU with all cores enabled.
The application is using manual (software) triggering.
The application queues multiple acquisition starts (calls ccAcqFifo:start() multiple times before calling ccAcqFifo::completeAcq()).
The application asynchronously acquires images from 3 or 4 cameras simultaneously (not using master-slave acquisition).
All of the cameras are high-speed cameras such as the Sony XC-HR70 or XC-HR90.
The acquisition error is transient, it affects only a single acquisition, and it is self-recovering. This error does not affect any acquisition that uses an external trigger; it only affects software-initiated acquisition that uses multiple queued starts.
You can prevent this error from happening by using any of the following workarounds:
Run your application on a single- or dual-core CPU.
If you are using a quad-core CPU, disable one core.
Do not call ccAcqFifo:start() more than once before calling ccAcqFifo::completeAcq().
Use an external trigger to acquire images.
This section describes open issues concerning MVS-8600 acquisition in CVL 8.0.
On the 8602e frame grabber, several lines of data may be dropped causing missing data with all black pixels when the acquired image size is greater than or equal to approximately 102 MB. The missing data is a continuous band of black pixels comprised of several lines.
The encoderResolution() and startAcqOnEncoderCount() functions are not supported for single-channel encoders (when useSingleChannelEncoder is true).
In order to avoid acquisition failures and corrupted images, with Automatic or FreeRun trigger model, use exposure of at least 60 microseconds for the Dalsa P2-4x08k40 camera and exposure of at least 50 microseconds when using the Atmel M4CL 6007 camera.
When the 8600 is configured for acquisition, a transient pulse can occur on the strobe output line even if strobeEnable is set to false. This transient may cause an attached strobe light to fire unexpectedly. This may occur when starting a series of acquisitions, or when the ccAcqFifo::prepare() function is called.
When using the MVS-8602e frame grabber with a Medium Line Scan Dalsa Pirhana P2-4x-8K only in Manual trigger model acquisition can suddenly stop acquiring. Other trigger models are not affected. To restart acquisition disable then re-enable triggers programmatically.
If you call ccAcqFifo::prepare(0) on a fifo using the MVS-8600 and no camera is attached, the call may take up to 60 seconds to complete.
Ensure that a camera is attached the frame grabber.
This section describes issues concerning image display.
Ellipse arcs are drawn incorrectly when the ellipse centers are far outside the display region. Using a radius value that is larger than sizeof(short) would result in this effect. This problem is caused by limitations in the Microsoft GDI graphics drawing code, and exists on all supported Windows platforms (2000, and XP).
The maximum zoom that you can use with ccDisplay::mag() is 65,536. The minimum zoom depends on the size of the image; for example, for a 640x480 image the minimum is -60. This can cause unwanted behavior when zooming using ccDisplayConsole. As displayed in the status bar at the bottom of the display console window, zooming out (using the toolbar buttons for zooming) produces magnifications of 1/2, 1/4, 1/8, 1/16, 1/32, and then 1/60, but zooming in from here produces magnifications of 1/30, 1/15, and so on.
Parenting does not work as expected when the child shape in a parent-child relationship is derived from ccUIManShape. If you drag the parent shape, only the handle of a ccUIManShape-derived child will go with its parent; the child shape itself will not move.
In general, parenting works as expected when the parent shape in a parent-child relationship is derived from ccUIManShape and the child shape is derived from ccUIPointShapeBase. However, ccUIGenAnnulus (a ccUIManShape-derived shape) is an exception and does not work appropriately as a parent.
You must ensure that the FIFO passed to ccDisplay::startLiveDisplay() is not destroyed before calling ccDisplay::stopLiveDisplay(). For example, if you create a FIFO in a function, call startLiveDisplay(fifo) passing in this FIFO, and then call stopLiveDisplay() after the function in which the FIFO was created returns, the stopLiveDisplay() method will hang and not return.
CVL does not provide an API to allow you to target a display console window to a specific monitor if the system has more than one monitor.
The ccGraphicProps::penfill() function does not work with ccEllipseAnnulusSection objects.
Setting the fill property to true for a ccUIGenAnnulus fills the entire shape, not just the annulus.
A test case was set up to run live display using the MVS-8504, a Sony DXC-390 camera, the "Sony DXC-390 640x480 IntDrv CCF" video format, and ccAcqFifoPtrh. When displayed onto an 8-bit Windows desktop, displayed images were observed to be blank.
When using this configuration, view displayed images using a 16-bit or 32-bit desktop color depth.
This section describes open issues concerning drivers in CVL 8.0.
During testing, Cognex has observed some PCs to take a relatively long time (5-6 ms) to respond to interrupts. This long latency does not cause problems with most CVL applications. However, when the acquisition rate is higher than one acquisition in every 6 ms, this prolonged delay could cause interrupts not to be serviced on time, resulting in missed acquisitions. The long latency of some PCs can also cause problems with other devices that require timely interrupt response.
The followings PCs are known to exhibit this problem:
IBM Intellistation Z Pro: model # MT-M 6221-22U (2.66 GHz Xeon single CPU)
IBM Intellistation M Pro: model # MT-M 6219-42U (3.06 GHz P4 single CPU)
This problem has implications for acquisition with a region of interest (ROI). When an image is small, the frame rate can be higher than usual, potentially causing interrupt overrun. The noted problem can therefore occur when using cameras that support ROI control and decimation with the following Cognex frame grabbers, which support ROI:
MVS-8500, which supports partial scan (with the same end result as ROI)
MVS-8600 and MVS-8600e
This section describes open issues concerning the CVL development environment in CVL 8.0.
CVL uses the newer iostream library from the std namespace; therefore, including any CVL headers also includes the new iostream headers. Using the old iostreams library, or another product (such as MatLab) that uses the old iostreams library, may result in compilation errors when a single source file attempts to include the headers for both libraries. The problem appears to stem from the Windows ios class.
This is both a compile-time problem for certain classes, and a potential run-time problem for others, because enums available in both classes have different values. If your software currently uses the old iostream library, Cognex recommends updating to the new iostream library. If your software requires the use of both the old and the new iostream libraries, Cognex recommends always including the new iostream library first.
When using stdafx.h (so every source file includes it first), you can just add lines such as the following to the top of stdafx.h:
#include <ch_cvl/defs.h> #include <fstream> #include <iostream>
The first include of defs.h is to take advantage of the pragma in defs.h, which disables the "debug symbol name too long" compiler warning (C4786). This pragma must occur before the file that generates the warning is included, or the warnings will occur. You could also use this pragma directly instead of including defs.h.
This section describes open issues concerning sample code in CVL 8.0.
The pmalign4 sample application shipped with CVL (under $VISION_ROOT\sample\cvl) crashes with a “plate.idb can’t be opened” error when run from either Windows Explorer or a Command Prompt command line with the current directory set to the location of the executable. The problem is that the relative path to the plate.idb file is not set correctly during installation.
Either build and run the sample inside Visual Studio, or move the plate.idb and plate.dxf files to the \cvlproj\ directory.
This section describes open issues concerning serial I/O in CVL 8.0.
ccSerialIO::read() blocks indefinitely until receiving at least one byte across the serial port, even if a non-infinite timeout is specified. After the serial port receives the first byte, read() works correctly from that point forward.
This section describes open issues concerning shape models in CVL 8.0.
The ccShapeModel::record() method requires the supplied pel buffer to be bound. However, it does not throw and will eventually cause the application to crash because of attempted division by 0 if an unbound pel buffer is supplied. For example, the following call will end in a crash. This is because the default-constructed 8-bit ccPelBuffer supplied as the second argument is unbound by default.
ccShapeModel::record(diagObj, ccPelBuffer<c_UInt8>(), shape,
gprops, gprops, gprops, cmT("Synthetic model"));
Always supply a bound pel buffer with non-zero width and height as the second argument to the ccShapeModel::record() method.
This section describes open issues concerning the Caliper tool in CVL 8.0.
When Caliper runs in eHighPrecision mode, it finds extra edges when the affine rectangle is set to clip the image. For example, when a projected image (corresponding to a reverse read of the original image) in the result reads 200 214 198 197 194 192 190 185 183 111 ..., the pixel value 214 causes extra edges to appear on the right side of the image when the contrast threshold is set to 5. If you change the mode to eBilinear, the projected image reads 198 198 197 196 193 191 189 184 176 107 ..., which represents the original image well.
The nature of high precision mode is to ring on edges. The workaround is to use the bilinear mode.
If you specify ccCaliperDefs::eDrawProjFilter in the drawMode argument to ccCaliperOneResult::draw(), the graphics (which show a graphical representation of the projection image and the filtered projection image) are not displayed if the projection region is clipped by the input image. To prevent this from happening, supply an input image that fully encloses the projection region.
Regardless of the projection mode, the ccCaliperResultSet::draw() method does not draw the projected image and the filtered image as specified when clipping is enabled. For example, the following code will draw only the label and the region.
clpResultSet.draw(graphList, ccCaliperDefs::eDrawLabel | ccCaliperDefs::eDrawProjFilter | ccCaliperDefs::eDrawProjectionRegion | ccCaliperDefs::eDrawStandard);
It is then not convenient to keep track of the project image.
This section describes open issues concerning the Edge tool in CVL 8.0.
Whether defaulting to deep copy or forcing shallow copy with diagFlags, it is possible to draw into the source image, magnitude image, and angle image after cfEdgeDetect() has recorded a diagnostic object, and for those modifications to show in the diagnostic viewer.
This section describes open issues concerning the Histogram tool in CVL 8.0.
The comment for the cfPelHistogram() function in the <ch_cvl/histo.h> header file inaccurately states that the function resizes and zeroes out the passed-in vector if that vector is of size 0. This function does not resize or zero a vector that has no elements.
This section describes open issues concerning the ID tool in CVL 8.0.
If you specify true for ccSymbologyParamsComposite::combineResults(), you cannot determine the subtype of the 2D component (CC-A or CC-B). Only the subtype of the linear part is returned.
This section describes open issues concerning the OCV tool in CVL 8.0.
The OCV Tool can exhibit anomalous behavior when trying to verify a char 'A' in the image with the current key set to '4' (or vice versa) and character rotational uncertainty set to greater than zero. These characters can be easily confused when rotation is allowed.
When rotational uncertainty is set, the tool usually verifies an A-4 mismatch, though with a low score, then all positions following the mismatch fail to verify. This behavior has been observed with three different fonts (Courier, Lucida Sans, Terminal) and with a range of uncertainties (5 to 45 degrees). For some uncertainties, the Courier font may verify one or two positions beyond the mismatch and then start failing. This behavior is consistent regardless of both where the mismatch occurs (whether near the beginning or end of the string) and the number of mismatches.
The OCV tool assumes that a blank character is never confusable with an actual character. So, for example, the tool never checks to see if a character that is expected to be an ‘a’ looks blank. The opposite is not true, however. The tool does check to see whether a character that you expect to be blank looks like an ‘a’ (if ‘a’ is considered confusable).
The OCV line arrangement bounding box does not include a wild card that is at the end of the line.
When a line is completely not found (that is, all characters are not found and the score is 0.0), the “Line Arrangement at Final Pose” diagnostic draws a red cross of the line arrangement pose. The cross is drawn in client coordinates.
This section describes open issues concerning PatInspect in CVL 8.0.
PatInspect boundary difference mode may incorrectly report features that lie close to the edge of the inspection region as missing or extra. This happens, for example, when the inspection region coincides with the training region, in which case all the boundary features should be of the matching type. This behavior has been observed in both CVL 5.4 backward and non-backward compatibility mode.
Make sure the rectangular inspection region provides at least five pixels of padding around the pattern you want to train.
This section describes open issues concerning PatMax in CVL 8.0.
The PatFlex algorithm ignores any nominal DOF values set in cc_PMRunParams using the nominal() setter.
To use nominal DOF values with PatFlex, enable the given DOF and set both its high and low zone values to the desired nominal value. For example, instead of:
runParams.zoneEnable(0); runParams.nominal(ccPMAlignDefs::kUniformScale, 2.0);
use
runParams.zoneEnable(ccPMAlignDefs::kUniformScale); runParams.zone(ccPMAlignDefs::kUniformScale, 2.0, 2.0);
This section describes open issues concerning the Wafer Pre-Align tool in CVL 8.0.
In NotchMax mode, the flat length computation uses wafer area, inner diameter, and outer diameter in computing the flat length, which you can query with ccWaferPreAlignResult::flatLength(). However, there may be 1, 2, or even 3 flats per wafer. This can affect the area computation, which in turn affects the inner and outer diameter computations. This can make the returned flat length inaccurate. For this reason, NotchMax mode is not supported on flat wafers.
This section lists bugs that were fixed in this release.
This section describes ID tool issues in CVL 7.2 CR10 that are fixed in CVL 8.0.
This issue has been resolved.
The only error information available from the tool is Unused Error Correction for the PDF417, Australia Post, and Postal UPU Code types. The ccIDDecodeResult::hasErrorInfo() function returns false in all other cases.
This section lists limitations you may need to be aware of. A limitation is behavior that is imposed on CVL by hardware, operating system software, product architecture, or other external constraints. Workarounds may exist for some limitations.
This section describes limitations concerning image acquisition.
The default exposure of 20 µs for all cameras is designed for strobed acquisition. If you use ambient lighting with a rapid reset camera such as the Sony XC-55, you may need to increase the exposure time to more than 1 ms.
The static video format for the Pulnix TM-6CN is instantiated with internal sync enabled, which is not correct for this camera and can produce odd images. The CCF version of the TM-6CN's video format correctly sets the sync model.
When using the static video format, set the sync property manually in your code to cfSyncExternallPLLComposite().
This section describes limitations of MVS-8500 acquisition in CVL 8.0.
For 8504 and 8501 frame grabbers, the acquisition brightness property default value is changed to 0.5. Because of this, images acquired with this release may look different than acquired with a previous release using a different default value right after creating the acquisition fifo.
The first acquisition with a Teli CSB4000 camera after starting the PC may fail. Subsequent acquisitions will succeed.
Supported Camera Link cameras must be configured a certain way for use with the MVS-8600 and CVL. Cognex provides the Camera Link Serial Communication Utility and one command set file (CLC file) for each supported camera. This utility and the use of CLC files are documented in the CVL Getting Started manual.
If you attempt to acquire images with an unconfigured camera left in its factory default condition, the consequences are as follows:
You can acquire images. That is, prepare(0.0) does not fail, and complete() does not hang.
However, exposure control does not work correctly. Images are either too bright or too dark.
In addition, the motion of moving objects cannot be frozen, which leads to blurred images of moving objects.
The MVS-8600 TTL-level trigger inputs only accept voltage swings of less than 5V . The 12V swing produced by some triggers does not trigger the MVS-8600. You can use a voltage divider circuit to reduce the output from 12V triggers to less than 5V for the TTL inputs.
This behavior is different from other Cognex frame grabbers.
Current CVL implementation for the MVS-8600 acquires the full image returned from the camera, and then returns the requested ROI set by the user by performing a software cropping operation. As a result, there is no speedup in image acquisition rates when you reduce the ROI from full size, even if the camera hardware supports faster acquisition rates with a smaller ROI.
To acquire at faster frame rates with small ROIs, change the ROI in the camera using the serial interface, and then set the CVL ROI property for the acquisition FIFO to be the same size as set in the camera settings. Note that the image is always returned starting at the top left corner. So, for example, if you set the camera for (100, 200, 400, 600) as the hardware ROI, set the CVL ROI property to be (0, 0, 400, 600).
When using the MVS-8600, the prepare() function can return true even in cases where the current video format setting does not match the attached camera. However, image acquisition under these circumstances can time out and fail. This situation means that prepare() cannot be relied on to detect the wrong camera attached for a vision processing application that is configured to expect a different camera.
The I/O cable between the MVS-8600's Hirose HR10 port and the 8600's I/O connection module (P/N 800-5885-1) must correspond to the currently loaded software I/O configuration, as described in the MVS-8600 Hardware Manual.
If you have the I/O cable for I/O configuration 1 or 2 attached to your I/O connection module, and you have strobe devices connected to the I/O module, and you change to I/O configuration 3 in software, then you have changed the strobe output lines on Hirose pins 7 and 12 into encoder input lines. In this unsupported circumstance, any state change on those lines would have undefined results for the strobe devices and for the MVS-8600.
An analogous mismatch would occur if you have the cable for I/O configuration 3 attached, and an encoder device attached to the I/O module, and you change in software to I/O configuration 1 or 2.
When changing I/O configurations in software, make sure you have the correct corresponding I/O cable attached before powering on the MVS-8600.
The frame grabber and the video firmware cannot support overlapped integration and readout on any area scan camera regardless of the video format.
It might be difficult to determine which Camera Link camera is connected to which serial communication port when using the Cognex Camera Link Serial Communication Utility to communicate with, and set up cameras. OEMs might be looking for a way to automate the setup of more than one Camera Link camera connected to one or more MVS-8600 boards in the same host PC, without knowing in advance which camera is connected to which port. The following points describe why blind advance setup is difficult.
There is no programmatic way to determine which camera is attached to a given port.
When finding Camera Link ports on the MVS-8601, it is common to detect an extra port that is not valid, called a "ghost port". In a system with two MVS-8600s, this ghost port can make it difficult to determine programmatically which Camera Link communication port goes with which board.
The most clear-cut way to configure a Camera Link camera is to configure one camera at a time, while only one camera is connected to camera port 0 of a single MVS-8600, and then save the configuration in the camera's non-volatile memory. The Cognex Camera Link Communication Utility provided with this release, along with the command set file for each camera, provide the means to configure and save the configuration for each supported camera. The Camera Link Utility is documented in this release's Getting Started manual.
Once the cameras are set up this way, they can be attached to systems containing multiple MVS-8600s without the need to reconfigure them.
Changing properties on the MVS-8600 may require from 20 to 300 milliseconds to take effect. The 300 millisecond delay is usually limited to the property changes before the first acquisition; subsequent changes typically take around 20 milliseconds.
Be aware of these acquisition limitations for the MVS-8601, MVS-8602, and MVS-8602e frame grabbers:
You cannot create an acquisition FIFO greater than the 8-bit mono video format.
64-bit operating system acquisition is not supported. The driver will install but use of the frame grabber is blocked by the software.
The use of the MVS-8602e with a 64-bit operating system is supported only if the firmware on board is version 3.56 or later. Otherwise, use of the frame grabber is blocked by the software.
This section describes limitations in displaying images.
Adding a large number of manipulable shapes to the display, or removing them from the display, one at a time in a loop can take a long time.
Call ccDisplay::disableDrawing() before adding or removing manipulable shapes, and then to call ccDisplay::enableDrawing(true) after all shapes have been added or removed.
The ccUIGenAnnulus::move() method moves a ccUIGenAnnulus to the location given by the supplied cc2Vect. This is incorrect behavior. It should adjust the position of the shape by the x- and y-values of the supplied cc2Vect.
Retrieve the position of the front child object of the UI generalized annulus with ccUIGenAnnulus::frontKid(), add the offset to the result, and then call ccUIGenAnnulus::pos(p) passing the adjusted position as an argument.
On 8-bit desktops, setting interpolated zoom to high precision mode by calling ccUITablet::interpolation(eHighPrecision) may cause colors outside the grey-scale range to be displayed.
Use a non-8-bit display and/or bilinear rather than high-precision interpolation.
If you are using Windows 2000, disable the power management feature, as described in the section Tuning System Configuration for Best Performance in the CVL User’s Guide. In particular, make sure that your system is configured to never shut off the video monitor. If the power management feature is configured to shut off the video monitor, your CVL application may have problems attempting to display graphics with live video.
The internal structure of the ellipse geometry class (ccEllipseGeom) was changed in CVL 5.4. Applications built against CVL 5.4 or later that attempt to display ccUISketch lists containing ccEllipse, ccEllipseArc, ccEllipseAnnulus, or ccEllipseAnnulusSection objects that were archived in CVL 5.3 or earlier may hang.
Static shapes are rendered differently in release and debug modes. Depending on the geometry of the shape, slight differences may occur between which pixels are rendered in the two modes. Do not rely on the exact same pixels being rendered between debug and release builds.
This section describes limitations of the CVL development environment.
Visual Studio uses a default of true for treat wchar_t as builtin type. Cognex uses Visual Studio defaults so your projects must also use treat wchar_t as builtin type == true.
This describes limitations you should be aware of when installing CVL.
When uninstalling CVL, if QuickEdit mode is enabled for command prompt windows and you click in the command prompt window that opens during uninstallation, the cursor goes into select mode and the uninstallation appears to have halted. Right click in the command prompt window to exit select mode and resume the uninstallation.
This section describes limitations of discrete I/O in CVL 8.0.
The external configuration of the universal parallel I/O card (P/N 800-5726-3) is used with the external I/O module (P/N 800-5712-2) to provide opto-isolated connection points for parallel I/O lines. When used with the MVS-8120, the polarities of output lines 4 through 7 on the external I/O module are inverted, compared to output lines 0 through 3, and compared to opto-isolated output lines on other Cognex hardware.
The CVL Class Reference correctly states that the ccOutputLine::set(true) member function sets the no-current-flowing state for opto-isolated output lines. This is true for output lines 0 through 3 on the external I/O module, and for other Cognex boards. However, for output lines 4 through 7 of the external I/O module when used with the MVS-8120, the meanings of set(true) and set(false) are reversed.
In some cases, the actual pulse signal can be shorter than the width parameter supplied to ccOutputLine::pulse(). For example, if you create a 500 ms pulse as follows:
oline.pulse(true, 0.5, false); // low-to-high transition, // 0.5 second width, non-blocking
the resulting pulse may actually be as short as 490 ms in duration.
This behavior is a known limitation of operating system timers, and affects all Cognex hardware platforms that support the pulse() feature. This problem is also known to occur more frequently when making simultaneous pulse() calls on multiple parallel output lines.
If your application requires an absolute minimum expected pulse duration, supply a width value to the ccOutputLine::pulse() function that is 1 ms longer than the actual desired pulse width. This will bump actual the pulse width to the next interval that matches the granularity of the multimedia timer.
In addition, reducing the multimedia timer period to 1 ms using the Microsoft Win32 API call timeBeginPeriod(1) can improve pulse accuracy. However, if you use this method, be aware that modifying the timer will affect overall system performance because this will result in timer interrupts needing to be serviced more frequently.
To use timeBeginPeriod(), you must include the Win32 mmsystem.h header file and the winmm.lib library in your code. In Visual C++ 6.0, the header file is located in the VC98\include directory; in Visual C++ .NET (7.0), it is in the VC7\PlatformSDK\include directory. It can also be found among the Platform SDK and DDK include files.
For example, you can add the following code to your application to adjust the system timer accuracy:
#include <windows.h> // Add this to avoid compiler errors
#include <mmsystem.h>
#pragma comment(lib, “winmm.lib”)
timeBeginPeriod(1);
// Set pulse width and perform I/O operations in CVL
timeEndPeriod(1); // Call before application ends to return
// the multimedia timer to original state
See also related notes on modifying the system timer in the Displaying Live Images section of the Displaying Images chapter of the CVL User’s Guide.
This section describes limitations and restrictions that apply to utility programs shipped with CVL 8.0.
CVL command line utilities such as Cogtool are normally run only under the direction of Cognex Technical Support. As of this release, the executable for these utilities must reside in the directory that contains the CVL-provided DLLs. This means that a utility's executable file (such as cogtool.exe) must remain in %VISION_ROOT%\bin\win32\cvl to produce correct results. If you copy a utility's executable file to another directory and run it from there, the tool will run, but will incorrectly report that there are no Cognex boards in the system, even if the Cognex bin directory is in the PATH.
This is a change from the CVL 6.2 behavior, in which you could copy a utility's executable file to another directory and run it from there.
This section describes limitations of the Barcode tool in CVL 8.0.
Between CVL 5.5.0 and 5.5.1, the boolean parameter autoRetry, with a default value of true, was added to the argument list to several virtual functions of the ccAcuBarCodeTool class, specifically the decode() functions. As this alters the function signature, if you were overriding these functions using the old signatures in CVL 5.5.0, not only do you no longer override them in CVL 5.5.1 and later, your overrides will no longer be called. No compiler errors will alert you to the fact that the function signature has changed. When upgrading CVL applications from CVL 5.5.0 to 5.5.1 or later, make sure that your overrides of the ccAcuBarCodeTool::decode() functions match the latest function signatures.
This section describes limitations of the Blob tool in CVL 8.0.
If you persist a ccBlobSceneDescription object by reference and then reload it from the archive, your application will leak memory. You can prevent this from happening by persisting ccBlobSceneDescription objects by pointer rather than by reference.
This section describes limitations of the Calibration tool in CVL 8.0.
When performing feature correspondence calibration, the feature detector does not work reliably with tile sizes smaller than 15x15 pixels. For most applications, the checker size should be larger than 15x15 to avoid operating at the range limit.
This section describes limitations of the Caliper tool in CVL 8.0.
The pixel value range in the filtered clipped projection is not correct. The range in the filtered image is from -255 through +255 while it should be from -255*n through +255*n, where n is the number of samples in the projection. To get the correct range, rescale (multiply by n) the filtered image.
This section describes limitations of the Gaussian Sampling tool in CVL 8.0.
The cfGaussSample() overload that uses a 16-bit destination pel buffer clamps result values to 32,767. Therefore, any values that would normally produce a result that is greater than 32,767 (for example, a scale setting of 255 with an input pel value greater than 128) produce incorrect results.
Set the scale low enough that all results are less than 32,767.
This section describes limitations of the Grey-Scale Morphology tool in CVL 8.0.
The NxM Morphology variable-size kernel image tool with configurations other than 3x3 kernel is not fully multi-core optimized.
This section describes limitations of the ID tool in CVL 8.0.
The only EAN.UCC Composite symbols supported in this release are those using RSS Composite symbology.
This section describes limitations of the acuRead tool in CVL 8.0.
In user-defined fonts, end characters can be missing. This is true of both fixed and variable length modes. In fixed length mode, the last character becomes a space.
Widen the ROI to allow more blank pixels at the beginning and end.
This section describes limitations of the OCV tool in CVL 8.0.
If a position in a line arrangement is defined with a blank character among its current keys, and if that position is not blank in the runtime image and does not match any of the other current keys, then the OCV tool may incorrectly verify or confuse that position. A blank current key always returns a non-zero score regardless of what is actually in the search position at runtime. Scores returned for a blank key are generally low, but for some narrow characters such as '-' or ',' the score may exceed the accept or confusion thresholds and thus not fail verification.
Some examples of blank character scores are listed below:
Character: Score: - 0.423 . 0.422 ‘ 0.382 : 0.312 , 0.276
This occurs whether multiple or single current keys are defined for the positions, though an instance has been observed in which the score was lower with a blank plus another current key than with just the blank alone. This problem has to do with the design of the OCV tool, where blank and "normal" characters are treated differently. OCV does not check for the confusion of blank characters with anything, it simply looks at the blankness score to establish the state of the blank character. Hence small characters can be easily overlooked.
This section describes limitations of the PatMax tool in CVL 8.0.
Training PatMax using a shape with a bounding box that is significantly larger than 2Kx2K when projected to image coordinates using the training time transform will result in either an access violation or an application hang from within train().