MVTec Software GmbH
  Building Vision For Business


Release Notes for HALCON 7.0

This document provides the release notes for MVTec HALCON 7.0, as released in December 2003. HALCON 7.0 is a major new release.


Overview

This document contains the following information:

Compatibility
Major New Features of HALCON 7.0
Detailed Description of Changes in HALCON 7.0 (relative to HALCON 6.1.2)
Major New Features of HALCON 6.1
Detailed Description of Changes in HALCON 6.1.2
Detailed Description of Changes in HALCON 6.1.1
Detailed Description of Changes in HALCON 6.1


Compatibility

o Licenses
    All HALCON 6.1 licenses must be replaced or upgraded. Please contact your local distributor.

o HALCON Library
    Compared to HALCON 6.1, many extensions have been introduced. Thus, the HALCON 7.0 libraries are not compatible with HALCON 6.1 or earlier versions.

o HALCON Applications
    Please re-compile all C or C++ programs developed with HALCON 6.1.x.
    The incompatibility with HALCON 6.1 or earlier versions mainly concerns the binaries, with only few changes in the operators' signatures. If you encounter problems during recompiling your programs, please check the detailed description of changes below and look up the signatures of the concerned operators in the reference manual.
    Please note the following incompatibilities:
    • The .def files of extension packages that use the sem_types affine2d and affine3d must be updated by changing affine2d to hom_mat2d and affine3d to hom_mat3d (see here).
    • Because of the changed data type for complex images, complex images cannot be sent and received with send_image and receive_image from HALCON 6.x and 5.x processes to HALCON 7.0 processes and vice versa.
    • Applications using user-defined FFT filters may need to be rewritten because of a change in the definition of exponents for fft_image, fft_image_inv, and gen_gabor.
    • Because of the improvements in HALCON's OCR, you must re-train font files created with previous HALCON versions.
    • All example images are now provided as PNG instead of TIFF and BMP files. This means that an application that tries to read such an example image and specifies the file name including the extension will produce an error message. If you leave out the extension, the application will run without problems.

o Frame Grabber Interfaces
    Frame grabber interfaces developed with HALCON 6.1.x are binary compatible with HALCON 7.0, interfaces developed with older versions must be re-generated.
    Please make sure that you no longer use the old PicPort, PicPortPro or PicProdigy interfaces that are part of older Leutron LV-SDS releases since these interfaces are not fully compatible with HALCON 7.0. Please use the new Leutron Interfaces instead.

o Extension Packages
    Please re-generate your own extension packages developed with HALCON 6.1.x.


o ActivVisionTools
    Since all ActivVisionTools versions are based on HALCON 6.1.1 or below, none of them can be used directly with HALCON 7.0. By installing HALCON 7.0, you would thus disable such an ActivVisionTools installation. Therefore, the setup program of HALCON 7.0 checks whether there is an ActivVisionTools installation on your computer.
    • If it detects ActivVisionTools 2.2, it offers to replace the corresponding OCX with a new one that is compatible to HALCON 7.0. Note that you might encounter problems with existing ActivVisionTools applications since HALCON 7.0 replaces also the used frame grabber interfaces.
    • In contrast, ActivVisionTools 1.0 to 2.1 cannot be used together with HALCON 7.0. If the setup program detects such an ActivVisionTools version, it warns you that by continuing to install HALCON 7.0 you will disable your ActivVisionTools installation.

      If you still want to use your ActivVisionTools installation you must also keep your old HALCON installation and switch back to it as described in the "Installation Guide". Note that if you only want to evaluate HALCON 7.0, you can minimize the switching effort by installing only the demo version.


Major New Features of HALCON 7.0

General Features

o Extended Functionality
  • HALCON's powerful matching has become even more versatile and flexible. It has been extended with a set of operators that enable you to find objects in images even when parts of the objects can move with respect to each other. This new component-based matching is also able to learn the movements of the components automatically based on a set of example images. Thus, the training of the model is simple. Furthermore, the search for the component model is much more efficient than searching for the individual components because the relative positions of the components is taken into account during the search to reduce the search space as much as possible.
  • The shape-based matching has been extended in several aspects, providing you with added flexibility and ease of use. First of all, a new mode has been introduced which can be used to generate models significantly faster. Furthermore, the model data now also contains a representation of the model as an XLD contour. This data is also stored when the model is written to a file. With this change, the shape model files now are self-contained and it should be unnecessary to store additional data of the model in separate files. Finally, a new operator enables you to determine the values of certain parameters explicitly without having to create the model. This is particularly useful in applications where the system should present the user with value suggestions that the user may modify.
  • HALCON 7.0 introduces a set of operators for stereo reconstruction. This enables you to measure the 3D shape of objects precisely and quickly. The new operators allow you to calibrate your stereo setup, to rectify the image pairs into a standard configuration in which the stereo matching can be performed with maximum efficiency, and to compute the disparity or depth for the entire image or for selected points only.
  • The operators for reading of 2D data codes have been improved significantly. The data code reader has been completely redesigned and reimplemented to achieve maximum robustness, flexibility, and ease of use. First of all, QR Code symbols can now be read in addition to the Data Matrix ECC 200 symbols that were supported in previous HALCON versions. Furthermore, the new reader is able to find and read the data code symbols even under the most difficult circumstances, e.g., when the code is etched or embossed on metal surfaces, or when the code appears disturbed, mirrored, or inverse.
  • HALCON 7.0 introduces operators the facilitate an automated creation of a mosaic image . With this set of operators, it is possible to combine several images of an object into a single large high-resolution image of the object without having to calibrate your camera. This functionality is based on a new set of operators that perform arbitrary 2D perspective transformations of images, regions, XLD contours, and points.
  • Novel methods for the subpixel-accurate extraction of color edges and lines have been implemented. This means that for the first time in machine vision history accurate measurements are possible for color images.
  • HALCON offers a new set of operators for OCR and classification based on neural nets. The new operators provide substantial improvements in the accuracy and reliability of the classification results. With the new operators, very high classification rates can be achieved. Furthermore, the confidences returned by the classification can be interpreted as a probability, and hence it is very easy to decide whether a classification result is reliable.
  • HALCON's existing OCR also has been improved in several aspects. For example, a new feature 'pixel_binary' has been introduced that provides better classification results in cases where the character can be segmented correctly, but the background contains unwanted structures that would make the classification based on gray value features difficult. Furthermore, several methods used to calculate features have been improved.
  • A new set of operators provides the means to rectify complex image distortions. With this new feature, you can perform measurements on curved surfaces like bottles or beverage cans by rectifying the image distortion to create a virtual "unwrapping" of the object's surface. Furthermore, the new functionality can also be used to rectify heavy distortions of lenses such that operations like OCR and bar code reading can be reliably performed.
  • The operators that are concerned with the FFT and filtering with the FFT have been improved significantly. HALCON's operators for performing the FFT are now up to 8 times faster. In addition, there is a new operator that computes only the non-redundant part of the FFT, which leads to another factor of 2 in increased performance. Furthermore, there are two new operators that generate filter masks in the frequency domain. All other filter mask operators have been extended such that optimum performance of the entire filtering process is easy to achieve.
  • There are several new operators that deal with the extraction of point-like structures from images. One group of operators extracts interest points with subpixel accuracy. These operators are, for example, useful to extract the necessary data for the image mosaicking. A second group of operators extracts critical points (local minima, maxima, and saddle points) with subpixel accuracy. Finally, there is a new specialized operator that extracts circular dots. This operator is, for example, very useful in OCR application, where it can be used to segment dot prints.
  • Two new operators that provide enhanced means to merge collinear XLD contours have been implemented. These new operators provide much more flexibility for this task than ever before. They can be used advantageously whenever the contours of an object may be broken into several parts, which may, for example, happen when edges are extracted and the contrast of the object's edges is very low in some parts.
  • HALCON 7.0 has two new operators that provide a more general and flexible image transformation from and to polar coordinates. In both operators, it is now possible to only transform an annular arc instead of a full circle. This makes it possible to transform only the relevant parts of the image, and hence the performance of the application can be increased. Furthermore, different interpolation methods can be used in the transformation.
  • HALCON's powerful processing of XLD contours has been extended with new operators that compute and process various geometric features of the contours. For example, distances between points and contours or between different contours can now be determined very efficiently.
  • A new set of operators that facilitates performing transformations of the local coordinate system for 2D and 3D affine transformations has been added. This is especially useful in robotics applications. Furthermore, a new operator for the transformation of pixel coordinates has been added.
  • Several new operators for processing 1D functions have been added. With these operators, it is very easy to perform sophisticated processing of the data, e.g., to extract the minima and maxima of a 1D function.
  • Two new operators for file and directory handling have been implemented. For example, it is now very easy to list the contents of a directory recursively with a single HALCON call.

o Parallel HALCON
    The performance of Parallel HALCON has been significantly improved under Windows by dramatically reducing the overhead for making parallel HALCON reentrant. The overhead of using Parallel HALCON on a single-processor machine is now less than 10% on most machines. Furthermore, the execution speed of operators that are parallelized automatically on multiprocessor machines has increased.

HDevelop

o Procedures
    HDevelop has been enhanced substantially by enabling you to generate and use procedures. This makes large projects easy to handle by structuring the code into logical processing units. Furthermore, procedures can be imported from different HDevelop programs, enabling you to build up a library of useful functionality that can be reused in different applications. Of course, procedures can also be exported into the target languages supported by HDevelop: C, C++, and Visual Basic. By structuring your code appropriately, it is now very easy to integrate the exported HDevelop code into your application without having to edit the exported code.

o Quick Access to Example Programs

Documentation

o New Manual: Quick Guide
    This manual provides a quick and interactive access to information about HALCON, both for beginners and advanced users. It explains how to apply HALCON's powerful image processing methods with examples from various industries and application areas. Furthermore, is describes how to develop applications using HDevelop or one of HALCON's interfaces to programming languages and gives an overview of the basic data structures.

o New Application Note: Machine Vision in World Coordinates
    This Application Note introduces you to HALCON's outstanding methods for performing machine vision in 3D world coordinates. You learn how to calibrate your camera and how to use the calibration data to transform results into 3D world coordinates or compensate distortion or the orientation of the camera. Furthermore, the Application Note explains how to use the new operators for stereo reconstruction. Finally, it shows how to combine multiple images into a larger mosaic image, either based on a calibrated setup or with the new operators for creating mosaic images without calibration.

o New Manual: Installation Guide
    This manual explains how to install HALCON, either for the first time or in form of an update or upgrade, and how to setup the different types of licenses.

o New Manual: Programmer's Guide
    This manual replaces the three manuals for HALCON's programming language interfaces. Furthermore, it describes how to use Parallel HALCON.

Detailed Description of Changes in HALCON 7.0

Detailed release notes can be obtained for the following topics:

HDevelop
HALCON Library
HALCON/C
HALCON/C++
HALCON/COM
Frame Grabber Interfaces
Extension Package Interface
HMatchIt
Miscellaneous
Please note that these release notes are relative to HALCON 6.1.2. If you are upgrading from earlier versions, you should also consult the release notes for earlier HALCON versions.


HDevelop

o Speed-Up and Enhancements:
  • HDevelop has been enhanced substantially by enabling the user to generate and use procedures. Procedures are treated in the same manner as HALCON operators, i.e., they are functional and follow the same rules for parameters as HALCON operators. It is possible to step into, over, and out of procedures during the program execution. Furthermore, procedures can be imported from different HDevelop programs, making it possible to build up a library of useful functionality that can be reused in different applications. Procedures can also be exported into the target languages supported by HDevelop: C, C++, and Visual Basic.
  • HDevelop now has a dialog "Open Example Program", which enables users to load HDevelop example programs grouped by industry, application area, or method.

o Functionality:
  • HDevelop's language provides 9 new tuple functions:
    • find returns the indices of all the occurences of a tuple within another tuple.
    • uniq discards all but one of successive identical elements from the input tuple.
    • int converts a tuple to integer values by truncating floating point values.
    • min2 and max2 calculate the element-wise minimum or maximum of two tuples.
    • The operator % calculates the element-wise modulus of an integer division.
    • rand returns a tuple of random numbers distributed uniformly in the interval [0,1).
    • sgn calculates the element-wise sign of a tuple, i.e., it returns +1 if the element is positive, -1 if the element is negative, and 0 if the element is 0.
    • subset selects a subset of elements of a tuple. Note that the operator tuple_select already provided the above functionality. Consequently, HDevelop exports function calls to subset to calls to tuple_select in C and Visual Basic.

o Examples:
  • The following new example programs show how to use the new operators for component-based matching: cbm_pipe_wrench.dev, cbm_dip_switch.dev, cbm_caliper.dev, and cbm_bin_switch.dev in examples/hdevelop/Applications/FA, and cbm_label_simple.dev, cbm_pipe_wrench_simple.dev, cbm_modules_simple.dev, cbm_param_visual.dev, and cbm_sbm.dev in examples/hdevelop/Matching/Component-Based. The example programs use the new example images in the directories pipe_wrench, modules, label, dip_switch, caliper, and bin_switch.
  • The example program examples/hdevelop/Matching/Shape-Based/find_scaled_shape_model.dev has been modified to use the shape-based matching without pregenerated models.
  • The example programs pm_measure_board.dev, pm_world_plane.dev, and pm_multiple_models.dev in the directory examples/hdevelop/Applications/FA and examples/Matching/Shape-Based/find_scaled_shape_model.dev have been adapted to make use of the new operator get_shape_model_contours.
  • The following new example programs show how to use the new operators for stereo reconstruction: board_components.dev and disparity.dev in examples/hdevelop/Applications/Stereo, and binocular_calibration.dev, binocular_disparity.dev, binocular_disparity_segmentation.dev, disparity_to_point_3d, and intersect_lines_of_sight.dev in examples/hdevelop/Tools/Stereo. The example programs use the new example images in the directories stereo/board and stereo/epipolar.
  • The new example programs ecc200_simple.dev, ecc200_optimized.dev, qrcode_simple.dev, qrcode_optimized.dev in examples/hdevelop/Applications/Datacode, and ecc200_default_settings.dev, ecc200_optimized_settings.dev, ecc200_training.dev, ecc200_write_model.dev, ecc200_read_model.dev, qrcode_default_settings.dev, and qrcode_optimized_settings.dev in examples/hdevelop/Tools/Datacode show how to use the new operators for detecting and decoding 2D data codes. The programs use the new example images in the directories images/datacode/ecc200 and images/datacode/qrcode.
  • The new example program examples/hdevelop/Applications/OCR/letters_mlp.dev shows how to use the new OCR classifier based on multilayer perceptrons (neural nets). Furthermore, the example programs engraved.dev and bottle.dev in the directory examples/hdevelop/Applications/OCR have been rewritten for the new OCR classifier. In addition, the new training examples engravedt.dev and bottlet.dev have been added in the directory examples/hdevelop/Applications/OCR.
  • The new example programs class_overlap.dev and regression.dev in the directory examples/hdevelop/Classification/Neural-Nets and the programs examples/hdevelop/Segmentation/Classification/classify_image_class_mlp.dev and examples/hdevelop/Filter/Texture/texture_laws_mlp.dev show how to use the new classification operators based on multilayer perceptrons (neural nets).
  • The following new example programs show how to use the new operators for projective transformations: projective_trans_image.dev and projective_trans_image_reduced.dev in examples/hdevelop/Filter/Geometric-Transformations, projective_trans_region.dev in examples/hdevelop/Regions/Geometric-Transformations, projective_trans_contour_xld.dev in examples/hdevelop/XLD/Transformation, and gen_projective_mosaic.dev, hom_vector_to_proj_hom_mat2d.dev, projective_trans_point_2d.dev, projective_trans_pixel.dev, and vector_to_proj_hom_mat2d.dev in examples/hdevelop/Tools/2D-Transformations.
  • The new example programs edges_color.dev, edges_color_sub_pix.dev in the directory examples/hdevelop/Filter/Edges, and the program examples/hdevelop/Filter/Lines/lines_color.dev show how to use the new operators for color edge and line extraction. The programs use the new example images olympic_stadium.png, cable1.png, and cable2.png in the directory images.
  • The new example programs programs grid_rectification.dev and gen_arbitrary_distortion_map.dev in the directory examples/hdevelop/Tools/Grid-Rectification show how to use the new operators for rectifying images. grid_rectification.dev uses the new example images images/can.png and images/can_with_grid.png.
  • The new example programs optimize_fft_speed.dev and rft_generic.dev in the directory examples/hdevelop/Filter/FFT show how to use the extensions of HALCON's FFT. Furthermore, the program examples/hdevelop/Tools/Shape-from/phot_stereo.dev has been modified to use the new operator optimize_fft_speed.
  • The new example programs points_foerstner.dev, points_foerstner_rotation.dev, points_foerstner_ellipses.dev, points_harris.dev, points_harris_rotation.dev, and points_sojka.dev in the directory examples/hdevelop/Filter/Points show how to use the new point operators.
  • The new example programs critical_points_sub_pix.dev, local_max_sub_pix.dev, and saddle_points_sub_pix.dev in the directory examples/hdevelop/Segmentation/Topography show how to use the new operators extracting critical points. saddle_points_sub_pix.dev uses the new example image images/landmarks.png.
  • The new example program examples/hdevelop/Filter/Points/dots_image.dev shows how to use the new operator dots_image.
  • The new example programs local_min.dev, lowlands.dev, and lowlands_center.dev in the directory examples/hdevelop/Segmentation/Topography show how to use the new operators extracting local minima and lowlands.
  • The new example programs distance_cc_min.dev and distance_pc.dev in examples/hdevelop/Tools/Geometry, test_xld_point.dev and select_xld_point.dev in examples/hdevelop/XLD/Features, and close_contours_xld.dev and sort_contours_xld.dev in examples/hdevelop/XLD/Transformation show how to use the new XLD operators.
  • The new example program examples/hdevelop/File/Misc/list_files.dev shows how to use the new operator list_files.
  • The subdirectory examples/quick_guide/hdevelop contains 23 new example programs used in the Quick Guide to HALCON. They use the new example images atoms.png, crystal.png, fuse.png, surface_scratch.png, and numbers_scale.png in images/, and the new images in the subdirectory images/coins.
  • The subdirectory examples/application_guide/3d_machine_vision/hdevelop contains 12 new example programs used in the Application Note on 3D Machine Vision. They use the new example images in the subdirectory images/3d_machine_vision.
  • The example program examples/hdevelop/Applications/Sequences/sequence_diff.dev has been rewritten to no longer use the images in the directory images/bvlab_2p. As a consequence, the images in the directories images/bvlab_2p and images/bvlab_hp are no longer shipped with HALCON because they are no longer used.
  • The example programs examples/hdevelop/Applications/Sequences/sequence_bg.dev and examples/hdevelop/Filter/Match/optical_flow_match.dev have been removed.

o Bug Fixes:
  • C-code exported by HDevelop caused a memory leak if an operator line contained at least one input and output control parameter that were equal. This problem has been fixed.
  • If a sequence file is opened using the virtual frame grabber, dev_update_var is set to 'off', and the FGHandle dialog is opened, then the value for 'Device' is now correctly set to the current image.
  • Various HDevelop operators crashed if empty tuples were passed as input control parameters. This problem has been fixed.
  • Under Windows, HDevelop crashed in rare cases when trying to cancel user interaction via stop. This problem has been fixed.
  • HDevelop crashed after finishing a call to the HALCON operators draw_region or draw_polygon in case the gray histogram dialog was visible and contained no image data at the time of the operator call. This problem has been fixed.
  • Under Windows 2000 and XP, the mouse cursor vanished if the return key was pressed in certain comboboxes, e.g., in the Operator combobox. This happened because the operating system hides the mouse cursor in these cases. Now, HDevelop forces the standard arrow cursor to reappear in these cases.

o Manual:
  • The HDevelop User's Manual is now available in a new edition. It now describes in detail how to work with the newly introduced HDevelop procedures.

HALCON Library

o New Operators:
  • HALCON now has operators to find compound objects in images. The shape-based matching has been extended to find objects that may be composed of components that can move with respect to each other.

    Furthermore, it is possible to train the model of the compound object by simply showing the system multiple images with varying objects. HALCON then automatically learns the relative movement (x, y, and angle) and extracts possible components.

    The new functionality is provided by the following new operators:

    • The operators gen_initial_components, train_model_components, inspect_clustered_components, cluster_model_components, modify_component_relations, get_training_components, get_component_relations, write_training_components, read_training_components, clear_training_components, and clear_all_training_components can be used to train the model components automatically.
    • The operators create_trained_component_model, create_component_model, get_component_model_params, get_component_model_tree, write_component_model, read_component_model, clear_component_model, and clear_all_component_models can be used to create and handle component models.
    • Finally, the operators find_component_model and get_found_component_model can be used to find the component model.

    The new example programs cbm_pipe_wrench.dev, cbm_dip_switch.dev, cbm_caliper.dev, and cbm_bin_switch.dev in examples/hdevelop/Applications/FA, and the programs cbm_label_simple.dev, cbm_pipe_wrench_simple.dev, cbm_modules_simple.dev, cbm_param_visual.dev, and cbm_sbm.dev in examples/hdevelop/Matching/Component-Based show how to use the new operators.

  • HALCON's shape-based matching has been further extended:
    • create_shape_model and create_scaled_shape_model now have a mode in which the model is not pregenerated completely. This is beneficial in applications in which the number of discrete model poses (i.e., the search space) is very large, and hence the creation of the model takes a relatively long time.

      Consequently, the model must be transformed at run time during the search in find_shape_model and all variants thereof.

      The documentation of create_shape_model and create_scaled_shape_model have been extended to describe this new mode.

      To ease the porting of existing applications to use the new functionality, set_system now has a parameter 'pregenerate_shape_models' that determines the default behavior of the pregeneration in create_shape_model and create_scaled_shape_model. The documentation of set_system has been extended accordingly.

      The example program examples/hdevelop/Matching/Shape-Based/find_scaled_shape_model.dev has been modified to use the new functionality.

    • HALCON now has an operator get_shape_model_contours that returns a representation of the shape model as XLD contours. This operator is useful to visualize the found instances of the model because it removes the necessity to call inspect_shape_model to create a representation of the model that can be used for visualization.

      To facilitate this operator, create_shape_model now stores additional data with the model that enable the generation of the XLD contour representation of the model. Consequently, write_shape_model writes this additional information to the shape model file. Because of this, the file format of the shape model files has changed. Older shape model files can still be read. However, they do not contain sufficient information to enable the XLD contour representation to be created. Therefore, get_shape_model_contours returns an empty set of XLD contours when called with a model that has been written to file with previous HALCON versions.

      The following example programs have been modified to make use of get_shape_model_contours: pm_measure_board.dev, pm_world_plane.dev, and pm_multiple_models.dev in the directory examples/hdevelop/Applications/FA, and examples/Matching/Shape-Based/find_scaled_shape_model.dev.

    • HALCON now has an operator determine_shape_model_params that explicitly computes the parameters that are estimated when the respective parameters in create_shape_model are set to 0. This means that determine_shape_model_params is able to compute the number of pyramid levels and the angle and scale step widths without creating an actual model.
  • HALCON now has operators for binocular stereo reconstruction. These operators allow to calibrate a binocular camera setup and then to rectify the images of these cameras in order to get an image pair with parallel, horizontal epipolar lines. Based on a pair of epipolar images, the new operators allow to reconstruct 3D information coded in a disparity or distance image.

    The new functionality is provided by the following operators:

    • The operators binocular_calibration and gen_binocular_rectification_map perform the calibration and rectification of the camera setup.
    • The operators binocular_disparity and binocular_distance provide 3D stereo reconstruction of an epipolar image pair.
    • Finally, the operators distance_to_disparity, disparity_to_distance, disparity_to_point_3d, and intersect_lines_of_sight supply auxiliary functionality.

    The new example programs board_components.dev and disparity.dev in examples/hdevelop/Applications/Stereo, and the programs binocular_calibration.dev, binocular_disparity.dev, binocular_disparity_segmentation.dev, disparity_to_point_3d, and intersect_lines_of_sight.dev in examples/hdevelop/Tools/Stereo show how to use the new operators. The example programs use the new example images in the directories stereo/board and stereo/epipolar.

  • HALCON now has a new set of operators for detecting and decoding 2D data codes. These operators support the following symbologies: Data matrix ECC 200 and QR Code (Model 1 and 2). Besides supporting QR Code now, this operator set is much easier to use than the old 2D bar code operators and produces much better results. In addition, there is a training mode for easily adapting the model to a class of data code symbols.

    The new functionality is provided by the following new operators: create_data_code_2d_model, clear_data_code_2d_model, clear_all_data_code_2d_models, find_data_code_2d, query_data_code_2d_params, set_data_code_2d_param, get_data_code_2d_param, get_data_code_2d_results, get_data_code_2d_objects, write_data_code_2d_model, read_data_code_2d_model.

    The new example programs ecc200_simple.dev, ecc200_optimized.dev, qrcode_simple.dev, qrcode_optimized.dev in examples/hdevelop/Applications/Datacode, and ecc200_default_settings.dev, ecc200_optimized_settings.dev, ecc200_training.dev, ecc200_write_model.dev, ecc200_read_model.dev, qrcode_default_settings.dev, and qrcode_optimized_settings.dev in examples/hdevelop/Tools/Datacode demonstrate how to use the new operators. The C++ program examples/cpp/source/ecc200.cpp was adapted to the new operators. The example programs use the new example images in the directories images/datacode/ecc200 and images/datacode/qrcode.

    The old 2D bar code operators gen_2d_bar_code_descr, find_2d_bar_code, get_2d_bar_code, get_2d_bar_code_pos, decode_2d_bar_code are now obsolete and are no longer supported. However, for compatibility reasons they will remain in HALCON. Applications should be rewritten to use the new set of operators.

  • HALCON now provides operators for mosaicking, i.e., the creation of a large image from several images that must either be taken with a camera that only rotates around its optical center or taken with a moving camera that captures a flat surface. The images may exhibit perspective distortions, which can be rectified by the mosaicking process. The projective mosaic is created by the new operator gen_projective_mosaic, which takes a set of images and a set of transformation matrices between pairs of images as input.

    The projection matrices between the image pairs can be created automatically with the new operator proj_match_points_ransac, which takes two point sets in the two images as input. The operator determines the point correspondences automatically using a RANSAC approach, and computes the 2D projection matrix from the point correspondences.

    The new example program examples/hdevelop/Tools/2D-Transformations/gen_projective_mosaic.dev shows how to use gen_projective_mosaic and proj_match_points_ransac. It uses the new example images in the directory images/mosaic.

    The mosaicking is based on the new operators for projective transformations described next.

  • HALCON now provides operators for the so-called projective transformations, which correspond to arbitrary 2D perspective transformations. With the new operators projective_trans_image, projective_trans_image_size, projective_trans_region, projective_trans_contour_xld, projective_trans_point_2d, and projective_trans_pixel, you can apply arbitrary 2D perspective transformations to images, regions, XLD contours, point and pixel coordinates, respectively.

    Projective transformation matrices can be created as follows:

    • With the new operator hom_mat3d_project, which creates a 2D projection matrix from a 3D homogeneous matrix. The operator assumes that the 3D matrix represents the pose of a plane in 3D, which is projected using a simple camera model to a 2D plane. The new example programs projective_trans_image.dev and projective_trans_image_reduced.dev in examples/hdevelop/Filter/Geometric-Transformations, examples/hdevelop/Regions/Geometric-Transformations/projective_trans_region.dev, examples/hdevelop/XLD/Transformation/projective_trans_contour_xld.dev, and projective_trans_point_2d.dev and projective_trans_pixel.dev in examples/hdevelop/Tools/2D-Transformations show how to use hom_mat3d_project.
    • With the new operator hom_vector_to_proj_hom_mat2d, which creates a 2D projection matrix from homogeneous point correspondences. The input to hom_vector_to_proj_hom_mat2d is a set of homogeneous 2D points (specified by three coordinates) to enable the user to specify that certain points are mapped to the line at infinity. The new example program examples/hdevelop/Tools/2D-Transformations/hom_vector_to_proj_hom_mat2d.dev shows how to use hom_vector_to_proj_hom_mat2d.
    • With the new operator vector_to_proj_hom_mat2d, which creates a 2D projection matrix from point correspondences. The input to vector_to_proj_hom_mat2d is a set of 2D points (specified by two coordinates). Furthermore, vector_to_proj_hom_mat2d is able to take the covariances of the points into account when determining the 2D projection matrix. The new example program examples/hdevelop/Tools/2D-Transformations/vector_to_proj_hom_mat2d.dev shows how to use vector_to_proj_hom_mat2d.

    The new examples programs projective_trans_image.dev and projective_trans_image_reduced.dev in examples/hdevelop/Filter/Geometric-Transformations, examples/hdevelop/Regions/Geometric-Transformations/projective_trans_region.dev, examples/hdevelop/XLD/Transformation/projective_trans_contour_xld.dev, and projective_trans_point_2d.dev and projective_trans_pixel.dev in examples/hdevelop/Tools/2D-Transformations show how to use these operators.

    To introduce the projective transformations, the following changes were applied to existing operators:

    • The semantic type of homogeneous transformation matrices has been changed from affine2d and affine3d to hom_mat2d and hom_mat3d in hcomp. The .def files of extension packages that use these sem_types must be updated by changing affine2d to hom_mat2d and affine3d to hom_mat3d.
    • The operators hom_mat2d_translate, hom_mat2d_scale, hom_mat2d_rotate, hom_mat2d_slant, hom_mat2d_compose, and hom_mat2d_invert have been extended to handle full 3x3 homogeneous 2D transformation matrices in addition to the abbreviated 2x3 homogeneous 2D transformation matrices. With this, 2D perspective transformations can be modified in the same manner as affine 2D transformations.
    • The operators hom_mat2d_to_affine_par, affine_trans_image_size, affine_trans_image, affine_trans_region, affine_trans_polygon_xld, affine_trans_contour_xld, affine_trans_pixel, and affine_trans_point_2d have been extended to also accept full 3x3 homogeneous 2D transformation matrices. They check whether the 3x3 transformation matrix represents an affine transformation, i.e., if the last row of the matrix is of the form [0,0,c], where c <> 0. If this is not the case, an error is returned.
  • HALCON now has 3 new operators for extracting edges (edges_color and edges_color_sub_pix) and lines (lines_color) from color images using a multispectral gradient. edges_color_sub_pix and lines_color provide results with subpixel precision.

    The new example programs edges_color.dev, edges_color_sub_pix.dev in the directory examples/hdevelop/Filter/Edges, and the program examples/hdevelop/Filter/Lines/lines_color.dev show how to use the new operators.

  • HALCON has been extended by an OCR classifier based on multilayer perceptrons (neural nets). The OCR classifier comprises the following operators in the chapter OCR -> Neural-Nets: clear_all_ocr_class_mlp, clear_ocr_class_mlp, create_ocr_class_mlp, do_ocr_multi_class_mlp, do_ocr_single_class_mlp, get_features_ocr_class_mlp, get_params_ocr_class_mlp, get_prep_info_ocr_class_mlp, read_ocr_class_mlp, trainf_ocr_class_mlp, write_ocr_class_mlp.

    The new example program examples/hdevelop/Applications/OCR/letters_mlp.dev shows how to use the new functionality.

    The following existing OCR examples in the directory examples/hdevelop/Applications/OCR have been rewritten for the new classifier: engraved.dev and bottle.dev. In addition, the new training examples engravedt.dev and bottlet.dev have been added in the directory examples/hdevelop/Applications/OCR.

    The new OCR classifier is based on the general multilayer perceptron classifier described next.

  • HALCON has been extended by a classifier based on multilayer perceptrons (neural nets). The classifier comprises the following operators in the chapter Classification -> Neural Nets: add_sample_class_mlp, classify_class_mlp, clear_all_class_mlp, clear_class_mlp, clear_samples_class_mlp, create_class_mlp, evaluate_class_mlp, get_params_class_mlp, get_prep_info_class_mlp, get_sample_class_mlp, get_sample_num_class_mlp, read_class_mlp, read_samples_class_mlp, train_class_mlp, write_class_mlp, write_samples_class_mlp.

    The new example programs class_overlap.dev and regression.dev in the directory examples/hdevelop/Classification/Neural-Nets show how to use the classifier.

    The classifier also comprises the following new operators (in the chapter Segmentation -> Classification) to classify multichannel images: add_samples_image_class_mlp, classify_image_class_mlp. How to use these operators for pixel and texture classification is shown in the new example programs examples/hdevelop/Segmentation/Classification/classify_image_class_mlp.dev and examples/hdevelop/Filter/Texture/texture_laws_mlp.dev.

  • The new operators create_rectification_grid, find_rectification_grid, connect_grid_points, gen_grid_rectification_map, and gen_arbitrary_distortion_map allow to rectify images based on a calibration with rectilinear grids.

    The new example programs grid_rectification.dev and gen_arbitrary_distortion_map.dev in the directory examples/hdevelop/Tools/Grid-Rectification show how to use the new operators. They use the new example images can.png and can_with_grid.png

  • HALCON now has 3 new operators for extracting points: points_foerstner, points_harris, and points_sojka extract interest points from an image using the Förstner or Harris operator or the algorithm proposed by E. Sojka, respectively.

    The new example programs points_foerstner.dev, points_foerstner_rotation.dev, points_foerstner_ellipses.dev, points_harris.dev, points_harris_rotation.dev, and points_sojka.dev in the directory examples/hdevelop/Filter/Points show how to use these operators.

    The example program corner_response.dev has been moved from the directory examples/hdevelop/Filter/Match/ to examples/hdevelop/Filter/Points/corner_response.dev.

  • HALCON now has 4 new operators for extracting critical points from an image with subpixel precision: local_max_sub_pix, local_min_sub_pix, and saddle_points_sub_pix extract local maxima, local minima, and saddle points, respectively. critical_points_sub_pix extracts all three types of points.

    The new example programs critical_points_sub_pix.dev, local_max_sub_pix.dev, and saddle_points_sub_pix.dev in the directory examples/hdevelop/Segmentation/Topography show how to use these operators.

  • HALCON now has an operator dots_image, which implements a specialized linear matched filter that enhances circular dots in an image. This filter is especially useful for segmenting dot prints in OCR applications.

    The new example program examples/hdevelop/Filter/Points/dots_image.dev shows how to use dots_image.

  • Two new operators union_collinear_contours_xld and union_collinear_contours_ext_xld have been implemented. They can be used to merge contours within an XLD contour array that are nearly collinear to each other, i.e. which lie nearly on one straight line. Whereas the operator union_collinear_contours_xld provides only the most basic parameters for selecting collinearity and is quite simple to use, the operator union_collinear_contours_ext_xld is more sophisticated and allows to control the level of collinearity very precisely.

    The example programs examples/hdevelop/XLD/Transformation/union_contours_xld.dev and examples/hdevelop/Tools/2D-Transformations/vector_to_proj_hom_mat2d.dev show how to use union_collinear_contours_xld. union_contours_xld.dev uses the new example image pads.png.

  • HALCON now has an operator polar_trans_image_ext that allows to transform only an annular arc instead of a full circle that starts at the center of the circle (as in the operator polar_trans_image). A second new operator, polar_trans_image_inv, can be used to transform a polar image (which has been created by polar_trans_image or polar_trans_image_ext) back to cartesian coordinates.

    The new example program examples/hdevelop/Applications/Barcode/circular_barcode.dev shows how to use polar_trans_image_ext. It uses the new example image images/circular_barcode.png

  • HALCON now has 9 new operators that extend the possibilities to with XLDs:
    • Five new operators compute distances between XLD contours (distance_cc and distance_cc_min), between a point and an XLD contour (distance_pc), and between a line or line segment and an XLD contour (distance_lc, distance_sc). The new example programs distance_cc_min.dev and distance_pc.dev in examples/hdevelop/Tools/Geometry show how to use distance_cc_min and distance_pc.
    • test_xld_point returns whether a given point lies within a given XLD contour. The new example program examples/hdevelop/XLD/Features/test_xld_point.dev shows how to use this operator.
    • Similarly to select_region_point, select_xld_point selects all XLD objects that contain a given point. The new example program examples/hdevelop/XLD/Features/select_xld_point.dev shows how to use the new operator.
    • sort_contours_xld sorts the elements of a XLD contour array according to their spatial order. The example program examples/hdevelop/XLD/Transformation/sort_contours_xld.dev shows how to use this operator.
    • close_contours_xld closes open contours. The new example program examples/hdevelop/XLD/Transformation/close_contours_xld.dev shows how to use this operator.
  • The operators hom_mat2d_translate_local, hom_mat2d_scale_local, hom_mat2d_rotate_local, hom_mat2d_slant_local, hom_mat3d_translate_local, hom_mat3d_scale_local, and hom_mat3d_rotate_local have been added. They modify homogeneous 2D and 3D matrices from the right. This has the effect of changing the local coordinate system.
  • HALCON now has an operator affine_trans_pixel. In contrast to affine_trans_point_2d, affine_trans_pixel regards the input points as pixels, i.e., having the origin at the upper left corner of the upper left pixel in the image.

    The following example programs have been modified to use affine_trans_pixel: examples/hdevelop/Applications/FA/pm_measure_board.dev, and the matching examples in the directories examples/mfc, examples/vb/Tools, examples/vb.net, examples/c#, examples/delphi, and examples/motif/Matching.

  • HALCON has been extended with the operators zero_crossings_funct_1d, local_min_max_funct_1d, and derivate_funct_1d, which calculate the zero crossings, local minima and maxima, and first or second derivatives of 1D functions.
  • HALCON now has 2 new operators for file and directory handling:
    • list_files is able to list all files and optionally directories in a directory. list_files is also able to list the files recursively. The new example program examples/hdevelop/File/Misc/list_files.dev shows how to use this operator.
    • delete_file deletes a specified file.
  • HALCON now has operators local_min, lowlands, and lowlands_center, which are analogous to local_max, plateaus, and plateaus_center, but extract local minima.

    The new example programs local_min.dev, lowlands.dev, and lowlands_center.dev in the directory examples/hdevelop/Segmentation/Topography show how to use the new operators.

  • HALCON has been extended with an operator symm_difference that computes the symmetric difference of two regions.
  • HALCON now has an operator sqrt_image that computes the square root of an image.
  • The operators draw_xld and draw_xld_mod have been added. With these operators, XLD contours can be drawn and modified interactively.
  • HALCON has a new operator disp_cross, which displays a cross at a given subpixel location. The user can choose the size and the orientation of the displayed cross. Alternatively, the new operator gen_cross_contour_xld can be used, which creates a cross-shaped XLD contour from a tuple of points. This operator is especially useful to create visualizations of extracted points in HDevelop.
  • The two new operators find_1d_bar_code_scanline and get_1d_bar_code_scanline allow to query information about the scanlines used for decoding a 1D bar code.
  • HALCON now has an operator get_socket_descriptor that returns the operating system socket descriptor used by the HALCON socket.
  • HALCON now has an operator overpaint_gray similar to paint_gray, and an operator overpaint_region similar to paint_region. Instead of creating a new image, the data is copied into the given image. This enhances the performance.
  • HALCON now provides 8 new tuple operators:
    • tuple_find returns the indices of all the occurences of a tuple within another tuple.
    • tuple_uniq discards all but one of successive identical elements from the input tuple.
    • tuple_int converts a tuple to integer values by truncating floating point values.
    • tuple_min2 and tuple_max2 calculate the element-wise minimum or maximum of two tuples.
    • tuple_mod calculates the element-wise modulus of an integer division.
    • tuple_rand returns a tuple of random numbers distributed uniformly in the interval [0,1).
    • tuple_sgn calculates the element-wise sign of a tuple, i.e., it returns +1 if the element is positive, -1 if the element is negative, and 0 if the element is 0.

o Speed-Up and Enhancements:
  • The overhead for making parallel HALCON reentrant on Windows has been reduced significantly. This results in faster operator execution in Parallel HALCON. For example, the overhead of using Parallel HALCON on a single-processor machine is now less than 10% on most machines. Furthermore, the execution speed of operators that are parallelized automatically on multiprocessor machines has increased.
  • The calculation of features and confidences for the OCR has been improved. This results in a better classification rate in many applications and more intuitive confidence values.

    Note that trained font files for HALCON 6.1 and earlier are no longer compatible with HALCON 7.0. To make use of old image data the OCR has to be trained again.

  • HALCON's OCR has a new feature 'pixel_binary', which converts the segmented region into a binary image, scales the binary image to the selected width and height with the selected interpolation mode, and uses the resulting gray values as features. The documentation has been extended accordingly.
  • HALCON's FFT has been substantially enhanced:
    • First of all, the operators that use the FFT (fft_image, fft_image_inv, fft_generic, wiener_filter, wiener_filter_ni, simulate_defocus, simulate_motion, sfs_mod_lr, sfs_orig_lr, sfs_pentland, phot_stereo) are now faster by up to a factor of 8.
    • The new operator optimize_fft_speed optimizes the run time for a particular image size. The new operators write_fft_optimization_data and read_fft_optimization_data allow to save and load the optimization data.

      The new example program examples/hdevelop/Filter/FFT/optimize_fft_speed.dev shows how to use optimize_fft_speed. In addition, the example program examples/hdevelop/Tools/Shape-from/phot_stereo.dev has been modified to use optimize_fft_speed.

    • Since the normalization and shifting of the DC term to the center of the image takes a substantial amount of time, the operators that create filter masks (gen_bandfilter, gen_bandpass, gen_highpass, gen_lowpass, gen_sin_bandpass, gen_std_bandpass, gen_gabor) have been modified to have new parameters that allow to incorporate the normalization into the filter and to specify the location of the DC term so that fft_generic can be used with Norm = 'none' and Mode = 'dc_edge' in both transformations to gain maximum speed. This means that the output image type of the filter generating operators had to be changed to real.

      As a consequence of this change, the filter-generating operators gen_bandfilter, gen_bandpass, gen_highpass, gen_lowpass, gen_sin_bandpass, gen_std_bandpass, and gen_gabor are not source code compatible with previous HALCON versions.

    • The operator fft_generic has been modified to have a parameter that allows to specify the result image type in the transformation from the frequency domain. Again, this causes a source code incompatibility with previous HALCON versions. To get the previous behavior, the new parameter ResultType must be set to 'complex' in all cases.

    • The operator convol_fft has been extended to process filters with an image type complex. The new example program examples/hdevelop/Filter/FFT/rft_generic.dev shows how convol_fft can be used with a complex filter.
    • HALCON has been extended with the operators gen_derivative_filter and gen_gauss_filter, which generate a derivative or Gauss filter, respectively, in the frequency domain. The new example programs examples/hdevelop/Filter/FFT/rft_generic.dev shows how to use these operators.
    • The exponents used in fft_image and fft_image_inv have been reversed: fft_image now uses -1 while fft_image_inv now uses +1. This is compatible with the definition of the FFT that is used most frequently. Furthermore, gen_gabor has been modified to use this convention. This may cause an incompatibility if user-defined filters are used in the application. Such applications must be rewritten to use fft_generic for the transformation instead of fft_image and fft_image_inv. If an application only used filters that are provided by HALCON, the change is transparent to the application.

      The documentation has been adapted to reflect this change.

    • HALCON has a new operator rft_generic that calculates the FFT of an image while only returning the non-redundant part of the complex output image. Furthermore, a new operator optimize_rft_speed that optimizes the run time for a particular image size has been implemented. The new example program examples/hdevelop/Filter/FFT/rft_generic.dev shows how to use rft_generic and optimize_rft_speed.

      Consequently, the operators that create filter masks (gen_bandfilter, gen_bandpass, gen_highpass, gen_lowpass, gen_sin_bandpass, gen_std_bandpass) have a new mode in which filters for rft_generic can be created.

    • HALCON now has an operator correlation_fft that computes the correlation of two Fourier-transformed images in the frequency domain.
  • HALCON's data type for complex images has been changed from two separate images (for the real and imaginary part) to a single image of complex numbers. Because of this change, complex images cannot be sent and received with send_image and receive_image from HALCON 6.x and 5.x processes to HALCON 7.0 processes and vice versa. The documentation in "Extension Package Programmer's Manual" has been adapted accordingly.
  • The operator find_1d_barcode now has two new attributes 'element_orientation' and 'element_orientation_tolerance'. With these attributes it is possible to preselect edges of a specific orientation.

o Modified Operators:
  • The operators bin_threshold and equ_histo_image now support uint2 images.
  • The operator camera_calibration now supports setting EstimateParams to 'pose' to make it easier for users to determine the pose of the camera. Previously, EstimateParams had to be set to ['alpha', 'beta', 'gamma', 'transx', 'transy', 'transz'] to determine the pose. The documentation has been extended accordingly. The example program examples/vb/Tools/Calibration has been modified to use the new parameter value.
  • The operator convert_image_type now is able to convert complex images to the image types supported by convert_image_type as output types. The conversion is performed by converting the real part of the complex image and by ignoring the imaginary part. This allows a quicker conversion of images transformed back from the frequency domain with fft_generic than to use power_real since back-transformed images should always have an imaginary part of 0.
  • The operator dump_window now supports writing PNG images in the same manner as write_image.
  • The HALCON frame grabber integration interface provides three additional error codes (H_ERR_FGSETPAR, H_ERR_FGGETPAR, and H_ERR_PARNA), which are useful in case of errors while getting or setting frame grabber specific parameters.
  • The HALCON frame grabber integration interface now supports the additional queries 'field', 'bits_per_channel', 'color_space', 'external_trigger', and 'device' for the operator info_framegrabber to provide frame grabber specific value lists. Furthermore, two additional queries 'parameters_readonly' and 'parameters_writeonly' provide the subset of all frame grabber specific parameters which are only gettable or settable.
  • The operators get_2d_bar_code and get_2d_bar_code_pos have now value lists for the parameters GenParamNames and GenParamValues.
  • The operator obj_to_integer now accepts -1 in the parameter Number. In this case, all IDs starting with Index are returned. The documentation has been extended accordingly.
  • The operator region_to_mean is now able to handle multichannel images.
  • The operator select_shape_proto now has a mode in which the overlap of the regions with the pattern is determined. It is possible to calculate the overlap as an absolute area ('overlaps_abs') or as relative to the size of the region to be tested ('overlaps_rel'). The documentation has been extended accordingly.
  • The operator write_image now uses the extension .tif instead of .tiff for TIFF images under Unix if no extension has been given. The documentation of write_image has been modified accordingly.
  • The operator write_region now only appends the file extension .reg if no other extension has been given. The documentation of write_region has been modified accordingly.

o Bug Fixes:
  • The operator affine_trans_image sometimes erroneously created empty output images with a transformation matrix that contained a mirroring, but which should have returned valid pixels in the output image. This problem has been fixed.
  • The operator approx_chain_simple sometimes crashed. This problem has been fixed.
  • The operator check_difference sometimes included too many pixels in the segmentation result. This problem has been fixed.
  • The operator clip_contours_xld sometimes created two contours from a closed contour that logically had only a single part. This problem has been fixed.
  • The operator convert_image_type was not able to convert images of type int2 and uint2 to type complex. The missing functionality has been implemented.
  • The operator convert_pose_type returned wrong results if the pose should be converted into a Rodriguez vector and the rotation angle exceeded 90 degrees. Furthermore, it returned wrong results if the pose should be converted into a Rodriguez vector and the rotation angle was exactly 180 degrees. Both problems have been fixed.
  • The operator copy_obj did not free all temporary memory when an empty object was copied. This problem has been fixed.
  • The operator create_shape_model sometimes created different shape models if a different number of pyramid levels that should be used during creation was choosen. This lead to different matching results when using find_shape_model even if the number of pyramid levels that should be used during the search was set to the same value. This problem has been fixed.
  • The cropping operators now support direction images, as specified in the documentation.
  • The operator deviation_image returned wrong pixel values along the ROI border if reduce_image was used. This happened with odd mask sizes only. This problem has been fixed.
  • The operator disp_arrow sometimes returned error 3513 (Internal error: number of chords too big for num_max). This problem has been fixed.
  • Lines drawn with disp_polygons were to short if set_line_style was used. This problem has been fixed.
  • The operator dist_ellipse_contour_xld returned erroneous results if 'Radius1' < 'Radius2' for Mode = 'geometric' and Mode = 'bisec'. This problem has been fixed.

    Furthermore, dist_ellipse_contour_xld could not handle multiple contours, contrary to what is specified in the documentation. In this case, it now returns a tuple of values.

  • The operators distance_lr and distance_sr now always return zero if the line intersects the region.
  • The operator edges_sub_pix erroneously allowed negative values for the hysteresis thresholds. Now, edges_sub_pix enforces that both hysteresis thresholds are positive and returns an error if one of the thresholds is <= 0.
  • A crash in find_1d_bar_code that happened in very rare cases has been fixed.
  • The operators find_scaled_shape_model and find_shape_model crashed in extremely rare cases. This problem has been fixed.
  • Various filter generating operators erroneously stated that multiple images can be returned (i.e., multivalue was erroneously set to optional). The following operators were affected: gen_gabor, gen_std_bandpass, gen_sin_bandpass, gen_filter_mask. This problem has been fixed. As a consequence, these four operators are no longer included in the class HImageArray in HALCON/C++. Applications that use these operators with HImageArray must be rewritten to use the class HImage instead.
  • The operator fit_circle_contour_xld in rare cases returned wrong results if the contours originated from region processing were not subpixel-precise. This problem has been fixed.
  • The operator gen_psf_motion sometimes returned incorrect results. This problem has been fixed.
  • The operator hamming_change_region sometimes returned the error 6002 (Memory partition on heap has been overwritten). This problem has been fixed.
  • The operator image_to_world_plane sometimes crashed if one of the four corner pixels of the input image were involved in the calculation. This problem has been fixed.
  • The operator info_parallels_xld sometimes returned erroneous values for StandardMin and StandardMax. This problem has been fixed.
  • The operator learn_class_box sometimes crashed if a tuple of integers and strings was passed as the feature vector. This problem has been fixed.
  • The operator lines_gauss returned the error 6002 (Memory partition on heap has been overwritten) for some sigmas. The error occured, for example, if the parameter Sigma was set to 0.6. This problem has been fixed.
  • The operator map_image sometimes crashed if the linearized coordinate in the first channel of the map pointed to the border quarter of one of the four corner pixels of the input image. This problem has been fixed.
  • The operator mirror_region sometimes returned an error if the checking of region data was enabled with set_check('data') (the default setting in HDevelop). This problem has been fixed.
  • The operator moments_any_xld sometimes returned the error 6002 (Memory partition on heap has been overwritten). This happened is more than one contour was passed. This problem has been fixed.
  • The operators moments_region_central_invar and moments_region_central did not compute the fourth moment (PSI4 in moments_region_central_invar, I4 in moments_region_central) correctly. This problem has been fixed.

    Note that this change makes fonts that use the features 'moments_central' that were trained with previous HALCON versions incompatible. Therefore, fonts that use the features 'moments_central' must be retrained.

  • The operator paint_xld in rare cases painted pixels with wrong gray values if the contours were running along a pixel border. Furthermore, it crashed if the iconic parameters were used incorrectly. Both problems have been fixed.
  • The operator rank_region only worked with mask sizes smaller than 100x100. This problem has been fixed.
  • The operator runlength_distribution sometimes returned the error 6002 (Memory partition on heap has been overwritten). This problem has been fixed.
  • The operator segment_contours_xld sometimes did not free all temporary memory when the parameter Mode was set to 'lines_circles'. Besides, it sometimes created a circle for a contour segment that was best approximated by a line. Both problems have been fixed.
  • The operator set_origin_pose only worked correctly for poses with code = 0 (i.e., for PoseType 1). Furthermore, it returned wrong results if the rotation angle Rot2 (Beta) of the input pose was exactly plus or minus 90 degrees. Both problems have been fixed.
  • The operator socket_accept_connect did not free all resources if it returned with an error. In particular, a socket handle was allocated and not freed. This problem has been fixed.
  • The operator split_contours_xld always returned an empty object for Mode = 'dominant'. This problem has been fixed.
  • The operator write_string did not display tuples correctly in zoomed windows under Unix. This problem has been fixed.
  • The operator read_string now displays the typed characters under Windows, and the default string is also displayed.

o Manual:
  • The new manuals "Quick Guide to HALCON" and "Installation Guide" completely cover the content of the manual "Getting Started with HALCON", which therefore is not provided anymore.
  • The new "Application Note on 3D Machine Vision" can be found via the Windows Start Menu or in the subdirectory doc/pdf/application_guide. It uses the new examples in the subdirectory examples/application_guide/3d_machine_vision/hdevelop.
  • In the reference manual, the description of the modes 'area', 'zuniga_haralick', 'gradient_dir', and 'eigenvec_dir' of the operator derivate_gauss has been added.
  • In the documentation of query_insert and set_insert, the mode 'complement' was falsely denoted as 'not'. Now, the documentation correctly denotes the complement modus as 'complement'.

o Miscellaneous:
  • The chapters containing operators for affine transformations have been revised:
    • Filter/Affine-Transformations has been renamed to Filter/Geometric-Transformations. Furthermore, the operator map_image now is included in this chapter instead of Filter/Misc. Consequently, the example directory examples/hdevelop/Filter/Affine-Transformations has been renamed to examples/hdevelop/Filter/Geometric-Transformations.
    • The chapter Regions/Affine-Transformations has been renamed to Regions/Geometric-Transformations. Consequently, the example directory examples/hdevelop/Regions/Affine-Transformations has been renamed to examples/hdevelop/Regions/Geometric-Transformations.
    • The chapter Tools/Affine-Transformations has been split into the two chapters Tools/2D-Transformations and Tools/3D-Transformations. Furthermore, the basic operators for handling 3D poses (e.g., create_pose) have been moved from Tools/Calibration to Tools/3D-Transformations. Consequently, the example directory examples/hdevelop/Tools/Affine-Transformations, which contained only examples for 2D transformations, has been renamed to examples/hdevelop/Tools/2D-Transformations.
  • The HALCON reference manuals have a new chapter Filter/Points, which contains point finders. The operator corner_response has been moved from the chapter Filter/Match to the chapter Filter/Points.
  • The operators in the chapter Classification have been moved to the new chapter Classification/Hyperboxes.
  • The operators in the chapter Tools/OCR have been moved to the new chapters OCR/Hyperboxes and OCR/Training-Files.
  • The chapter Segmentation has been split into the subchapters Classification, Edges, Regiongrowing, Threshold, Topography. Consequently, the examples in examples/hdevelop/Segmentation have been moved into the appropriate subchapters.

HALCON/C

o Manual:

HALCON/C++

o Programming:
  • HALCON/C++ tuple operators no longer exist in the single input control parameter version if the default type for an input control parameter is of type real or integer and the type list contains both types. This was necessary in order to eliminate unexpected runtime behavior when passing single input control parameters values that were not of the default type.
  • The HALCON/C++ class HTuple has 9 new members:
    • Find returns the indices of all the occurences of a tuple within another tuple.
    • Uniq discards all but one of successive identical elements from the input tuple.
    • Int converts a tuple to integer values by truncating floating point values.
    • Min2 and Max2 calculate the element-wise minimum or maximum of two tuples.
    • Mod calculates the element-wise modulus of an integer division.
    • Rand returns a tuple of random numbers distributed uniformly in the interval [0,1).
    • Sgn calculates the element-wise sign of a tuple, i.e., it returns +1 if the element is positive, -1 if the element is negative, and 0 if the element is 0.
    • Subset selects a subset of elements of a tuple.
  • Applications that use the operators GenGabor, GenStdBandpass, GenSinBandpass, GenFilterMask with the class HImageArray must be rewritten to use the class HImage instead (see also here).
  • The operator that casts handle classes into handles now declares the input class as const. All .h files in include/cpp that are associated with handle classes have been modified accordingly.

o Bug Fixes: