Polar Controller for Defining and Generating Spiral-Like Shapes

The present invention concerns generation of graphics using a computing system and pertains particularly to a polar controller for generating spiral-like shapes.

Computer Aided Engineering (CAE) software is used for a variety of purposes. For example, electrical engineers often use CAE software to design circuits.

When using CAE software, a productivity engineer or a circuit designer may discover that artwork desirable for a particular project is not included with the CAE software. In order to generate the desired artwork, it is then necessary to modify an existing artwork macro or create a new artwork macro. Alternatively, an internal macro language such as the Application Extension Language (AEL) may be used to generate an appropriate macro.

Programming in an internal macro language such as the Application Extension Language (AEL) can require a significant amount of expertise. Therefore, various attempts have been made to make it easier for a designer to generate a library of useful variable graphics which can be used for a variety of purposes.

For example, the Virtuoso.TM. Parameterized Cell Reference Manual, Version 4.2.1, September 1992, available from Cadence, having a business address of 555 River Oaks Parkway, San Jose, Calif. 95134-1917, describes a product which uses parameterized cells as graphic, programmable cells which can be customized. Each parameterized cell includes a graphic layer and assigned parameters. Using the parameterized cell, instances can be created in which parts of the parameterized cell may be repeated or stretched.

While products exist to allow some generation of parameterized cells, the types of shapes that can be produced simply and efficiently are limited. For example, there is no straightforward way to generate spiral-like shapes. The present invention solves this lack in the prior art.

In accordance with the preferred embodiment of the present invention, a polar controller generates a graphic shape. An interface of the polar controller receives from a user a start angle, a stop angle, a step angle and a radius length for the graphic shape. A polar execution engine of the polar controller generates the graphic shape based on the start angle, the stop angle, the step angle and the radius length. For example, when the radius length is expressed as a function of angle, the polar controller is able to generate spiral-like shapes.

Additionally, in the preferred embodiment, the interface is additionally adapted to receive from the user an x offset and a y offset. When an x offset and a y offset are specified by a user, the polar execution engine generates the graphic shape also based on the x offset and the y offset.

In the preferred embodiment, the polar controller evaluates once any equation the user uses to specify the start angle, evaluates once any equation the user uses to specify the stop angle, evaluates once any equation the user uses to specify the step angle, and evaluates for each step any equation the user uses to specify the radius length. When an x-offset and a y-offset are specified, the polar execution engine evaluates for each step any equation the user uses to specify the x-offset, and evaluates for each step any equation the user uses to specify the y-offset.

Also in the preferred embodiment, the polar execution engine generates the graphic shape based on a selected shape, and a construction line. When the construction line is specified as not intersecting the selected shape, the polar execution engine generates the graphic shape by copying the selected shape. When the construction line is specified as intersecting the selected shape, the polar execution engine generates the graphic shape by expanding the selected shape.

The present invention allows for great flexibility in generating graphic shapes. For example, the present invention allows the simple generating of spiral-like shapes by allowing radius length to be expressed as a function of angle, and by evaluating the radius length at each step.

FIG. 1 is a simplified general overview flowchart which illustrates a design process using a graphical cell compiler and component libraries.

FIG. 2 is a flowchart which illustrates flow of control information and layout information through the graphical cell compiler shown in FIG. 1.

FIG. 3 is a simplified flowchart which illustrates flow of control data and graphic data through a polar controller in accordance with a preferred embodiment of the present invention.

FIG. 4 is graphic data input which is a selected shape and a construction line used by a polar controller in accordance with a preferred embodiment of the present invention.

FIG. 5 is a dialog box for a polar controller in accordance with a preferred embodiment of the present invention.

FIG. 6 is a guide which graphically represents parameters used by a polar controller in accordance with a preferred embodiment of the present invention.

FIG. 7 is a spiral-like shape generated without x/y offset parameters using a polar controller in accordance with a preferred embodiment of the present invention.

FIG. 8 is spiral-like shape generated with x/y offset parameters using a polar controller in accordance with a preferred embodiment of the present invention.

FIG. 9 is a flowchart which summarizes operation of a polar controller in accordance with a preferred embodiment of the present invention.

FIG. 10 is a flowchart which describes operation of a polar execution engine in accordance with a preferred embodiment of the present invention.

FIG. 11 is a flowchart which describes generation of a graphics language macro in accordance with a preferred embodiment of the present invention.

FIG. 1 is a simplified general overview flowchart which illustrates a design process using a graphical cell compiler 12 to generate entries in component libraries 11. A designer uses CAE software to work with a schematic 13 and a layout 14. When a circuit design is completed, and possibly during various stages of development, simulation 15 is performed and the results are shown in a data display 16.

When desired artwork is not supplied as part of the CAE software, graphical cell compiler 12 can be used to generate complex parameterized artwork macros (PAMS).

FIG. 2 is a flowchart which illustrates flow of control and data through graphical cell compiler 12. Layout information 21 is obtained a layout window 14 is the source of graphical data 23. Control dialogs 22 are dialog boxes which allow the user to enter the information which defines the operations on graphical data 23. The information is stored as control data 24.

A macro compiler 25 generates an Application Extension Language (AEL) macro 27 within a component 26. Component 26 is stored in components library 11. Within component 26, simulation data 28 and schematic data 29 are also included.

A layout editor 30 uses an insertion engine 31 to place component 26 inside a layout window 32.

In order to generate a PAM, a designer defines the artwork graphically in a Layout window (represented by layout information 21), typically using a layout editor. The designer then defines parameters to effect the artwork. Macro compiler 25 is used to compile the macro. The compiled macro 27 may then be stored as part of a component 26 within component libraries 11 (shown in FIG. 1) for later use by the designer. For storage within component libraries 11, default values are generally assigned to the parameters for the compiled macro. A designer may then utilize the macro in a current layout (represented by layout window 32). The designer edits the parameters as desired for each instance of the macro used.

FIG. 3 is a simplified flowchart which illustrates flow of control and data through a polar controller. The polar controller allows graphic shapes to be defined in the polar (angle, radius) coordinate system. For the polar controller the selected shape (shape) to be effected is defined. A construction (control) line is added to the selected shape. If the construction line does not intersect the selected shape, the polar execution engine generates the graphic shape by copying (i.e., repeating) the selected shape. When the construction line intersects the selected shape, the polar controller generates the graphic shape by stretching (i.e., expanding) the selected shape.

Graphical data 23 and control data 24 are read in by the polar controller. Graphical data 23 is, for example, a selected shape (which functions as a primitive) and a construction line. The selected shape, is for example, a path. Control data 24 includes information indicating a start angle, stop angle, step information, radius information, an x-offset and a y-offset.

In a control setup step 43, the polar controller checks for an intersection of the construction line and the selected shape and finds the cut point, i.e., the location at which the construction line intersects the selected shape. The polar controller also computes the draw direction of the compiled graphic. The polar controller also evaluates the start, step, and step control inputs.

In a copy pre-points step 44, the polar controller generates the first points for the compiled graphic. Since the construction line is specified as intersecting the selected shape, the graphic shape is drawn by expanding (i.e., stretching) the selected shape. In this case, first points are generated based on the points of the selected shape before the cut point (as defined by the construction line).

In a step 45, when the selected shape is expanded to generate the graphic shape, the polar controller uses the step information and radius information to generate an additional computed point. In a step 46, the polar controller uses an x-offset and a y-offset to compute offsets for the additional computed point generated in step 45. In a step 47, a check is made to see if the stop angle has been reached. If not additional points are computed. When the stop angle has been reached, in a step 48 the post-points are added to the graphic shape. The post-points are the points from the source shape that came after the cut point. These are the final points necessary to complete the graphic shape for the case where the graphic shape is drawn by expanding the selected shape.

FIG. 4 gives an example of graphical data 23 used as input to a polar controller. A selected shape 106 is in this case a source path. Selected shape 106 is shown intersected by a construction line 105. Source path 106 and construction line 105 are, for example, within a layout window for a graphical editor. For example source path 106 is 25 mil wide. Selected shape 106 serves as a primitive for the generated graphic shape.

FIG. 5 shows a dialog box 70 used to receive, from a user, control data 24 used as input to a polar controller. When a user selects box 71, angle sweep values are interpreted as radians. When a user selects box 72, angle sweep values are interpreted as degrees.

In a box 73 a user indicates a start angle. The start angle can be a constant, a variable whose value is supplied by the user at insertion time, or an equation made up one or more variables and/or constants. In a box 74 a user indicates a stop angle. The stop angle can be a constant, a variable whose value is supplied by the user at insertion time, or an equation made up one or more variables and/or constants. In a box 75 a user indicates a step angle. The step angle can be a constant, a variable whose value is supplied by the user at insertion time, or an equation made up one or more variables and/or constants. In a box 76 a user indicates the length of the radius. The length of the radius can be a constant, a variable whose value is supplied by the user at insertion time, or an equation made up one or more variables and/or constants. In a box 77 a user indicates an x-offset for each step. The x-offset can be a constant, a variable whose value is supplied by the user at insertion time, or an equation made up one or more variables and/or constants. In a box 78 a user indicates a y-offset for each step. The y-offset can be a constant, a variable whose value is supplied by the user at insertion time, or an equation made up one or more variables and/or constants. When a user selects an OK button 79, all the values are entered into the system as control data 24. When the user selects a Cancel button 80, all the information just entered is discarded. A user can request help information by selecting a Help button 81.

The start angle, stop angle and step angle are evaluated and executed once by the polar controller. However, the length of the radius, the x-offset and the y-offset are evaluated by the polar controller for each step. This allows, for example, the polar controller to generate spiral-like shapes when the user specifies the length of the radius as a function of angle.

FIG. 6 is a guide which graphically represents how user inputs received via dialog box 70 relate to one another. An x-axis 91 and a y-axis 92 are shown for reference. A line 93 indicates a start angle measured from x-axis 91. A line 94 indicates a stop angle measured from x-axis 91. An angle 95 indicates an incremental step distance that starts from line 93 and continues until stop angle 94. A radius length is represented by a line 96 originating from the intersection of x-axis 91 and y-axis 92. An x-offset 97 and a y-offset are shown extending from the top of line 96.

FIG. 7 shows a resulting component 101 which was generated by a user selecting values using dialog box 70. For this example, the user has selected box 71, so that angle sweep values are interpreted as radians. In box 73 the user has indicated a start angle of 0. In box 74 the user has indicated stop angle of 4*.pi.. In box 75 the user has indicated a step angle of .pi./2. In box 76 the user has indicated the length of radius is equal to the equation (angle/(2*.pi.))*50 mil/sin(.pi./2-.pi./4). In box 77 the user has indicated an x-offset for each step of 0 mil. In box 78 the user has indicated a y-offset for each step of 0 mil. The user then proceeded with entering the data into the system by selecting OK button 79. Because the length of the radius is an equation which is a function of angle, the resulting graphic shape is spiral-like.

In order to make the spiral-like shape into a square shape the user can add x and y offsets. For example, FIG. 8 shows a resulting graph 111 which can be generated by a user selecting values using dialog box 70. For this example, the user has selected box 71, so that angle sweep values are interpreted as radians. In box 73 the user has indicated a start angle of 0. In box 74 the user has indicated stop angle of 4*.pi.. In box 75 the user has indicated a step angle of .pi./2. In box 76 the user has indicated the length of radius is equal to the equation (angle/(2*.pi.))*50 mil/sin(.pi./2-.pi./4). In box 77 the user has indicated an x-offset for each step of 50 mil/(8*(cos(angle+.pi./2-.pi./4)-sin(angle+.pi./2-.pi./4))). In box 78 the user has indicated a y-offset for each step of 50 mil/(8*(cos(angle+.pi./2-.pi./4)+sin(angle+.pi./2-.pi./4))). The user then proceeded with entering the data into the system by selecting OK button 79. Of course, the values given in this and the previous example are very specific to these particular examples. The values would differ significantly for a different line width, different number of sides, different number of turns, etc.

FIG. 9 summarizes operation of a polar controller. In a step 131, parameters are received from a user. In a step 132, validity of the parameters is verified. In a step 133, the graphic shape data is initialized. In a step 134, the parameters are prepared and the polar execution engine is called. The polar execution engine is called with the data for the source layout and all other controller parameters. In a step 135, the generated shape is inserted into a database. An example of code which loads the construction line, sends the construction line to the polar execution engine, evaluates the user-defined equations to generate a real value for start, stop and step angles, and calls the polar execution engine for the graphic is set out in Table 1 below:

FIG. 10 is a flowchart which describes operation of a polar execution engine. In a step 51, all the parameters for the construction line, the selected shape being operated on are passed in. Table 2 below shows an example of code within a polar execution engine which receives the parameters.

In a step 52, local variables are declared. Table 3 below shows an example of code within a polar execution engine which declares the local variables.

In a step 53, error checking is performed. Table 4 below shows an example of code within a polar execution engine which performs the error checking.

In a step 54, a check is made to see if the construction line cuts through the selected shape passed to the polar execution engine. Table 5 below shows an example of code within a polar execution engine which performs the check.

In a step 55, a polar copy and return is performed when the construction line does not cut through the selected shape passed to the polar execution engine. Table 6 below shows an example of code within a polar execution engine which performs the polar copy and return.

In a step 56, a check is made to determine where the construction line cuts the selected shape, i.e., whether the construction line intersects the first point, the last point, or if the construction line cuts between points (e.g., mid segment). Table 7 below shows an example of code within a polar execution engine which performs the check.

In a step 57, a check is made to determine the direction of the stretch with respect to the direction of the selected shape so that no matter which way the selected shape is drawn or which way the selected shape is stretching the appearance of the final graphic will appear correct. Table 8 below shows an example of code within a polar execution engine which performs this check.

In a step 58, space is allocated for the modified selected shape. Table 9 below shows an example of code within a polar execution engine which performs the allocation.

In a step 59, the modified selected shape is loaded with the points for the parts of the selected shape that appear before the reference line. The direction constituting "before" is based on the direction of the stretch and the orientation of the selected shape. Table 10 below shows an example of code within a polar execution engine which performs the load.

In a step 60, local constants are initialized in preparation for use by the user equations. These are the results of the user equations that get evaluated just one time. As discussed above, in the preferred embodiment the local constants which get evaluated one-time include the user-provided expressions for the start angle, the stop angle and the step angle. Table 11 below shows an example of code within a polar execution engine which performs the initialization.

In a step 61, the calculations are performed. This is the "real" work of the polar execution engine. In this step, the polar execution engine computes the next angle, sets the local variable with angle information, evaluates the user equation for the radius, evaluates the user equations for the x offset and the y offset, converts from polar to rectangular coordinates and computes the next (x,y) point based on the intersection point of the construction line and the selected shape modified with the (angle, radius) pair and the (x,y) offset. Table 12 below shows an example of code within a polar execution engine which performs these calculations.

In a step 62, the points which occur after the intersection of the construction line and the selected shape are copied into the modified selected shape. Table 13 below shows an example of code within a polar execution engine which performs this copy.

In a step 63, a check is made to make sure the resulting graphic has the right amount of points. Table 14 below shows an example of code within a polar execution engine which performs this check.

In addition to a polar execution engine, a polar controller contains additional code which allows parameters specified by a user to be evaluated and used by the polar controller before the polar execution engine is called. This code is necesary as the parameters are coming from a generated AEL script and being passed to C code. For example, Table 15 below sets out code which unpacks parameters and calls a stretch version of the polar execution engine or a copy version of the polar execution engine:

When a graphical cell compiler (e.g., macro compiler 25) is used to generate a Parameterized Artwork Macro (PAM), the graphical cell compiler combines the source shape(s) and construction line (graphical data 23), and the equations entered in dialog box 70 (e.g., control data 24), and the user supplied parameter values entered by user at insertion time (e.g., as represented by step 134 shown in FIG. 9), to generate graphical shapes. FIG. 11 is a flowchart which gives a simplified description of how the values entered in dialog box 70 along with a selected shape and construction line can be used to generate a graphics language macro which will generate a graphic shape. In the preferred embodiment, the graphics language macro is written in AEL. Alternatively, other system specific macro languages could be used. In a step 121, shown in FIG. 11, a syntax check and name parse is performed on equations placed in any entry box in dialog box 70. The syntax check and name parse is performed to verify the equations and to collect the parameter names. Any name not identified by the system as a built-in is taken as a parameter name to be defined by the user at insertion time.

In a step 122, a graphic shape entered from a layout editor are evaluated in order to verify the graphic shape is valid and supported by the polar controller.

In a step 123 the parts entered are all verified, i.e., it is verified that the necessary parts are present and valid. The parts include the controller input by the user, the shape input via the layout editor and the construction line.

In a step 124, shape data is output. That is, the variables (e.g., point locations) which define the selected shape are loaded into variables for the graphics language macro.

In a step 125, the calls to a polar execution engine are generated. In a step 126, the output shape is created.

In a step 127, a main driver is produced, the main driver makes, procedure calls to procedures constructed in steps 124, 125 and 126.

The graphics language macro (e.g., an AEL script) generated from the flowchart shown in FIG. 11, is stored in a data base and can be accessed by a user to insert an instance of the generated shape into a window of a layout editor.

Table 16 below gives an example of code which creates name mappings between the internal macro language AEL and the programming language C.

The foregoing discussion discloses and describes merely exemplary methods and embodiments of the present invention. As will be understood by those familiar with the art, the invention may be embodied in other specific forms without departing from the spirit or essential characteristics thereof. Accordingly, the disclosure of the present invention is intended to be illustrative, but not limiting, of the scope of the invention, which is set forth in the following claims.