The algorithm runs through three stages sequentially, as follows:
Separates features selected by the operator into `connected groups' to allow the operator to run the action simultaneously on several groups of different shapes (referred to as `reference groups').
Scans the layer and compares geometrical patterns of groups with patterns in reference groups. The order of features inside the group is irrelevant.
Replaces groups that match a reference group with standard symbols* (round, square, rectangles, ovals, etc., that can be identified by the system by name, without graphical representation). It tries to match shapes with standard symbols in a certain order, as follows:
The system accepts the first match and does not look further. The following example will clarify.
The original shape is a Rect. Round with a rounded corners diameter of 4 mils (that is a radius of 2 mils). The tolerance ( pp_tol ) is 1 mil.
The system looks first at Square but finds that one side is longer than the other, it passes on to Rect. It finds that the gap between the rounded corners and the square corners of the Rect. standard symbol are within the tolerance. Therefore it matches the shape with a Rectangle with square corners (discarding the rounded corners) and generates a square rectangle. The following figure illustrates:
*
If, in the above example, you specified the tolerance as 0.5 mil,
then the gap between outlines would have been more than the tolerance and the
system would not have matched the shape with Rect. It would have continued and
matched it with Rect. Round.
If a pad shape cannot be matched to a standard symbol, the action will create a special symbol for the pad with a name starting with the string ` construct. Thus, after the operation the job may contain pads called ` construct, ` construct+1, ` construct+2 ', etc.**
*
The first step can be disabled with the parameter `Break to
Connected Groups'.
* For a full description of standard symbols please refer to Doc.0202, ODB++.
** When the action encounters a pad shape that requires a new symbol, it tries to match it with one of the existing ` construct* symbols before creating a new one. This minimizes significantly the number of construct symbols created.