Find the best matches of a scale invariant shape model in an image.

The operator find_scaled_shape_model finds the best NumMatches instances of the scale invariant shape model ModelID in the input image Image. The model must have been created previously by calling create_scaled_shape_model or read_shape_model.

The position, rotation, and scale of the found instances of the model are returned in Row, Column, Angle, and Scale. The coordinates Row and Column are the coordinates of the origin of the shape model in the search image. By default, the origin is the center of gravity of the domain (region) of the image that was used to create the shape model with create_scaled_shape_model. A different origin can be set with set_shape_model_origin.

Note that the coordinates Row and Column do not exactly correspond to the position of the model in the search image. Thus, you cannot directly use them. Instead, the values are optimized for creating the transformation matrix with which you can use the results of the matching for various tasks, e.g., to align ROIs for other processing steps. The example below shows how to create this matrix and use it to display the model at the found position in the search image and to calculate the exact coordinates.

Additionally, the score of each found instance is returned in Score. The score is a number between 0 and 1, which is an approximate measure of how much of the model is visible in the image. If, for example, half of the model is occluded, the score cannot exceed 0.5.

The domain of the image Image determines the search space for the reference point of the model, i.e., for the center of gravity of the domain (region) of the image that was used to create the shape model with create_scaled_shape_model. A different origin set with set_shape_model_origin is not taken into account. The model is searched within those points of the domain of the image, in which the model lies completely within the image. This means that the model will not be found if it extends beyond the borders of the image, even if it would achieve a score greater than MinScore (see below). The parameters AngleStart and AngleExtent determine the range of rotations for which the model is searched. The parameters ScaleMin and ScaleMax determine the range of scales for which the model is searched. If necessary, both ranges are clipped to the range given when the model was created with create_scaled_shape_model. In particular, this means that the angle ranges of the model and the search must truly overlap. The angle range in the search is not adapted modulo 2*pi. To simplify the presentation, all angles in the remainder of the paragraph are given in degrees, whereas they have to be specified in radians in find_scaled_shape_model. Hence, if the model, for example, was created with AngleStart = -20° and AngleExtent = 40° and the angle search space in find_scaled_shape_model is, for example, set to AngleStart = 350° and AngleExtent = 20°, the model will not be found, even though the angle ranges would overlap if they were regarded modulo 360°. To find the model, in this example it would be necessary to select AngleStart = -10°.

Furthermore, it should be noted that in some cases instances with a rotation or scale that is slightly outside the specified range are found. This may happen if the specified range is smaller than the range given when the model was created.

The parameter MinScore determines what score a potential match must at least have to be regarded as an instance of the model in the image. The larger MinScore is chosen, the faster the search is. If the model can be expected never to be occluded in the images, MinScore may be set as high as 0.8 or even 0.9. If the matches are not tracked to the lowest pyramid level (see below) it might happen that instances with a score slightly below MinScore are found.

The maximum number of instances to be found can be determined with NumMatches. If more than NumMatches instances with a score greater than MinScore are found in the image, only the best NumMatches instances are returned. If fewer than NumMatches are found, only that number is returned, i.e., the parameter MinScore takes precedence over NumMatches.

If the model exhibits symmetries it may happen that multiple instances with similar positions but different rotations are found in the image. The parameter MaxOverlap determines by what fraction (i.e., a number between 0 and 1) two instances may at most overlap in order to consider them as different instances, and hence to be returned separately. If two instances overlap each other by more than MaxOverlap only the best instance is returned. The calculation of the overlap is based on the smallest enclosing rectangle of arbitrary orientation (see smallest_rectangle2) of the found instances. If MaxOverlap=0, the found instances may not overlap at all, while for MaxOverlap=1 all instances are returned.

The parameter SubPixel determines whether the instances should be extracted with subpixel accuracy. If SubPixel is set to 'none' (or 'false' for backwards compatibility) the model's pose is only determined with pixel accuracy and the angle and scale resolution that was specified with create_scaled_shape_model. If SubPixel is set to 'interpolation' (or 'true') the position as well as the rotation and scale are determined with subpixel accuracy. In this mode, the model's pose is interpolated from the score function. This mode costs almost no computation time and achieves an accuracy that is high enough for most applications. In some applications, however, the accuracy requirements are extremely high. In these cases, the model's pose can be determined through a least-squares adjustment, i.e., by minimizing the distances of the model points to their corresponding image points. In contrast to 'interpolation', this mode requires additional computation time. The different modes for least-squares adjustment ('least_squares', 'least_squares_high', and 'least_squares_very_high') can be used to determine the accuracy with which the minimum distance is being searched. The higher the accuracy is chosen, the longer the subpixel extraction will take, however. Usually, SubPixel should be set to 'interpolation'. If least-squares adjustment is desired, 'least_squares' should be chosen because this results in the best tradeoff between run time and accuracy.

The number of pyramid levels used during the search is determined with NumLevels. If necessary, the number of levels is clipped to the range given when the shape model was created with create_scaled_shape_model. If NumLevels is set to 0, the number of pyramid levels specified in create_scaled_shape_model is used. If NumLevels is set to 0, the number of pyramid levels specified in create_shape_model is used. Optionally, NumLevels can contain a second value that determines the lowest pyramid level to which the found matches are tracked. Hence, a value of [4,2] for NumLevels means that the matching starts at the fourth pyramid level and tracks the matches to the second lowest pyramid level (the lowest pyramid level is denoted by a value of 1). This mechanism can be used to decrease the runtime of the matching. It should be noted, however, that in general the accuracy of the extracted pose parameters is lower in this mode than in the normal mode, in which the matches are tracked to the lowest pyramid level. Hence, if a high accuracy is desired, SubPixel should be set to at least 'least_squares'. If the lowest pyramid level to use is chosen too large, it may happen that the desired accuracy cannot be achieved, or that wrong instances of the model are found because the model is not specific enough on the higher pyramid levels to facilitate a reliable selection of the correct instance of the model. In this case, the lowest pyramid level to use must be set to a smaller value.

The parameter Greediness determines how ``greedily'' the search should be carried out. If Greediness=0, a safe search heuristic is used, which always finds the model if it is visible in the image. However, the search will be relatively time consuming in this case. If Greediness=1, an unsafe search heuristic is used, which may cause the model not to be found in rare cases, even though it is visible in the image. For Greediness=1, the maximum search speed is achieved. In almost all cases, the shape model will always be found for Greediness=0.9.

create_scaled_shape_model (ImageReduced, 0, rad(-45), rad(180), 0, 
                           0.9, 1.1, 0, 'none', 'use_polarity', 
                           30, 10, ModelID)
get_shape_model_contours (ModelXLD, ModelID, 1)
find_scaled_shape_model (SearchImage, ModelID, rad(-45), rad(180), 
                         0.9, 1.1, 0.5, 1, 0.5, 'interpolation', 
                         0, 0, Row, Column, Angle, Scale, Score)
vector_angle_to_rigid (0, 0, 0, Row, Column, Angle, HomMat2DTmp)
hom_mat2d_scale (HomMat2DTmp, Scale, Scale, Row, Column, HomMat2DObject)
affine_trans_contour_xld (ModelXLD, ObjectXLD, HomMat2DObject)
affine_trans_pixel (HomMat2DObject, 0, 0, RowObject, ColObject)

If the parameter values are correct, the operator find_scaled_shape_model returns the value 2 (H_MSG_TRUE). If the input is empty (no input images are available) the behavior can be set via set_system('no_object_result',<Result>). If necessary, an exception is raised.

find_scaled_shape_model is reentrant and processed without parallelization.

create_scaled_shape_model, read_shape_model, set_shape_model_origin

find_shape_model, find_shape_models, find_scaled_shape_models, best_match_rot_mg

Matching