MVTec Software GmbH
 

Release Notes for HALCON 20.11 Steady

This document provides the release notes for MVTec HALCON 20.11.1.0 Steady, as released in November 2020.

Contents

Major New Features of HALCON 20.11.1.0 Steady

Improvements for Shape-Based Matching

In HALCON 20.11, the core technology of shape-based matching has been improved especially for scenarios with low contrast and high noise. More parameters are now estimated automatically. This increases usability as well as the matching rate and robustness in low contrast and high noise situations.

Additionally, users can now, for example, define so-called “clutter” regions. These are areas within a search model that should not contain any contours. Adding such clutter information to the search model leads to more robust matching results, for example repetitive structures.

DotCode Reader

In HALCON 20.11, the data code reader has been extended by the new code type DotCode. This type of 2D code is based on a matrix of points. Therefore, it can be printed very fast and is applicable especially for high speed applications, like in the pharma or tobacco industry.

Deep OCR

With Deep OCR in HALCON 20.11, MVTec introduces a holistic deep-learning-based approach for OCR. This new technology brings machine vision one step closer to human reading. Compared to existing algorithms, Deep OCR can localize characters much more robustly, even regardless of their orientation and font type. The ability to automatically group characters allows the identification of whole words. This strongly increases the recognition performance as, e.g., misinterpretation of characters with similar appearances can be avoided.

Improved Egde-Supported Surface-Based 3D-Matching

In HALCON 20.11, the core technology edge-supported surface-based 3D-matching is significantly faster for 3D scenes with many objects and edges. In addition to this speedup, the usability has been improved by removing the need of setting a viewpoint.

HALCON/Python

HALCON 20.11 introduces a new HALCON/Python interface. This enables developers who work with Python to easily access HALCON's powerful operator set.

HDevelop Facelift

For enhanced usability, HALCON’s integrated development environment HDevelop has been given a facelift. In HALCON 20.11, more options for individual configuration have been implemented, e.g., a new modern window docking concept. Moreover, themes are now available to improve visual ergonomics and to suit individual preferences.

Deep Learning Edge Extraction

Deep learning edge extraction is a new and unique method to robustly extract edges (e.g., object boundaries) that comes with two major use cases. Especially for scenarios where a variety of edges is visible in an image, MVTec's deep learning edge extraction can be trained with only few images to reliably extract the desired edges. Hence, the programming effort to extract specific kinds of edges is highly reduced with MVTec HALCON.
Besides, the pretrained network is innately able to robustly detect edges in low contrast and high noise situations. This makes it possible to extract edges that usual edge detection filters cannot detect.

Pruning for Deep Learning

With network pruning, users have the option to subsequently optimize a fully trained deep learning network in terms of storage requirements and speed. With this feature, it is possible to control the priority of the parameters speed, storage, and accuracy and thus modify the network according to application-specific requirements.

Anomaly Detection

This feature significantly facilitates the automated surface inspection for, e.g., detection and segmentation of defects. Here, users face two challenges: getting enough training images of the respective defect and having to label all of these images. However, with HALCON's anomaly detection, you only need a low number of high quality “good” images for training. The technology is able to unerringly and independently localize deviations, i.e., defects of any type, on subsequent images. This means, defects of varying appearance can be detected without any previous knowledge or any preceding labeling efforts.

More Flexibility With Deep Learning

With HALCON 20.11, training for all deep learning technologies can be performed on the CPU. By removing the need for a dedicated GPU, standard industrial PCs (that could not house powerful GPUs) can now be used for training as well. This greatly increases customers' flexibility regarding the implementation of deep learning, because training can now be performed directly on the production line allowing for “on the fly” adjustments of the application. Additionally, the inference for all deep learning technologies runs out-of-the-box on Arm® processors.

More Transparency With the Grad-Cam-Based Heatmap

Deep learning networks are often considered a black box because users do not know what happens with the data during the inspection process. Therefore, it is very difficult to debug in case of misclassifications. HALCON's newly implemented Grad-CAM-based (Gradient-weighted Class Activation Mapping) heatmap supports you in analyzing which parts of an image influence the classification decision. Since this new heatmap can be calculated on the CPU without significant speed drops, users can analyze their network's class prediction “on the fly”.

Generic Box Finder for Pick-and-Place Applications

The generic box finder allows users to locate boxes of different sizes within a predefined range of height, width, and depth, removing the need to train a model. This makes many applications much more efficient – especially within the logistics and pharmaceutical industries, where usually boxes in a large variety of different sizes are used.

More Accurate and Robust Matching Results With Surface-Based 3D Matching

Especially in the assembly industry, workpieces must be located robustly and accurately to allow for further processing. Often, properties like small holes are the only unique feature to find the correct orientation of the object. HALCON's surface-based 3D matching can now make use of these features to increase accuracy and robustness of the matching result. Furthermore, edge-supported surface-based matching is now more robust against noisy point clouds: Users can control the impact of surface and edge information via multiple min-scores. If necessary, 3D edge alignment can also be switched off entirely to eliminate the influence of insufficient 3D data on the matching result.

Reading Very Small Codes With the Subpixel Bar Code Reader

The bar code reader in HALCON 20.11 features an advanced decoding algorithm, which increases the decoding rate when reading codes with very thin bars. Thanks to this, it is now possible to even read codes with bars smaller than one pixel.

Speedup of the ECC 200 Code Reader

In HALCON 20.11, the code reader for ECC 200 codes is significantly faster on multi-core systems. This is especially true for codes that are difficult to detect and read. For such codes, a speedup of up to factor 3 can be reached. This speedup also increases the viability of embedded-based code readers by taking full advantage of existing hardware capacities.

Compatibility

Licenses

All HALCON 18.11.3 Steady licenses or licenses of earlier versions must be replaced or upgraded. Please contact your local distributor. HALCON 20.11.1.0 Steady licenses will be downwards compatible to HALCON 18.11.3 Steady.

Furthermore, please note the following compatibility issues related to licenses:

  • The following licensing issues are known:
    • After starting applications based on HALCON 20.05 Progress (or later)/HALCON 20.11 Steady (or later), the dongle must be removed and inserted again before starting applications based on HALCON 19.11 (or earlier).
      This problem can be avoided by installing the CodeMeter Runtime from WIBU SYSTEMS AG. The CodeMeter Runtime is not shipped with HALCON and must be downloaded from https://www.wibu.com in the download area.
    • On Arm platforms (aarch64 architecture) with GLIBC 2.21, it is no longer possible to run both 64-bit and 32-bit HALCON processes in parallel because they might block each other.
    More information.

HALCON Library

Compared to HALCON 18.11.3, many extensions have been introduced. Thus, the HALCON 20.11.1.0 Steady libraries are not binary compatible with HALCON 18.11.3 or earlier versions. However, HALCON 20.11.1.0 Steady is mostly source-code compatible to HALCON 18.11.3 except for the changes listed below:
  • The signature in the following member functions of the classes HImage and HShapeModel have changed in the language  interfaces HALCON/CPP and HALCON/.NET: FindAnisoShapeModel,  FindScaledShapeModel, and FindShapeModel. The parameter MinScore has changed the type from double to HTuple, so that under certain circumstances ambiguities may occur during a type conversion in the compilation process. In these cases, an explicit cast of your passed variable to double resolves the ambiguity. More information.
  • As the surface-based matching has been extended to be able to calculate a view-based score during the matching and pose refinement step, the interface of the procedure dev_display_surface_matching_results has been extended by the new parameter VisibilityTrained to support the view-based score. More information.
  • The parameter 'batch_size_device' of the deep learning classifier has been replaced by the parameter 'batch_size_multiplier', which has a different semantics. Hence, programs using 'batch_size_device' need to be adapted to use 'batch_size_multiplier' instead. More information.
  • Support for deep learning inference on 32-bit Windows has been removed. Further, the extra library hcpudnn.so/.dylib/.dll has been removed and is not needed anymore. More information.
  • Dev operator implementation classes for HDevEngine have to be extended with an implementation for the new dev_set_contour_style operator. More information.
  • Previously, write_object_model_3d wrote all user added attributes as floats when choosing FileType 'ply'. This behavior has been changed such that all user added attributes are now written as doubles. More information.
  • Extending the functionality of the deep learning model led to changes in the signatures of the following private procedures:
    • dev_display_update_train_dl_model
    • prepare_image_lists
    During this process, parameters have been renamed, which can lead to incompatibilities when running the procedures by the HDevEngine. The following procedures are affected:
    • create_dl_preprocess_param,
    • create_dl_preprocess_param_from_model,
    as well as the following private procedures:
    • get_next_window, and
    • open_next_window.
    More information.
  • triangulate_object_model_3d with Method set to 'xyz_mapping' or 'greedy' now only returns points that are actually used in the output triangulation. Attributes attached to points get thinned out accordingly. The attributes 'lines' and 'polygons' are not copied to the output. To obtain the old behavior, e.g., to return all input points, set the GenParamName 'greedy_output_all_points' or 'xyz_mapping_output_all_points' to 'true'. Alternatively, you can use the old point indices, which are stored in the triangulated 3D object model as an extended attribute named 'original_point_indices' and which can be queried with get_object_model_3d_params. More information.
  • For deep-learning-based object detection models, get_dl_model_param now returns a tuple of values that is as long as the number of classes for the parameter "class_weights" in any case. More information.
  • The interfaces of the procedures disp_menu_ext and inspect_normal_direction are extended by the parameter 'WindowScaling' to scale the text according to the user's setting. More information.
  • As the pretrained deep learning models used in semantic segmentation have been changed, other training results than before must be expected. Although the new models perform better in all our tested application cases, if you have chosen very specific training parameters for the old models, you might need to optimize those parameters again for the new models. More information.
  • The define for the error code 7824 ("DL: Invalid instance type") has been renamed from H_ERR_DL_DETECTOR_INVALID_TYPE to H_ERR_DL_DETECTOR_INVALID_INSTANCE_TYPE. Applications using this define must be adapted. More information.
  • Only NVIDIA cards with compute capability 3.5 are supported. More information.
  • Since find_box_3d is now independent of a viewpoint and the position of the input point cloud in space, the procedure debug_find_box_3d has been adapted accordingly. Furthermore, an error is raised in case that the input GenParam contains a key 'viewpoint'. The returned GrippingPose is set according to the XYZ-mapping.
    If the input point cloud of find_box_3d contains normals, they are not used anymore. More information.
  • Due to changes to the calculation of the anomaly score histogram in evaluate_dl_model (in order to solve a display issue), the following parameter keys have become obsolete and hence unavailable for the procedure's generic parameter dictionary GenParam:
    • 'anomaly_num_bins'
    • 'anomaly_min_value'
    • 'anomaly_max_value'
    More information.
  • The default value for the texture inspection model parameter 'gmm_preprocessing' has been changed from 'none' to 'normalization'. When using gray scale images, identical results compared to previous HALCON versions can be obtained by calling set_texture_inspection_model_param(TextureInspectionModel, 'gmm_preprocessing', 'none') before executing train_texture_inspection_model(). More information.
  • sort_region with SortMode 'character' previously took the larger one of two overlapping regions for the calculation of the overlap. This can cause an issue in case the two regions greatly differ in their sizes. Now, the smaller region is used to compute the overlap. Hence, in cases with overlapping regions that are very different in their sizes, this change can cause a different behavior of the operator.
    Also note that the extension of the parameter SortMode with a second optional value affects the compatibility as the operator signature changed for language interfaces. Affected interfaces are C, C++ and .NET. More information.
  • Because of a bug fix regarding the calculation of the mean average precision (mean_ap) measure during the evaluation of deep-learning-based object detection, the deep-learning-based object detection evaluation results might be different. To obtain the same results for 'mean_ap' as before, the evaluation parameter 'interpolate_pr_curves' can be set to false (default: true). More information.
  • As edges_object_model_3d is now by default independent of a viewpoint, a 'viewpoint' contained in GenParamName is silently ignored. To obtain the old behavior, add 'estimate_viewpose' and 'false' to GenParamName and GenParamValue, respectively.
    To obtain the old behavior in case no manual viewpoint has been set, add ['estimate_viewpose', 'viewpoint'] and ['false', '0 0 0'] to GenParamName and GenParamValue, respectively. More information.
  • In previous versions, train_dl_model_batch expected the parameter 'DLSampleBatch' as single dictionary in the C++ and .NET interface. While the operator now expects a tuple of dictionaries, with the new signature it is still possible to use a single dictionary for 'DLSampleBatch'. More information.
  • The default value for the new parameter 'max_num_samples' in the deep learning procedure determine_dl_model_detection_param has been set to 1500. For datasets with more than 1500 samples, this can lead to different detection parameters determined by the procedure. To reproduce the previous behavior, set 'max_num_samples' to '-1'. More information.
  • A set 'viewpoint' in GenParamName of find_surface_model, find_surface_model_image, refine_surface_model_pose, and refine_surface_model_pose_image has no effect anymore, except for the calculation of the view-based score if specified by 'use_view_based' set to 'true'. The procedure debug_find_surface_model has been adapted accordingly.
    If a surface-based model has been trained for use of edges, and the input point cloud of find_surface_model and find_surface_model_image contains a mapping, scene normals are automatically generated flipped inwards consistently w.r.t. the mapping. Normals contained in the input point cloud are not used anymore. Furthermore, the GenParamName 'scene_invert_normals' should not be needed anymore. Typically, 'scene_invert_normals' should be set to 'false' or be removed from GenParamName.
    In rare cases, edge-supported surface-based matching returns slightly different results.
    More information.
  • Using NVIDIA GPUs under Windows 7 is not supported anymore. More information.
  • Due to the change of the default value for the parameter 'rectif_interpolation' when using stereo models, identical results compared to previous HALCON versions can be obtained by calling set_stereo_model_param(StereoModel, 'rectif_interpolation', 'none') and set_stereo_model_image_pairs before reconstructing the surface using reconstruct_surface_stereo. More information.
  • The default encoding of 2D data codes has been changed from 'utf8' to 'latin1'. Programs that expect UTF-8 encoded messages must be adapted by setting the parameter 'string_encoding' to 'utf8' with set_data_code_2d_param. More information.
  • get_data_code_2d_results now returns the value '-1' for all result-specific parameters if 'CandidateHandle' is 'general'. Applications that expect another value or an empty tuple need to be adapted. More information.
  • In very rare cases, the results of the operators watersheds, watersheds_threshold, and watersheds_marker might have changed for basins at the boundary of the ROI that are one pixel large. More information.
  • HALCON's camera models for perspective line scan cameras now support the polynomial distortion model. As a result of this change, the camera model type string 'line_scan' has been replaced by 'line_scan_division'. The old camera type string 'line_scan' is still supported as input to provide backward compatibility. However, applications should be modified to use 'line_scan_division' instead of 'line_scan'. In particular, programs that test for 'line_scan' in a camera parameter tuple that has been output by HALCON must be rewritten to test for 'line_scan_division'. Furthermore, the procedure gen_cam_par_line_scan has been deprecated. It should be replaced by a call to the new procedure gen_cam_par_line_scan_division. More information.

HALCON Applications

Please re-compile all C, C++, or .NET programs developed with HALCON 18.11.3. The incompatibility with HALCON 18.11.3 or earlier versions mainly concerns the binaries, with only few changes in the language interfaces. If you encounter problems during recompiling your programs, please check the detailed description of changes below.

Image Acquisition Interfaces

In general, HALCON 20.11.1.0 Steady, HALCON 18.11.3, and HALCON 18.11.x image acquisition interfaces are library compatible.

HALCON 20.11.1.0 Steady includes only a subset of available manufacturer-independent image acquisition interfaces. Image acquisition interfaces that are included are: DirectFile, DirectShow, File, GenICamTL, GigEVision2, GStreamer, USB3Vision, and Video4Linux2. You can download additional proprietary interfaces from our web server.

Digital I/O Interfaces

In general, HALCON 20.11.1.0 Steady, HALCON 18.11.3, and HALCON 18.11.x digital I/O interfaces are library compatible.

HALCON 20.11.1.0 Steady includes only a subset of available manufacturer-independent digital I/O interfaces. Digital I/O interfaces that are included are: Linux-GPIO, OPC_UA, and Hilscher-cifX. You can download additional proprietary interfaces from our web server.

Extension Packages

Please re-generate your own extension packages developed with HALCON 18.11.3.

Note also the following compatibility issues:

  • Previously, in user-provided .def files of extension packages, parameters could be declared with default_type only, i.e., without declaring sem_type. This has been changed. sem_type is now a required field for all parameters. More information.

Further Compatibility Information

  • The legacy include file "HSync.h" has been removed from the fileset. Therefore, the legacy macro definitions for CRITICAL_SECTIONS that were not used by HALCON for several versions are not available anymore. More information.
  • String literals in HDevelop scripts must not span multiple lines. Previously, the use of line continuation (backslash + newline) within a string literal was not treated as an error but led to corrupted strings with extra spaces. Now it is reported as an error and leads to invalid lines. Note that you can break long string literals by concatenating multiple string literals. More information.
  • The new revision 19.11.1 of the OPC_UA interface is not backwards compatible to older HALCON versions. The interface heavily uses HALCON Dictionaries, which are only available since HALCON 19.11 Progress/HALCON 20.11 Steady for image acquisition and digital I/O interfaces. Further, the OpenSSL version required by the interface is not compatible with the one included in previous releases of HDevelop. More information.
  • When exporting a program or library as source code for HALCON/.NET, private procedures will now be exported with the "private" access modifier. If your application relies on calling such a procedure you may need to configure it as "Public" explicitly. More information.

Discontinuation of the x86-win32 Platform Version for Windows

With HALCON 20.11, the x86-win32 platform version for Windows is discontinued. Switch any existing x86-win32 applications to the x64-win64 platform version for Windows to be able to use HALCON 20.11.

Supported Operating Systems

Windows

HALCON 20.11.1.0 Steady has been compiled for the x64-win64 platform version for Windows 7/8.1/10 or Windows Server 2008 R2/2012 R2/2016/2019 x64 Edition on Intel 64 or AMD 64 processors.

Linux

HALCON 20.11.1.0 Steady has been compiled for the following Linux platform versions:

  • x64 platform version for Linux x86_64, GLIBC_2.17, GLIBCXX_3.4.21, on Intel 64 or AMD 64 processors
  • armv7a platform version for Linux armv7a, Kernel with hidraw support, hard-float ABI, GLIBC_2.17, GLIBCXX_3.4.21 on Armv7-A processors with NEON support
  • aarch64 platform version for Linux aarch64, Kernel with hidraw support, GLIBC_2.17, GLIBCXX_3.4.21 on AArch64 processors

Please refer to the Installation Guide for detailed system requirements corresponding to the different Application Binary Interfaces.

macOS

HALCON 20.11.1.0 Steady has been compiled for the x64 platform version of macOS 10.15 on Intel 64.

Detailed Description of Changes in HALCON 20.11.1.0 Steady

The changes in HALCON 20.11.1.0 Steady are described with respect to HALCON 18.11.3.

HDevelop

New Functionality

Assistants
  • A new reference manual chapter entry 'Calibration' was added. It gathers data applicable to different calibration setups. Among them are calibration recommendations, which are now centralized for improved readability. This allowed to prune other documentation parts and enhance their focus. As part of this work, the recommended values have been reviewed.
    The HDevelop example program 'hdevelop/Calibration/Multi-View/check_calib_image_quality.hdev' as well as the HDevelop Calibration Assistant have been updated and are in line with the current recommendations. As a consequence, the score for the image coverage by a single plate has been removed.
  • HALCON has been extended by a new camera model for line scan cameras with telecentric lenses:
    • 'line_scan_telecentric_division'
    • 'line_scan_telecentric_polynomial'.
    New HDevelop procedures to generate camera parameter tuples for each camera type have been added:
    • gen_cam_par_line_scan_telecentric_division
    • gen_cam_par_line_scan_telecentric_polynomial.
    The new HDevelop example program hdevelop/Calibration/Multi-View/line_scan_telecentric_calibration.hdev shows how to use the new functionality.
    The HDevelop Calibration Assistant has been extended accordingly.
Code Export
  • Code exported from HDevelop added a call to the Xlib function XInitThreads on Linux systems, which has been unnecessary since HALCON 13.0. This has been adapted accordingly.
  • Within the HDevelop User's Guide, the chapter about Code Export has been improved. Further, the section about the Library Project Export now also provides a link to the tutorial video.
  • When exporting a program or library as source code for HALCON/.NET, private procedures will now be exported with the "private" access modifier. Note that this change affects the compatibility. Read more.
GUI
  • The Qt version used by HDevelop has been upgraded to Qt 5.12.5. A known problem is that on macOS, HDevelop does not use the macOS style buttons for closing, minimizing, and maximizing in the title bars.
  • HDevelop's Start Dialog has been extended with a direct link to the complete collection of MVTec's video tutorials.
  • The About dialog has been improved. Previously, the license status was not displayed. Now, the used license and, if applicable, the expiration date are displayed.
  • HALCON has been extended with means to configure the fill style for displaying XLD contours. The operators set_contour_style, get_contour_style, and the respective HDevelop operator dev_set_contour_style have been added to enable this.
    The pie charts displayed by the evaluation procedures for deep learning have been adapted to use this new functionality. Note that this change affects the compatibility. Read more.
  • The HDevelop window modes MDI and SDI have been replaced by a new docking framework. This allows users to dock, float, and combine windows. Further, it better supports the usage of a second screen and to attach windows on the left or right of the desktop.
  • The font size in the Program Window of HDevelop can now be adjusted via
    • the mouse wheel + CTRL or via
    • CTRL+Plus to increment the font size and
    • CTRL+Minus to decrement the font size.
  • Procedures that have a non-empty warning section in their general documentation now get displayed in HDevelop in the same manner as operators with a non-empty warning slot already do. In particular:
    • Calls to such a procedure get marked with a warning sign in the program listing.
    • The procedures get marked with a warning sign in the Program Window's procedure selection box.
    • The warning text is prominently displayed in the Operator Window.
  • Since HDevelop has been updated to Qt 5.12.5 and now uses the QtWebEngine, it is required that the linux system provides the correct version of the libdbus-1.so3 library. Otherwise an error like below may be displayed:
    "hdevelop: relocation error: ../libQt5DBusMVTec.so.5: symbol dbus_message_get_allow_interactive_authorization, version LIBDBUS_1_3 not defined in file libdbus-1.so.3 with link time reference"
  • High DPI displays are now much better supported. HDevelop adapts appropriately to the Windows screen settings "Scale and layout".
  • The Handle Inspect window in HDevelop no longer shows internal data containers, which are only used to structure the presented data in a tree, as modified. Instead, only the data contained by them is shown as modified if it was changed in the last step or run operation.
  • The GUI of HDevelop has been modernized in the following way:
    • HDevelop's icons have been updated.
    • HDevelop now supports a dark and a light theme. This can be set via menu > Edit Preferences > User Interface > Themes.
    • HDevelop now shows the MVTec logo in the status bar. Clicking the logo opens the HALCON product page of the MVTec website in a browser.
  • The status bar of HDevelop now contains a new bell icon, which signals whether an update of the currently used version is available.
    The update check is done during the start of HDevelop.
  • HDevelop now logs internal errors, which can be viewed in the output console of HDevelop.
  • 3D object models can now be visualized directly from within handle inspect windows. This allows visualizing 3D object models that are, e.g., inside a dictionary.
    Furthermore, corresponding information can now also be visualized for 2D data codes, barcodes, and serialized items.
  • The GUI of HDevelop has been simplified, and several icons have been removed.
    In particular, the complexity of the output console's layout has been reduced.
  • The export buttons and corresponding icons have been removed from the toolbar. They are now available under "File → Export → Export..." and "File → Export → Export Library Project...".
  • The usability of the color selection of the program window and variable window has been improved. All color-related settings are now grouped under theming.
    Additionally, the program window and variable window react to the global theme change without changing user-defined colors.
    It is now also possible to reset single colors to their current, theme-specific, default setting or to reset all colors to the current default setting.
    To increase the usability, the color settings are versioned to avoid conflicts with older installations of HDevelop.
  • The Start Dialog has been enhanced by a new Tip of the Day.
  • The loading times of the help have been improved.
  • The HDevelop graphics window now offers a new setting that controls how the visible image part is adapted when the window is resized. This facilitates the use of docked graphics windows where the window size can no longer be controlled exactly. The setting is located in the "Set image size" toolbar dropdown menu. It supports the following values:
    • Full Stretch (classic): The visible image part remains constant. The zoom levels are adapted to fully fit the previous view into the new window size.
    • Keep Aspect Ratio (default for interactively opened windows): The zoom level is changed using the same factor for both axes (preserving the previous aspect ratio). The visible image part may change in one axis as a result of the resize operation.
    • No Stretch: The zoom level remains fixed. Resizing the window will show a correspondingly larger or smaller portion of the image.
    In addition, this setting affects the automatic part reset that occurs in HDevelop when displaying an image with a new size (double clicking in the variable window or calling dev_display without explicitly calling dev_set_part). In Full Stretch mode, the part will be set to the full image size as before. In the other modes, the part is extended to fit the full image in a 1:1 aspect ratio with black bars on one side.
    The default setting for new graphics windows can be changed under Preferences > General Options.
    HDevelop windows opened from script (via dev_open_window) will be opened as floating windows using the classic "Full Stretch" mode for maximum backwards compatibility. In particular, note that graphics windows that are docked and/or use one of the newer modes may cause unexpected results for programs that rely on a fixed window size or a constant part. For example, get_part may routinely return negative coordinates for the upper left corner after displaying a new image, and dump_window_image may result in an image with unexpected size. For the latter use case, we recommended creating an off-screen "buffer" window instead (using the operator open_window).
  • In the HDevelop program window, the line number display has been improved. Previously, big font sizes or long programs could lead to truncated and thus not fully visible line numbers. Now the line number display adjusts according to the line count and font size.
  • It is now possible to use the mouse wheel to zoom in and out in the HDevelop graphics window. This can also be achieved via CTRL++ and CTRL+-.
Help
  • The usability of the HDevelop help has been improved. Now, a search in the HDevelop help also returns results from the procedures located in HDevelop's standard procedure path (if the search option "Reference" is checked).
IDE
  • The usability of the profiler has been improved. Now it is possible to show the last execution time in HDevelop.
  • HDevelop's autocompletion can now also provide suggestions for empty lines of code. In this case, the possible successors of the previous HALCON operator are suggested.
    Further, the autocompletion now provides suggestions for a completely empty program, too. In that case, a list of typical first operators (like open_window or read_image) is offered.
  • HDevelop's Variable Inspection widget now highlights the variables which have been written to during the last execution step. This can be switched on and off via the Preferences Dialog under UserInterface > Program Window > Highlight Modified Variables.
Language
  • HALCON has been extended with functions to calculate the Gaussian error function. In particular, the operators tuple_erf and tuple_erfc and the corresponding HDevelop language functions erf and erfc have been implemented.
  • HALCON has been extended with functions to calculate the hypotenuse and the cube root. In particular, the new operator tuple_hypot and the corresponding HDevelop language function hypot calculate the hypotenuse sqrt(x*x+y*y) without undue overflow or underflow during the intermediate steps of the calculation. Furthermore, the new operator tuple_cbrt and the corresponding HDevelop language function cbrt calculate the cube root.
  • HALCON has been extended with tuple operators for the inverse hyperbolic functions tuple_asinh, tuple_acosh, and tuple_atanh and the corresponding HDevelop language functions asinh, acosh, and atanh.
  • HALCON has been extended with the following tuple operators: tuple_exp10 (base 10 exponentiation), tuple_exp2 (base 2 exponentiation), and tuple_log2 (base 2 logarithm).
  • HALCON has been extended with the tuple operators tuple_tgamma and tuple_lgamma and their counterparts tgamma and lgamma in HDevelop. They calculate the gamma function and the logarithm of the absolute value of the gamma function, respectively.
Procedures
  • The procedure documentation has been improved. Now, the procedure reference shows the status (private, public, private protected, public protected) of the procedure.
  • HDevelop's procedure documentation now supports Markdown syntax. This offers improved text formatting and enables the addition of tables, images, and more. Please refer to the HDevelop User's Guide for more information.
Miscellaneous
  • The content of HDevelop's main title bar has been improved.
  • If a user searches for "MVTec" in the Windows taskbar, now HDevelop is listed.
  • The Qt version used by HDevelop has been upgraded to Qt 5.15.1.

Bug Fixes

Assistants
  • The Calibration Assistant wrongly indicated an error when trying to modify calibration parameters if no images were loaded. This problem has been fixed.
  • Using planar deformable matching with calibration in the HDevelop Matching Assistant could lead to failures, even though the model was actually found correctly and code generated from the assistant would work fine. This problem has been fixed. In addition, the assistant now visualizes the transformed model contour properly for this scenario.
Code Export
  • Within the file dialog, when exporting to C, the pre-selected file extension was wrong. This problem has been fixed.
  • For C, Visual Basic .NET, and C#, HDevelop exported the comparison of two objects '( obj1 != obj2)' as test_equal_obj, without the necessary negation. This problem has been fixed.
  • Using the HDevWindowStack member functions of the C++ language interface before calling the first HALCON operator led to a crash. This problem has been fixed.
GUI
  • For HDevelop on macOS, window redrawing was not correct in any case. This problem has been fixed. Now, it has been improved and the graphics window is no longer the topmost window.
  • open_window can open child windows within previously opened HALCON windows. Due to changes in the internal HDevelop window management, this may no longer work reliably in HDevelop programs if the parent window is an HDevelop graphics window. If nested windows are needed the top-level container window should be opened as a native HALCON window as well (using the operator open_window).
  • On Linux systems, using file selection dialogs in HDevelop sometimes caused warning messages to be printed on the console. This problem has been fixed.
  • Scaling of HDevelop on screens with fractional scaling settings was not always correct. This problem has been fixed.
  • The icon that indicates the run state of programs, which is located in the status bar of HDevelop, sometimes had a wrong scaling and was off centered. This problem has been fixed.
  • Setting a breakpoint on a variable visually changes the background of it to red in the Variable Window when the breakpoint is hit. That color was not reset. This problem has been fixed.
  • The x-axis in plot-based windows (e.g., function inspect with operator dev_inspect_ctrl) sometimes was drawn over the active window above it. This problem has been fixed.
  • The HDevelop graphics window had an unlimited update frequency. This could lead to a slow down if too many update requests where queued. This problem has been fixed. Now, the update frequency of the HDevelop graphics window is limited to 60 Hz.
  • If a program containing procedures was loaded while the preferences dialog was open, the 'Procedure Use' table of the dialog was not correctly filled. This problem has been fixed.
  • For big numbers, variable inspection may have corrupted the input. This problem has been fixed.
  • Minimizing the line profile dialog caused it to stop updating after ROI changes. This problem has been fixed.
  • In the Move mode of HDevelop's graphics window, moving an image outside of the graphics window while pressing the CTRL key (i.e., displaying the pixel info) caused the displayed image to jump and change its display size. This problem has been fixed.
  • When opening the 'Invalid Lines' tab of the Quick Navigation window, HDevelop crashed in rare cases. This problem has been fixed.
  • Most of the provided examples open the windows at position 0,0. In the old MDI mode, the reference point was HDevelop or the MDI area, which was located below the toolbar of HDevelop.
    With docking, the windows are now opened floating, just like in the old SDI mode. In this case, the point of origin is that of the desktop.
    If HDevelop is now used in fullscreen mode, the windows would cover the menu and the toolbar. To avoid this, you can add an offset to the coordinates of the windows. By default, this offset is set to a value of 100,0. It can be changed via Preferences > General Options.
  • The size of the start dialog could exceed the desktop geometry. This problem has been fixed.
IDE
  • If the program counter was on the last line of an if-block in an if-else-statement or the last line of a try-block in a try-catch statement, and that line was removed or deactivated, the program counter would have moved to the following else- or catch-block even though these should not normally be executed. This problem has been fixed. Now, the program counter moves past those blocks.
  • In the handle inspect windows, floating-point values were not always shown with a decimal point, making it difficult to distinguish them from integer values. This problem has been fixed. Floating-point values are now always shown with a decimal point in the handle inspect window.
  • If the variable window was closed then the automatic display of changed iconic variables in the graphics window did not work. This problem has been fixed.
  • HDevelop was not able to load ROIs of the type 'Arbitrary Region' from file. This problem has been fixed.
Language
  • HDevelop corrupted string literals if they spanned two or more lines of code. This case is now detected as an invalid line. Instead, use the + operator to concatenate multiple strings and place line breaks in between if desired. For example, use
    string_complete := 'string_part1' + \
    'string_part2'

    Note that this change affects the compatibility. Read more.
Procedures
  • Setting the File Extensions slot of a procedure's parameter documentation prevented HDevelop from generating the proper reference documentation. This problem has been fixed.
  • When setting directories over GenParam dicts, tuples of strings were not processed correctly when reading deep learning data sets.
    This affects the following procedures:
    • read_dl_dataset_anomaly
    • read_dl_dataset_segmentation
    This problem has been fixed.
  • Pressing CTRL+ALT+ENTER to open a procedure in HDevelop did not work. This problem has been fixed.
Miscellaneous
  • During startup, HDevelop checks if a new HALCON version is available. The check did not consider the system architecture. This problem has been fixed.
  • Passing command line parameters with arbitrary unicode characters (not included in the character set of the OS locale) did not work under Windows. In particular, this prevented opening of program files with special characters from, e.g., the Windows Explorer. This problem has been fixed.
  • If, at the moment of a program reset, variable inspection windows were hidden, they were not cleared after the reset. This problem has been fixed.
  • The use of certain characters could cause erratic behavior in the editor including extra or missing line breaks and corrupted program contents after reloading. This problem has been fixed.
    Specifically, this fix addresses combining characters where multiple Unicode code points form a single grapheme ("character"). These are common in some languages such as Thai but can also occur in other languages, e.g., the Japanese Halfwidth Katakana Voiced Sound Mark "゙" or even just accents like é (which are typically represented by their own "precomposed" Unicode code point instead).

HDevelop Example Programs

New HDevelop Example Programs
  • hdevelop/3D-Matching/3D-Box/find_box_3d.hdev
  • hdevelop/3D-Matching/Surface-Based/find_surface_model_self_similar_poses.hdev
  • hdevelop/3D-Matching/Surface-Based/find_surface_model_view_based_score.hdev
  • hdevelop/3D-Object-Model/Segmentation/reduce_object_model_3d_to_visible_parts.hdev
  • hdevelop/3D-Object-Model/Segmentation/remove_background_for_3d_object_localization.hdev
  • hdevelop/3D-Object-Model/Segmentation/remove_bin_for_3d_object_localization.hdev
  • hdevelop/3D-Object-Model/Segmentation/sample_object_model_3d.hdev
  • hdevelop/3D-Object-Model/Transformations/triangulate_object_model_3d_xyz_mapping.hdev
  • hdevelop/Applications/Data-Codes/dotcode_optimized_settings.hdev
  • hdevelop/Applications/Data-Codes/dotcode_simple.hdev
  • hdevelop/Applications/General/correct_vignetting.hdev
  • hdevelop/Applications/General/sony_polarsens_polarization_angle_degree.hdev
  • hdevelop/Calibration/Multi-View/calibrate_cameras_telecentric_line_scan_stereo.hdev
  • hdevelop/Calibration/Multi-View/line_scan_telecentric_calibration.hdev
  • hdevelop/Deep-Learning/AnomalyDetection/dl_anomaly_detection_workflow.hdev
  • hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_1_preprocess.hdev
  • hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_2_train.hdev
  • hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_3_evaluate.hdev
  • hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_4_infer.hdev
  • hdevelop/Deep-Learning/Classification/dl_classification_workflow.hdev
  • hdevelop/Deep-Learning/Classification/prune_dl_model_classification_workflow.hdev
  • hdevelop/Deep-Learning/Classification/show_feature_maps_for_dl_classification.hdev
  • hdevelop/Deep-Learning/DeepLearningTool/import_model_from_dlt.hdev
  • hdevelop/Deep-Learning/Detection/dl_detection_with_orientation_workflow.hdev
  • hdevelop/Deep-Learning/Detection/dl_detection_workflow.hdev
  • hdevelop/Deep-Learning/Segmentation/dl_segmentation_workflow.hdev
  • hdevelop/Deep-Learning/Segmentation/segment_edges_deep_learning.hdev
  • hdevelop/Deep-Learning/Segmentation/segment_edges_deep_learning_with_retraining.hdev
  • hdevelop/File/Access/fread_bytes.hdev
  • hdevelop/File/Images/read_write_image_metadata.hdev
  • hdevelop/Identification/Bar-Code/barcode_small_elements_robustness.hdev
  • hdevelop/Image/Acquisition/genicamtl_basler_blaze_objectmodel3d.hdev
  • hdevelop/Image/Acquisition/genicamtl_parameter_persistence.hdev
  • hdevelop/Image/Acquisition/gigevision2_parameter_persistence.hdev
  • hdevelop/Image/Acquisition/gstreamer_parameter_persistence.hdev
  • hdevelop/Image/Acquisition/usb3vision_information.hdev
  • hdevelop/Image/Acquisition/usb3vision_parameter_persistence.hdev
  • hdevelop/Inspection/Texture-Inspection/apply_texture_inspection_model_color.hdev
  • hdevelop/Matching/Shape-Based/adapt_shape_model_high_noise.hdev
  • hdevelop/Matching/Shape-Based/find_shape_low_contrast_high_noise.hdev
  • hdevelop/Matching/Shape-Based/find_shape_model_clutter.hdev
  • hdevelop/Matching/Shape-Based/set_shape_model_model_cache.hdev
  • hdevelop/OCR/Deep-OCR/deep_ocr_workflow.hdev
  • hdevelop/Segmentation/Topography/watersheds_marker.hdev
  • hdevelop/System/IO-Devices/opc_ua_enumeration.hdev
  • hdevelop/System/IO-Devices/opc_ua_monitor_connection.hdev
  • hdevelop/System/IO-Devices/opc_ua_option_set.hdev
  • hdevelop/System/IO-Devices/opc_ua_structure.hdev
  • hdevelop/System/IO-Devices/opc_ua_union.hdev
  • hdevelop/System/Sockets/generic_socket_TLS_echo_server.hdev
  • hdevelop/Tools/Geometry/area_intersection_rectangle2.hdev
  • hdevelop/Tools/Mosaicking/two_camera_calibrated_mosaicking.hdev
New Functionality
  • HALCON now provides an example that demonstrates how to import a model trained with the Deep Learning Tool (DLT) into HALCON. This example is called hdevelop/Deep-Learning/DeepLearningTool/import_model_from_dlt.hdev.
  • select_points_object_model_3d now accepts a tuple of numbers instead of an attribute name as input on which the threshold is applied. This allows to select points based on some mask without first setting that mask as attribute in the 3D object model. The HDevelop example program hdevelop/3D-Object-Model/Segmentation/select_points_object_model_3d.hdev has been extended to show this new functionality.
  • The operators find_surface_model, find_surface_model_image, refine_surface_model_pose, and refine_surface_model_pose_image now accept multiple values in their MinScore argument. Those values can be used to set minimum scores for the surface overlap, the 3D edge overlap, and for image-based operators, the 2D edge overlap. Additionally, the values of these scores can be obtained using the operator get_surface_matching_result. The visualization of the corresponding surface matching result handles in the handle inspection windows has been adapted accordingly.
    The HDevelop example program hdevelop/3D-Matching/Surface-Based/find_surface_model_with_edges.hdev has been extended to show the new functionality.
  • The new HDevelop example program hdevelop/Applications/General/correct_vignetting.hdev shows how to perform a vignetting correction on different sample images.
  • The new HDevelop example program hdevelop/Applications/General/sony_polarsens_polarization_angle_degree.hdev shows how to extract the four polarization images from a RAW image, and how to calculate the direction and degree of polarization for each pixel.
Bug Fixes
  • In the following examples, the random seed was not working for the first run:
    • hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_2_train.hdev
    • hdevelop/Deep-Learning/Detection/detect_pills_deep_learning_2_train.hdev
    • hdevelop/Deep-Learning/Segmentation/segment_pill_defects_deep_learning_2_train.hdev
    This problem has been fixed.
  • In the HDevelop example programs hdevelop/Deep-Learning/Segmentation/segment_pill_defects_deep_learning_3_evaluate.hdev and hdevelop/Deep-Learning/Detection/detect_pills_deep_learning_3_evaluate.hdev the batch size was set after the call of set_dl_model_param(DLModelHandle, 'runtime_init', 'immediately'). This could have led to an out of memory error. This problem has been fixed. Now, the batch size is set before the "runtime_init" call.
  • In some places of the HDevelop example program explore_halcon.hdev, set_system('flush_graphic', ...) was used, although this is no longer recommended. Instead, the operators set_window_param and flush_buffer should be used. This problem has been fixed.

HDevEngine

Functionality

  • The code formatting of the HDevEngineCpp.h header file has been changed.
  • The just-in-time compiler of the HDevEngine is now able to compile procedures that call dev_clear_obj on a global variable.
  • The C# and VB HDevEngine examples for executing programs and procedures now use a background thread for execution. This provides a better experience when these examples are adapted to execute own code that makes use of interactive drawing objects.
  • JIT compilation of procedures is now supported with the standard Arm architectures aarch64-linux and armv7a-linux.
    The size of the HDevEngine for Arm architectures increased to approximately 30 MB.

Bug Fixes

  • The internal JIT compiler holds a cache that was not freed at program end which led to a falsely reported memory leak. This problem has been fixed.
  • In rare cases, when editing a JIT-compiled procedure and an exception was thrown from a different JIT-compiled procedure that called the edited JIT-compiled procedure, HDevelop could crash or return an invalid exception. This problem has been fixed.

HALCON Library

Speedup

Note that the mentioned speedups are based on comparisons between Progress versions. For HALCON Steady, the corresponding numbers may vary.

  • affine_trans_image, affine_trans_image_size, zoom_image_factor, zoom_image_size, and rotate_image (for angles not multiples of 90 degrees) have been accelerated on Arm 64-bit processors that support the NEON instruction set.
    For images of type 'byte' and 'uint2', the operators are faster
    • by up to 20% for Interpolation = 'bilinear' and
    • by up to 30% for Interpolation = 'constant' and Interpolation = 'weighted'.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation produces identical results as the old implementation.
    For images of type 'real', the operators are faster
    • by up to 80% for Interpolation = 'bilinear',
    • by up to 150% for Interpolation = 'constant' and Interpolation = 'weighted', and
    • by up to 60% for Interpolation = 'bicubic'.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation is numerically infinitesimally less accurate than the previous implementation. If utmost accuracy is desired, the previous implementation can be selected by setting 'int_zooming' to 'false'.
    Furthermore, affine_trans_region has been accelerated on Arm 64-bit processors that support the NEON instruction set.
    • The acceleration is up to 35% for Interpolation = 'constant'.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation produces identical results as the old implementation.
  • affine_trans_image, affine_trans_image_size, zoom_image_factor, zoom_image_size, and rotate_image (for angles not multiples of 90 degrees) have been accelerated on processors that support AVX2.
    For images of type 'byte', the operators are faster
    • by up to 100% for Interpolation = 'nearest_neighbor',
    • by up to 70% for Interpolation = 'bilinear',
    • by up to 130% for Interpolation = 'constant' and Interpolation = 'weighted', and
    • by up to 120% for Interpolation = 'bicubic' on processors that support AVX2.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default) and if 'avx2_enable' is set to 'true' with set_system (the default on machines that support AVX2).
    The new implementation produces identical results as the old implementation.
    For images of type 'uint2', the operators are faster
    • by up to 120% for Interpolation = 'nearest_neighbor',
    • by up to 170% for Interpolation = 'bilinear',
    • by up to 230% for Interpolation = 'constant' and Interpolation = 'weighted', and
    • by up to 90% for Interpolation = 'bicubic' on processors that support AVX2.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default) and if 'avx2_enable' is set to 'true' with set_system (the default on machines that support AVX2).
    The new implementation produces identical results as the old implementation.
    For images of type 'int2', the operators are faster
    • by up to 120% for Interpolation = 'nearest_neighbor',
    • by up to 150% for Interpolation = 'bilinear',
    • by up to 230% for Interpolation = 'constant' and Interpolation = 'weighted', and
    • by up to 80% for Interpolation = 'bicubic' on processors that support AVX2.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default) and if 'avx2_enable' is set to 'true' with set_system (the default on machines that support AVX2).
    The new implementation produces identical results as the old implementation.
    For images of type 'real', the operators are faster
    • by up to 80% for Interpolation = 'nearest_neighbor',
    • by up to 170% for Interpolation = 'bilinear',
    • by up to 280% for Interpolation = 'constant' and Interpolation = 'weighted', and
    • by up to 120% for Interpolation = 'bicubic' on processors that support AVX2.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation is numerically infinitesimally less accurate than the previous implementation. If utmost accuracy is desired, the previous implementation can be selected by setting 'int_zooming' to 'false'.
    Furthermore, affine_trans_region has been accelerated on processors that support AVX2.
    The acceleration is
    • up to 50% for Interpolation = 'nearest_neighbor' and
    • up to 110% for Interpolation = 'constant'.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default) and if 'avx2_enable' is set to 'true' with set_system (the default on machines that support AVX2).
    The new implementation produces identical results as the old implementation.
  • The following operators have been sped up and parallelized internally when operating on many points:
    affine_trans_pixel, affine_trans_point_2d, affine_trans_point_3d, projective_trans_pixel, projective_trans_point_2d, projective_trans_point_3d, projective_trans_hom_point_3d, project_hom_point_hom_mat3d, project_3d_point, project_point_hom_mat3d, rigid_trans_object_model_3d, affine_trans_object_model_3d, projective_trans_object_model_3d, and get_line_of_sight.
  • The operators binocular_disparity_ms and binocular_distance_ms have been extended and now offer a coarse-to-fine optimization strategy. The coarse-to-fine strategy requires significantly less memory for large images and large disparity ranges. For example, for an image pair with size 3460x2309 and a disparity range of 800, speedups of over 1000% can be expected. However, the generated disparity images are less accurate for the coarse-to-fine strategy than for the default approach. Especially in case of sharp disparity jumps, the discontinuities are preserved less accurately. Furthermore, it is now possible to pass an empty tuple for MinDisparity and MaxDisparity. The respective values are then computed automatically from the passed input images. Moreover, the operators are now interruptible, i.e. they can be canceled in HDevelop. The HDevelop example program hdevelop/3D-Reconstruction/Binocular-Stereo/binocular_disparity_ms.hdev has been extended to highlight the new functionality.
  • compare_variation_model and compare_ext_variation_model for all supported image object types ('byte', 'int2', and 'uint2') have been optimized to use the Arm Neon instruction set extension. On a Cortex A73 processor, the operator is now 220% faster for 'byte' images.
  • compare_variation_model and compare_ext_variation_model are now faster for all supported image types ('byte', 'int2', and 'uint2') on Intel compatible processors that support AVX2. In particular, the following speedups can be expected compared to the standard C implementation:
    Image Type Operator Mode Available Instruction Set Speedup
    byte compare_variation_model - AVX2 up to 475%
    int2   -   up to 625%
    uint2   -   up to 550%
             
    byte compare_ext_variation_model 'absolute'   up to 400%
    int2       up to 550%
    uint2       up to 500%
    byte   'light', 'dark'   up to 700%
    int2       up to 250%
    uint2       up to 250%
    byte    'light_dark'   up to 675%
    int2       up to 550%
    uint2       up to 380%
     
  • derivate_gauss for all image types is now supported on computers that support the AVX512F instruction set. For 'byte' images, the operator is 30% faster than the implementation in AVX2.
  • The following operators run faster now:
    • div_image on 'byte' images is faster by up to 17%, on 'real' images up to 9%, and on 'int2' images up to 23%
    • invert_image is faster by up to 6%
    • sub_image on byte images is faster by up to 13%, on uint2 images up to 15%
    • derivate_gauss with the 'laplace' parameter value is faster by up to 23%
    • edges_color with the 'canny' parameter value on 'byte' images is faster by up to 15%
    • mirror_image with the 'mirror' parameter value on 'byte' images is faster by up to 21%
    • gen_gauss_pyramid on 'int2' images is faster by up to 150% ('min','max'), 230% ('constant'), or 215% ('weighted'), and on 'byte' images up to 87% ('weighted')
    • binomial_filter on 'byte' images is faster by up to 7%, on 'uint2' images up to 10%, and on 'real' images up to 16%
    • median_image on 'int2', 'uint2', or 'int4' images is faster by up to 36% (for 'circle', 'mirrored')
    • median_separate on 'int2', 'uint2', or 'int4' images is faster by up to 10% (for 'mirrored')
    • rank_image on 'int2','uint2', or 'int4' images is faster by up to 40% (for 'mirrored')
    • smooth_image on 'byte' images is faster by up to 9% (for 'deriche1','deriche2','shen')
    • convert_image_type for 'byte' to 'real' is faster by up to 98%, for 'real' to 'byte' up to 50%, and for 'byte' to 'uint2' or 'real' to 'uint2' up to 46%.
    • dual_rank on 'uint2' images is faster by up to 17%
    • gray_closing_rect on 'byte' images is faster by up to 80%, on 'real' images up to 19%
    • gray_closing_shape on 'byte' images is faster by up to 50% (for 'rectangle')
    • gray_dilation_rect on 'byte' images is faster by up to 67%, on 'real' images up to 17%, on 'int4' images up to 168%, and on 'int2' images up to 230%
    • gray_dilation_shape on 'byte' images is faster by up to 47% (for 'rectangle')
    • gray_erosion_rect on 'byte' images is faster by up to 68%, on 'real' images up to 22%
    • gray_erosion_shape on 'byte' images is faster by up to 50% (for 'rectangle')
    • gray_opening_rect on 'byte' images is faster by up to 68%, on 'real' images up to 20%, on 'int2' images up to 43%, and on 'int4' images up to 70%
    • gray_opening_shape on 'byte' images is faster by up to 50% (for 'rectangle')
    • gray_range_rect on 'byte' images is faster by up to 62%, on 'real' images up to 20%, on 'int2' images up to 110%, and on 'int4' images up to 80%
    • affine_trans_region is faster by up to 100% (Interpolation: 'nearest_neighbor')
    • projective_trans_region is faster by up to 46% for 'bilinear' interpolation
    • partition_dynamic is faster by up to 64%
    • threshold on 'byte' images is faster by up to 10%, on 'real' images up to 9%, on 'int1' images up to 46%
    • threshold_sub_pix on 'real' images is faster by up to 18%
    • fuzzy_measure_pairing on 'byte' and 'uint2' images is faster by up to 20%
    • volume_object_model_3d_relative_to_plane is faster by up to 18% (for 'signed' method)
    • sort_contours_xld is faster by up to 33%
  • find_data_code_2d has been accelerated for Data Matrix ECC200 codes on multi-core systems. It now supports the parallel execution of multiple parameter sets. Thus, a significant speedup can be expected if one or several of the generic parameters 'polarity', 'contrast_tolerance', or 'finder_pattern_tolerance' are set to 'any', or if the values for 'module_gap_min' and 'module_gap_max' differ. This applies in particular if 'default_parameters' is set to 'enhanced_recognition' or 'maximum_recognition' with create_data_code_2d_model or set_data_code_2d_param. Compared to HALCON 19.05 a speedup of
    • 30 to 70% with enhanced settings, and
    • 60 to 240% with maximum settings
    for 2 to 8 threads can be achieved. Please note, that the memory consumption increases with the number of parallel running threads. The number of threads can be controlled with the corresponding set_system parameters. In addition, it is possible to disable the Data Matrix ECC 200 specific parallelization by setting the new generic parameter 'specific_parallelization' of find_data_code_2d to 'disable'. Per default, 'specific_parallelization' is set to 'enable'.
  • On systems that allow memory prefetching, find_surface_model, refine_surface_model_pose, find_surface_model_image, and refine_surface_model_pose_image are now up to 15% faster, while distance_object_model_3d in voxel mode is up to 30% faster.
  • There is a significant speedup for the following deep learning procedures, especially for long input or output tuples:
    • find_dl_samples
    • split_dl_dataset
    • gen_dl_samples
    This also affects other deep learning procedures that use the procedures mentioned above.
  • The x86 CPU inference for deep learning has been rewritten. The extra library hcpudnn.so/.dylib/.dll has been removed and is not needed anymore. Furthermore, support for 32-bit Windows has been removed. The new inference is faster in some cases; especially object detection is faster by up to 400% in some cases. Note that this change affects the compatibility. Read more.
  • get_object_model_3d_params now returns pure tuples for some parameters, such as coordinates, normals, and mappings, which can speed up subsequent processing of such attributes by up to 260%.
  • gray_erosion_rect, gray_dilation_rect, gray_opening_rect, gray_closing_rect, gray_erosion_shape, gray_dilation_shape, gray_opening, and gray_closing_shape with parameter 'MaskShape' set to 'rectangle' are now faster for 'uint2' images on Intel compatible processors that support SSE2 or AVX2, depending on the image size and mask dimensions.
    In particular, the following speedups can be expected for a 1600x1200 image compared to the previously available SSE2 implementation:
    MaskHeight x
    MaskWidth
    Morphological
    operation
    Speedup
    without
    Parallelization
    and with SSE2
    (Windows/Linux)
    Speedup
    without
    Parallelization
    and with AVX2
    (Windows/Linux)
    Speedup
    with 8/2-Thread
    Parallelization
    and with SSE2
    (Windows/Linux)
    Speedup
    with 8/2-Thread
    Parallelization
    and with AVX2
    (Windows/Linux)
    3x3 erosion/dilation 10%/5% 85%/100% 150%/80% 160%/160%
    5x5 erosion/dilation 5%/5% 160%/195% 115%/50% 190%/275%
    7x7 erosion/dilation 15%/12% 205%/230% 100%/45% 265%/290%
    9x9 erosion/dilation 10%/7% 185%/203% 85%/30% 200%/270%
    11x11 erosion/dilation 3%/ -5% 120%/125% 25%/15% 85%/135%
    13x13 erosion/dilation 5%/ 0% 145%/160% 60%/15% 140%/160%
    1x3 erosion/dilation 100%/145% 105%/150% 100%/145% 105%/150%
    3x1 erosion/dilation 90%/170% 105%/140% 90%/170% 105%/140%
    1x11 erosion/dilation 3%/30% 5%/40% 3%/30% 5%/40%
    11x1 erosion/dilation -5%/3% -5%/3% -5%/3% -5%/3%
    3x5 erosion/dilation 60%/75% 65%/75% 60%/75% 65%/75%
    5x3 erosion/dilation 60%/70% 65%/90% 60%/70% 65%/90%
               
               
    3x3 opening/closing -5%/0% 50%/85% 80%/70% 80%/110%
    5x5 opening/closing -4%/0% 120%/185% 90%/45% 120%/190%
    7x7 opening/closing 5%/5% 165%/220% 80%/30% 150%/255%
    9x9 opening/closing 4%/5% 155%/200% 70%/35% 180%/250%
    11x11 opening/closing -5%/ -5% 105%/130% 15%/10% 70%135%
    13x13 opening/closing -4%/0% 130%/160% 40%/15% 105%/175%
    1x3 opening/closing 80%/100% 75%/100% 80%/100% 75%/100%
    3x1 opening/closing 80%/90% 75%/70% 80%/90% 75%/70%
    Note that, previously, values outside the domain have been calculated in the unparallelized case that led to well defined pixel values outside the actual image domain. Now, the image only contains pixel values in the actual domain. Please note that the new SSE2 implementation for filter masks 1xN (e.g., 1x3, 1x5, ...) and for filter masks 3xN (e.g., 3x3, 3x5, ...) can be slightly slower than the old SSE2 implementation.
  • gray_erosion_rect, gray_dilation_rect, gray_opening_rect, gray_closing_rect, gray_erosion_shape, gray_dilation_shape, gray_opening, and gray_closing_shape with parameter 'MaskShape' set to 'rectangle' are now faster for 'byte' images on Intel compatible processors that support SSE2 or AVX2, depending on the image size and mask dimensions.
    In particular, the following speedups can be expected for a 1600x1200 image compared to the previously available SSE2 implementation:
    MaskHeight x
    MaskWidth
    Morphological
    operation
    Speedup
    without
    Parallelization
    and with SSE2
    (Windows/Linux)
    Speedup
    without
    Parallelization
    and with AVX2
    (Windows/Linux)
    Speedup
    with xx-Thread
    Parallelization
    and with SSE2
    (Windows/Linux)
    Speedup
    with xx-Thread
    Parallelization
    and with AVX2
    (Windows/Linux)
    3x3 erosion/dilation 0%/-10 25%/60% 50%/30% 90%/75%
    5x5 erosion/dilation 25%/15% 85%/110% 45%/35% 130%/135%
    7x7 erosion/dilation 60%/45% 135%/175% 65%/65% 145%/180%
    9x9 erosion/dilation 60%/60% 120%/175% 65%/80% 140%/180%
    11x11 erosion/dilation 20%/20% 80%/100% 30%/30% 80%/115%
    13x13 erosion/dilation 10%/15% 55%/85% 15%/25% 55%/105%
    1x3 erosion/dilation -8%/-10% 2%/10% 75%/50% 80%/75%
    3x1 erosion/dilation 5%/30% 15%/55% 90%/55% 100%/110%
    1x11 erosion/dilation -10%/ -15% 5%/5% 0%/0% 10%/15%
    11x1 erosion/dilation 5%/25% 15%/55% 20%/40% 30%/50%
    3x5 erosion/dilation -10%/-10% 10%/35% 35%/20% 65%/70%
    5x3 erosion/dilation 0%/5% 20%/55% 40%/35% 65%/95%
               
               
    3x3 opening/closing 0%/-5% 30%/65% 65%/35% 100%/130%
    5x5 opening/closing 25%/15% 80%/125% 70%/50% 150%/190%
    7x7 opening/closing 45%/40% 110%/175% 75%/60% 150%/220%
    9x9 opening/closing 50%/50% 100%/160% 75%/70% 160%/195%
    11x11 opening/closing 10%/5% 60%/75% 30%/15% 75%/85%
    13x13 opening/closing 0%/2% 45%/65% 15%/11% 60%/75%
    1x3 opening/closing -10%/-15% 0%/3% 80%/65% 95%/100%
    3x1 opening/closing 10%/30% 20%/55% 80%/40% 90%/120%
    Please note that the new SSE2 implementation for filter masks 1xN (e.g., 1x3, 1x5, ...) and for filter masks 3xN (e.g., 3x3, 3x5, ...) can be slightly slower than the old SSE2 implementation. This is simply due to a behavior change in the algorithm. Previously, values outside the domain have been calculated in the unparallelized case that led to well defined pixel values outside the actual image domain. Now, the image only contains pixel values in the actual domain.
  • list_files is now faster on Unix systems by a factor of at least 2.
  • mean_image has been accelerated for 'byte' images.
  • mirror_image with 'byte' images, Mode='col', and image widths that are a multiple of 4 is now faster on Intel x86 compatible machines. The speedup is up to 270%.
    Furthermore, mirror_image is now faster with 'byte' images, Mode='col' on Intel compatible processors that support AVX2 or SSSE3. In particular, the speedup is up to 450%.
  • polar_trans_image_ext has been accelerated on processors that support AVX2.
    For images of type 'byte', polar_trans_image_ext is faster
    • by up to 120% for Interpolation = 'nearest_neighbor' and
    • by up to 70% for Interpolation = 'bilinear' on processors that support AVX2.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default) and if 'avx2_enable' is set to 'true' with set_system (the default on machines that support AVX2).
    The new implementation produces identical results as the old implementation.
    For images of type 'uint2', polar_trans_image_ext is faster
    • by up to 140% for Interpolation = 'nearest_neighbor' and
    • by up to 160% for Interpolation = 'bilinear' on processors that support AVX2.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default) and if 'avx2_enable' is set to 'true' with set_system (the default on machines that support AVX2).
    The new implementation produces identical results as the old implementation.
    For images of type 'int2', polar_trans_image_ext is faster
    • by up to 130% for Interpolation = 'nearest_neighbor' and
    • by up to 150% for Interpolation = 'bilinear' on processors that support AVX2.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default) and if 'avx2_enable' is set to 'true' with set_system (the default on machines that support AVX2).
    The new implementation produces identical results as the old implementation.
    For images of type 'real', polar_trans_image_ext is faster
    • by up to 230% for Interpolation = 'nearest_neighbor' and
    • by up to 180% for Interpolation = 'bilinear' on processors that support AVX2.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation is numerically infinitesimally less accurate than the previous implementation. If utmost accuracy is desired, the previous implementation can be selected by setting 'int_zooming' to 'false'.
    Furthermore, polar_trans_region has been accelerated on processors that support AVX2.
    • The acceleration is up to 50% for Interpolation = 'nearest_neighbor' and Interpolation = 'bilinear'.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default) and if 'avx2_enable' is set to 'true' with set_system (the default on machines that support AVX2).
    The new implementation produces identical results as the old implementation.
  • polar_trans_image_inv has been accelerated on all processors
    • by more than 30% for all image types and all interpolation modes
      by an internal implementation that uses slightly less accurate floating-point calculations.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation is numerically infinitesimally less accurate than the previous implementation. If utmost accuracy is desired, the previous implementation can be selected by setting 'int_zooming' to 'false'.
    Furthermore, the new implementation has been accelerated on processors that support AVX2.
    The acceleration for Interpolation = 'nearest_neighbor' is more than 550% for all supported image types ('byte', 'int2', 'uin2', and 'real').
    For Interpolation = 'bilinear', the acceleration is
    • up to 400% for 'byte' images,
    • up to 600% for 'int2' and 'uint2' images, and
    • up to 550% for 'real' images.
    Furthermore, polar_trans_region_inv has been accelerated. On processors that do not support AVX2, the acceleration is
    • up to 35%.
    On processors that support AVX2, the acceleration is
    • up to 450% for Interpolation = 'nearest_neighbor' and
    • up to 350% for Interpolation = 'bilinear'.
    The new implementations are selected if 'int_zooming' is set to 'true' with set_system (the default).
  • projective_trans_image and projective_trans_image_size have been accelerated on processors that support the Arm NEON instruction set.
    On 32-bit Arm systems, the acceleration for images of type byte and uint2 is
    • up to 50% for Interpolation = 'nearest_neighbor' and
    • up to 150% for Interpolation = 'bilinear'.
      On 64-bit Arm systems, the acceleration for images of type byte and uint2 is
    • up to 20% for Interpolation = 'nearest_neighbor' and
    • up to 50% for Interpolation = 'bilinear'.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation is numerically significantly more accurate than the previous implementation.
    The previous implementation cannot be selected any longer.
    On 32-bit Arm systems, the acceleration for images of type real is
    • up to 250% for both interpolation modes.
      On 64-bit Arm systems, the acceleration is
    • up to 230% for nearest-neighbor interpolation and
    • up to 130% for bilinear interpolation.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation is numerically infinitesimally less accurate than the previous implementation. If utmost accuracy is desired, the previous implementation can be selected by setting 'int_zooming' to 'false'.
    Furthermore, projective_trans_region has been accelerated on processors that support the Arm NEON instruction set.
    On 32-bit Arm systems, the acceleration is
    • up to 60% for Interpolation = 'nearest_neighbor' and
    • up to 150% for Interpolation = 'bilinear'.
      On 64-bit Arm systems, the acceleration is
    • up to 20% for Interpolation = 'nearest_neighbor' and
    • up to 50% for Interpolation = 'bilinear'.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation is numerically significantly more accurate than the previous implementation.
    The previous implementation cannot be selected any longer.
  • projective_trans_image and projective_trans_image_size have been accelerated on processors that support AVX2.
    The acceleration for images of type 'byte' is
    • up to 100% for Interpolation = 'nearest_neighbor' and
    • up to 250% for Interpolation = 'bilinear'.
    The acceleration for images of type 'uint2' is
    • up to 100% for Interpolation = 'nearest_neighbor' and
    • up to 400% for Interpolation = 'bilinear'.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default). The new implementation is numerically significantly more accurate than the previous implementation.
    The previous implementation cannot be selected any longer.
    The acceleration for images of type 'real' is
    • up to 300% for both interpolation modes.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation is numerically infinitesimally less accurate than the previous implementation. If utmost accuracy is desired, the previous implementation can be selected by setting 'int_zooming' to 'false'.
    Furthermore, projective_trans_region has been accelerated on processors that support AVX2. The acceleration is
    • up to 90% for Interpolation = 'nearest_neighbor' and
    • up to 200% for Interpolation = 'bilinear'.
    The new implementation is selected if 'int_zooming' is set to 'true' with set_system (the default).
    The new implementation is numerically significantly more accurate than the previous implementation.
    The previous implementation cannot be selected any longer.
  • The operator read_object_model_3d is now able to read binary PLY files that contain previously unsupported elements and properties. If possible, such items are converted into extended attributes while reading. Additionally, reading PLY files is now up to 380% faster when reading PLY ASCII files and up to 72% faster when reading binary PLY files that contain faces.
  • The operator reconstruct_surface_stereo now takes the image domain into account.
  • rotate_image is now faster for 90 and 270 degrees. For 'byte' images the speedup is up to 150% on AVX2 capable machines. For 'int2'/'uint2' images the speedup is up to 90% on SSE2 capable machines. For 'real' images the speedup is up to 50% on SSE2 capable machines.
  • set_dl_model_param has been extended to set the parameter 'fuse_bn_relu'.
    If this parameter is set to 'true', each of the batch normalization and activation layers in a deep learning network will be fused. Currently, only ReLU activation is supported. As a consequence, the runtime for the inference and for a training step can be reduced. This function has been adapted for the following delivered networks:
    • initial_dl_anomaly_medium.hdl: Speedup up to 12 % for inference and up to 15 % for a training step.
    • initial_dl_anomaly_large.hdl: Speedup up to 13 % for inference and up to 1 % for a training step.
    • pretrained_dl_classifier_resnet50.hdl: Speedup up to 15 % for inference and up to 8 % for a training step.
    • pretrained_dl_segmentation_compact.hdl: Speedup up to 15 % for inference and up to 7 % for a training step.
    • pretrained_dl_segmentation_enhanced.hdl: Speedup up to 19 % for inference and up to 14 % for a training step.
    Note that this change affects the compatibility. Read more.
  • sobel_amp for FilterType='sum_abs' is now faster on processors that support the AVX2 instruction set. Using a filter size of 3, the speedup for byte images with a size of 512x512 is up to 45% and up to 30% for images of size 1600x1200. For larger filter sizes, the speedup is slightly less.
  • threshold and dyn_threshold have been optimized for the Arm Neon instruction set extension for 'byte' and 'uint2' image types, for both 32 and 64 bit Arm systems. For the threshold operator, operations on float images have been optimized as well. On Cortex A73 processors, for 'byte' images threshold operations are up to 200% faster, while dyn_threshold operations are up to 180-250% faster, depending on the mode.
  • train_class_gmm is now significantly faster when training a classifier with a single class. Furthermore, train_class_gmm is now also parallelized on an internal data level when training a classifier with a single class.
    The achievable speedup depends on the number of available threads and the selected covariance matrix type.
    The following speedups can be expected for classifiers with high-dimensional training data (n=25) and a large amount of training data (>100.000) with the following exemplary configurations:
    Number threads Speedup for covariance 'diag' Speedup for covariance 'full'
    1 139% 306%
    2 261% 535%
    4 341% 957%
    8 375% 1530%
    16 463% 2346%
    As a result, train_texture_inspection_model is now also significantly faster when executed either in parallel or with a single thread.
  • train_dl_model_anomaly_dataset has been improved and is now faster. A speedup up to 900% and 1500% can be expected for CPU and GPU training, respectively.
  • The speed of the operators watersheds, watersheds_threshold, and watersheds_marker has been significantly improved if a reduced domain is used.
    Now, depending on the size of the image and the reduced domain, it is up to 2300 % faster.
    Note that this change affects the compatibility. Read more.
  • The performance of the operators watersheds and watersheds_threshold has been improved for images of type 'real'. watersheds is now up to 35% faster, watersheds_threshold is up to 33% faster.
  • Reading and writing of JPEG images is now faster by up to 30% on AVX2 capable processors.
  • The thirdparty Arm Compute Library (ACL) has been updated from version 18.11 to 19.08. The BatchNorm layer was included. As a result, the delivered deep learning segmentation networks and detection networks can be accelerated by up to 5 %.
  • The pretrained deep learning models used in semantic segmentation have been significantly improved:
    • dl/pretrained_dl_segmentation_compact.hdl
    • dl/pretrained_dl_segmentation_enhanced.hdl
    Inference speed is improved by 30-45% on GPUs, 90-190% on CPUs, and 90% on Arm®. Additionally, the training is faster and leads to improved results in all our tested application cases. Furthermore, please note that the minimal allowed input image size of the "enhanced" network has been lowered from 81 to 47 pixels in width and height. Note that this change affects the compatibility. Read more.
  • Reading big datasets was rather slow. This problem has been fixed.
  • The inference speed of the anomaly detection models initial_dl_anomaly_medium.hdl and initial_dl_anomaly_large.hdl has been improved by up to 50% on GPUs and up to 30% on CPUs.

New Functionality

3D
  • The operators for surface-based matching have been improved to better handle objects with self-similarities, i.e., objects that look similar under different poses. When activating the parameter 'train_self_similar_poses' in the operator create_surface_model, the model will automatically be analyzed for such poses, and they will be better resolved when calling find_surface_model, find_surface_model_image, refine_surface_model_pose, or refine_surface_model_pose_image.
  • object_model_3d_to_xyz has been extended by the new type 'cartesian_faces', which transforms the triangles of one or more 3D object model(s) into three densely filled coordinate images X, Y, and Z.
    The new HDevelop example program hdevelop/3D-Object-Model/Segmentation/reduce_object_model_3d_to_visible_parts.hdev shows how to use the new type to reduce a 3D object model to the triangles visible for a virtual camera.
  • The operator set_stereo_model_param now supports the parameters 'min_disparity' and 'max_disparity'.
  • The operators find_surface_model, find_surface_model_image, refine_surface_model_pose, and refine_surface_model_pose_image now accept multiple values in their MinScore argument. Those values can be used to set minimum scores for the surface overlap, the 3D edge overlap, and for image-based operators, the 2D edge overlap. Additionally, the values of these scores can be obtained using the operator get_surface_matching_result. The visualization of the corresponding surface matching result handles in the handle inspection windows has been adapted accordingly.
    The HDevelop example program hdevelop/3D-Matching/Surface-Based/find_surface_model_with_edges.hdev has been extended to show the new functionality.
  • HALCON has been extended with the operator find_box_3d, which enables the detection, localization, and length measurement of boxes of various sizes in 3D data.
    The new HDevelop example program hdevelop/3D-Matching/3D-Box/find_box_3d.hdev demonstrates the new functionality.
    The new procedure debug_find_box_3d has been added, which allows debugging the parameters for the 3D box finder. The procedure is included in the existing library procedures/general/debug_find_surface_model.hdpl.
  • Surface models that have been created for edge-supported surface-based matching and refinement can now also be used without edge support. This allows to use the same surface model for both edge-supported and non-edge-supported matching. For this, the operators find_surface_model, find_surface_model_image, refine_surface_model_pose, and refine_surface_model_pose_image accept the new generic parameter 'use_3d_edges'.
  • The operator reconstruct_surface_stereo now takes the image domain into account.
  • The operator read_object_model_3d is now able to read binary PLY files that contain previously unsupported elements and properties. If possible, such items are converted into extended attributes while reading. Additionally, reading PLY files is now up to 380% faster when reading PLY ASCII files and up to 72% faster when reading binary PLY files that contain faces.
  • Surface-based matching has been extended to be able to calculate a view-based score during the matching and pose refinement step. For this, HALCON has been extended such that the operator create_surface_model can be used to prepare the model for view-based score calculation. Additionally, the operators find_surface_model, find_surface_model_image, refine_surface_model_pose, and refine_surface_model_pose_image now accept an additional value for their MinScore argument. This value can be used to set a minimum score for the view-based overlap. Further, the value of this score can be obtained using the operator get_surface_matching_result. The visualization of the corresponding surface matching result handles in the Handle Inspect window has been adapted accordingly. The new HDevelop example program hdevelop/3D-Matching/Surface-Based/find_surface_model_view_based_score.hdev shows how to use the new functionality. The procedure debug_surface_based_matching has been extended to check the visibility of the scene based on the current viewpoint. The HDevelop example program hdevelop/3D-Matching/Surface-Based/debug_find_surface_model.hdev has been extended accordingly. Note that this change affects the compatibility. Read more.
  • sample_object_model_3d now includes a new sampling mode that uses the XYZ-mapping of the 3D object model to speed up the sampling. This mode can be activated with the two new parameters 'xyz_mapping' and 'xyz_mapping_compute_normals'. The new HDevelop example program hdevelop/Object-Model-3D/Segmentation/sample_object_model_3d.hdev shows the different sampling strategies that are supported by sample_object_model_3d.
  • HALCON has been extended with the operators remove_object_model_3d_attrib and remove_object_model_3d_attrib_mod. They provide the functionality to remove standard or extended (user-defined) attributes to reduce memory consumption of 3D object models.
    The HDevelop example program hdevelop/3D-Object-Model/Creation/set_object_model_3d_attrib.hdev has been extended to show how to use the new operators.
  • select_points_object_model_3d now accepts a tuple of numbers instead of an attribute name as input on which the threshold is applied. This allows to select points based on some mask without first setting that mask as attribute in the 3D object model. The HDevelop example program hdevelop/3D-Object-Model/Segmentation/select_points_object_model_3d.hdev has been extended to show this new functionality.
  • reduce_object_model_3d_by_view now allows to use the existing XYZ mapping of a 3D object model instead of a virtual camera.
  • The documentation has been extended by a new technical note "Surface-Based Matching". It contains information about different methods, troubleshooting, and further useful information regarding surface-based matching.
  • The usability of find_surface_model and its derivations find_surface_model_image and find_deformable_surface_model has been improved. Now, the normals of the object model 3d scene can be inverted with the new generic parameter 'scene_invert_normals'.
  • triangulate_object_model_3d with Method set to 'xyz_mapping' has been improved. Now, the operator provides new parameters to apply a post-processing step that removes triangles whose normals differ strongly from a specified direction.
    The new HDevelop example program hdevelop/3D-Object-Model/Transformations/triangulate_object_model_3d_xyz_mapping.hdev shows how to obtain a mesh from a 2D mapping contained in a 3D object model. Note that this change affects the compatibility. Read more.
  • triangulate_object_model_3d with Method set to 'xyz_mapping' or 'greedy' now only returnes points which are actually used in the output triangulation. Note that this change affects the compatibility. Read more.
  • prepare_object_model_3d has been extended with the new Purpose 'gen_xyz_mapping', that computes XYZ-mapping for 3D object models containing ordered point clouds. Also, prepare_object_model_3d now returns an error if a generic parameter that is not valid for the Purpose is set.
  • The reference manual entry of find_surface_model was pruned by removing the description of the GenParamName 'score_type'. The default behavior of 'score_type' is sufficient for the use of the operator. Nevertheless, the parameter remains functioning to maintain backwards compatibility.
  • The Solution Guide on 3D Vision has been extended with information about the benefits of using 2D mappings when handling 3D objects.
  • The procedure debug_find_surface_model has been improved. Now, the menu text is scaled and positioned according to the user setting 'WindowScaling'. Additionally, the menu colors have been changed. Note that this change affects the compatibility. Read more.
  • The usability of copy_object_model_3d has been improved. Now, the attribute names are similar to the get/set-operators for 3D object models. The old attribute names continue to work but are legacy from now on.
  • reduce_object_model_3d_by_view previously required to pass the string 'xyz_mapping' as camera parameters to use the mapping for point selection. Now, an empty tuple can be passed as camera parameters as well.
  • HALCON now supports multi-view and binocular stereo when using line-scan cameras with telecentric lenses.
    The new HDevelop example program hdevelop/Calibration/Multi-View/calibrate_cameras_telecentric_line_scan_stereo.hdev shows how to use the new functionality.
  • find_box_3d has been improved to yield more robust and intuitive results. Furthermore, find_box_3d is now independent of a viewpoint and the position of the input point cloud in space, i. e., independent of grayvalues and coordinate frames in the XYZ-images. The returned GrippingPose is set according to the XYZ-mapping. For certain scenes and configurations, find_box_3d is faster than in previous HALCON versions. Note that this change affects the compatibility. Read more.
  • The handle inspect window can now show the content of 3D scenes (semantic type scene_3d).
    The operators get_handle_param, get_handle_tuple, and get_handle_object have been extended accordingly.
  • disparity_image_to_xyz is now more accurate for telecentric cameras.
  • The new HDevelop example programs
    • hdevelop/3D-Object-Model/Segmentation/remove_background_for_3d_object_localization.hdev and
    • hdevelop/3D-Object-Model/Segmentation/remove_bin_for_3d_object_localization.hdev
    show how to remove the background or bin, respectively, from a scene that was acquired with a 3D sensor. In both cases, several different methods are presented to cover different use cases.
  • edges_object_model_3d is now by default independent of a viewpoint and the position of the input point cloud in space. The new GenParamName 'estimate_viewpose' can be set to 'false' to still set a manual viewpoint. Note that this change affects the compatibility. Read more.
  • In edge-supported surface-based matching, usability has been improved for the following operators: find_surface_model, find_surface_model_image, refine_surface_model_pose, and refine_surface_model_pose_image. In particular:
    • They are now independent of a viewpoint. GenParamName can still contain 'viewpoint' but it only affects the calculation of the view-based score if 'use_view_based' is set to 'true'.
    • They are now independent of the position of the input point cloud in space, i. e., independent of gray values and coordinate frames in the XYZ images. However, note that HALCON assumes right-handed coordinate systems.
    • They automatically generate scene normals flipped inwards consistently w.r.t. the mapping (only relevant for the find_* operators).
    Furthermore, find_surface_model, find_surface_model_image, refine_surface_model_pose, and refine_surface_model_pose_image have been sped up. Especially for the edge-supported surface-based matching, a significant speedup can be expected when multiple small objects are scattered within a large scene. For the standard surface-based matching, a performance improvement can be expected when the scene exhibits a large number of points. Note that this change affects the compatibility. Read more.
  • get_object_model_3d_params now returns pure tuples for some parameters, such as coordinates, normals, and mappings, which can speed up subsequent processing of such attributes by up to 260%.
  • In the stereo model, the default value for the parameter 'rectif_interpolation' has been changed from 'none' to 'bilinear'. Note that this change affects the compatibility. Read more.
  • The operators binocular_disparity_ms and binocular_distance_ms have been extended and now offer a coarse-to-fine optimization strategy. The coarse-to-fine strategy requires significantly less memory for large images and large disparity ranges. For example, for an image pair with size 3460x2309 and a disparity range of 800, speedups of over 1000% can be expected. However, the generated disparity images are less accurate for the coarse-to-fine strategy than for the default approach. Especially in case of sharp disparity jumps, the discontinuities are preserved less accurately. Furthermore, it is now possible to pass an empty tuple for MinDisparity and MaxDisparity. The respective values are then computed automatically from the passed input images. Moreover, the operators are now interruptible, i.e. they can be canceled in HDevelop. The HDevelop example program hdevelop/3D-Reconstruction/Binocular-Stereo/binocular_disparity_ms.hdev has been extended to highlight the new functionality.
Bar Code
  • The handle inspect window can now show information about the results and candidates of barcodes (semantic type barcode).
    The operators get_handle_param, get_handle_tuple, and get_handle_object have been extended accordingly.
  • The bar code reader now decodes codes with very small (<1.3 pixel) element sizes more robustly and is even able to read codes with element sizes smaller than one pixel. To do so, an additional decoding algorithm is performed, which is specialized for small elements and works for (non-stacked) codes without occlusions. For this algorithm, it is beneficial to slightly rotate the camera sensor with respect to the bar code. To activate the feature, the parameter 'small_elements_robustness' has to be set to 'true' and additionally 'element_size_min' has to be set to a value smaller than 2.0 (via set_bar_code_param). Per default, 'small_elements_robustness' is set to 'true'. To get information about the decoding status of bar codes with very small element sizes, the operator get_bar_code_result has been extended with the parameter 'status_small_elements_robustness'.
    The new HDevelop example program hdevelop/Identification/Bar-Code/barcode_small_elements_robustness.hdev shows the decoding of bar codes with very small element sizes.
    Additionally, the HDevelop example program hdevelop/explore_halcon.hdev has been adapted to show the new functionality.
    The custom HPeek demo has been extended by the sub-pixel barcode reader feature example. You can download this demo on our customer area for free and evaluate the performance on your hardware.
  • HALCON now supports the GS1 application identifier 395x.
Calibration
  • HALCON has been extended by a new camera model for line scan cameras with telecentric lenses:
    • 'line_scan_telecentric_division'
    • 'line_scan_telecentric_polynomial'.
    New HDevelop procedures to generate camera parameter tuples for each camera type have been added:
    • gen_cam_par_line_scan_telecentric_division
    • gen_cam_par_line_scan_telecentric_polynomial.
    The new HDevelop example program hdevelop/Calibration/Multi-View/line_scan_telecentric_calibration.hdev shows how to use the new functionality.
    The HDevelop Calibration Assistant has been extended accordingly.
  • HALCON now supports multi-view and binocular stereo when using line-scan cameras with telecentric lenses.
    The new HDevelop example program hdevelop/Calibration/Multi-View/calibrate_cameras_telecentric_line_scan_stereo.hdev shows how to use the new functionality.
  • The following operators have been sped up and parallelized internally when operating on many points:
    affine_trans_pixel, affine_trans_point_2d, affine_trans_point_3d, projective_trans_pixel, projective_trans_point_2d, projective_trans_point_3d, projective_trans_hom_point_3d, project_hom_point_hom_mat3d, project_3d_point, project_point_hom_mat3d, rigid_trans_object_model_3d, affine_trans_object_model_3d, projective_trans_object_model_3d, and get_line_of_sight.
  • The reference manual entry of create_caltab did not give sufficient information about the distribution of finder patterns on a calibration plate. The reference has been adapted accordingly.
  • The new HDevelop example program hdevelop/Tools/Mosaicking/two_camera_calibrated_mosaicking.hdev shows how accurate mosaicking can be easily performed using the standard HALCON calibration plate with hexagonally arranged marks. It requires the 28 new images from the subdirectory images/3d_machine_vision/calibrated_mosaic.
  • HALCON's camera models for perspective line scan cameras now support the polynomial distortion model. Consequently, there are two perspective line scan camera models in HALCON:
    • 'line_scan_division'
    • 'line_scan_polynomial'.
    New HDevelop procedures to generate camera parameter tuples for each camera type have been added:
    • gen_cam_par_line_scan_division
    • gen_cam_par_line_scan_polynomial.
    The HDevelop Calibration Assistant has been extended accordingly. Note that this change affects the compatibility. Read more.
Classification
  • train_class_gmm is now significantly faster when training a classifier with a single class. Furthermore, train_class_gmm is now also parallelized on an internal data level when training a classifier with a single class.
    The achievable speedup depends on the number of available threads and the selected covariance matrix type.
    The following speedups can be expected for classifiers with high-dimensional training data (n=25) and a large amount of training data (>100.000) with the following exemplary configurations:
    Number threads Speedup for covariance 'diag' Speedup for covariance 'full'
    1 139% 306%
    2 261% 535%
    4 341% 957%
    8 375% 1530%
    16 463% 2346%
    As a result, train_texture_inspection_model is now also significantly faster when executed either in parallel or with a single thread.
Data Code
  • find_data_code_2d has been accelerated for Data Matrix ECC200 codes on multi-core systems. It now supports the parallel execution of multiple parameter sets. Thus, a significant speedup can be expected if one or several of the generic parameters 'polarity', 'contrast_tolerance', or 'finder_pattern_tolerance' are set to 'any', or if the values for 'module_gap_min' and 'module_gap_max' differ. This applies in particular if 'default_parameters' is set to 'enhanced_recognition' or 'maximum_recognition' with create_data_code_2d_model or set_data_code_2d_param. Compared to HALCON 19.05 a speedup of
    • 30 to 70% with enhanced settings, and
    • 60 to 240% with maximum settings
    for 2 to 8 threads can be achieved. Please note, that the memory consumption increases with the number of parallel running threads. The number of threads can be controlled with the corresponding set_system parameters. In addition, it is possible to disable the Data Matrix ECC 200 specific parallelization by setting the new generic parameter 'specific_parallelization' of find_data_code_2d to 'disable'. Per default, 'specific_parallelization' is set to 'enable'.
  • The data code reader now supports DotCode symbols. Furthermore, the GS1 DotCode symbology was introduced to the data code model.
    The new HDevelop example programs
    • hdevelop/Applications/Data-Codes/dotcode_default_settings.hdev and
    • hdevelop/Applications/Data-Codes/dotcode_optimized_settings.hdev
    show how to use the new functionality. They use the new images dotcode_* from the subdirectory images/datacode/dotcode/.
    The following HDevelop example programs have been adapted accordingly:
    • hdevelop/explore_halcon.hdev
    • hdevelop/Identification/Data-Code/2d_data_codes_default_settings.hdev
    • hdevelop/Identification/Data-Code/gs1_data_codes.hdev
    The latter uses the new images gs1dotcode_* from the subdirectory images/datacode/gs1dotcode/.
    Further, the Solution Guide on 2D Data Codes has been extended with information about the DotCode reader.
    For DotCode symbols, the parameter 'candidate_selection' of set_data_code_2d_params was extended by the value 'all'. Additionally, the parameters 'symbology_ident_separated', 'decoded_string_separated', 'structured_append_separated', 'reader_programming_separated', 'decoded_data_separated', and 'segment_num' were added to get_data_code_2d_results such that DotCode symbols with separated message segments are supported. Furthermore, the parameter 'max_allowed_error_correction' was added to set_data_code_2d_param as well as to get_data_code_2d_param.
    The custom HPeek demo has been extended by the DotCode reader. You can download this demo on our customer area for free and evaluate the performance on your hardware.
  • The handle inspect window can now show information about the results and candidates of 2D data codes (semantic type datacode_2d).
    The operators get_handle_param, get_handle_tuple, and get_handle_object have been extended accordingly.
  • The reference manual entry of create_data_code_2d_model contained an incomplete list of parameters that have different default values depending on the chosen recognition approach. This problem has been fixed.
  • HALCON now supports the GS1 application identifier 395x.
  • The ECC 200 code reader now supports the Data Matrix Rectangular Extension, which adds new symbol sizes.
    According to ISO/IEC DIS 21471:2019, these are: 
    • 8 x [48, 64, 80, 96, 120, 144]
    • 12 x [64, 88]
    • 16 x 64
    • 20 x [36, 44, 64]
    • 22 x 48
    • 24 x [48, 64]
    • 26 x [40, 48, 64]

Deep Learning
  • set_dl_model_param has been extended to set the parameter 'batch_size_multiplier' in a model. This new model parameter is used to enable training with larger numbers of images in a single step which otherwise would not be possible due to GPU memory limitations. The parameter 'batch_size_multiplier' does not have any impact during evaluation and inference. Note that the parameter 'batch_size_device' of the deep learning classifier has been replaced by the parameter 'batch_size_multiplier', which has a different semantics. Note that this change affects the compatibility. Read more.
  • apply_dl_model is now independent of the batch size. It can be supplied with an arbitrary number of input images. Further, the processing of the operator can be stopped by external interrupts.
  • The operators set_dl_model_param and get_dl_model_param were extended with the parameter 'input_dimensions', which allows users to change the dimensions of any input layer of the network. This parameter works for any type of network, except for detection.
  • The x86 CPU inference for deep learning has been rewritten. The extra library hcpudnn.so/.dylib/.dll has been removed and is not needed anymore. Furthermore, support for 32-bit Windows has been removed. The new inference is faster in some cases; especially object detection is faster by up to 400% in some cases. Note that this change affects the compatibility. Read more.
  • apply_dl_model provides a new option for the parameter 'Outputs' for models of type 'detection'. In particular, now the bounding box and class predictions of selected levels can be returned.
  • The inference of deep learning networks using apply_dl_classifier and apply_dl_model can now be done on Arm processors.
    A custom HPeek demo has been created, which showcases classification, detection, segmentation, and OCR using deep learning. You can download this demo on our customer area for free and evaluate the performance on your hardware.
    Please consider that the inference on Arm processors uses parallelization and the number of threads can be determined via set_system('thread_num', NumThreads).
    In order to reduce inference times when using Arm processors, the operator create_dl_model_detection has been adapted to create an improved model. The file examples/hdevelop/Deep-Learning/Detection/detect_pills.hdl used for the HDevelop example program for detection has been changed accordingly.
  • HALCON's deep learning core functionality has been moved to the separate library halcondl(xl).dll/libhalcondl(xl).so/libhalcondl(xl).dylib. Applications using HALCON's deep learning functionality must ship this library along with the HALCON library.
  • During the training of a deep learning model, now the learning rate is plotted.
  • The object detection based on deep learning has been extended by the support of a new instance type. Now, the location of an instance and its orientation within the image can be given by an oriented rectangular bounding box. Such oriented bounding boxes are defined using specific parameters, therefore the dataset dictionaries (e.g., DLDataset) use corresponding parameter entries. The new model parameter 'instance_type' has been introduced to distinguish the instance types. For this new instance type the parameter 'ignore_direction' allows you to specify if the model shall return the direction of the instance or only its best fitting bounding box, while the parameter 'class_ids_no_orientation' allows you to specify for which specific class the orientation shall not be considered (e.g., due to spherical symmetry). The workflow for deep-learning-based object detection stays the same, independent of the instance types.
    The HDevelop example program examples/hdevelop/Deep-Learning/Detection/dl_detection_with_orientation_workflow.hdev has been added to show how to use deep-learning-based object detection with oriented bounding boxes in HALCON. It uses the new images in examples/images/screws and the annotations in examples/hdevelop/Deep-Learning/Detection/screws.hdict. The HALCON reference manual has been extended and a set of new local procedures has been added to facilitate the usage of this new instance type.
  • For deep-learning-based classification models it is now possible to extract the feature maps of a selected layer. The new HDevelop example program hdevelop/Deep-Learning/Classification/show_feature_maps_for_dl_classification.hdev shows how this feature can be applied.
  • The deep learning-based classification has been refactored. Now, classification is done using the same operators and workflow as the deep learning methods object detection and semantic segmentation. For this, the existing deep learning model procedures have been extended. The following HDevelop example programs have been added to show how to use deep learning-based classification in HALCON with the model approach:
    • hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_1_preprocess.hdev
    • hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_2_train.hdev
    • hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_3_evaluate.hdev
    • hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_4_infer.hdev
    Additionally, the new HDevelop example program
    • hdevelop/Deep-Learning/Classification/dl_classification_workflow.hdev
    concisely shows the overall workflow reduced to its main parts. The reference manual has been adapted and extended to describe how to use the functionality. The new procedure read_dl_dataset_classification can be used to read annotation data.
    Note that the operator set and procedures using the previous workflow have been set to legacy and the corresponding examples have been removed.
  • The Deep Learning detection parameters 'aspect_ratios' and 'num_subscales', which can be set with create_dl_model_detection have been renamed to 'anchor_aspect_ratios' and 'anchor_num_subscales', respectively.
  • The flexibility of object detection heads has been improved. Now, different weights for class and bounding box heads are supported. These weights can be set with create_dl_model_detection using the parameters "bbox_head_weight" and "class_head_weight".
  • The visualization of the deep learning training information (after the training) has been improved for models of type classification, detection, and segmentation. Now this can be done using the procedure dev_display_dl_model_train_info. Further, additional information is written in the training info dictionaries.
  • HALCON has been extended by the new HDevelop example programs Detection/dl_detection_workflow.hdev and Segmentation/dl_segmentation_workflow.hdev in the subdirectory hdevelop/Deep-Learning, which in few lines show the fundamental workflow of preprocessing a dataset, training a model (respectively detection and segmentation), evaluating the model, and inference on new images.
  • HALCON has been extended with a deep learning procedure determine_dl_model_detection_param. The procedure automatically generates model parameters for deep learning object detection (parameters related to reference anchor boxes) by analyzing the dataset used for training the model. Using the generated parameters, the detection performance as well as the model runtime can be improved.
  • read_dl_model now supports reading ONNX models with arbitrary padding values given in the 'pads' field of the 'Conv', 'AveragePool', and 'MaxPool' operations.
  • HALCON now can read classification networks written in the ONNX format (see https://onnx.ai/) using read_dl_model. The read network is internally converted to a HALCON model and can be used as any other classification model. During the format conversion, some transformations may be applied automatically in order to improve the efficiency. These transformations as well as the existing restrictions are documented in the operator reference.
  • get_system and set_system now support the parameters 'calib_dir', 'dl_dir', 'filter_dir', and 'ocr_dir' to get and set the default search path for camera parameters, deep learning models, filter parameters, and OCR classifiers, respectively.
  • HALCON has been extended with deep learning-based anomaly detection. This method makes it possible to learn the distribution of common features on a set of images. Features deviating from the learned distribution can thus be detected, which enables finding anomalies on new images. The new operator train_dl_model_anomaly_dataset has been added to train a deep learning model for anomaly detection. For all other purposes besides creation, the general purpose dl_model operator set is used. The HDevelop example program hdevelop/Deep-Learning/AnomalyDetection/dl_anomaly_detection_workflow.hdev has been added to show how to use deep learning-based anomaly detection in HALCON in a few lines. The example uses the new images in images/bottles and the annotations in images/labels/bottles. HALCON has been extended with two initial deep learning-based models for anomaly detection, which can be found in the directory %HALCONROOT%/dl: initial_dl_anomaly_medium.hdl and initial_dl_anomaly_large.hdl. The reference manual has been extended with a chapter on anomaly detection to describe how to use the new deep learning functionality ("Deep Learning" > "Anomaly Detection"). The procedure read_dl_dataset_anomaly can be used to read the images and possible ground truth annotation. Please note that this functionality has special system requirements. Among others, third-party libraries have to be installed with a separate installer. This installer also contains the images and pretrained model for the examples. Please refer to the Installation Guide for more information. Note that this change affects the compatibility. Read more.
  • The procedure augment_dl_samples provides two new augmentation types available for deep learning detection and segmentation models. They enable to augment the images with a global or local brightness variation.
  • The deep-learning-based training of classification models now supports setting weights for each class to handle unbalanced training data sets. To this aim, the delivered classification models pretrained_dl_classifier_alexnet.hdl and pretrained_dl_classifier_resnet50.hdl have been slightly changed. Note that this change affects the compatibility. Read more.
  • HALCON has been extended with a procedure dev_close_window_dict that can be used to close window handles contained in a dictionary.
  • The procedure set_dl_model_param_max_gpu_batch_size has been extended to support models of type 'classification'.
  • In HDevelop, the deep learning object detection example hdevelop/Deep-Learning/Detection/detect_pills_deep_learning_1_prepare.hdev has been extended. It now shows the usage of the new procedure determine_dl_model_detection_param, which generates model parameters by analyzing the dataset.
  • get_dl_model_param has been extended with the parameter 'summary' that returns information on the network architecture. This can be used to select 'backbone_docking_layer' for classifiers read from an ONNX model, such that they can be used as backbone for object detection.
  • HALCON has been extended with the operator gen_dl_model_heatmap, which returns an improved heatmap that is based on Grad-CAM (Gradient-weighted Class Activation Mapping). The operator is much faster than the procedure gen_dl_model_classification_heatmap. To display the heatmap, the procedure dev_display_dl_data has been extended. So far, the operator is only supported for runtime 'gpu'. A workflow using the new operator is shown in the HDevelop example program hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_4_infer.hdev.
  • The deep learning evaluation procedures have been extended to support the model type Anomaly Detection.
  • The procedure train_dl_model has been extended with a new option to display the evaluation measure for the training split.
  • HALCON has been extended with a pretrained deep learning classification model called pretrained_dl_model_alexnet.hdl.
  • HALCON now supports the pruning of deep learning-based classification models. Pruning allows you to remove kernels of convolutional layers, making the classifier smaller and (with exception of CPUs on x64 systems) faster.
    For this purpose, HALCON comes with a set of new operators: as well as a new procedure:
    • prune_dl_model
    The method is demonstrated in the workflow example
    hdevelop/Deep-Learning/Classification/prune_dl_model_classification_workflow.hdev.
  • When preprocessing the images to train a deep learning model, the new parameter 'normalization_type' replaces the parameter 'contrast_normalization'. For this, the deep learning procedure library dl_preprocessing has been adapted and extended to replace the legacy parameter 'contrast_normalization' keys with the relaunched keys for the new parameter 'normalization_type'.
  • The thirdparty Arm Compute Library (ACL) has been updated from version 18.11 to 19.08. The BatchNorm layer was included. As a result, the delivered deep learning segmentation networks and detection networks can be accelerated by up to 5 %.
  • The pretrained deep learning models used in semantic segmentation have been significantly improved:
    • dl/pretrained_dl_segmentation_compact.hdl
    • dl/pretrained_dl_segmentation_enhanced.hdl
    Inference speed is improved by 30-45% on GPUs, 90-190% on CPUs, and 90% on Arm®. Additionally, the training is faster and leads to improved results in all our tested application cases. Furthermore, please note that the minimal allowed input image size of the "enhanced" network has been lowered from 81 to 47 pixels in width and height. Note that this change affects the compatibility. Read more.
  • HALCON now supports newer versions of the two ONNX primitives Gemm and Resize, which were updated with the new release of ONNX 1.6.
  • The custom HPeek demo has been extended by the deep learning anomaly detection example for embedded GPU. You can download this demo on our customer area for free and evaluate the performance on your hardware.
  • The memory consumption of the anomaly detection deep learning models 'initial_dl_anomaly_medium.hdl' and 'initial_dl_anomaly_large.hdl' has been reduced to around 70% in respect to the previous version. The size on the disk of those models has also been significantly reduced by around half.
  • set_dl_model_param has been extended to set the parameter 'fuse_bn_relu'.
    If this parameter is set to 'true', each of the batch normalization and activation layers in a deep learning network will be fused. Currently, only ReLU activation is supported. As a consequence, the runtime for the inference and for a training step can be reduced. This function has been adapted for the following delivered networks:
    • initial_dl_anomaly_medium.hdl: Speedup up to 12 % for inference and up to 15 % for a training step.
    • initial_dl_anomaly_large.hdl: Speedup up to 13 % for inference and up to 1 % for a training step.
    • pretrained_dl_classifier_resnet50.hdl: Speedup up to 15 % for inference and up to 8 % for a training step.
    • pretrained_dl_segmentation_compact.hdl: Speedup up to 15 % for inference and up to 7 % for a training step.
    • pretrained_dl_segmentation_enhanced.hdl: Speedup up to 19 % for inference and up to 14 % for a training step.
    Note that this change affects the compatibility. Read more.
  • The procedure read_dl_dataset_segmentation has been improved. Now, further options are allowed for possible annotation files matches.
  • read_dl_model now supports reading ONNX models with convolutions that use different values for width and height dimensions for 'kernel_shape', 'stride', and 'dilation'.
  • train_dl_model_anomaly_dataset has been improved and is now faster. A speedup up to 900% and 1500% can be expected for CPU and GPU training, respectively.
  • For deep-learning-based models of type classification, detection, and segmentation it is now possible to optimize the trained model concerning memory consumption and free all memory not used for inference. This significantly reduces the size of the model.
  • The inference speed of the anomaly detection models initial_dl_anomaly_medium.hdl and initial_dl_anomaly_large.hdl has been improved by up to 50% on GPUs and up to 30% on CPUs.
  • The standard HDevelop example hdevelop/Deep-Learning/AnomalyDetection/dl_anomaly_detection_workflow.hdev has been extended by showing the new evaluation measures for image level classification. The documentation, some parameter values, as well as the structure of the example have also been improved.
  • The third-party Deep Neural Network Library (DNNL) has been updated from version 1.1 to 1.2.
  • The deep learning training visualization procedures can now also take the number of iterations as argument for the plotted loss values and not only the number of epochs.
  • The procedure determine_dl_model_detection_param has been improved. Now, the clustering of anchor_angles takes the jump discontinuity at 180° into account. If the generic parameter 'ignore_direction' is set to 'true' the jump discontinuity at 90° is considered correctly. If at least one 'class_ids_no_orientation' is set, it is more likely that an anchor_angle of 0.0 is returned. In summary, the returned anchor_angles are representing the underlying distribution of angles in the given dataset better.
  • Deep-learning-based models for classification, detection, and segmentation can now be trained also on CPU for supported x64 platforms. Restrictions are documented in the Installation Guide and the Operator Reference.
  • gen_dl_model_heatmap is now also executable on CPU for supported x64 platforms. Restrictions are documented in the Installation Guide and the Operator Reference.
  • The deep learning procedure dev_display_dl_data has been improved to display the results of anomaly detection. Now, the anomaly class and region in DLResult returned by threshold_dl_anomaly_results are displayed in case no thresholds are passed via GenParam.
  • HALCON now supports the new parameter 'freeze_backbone_level' for deep learning object detection models.
  • There is a significant speedup for the following deep learning procedures, especially for long input or output tuples:
    • find_dl_samples
    • split_dl_dataset
    • gen_dl_samples
    This also affects other deep learning procedures that use the procedures mentioned above.
  • The deep learning procedure preprocess_dl_dataset has been improved. Now, subsequent redundant checks of the preprocessing parameters are avoided.
  • The DL serialization during training has been improved. Now, a new serialization type 'current' is available that overwrites the serialized model with the current model after each epoch of the training. This allows resuming long trainings from the current state if they have been stopped for some reason.
  • HALCON now supports to set StartEpochs to 'resume' for the deep learning training procedure train_dl_model when resuming a training. With this option, the last available serialized model is automatically determined to start the resumed training.
  • HALCON has been extended with a pretrained deep learning classification model called pretrained_dl_model_mobilenet_v2.hdl.
  • The deep learning procedure determine_dl_model_detection_param now has the option to define 'max_num_samples'. This can be used to speedup the procedure for large datasets by restricting the number of samples that is used to determine the model parameters. Additionally, the procedure is now faster. Note that this change affects the compatibility. Read more.
  • The NVIDIA CUDA Basic Linear Algebra Subroutine library (cuBLAS) and NVIDIA CUDA Deep Neural Network library (cuDNN) have been updated to the latest versions. To support also the latest NVIDIA graphics cards, HALCON now ships and supports these libraries for the two CUDA versions 10.2 and 11.1. The libraries can be found in the cuda10_2 and cuda11_1 subdirectories of the thirdparty library directory.
    Depending on the installed CUDA versions, the respective libraries are loaded.
    The following versions of the NVIDIA libraries are shipped for CUDA 10.2:
    • NVIDIA CUDA Basic Linear Algebra Subroutine library (cuBLAS) from the CUDA 10.2 Toolkit version 10.2.2.214
    • NVIDIA CUDA Deep Neural Network library (cuDNN) version 8.0.4
    The following versions are shipped for CUDA 11.1:
    • NVIDIA CUDA Basic Linear Algebra Subroutine library (cuBLAS) from the CUDA 11.1 Toolkit version 11.2.1.74
    • NVIDIA CUDA Deep Neural Network library (cuDNN) version 8.0.4
    Note that this change affects the compatibility. Read more.
  • read_dl_model now supports reading in ONNX models containing the following operations:
    • ArgMax
    • Clip
    • ReduceMax
    • Resize
    • Sigmoid
    For information about limitations, have a look at the operator reference of the operator read_dl_model.
  • HALCON has been extended with an operator set to query and handle deep-learning capable hardware devices. The new operators are: The HALCON deep learning examples have been extended to show how to use the new operators. The operator get_dl_model_param and set_dl_model_param have been extended to use the hardware devices that are provided by query_available_dl_devices.
    The procedure set_dl_model_param_max_gpu has been extended to use the new operator query_available_dl_devices.
  • HALCON now provides a new pretrained deep learning model for edge extraction
    pretrained_dl_edge_extractor.hdl.
    This segmentation model is specially trained for the two-class segmentation problem with one class for edges and one for background. The pretrained model is capable of extracting edges in images and, moreover, can be retrained to find specific edges. Note that the retraining of this model is currently only supported on GPU.
    The new functionality is demonstrated in two new examples:
    • hdevelop/Deep-Learning/Segmentation/segment_edges_deep_learning.hdev shows how to extract general edges and uses the images from the subdirectory images/crosses.
    • hdevelop/Deep-Learning/Segmentation/segment_edges_deep_learning_with_retraining.hdev demonstrates how the model can be retrained to detect specific edges. It uses the new images fabrics_01.png to fabrics_20.png from the subdirectory images/fabrics and the new images fabrics_01_gt.png to fabrics_10_gt.png from the subdirectory images/labels/fabrics.
    The operator reference for read_dl_model has been extended with details on the new pretrained model. A section for this new functionality has also been added to the chapter "Edge Extraction (Pixel-Precise)" in Solution Guide I - Basics.

File
  • HALCON has been extended with the operators fread_bytes and fwrite_bytes, which read bytes from and write bytes to binary files, respectively.
    The new HDevelop example program hdevelop/File/Access/fread_bytes.hdev shows the usage of the new operators by copying a file bytewise.
    In the reference manual, the operators open_file, close_file, fread_char, fread_string, fread_line, fnew_line, and fwrite_string moved from chapter "File" > "Text" to "File" > "Access". Further, the corresponding HDevelop example programs moved from the directory hdevelop/File/Text to the directory hdevelop/File/Access.
  • HALCON has been extended with the possibility to read and write image metadata. For this purpose, the new operators write_image_metadata and read_image_metadata have been added.
    Currently, this feature is restricted to TIFF images and the tags mentioned in the reference manual entry of read_image_metadata.
    The workflow is shown in the new HDevelop example program hdevelop/File/Images/read_write_image_metadata.hdev.

  • list_files is now faster on Unix systems by a factor of at least 2.
  • The handle inspect window can now show the content of serialized items (semantic type serialized_item).
    The operators get_handle_param, get_handle_tuple, and get_handle_object have been extended accordingly.
Filter
  • mirror_image with 'byte' images, Mode='col', and image widths that are a multiple of 4 is now faster on Intel x86 compatible machines. The speedup is up to 270%.
    Furthermore, mirror_image is now faster with 'byte' images, Mode='col' on Intel compatible processors that support AVX2 or SSSE3. In particular, the speedup is up to 450%.
Graphics
  • HALCON has been extended with means to configure the fill style for displaying XLD contours. The operators set_contour_style, get_contour_style, and the respective HDevelop operator dev_set_contour_style have been added to enable this.
    The pie charts displayed by the evaluation procedures for deep learning have been adapted to use this new functionality. Note that this change affects the compatibility. Read more.
  • HALCON has been extended with two additional colormaps, namely jet and inverse jet.
  • HALCON now only attempts to load and initialize OpenGL support when a HALCON operator is called that uses OpenGL functionality.
Inspection
  • The texture inspection model has been extended to support multichannel images. This enables a better detection of colored texture defects. The new HDevelop example program hdevelop/Inspection/Texture-Inspection/apply_texture_inspection_model_color.hdev shows the usage of the new feature. It uses the new images leather/good/leather_good_[01-02].png and
    leather/defect/leather_defect_[01-06].png. Note that this change affects the compatibility. Read more.
Image
  • HALCON has been extended with an operator crop_rectangle2 that cuts out arbitrarily oriented rectangular parts from the input image.
Matching
  • Shape-based matching now supports new parameters to set clutter constraints on the matching model. This is helpful, e.g., if it is a special characteristic of the model that, in specific parts near to the model, structures are missing. The new operators set_shape_model_clutter and get_shape_model_clutter can be used to respectively set and query those parameters. The input parameter MinScore of the operators find_shape_model, find_shape_models, find_scaled_shape_model, find_scaled_shape_models, find_aniso_shape_model, and find_aniso_shape_models has been extended to pass a maximum clutter value in addition to the minimum score of the matches to be found. The operator set_shape_model_param has been extended to enable and disable the clutter usage.
    The Solution Guide on Matching has been extended by a section describing the concept of clutter regions.
    The new HDevelop example program hdevelop/Matching/Shape-based/find_shape_model_clutter.hdev shows how to use the new functionality.
    The new HDevelop procedure procedures/general/get_hom_mat2d_from_matching_result helps the user to calculate the transformation matrix for the model contours from the results of shape-based matching. The procedure procedures/general/dev_display_shape_matching_results has been extended to visualize the clutter region for each found match. Note that this change affects the compatibility. Read more.
  • The new HDevelop example program hdevelop/Matching/Shape-Based/find_shape_low_contrast_high_noise.hdev shows which parameter settings might improve the performance of shape based matching on images of low contrast and high noise. It uses the new images crosses_01 - crosses_10 from the subdirectory images/crosses.
  • Shape-based matching now supports model adaptation to handle images with high noise. The new operator adapt_shape_model_high_noise can be used to estimate the lowest pyramid level suitable for a sample search image. The operator get_shape_model_params has been extended to return both the highest pyramid level and the estimated lowest level when adapt_shape_model_high_noise is called.
    The Solution Guide on Matching has been extended by information on the usage of the new operator.
    The new HDevelop example program hdevelop/Matching/Shape-based/adapt_shape_model_high_noise.hdev shows how to use the new functionality.
  • set_shape_model_param now supports the parameter 'model_cache'. This parameter controls the use of an internal cache of the find operations of the shape-based matching. Setting 'model_cache' to 'false' reduces the temporary memory consumption. This functionality is shown in the example program hdevelop/Matching/Shape-Based/set_shape_model_param_model_cache.hdev.
Miscellaneous
  • HALCON has been extended with an operator area_intersection_rectangle2, which calculates the intersection area of oriented rectangles. The new HDevelop example program hdevelop/Tools/Geometry/area_intersection_rectangle2.hdev shows the new functionality.
  • The operator reference of set_system now mentions that the value of the parameter 'thread_num' is automatically increased if the sum of thread-specific threads set in 'tsp_thread_num' exceeds 'thread_num'.
  • For get_spy and set_spy, the parameters 'button_click', 'button_notify', 'button_window', 'halt', 'input_gray_window', 'input_region_window', 'input_xld_window', and 'timeout' have been removed and are no longer supported.
  • The operators find_data_code_2d, find_bar_code, and decode_bar_code_rectangle2 now can be canceled using the operators set_operator_timeout and interrupt_operator.
Morphology
  • gray_erosion_rect, gray_dilation_rect, gray_opening_rect, gray_closing_rect, gray_erosion_shape, gray_dilation_shape, gray_opening, and gray_closing_shape with parameter 'MaskShape' set to 'rectangle' are now faster for 'uint2' images on Intel compatible processors that support SSE2 or AVX2, depending on the image size and mask dimensions.
    In particular, the following speedups can be expected for a 1600x1200 image compared to the previously available SSE2 implementation:
    MaskHeight x
    MaskWidth
    Morphological
    operation
    Speedup
    without
    Parallelization
    and with SSE2
    (Windows/Linux)
    Speedup
    without
    Parallelization
    and with AVX2
    (Windows/Linux)
    Speedup
    with 8/2-Thread
    Parallelization
    and with SSE2
    (Windows/Linux)
    Speedup
    with 8/2-Thread
    Parallelization
    and with AVX2
    (Windows/Linux)
    3x3 erosion/dilation 10%/5% 85%/100% 150%/80% 160%/160%
    5x5 erosion/dilation 5%/5% 160%/195% 115%/50% 190%/275%
    7x7 erosion/dilation 15%/12% 205%/230% 100%/45% 265%/290%
    9x9 erosion/dilation 10%/7% 185%/203% 85%/30% 200%/270%
    11x11 erosion/dilation 3%/ -5% 120%/125% 25%/15% 85%/135%
    13x13 erosion/dilation 5%/ 0% 145%/160% 60%/15% 140%/160%
    1x3 erosion/dilation 100%/145% 105%/150% 100%/145% 105%/150%
    3x1 erosion/dilation 90%/170% 105%/140% 90%/170% 105%/140%
    1x11 erosion/dilation 3%/30% 5%/40% 3%/30% 5%/40%
    11x1 erosion/dilation -5%/3% -5%/3% -5%/3% -5%/3%
    3x5 erosion/dilation 60%/75% 65%/75% 60%/75% 65%/75%
    5x3 erosion/dilation 60%/70% 65%/90% 60%/70% 65%/90%
               
               
    3x3 opening/closing -5%/0% 50%/85% 80%/70% 80%/110%
    5x5 opening/closing -4%/0% 120%/185% 90%/45% 120%/190%
    7x7 opening/closing 5%/5% 165%/220% 80%/30% 150%/255%
    9x9 opening/closing 4%/5% 155%/200% 70%/35% 180%/250%
    11x11 opening/closing -5%/ -5% 105%/130% 15%/10% 70%135%
    13x13 opening/closing -4%/0% 130%/160% 40%/15% 105%/175%
    1x3 opening/closing 80%/100% 75%/100% 80%/100% 75%/100%
    3x1 opening/closing 80%/90% 75%/70% 80%/90% 75%/70%
    Note that, previously, values outside the domain have been calculated in the unparallelized case that led to well defined pixel values outside the actual image domain. Now, the image only contains pixel values in the actual domain. Please note that the new SSE2 implementation for filter masks 1xN (e.g., 1x3, 1x5, ...) and for filter masks 3xN (e.g., 3x3, 3x5, ...) can be slightly slower than the old SSE2 implementation.
OCR
  • HALCON has been extended with Deep OCR. This method makes it possible to find and read arbitrarily oriented text easily and robustly without setting complex parameters.
    The operators for Deep OCR are: The HDevelop example program hdevelop/OCR/Deep-OCR/deep_ocr_workflow.hdev has been added to show how to use Deep OCR in HALCON in a few lines. The example uses the new images airplane_ticket_01, blister_package_01, bottle_label_09, chip_01, cropped_text_image_01, cropped_text_image_02, cropped_text_image_03, cropped_text_image_04, cropped_text_image_05, cropped_text_image_06, cropped_text_image_07, cropped_text_image_08, cropped_text_image_09, cropped_text_image_10, dot_print_12, industrial_text_01, industrial_text_02, keys_01, metal_print_01, and street_sign_01 from the subdirectory images/ocr.
    The new procedure dev_display_deep_ocr_results can be used to visualize the results of Deep OCR.
    HALCON has been extended with pretrained Deep OCR models for text detection and recognition, which can be found in the directory %HALCONROOT%/dl: pretrained_deep_ocr_detection.hdl and pretrained_deep_ocr_recognition.hdl.
    The reference manual has been extended with a chapter describing how to use the new OCR functionality ("OCR" > "Deep OCR").
    This functionality has special system requirements. Among others, third-party libraries have to be installed with a separate installer. Please refer to the Installation Guide for more information.
  • HALCON has been extended with two additional colormaps, namely jet and inverse jet.
Parallelization
  • The legacy include file "HSync.h" has been removed from the fileset. Therefore, the legacy macro definitions for CRITICAL_SECTIONS that were not used by HALCON for several versions are not available anymore. Note that this change affects the compatibility. Read more.
  • The HALCON library now properly synchronizes the initialization when called from multiple threads, so it is no longer necessary to call the first HALCON operator exclusively.
  • HALCON Spy has been improved and is now also capable to run multi-threaded.
Region
  • sort_region with 'SortMode' set to 'character' has been extended by a second, optional parameter for 'SortMode'. Now, a tuple consisting of 'character' and a numeric value can be passed to 'SortMode'. This optional parameter specifies the percentage of overlap that adjacent rows or columns can have to be considered as different rows or columns. Previously, this percentage had a fixed value of 15.
    Through the configurable percentage, the 'character' mode is more flexible at handling different amount of overlapping between rows and columns. The operator reference has been adapted with details on this new, optional parameter. Note that this change affects the compatibility. Read more.
Segmentation
  • The usability of the operator regiongrowing has been improved. Now, its parameters Row and Column have been renamed to RasterHeight and RasterWidth in order to better point out their meaning.
  • HALCON has been extended with a new operator watersheds_marker to perform marker-based watershed image segmentation.
    The new HDevelop example program hdevelop/Segmentation/Topography/watersheds_marker.hdev demonstrates the new functionality.
  • The performance of the operators watersheds and watersheds_threshold has been improved for images of type 'real'. watersheds is now up to 35% faster, watersheds_threshold is up to 33% faster.
  • The threshold operator has been improved. Now, it supports the parameter values 'min' and 'max' for the lower and upper gray value, respectively.
  • threshold and dyn_threshold have been optimized for the Arm Neon instruction set extension for 'byte' and 'uint2' image types, for both 32 and 64 bit Arm systems. For the threshold operator, operations on float images have been optimized as well. On Cortex A73 processors, for 'byte' images threshold operations are up to 200% faster, while dyn_threshold operations are up to 180-250% faster, depending on the mode.
  • The speed of the operators watersheds, watersheds_threshold, and watersheds_marker has been significantly improved if a reduced domain is used.
    Now, depending on the size of the image and the reduced domain, it is up to 2300 % faster. Note that this change affects the compatibility. Read more.
System
  • get_system and set_system now support the parameters 'calib_dir', 'dl_dir', 'filter_dir', and 'ocr_dir' to get and set the default search path for camera parameters, deep learning models, filter parameters, and OCR classifiers, respectively.
  • HALCON sockets support Transport Layer Security (TLS) for data transmission. Therefore, additional "tls_*" parameters have been added to the operators open_socket_connect and open_socket_accept.
    To show how TLS encryption is used, the example program example/hdevelop/System/Sockets/generic_socket_TLS_echo_server.hdev has been added.
Tuple
  • HALCON has been extended with functions to calculate the Gaussian error function. In particular, the operators tuple_erf and tuple_erfc and the corresponding HDevelop language functions erf and erfc have been implemented.
  • HALCON has been extended with functions to calculate the hypotenuse and the cube root. In particular, the new operator tuple_hypot and the corresponding HDevelop language function hypot calculate the hypotenuse sqrt(x*x+y*y) without undue overflow or underflow during the intermediate steps of the calculation. Furthermore, the new operator tuple_cbrt and the corresponding HDevelop language function cbrt calculate the cube root.
  • HALCON has been extended with tuple operators for the inverse hyperbolic functions tuple_asinh, tuple_acosh, and tuple_atanh and the corresponding HDevelop language functions asinh, acosh, and atanh.
  • HALCON has been extended with the following tuple operators: tuple_exp10 (base 10 exponentiation), tuple_exp2 (base 2 exponentiation), and tuple_log2 (base 2 logarithm).
  • HALCON has been extended with the tuple operators tuple_tgamma and tuple_lgamma and their counterparts tgamma and lgamma in HDevelop. They calculate the gamma function and the logarithm of the absolute value of the gamma function, respectively.
XLD
  • HALCON has been extended with an operator rectangularity_xld that computes the rectangularity scores for XLD contours and polygons.
    select_shape_xld has been extended by the new type 'rectangularity', which selects XLD contours based on their rectangularity score.
    The HDevelop example program hdevelop/XLD/Features/select_shape_xld.hdev has been extended to show how to use the new parameter.

Bug Fixes

3D
  • Some files in the binary PLY format could not be read by read_object_model_3d. This problem has been fixed.
  • The auxiliary procedure debug_find_surface_model did not always show the correct result scores in the result inspection if the edge-supported surface-based matching was used and multiple results were visualized. This problem has been fixed.
  • find_surface_model, find_surface_model_image, refine_surface_model_pose, and refine_surface_model_pose_image returned a too high Score when the model was trained using 3D edges, but their use was disabled by the generic parameter 'use_3d_edges'. This problem has been fixed.
  • find_surface_model, find_surface_model_image, refine_surface_model_pose, and refine_surface_model_pose_image allowed setting 'use_3d_edges' to 'true', even if the 3D surface model was not trained for edge-supported matching. This problem has been fixed. Now, the error 9504 ("3D surface model not trained for edge-supported matching") is returned.
  • In rare cases, reduce_object_model_3d_by_view could have caused memory corruption or crashed when using the 'xyz_mapping' mode. This problem has been fixed.
  • The automatic value check in debug_find_box_3d threw an exception and skipped several tests when no boxes were found during matching. This problem has been fixed.
  • When using fit_primitives_object_model_3d to fit cylinders or spheres, the condition min_radius > max_radius was not detected as error. This problem has been fixed.
  • read_object_model_3d for PLY files sometimes generated empty triangle or polygon attributes, which may have caused problems when processing the read models. This problem has been fixed.
  • Some operators sometimes generated empty attributes of type triangle, polygon, or line in 3D object models, which may have caused problems when further processing the models. Examples include read_object_model_3d for .om3 files, triangulate_object_model_3d, and simplify_object_model_3d.
    This problem has been fixed. The operators now no longer create empty attributes of the listed types and will simply not emit the attribute if it were empty.
  • The procedure visualize_object_model_3d returned the error "Wrong type or value for parameter" when the used attribute for GenParamName 'color_attrib', 'red_channel_attrib', 'green_channel_attrib', 'blue_channel_attrib' was not attached to the points of the 3D object model. This problem has been fixed.
    visualize_object_model_3d now returns the error extended by GenParamValue "may not be attached to the points of the 3D object model. Compare the parameter AttachExtAttribTo of set_object_model_3d_attrib."
  • triangulate_object_model_3d, find_text, segment_object_model_3d, and prepare_object_model_3d with parameter 'Purpose' set to 'segmentation' have not been thread-safe. This problem has been fixed.
  • refine_surface_model_pose and refine_surface_model_pose_image threw the error 1306 ('Wrong value of control parameter 6') when 'use_self_similar_poses' was set to a valid value (i.e. 'true', 'false', 1, 0) although the model had been trained with self-similar poses. This problem has been fixed.
  • register_object_model_3d_pair and register_object_model_3d_global crashed, leaked memory, or deadlocked if at least one of the input models did not contain any points. This problem has been fixed.
  • Errors were not handled properly when passing wrong parameters to set_metrology_model_param, get_metrology_model_param, select_object_model_3d, volume_object_model_3d_relative_to_plane, or adjust_mosaic_images. This problem has been fixed.
  • In rare cases and when using UINT2 input images, photometric_stereo returned the gray value of '0' for the albedo image. This problem has been fixed.
  • find_box_3d had an insufficient resolution in its timeout mechanism. This problem has been fixed.
Bar Code
Calibration
  • The example program hdevelop/Calibration/Multi-View/check_calib_image_quality.hdev sometimes could not read the description file of the calibration plate. This problem has been fixed.
Data Code
  • The default encoding of 2D data codes has been UTF-8 ('utf8'). To be in accordance with the coresponding standards, the default encoding is now ISO-8859-1 ('latin1'). Note that this change affects the compatibility. Read more.
  • In some cases, get_data_code_2d_results returned inconsistent values if a result-specific parameter name was passed in 'ResultNames' but 'CandidateHandle' was set to 'general'. This problem has been fixed. Now, get_data_code_2d_results returns the value '-1' in those cases. Note that this change affects the compatibility. Read more.
  • For mirrored Data Matrix ECC200 codes with a square shape, get_data_code_2d_objects returned wrong results for 'module_1_rois' and 'module_0_rois' in some cases. Additionally, get_data_code_2d_results returned wrong results for 'bin_module_data' for the same cases. These problems have been fixed.
  • In very rare cases, find_data_code_2d showed non-deterministic behavior if the ECC200 code was located very close to the image borders. This problem has been fixed.
  • get_data_code_2d_objects returned wrong results for 'module_1_rois' and 'module_0_rois' in case of mirrored QR codes. This problem has been fixed.
  • When find_data_code_2d was called in training mode for data codes with modules greater than 100 pixel, the parameters 'module_size_min' and 'module_size_max' in some cases were set to values greater than 100, thus exceeding the maximum value that can be set for them with set_data_code_2d_param. This problem has been fixed.
  • For Data Matrix ECC 200 symbols, get_data_code_2d_results in some cases returned wrongly calculated grades for fixed pattern damage with the parameters 'quality_aimdpm_1_2006' or 'quality_isoiec_tr_29158'. This problem has been fixed.
Deep Learning
  • The option 'ignore_missing_labels' in the deep learning procedure gen_dl_samples did not work correctly for the detection workflow (with and without oriented bounding boxes). This problem has been fixed.
  • The HALCON deep learning features did not support very large images on 64-bit systems. this problem has been fixed.
  • In the HDevelop example programs hdevelop/Deep-Learning/Segmentation/segment_pill_defects_deep_learning_3_evaluate.hdev and hdevelop/Deep-Learning/Detection/detect_pills_deep_learning_3_evaluate.hdev the batch size was set after the call of set_dl_model_param(DLModelHandle, 'runtime_init', 'immediately'). This could have led to an out of memory error. This problem has been fixed. Now, the batch size is set before the "runtime_init" call.
  • When training a deep learning model for object detection and segmentation, the legend (TextWindow) for the images (input, ground truth, results) at the training progress was placed at the bottom right corner. As a result, you could not see the predicted bounding boxes quite well. This problem has been fixed. Now, the visualization of the legend is placed at the top right corner.
  • When setting a bigger font size in a WindowHandle in the visualization procedure dev_display_dl_data for displaying the confusion matrix in a Deep Learning application, the title "Ground truth" overlapped the content of the confusion matrix. This visualization problem has been fixed.
  • The procedure create_dl_train_param failed if a deep learning model of type 'detection' created in HALCON 18.11 was passed over to the procedure. This problem has been fixed.
  • train_dl_classifier_batch returned a temporary memory error if the image size of the input images was incorrect. This problem has been fixed.
  • In very rare cases, apply_dl_model ran into an infinite loop for models of type detection with instance_type='rectangle2' when the trained weights were corrupt. This problem has been fixed. Now, an error is raised.
  • set_dl_model_param does not longer allow to set the parameter 'class_ids_no_orientation' for deep learning detection models because this could too easily be done incorrectly. Instead, set 'class_ids_no_orientation' when creating the model with create_dl_model_detection.
  • The following procedures have been moved to a common procedure library called dl_dataset.hdpl:
    • find_dl_samples.hdvp
    • gen_dl_samples.hdvp
    • gen_dl_samples_from_images.hdvp
    • read_dl_dataset_anomaly.hdvp
    • read_dl_dataset_classification.hdvp
    • read_dl_dataset_from_coco.hdvp
    • read_dl_dataset_segmentation.hdvp
    • read_dl_samples.hdvp
    • split_dl_dataset.hdvp
    • write_dl_samples.hdvp
  • Reading big datasets was rather slow. This problem has been fixed.
  • The define for the error 7824 ("DL: Invalid instance type") has been renamed from H_ERR_DL_DETECTOR_INVALID_TYPE to H_ERR_DL_DETECTOR_INVALID_INSTANCE_TYPE . Note that this change affects the compatibility. Read more.
  • The HDevelop example programs classify_pill_defects_deep_learning_2_train.hdev and segment_pill_defect_deep_learning_2_train.hdev had a statement about the recommended batch size, which was not always optimal. This problem has been fixed.
  • The deep learning procedure determine_dl_model_detection_param in some cases did not handle angles for object detection of instance type 'rectangle2' correctly. This problem has been fixed. Additionally, for the procedure the generic parameter GenParam has been extended by accepting the parameters 'class_ids_no_orientation' and 'ignore_direction', which correspond to the object detection model parameters of the same name.
  • Deep learning preprocessing of samples for detection with instance_type="rectangle2" in rare cases caused bounding boxes that are out of the allowed range. This could have led to problems when training the network with the incorrectly preprocessed samples. This problem has been fixed.
  • Deep learning classification models that have been created with HALCON 17.12 Progress and read with HALCON 19.05 Progress or later returned incorrect classification results during inference. This problem has been fixed.
  • In all read_dl_dataset procedures parallelization of some loops was introduced to speedup reading of big deep learning datasets.
  • The calculation of the score histogram from deep learning anomaly detection was not exact. This caused issues when it was displayed together with the classification thresholds. This problem has been fixed. Now, the histogram is calculated and displayed in a more accurate way. Note that this change affects the compatibility. Read more.
  • Under certain circumstances, when using CPU based deep learning functionality on Arm based platforms, in conjunction with other HALCON operators using AOP, a crash may have occurred. This problem has been fixed.
  • train_dl_model_anomaly_dataset did not handle input images with empty domains correctly and threw an error in these cases. This problem has been fixed. Now, input training images with empty domains are ignored. However, if all input images have empty domains, the operator will still return with an error.
  • train_dl_model_anomaly_dataset took into account data from previous calls, if it has been called more than once with the same model, which could have led to erroneous results. This problem has been fixed.
  • For model_type 'detection' and instance_type 'rectangle2' the procedure dev_display_dl_data swapped the position of labeled class ID and predicted class ID compared to the visualization in case of instance_type 'rectangle1' when using KeysForDisplay 'bbox_both'. This problem has been fixed.
  • train_dl_model_batch returned the misleading error code 9000 ("Function not implemented on this machine") when called with an anomaly detection model. This problem has been fixed. Now, the error code 7912 ("DL: Operator does not support the model type") is returned.
  • In some cases, the intermediate classification threshold returned by the procedure compute_dl_anomaly_thresholds was not between the other two returned thresholds. This problem has been fixed.
  • Inference on a CPU for segmentation models returned incorrect results in some cases. This also affected anomaly detection models when either the 'image_height' or the 'image_width' is exactly 32. This problem has been fixed.
  • create_dl_model_detection froze weights of all layers until level 2 even if the number of channels of the image has changed to a value unequal to 1 or 3, which causes reinitialization of the weight of the first convolution layer. This problem has been fixed. Now, the weights are not frozen when weights need to be reinitialized due to the set image dimensions.
  • The HDevelop procedure split_dl_dataset used for deep learning returned an error in case of a set model type. This problem has been fixed.
  • apply_dl_model could not be interrupted after setting a timeout via set_operator_timeout. This problem has been fixed.
  • The library procedure preprocess_dl_model_images did not always produce the same output for all supported image types depending on the normalization type. This problem has been fixed.
  • There was a limitation when setting the input dimensions for a deep learning-based model for model type 'classification'. Now it is possible to set the input dimensions to any conceivable small values bigger than zero.
  • train_dl_model did not resume trainings correctly when StartEpoch was set to a value > 0.0. This problem has been fixed. Now, the previous trainig results are displayed and the previously best model achieved is not overwritten.
  • preprocess_dl_samples could not handle samples labeled for object detection with instance_type='rectangle2' if the tuples with the bounding box coordinates were empty. This problem has been fixed.
  • During the calculation of the mean average precision (mean_ap) measure during the evaluation of deep-learning-based object detection, precision-recall curves have not been interpolated as intended. This problem has been fixed. A new evaluation parameter for object detection, 'interpolate_pr_curves', has been added (default: true). Due to the correct interpolation, the evaluation will in most cases output higher 'mean_ap' values. Note that this change affects the compatibility. Read more.
  • The operator train_dl_model_batch expected a single dictionary for its parameter 'DLSampleBatch', which was especially confusing in the .NET signature. This problem has been fixed. Now, the operator expects a tuple of dictionaries, one for each sample of the batch.
    Note that this fix violates the binary compatibility as the operator signature changed. Affected interfaces are C++ and .NET. Note that this change affects the compatibility. Read more.
  • dev_display_dl_data did not always use the correct contour style if KeysForDisplay contained 'bbox_result' or 'bbox_both'. This problem has been fixed.
  • For deep learning backbones with many skip connections, create_dl_model_detection was running very long. This problem has been fixed.
  • In the following examples, the random seed was not working for the first run:
    • hdevelop/Deep-Learning/Classification/classify_pill_defects_deep_learning_2_train.hdev
    • hdevelop/Deep-Learning/Detection/detect_pills_deep_learning_2_train.hdev
    • hdevelop/Deep-Learning/Segmentation/segment_pill_defects_deep_learning_2_train.hdev
    This problem has been fixed.
  • When setting directories over GenParam dicts, tuples of strings were not processed correctly when reading deep learning data sets.
    This affects the following procedures:
    • read_dl_dataset_anomaly
    • read_dl_dataset_segmentation
    This problem has been fixed.
  • Serializing and deserializing a classifier as a handle was leading to a crash. This problem has been fixed.
  • In the deep learning training procedures, the handling of the evaluation measures was not always correct. The selected measure was not displayed correctly during the training process. This problem has been fixed.
  • Setting the deep learning measure 'soap' during a detection training with oriented boxes did not work correctly. This problem has been fixed.
  • The error message of the augmentation parameter 'rotate_range' in the deep learning procedure augment_dl_samples returned a wrong exception. This problem has been fixed.
  • set_dl_model_param has been extended to set the parameters 'bbox_heads_weight' and 'class_heads_weights' for models of type 'detection'.
  • In the deep learning procedure restore_dl_train_info_for_resuming, the output parameter 'StartEpochNumber' was not initialized correctly. This could lead to problems when exporting the code to another language. This problem has been fixed.
  • The procedure dev_display_dl_data threw an exception when displaying segmentation ground truth, results, or both in case of non-trivial class IDs. This problem has been fixed.
  • get_dl_model_param 'layer_names' retrieved wrongly 'unnamed' layers for the deep-learning models pretrained_dl_segmentation_compact.hdl and pretrained_dl_segmentation_enhanced.hdl. This problem has been fixed.
File
  • fread_char, fread_line, fread_string, and fread_serialized_item did not report an error when used on a file opened for output. Additionally, fwrite_string and fwrite_serialized_item did not report the correct error when used on a file opened for input. These problems have been fixed.
  • Reading big datasets was rather slow. This problem has been fixed.
  • Attempting to read a TIFF file with a color map and an alpha channel returned an internal error. This problem has been fixed. Now, the error 5556 ("TIFF: Image format not supported by HALCON") is returned.
  • In rare cases, read_image read only one color channel of bitmap RGB image files (BMP). This problem has been fixed.
  • read_image leaked memory for 'jpegxr' images containing an alpha channel. This problem has been fixed.
Filter
  • The procedure scale_image_range also scaled constant images. This problem has been fixed.
  • The operator threshold internally truncates the input parameters 'MinGray' and 'MaxGray' from double precision to single precision floating point values. Previously, this happened unnoticed. Now, if the truncated value deviates from the initial input value, a message is printed to console, e.g.: "MinGray parameter outside of numerical precision. Input value 1e-50 truncated to 0 with difference 1e-50"
Graphics
  • disp_text did not show the correct specified color for all parts of a string if multiple fonts are used within a string. This problem has been fixed.
  • If any interpolation mode but 'nearest_neighbor' was chosen with set_part_style, the visualization displayed garbage data outside the image when setting the window part such that the image did not completely fill the window. This problem has been fixed.
  • When using specific corner-case parameters with legacy pixmap windows, a crash could occur. This problem has been fixed.
  • drag_region1, drag_region2, and drag_region3 could not be canceled correctly using the HDevelop stop button when running in windows opened with open_window. This problem has been fixed.
  • In very rare cases, draw_rectangle2 returned the error 3513 ("Internal error: number of chords too big for num_max") if the current image part was very small. This problem has been fixed.
  • In very rare cases, dev_display and disp_obj crashed if the region or image domain to be displayed had to be scaled down to fit the window and contained a large number of runlengths. This problem has been fixed.
  • get_os_window_handle could return truncated handles on 64-bit systems. This problem has been fixed.
Inspection
Images
  • affine_trans_image crashed in rare cases if the interpolation was set to 'nearest_neighbor' for real images. This problem has been fixed.
  • read_image read a SubIFD in a TIFF image as another channel of the main image, even if the dimensions were different. This problem has been fixed.
Matching
Measure
Miscellaneous
OCR
  • In some cases, the result of find_text with text models of mode 'auto' was dependent on the internal image width and height of the system or the current thread. This problem has been fixed.
Region
  • gen_rectangle1 could have not returned an error for very big coordinates. This problem has been fixed.
  • gen_region_points, gen_region_runs, and gen_rectangle1 did not raise an error if coordinates were too small or too big for MAX_FORMAT. This problem has been fixed. Now, they return the errors 3040 ("Row value of a coordinate > 2^15-1"), 3041 ("Row value of a coordinate < -2^15"), 3042 ("Column value of a coordinate > 2^15-1"), or 3043 ("Column value of a coordinate < -2^15"), respectively.
Segmentation
System
  • HALCON did not detect the correct operating system version for Windows 8.1 and higher. This problem has been fixed.
  • Under certain conditions, timeouts for socket operations were ignored. This problem has been fixed.
  • Under certain language settings on Windows systems, socket-related extended error messages were not encoded correctly and unreadable. This problem has been fixed.
XLD
  • read_contour_xld_dxf and read_polygon_xld_dxf did not properly treat the orientation of the arbitrary axis for the DXF 2D entities POLYLINE and ARC. This caused wrong position and/or orientation of XLDs when an arbitrary axis was specified. This problem has been fixed.
  • DxfStatus messages of read_contour_xld_dxf and read_polygon_xld_dxf were not returned completely in some cases. This problem has been fixed.
  • In rare cases, union_cotangential_contours_xld returned suboptimal results when the parameter 'FitLength' was set to 'auto'. This problem has been fixed.

Procedures

Bug Fixes

  • The error message of the augmentation parameter 'rotate_range' in the deep learning procedure augment_dl_samples returned a wrong exception. This problem has been fixed.
  • In the deep learning procedure restore_dl_train_info_for_resuming, the output parameter 'StartEpochNumber' was not initialized correctly. This could lead to problems when exporting the code to another language. This problem has been fixed.

HALCON/C++

Functionality

  • All methods in the C++ language interface that do not change a member of an own instance (i.e., all methods with read only access) are now declared as const in order to see the access rights of the method and to prevent that further casting is needed.
  • The performance of convert_vector_to_tuple and convert_tuple_to_vector_1d when using the C++ language interface has been substantially improved under certain circumstances.

Bug Fixes

  • Not all headers provided by the HALCON/CPP language interface were included within the HalconCpp namespace. The generated C++ classes were globally defined inside the HalconCppForwards.h file without the HalconCpp namespace. This problem has been fixed. Now, all headers provided by HALCON are inside HalconCppForwards.h and surrounded by the HalconCpp namespace. This is specially useful for software development, to include only HalconCppForwards.h and to define all classes without further modification.
  • The ToLArr, ToDArr, and ToSArr HTuple member functions in the HALCON C++ language interface could leak memory in case an exception was thrown. This problem has been fixed.
  • Accessing the string value of a tuple element with .C() threw an exception when the tuple was a mixed tuple. This problem has been fixed.

HALCON/.NET

Functionality

  • The performance of convert_vector_to_tuple and convert_tuple_to_vector_1d when using the .NET language interface has been substantially improved under certain circumstances.
  • The HALCON/.NET interface has been extended with support for .NET Core. This support comes in the form of two new packages that are available online via NuGet:
    • MVTec.HalconDotNet
      • This package targets .NET Standard 2.0 and provides full access to the HALCON library as well as HDevEngine. It can be used on all architectures supported by HALCON.
    • MVTec.HalconDotNet-Windows
      • This package targets .NET Core 3.1 and additionally includes Windows Forms and WPF controls for integrating HALCON windows into GUI applications.
    Note that for technical reasons the package versioning deviates from standard HALCON versioning. For HALCON 20.05 Progress, the matching package version is 20050.0.0. For more information, please consult the Programmer's Guide. The documentation of the HALCON/.NET interface has been extended with information on using .NET Core.
    The minimal new C# example 'ConsoleApp' demonstrates the use of .NET Core under Windows and Linux. In addition, the C# examples 'Matching' and 'MatchingWPF' have been extended with build configurations for .NET Core under Windows. Instructions for creating a minimal console-based HDevEngine example can be found in the documentation.

Bug Fixes

  • On 64-bit systems, certain window messages could lead to arithmetic overflow when using HWindowControlWPF. This problem has been fixed.

HALCON/PYTHON

Functionality

  • HALCON provides the new language interface HALCON/Python, which supports both the HALCON library and HDevEngine. This language interface can be imported into a Python program via the pip package management system. The usage of the interface is described in Part IV  "Programming With HALCON/Python" of the Programmer's Guide. Additionally, the new example programs examples/python/consoleapp, examples/python/matching (HALCON Library) and examples/hdevengine/python/exec_procedures (HDevEngine) show the usage of the HALCON/Python interface.

Language Interface Example Programs

Functionality

  • The C# and VB HDevEngine examples for executing programs and procedures now use a background thread for execution. This provides a better experience when these examples are adapted to execute own code that makes use of interactive drawing objects.

HALCON Variable Inspect

Functionality

  • The HALCON Variable Inspect Extension for Visual Studio can now be used with student licenses.

Extension Packages

Functionality

  • The fileset of HALCON now contains an example which shows the use of handles in extension packages. In particular, the following files have been added to the new directory example/extension_package/userhandle: common.mak, def/userhandle.def, hdevelop/example.hdev, make.dotnet, makefile, rules.mak, source/cuserhandle.c
  • For the procedure HIncrRL, which increases the current runlength number for memory allocation, a dedicated documentation is provided in the Extensions Package Programmers Manual.
  • The extension package example "halconuser" now contains examples of how to define custom handle types and how to create and use the handles of such a custom type. This covers the previous extension package example "userhandle", which has been removed from the Linux installation.
  • Declaring a parameter in user-provided .def files in extension packages now requires the declaration of sem_type. Note that default_type remains conceptually optional. Note that this change affects the compatibility. Read more.
  • The Extension Package Programmer's Guide did not give a description on the 'multiinstance' slot used for the parameter description in .def files. The reference manual entry of get_param_info did not mention this information either. The description has been added accordingly.

HBench

Functionality

  • The list of hbench reference values (hbench -reference) has been extended by benchmark values for the processors AMD Ryzen™ 9 3950X and Intel® Core™ i9-10900X.

Bug Fixes

  • The hbench memory benchmarks could crash on Linux machines in low memory situations. This problem has been fixed.

Image Acquisition Interfaces

The latest information about new interface revisions and newly supported image acquisition devices can be found on MVTec's web server. Please refer to the release notes within the documentation of the individual image acquisition interfaces for information about improvements, bugfixes, or whether a new revision of the corresponding device driver is required.

Image Acquisition Example Programs

  • The HDevelop example program hdevelop/Image/Acquisition/genicamtl_basler_tof_objectmodel3d.hdev has been replaced with the new example program genicamtl_basler_blaze_objectmodel3d.hdev.
  • It is now possible to write and load persistence files for individual GenTL Producer modules or the GenTL Consumer if the device has already been opened. This was so far only possible for the remote device. The persistence file to be written or loaded is selected with the parameter 'settings_selector'.
    The following HDevelop examples have been added to demonstrate writing parameter values to files and restoring parameter values from files:
    • hdevelop/Image/Acquisition/gstreamer_parameter_persistence.hdev
    • hdevelop/Image/Acquisition/gigevision2_parameter_persistence.hdev
    • hdevelop/Image/Acquisition/genicamtl_parameter_persistence.hdev
    • hdevelop/Image/Acquisition/usb3vision_parameter_persistence.hdev
  • The example hdevelop/Image/Acquisition/usb3vision_information.hdev has been added to gather information about the system and the camera configuration for USB3Vision devices.

Digital I/O Interfaces

The latest information about new interface revisions and newly supported digital I/O interfaces can be found on MVTec's web server. Please refer to the release notes within the documentation of the individual digital I/O interfaces for information about improvements, bugfixes, or whether a new revision of the corresponding device driver is required.

Miscellaneous

  • The OPC_UA interface has been updated to revision 19.11.1. For this revision the handling of complex datatypes has been rewritten to use HALCON Dictionaries instead of Tuples. This allows for a better treatment of complex datatypes, and also allows reading and writing to nested datatypes.
    The following HDevelop example programs have been added to show the behavior of the new revision:
    • hdevelop/System/IO-Devices/opc_ua_enumeration.hdev
    • hdevelop/System/IO-Devices/opc_ua_optionset.hdev
    • hdevelop/System/IO-Devices/opc_ua_structure.hdev
    • hdevelop/System/IO-Devices/opc_ua_union.hdev
    These example programs replace the following examples that have been removed:
    • hdevelop/System/IO-Devices/opc_ua_read_struct.hdev
    • hdevelop/System/IO-Devices/opc_ua_read_write_complex_data_types.hdev
    Note that this change affects the compatibility. Read more.

HALCON for Embedded Vision

Functionality

  • JIT compilation of procedures is now supported with the standard Arm architectures aarch64-linux and armv7a-linux.
    The size of the HDevEngine for Arm architectures increased to approximately 30 MB.

Documentation

Programmer's Manuals

  • The usability of the Programmer's Guide has been improved. In particular, it now contains more information and examples about compiling and linking C++ programs.
  • The Programmers Guide showed an erroneous .NET example code. This problem has been fixed.
  • For the procedure HIncrRL, which increases the current runlength number for memory allocation, a dedicated documentation is provided in the Extensions Package Programmers Manual.

User Guides

  • The documentation for HALCON for Arm-based Platforms has been improved to better describe installation related issues, e.g., necessary variables, uninstallation, and the type of installation for the development PC.
  • The documentation has been extended by a new technical note "Surface-Based Matching". It contains information about different methods, troubleshooting, and further useful information regarding surface-based matching.
  • Within the HDevelop User's Guide, the chapter about Code Export has been improved. Further, the section about the Library Project Export now also provides a link to the tutorial video.
  • The HDevelop User's Guide has been improved. The content of the unspecific chapter "Miscellaneous" moved into other chapters. For example, the keyboard shortcuts are now in a first level chapter (Appendix D). Further, wrong or outdated shortcuts have been updated.
  • The index of the HDevelop User's Guide has been improved. Wrong and duplicate entries have been removed.
  • The section about system requirements within the Installation Guide mentioned an outdated requirement concerning the NVIDIA compute capability. This problem has been fixed.
  • The Extension Package Programmer's Guide did not give a description on the 'multiinstance' slot used for the parameter description in .def files. The reference manual entry of get_param_info did not mention this information either. The description has been added accordingly.

Solution Guides

  • The reference manual entry of evaluate_class_gmm did not clearly describe the meaning of the parameter 'KSigmaProb'. The reference has been adapted accordingly.
  • The chapter about calibrated mosaicking within the Solution Guide on 3D Vision has been extended by a new approach. For this approach, one calibration plate with hexagonally arranged marks is sufficient, thus the proceeding is simplified distinctly.
  • Within the Solution Guide Basics, the chapter about deflectometry has been improved to mention reflectors as possible source and to describe possible setups in more detail.
  • The Solution Guide on 3D Vision has been extended with information about the benefits of using 2D mappings when handling 3D objects.
  • The Solution Guide II-D Classification contained an ambiguous phrase about the necessity of training from scratch. The corresponding sentence has been clarified.

Reference Manual

  • The reference manual entry of boundary has been improved. Now, it mentions possible differences of output regions due to input parameter values.
  • The reference manual entry of create_caltab did not give sufficient information about the distribution of finder patterns on a calibration plate. The reference has been adapted accordingly.
  • The reference manual entry of create_data_code_2d_model contained an incomplete list of parameters that have different default values depending on the chosen recognition approach. This problem has been fixed.
  • The reference manual entries of create_funct_1d_array and create_funct_1d_pairs did not clearly state the meaning of all the components of the created function. This problem has been fixed.
  • The reference manual entries of create_shape_model, create_aniso_shape_model, create_scaled_shape_model, and inspect_shape_model have been extended to clearly describe the results to be expected when setting the minimum size for the parameter 'Contrast'.
  • The reference manual entry of derivate_gauss only mentioned the SSE2 optimization, but not further implementations. This problem has been fixed. Now, also optimizations for instructions of type AVX and AVX512f are mentioned.
  • The reference manual entries of eliminate_sp, mean_sp, gray_dilation_rect, gray_erosion_rect, gray_opening_rect, gray_closing_rect, gray_range_rect, illuminate, mean_image, and deviation_image did not state any information on maximum mask sizes. This problem has been fixed.
  • The reference manual entry of evaluate_class_gmm did not clearly describe the meaning of the parameter 'KSigmaProb'. The reference has been adapted accordingly.
  • The reference manual entry of find_box_3d did not clearly state the difference between setting the generic parameter 'box_type' to 'single_side_visible' and setting the parameter 'SideLen3' to '[-1]'. This problem has been fixed.
  • The reference manual entry for find_component_model has been improved. Now the information is structured better and thus it is easier to get an overview and find possible parts.
  • The reference manual entry of find_data_code_2d has been improved. Now, the parameters trained with this operator are documented for each option.
  • The reference manual entry of find_planar_uncalib_deformable_model falsely stated that the parameter 'angle_change_restriction' allows arbitrary deformation when set to 0 and no deformation when set to pi/2. The actual behavior is the other way around. This problem has been fixed.
  • The reference manual entry of find_surface_model was pruned by removing the description of the GenParamName 'score_type'. The default behavior of 'score_type' is sufficient for the use of the operator. Nevertheless, the parameter remains functioning to maintain backwards compatibility.
  • The reference manual entry of find_surface_model has been extended by adding descriptions for the generic parameters 'viewpoint' and 'max_gap'.
  • The German reference manual entry for the chapter 2D Transformations included a wrong axis assignment. This problem has been fixed.
  • A new reference manual chapter entry 'Calibration' was added. It gathers data applicable to different calibration setups. Among them are calibration recommendations, which are now centralized for improved readability. This allowed to prune other documentation parts and enhance their focus. As part of this work, the recommended values have been reviewed.
    The HDevelop example program 'hdevelop/Calibration/Multi-View/check_calib_image_quality.hdev' as well as the HDevelop Calibration Assistant have been updated and are in line with the current recommendations. As a consequence, the score for the image coverage by a single plate has been removed.
  • The reference manual entries of gen_circle_sector and gen_ellipse_sector were not clear concerning special angle combinations. This problem has been fixed.
  • The reference manual entry for gen_grid_region has been improved to describe some restrictions more clearly.
  • The reference manual entries of gen_region_histo and disp_distribution falsely referred to disp_image for a description of its control parameters 'Row', 'Column', and 'Scale'. This problem has been fixed.
  • The reference manual entry for get_bar_code_result had an erroneous entry for Code 128. This problem has been fixed.
  • The reference manual entry for get_bar_code_result has been modified to simplify the structure and make possible values better visible.
  • The reference manual entry of get_calib_data_observ_contours has been improved. Now, the involved parameters and finder patterns are described more clearly.
  • The reference manual entry of get_data_code_2d_results now mentions also the output parameters 'format information' and 'version information', which are returned when querying the print quality for QR Code and Micro QR Code with 'quality_isoiec_tr_29158' and 'quality_aimdpm_1_2006'.
  • The reference manual entry of get_deformable_model_params has been improved. Now, it is mentioned how further parameter values can be retrieved.
  • For certain parameter slots, the notation used in the .def files differed from the one used by the operator get_param_info and returned by the operator query_param_info. This has been fixed. Now, the operators get_param_info and query_param_info use the notation used in the .def file entries, while get_param_info still accepts the legacy notation.
  • The operator reference entry for get_param_info and the Extension Package Programmers Manual mention semtypes but forgot the type 'serial'. This problem has been fixed.
  • The operator reference manual of read_dl_model now explains the meaning of the four dimensions when reading in an ONNX model.
  • The reference manual entry of rectangle1_domain stated that the old image domain would be ignored, which is not the case. The reference has been adapted accordingly.
  • The reference manual entry of sample_object_model_3d has been extended by information on the computation of the model normals, depending on the input model.
  • The reference manual entry of select_points_object_model_3d has been extended by the information that if an empty object model is passed the error 9515 ("Required points missing in 3D object model") is raised.
  • The reference manual entry of set_data_code_2d_param did not mention an upper limit for the generic parameter 'contrast_min'. This problem has been fixed.
  • The reference manual still mentioned an outdated option of using set_paint with 'histogram'. This problem has been fixed.
  • The operator reference entry of set_surface_model_param did not clearly state how the parameter 'pose_restriction_max_angle_diff' is defined. The corresponding formula has been improved.
  • In the German reference manual entry of set_system 'cleanup' was not listed as a possible value for the system parameter 'global_mem_cache'. This problem has been fixed.
  • The reference manual entries of the deep learning training operators have been extended to mention their non-deterministic behavior. Additionally, the corresponding entry of set_system has been improved.
  • The operator reference of set_system now mentions that the value of the parameter 'thread_num' is automatically increased if the sum of thread-specific threads set in 'tsp_thread_num' exceeds 'thread_num'.
  • The reference manual entry of set_system has been extended with the information that the parameter 'int_zooming' affects different processing steps.
  • The reference manual entry of smooth_funct_1d_gauss did not explain how the maximum value for Sigma is effected by an equidistance of the x values differing from 1. This problem has been fixed.
  • The reference manual entry of train_dl_model_batch now mentions which loss values are returned and that they are returned for different levels in case of training a deep learning-based model of type object detection.
  • The reference manual entry for tuple_split has been improved. Now, its behavior regarding the different input tuple sizes is more obvious.
  • The reference documentation of the 'Format' parameter of the operator tuple_string has been revised.
  • The documentation of the operator uncalibrated_photometric_stereo has been improved.
  • The reference manual entry of union_straight_contours_xld did not mention that differing contour attributes prevented the union computation. This information has been added.
  • The reference manual entry of write_dl_model did not mention that the runtime-specific parameters 'runtime' and 'runtime_init' are not written. This problem has been fixed.
  • The reference manual entries of zoom_image_factor and zoom_image_size did not state that slightly different results can occur for different image types. This problem has been fixed.
  • Within the reference manual, the chapter Image has been extended with an introduction that provides an overview of the different image types.
  • Within the reference manual, the introduction of the chapter Bar Code has been extended with more detailed descriptions regarding the general bar code composition and symbols.
  • The reference manual chapter concerning deep learning models has been improved to provide a data structure overview.

Miscellaneous

Installation

  • HALCON has been extended with a hrun program, which is a command line utility to run HDevelop scripts.
  • The HALCON Student Edition now uses version 7.10a of the CodeMeter Runtime.
  • If a user searches for "MVTec" in the Windows taskbar, now HDevelop is listed.
  • The Deep Learning AddOn Installer for Windows has been split into two separate installers because of the size of the additional pretrained deep learning networks that are delivered with HALCON 20.11. The new installers are called
    • halcon-20.11.1.0-windows-deep-learning-core.exe
    • halcon-20.11.1.0-windows-deep-learning-data.exe
    The installer with the suffix "core" contains the NVIDIA Libraries Windows 10 as well as the pretrained deep learning networks. It contains everything that is required for building and running your own deep learning application. If you want to use deep learning, you always need this installer.
    The installer with the suffix "data" contains the data (images and pretrained deep learning networks) that are used by the deep learning example programs. Install it if you want to run the deep learning example programs that are part of the HALCON installation.
  • The ia_integration and io_integration examples, as well as the Image Acquisition Interface Programmer's Manual have been removed from the fileset. From now on, these files are available for download from our website.
  • The number of images in the image sequence 'xing', which is used as a traffic monitoring example, has been reduced. Furthermore, the HDevelop example program Applications/Security-Systems/xing_simple.hdev has been removed.
  • The Linux runtime installer unnecessarily contained the Qt libraries. This problem has been fixed.
  • The Ensenso-NxLib interface is no longer part of the HALCON installation.
  • In addition to the default offline installer, HALCON can now be installed using the MVTec Software Manager (SOM). This online installer is a package manager that downloads the required packages before installing them.
  • On macOS, the installer of the HALCON Student Edition did not update previously installed versions of CodeMeter Runtime. This problem has been fixed.
  • All proprietary image acquisition and digital I/O interfaces have been removed from the HALCON installer. All interfaces can still be downloaded from our web server.

Licensing

  • The HALCON Student Edition now uses version 7.10a of the CodeMeter Runtime.
  • The following licensing issues are known:
    • After starting applications based on HALCON 20.05 Progress (or later)/HALCON 20.11 Steady (or later), the dongle must be removed and inserted again before starting applications based on HALCON 19.11 (or earlier).
      This problem can be avoided by installing the CodeMeter Runtime from WIBU SYSTEMS AG. The CodeMeter Runtime is not shipped with HALCON and must be downloaded from https://www.wibu.com in the download area.
    • On Arm platforms (aarch64 architecture) with GLIBC 2.21, it is no longer possible to run both 64-bit and 32-bit HALCON processes in parallel because they might block each other.
    The Installation Guide has been adapted with the corresponding information. Note that this change affects the compatibility. Read more.

Follow this link to read about the changes of previous HALCON versions.