US20020032554A1

US20020032554A1 - Layout apparatus for laying out objects in space and method thereof

Info

Publication number: US20020032554A1
Application number: US09/897,070
Authority: US
Inventors: Toru Nakagawa
Original assignee: Fujitsu Ltd
Current assignee: Fujitsu Ltd
Priority date: 1997-02-03
Filing date: 2001-07-03
Publication date: 2002-03-14
Also published as: US6374200B1

Abstract

A layout system manages a designated layout space with a set of inscribed rectangles. Whenever an object is input, the layout system determines a layout position of the object in the layout space according to a designated priority rule. The layout system simulates the layout process for various conditions so as to optimize the layout of objects

Description

This application is a continuation of application Ser. No. 08/909,095, filed Aug. 12, 1997 now allowed.[0001]

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to a two dimensional object layout apparatus for automatically designing a two-dimensional layout of many objects such as commodities in a warehouse, parts on a printed circuit board, or cells on a VLSI (Very Large Scale Integration) circuit, and a method thereof.

2. Description of the Related Art

In designing a printed circuit and a VLSI, a very large number of circuit parts, transistors, and so forth should be laid out on a two-dimensional board (or a chip). To do that, computer aided design (CAD) systems have been used.

Such CAD systems roughly operate in two phases. The first phase is a logical phase where logic circuits are formed, a process is simulated, and test data is generated. The second phase is a physical phase where cells (parts) are laid out and lines (leads) thereof are connected.

In the second phase, based on a design drawing of a logic circuit received from the first phase, a large number of circuit elements or semiconductor devices are optimally laid out on a two-dimensional plane (of multiple layers) and lines thereof are optimally connected corresponding to a predetermined design rule for each device and therebetween in such a manner that the total area of the structure becomes compact and the line lengths become short.

In the process for laying out cells, it is not effective to directly handle cells in the order of the 0.1 million cells or 1 million cells of an VLSI. Thus, conventionally, the physical design work is hierarchically performed and thereby several tens of cells to several hundreds of cells (module parts) are handled at a time. Each cell has the size and shape necessary for the internal logic and the input/output terminals. These cells should be connected with lines corresponding to the logical design. However, unless the layout of the cells is designated, wiring is not determined.

A fundamental problem for laying out cells is to optimally obtain a two-dimensional layout of cells of various sizes (mainly, rectangular cells) free from two-dimensionally overlapping in consideration of the line connections among them. The optimization of this layout is a problem in which the degree of freedom of the search space is very large. Thus, a highly heuristic solution is required.

The method that has been widely used for easily designing a layout is the standard cell method (gate array method). In this method, the lengths of individual cells are regulated and many cells are laid out breadthwise. Input/output terminals of the cells are laid out lengthwise only. When the lengths of the cells are restricted and the layout positions thereof are restricted, the degree of freedom of the two dimensional layout problem is reduced.

When cells are two-dimensionally laid out without restricting the sizes and shapes thereof, a problem for laying out many rectangles in a two-dimensional container (for example, a circuit base board or a chip) as compactly as possible needs to be solved. Thus, this problem is referred to as “a problem for optimizing a two-dimensional layout of rectangles.”

As one method for optimizing a two-dimensional layout of rectangles, Otten et al. has proposed the “Slicing floorplan” method (R. H. J. M Otten, “Automatic Floorplan Design, in Proc. 19th ACM/IEEE Design Automation Conf., pp. 261-267, 1982). In this method, one rectangular base board is sliced lengthwise or breadthwise into two portions at a suitable position. Each of the sliced portions is further sliced into two portions. This process is repeated.

A two-branched tree that represents such division is formed as a data structure. By laying out individual cells to branches, the required area is obtained. By varying the dividing method (a combination of lengthwise and breadthwise slicing), the minimum area is obtained. A drawback of this method is in that rectangles cannot be laid out in a chained pattern.

In addition, Nakatake et al. has proposed the BSG (Bounded Slicing Grid) method for optimizing a two-dimensional layout of rectangles (S. Nakatake, K. Fujiyoshi, H. Murata, Y. Kajitani, “Module Placement on BSG-Structure and IC Layout Applications,” Int. Conf. on Computer Aided Design, 1996). In this method, cells are laid out on grids with a special structure termed a BSG. The cells are mapped to a physical space corresponding to the rules of BSG method.

The BSG method represents a restriction in which cells are laid out lengthwise and breadthwise adjacent to the positions of the BSG grids. Since this restriction is strict, blanks are inserted at suitable positions on the grids to obtain a more compact layout. To optimize the layout of the cells, trial and error is repeated in laying out cells in the BSG and an optimum result is selected.

In the aforementioned standard cell method, slicing floorplan method, and BSG method, as a common process, various layouts are simulated and an optimum result is obtained. When this trial and error process is manually performed, huge amounts of work are required.

To solve this problem, with a proper evaluation function, the simulation is performed as effectively and systematically as possible. To do that, a conventional optimizing method can be used. As such a conventional method, the simulated annealing (SA) method has become popular.

In the SA method, the optimizing search space is represented with parameters. By a converting operation with parameters including a probability element, a desired solution is searched for by trial and error. In the SA method, it is important to consider how search parameters are structured for the problem they are to be applied to, (in this case a problem of a two-dimensional layout of rectangles), and when a particular parameter is given, how the given parameter is converted into a particular space (namely, laid out two-dimensionally) and how the obtained result is evaluated.

These points should be considered for individual problems and solutions. In reality, the optimization by the SA method has been attempted with the standard cell method, slicing floorplan method, and BSG method.

However, the aforementioned conventional solving methods have the following drawbacks.

In the standard cell method, so as to simplify a given problem, the lengths of cells and the two-dimensional layout thereof are restricted. According to this method, although the problem is simplified, it is not assured that wiring among the cells are optimum. It is logically clear that when such restrictions are not applied, better layout results can be obtained.

In the slicing floorplan method, since the slicing in two process is repeated, special layouts such as a four-rectangle-chained shape cannot be represented. Although a modification method for representing such a shape has been studied, complicated calculations are required.

In the BSG method, the structure of the grids is special and complicated. In addition, the restrictions are strict. In other words, unless many blanks are inserted on the grids, cells cannot be freely laid out. Thus, the BSG method is used for automatically optimizing a layout of cells corresponding to the SA method, rather than creating a BSG that represents a two-dimensional layout by a designer. Although good results from calculations in the SA method have been obtained at the laboratory level, they should be further improved for practical use.

As described above, although many CAD tools for two-dimensional layouts have been developed and used, with respect to calculation time and quality thereof, there are still many problems to be solved.

In the designing phase of a cell layout for a VLSI that requires high performance, it is stated that a manual layout performed by an experienced designer is superior to an automatic layout. In addition, as the structure and scale of the VLSI have become complicated and large and the required design period has become short, a new approach for solving the problem of a two-dimensional layout has been strongly desired.

SUMMARY OF THE INVENTION

An object of the present invention is to provide a two-dimensional layout apparatus for accurately and promptly solving such a two-dimensional layout problem and a method thereof.

A first aspect of the present invention is a two-dimensional layout system having a storing unit and a layout unit for designing a layout of a plurality of objects. The objects are any physical resources that have shapes and sizes.

The storing unit stores a priority rule for layout positions. The layout unit determines the layout positions of the objects in a layout space according to the priority rule for the layout positions. The priority rule for the layout positions represents a predetermined rule for determining priority layout positions of objects in the current layout space.

A second aspect of the present invention is a two-dimensional layout system having a space representing unit and a managing unit. The space representing unit represents a two-dimensional space composed of at least one closed figure surrounded by lengthwise sides and breadthwise sides with a set of inscribed rectangles, a part of each side of which is included in a side of the closed figure. The managing unit manages the two-dimensional space with the set of inscribed rectangles.

A third aspect of the present invention is a reverse analyzing apparatus having a storing unit and an analyzing unit. The storing unit stores a priority rule for layout positions. The analyzing unit analyzes a layout result of a plurality of objects, and obtains a layout order for objects to restore the layout result by laying out the objects according to the priority rule for the layout positions.

A fourth aspect of the present invention is a layout evaluating apparatus having a layout unit and an evaluating unit for designing a layout of a plurality of objects. Whenever an object is received, the layout unit determines the layout position of the received object in a layout space according to the priority rule for the layout positions. The evaluating unit evaluates the layout result obtained by the layout unit.

A fifth aspect of the present invention is a layout optimizing apparatus having a storing unit, a layout unit, and an evaluating unit for designing a layout of a plurality of objects. The storing unit stores a priority rule for layout positions. Whenever an object is received, the layout unit determines the layout position of the received object in a layout space, which is defined by excluding other objects that have been laid out from an initial space, according to the priority rule for the layout positions. The evaluating unit evaluates a plurality of layout results obtained by varying at least one of the object layout order, the priority rule for the layout positions, and the initial space, and selects an excellent layout result.

A sixth aspect of the present invention is a layout optimizing apparatus having a storing unit, a layout unit, an evaluating unit, and a searching unit based on the simulated annealing method for designing a layout of a plurality of objects.

The storing unit stores at least one priority rule for layout positions. Whenever an object is received, the layout unit determines the layout position of the received object in a layout space according to the priority rule for the layout positions. The evaluating unit evaluates the layout result obtained by the layout unit. The searching unit represents the object layout order as a parameter of the search space. While varying the parameter according to the simulated annealing method, the searching unit searches the search space and automatically obtains an excellent layout result.

A seventh aspect of the present invention is a layout optimizing apparatus having a storing unit, a layout unit, an evaluating unit, and a searching unit based on a genetic algorithm for designing a layout of a plurality of objects.

The storing unit stores at least one priority rule for layout positions. Whenever an object is received, the layout unit determines the layout position of the received object in a layout space according to the priority rule for the layout positions. The evaluating unit evaluates the layout result obtained by the layout unit. The searching unit represents the object layout order as gene data, performs a genetic operation for a gene group including at least one gene data according to the genetic algorithm, and automatically obtains an excellent layout result.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a schematic diagram showing the principle of a two-dimensional layout system according to the present invention; [0037]
FIG. 2 is a schematic diagram showing a set of inscribed rectangles of a figure; [0038]
FIG. 3 is a schematic diagram showing a set of inscribed rectangles of a figure having a concaved portion; [0039]
FIG. 4 is a schematic diagram showing a set of inscribed rectangles of a figure having an opening therein; [0040]
FIG. 5 is a schematic diagram showing a set of inscribed rectangles of separated figures; [0041]
FIG. 6 is a schematic diagram showing the structure of a two-dimensional layout system; [0042]
FIG. 7 is a schematic diagram showing the first layout example; [0043]
FIG. 8 is a schematic diagram showing an initial setting; [0044]
FIG. 9 is a schematic diagram showing the layout of the first object; [0045]
FIG. 10 is a schematic diagram showing the layout of the second object; [0046]
FIG. 11 is a schematic diagram showing the layout of the third object; [0047]
FIG. 12 is a schematic diagram showing an example of the layout in which an occupied blank area is laid out around objects; [0048]
FIG. 13 is a schematic diagram showing a reverse analyzing apparatus; [0049]
FIG. 14 is a schematic diagram showing an evaluating unit and a selecting unit; [0050]
FIG. 15 is a schematic diagram showing four orientations; [0051]
FIG. 16 is a block diagram showing the structure of an information processing apparatus; [0052]
FIG. 17 is a schematic diagram showing relative positions of two rectangles; [0053]
FIG. 18 is a calculation table for the sum of rectangles (No. 1); [0054]
FIG. 19 is a calculation table for the sum of rectangles (No. 2); [0055]
FIG. 20 is a schematic diagram showing the first example of the sum of rectangles; [0056]
FIG. 21 is a calculation table for the difference of rectangles (No. 1); [0057]
FIG. 22 is a calculation table for the difference of rectangles (No. 2); [0058]
FIG. 23 is a schematic diagram showing an example of the difference of rectangles; [0059]
FIG. 24 is a schematic diagram showing the second example of the sum of rectangles; [0060]
FIG. 25 is a schematic diagram showing the first intermediate data; [0061]
FIG. 26 is a schematic diagram showing the second intermediate data; [0062]
FIG. 27 is a schematic diagram showing the first set of inscribed rectangles; [0063]
FIG. 28 is a schematic diagram showing the third example of the sum of rectangles; [0064]
FIG. 29 is a schematic diagram showing the third intermediate data; [0065]
FIG. 30 is a schematic diagram showing the second set of inscribed rectangles; [0066]
FIG. 31 is a schematic diagram showing the fourth example of the sum of rectangles; [0067]
FIG. 32 is a schematic diagram showing the fourth intermediate data; [0068]
FIG. 33 is a schematic diagram showing the third set of inscribed rectangles; [0069]
FIG. 34 is a schematic diagram showing the fifth example of the sum of rectangles; [0070]
FIG. 35 is a schematic diagram showing the fifth intermediate data; [0071]
FIG. 36 is a schematic diagram showing the sixth intermediate data; [0072]
FIG. 37 is a schematic diagram showing the seventh intermediate data; [0073]
FIG. 38 is a schematic diagram showing the eighth intermediate data; [0074]
FIG. 39 is a schematic diagram showing the ninth intermediate data; [0075]
FIG. 40 is a schematic diagram showing the tenth intermediate data; [0076]
FIG. 41 is a schematic diagram showing the fourth set of inscribed rectangles; [0077]
FIG. 42 is a schematic diagram showing the sixth example of the sum of rectangles; [0078]
FIG. 43 is a schematic diagram showing the eleventh intermediate data; [0079]
FIG. 44 is a schematic diagram showing the twelfth intermediate data; [0080]
FIG. 45 is a schematic diagram showing the thirteenth intermediate data; [0081]
FIG. 46 is a schematic diagram showing the fifth set of inscribed rectangles; [0082]
FIG. 47 is a schematic diagram showing the first layout process; [0083]
FIG. 48 is a schematic diagram showing the second layout process; [0084]
FIG. 49 is a schematic diagram showing the third layout process; [0085]
FIG. 50 is a schematic diagram showing the first raising process; [0086]
FIG. 51 is a schematic diagram showing the second raising process; [0087]
FIG. 52 is a schematic diagram showing the third raising process; [0088]
FIG. 53 is a schematic diagram showing the fourth layout process; [0089]
FIG. 54 is a schematic diagram showing the fourth raising process; [0090]
FIG. 55 is a schematic diagram showing the fifth raising process; [0091]
FIG. 56 is a schematic diagram showing the fifth layout process; [0092]
FIG. 57 is a schematic diagram showing the sixth layout process; [0093]
FIG. 58 is a schematic diagram showing the first list structure pointing to rectangles in the first level; [0094]
FIG. 59 is a schematic diagram showing the second list structure pointing to rectangles in the second level; [0095]
FIG. 60 is a schematic diagram showing the first list of data of individual rectangles; [0096]
FIG. 61 is a schematic diagram showing the third list structure pointing to rectangles in the first level; [0097]
FIG. 62 is a schematic diagram showing the fourth list structure pointing to rectangles in the second level; [0098]
FIG. 63 is a schematic diagram showing the second list of data of individual rectangles; [0099]
FIG. 64 is a flowchart showing a process of a space managing unit; [0100]
FIG. 65 is a flowchart showing a process for calculating the sum of rectangles; [0101]
FIG. 66 is a flowchart showing a rectangle layout process; [0102]
FIG. 67 is a flowchart (No. 1) showing a rearranging process; [0103]
FIG. 68 is a flowchart (No. 2) showing a rearranging process; [0104]
FIG. 69 is a flowchart (No. 3) showing a rearranging process; [0105]
FIG. 70 is a flowchart (No. 1) showing the first calculated result storing process; [0106]
FIG. 71 is a flowchart (No. 2) showing the first calculated result storing process; [0107]
FIG. 72 is a flowchart (No. 1) showing the second calculated result storing process; [0108]
FIG. 73 is a flowchart (No. 2) showing the second calculated result storing process; [0109]
FIG. 74 is a schematic diagram showing a figure with four rectangles connected in chain pattern; [0110]
FIG. 75 is a schematic diagram showing the fourteenth intermediate data; [0111]
FIG. 76 is a schematic diagram showing the fifteenth intermediate data; [0112]
FIG. 77 is a schematic diagram showing the sixteenth intermediate data; [0113]
FIG. 78 is a schematic diagram showing the seventeenth intermediate data; [0114]
FIG. 79 is a schematic diagram showing the eighteenth intermediate data; [0115]
FIG. 80 is a schematic diagram showing the nineteenth intermediate data; [0116]
FIG. 81 is a schematic diagram showing the twentieth intermediate data; [0117]
FIG. 82 is a schematic diagram showing the twenty-first intermediate data; [0118]
FIG. 83 is a schematic diagram showing the twenty-second intermediate data; [0119]
FIG. 84 is a schematic diagram showing the twenty-third intermediate data; [0120]
FIG. 85 is a schematic diagram showing the twenty-fourth intermediate data; [0121]
FIG. 86 is a schematic diagram showing the twenty-fifth intermediate data; [0122]
FIG. 87 is a schematic diagram showing the twenty-sixth intermediate data; [0123]
FIG. 88 is a schematic diagram showing the twenty-seventh intermediate data; [0124]
FIG. 89 is a schematic diagram showing the twenty-eighth intermediate data; [0125]
FIG. 90 is a schematic diagram showing the twenty-ninth intermediate data; [0126]
FIG. 91 is a schematic diagram showing the thirtieth intermediate data; [0127]
FIG. 92 is a schematic diagram showing the thirty-first intermediate data; [0128]
FIG. 93 is a schematic diagram showing the thirty-second intermediate data; [0129]
FIG. 94 is a schematic diagram showing the sixth set of inscribed rectangles; [0130]
FIG. 95 is a flowchart showing a process of a two-dimensional layout apparatus; [0131]
FIG. 96 is a schematic diagram showing 16 rectangles; [0132]
FIG. 97 is a schematic diagram showing the second layout example; [0133]
FIG. 98 is a schematic diagram showing the third layout example; [0134]
FIG. 99 is a schematic diagram showing the fourth layout example; [0135]
FIG. 100 is a schematic diagram showing the fifth layout example; [0136]
FIG. 101 is a schematic diagram showing the sixth layout example; [0137]
FIG. 102 is a schematic diagram showing layout positions with priority at a lower left position; [0138]
FIG. 103 is a schematic diagram showing the seventh layout example; [0139]
FIG. 104 is a schematic diagram showing the eighth layout example; [0140]
FIG. 105 is a schematic diagram showing the first intermediate layout; [0141]
FIG. 106 is a schematic diagram showing the second intermediate layout; [0142]
FIG. 107 is a schematic diagram showing the ninth layout example; [0143]
FIG. 108 is a schematic diagram showing the tenth layout example; [0144]
FIG. 109 is a schematic diagram showing distances from outer peripheral sides; [0145]
FIG. 110 is a schematic diagram showing the third intermediate layout; [0146]
FIG. 111 is a schematic diagram showing the fourth intermediate layout; [0147]
FIG. 112 is a schematic diagram showing t he eleventh layout example; [0148]
FIG. 113 is a schematic diagram showing the twelfth layout example; [0149]
FIG. 114 is a schematic diagram showing an approximating method of an arbitrary shape; [0150]
FIG. 115 is a schematic diagram showing a hierarchical layout; [0151]
FIG. 116 is a schematic diagram showing blank spaces in the third layout example; [0152]
FIG. 117 is a schematic diagram showing a reverse analyzing process; [0153]
FIG. 118 is a flowchart showing simulated annealing process; and [0154]
FIG. 119 is a flowchart showing a genetic algorithm.[0155]

DESCRIPTION OF PREFERRED EMBODIMENTS

FIG. 1 is a schematic diagram showing the principle of a two-dimensional layout system according to the present invention. The two-dimensional layout system shown in FIG. 1 comprises a [0156] space representing unit 1, a managing unit 2, a storing unit 3, a layout unit 4, and an evaluating unit 5. The two-dimensional layout system designs a layout of a plurality of objects. In this case, the objects represent any physical resources that have shapes and sizes, not limited to circuit parts or semiconductor cells of a VLSI.
The [0157] storing unit 3 stores a priority rule for layout positions. Whenever an object is received, the layout unit 4 determines the layout position of the received object in a layout space according to the priority rule for the layout positions.
The priority rule for the layout positions is a predetermined rule for determining priority layout positions for objects in the current layout space. For example, the priority direction in the layout space is designated beforehand. Objects are laid out in the designated direction. [0158]
When objects are successively received and laid out in the layout space, the [0159] layout unit 4 lays out the received objects in the layout space without moving other objects that have been laid out and overlapping therewith according to the priority rule for the layout positions.
Thus, when the priority rule for the layout positions is designated beforehand, the layout positions of objects can be automatically determined. In other words, objects are successively laid out in the received order. Consequently, any layout problem can be effectively solved without empirical knowledge of a skilled engineer. [0160]
The [0161] space representing unit 1 represents a two-dimensional space composed of at least one closed figure (referred to hereinafter as figure S) surrounded by lengthwise sides and breadthwise sides with a set of inscribed rectangles, a part of or all of each side of which is included in a side of the closed figure. The managing unit 2 manages the space with the set of inscribed rectangles.
The closed figures represent the initial space, each of which can be divided into several rectangles. Objects to be laid out, having any shapes and sizes, are represented as rectangles. The layout space during the process is equal to an area which is obtained by removing the spaces of other objects that have been laid out from the initial space. Thus, after the process is started, the layout space is composed of at least one closed figure surrounded by lengthwise sides and breadthwise sides. An inscribed rectangle of a particular closed figure S is defined as a rectangle, a part of or all of each side of which is included in a side of the figure S and which is inside the figure S. A set of inscribed rectangles of the figure S is defined as a set of all possible inscribed rectangles of the figure S. At this point, the area of the figure S is represented with the sum of the inscribed rectangles thereof. [0162]
Whenever an object is laid out, the managing [0163] unit 2 communicates with the layout unit 4 and inputs as a new layout space to the space representing unit 1 an area which is obtained by excluding the rectangle thereof from the layout space. The space representing unit 1 represents the layout space received from the managing unit 2 as a set of inscribed rectangles thereof.
The set of inscribed rectangles can uniquely represent any closed figure represented with lengthwise sides and breadthwise sides. In addition, the remaining space can be represented with a set of inscribed rectangles. Thus, the layout space of any two-dimensional layout problem can be managed. A closed figure of a layout space may have concaved (recessed) portions or holes. [0164]
The evaluating [0165] unit 5 evaluates a plurality of layout results obtained by varying at least one of the object layout order, the priority rule for the layout positions, and the initial space, and selects an excellent layout result.
The object layout order represents the order of a plurality of objects supplied to the [0166] layout unit 4.
When the object layout order is varied, the layout results are varied. Likewise, when the priority rule for the layout positions or the shape/size of the initial space is varied, the layout results are varied. Thus, with various combinations of such conditions, various layout results can be obtained. [0167]
The evaluating [0168] unit 5 evaluates the layout results with a proper evaluation function and outputs a relatively good layout result as an excellent layout result. When such conditions are varied, since the layout results can be uniquely obtained, the excellent layout result can be automatically and effectively determined. In addition, by repeating such a process for many layouts, an excellent result can be selected therefrom. Thus, since the objects are optimally laid out, a desired layout result can be obtained.
For example, the [0169] space representing unit 1 and the managing unit 2 shown in FIG. 1 accord with a layout space managing unit 12 shown in FIG. 6. The storing unit 3 and the layout unit 4 shown in FIG. 1 accord with a two-dimensional layout unit 11 shown in FIG. 6. The evaluating unit 5 shown in FIG. 1 accords with a two-dimensional layout evaluating unit 16 shown in FIG. 14.
According to the present invention, in designing a printed circuit and a VLSI, parts and cells are laid out in the second phase. However, the present invention is not limited to such problems. Instead, the present invention can be applied for a general two-dimensional layout problem. For example, a general two-dimensional layout problem is defined as follows. [0170]
There are many “objects” to be laid out. These objects are two-dimensionally laid out in a “container” that is a designated (appropriately selectable) area in such a manner that they do not overlap. The external shapes of the “objects” are basically rectangular. The objects have individual sizes and shapes (length-breadth ratios). [0171]
The objects should be laid out as compactly as possible. In addition, the layout results are evaluated with other data such as the positions of the “objects,” the mutual relation thereof, and wiring among them. To obtain the best evaluated result, the objects should be laid out optimally or semi-optimally. [0172]
Such a two-dimensional layout problem should be solved in a more general method with a better evaluated result (for example a compact layout result) in a shorter calculation time. [0173]
A fundamental feature of the present invention is that when “objects” to be laid out have been designated and a priority rule for layout positions thereof has been designated, the “objects” are successively laid out without moving the other “objects” that have been laid out. Thus, the “objects” are laid out two-dimensionally. The layout results are evaluated with a proper evaluation function so as to select a desired layout result. [0174]
To obtain the desired layout result, the priority rule for the layout positions should be designated beforehand. Corresponding to the priority rule, the input order of the “objects” should be designated. Thus, various layout orders are simulated using the layout processing unit (layout simulator) that has at least one priority rule of layout positions and then a layout with the highest evaluated result is selected. [0175]
To simulate the priority rule for layout positions and the layout order and automatically select the optimum (or semi-optimum) solution, the genetic algorithm (GA) or simulated annealing (SA) method can be used. [0176]
In this example, it is assumed that “objects” to be laid out have arbitrary rectangular shapes and sizes. When “objects” with complicated shapes are laid out, their overall shapes can be treated using appropriate rectangles as an approximation. [0177]
On the other hand, a “container” in which “objects” are laid out may be formed in a shape composed of a plurality of rectangles with their lengthwise and breadthwise directions arranged in order. The “container” may have concaved portions, holes, or obstacles. In addition, the “container” may be separated into a plurality of areas. The “obstacle” represents a portion on which an “object” cannot be laid out. For example, the “obstacle” represents a hole or another object. [0178]
A fundamental feature of present invention that accomplishes the above described two-dimensional layout optimizing method is a layout space managing unit that represents and manages a space in which objects can be laid out using a set of inscribed rectangles. The shape of the space managed by the apparatus is defined in the same manner as the shape of the “container.”[0179]
In other words, the shape of the space is defined as the closed figure S composed of one or a plurality of inscribed rectangles with arbitrary sizes. The rectangles are composed of lengthwise and breadthwise sides with the lengthwise and breadthwise orientations arranged in order. For example, a side lies in one of vertical and horizontal directions. The closed figure S may have concaved portions, holes, or obstacles. The closed figure S may be separated into a plurality of areas. [0180]
Next, an example of the figure S and an example of a set of inscribed rectangles will be described. In these examples, figures are denoted as follows. [0181]
Rectangle of width w×height h: □(w, h) [0182]
Rectangle with four vertices (x[0183] ₀, y₀), (x₁, y₀), (x₁, y₁), (x₀, y₁): □((x₀, x₁), (y₀, y₁))
“Object” is denoted by ▪ instead of □, when it should be clearly distinguished from blank areas. [0184]
The figure S (denoted by thick lines) shown in FIG. 2, for example, has four inscribed rectangles. [0185]
a=□((1, 4), (0, 3)) [0186]
b=□((2, 4), (0, 4)) [0187]
c=□((0, 5), (1, 3)) [0188]
d=□((2, 5), (1, 4)) [0189]
The set of the inscribed rectangles of the figure S: [0190]
Set of inscribed rectangles of S={a, b, c, d}[0191]
The area of the figure S is denoted by the inscribed rectangles as follows. [0192]
S=a∪b∪c∪d [0193]
But the following rectangles are not inscribed rectangles. [0194]
g=□((2, 4), (0, 3)) [0195]
h=□((0, 4), (1, 3)) [0196]
In the case of a figure S having a concaved portion, as shown in FIG. 3, inscribed rectangles of the figure S, a set of the inscribed rectangles, and an area of the figure S are denoted as follows. [0197]
a=□((0, 1), (0, 5)) [0198]
b=□((2, 4), (1, 5)) [0199]
c=□((0, 4), (3, 5)) [0200]
Set of inscribed rectangles of S={a, b, c}[0201]
S=a∪b∪c∪d [0202]
In this case, the following rectangles are not inscribed rectangles. [0203]
g=□((0, 1), (0, 3)) [0204]
h=□((0, 4), (1, 5)) [0205]
In the case of a figure S having a hole, as shown in FIG. 4, inscribed rectangles of the figure S, a set of the inscribed rectangles, and an area of the figure S are denoted as follows. [0206]
a=□((0, 5), (0, 2)) [0207]
b=□((0, 2), (0, 6)) [0208]
c=□((4, 5), (0, 6)) [0209]
d=□((0, 5), (4, 6)) [0210]
Set of inscribed rectangles of S={a, b, c, d}[0211]
S=a∪b∪c∪d [0212]
In FIG. 4, ▪((2, 4), (2, 4)) represents an area (that is, “hole” or “obstacle”) which is not included in the figure S. [0213]
In the case of a figure S composed of separated areas, as shown in FIG. 5, inscribed rectangles of the figure S, a set of the inscribed rectangles, and an area of the figure S are represented as follows. [0214]
a=□((0, 1), (0, 4)) [0215]
b=□((2, 5), (0, 2)) [0216]
c=□((4, 5), (0, 4)) [0217]
Set of inscribed rectangles of S={a, b, c}[0218]
S=a∪b∪c [0219]
As one method for obtaining a set of inscribed rectangles of each of various figures, the set is represented with a combination of appropriate rectangles. As the basis for such a method, an area which is the “sum” or “difference” of two rectangles is represented with a set of inscribed rectangles. [0220]
The layout space managing unit manages the layout space with any shape as a set of inscribed rectangles. When one “object” (rectangle) is commanded to be laid out at a particular position, the unit lays out the object, represents the remaining layout space as inscribed rectangles again, and manages them. When a commanded “object” cannot be laid out at the designated position, the unit informs a user of the result. [0221]
To do this, the layout space managing unit performs the following two types of basic calculations as internal functions. [0222]
(a) Calculation for “sum” of rectangles: The sum of areas of two rectangles (having any positional relation) is represented with a set of inscribed rectangles. [0223]
(b) Calculation for “difference” of rectangles: A rectangle is subtracted from another rectangle (having any positional relation therewith) and the remaining space is represented with a set of inscribed rectangles. [0224]
The layout space managing process is executed by a combination of such calculations. The twodimensional layout system having such a layout space managing unit has the fundamental structure as shown in FIG. 6. [0225]
In the two-dimensional layout system shown in FIG. 6, an appropriate priority rule for layout positions has been supplied to a two-dimensional layout unit (LM) [0226] 11. As a layout space in the initial state (initial space), a “container” is designated. The two-dimensional layout unit 11 supplies the “container” to a layout space managing unit (SM) 12. The layout space managing unit 12 stores the “container” as a set of inscribed rectangles. In this example, the two-dimensional layout unit 11 and the layout space managing unit 12 are disposed as separate units. However, it should be noted that the layout space managing unit 12 may be built into the two-dimensional layout unit 11.
“Objects” (rectangles) are successively input to the two-[0227] dimensional layout unit 11. Each “object” is designated with a width w and a height h. If necessary, each “object” has additional information such as the name, type, orientation, and front/rear. The two-dimensional layout unit 11 communicates with the layout space managing unit 12 and two-dimensionally lays out the designated “objects” in succession. In this case, the following three conditions should be satisfied.
(a) “Objects” should be laid out only within the “container.”[0228]
(b) “Objects” that have been laid out should not be moved. [0229]
(c) “Objects” to be newly laid out should not overlap with “objects” that have been laid out. [0230]
When one “object” is input to the two-[0231] dimensional layout unit 11, it performs the following process. The two-dimensional layout unit 11 receives information of a blank space as a set of inscribed rectangles from the layout space managing unit 12. The two-dimensional layout unit 11 can select an inscribed rectangle with the first priority (for example, an inscribed rectangle at the furthest lower left position) according to the priority rule for layout positions.
Thereafter, the two-[0232] dimensional layout unit 11 orders the layout space managing unit 12 to lay out the “object” to the designated position (for example, the lower left corner) according to the priority rule for the layout positions. When the layout space managing unit 12 replies with a message that represents that the “object” cannot be laid out at the designated position, the two-dimensional layout unit 11 orders the layout space managing unit 12 to lay out the “object” at the inscribed rectangle with the second priority position, the third priority position, and so forth. After the layout space managing unit 12 has laid out the “object,” it receives the next “object.”
After all “objects” have been input and laid out, the two-[0233] dimensional layout unit 11 outputs the layout positions of the “objects” and the additional information thereof as the result. When one “object” is input and it cannot be successfully laid out in any of the set of inscribed rectangles, the layout of that “object” is unsuccessful.
In this case, the layout of the “objects” in this specific order was unsuccessful. The two-[0234] dimensional layout unit 11 outputs a message that represents that the layout was unsuccessful and completes the process. However, depending on a problem to be resolved, an “object” that has not been laid out may be skipped and the next “object” may be laid out.
For clarifying the present method, the process of the two-dimensional layout system will be described with a simple example. FIG. 7 shows an example of the process of which “objects” a, b, c, d, e, and f have been successively laid out in a rectangular “container” with a width of 10 and a height of 8. The layout process is performed in the following order. [0235]
[0] Initial setting [0236]
In this example, a layout priority rule provides that an “object” is laid out from the lowermost position and from the leftmost position on a specific horizontal line is used. In addition, as a “container,” a rectangle □(10, 8) shown in FIG. 8 is designated. At the initial stage in this case, a blank space in which an “object” can be laid out is represented by □(10, 8). [0237]
[1] A first “object” a▪(2, 4) is input. The first-priority candidate position for the layout is the lower left corner of the rectangle of the blank space. Thus, as shown in FIG. 9, the “object” a▪(2, 4) can be laid out at the lower left corner of the rectangle of the blank space. Thus, the first “object” a▪(2, 4) is laid out at the following position. [0238]
a▪((0, 2), (0, 4)) [0239]
As a result, the set of inscribed rectangles of the remaining blank space are as follows in the priority order of the layout. [0240]
q[0241] ₁=□((2, 10), (0, 8))
q[0242] ₂=□((0, 10), (4, 8))
[2] A second “object” b▪(4, 2) is input. The lower left corner of the inscribed rectangle q[0243] ₁with the first priority is designated as the first-priority candidate position. As shown in FIG. 10, it is clear that the “object” b▪(4, 2) can be laid out at this position. Thus, the second “object” b▪(4, 2) is laid out at the following position.
b▪((2, 6), (0, 2)) [0244]
As a result, the set of inscribed rectangles of the remaining blank space are as follows in the priority order of the layout. [0245]
q[0246] ₁=□((6, 10), (0, 8))
q[0247] ₂=□((2, 10), (2, 8))
q[0248] ₃=□((0, 10), (4, 8))
[3] A third “object” c▪(6, 2) is input. The lower left corner of the inscribed rectangle q[0249] ₁with the first priority is designed as the first-priority candidate position. However, the third “object” c▪(6, 2) cannot be laid out at the lower left corner of the inscribed rectangle q₁. Thus, the lower left corner of the inscribed rectangle q₂with the second priority is designated as the next-priority candidate position. As shown in FIG. 11, it is clear that the third “object” c▪(6, 2) can be laid out at the lower left corner of the inscribed rectangle q₂with the second priority. Thus, the third “object” c▪(6, 2) is laid out at the following position.
c▪((2, 8), (2, 4)) [0250]
As a result, the set of inscribed rectangles of the remaining blank space are as follows in the priority order of the layout. [0251]
q[0252] ₁=□((6, 10), (0, 2))
q[0253] ₂=□((8, 10), (0, 8))
q[0254] ₃=□((0, 10), (4, 8))
Although the following steps of the layout process are not shown in figures, they can be performed in the same manner as the above-described steps. [0255]
[4] A fourth “object” d▪(2, 6) is input. The lower left corner of the inscribed rectangle q[0256] ₁with the first priority is designated as the first-priority candidate position. However, the fourth “object” d▪(2, 6) cannot be laid out at the lower left corner of q₁. Thus, the lower left corner of the inscribed rectangle q₂with the second priority is designated as the next-priority candidate position. Thus, it is clear that the fourth “object” d▪(2, 6) can be laid out at the lower left corner of the inscribed rectangle q₂with the second priority. Thus, the fourth “object” d▪(2, 6) is laid out at the following position.
d▪((8, 10), (0, 6)) [0257]
As a result, the set of inscribed rectangles of the remaining blank space are as follows in the priority order of the layout. [0258]
q[0259] ₁=□((6, 8), (0, 2))
q[0260] ₂=□((0, 8), (4, 8))
q[0261] ₃=□((0, 10), (6, 8))
[5] A fifth “object” e▪(6, 4) is input. The lower left corner of the inscribed rectangle q[0262] ₁with the first priority is designated as the first-priority candidate position. However, the fifth “object” e▪(6, 4) cannot be laid out at the lower left corner of the inscribed rectangle q₁with the first priority. Thus, the lower left corner of the inscribed rectangle q₂with the second priority is designated as the next-priority candidate position. It is clear that the fifth “object” e▪(6, 4) can be laid out at the lower left corner of the inscribed rectangle q₂with the second priority. Thus, the fifth “object” e▪(6, 4) is laid out at the following position.
e▪((0, 6), (4, 8)) [0263]
As a result, the set of inscribed rectangles of the blank space are as follows in the priority order of the layout. [0264]
q[0265] ₁=□((6, 8), (0, 2))
q[0266] ₂=□((6, 8), (4, 8))
q[0267] ₃=□((6, 10), (6, 8))
[6] A sixth “object” f▪(2, 2) is input. The lower left corner of the inscribed rectangle q[0268] ₁with the first priority is designated as the first-priority candidate position. It is clear that the sixth “object” f▪(2, 2) can be laid out at the lower left corner of the inscribed rectangle q₁with the first priority. Thus, the sixth “object” f▪(2, 2) is laid out at the following position.
f▪((6, 8), (0, 2)) [0269]
As a result, the set of inscribed rectangles of the remaining blank space are as follows in the priority order of the layout. [0270]
q[0271] ₁=□((6, 8), (4, 8))
q[0272] ₂=□((6, 10), (6, 8))
[7] After all the “objects” have been input, an ending process is performed. As a result, the following list of objects is output. [0273]
a▪((0, 2), (0, 4)), b▪((2, 6), (0, 2)), [0274]
c▪((2, 8), (2, 4)), d▪((8, 10), (0, 6)), [0275]
e▪((0, 6), (4, 8)), f▪((6, 8), (0, 2)) [0276]
The set of the inscribed rectangles of the blank space becomes as follows. [0277]
{□((6, 8), (4, 8)), □((6, 10), (6, 8))}[0278]
In this example, it should be noted that the “object” f is laid out at the lower side position of the “container.” In this case, it is assumed as a sub-rule of the layout rule that a new “object” can be laid out in a blank area even if it is surrounded with other “objects”. [0279]
As described above, the layout [0280] space managing unit 12 can represent and manage a complicated shape with a combination of simple rectangles. Thus, with a command, the user can order the two-dimensional layout system to accomplish the following functions.
(a) With a plurality of rectangles having appropriate sizes and positions, a figure in a complicated shape represented by a combination of rectangles can be formed. The formed figure may be designated as a “container.”[0281]
(b) A particular position of the “container” may be designated for a particular (at least one) “object” (rectangle). The “object” is laid out at the designated position with the highest priority. The remaining blank space is treated as the normal “container.” The other “objects” are laid out in the blank space according to the normal priority rule. [0282]
The basic rule of the two-dimensional layout according to the embodiment is in that “objects” should be laid out as compactly as possible. Thus, it is necessary to lay out the “objects” in such a manner that there is no unnecessary blanks in the two-dimensional layout. However, depending on a problem, a blank area may be actively formed at a desired position. In this case, the following two methods are effective. [0283]
(a) An “occupied blank area” represented by a rectangle is treated as one “object.” The “occupied blank area” is inserted into a suitable position in the object sequence and input to the two-[0284] dimensional layout unit 11.
(b) An occupied blank area with an appropriate width w[0285] 1 is attached around a rectangle of an “object.” The rectangle with the occupied blank area is input to the two-dimensional layout unit 11 or the layout space managing unit 12. In this case, as shown in FIG. 12, when an area with a width w1 is attached around a “container” 13, “objects” 14 are laid out properly in contact with the “container” 13. On the other hand, the “objects” 14 can be spaced with a blank area with a width of double w1. In the case of a layout problem of a printed circuit board and a VLSI, the occupied blank area can be used as a wiring area.
As a basic method for designating a priority rule for layout positions, a coordinate system of a two-dimensional layout is designated. Thereafter, “main direction” and “sub direction” that represent the directions of the priority of the layout on the coordinate system are designated as two directional vectors. Thus, “objects” are laid out according to the following rules. [0286]
(a) “Objects” are successively laid out at the position farthest in the direction that the “main direction” vector represents in the blank space. [0287]
(b) When there are a plurality of positions with the same priority order in the “main direction,” they are successively laid out at the position farthest in the direction that the “sub direction” vector represents. [0288]
The “main direction” and the “sub direction” may be placed in parallel with the coordinate axes or angled thereto. In the following description, “main direction” and “sub direction” are represented as a pair in a form of “main direction/sub direction” such as “down first/left first.” In a basic method of layout, while all “objects” are being laid out, these layout rules should not be changed. [0289]
As a method for designating a priority rule for layout positions, it can be more flexibly and sophisticatedly designated. From the fact that “objects” which are first laid out at four corners and outer peripheral sides can be compactly laid out, the priority rule can be designated in the following manner. [0290]
(a) The position with the smallest distance to the outer peripheral sides of the “container” or the sides of the circumscribed rectangle thereof, in the direction perpendicular to the sides, is treated as the priority layout position. When there are a plurality of positions with the same distance, they are laid out according to the predetermined priority order of corners and sides. The distance from the outer peripheries may be standardized with an appropriate ratio of vertical direction to horizontal direction, and the smallest standardized distance may be treated as the priority condition. In this case, the ratio of the vertical sides to the horizontal sides of the circumscribed rectangle of the “container” may be used. [0291]
(b) The “main direction/sub direction” as a priority rule for the layout positions is rotated by a predetermined angle whenever an “object” is laid out. As the rotation angle, 90 degrees (deg) or another appropriate angle may be used. Thus, “objects” can be laid out at four corners first and then positions close thereto. [0292]
In the two-dimensional layout system shown in FIG. 6, “container” and “priority rule for layout positions” have been designated. Thereafter, “objects” to be laid out are successively received. As a result, a two-dimensional layout is accomplished. In contrast, when one two-dimensional layout is received and “container” and “priority rule for layout positions” are designated, the order of the layout of “objects” can be analyzed by a reverse analyzing apparatus. [0293]
A result of the two-dimensional layout is given by the list of layout positions of “objects” and the list of the set of inscribed rectangles representing the blank space. The reversely analyzed result can include rectangles representing “occupied blank areas” along with “objects.”[0294]
When a reversely analyzed result is input to the two-[0295] dimensional layout unit 11 with the “priority rule for layout positions,” it precisely restores the layout order of a two-dimensional layout to be analyzed. The input/output relation of the two-dimensional layout reverse analyzing apparatus is shown in FIG. 13.
The [0296] reverse analyzing apparatus 15 can be simply structured. Rectangles of “objects” and “blank spaces” that represent an input two-dimensional layout are successively extracted in the priority order represented by the designated “priority rule for layout positions.” Since the “blank spaces” are represented with a set of inscribed rectangles, when one of them is extracted as an “occupied blank area,” the set of inscribed rectangles of the remaining “blank space” should be re-calculated.
In the above-described reverse analyzing method, all inscribed rectangles of a “blank space” are extracted as “occupied blank areas.” When “objects” are laid out according to the designated “priority rule of layout positions,” some of “occupied blank areas” may be skipped, to obtain the same two-dimensional layout. They are not necessary to be represented as “occupied blank areas.”[0297]
On the other hand, there is a case in that, when “occupied blank areas” are skipped and “objects” are laid out, a different two-dimensional layout may be formed. Thus, it is desired to correctly analyze whether or not “occupied blank areas” can be skipped. Consequently, it is desired that “occupied blank areas” are omitted so as to obtain a reversely analyzed result in which “occupied blank areas” are minimized. [0298]
With an approximately-reverse analysis (namely, by omitting the extraction of all “occupied blank areas,”) a result in which only “objects” that have been laid out are re-arranged according to a designated “priority rule for layout positions” can be obtained. When the result of a two-dimensional layout according to a particular priority rule A is approximately-reversely analyzed according to the same priority rule A and then the resultant objects are laid out again according to the priority rule A, the original two-dimensional layout may not be obtained. [0299]
Likewise, when the result of a two-dimensional layout according to a different priority rule B is approximately-reversely analyzed according to the layout rule A and then the result is laid out again according to the priority rule A, a different twodimensional layout result may be obtained. When the approximately-reverse analysis is used, the original two-dimensional layout is approximately restored. However, the original two-dimensional layout is not always correctly restored. [0300]
When the above-described two-dimensional layout system is used, various two-dimensional layouts can be accomplished. Thus, the function for evaluating the obtained two-dimensional layouts and selecting the excellent one becomes important. [0301]
The evaluation of a two-dimensional layout largely depends on the problem and objective. To evaluate a two-dimensional layout, various additional information is sometimes required along with information of layout positions. In addition, there are cases in which one evaluation value is required while other cases in which a plurality of evaluation values are required. The evaluating unit and the selecting unit according to the embodiment have the structure as shown in FIG. 14. [0302]
In FIG. 14, the result of a two-dimensional layout obtained by the two-dimensional layout system shown in FIG. 6, additional information such as the name, type, orientation, and front/rear of each of “objects,” and the related information such as the relation of connections of “objects”, are input to a two-dimensional [0303] layout evaluating unit 16. The evaluating unit 16 evaluates the two-dimensional layout with the obtained information according to a designated evaluating method and outputs an evaluation value (evaluation vector).
At this point, the layout result is evaluated based on the layout information such as the entire size of the layout result, the layout position of a particular object, the relative layout positions of two or more particular objects, the distribution of the layout of objects, and the layout of the blank space between objects. The selecting [0304] unit 17 selects an excellent two-dimensional layout based on the evaluated values of a plurality of two-dimensional layouts according to the given selection standard.
When the two-dimensional layout system shown in FIG. 6 is repeatedly used or when a plurality of twodimensional layout systems are used in parallel, a plurality of two-dimensional layouts are obtained. In addition, with the evaluating [0305] unit 16 and the selecting unit 17 shown in FIG. 14, the following functions can be accomplished.
(a) When “objects” to be laid out, a “container” thereof, and the order of the layout of “objects” are designated, a two-dimensional layout is simulated according to a plurality of “priority rules for layout positions.” These results are evaluated and an excellent two-dimensional layout is selected therefrom. [0306]
(b) When “objects” to be laid out, a “container” thereof, and a “priority rule for layout positions,” are designated, a two-dimensional layout is simulated using a plurality of layout orders. The obtained results are evaluated and an excellent two-dimensional layout is selected therefrom. [0307]
(c) When “objects” to be laid out, a “priority rule for layout positions,” and a layout order are designated, a two-dimensional layout is simulated using a plurality of “containers. The obtained results are evaluated and an excellent two-dimensional layout is selected therefrom. [0308]
(d) When “objects” to be laid out (including extra “objects”), a “container” thereof, and “a priority rule for layout positions” are designated, a two-dimensional layout is simulated using a plurality of layout orders. The obtained results are evaluated and an excellent two-dimensional layout is selected therefrom. In this case, the simulation is performed in such a manner that some of the “objects” may not be laid out and left as extra “objects.”[0309]
(e) In a combination of the functions (a), (b), (c), and (d), various two-dimensional layouts are simulated. The obtained results are evaluated and an excellent two-dimensional layout is selected therefrom. [0310]
In such a manner, various conditions are varied. A two-dimensional layout is simulated in a plurality of conditions. The obtained results are evaluated and an excellent two-dimensional layout can be selected therefrom. As one method for automatically simulating a two-dimensional layout and selecting an excellent two-dimensional layout and for obtaining the optimum or semi-optimum result, the simulated annealing method is known. The simulated annealing method can be used for optimizing a two-dimensional layout in the following manner. [0311]
As a basic structure, it is assumed that a “container” has been designated, and the order of the layout of “objects” is selected as a space to be searched. An appropriate rule as the “priority rule for layout positions” may be set to the two-dimensional layout system shown in FIG. 6. Alternatively, a plurality of rules may be set to the two-dimensional layout system with the evaluating and selecting functions as shown in FIG. 14. In the latter, the optimum “priority rule for layout positions” is automatically searched for and selected. [0312]
The search space of the layout order of “objects” is treated as a parameter by generating permutations of designated N “objects.” In the searching process according to the simulated annealing method, a basic converting operation for an order represented as the parameter is selected, a random conversion is repeated so as to vary the parameter, thereby the search space is searched. As the converting operation, one of the following two types can be appropriately selected. [0313]
(a) The order positions of “objects” are exchanged between an order position i that is randomly selected and the next order position (i+1). In other words, the order positions of any two successive objects one of which is designated at random are exchanged. [0314]
(b) The order positions of “objects” are exchanged between two order positions i and j that are randomly selected. In other words, the order positions of any two objects that are randomly selected are exchanged. [0315]
As an objective function of the simulated annealing method, an appropriate evaluation function represented by the compactness of a two-dimensional layout, the mutual relation of the layout of “objects,” the relation of the connections thereof, or the like is used. [0316]
In the above-described designation, “objects” are laid out only in the designated orientation. However, to vary “orientations” of “objects” and obtain the optimum two-dimensional layout, the orientations of the individual “objects” are included in the search space along with the layout order of the “objects.” For example, when there are terminals for wiring around cells to be laid out, the orientations of the cells become important to design lines connected thereto. [0317]
As orientations of “objects”, for example, rotating angles (0 deg, 90 deg, 180 deg, and 270 deg) corresponding to four positions of an [0318] object 18 shown in FIG. 15 and the front/rear face thereof are considered. The orientations of the “objects” are represented with bit data such as a vertical/horizontal bit, a 180 deg rotation bit, and a front/rear face bit. With such bit data, the converting operation is selected at random.
In the simulated annealing method, any condition such as a priority rule for layout positions and a change of orientation of each object is included in the search space so as to search an optimum state. [0319]
In a two-dimensional layout problem, even if the same priority rule for layout positions is used, different layout orders may result in the same two-dimensional layout. Thus, the search space for optimizing a two-dimensional layout becomes complicated. To alleviate this problem, the two-dimensional layout [0320] reverse analyzing apparatus 15 as shown in FIG. 13 can be used.
Assume that a two-dimensional layout is simulated in a particular layout order according to the simulated annealing method and thereby a two-dimensional layout with a relatively high evaluation value is obtained. [0321]
At this point, the two-dimensional layout [0322] reverse analyzing apparatus 15 performs a reverse analyzing process or an approximately reverse analyzing process for a two-dimensional layout. Thus, a layout order in which the two-dimensional layout is most smoothly accomplished according to the predetermined standard priority rule can be obtained. By substituting the layout order as a standard layout order with a coordinate representation (a parameter representation) in the search space, the two-dimensional layout can be searched according to the standard priority rule. Such a substitution corresponds to a process for normalizing the parameter representation.
For automatically optimizing a two-dimensional layout through simulations and selections, another general optimization method that is a genetic algorithm (GA) that represents a search space in a genetic representation can be applied. In the genetic algorithm, it is important to consider how genes are structured, how they are converted into a particular space, and how they are evaluated. In the case of a two-dimensional layout problem, with the genetic [0323]
algorithm, the optimization problem can be formalized in the following manner. [0324]
In the basic structure, it is assumed that a “container” has been designated. The layout order of “objects” is represented as gene data and an optimum layout order is searched for. In the searching process, a gene group including a plurality of genes is selected and screened through a genetic operation so as to obtain an excellent two-dimensional layout. [0325]
With respect to “a priority rule for layout positions,” an appropriate rule may be set to the two-dimensional layout system shown in FIG. 6. Alternatively, a plurality of rules may be set to the two-dimensional layout system with the evaluating and selecting functions as shown in FIG. 14. In the latter, the optimum “priority rule for layout positions” is automatically searched for. [0326]
As a genetic operation of the genetic algorithm, one of the following operations can be effectively selected. [0327]
(a) The order positions of “objects” are exchanged between an order position i that is randomly selected in a gene and the next order position (i+1) (mutation). [0328]
(b) The order positions of “objects” are exchanged between order positions i and j that are selected at random in a gene (mutation). [0329]
(c) One order position i is selected at random in a gene. A portion from the order position i to the last order position M is moved as a block to the top of the gene. In other words, “selective circulating operation” is performed (a large scale mutation). [0330]
(d) One order position i in appropriately selected two genes A and B is selected at random. Two genes are intersected at the order position i so as to obtain the following child genes A′ and B′. [0331]
A′: [0332] Order positions 1 to (i−1) of A′ are the same as those of A. Order positions i to M of “objects” that are not present in the order positions 1 to (i−1) are arranged in the order of occurrences in B.
B′: [0333] Order positions 1 to (i−1) of B′ are the same as those of B. Order positions i to M of “objects” that are not present in the order positions 1 to (i−1) are arranged in the order of occurrences in A.
(e) One order position i in appropriately selected two genes A and B is selected at random. Two genes are intersected at the order position i so as to obtain the following child genes A′ and B′. [0334]
A′: Order positions i to M of A′ are the same as those of A. Order positions [0335] 1 to (i−1) of “objects” that are not present in the order position i and later are arranged in the order of occurrences in B.
B′: Order positions i to M of B′ are the same as those of B. Order positions [0336] 1 to (i−1) of “objects” that are not present in the order position i and later are arranged in the order of occurrences in A.
As an objective function of a genetic algorithm, as with the simulated annealing method, an appropriate evaluation function represented with, for example, the compactness of a two-dimensional layout, the mutual relation of the layout of “objects, “or the connection relation, is used. [0337]
The generation of a gene group in a genetic algorithm, the selection of a gene group, and the preservation of an excellent gene can be performed in conventional manners. As with the simulated annealing method, along with the order of “objects,” any condition such as the priority rule for layout positions and a change of the orientation of each “object” can be included in the search space so as to designate an operation of a mutation at random. [0338]
In addition, to simplify a search space for optimization, as with the simulated annealing method, the two-dimensional layout reverse analyzing apparatus can be used. For example, assume that with the genetic algorithm, a two-dimensional layout process is executed in a predetermined layout order and thereby a two-dimensional layout result is obtained. When a plurality of priority rules for layout positions are used, a two-dimensional layout with the best evaluated result is employed. [0339]
Next, the two-dimensional layout [0340] reverse analyzing apparatus 15 performs a reverse analyzing process or an approximately reverse analyzing process for the obtained two-dimensional layout. Thus, a layout order in which the two-dimensional layout is most smoothly accomplished according to the predetermined standard priority rule is obtained. The obtained layout order is substituted as a standard layout order with a genetic representation of the current generation so as to search the two-dimensional layout according to the standard priority rule. Such a substitution corresponds to the normalizing process of the genetic representation.
Next, the structure of a two-dimensional layout system accomplished by a computer will be described. FIG. 16 is a block diagram showing the structure of an information processing apparatus that realizes the two-dimensional layout system. The information processing apparatus shown in FIG. 16 comprises a CPU (Central Processing Unit) [0341] 21, a memory 22, an inputting unit 23, an outputting unit 24, an external storing unit 25, a medium driving unit 26, and a network connecting unit 27 that are connected together by a bus 28.
The CPU [0342] 21 executes a program stored in the memory 22 so as to perform processes of the two-dimensional layout unit 11, the layout space managing unit 12, the reverse analyzing apparatus 15, the evaluating unit 16, and the selecting unit 17. The memory 22 is, for example, composed of a ROM (Read Only Memory) and a RAM (Random Access Memory).
The inputting unit [0343] 23 is equivalent to, for example, a keyboard, a pointing device, and so forth. With the inputting device 23, the user inputs commands to the system. The outputting unit 24 is equivalent to, for example, a display unit, a printer, and so forth. With the outputting unit 24, the system prompts the user to input commands and outputs processed results to the user.
The [0344] external storing unit 25 is, for example, a magnetic disk unit, an optical disc unit, a magnetooptical disc unit, or the like. The external storing unit 25 stores programs and data. In addition, the external storing unit 25 is used as a database for storing priority rules for layout positions, information of “containers,” information of “objects,” layout orders, evaluating methods, and so forth. The medium driving unit 26 drives the portable storing medium 29 and accesses the contents stored thereon. The portable storing medium 29 is, for example, a memory card, a floppy disk, a CD-ROM (Compact Disk Read Only Memory), an optical disc, a magneto-optical disc, or the like, from which the computer can read data. The portable storing medium 29 stores data used for the processes of the two-dimensional layout system, and programs for executing the processes.
The [0345] network connecting unit 27 is connected to any communication network such as a LAN (Local Area Network). The network connecting unit 27 converts data for communication. The two-dimensional layout system can receive data and programs from an external database or the like through the network connecting unit 27.
Next, with reference to FIGS. [0346] 17 to 23, the space management method of the layout space managing unit 12 shown in FIG. 6 will be described in detail.
In the space management method using a set of inscribed rectangles, calculations for “sum” and “difference” of two rectangles act as basic roles thereof. The calculation for “sum” of two rectangles is accomplished in the following manner. [0347]
Input: Rectangles a□((x[0348] ₀ ^a, x₁ ^a), (y₀ ^a, y₁ ^a)) and b□((x₀ ^b, x₁ ^b), (y₀ ^b, y₁ ^b))
Output: A set of inscribed rectangles of a space a□∪b□ of the “sum” of rectangles a and b [0349]
Process: In this case, the inscribed rectangles are represented as follows. [0350]
<ijkl>=Q□((x[0351] ₀ ⁱ, x₁ ^j), (y₀ ^k, y₁ ^l)
where i, j, k, and l represent a or b. The values of i, j, k, and l depend on the relative positions of the two rectangles. For example, the relative positions of the two rectangles with respect to the horizontal coordinate (x coordinate) are categorized into the [0352] 13 cases as shown in FIG. 17. Likewise, the relative positions of the rectangles with respect to the vertical coordinate (y coordinate) are categorized into 13 cases. Thus, when a calculation table for 13×13 cases is formed, the calculated result for the “sum” can be represented.
FIGS. 18 and 19 show part of such a calculation table for “sum”. For example, as shown in FIG. 18, when the relative positions of the rectangles a and b on the x coordinate have the relation of case (1) and the relative positions of the rectangles a and b on the y coordinate have the relation of case (3), a set of inscribed rectangles of the “sum” are composed of the rectangles a and b. In other words, an inscribed rectangle of which <ijkl>=<aaaa> and an inscribed rectangle of which <ijkl>=<bbbb> become elements of a set of inscribed rectangles of the “sum.”[0353]
On the other hand, when the relative positions of rectangles a and b on the x coordinate have the relation of case ([0354] 3) and the relative positions of the rectangles a and b on the y coordinate have the relation of case (3), a set of inscribed rectangles of the “sum” are composed of four inscribed rectangles <ijkl>=<aaaa>, <bbbb>, <baab>, <abba>. This tabular method applies to the representation of the calculated results of other cases.
In the case of two rectangles shown in FIG. 20, the “sum” can be calculated as follows. [0355]
Q[0356] ₁□((0, 3), (0, 2))∪Q₂∪((1, 4), (1, 3))
→a□((0, 3), (0, 2))∪b□((1, 3), (0, 3))∪[0357]
c□((0, 4), (1, 2))∪d□((1, 4), (1, 3)) [0358]
The “difference” of the two rectangles can be calculated as follows. [0359]
Input: Rectangles a□((x[0360] ₀ ^a, x₁ ^a), (y₀ ^a, y₁ ^a)) and b□((x₀ ^b, x₁ ^b), (y₀ ^b, y₁ ^b))
Output: A set of inscribed rectangles of a space a□-b□ in which the rectangle b is subtracted from the rectangle a Process: In this case, the inscribed rectangles are represented as follows. [0361]
<ijkl>=Q□((x[0362] _s ⁱ, x_t ^j), (y_u ^k, y_v ^l))
where superscripts i, j, k, and l represent a or b; and subscripts s, t, u, and v represent 0 or 1. When the superscript of an element is a, the corresponding subscript represents the normal value at the position of that element. When the superscript of an element is b, the corresponding subscript represents the reverse value at the position of that element. [0363]
As with the calculation for “sum,” the values of i, j , k, and l depend on the relative positions of the two rectangles. For example, the relative positions of the two rectangles on the horizontal coordinate (x coordinate) have 13 cases as shown in FIG. 17. Likewise, the relative positions of the two rectangles on the vertical coordinate (y coordinate) have 13 cases. Thus, when a calculation table for 13×13 cases are formed, the calculated result for the “difference” can be represented. [0364]
FIGS. 21 and 22 show part of such a calculation table for “difference.” For example, in FIG. 21, when the relative positions of the rectangles a and b on the x coordinate have the relation of case (1) and the relative positions of the rectangles a and b on the y coordinate have the relation of case (3), a set of inscribed rectangles of the result in which the rectangle b is subtracted from the rectangle a, is the rectangle a itself. In other words, only the inscribed rectangle <ijkl>=<aaaa> becomes an element of the set of the inscribed rectangles of the “difference.”[0365]
On the other hand, when the relative positions of the rectangles a and b on the x coordinate have the relation of case (3) and the relative positions of the rectangles a and b on the y coordinate have the relation of case (3), a set of inscribed rectangles of the “difference” thereof are composed of two inscribed rectangles <ijkl>=<aaba>, <baaa>. This tabular method applies to the representation of the calculated results of the other cases. [0366]
In the case of two rectangles shown in FIG. 23, the “difference” can be calculated as follows. [0367]
S[0368] ₁□((0, 3), (0, 2))−S₂□((1, 4), (1, 3))
→a□((0, 3), (0, 1))∪b□((0, 1), (0, 2)) [0369]
Next, with reference to FIGS. [0370] 24 to 46, a space management method will be described, the space being represented with a composite figure.
With calculations for “sum” and “difference” of rectangles, a rectangle with any size can be added at any position of one or more closed figures represented by vertical sides and horizontal sides. In addition, a rectangle with any size can be subtracted from any position of the closed figures. Thus, one or more closed figures can be composed of several rectangles, and represented as a set of inscribed rectangles so as to dynamically manage them. [0371]
Next, with reference to simple and then complicated examples, the calculating method and the managing method of the [0372] space managing unit 12 shown in FIG. 6 will be described. In the process of the calculations, it is necessary to carefully manage whether or not many rectangles appearing as intermediate data affect other rectangles. To do that, a special data structure is used. The data structure and the method thereof will be described later when necessary.
Basically, each intermediate rectangle is categorized as two levels. The first level (hereinafter, denoted by a prefix #) represents a rectangle included in a set of inscribed rectangles in the preceding stage or a rectangle listed as a candidate of a current set of inscribed rectangles. [0373]
The second level (hereinafter, denoted by an indentation and a prefix @) is a rectangle newly formed as the result of a calculation for “sum” or “difference.” When a rectangle in the second level satisfies a predetermined condition with respect to a relation to another rectangle (interaction), the rectangle in the second level can be raised to the first level. When one rectangle is added to a set of inscribed rectangles or one rectangle is subtracted from a set of inscribed rectangles, the influence of the addition (subtraction) of the rectangle against all the inscribed rectangles should be considered. [0374]
For example, in the case of a figure having a concaved portion as shown in FIG. 24, the figure can be composed of three rectangles A, B, and C and thereby a set of inscribed rectangles thereof can be obtained. In this case, the rectangles A, B, and C can be represented as follows. [0375]
A□((0, 1), (0, 3)) [0376]
B□((0, 4), (3, 5)) [0377]
C□((2, 4), (1, 3)) [0378]
Assuming that the first rectangle A forms a set of inscribed rectangles, an area S[0379] ¹thereof is represented as follows.
S[0380] ¹=[#A□((0, 1), (0, 3))]
Next, as shown in FIG. 25, the second rectangle B is added to the area S[0381] ¹.
S[0382] ²=S¹∪B□((0, 4), (3, 5))
At this point, with a calculation for “sum,” a set of inscribed rectangles of the area S[0383] ²is represented as follows.
→[#b[0384] ₁□((0, 1), (0, 5))
#B□((0, 4), (3, 5))][0385]
Next, as shown in FIG. 26, a third rectangle C is added to the area S[0386] ².
S[0387] ³=S²∪C□((2, 4), (1, 3))
At this point, when the rectangle C is interacted with the two inscribed rectangles b[0388] ₁and B, a calculation of B□∪C□ causes the rectangle C to be eliminated to form a new inscribed rectangle c₁. As shown in FIG. 27, a set of inscribed rectangles of S³are represented as follows.
→[#b[0389] ₁□((0, 1), (0, 5))
#B□((0, 4), (3, 5)) [0390]
@c[0391] ₁□((2, 4), (1, 5))]
After the interaction of the rectangle c[0392] ₁in the second level and the other rectangle b₁is checked, the rectangle cl in the second level is raised to the first level. Thus, a set of inscribed rectangles of S³are represented as follows.
→[#b[0393] ₁□((0, 1), (0, 5))
#B□((0, 4), (3, 5)) [0394]
#c[0395] ₁□((2, 4), (1, 5))]
Next, it is assumed that the position of the rectangle C shown in FIG. 26 is moved to the left so as to form a composite figure as shown in FIG. 28. When the rectangle C is added to the area S[0396] ²in which the rectangle B is added to the rectangle A, the following area is formed.
S=[#b[0397] ₁□((0, 1), (0, 5))
#B□((0, 4), (3, 5))][0398]
∪C□((1, 3), (1, 3)) [0399]
When the “sum” of each of the rectangles b[0400] ₁and B and the rectangle C is calculated, as shown in FIG. 29, the area S is represented as follows.
→[#b[0401] ₁□((0, 1), (0, 5))
@c[0402] ₁□((0, 3), (1, 3))
#B□((0, 4), (3, 5))]ps The “sum” of the rectangles C and b[0403] ₁generates the rectangle c₁. Thus, since the rectangle C is included in the rectangle c₁and eliminated, the “sum” of the rectangles C and B is not required. Next, the interaction of the rectangle c₁in the second level and the other rectangle B is checked. As shown in FIG. 30, since the interaction generates the rectangle c₂and thereby eliminates the rectangle c₁, the area S is represented as follows.
→[#b[0404] ₁□((0, 1), (0, 5))
#B□((0, 4), (3, 5)) [0405]
@c[0406] ₂□((0, 3), (1, 5))]
In this case, since the sum of the rectangles C and b[0407] ₁has generated the rectangle c₁, it is not necessary to check the interaction of the rectangles c₁and b₁. Next, the interaction of the rectangle c₂in the second level and the rectangle b₁is checked and then the rectangle c₂is raised to the first level.
→[#b[0408] ₁□((0, 1), (0, 5))
#B□((0, 4), (3, 5)) [0409]
#c[0410] ₂□((0, 3), (1, 5))]
Thus, the rectangles in the second level are eliminated and a set of inscribed rectangles of the area S are obtained. [0411]
Next, it is assumed that the rectangle C shown in FIG. 26 is slightly enlarged and thereby a composite figure as shown in FIG. 31 is formed. When the rectangle C is added to an area S[0412] ²of which a rectangle B is added to a rectangle A, the following area is formed.
S=[#b[0413] ₁□((0, 1), (0, 5))
#B□((0, 4), (3, 5))][0414]
∪c□((1, 3), (0, 3)) [0415]
When the sum of each of the rectangles b[0416] ₁and B and the rectangle C is calculated, as shown in FIG. 32, the area S is represented as follows.
→[#b[0417] ₁□((0, 1), (0, 5))
@c[0418] ₁□((0, 3), (0, 3))
#B□((0, 4), (3, 5))][0419]
In this case, the sum of the rectangle C and the rectangle b[0420] ₁generates the rectangle c₁and thereby the rectangle C is eliminated. Thus, the sum of the rectangles C and B is not required. Next, the interaction of the rectangles c₁in the second level and the other rectangle B is checked. As shown in FIG. 33, the interaction generates the rectangle c₂and thereby the rectangle c₁is eliminated. Thus, the area S is represented as follows.
→[#b[0421] ₁□((0, 1), (0, 5))
#B□((0, 4), (3, 5)) [0422]
@c[0423] ₂□((0, 3), (0, 5))]
Next, the interaction of the rectangle c[0424] ₂in the second level and the rectangle b₁is checked and then the rectangle c₂is raised to the first level. At this point, since the rectangle b₁is absorbed by the rectangle c₂, the rectangle #b₁is eliminated. Thus, a set of inscribed rectangles of the area S are represented as follows.
→[#B□((0, 4), (3, 5)) [0425]
#c[0426] ₂□((0, 3), (0, 5))]
In these examples, when a rectangle to be added generates a larger rectangle including itself and thereby is eliminated, a calculation for the sum with another rectangle or a calculation for the interaction with another rectangle is omitted so as to prevent an unnecessary process from being performed. Even if the rectangle is not eliminated and the interaction with all other rectangles is calculated, the same result is obtained. [0427]
In the case of a figure shown in FIG. 2, by combining three rectangles A, B, and C, a set of inscribed rectangles thereof can be obtained as shown in FIG. 34. In this case, an area composed of the rectangles A, B, and C is represented as follows. [0428]
A□((1, 4), (0, 1))∪[0429]
B□((0, 2), (1, 3))∪[0430]
C□((2, 5), (1, 4)) [0431]
When the two rectangles A and B are combined, as shown in FIG. 35, the resultant area S[0432] ²is represented as follows.
S[0433] ²=A□((1, 4), (0, 1))∪
B□((0, 2), (1, 3)) [0434]
→[#A□((1, 4), (0, 1)) [0435]
#d□((1, 2), (0, 3)) [0436]
#B□((0, 2), (1, 3))][0437]
Next, when the rectangle C is added to the area S[0438] ², the resultant area S³is represented as follows.
S[0439] ³=S²∪C□((2, 5), (1, 4))
The sum of the rectangle C and each of other rectangles is calculated one after the other. Thus, as shown in FIG. 36, the rectangle B generates a rectangle g and thereby the rectangle B is eliminated. [0440]
→[#A□((1, 4), (0, 1)) [0441]
@e□((2, 4), (0, 4)) [0442]
#d□((1, 2), (0, 3)) [0443]
@f□((1, 5), (1, 3)) [0444]
#@g□((0, 5), (1, 3)) [0445]
#C□((2, 5), (1, 4))][0446]
A prefix # of the rectangle g in the second level represents that the rectangle g is derived from a rectangle at this position in the first level. Next, the rectangle e in the second level is raised to the first level. At this point, the rectangle e is interacted with each of the other rectangles d, f, and g, but it is not necessary to check the interaction of the rectangle e and each of the rectangles A and C. Thus, as shown in FIG. 37, a rectangle h is generated as follows. [0447]
→[#A□((1, 4), (0, 1)) [0448]
#@′h□((1, 4), (0, 3)) [0449]
@f□((1, 5), (1, 3)) [0450]
#@g□((0, 5), (1, 3)) [0451]
#C□((2, 5), (1, 4)) [0452]
#e□((2, 4), (0, 4))][0453]
where @′ represents a new rectangle generated by a raising operation of a rectangle in the second level to the first level. Thereafter, rectangles in the second level are raised in the order of occurrences. When the rectangle f is raised to the first level and interacted with each of the rectangles A, h, and g, as shown in FIG. 38, the rectangle f is absorbed by the rectangle g and eliminated as follows. [0454]
→[#@i□(1, 4), (0, 3)) [0455]
#@′h□((1, 4), (0, 3)) [0456]
#@g□((0, 5), (1, 3)) [0457]
#C□((2, 5), (1, 4)) [0458]
#e□((2, 4), (0, 4))][0459]
Although the generated rectangles i and h are the same, the algorithm of the [0460] space managing unit 12 does not know that. Next, when the rectangle g is raised to the first level and interacted with each of the rectangles i and h, the resultant area is represented as follows.
→[#@i□((1, 4), (0, 3)) [0461]
#@′h□((1, 4), (0, 3)) [0462]
#C□((2, 5), (1, 4)) [0463]
#e□((2, 4), (0, 4)) [0464]
#g□((0, 5), (1, 3))][0465]
When the rectangle h is raised to the first level and interacted with the rectangle i, as shown in FIG. 39, the rectangle i is absorbed by the rectangle h and thereby eliminated. When the rectangle h is interacted with the rectangle C, as shown in FIG. 40, the resultant area is represented as follows. [0466]
→[#C□((2, 5), (1, 4)) [0467]
@j□((2, 4), (0, 4)) [0468]
@k□((1, 5), (1, 3)) [0469]
#e□((2, 4), (0, 4)) [0470]
#g□((0, 5), (1, 3)) [0471]
#h□((1, 4), (0, 3))][0472]
Although the generated rectangles j and e are the same, the [0473] space managing unit 12 does not know that. Next, when the rectangle j is raised to the first level and interacted with each of the rectangles e and g, the rectangle j is absorbed by the rectangle e and thereby eliminated. Thus, the resultant area is represented as follows.
→[#C□((2, 5), (1, 4)) [0474]
@k□((1, 5), (1, 3)) [0475]
#e□((2, 4), (0, 4)) [0476]
#g□((0, 5), (1, 3)) [0477]
#h□((1, 4), (0, 3))][0478]
Next, when the rectangle k is raised to the first level and interacted with each of the rectangles e and g, as shown in FIG. 41, the rectangle k is absorbed by the rectangle g and thereby eliminated. The resultant set of inscribed rectangles are represented as follows. [0479]
→[#C□((2, 5), (1, 4)) [0480]
#e□((2, 4), (0, 4)) [0481]
#g□((0, 5), (1, 3)) [0482]
#h□((1, 4), (0, 3))][0483]
Next, it is considered that a rectangle is added to a concaved portion of a particular figure. An H-shaped area shown in FIG. 42 is represented by the following set of inscribed rectangles. [0484]
S[0485] ³=[#a□((0, 1), (0, 3))
#b□((0, 3), (1, 2)) [0486]
#c□((2, 3), (0, 3))][0487]
When a rectangle d□((1, 2), (0, 1)) is added to the concaved portion of the area S[0488] ³, the resultant area is represented as follows.
S=S[0489] ³∪d□((1, 2), (0, 1))
When the sum of the rectangle d and each of the rectangles a, b, and c is calculated one after the other, as shown in FIG. 43, the rectangle d generates a rectangle e and thereby is eliminated. Thus, it is clear that the sum of the rectangle d and each of the rectangles b and c is not required. The area S is represented as follows. [0490]
→[#a□((0, 1), (0, 3)) [0491]
@e□((0, 2), (0, 1)) [0492]
#b□((0, 3), (1, 2)) [0493]
#c□((2, 3), (0, 3)) [0494]
Next, when the rectangle e is raised to the first level and interacted with each of the rectangles b and c, as shown in FIG. 44, the rectangle e generates a rectangle f and thereby is eliminated. Thus, it is clear that the sum of the rectangles e and c is not required. The area S is represented as follows. [0495]
→[#a□((0, 1), (0, 3)) [0496]
#b□((0, 3), (1, 2)) [0497]
@f□((0, 2), (0, 2)) [0498]
#c□((2, 3), (0, 3))][0499]
Next, when the rectangle f is raised to the first level and interacted with each of the rectangles a and c, as shown in FIG. 45, the rectangle f generates a rectangle g and thereby is eliminated. Thus, the resultant area is represented as follows. [0500]
→[#a□((0, 1), (0, 3)) [0501]
#b□((0, 3), (1, 2)) [0502]
#c□((2, 3), (0, 3)) [0503]
@g□((0, 3), (0, 2))][0504]
Next, when the rectangle g is raised to the first level and interacted with each of the rectangles a and b, as shown in FIG. 46, the rectangle b is absorbed by the rectangle g and thereby eliminated. The resultant set of inscribed rectangles are represented as follows. [0505]
→[#a□((0, 1), (0, 3)) [0506]
#c□((2, 3), (0, 3)) [0507]
#g□((0, 3), (0, 2))][0508]
Next, with reference to FIGS. [0509] 47 to 57, a process for laying out “objects” in a blank space performed by the space managing unit 12 shown in FIG. 6 will be described. In the previous examples shown in FIGS. 24 to 46, a set of inscribed rectangles of an area was obtained by adding rectangles. In the example shown in FIGS. 47 to 57, a process for removing an area of a particular rectangle from a closed figure represented by a set of inscribed rectangles is described.
When an “object” is laid out, it is checked that the “object” does not protrude from the closed figure. Thereafter, the rectangle corresponding to the “object” is eliminated. Next, for the example of the two-dimensional layout shown in FIG. 7, the algorithm for managing a set of inscribed rectangles is described, without the layout position checking process, for the sake of clarity in explanation. The size of an “object” e in this example is slightly different from that shown in FIG. 7. [0510]
[0] Initial setting [0511]
S[0512] ⁰=[#S□((0, 10), (0, 8))]
[1] As shown in FIG. 47, when an “object” a is laid out at the position of a rectangle a▪((0, 2), (0, 4)), the remaining area is represented as the difference between the two rectangles S[0513] ⁰and a.
S[0514] ¹=S⁰−a▪((0, 2), (0, 4))
→[#a[0515] ₁□((2, 10), (0, 8))
#a[0516] ₂□((0, 10), (4, 8))]
[2] As shown in FIG. 48, an “object” b is laid out at the position of a rectangle b▪((2, 6), (0, 2)). [0517]
S[0518] ²=S¹−b▪((2, 6), (0, 2))
When the rectangle b is subtracted from each of the inscribed rectangles of the area S[0519] ¹, the resultant area is represented as follows.
→[#@b[0520] ₁□((6, 10), (0, 8))
@b[0521] ₂□((2, 10), (2, 8))
#a[0522] ₂□((0, 10), (4, 8))]
Next, each of the rectangles in the second level is raised. When the rectangle b[0523] ₁is raised to the first level and interacted with the rectangle a₂, the resultant area is represented as follows.
→[@b[0524] ₂□((2, 10), (2, 8))
#a[0525] ₂□((0, 10), (4, 8))
#b[0526] ₁□((6, 10), (0, 8))]
When the rectangle b[0527] ₂is raised to the first level and interacted with the rectangle a₂, the resultant area is represented as follows.
→[#a[0528] ₂□((0, 10), (4, 8))
#b[0529] ₁□((6, 10), (0, 8))
#b[0530] ₂□((2, 10), (2, 8))]
When the order of the rectangles is sorted in the priority order of layout, the resultant rectangles are represented as follows. [0531]
→[#b[0532] ₁□((6, 10), (0, 8))
#b[0533] ₂□((2, 10), (2, 8))
#a[0534] ₂□((0, 10), (4, 8))]
[3] As shown in FIG. 49, an “object” c is laid out at the position of a rectangle c▪((2, 8), (2, 4)). [0535]
S[0536] ³=S²−c□((2, 8), (2, 4))
When the rectangle c is subtracted from each of inscribed rectangles of the area S[0537] ², the resultant area is represented as follows.
→[#@c[0538] ₁□((6, 10), (0, 2))
@c[0539] ₂□((8, 10), (0, 8))
@c[0540] ₃□((6, 10), (4, 8))
#@c[0541] ₄□((8, 10), (2, 8))
@c[0542] ₅□((2, 10), (4, 8))
#@a[0543] ₂□((0, 10), (4, 8))]
Next, each of the rectangles in the second level is raised to the first level. First, the rectangle c[0544] ₁is raised to the first level and interacted with each of the rectangles c₄, c₅, and a₂. Thus, as shown in FIG. 50, the resultant area is represented as follows.
→[#@c[0545] ₂□((8, 10), (0, 8))
@c[0546] ₃□((6, 10), (4, 8))
#@′c[0547] ₆□((8, 10), (0, 8))
@c[0548] ₅□((2, 10), (4, 8))
#a[0549] ₂□((0, 10), (4, 8))
#c[0550] ₁□((6, 10), (0, 2))]
Next, the rectangle c[0551] ₂is raised to the first level and interacted with each of the rectangles c₆, c₅, and a₂. Thus, as shown in FIG. 51, the rectangle c₆is absorbed by the rectangle c₂and thereby eliminated. The resultant area is represented as follows.
→[#@c[0552] ₃□((6, 10), (4, 8))
#@c[0553] ₅□((2, 10), (4, 8))
#a[0554] ₂□((0, 10), (4, 8))
#c[0555] ₁□((6, 10), (0, 2))
#c[0556] ₂□((8, 10), (0, 8))]
Next, when the rectangle c[0557] ₃is raised to the first level and interacted with each of the rectangles c₅and a₂, the rectangle c₃is absorbed by the rectangle c₅and thereby eliminated. Thus, the resultant area is represented as follows.
→[#@c[0558] ₅□((2, 10), (4, 8))
#a[0559] ₂□((0, 10), (4, 8))
#c[0560] ₁□((6, 10), (0, 2))
#c[0561] ₂□((8, 10), (0, 8))]
When the rectangle c[0562] ₅is raised to the first level and interacted with the rectangle a₂, as shown in FIG. 52, the rectangle c₅is absorbed by the rectangle a₂and thereby eliminated. Thus, the resultant area is represented as follows.
→[#a[0563] ₂□((0, 10), (4, 8))
#c[0564] ₁□((6, 10), (0, 2))
#c[0565] ₂□((8, 10), (0, 8))]
When the rectangles are sorted in the priority order of layout, the resultant rectangles are represented as follows. [0566]
→[#c[0567] ₁□((6, 10), (0, 2))
#c[0568] ₂□((8, 10), (0, 8))
#a[0569] ₂□((0, 10), (4, 8))]
[4] As shown in FIG. 53, an “object” d is laid out at the position of a rectangle d▪((8, 10), (0, 6)). The resultant area s[0570] ⁴is represented as follows.
S[0571] ⁴=S³−d▪((8, 10), (0, 6))
When the rectangle d is subtracted from each of the inscribed rectangles of the area S[0572] ³, as shown in FIG. 54, the resultant area is represented as follows.
→[#@d[0573] ₁□((6, 8), (0, 2))
#@d[0574] ₂□((8, 10), (6, 8))
#@d[0575] ₃□((0, 8), (4, 8))
@d[0576] ₄□((0, 10), (6, 8))]
Next, the rectangles in the second level are raised to the first level in the order of occurrences. First, the rectangle d[0577] ₁is raised to the first level and interacted with each of the rectangles d₂, d₃, and d₄. Thus, the resultant area is represented as follows.
→[#@d[0578] ₂□((8, 10), (6, 8))
#@d[0579] ₃□((0, 8), (4, 8))
@d[0580] ₄□((0, 10), (6, 8))
#d[0581] ₁□((6, 8), (0, 2))]
Next, the rectangle d[0582] ₂is raised to the first level and interacted with each of the rectangles d₃and d₄. Thus, the resultant area is represented as follows.
→[#@d[0583] ₃□((0, 8), (4, 8))
@′d[0584] ₅□((0, 10), (6, 8))
@d[0585] ₄□((0, 10), (6, 8))
#d[0586] ₁□((6, 8), (0, 2))]
In this case, the algorithm of the [0587] space managing unit 12 does not know that the rectangle d₅is the same as the rectangle d₄. Next, the rectangle d₃is raised to the first level and interacted with each of the rectangles d₄and d₅. Thus, the resultant area is represented as follows.
→[#@′d[0588] ₅□((0, 10), (6, 8))
@d[0589] ₄□((0, 10), (6, 8))
#d[0590] ₁□((6, 8), (0, 2))
#d[0591] ₃□((0, 8), (4, 8))]
Next, the rectangle d[0592] ₄is raised to the first level and interacted with the rectangle d₅. Thus, the rectangle d₅is absorbed by the rectangle d₄and thereby eliminated. Consequently, as shown in FIG. 55, the resultant area is represented as follows.
→[#d[0593] ₁□((6, 8), (0, 2))
#d[0594] ₃□((0, 8), (4, 8))
#d[0595] ₄□((0, 10), (6, 8)]
[5] As shown in FIG. 56, an “object” e is laid out at the position of a rectangle e▪((0, 4), (4, 8)). The resultant area S[0596] ⁵is represented as follows.
S[0597] ⁵=S⁴−e▪((0, 4), (4, 8))
When the rectangle e is subtracted from each of the inscribed rectangles of the area S[0598] ⁴, the resultant area is represented as follows.
→[#d[0599] ₁□((6, 8), (0, 2))
#@e[0600] ₁□((4, 8), (4, 8))
#@e[0601] ₂□((4, 10), (6, 8))]
Next, the rectangles in the second level are raised to the first level in succession. When the rectangle e[0602] ₁is raised to the first level and interacted with each of the rectangles d₁and e₂, the resultant area is represented as follows.
→[#d[0603] ₁□((6, 8), (0, 2))
#@e[0604] ₂□((4, 10), (6, 8))
#e[0605] ₁□((4, 8), (4, 8))]
Next, the rectangle e[0606] ₂is raised to the first level and interacted with the rectangle d₁. Thus, the resultant area is represented as follows.
→[#d[0607] ₁□((6, 8), (0, 2))
#e[0608] ₁□((4, 8), (4, 8))
#e[0609] ₂□((4, 10), (6, 8))]
[6] As shown in FIG. 57, an “object” f is laid out at the position of a rectangle f▪((6, 8), (0, 2)). The resultant area S[0610] ⁶is represented as follows.
S[0611] ⁶=S⁵−f▪((6, 8), (0, 2))
When the rectangle f is subtracted from each of the inscribed rectangles of the area S[0612] ⁵, the resultant area is represented as follows.
→[#e[0613] ₁□((4, 8), (4, 8))
#e[0614] ₂□((4, 10), (6, 8))]
Since all the rectangles of the area S[0615] ⁶are in the first level, they form the set of inscribed rectangles. Now that there are no “objects” to be laid out, the process is completed.
As shown in FIGS. [0616] 24 to 57, the process for managing a space with a set of inscribed rectangles is complicated. To systematically describe the process, the data structure and process flow of the space managing unit (SM) 12 shown in FIG. 6 will be described.
(a) Data structure for managing space [0617]
In the [0618] SM 12, a set of rectangles that represents a space are represented with the following three types of data structures.
List structure pointing to rectangles in the first level: T [0619]
List structure pointing to rectangles in the second level: W [0620]
List of data of individual rectangles: Q [0621]
Each element (cell) of the list structure T in the first level has the following data. [0622]
Generation order number: gen [0623]
Number of rectangles in the second level belonging to the element: nsub [0624]
Pointer to a rectangle: jq [0625]
(When there is no rectangle in the first level included in the cell, jq=Nil, where Nil represents a blank list.) [0626]
Each element (cell) of the list structure W in the second level has the following data. [0627]
Generation order number: gen [0628]
Generation order number of an element (cell) in the first level to which the cell in the second level belongs (this generation order number is referred to as “affiliation number”): genl [0629]
Pointer to a rectangle: jq(jq≠Nil) [0630]
Each element (cell) of the list Q of individual rectangles has the following data. [0631]
Name (or identification number): idq [0632]
Position and size of rectangle (“position information”): ((x[0633] ₀, x₁), (y₀, y₁))
When the [0634] SM 12 represents a set of inscribed rectangles with such a data structure, each element of the list structure T in the first level points to one inscribed rectangle. The list structure W in the second level for a work storage is a blank list that has no elements. The SM 12 can receive input instructions (for example, addition of a space, layout of an “object”, and report on a blank space).
At this point, it is assumed that the generation order numbers gen of the list structure T in the first level have been sorted as 1, 2, . . . , n. In addition, it is assumed that the number of current rectangles nsub in the second level is cleared to 0. [0635]
As an example, in the case of a set of inscribed rectangles shown in FIG. 41, the list structure T in the first level is as shown in FIG. 58. The list structure W in the second level is Nil as shown in FIG. 59. The list Q of individual rectangles is as shown in FIG. 60. [0636]
In the intermediate stage of the calculation as shown in FIG. 37, the list structure T in the first level is as shown in FIG. 61. The list structure W in the second level is as shown in FIG. 62. The list Q of individual rectangles is as shown in FIG. 63. [0637]
(b) Outline of the space managing process [0638]
In the initial state, it is assumed that the [0639] SM 12 represents one set of inscribed rectangles. In the initial state, there are the following cases.
In the case of “Nil”: The list structure T in the first level is a blank list that has no elements. [0640]
In the case of one rectangle: The list structure T in the first level has only one element that represents one rectangle. The list structure W in the second level has no elements. [0641]
In the general case: The list structure T in the first level has a plurality of elements that represent respective inscribed rectangles. The list structure W in the second level has no elements. [0642]
For the initial state where there are n inscribed rectangles, when one rectangle B is input and added, the variable igen, which represents the current generation order number, is set to (n+1). The “sum” of each of the rectangles in the first level is successively calculated. The result is stored in the list structures T, W, and Q. The obtained result is “re-arranged” and converted into a set of inscribed rectangles. When one rectangle B is specified and subtracted from the set of inscribed rectangles, the variable igen, which represents the generation order number, is set to (n+1). The rectangle B is subtracted from each of the rectangles in the first level. The result is stored in the list structures T, W, and Q. The result is “re-arranged” and converted into a set of inscribed rectangles. [0643]
When one rectangle B is laid out as an “object” to a set of inscribed rectangles, it is checked whether or not one of rectangles in the first level includes the rectangle B. When the determined result is Yes, the process for subtracting the rectangle B is performed. When the determined result is No, a “layout rejection” is output. [0644]
The “re-arrangement” represents that each of rectangles in the second level obtained in the process of the calculations (namely, rectangles to be checked for interactions with other rectangles) is selected and calculated for interactions with other rectangles in the first level and other rectangles in the second level. However, such calculations are not necessary for some of the rectangles. [0645]
In the calculations for the interactions, rectangles in the first level may remain or may not. In the second level, one or more rectangles may be generated or may not. In the first level, rectangles may be added or may not. In the space managing process, by repeating the process for “raising” individual rectangles in the second level to the first level, a representation of a set of inscribed rectangles can be obtained again. [0646]
The process for “raising” one rectangle in the second level to the first level for the “re-arrangement” is similar to the process for obtaining the sum with a rectangle designated from the outside. The “raising” process is performed in the following manner. [0647]
One rectangle B in the second level is selected as an object to be raised. The current generation order number igen is incremented by 1. Next, the sum of the rectangle B and each of required rectangles in the first level and the second level is calculated. The result is stored in the list structures T, W, and Q. When the obtained result includes a rectangle in the second level, the “raising” process is performed again. [0648]
Based on the above-described processes, the internal space managing process will be described from the three view points of the process for interactions with rectangles in the first level, the process for interactions with rectangles in the second level, and the process for raising” rectangles in the second level to the first level. [0649]
(c) Process for interactions with rectangles in the first level [0650]
To interact one rectangle B with a rectangle (cell) A in the first level, the following calculation is performed correspondingly to the type of the interaction. [0651]
Addition of rectangle B: Calculation for “sum”: A+B [0652]
Subtraction of rectangle B: Calculation for “difference”: A−B [0653]
“Raising” rectangle B to the first level: Calculation for “sum”: A+B [0654]
According to the calculated result, the following cases are examined and a relevant process is performed. [0655]
When a rectangle D (one or more rectangles) other than the rectangles A and B is generated, the rectangle D is treated as a rectangle in the second level. At this point, the number of rectangles to be added as rectangles in the second level is added to nsub in the cell A of the rectangle A and the generated rectangle D is added to the list structure Q of rectangles along with its position information. The current generation order number igen is set to the generation order number gen of the list structure W in the second level for each rectangle D. The generation order number A. gen in the cell A is set to the affiliation number genl. The pointer jq to the rectangle is set so that it points to the rectangle D in the list structure Q. [0656]
When the rectangle A is left, it is maintained in the first level. When the rectangle A is not left, a cell of the rectangle A is eliminated from the list structure Q of rectangles, and the pointer jq in the cell A of the list structure T in the first level is set to Nil. At this point, when nsub in the cell A is 0, the cell A is eliminated from the list structure T. [0657]
When the rectangle B is eliminated in the calculation for “sum,” the value of the control flag LDELB is set to “1.”[0658]
(d) Process for interactions with rectangles in the second level [0659]
When a rectangle B in the second level is “raised” to the first level, the interaction of the rectangle B with the rectangle C in the second level is examined. In this process, the “sum” of the rectangles C and B is calculated and then the following process is performed according to the result. [0660]
When a rectangle D (one or more rectangles) other than rectangles C and B is generated, the rectangle D is treated as a rectangle in the second level. At this point, when a cell in the first level, to which the rectangle C belongs, is a cell A (designated by gent of the rectangle C), the number of rectangles D that are newly generated is added to the number of current rectangles nsub of the cell A and the generated rectangles D are added to the list structure Q of rectangles. [0661]
Then, a cell in the list structure W in the second level is prepared for each of the generated rectangles. The current generation order number igen is set to the generation order number gen in the cell so that the affiliation number genl accords with the affiliation number of the rectangle C. The pointer jq to a rectangle is set so that it points to the rectangle D in the structure list Q of rectangles. [0662]
When the rectangle C is left, it is maintained in the second level. When the rectangle C is not left, the rectangle C is removed from the list structure Q of rectangles and the list structure W in the second level. The number of current rectangles nsub in the cell A in the first level indicated by the affiliation number genl of the rectangle C is decremented by 1. At this point, if nsub=0 and A.jq=Nil, the cell A is eliminated from the list structure T in the first level. [0663]
When the rectangle B is eliminated in a calculation for “sum,” the value of the flag LDELB is set to “1.”[0664]
(e) Process for “raising” a rectangle in the second level to the first level [0665]
In the “re-arranging” process, one rectangle B in the list structure W of rectangles in the second level is raised to the first level and interacted with each of rectangles in the second level and rectangles in the first level. These process are performed in the following manner. The oldest rectangle B is selected from the list structure W in the second level. In reality, a rectangle with the minimum generation order number gen and the minimum affiliation number genl is selected as the rectangle B to be raised to the first level from the list structure W. If the list structure W is Nil, the “re-arranging” process is completed. [0666]
Next, the current generation order number igen is incremented by 1 and the flag LDELB is set to “0.” The selected rectangle (cell) B in the second level is treated as a work rectangle (cell) B for a raising operation. [0667]
At this point, the cell B of the rectangle B in the list structure W in the second level is copied to the work cell B and then eliminated from the list structure W. Next, a cell AB in the list structure T in the first level corresponding to the affiliation number genl of the rectangle B is obtained. The number of current rectangles nsub in the cell AB is decremented by 1. At this point, if nsub=0 and pointer jq=Nil, the cell AB is eliminated from the list structure T in the first level. [0668]
The selected rectangle B is interacted with the following rectangles. First, the rectangle AB in the first level to which the rectangle B belongs is excluded from the rectangles A of the list structure T in the first level. Then, all rectangles with the older generation order number A.gen than the generation order number B.gen of the rectangle B are interacted as the first level objects with the selected rectangle B. [0669]
Second, rectangles with the same generation order number gen as the rectangle B and with the same affiliation number genl as the rectangle B are excluded from the rectangles C in the list structure W in the second level. Then, rectangles with the newer generation order number gen than the rectangle B are excluded. The remaining rectangles are interacted as the second level objects with the selected rectangle B. [0670]
The order of the interactions of the rectangle B with these rectangles does not affect the final result. Thus, the following order can be used. The selected rectangle B is interacted with rectangles in the first level in the order of their generation. Thereafter, the selected rectangle B is interacted with rectangles in the second level in the order of their generation. The processes to be performed are the same as those in (c) and (d) described above. [0671]
Whenever the selected rectangle B is interacted with each rectangle, the value of the flag LDELB is checked. When LDELB=1, which means that the rectangle B is eliminated in the interaction with the corresponding rectangle, the rectangle B is eliminated from the list structure Q of rectangles. In this case, the “raising” process of the rectangle B is terminated. After the selected rectangle B is interacted with each of all the rectangles, if LDELB=0, the rectangle B is added to the list structure T in the first level. At this point, a new cell is added to the list structure T in the first level. As its generation order number gen, the current generation order number igen is set. The number of current rectangles nsub is set to “0.” The pointer jq to a rectangle is set so that it points to the rectangle B. Thus, the “raising” process for the rectangle B is completed. [0672]
Next, with reference to FIGS. [0673] 64 to 73, the flow of the process of the SM 12 will be described. In the above-described data structures, when a newly generated rectangle is added to the list structures T and W, as a rule, if it is added to the last of the list, the process may be simplified. In this example, with such a rule being applied, part of the process for judging the generation order is simplified.
FIG. 64 is a flowchart showing an outline of a process performed by the [0674] SM 12. When the process is started, the SM 12 initializes a management space, forms a set of inscribed rectangles S⁰in the initial state, and stores it (at step ST1). The SM 12 receives an external command (at step ST2) and executes a process corresponding to the received command (at step ST3).
When a command for adding a rectangle B is received, a process SM[0675] 1A calculates the sum of (A+B) for each rectangle A of all inscribed rectangles of the set S⁰and stores the result (at step ST4). When a command for subtracting a rectangle B is received, a process SM1B calculates the difference of (A−B) for each of all inscribed rectangles of the set S⁰and stores the result (at step ST5).
When a command for laying out a rectangle B as an “object” is received, a process SM[0676] 1C determines whether or not any inscribed rectangle A of the set S⁰includes a rectangle B (at step ST6). When the determined result is No, the process SM1C outputs a “layout rejection” (at step ST7). When the determined result is Yes, the process SM1C calculates the difference of (A−B) for each of all the inscribed rectangles of the set S⁰and stores the result (at step ST8).
After steps ST[0677] 4, ST5, ST7, and ST8, a process SM2 of the SM 12 calls a “re-arranging” process and converts the obtained result into a set S of inscribed rectangles (at step ST9). The SM 12 repeats the process at and after step ST2 with the set S instead of the set S⁰.
When a command for requesting a blank space report is received, the [0678] SM 12 outputs the information of the set S⁰of inscribed rectangles (at step ST10) and repeats the process at and after step ST2.
FIG. 65 is a flowchart showing the rectangle adding process SM[0679] 1A performed at step ST4 shown in FIG. 64. When the process is started, the SM 12 stores a rectangle B as a work rectangle B at the preliminary step. Assuming that the number of rectangles in the set S⁰is n, the SM 12 sets igen=n+1 and LDELB=0 (at step ST21). Thereafter, the SM 12 performs the process from step ST22 to step ST26 for all cells of the list structure T in the first level.
Assuming that one of the cells of the list structure T is a cell A, the [0680] SM 12 obtains the position information of the rectangle A to which the pointer jq in the cell A points (at step ST22). The SM 12 obtains the sum of the rectangles A and B as a set of inscribed rectangles (at step ST23). Next, a sub-process SM3A of the SM 12 stores the calculated result of the sum as the list structures T, W, and Q (at step ST24).
Next, the [0681] SM 12 determines whether or not the value of the flag LDELB is 1 (at step ST25). When the determined result is No, the SM 12 determines whether or not there is a cell of a rectangle to which the rectangle B is added (at step ST26). When the determined result at step ST26 is Yes, the SM 12 treats the cell as the cell A and repeats the process at and after step ST22. When the SM 12 has performed the process for all the cells, the SM 12 adds a cell of the rectangle B to the list structure T (at step ST27) and returns to the process shown in FIG. 64.
When the determined result at step ST[0682] 25 is Yes, the flow advances to step ST28. At step ST28, the SM 12 eliminates the rectangle B and returns to the process shown in FIG. 64. The content of the sub-process SM3A will be described later.
FIG. 66 is a flowchart showing the layout process SM[0683] 1C for laying out a rectangle as an “object” at steps ST6, ST7, and ST8 shown in FIG. 64. When the process is started, the SM 12 stores a rectangle B as a work rectangle B as a preliminary step. Assuming that the number of rectangles of the set S^ois n, the sub-process SM1C sets igen=n+1 and LDELB=0 (at step ST31). The sub-process SMIC repeats the process from steps ST32 to ST34 for all cells of the list structure T in the first level.
Assuming that one of the cells of the list structure T is a cell A, the [0684] SM 12 obtains the position information of the rectangle A to which the pointer jq in the cell A points (at step ST32) and determines whether or not the rectangle A includes the rectangle B (at step ST33). The state of that the rectangle A includes the rectangle B means that the rectangle B is included in the rectangle A.
When the determined result at step ST[0685] 33 is No, the SM 12 determines whether or not there is another cell in the list structure T (at step ST34). When the determined result at step ST34 is Yes, the SM 12 treats the cell as the cell A and repeats the process at and after step ST32. When all the rectangles cannot include the rectangle B, the SM 12 outputs a “layout rejection” (at step ST35) and returns to the routine shown in FIG. 64.
When the determined result at step ST[0686] 33 is Yes, the SM 12 repeats the process from step ST36 to step ST39 for all the cells of the list structure T.
The [0687] SM 12 treats one of the cells of the list structure T as a cell A and obtains the position information of the rectangle A to which the pointer jq in the cell A points (at step ST36). The SM 12 obtains the subtraction result in which the rectangle B is subtracted from the rectangle A as a set of inscribed rectangles (at step ST37). Next, a sub-process SM3A of the SM 12 stores the calculated result of the difference as list structures T, W, and Q (at step ST38).
Next, the [0688] SM 12 determines whether or not there is a cell of a rectangle from which the rectangle B is to be subtracted (at step ST39). When the determined result at step ST39 is Yes, the SM 12 treats the cell as the cell A and repeats the process at and after step ST36. When the SM 12 has performed the calculations for all the cells, the flow returns to the routine shown in FIG. 64.
The content of the subtracting process SM[0689] 1B for the rectangles performed at step ST5 shown in FIG. 64 is basically the same as the process from steps ST36 to ST39 shown in FIG. 66.
FIGS. 67, 68, and [0690] 69 are flowcharts showing the re-arranging process SM2 performed at step ST9 shown in FIG. 64. When the process is started, the SM 12 determines whether or not the list structure W in the second level is Nil (at step ST41 shown in FIG. 67).
When the determined result is No, the [0691] SM 12 increments igen by 1 and set LDELB=0 as a preliminary step (at step ST43). The SM 12 treats the first cell of the list structure W in the second level as a cell W1 and selects it as an object for a raising operation. The SM 12 selects the object in the following manner.
The [0692] SM 12 copies the content of the cell W1 to a work cell B and eliminates the cell W1 from the list structure W (at step ST44). Next, the SM 12 obtains the cell AB which has the generation order number gen same as the affiliation number genl of the cell B from the list structure T and decrements nsub of the cell AB by 1 (at step ST45).
The [0693] SM 12 determines whether or not nsub=0 and AB.jq=Nil for the cell AB (at step ST46). When the determined result at step ST46 is Yes, the SM 12 eliminates the cell AB from the list structure T (at step ST47). Thereafter, the SM 12 repeats the process from step ST48 to ST53 shown in FIG. 68 for all cells of the list structure T and calculates interactions.
The [0694] SM 12 treats one of the cells of the list structure T as a cell A (at step ST48 shown in FIG. 68) and determines whether gen of the cell A is larger than gen of the cell B (at step ST49). When the determined result at step ST 49 is No, the SM 12 determines whether or not gen of the cell A is the same as gen of the cell B (at step ST50).
When the determined result at step ST[0695] 50 is No, the SM 12 obtains the sum of the rectangle A corresponding to the cell A and the rectangle B corresponding to the cell B and causes a sub-process SM3A to store the calculated result of the sum to the list structures T, W, and Q (at step ST51).
Next, the [0696] SM 12 determines whether or not the value of the flag LDELB is 1 (at step ST52). When the determined result at step ST52 is No, the SM 12 determines whether there is a cell of a rectangle to be interacted with the rectangle B in the list structure T in the first level (at step ST53). When the determined result at step ST53 is Yes, the SM 12 treats the cell as the cell A and repeats the process at and after step ST48. When the determined result at step ST50 is yes, the SM 12 performs the process at and after step ST53.
When the determined result at step ST[0697] 53 is No and when the determined result at step ST49 is Yes, the SM 12 repeats the process from steps ST54 to ST59 shown in FIG. 69 for all the cells of the list structure W so as to calculate interactions.
The [0698] SM 12 treats one of the cells of the list structure W as a cell C (at step ST54 shown in FIG. 69) and determines whether or not gen of the cell C is larger than gen of the cell B (at step ST55). When the determined result at step ST55 is No, the SM 12 determines whether or not gen of the cell C is the same as gen of the cell B and genl of the cell C is the same as genl of the cell B (at step ST56).
When the determined result at step ST[0699] 56 is No, the SM 12 calculates the sum of the rectangle C and the rectangle B and causes a sub-process SM3B to store the result to the list structures T, W, and Q (at step ST57). The content of the sub-process SM3B will be described later.
Next, the [0700] SM 12 determines whether or not the value of the flag LDELB is 1 (at step ST58). When the determined result at step ST58 is NO, the SM 12 determines whether or not there is a cell of a rectangle to be interacted with the rectangle B (at step ST59). When the determined result at step ST59 is Yes, the SM 12 treats the cell as the cell C and repeats the process at and after step ST54. When the determined result at step ST56 is Yes, the SM 12 performs the process at and after step ST59.
When the determined result at step ST[0701] 59 is No and when the determined result at step ST55 is Yes, the SM 12 adds a new cell of the rectangle B at the last of the list structure T and sets gen=igen, nsub=0, and jq=B.jq (at step ST60). Next the SM 12 repeats the process at and after step ST41.
When the determined result at step ST[0702] 52 is Yes, and when the determined result at step ST58 is Yes, the SM 12 stops calculating the interactions and eliminates the cell to which the pointer B.jq of the cell B points from the list structure Q of rectangles (at step ST61). Next, the SM 12 repeats the process at and after step ST41.
When the list structure W is Nil at step ST[0703] 41, the SM 12 performs an end process (at step ST42) and returns to the process shown in FIG. 64. In the end process, the SM 12 resorts the generation order number gen of each cell of the list structure T in the ascending order 1, 2, . . . and sets the number of cells of the list structure T to the variable n.
FIGS. 70 and 71 are flowcharts showing the calculated result storing process SM[0704] 3A called at step ST24 shown in FIG. 65, step ST38 shown in FIG. 66, and step ST51 shown in FIG. 68. When the process is started, the SM 12 receives information of a cell A in the first level, information of a rectangle A corresponding to the cell A, information of a work cell B, information of a rectangle B corresponding to the cell B, and information of th e calculated result of the rectangles A and B (at step ST71 shown in FIG. 70).
Next, the [0705] SM 12 determines whether or not the calculated result includes any rectangle other than the rectangles A and B (at step ST72). When the determined result at step ST72 is Yes, the SM 12 performs the process from steps ST73 to ST76 and stores the rectangle as a rectangle in the second level.
The [0706] SM 12 adds the number of generated rectangles other than the rectangle A and B to A.nsub (at step ST73), treats one of the rectangles as a rectangle D, and adds a cell D of the rectangle D to the last of the list structure Q (at step ST74). At this point, the SM 12 stores the position information ((x₀, x₁), (y₀, y₁)) of the rectangle D in the cell D added to the list structure Q.
Next, the [0707] SM 12 adds a cell D to the last of the list structure W and sets gen=igen, genl=A.gen, and jq=address of the cell D of the list structure Q (at step ST75). Thereafter, the SM 12 determines whether or not there is another rectangle other than the rectangles A and B (at step ST76). When the determined result at step ST76 is Yes, the SM 12
treats the rectangle as the rectangle D and repeats the process at and after step ST[0708] 74.
When the determined result at step ST[0709] 76 is No and when the determined result at step ST72 is No, the ST 12 determines whether or not the calculated result includes a rectangle A (at step ST77 shown in FIG. 71). When the determined result at step ST77 is No, the SM 12 performs the process from step ST78 to step ST80 and eliminates the information of the rectangle A.
First, the [0710] SM 12 eliminates the rectangle A from the list structure Q and sets jq in the cell A of the list structure T to Nil (at step ST78). The SM 12 determines whether or not the value of nsub of the cell A is 0 (at step ST79). When the determined result at step ST79 is Yes, the SM 12 eliminates the cell A from the list structure T (at step ST80).
Next, the [0711] SM 12 determines whether or not the calculated result includes the rectangle B (at step ST81). When the determined result at step ST77 is Yes and when the determined result at step ST79 is No, the SM 12 performs the process at and after step ST81.
When the determined result at step ST[0712] 81 is Yes, the SM 12 returns to the main routine that has called the sub-process SM3A. When the determined result at step ST81 is No, the SM 12 sets LDELB=1 (at step ST82) and returns to the main routine.
FIGS. 72 and 73 are flowcharts showing a calculated result storing process SM[0713] 3B called at step ST57 shown in FIG. 69. When the process is started, the SM 12 receives information of a cell C in the second level, information of a rectangle C corresponding to the cell C, information of a cell A in the first level to which the rectangle C belongs, information of a work cell B, information of a rectangle B corresponding to the cell B, and information of the calculated result of the rectangle C and the rectangle B (at step ST91 shown in FIG. 72).
Next, the [0714] SM 12 determines whether or not the calculated result includes any rectangle other than the rectangles C and B (at step ST92). When the determined result at step ST92 is Yes, the SM 12 performs the process from step ST93 to step ST96 and stores all the rectangles (other than B and C) as rectangles in the second level.
The [0715] SM 12 adds the number of rectangles other than the rectangles C and B to A.nsub (at step ST93). Then the SM 12 adds a cell of one of the rectangles as a cell D of a rectangle D to the last of the list structure Q (at step ST94). At this point, the SM 12 stores the position information ((x₀, x₁), (y₀, y₁)) of the rectangle D to the cell D added to the list structure Q.
Next, the [0716] SM 12 adds a cell D of the rectangle D to the last of the list structure W and sets gen=igen, genl=C.genl, and jq=address of the cell D of the list structure Q (at step ST95). Next, the SM 12 determines whether or not the calculated result includes any rectangle other than the rectangles C and B (at step ST96). When the determined result at step ST96 is Yes, the SM 12 treats the rectangle as the rectangle D and repeats the process at and after step
ST[0717] 94.
When the determined result at step ST[0718] 96 is No and when the determined result at step ST92 is No, the SM 12 determines whether or not the calculated result includes a rectangle C (at step ST97 shown in FIG. 73). When the determined result at step ST97 is No, the SM 12 performs the process from step ST98 to step ST101 and eliminates the information of the rectangle C.
First, the [0719] SM 12 eliminates the cell C from the list structure Q and eliminates the cell C from the list structure W (at step ST98). Next, the SM 12 decrements the value of nsub of the cell A of the list structure T by 1 (at step ST99). Thereafter, the SM 12 determines whether or not nsub=0 and A.jq=Nil for the cell A (at step ST100).
When the determined result at step ST [0720] 100 is Yes, the SM 12 eliminates the cell A from the list structure T (at step ST101). Next, the SM 12 determines whether or not the calculated result includes the rectangle B (at step ST102). When the determined result at step ST97 is Yes and when the determined result at step ST 100 is No, the SM 12 performs the process at and after step ST102.
When the determined result at step ST[0721] 102 is Yes, the SM 12 returns to the routine that has called the sub-process SM3B. When the determined result at step ST102 is No, the SM 12 sets LDELB=1 (at step ST103) and returns to the routine.
In the above-described process, the space managing process is performed with a set of inscribed rectangles. Next, the basics, inventive points and the variation of the space managing process of the [0722] SM 12 will be additionally explained.
The theoretical basis of which a set of inscribed rectangles are determined in the above-described process without an endless loop in the “re-arranging” process is in that the set of inscribed rectangles is unique with respect to a given closed figure and includes rectangles corresponding to local maxima. [0723]
In the “re-arranging” process, the sum of a “raised” rectangle and each of other rectangles is repeatedly calculated. Thus, various intermediate rectangles gradually become larger. Thus, “a set of inscribed rectangles” is obtained as a set of rectangles with a maximum size. [0724]
The fact that only uni-directional calculations for “sum” are performed is the theoretical basis of which the “re-arranging” process is always completed. This theoretical basis can be explained with Church-Rosser's theory. [0725]
According to Church-Rosser's theory, as long as only calculations for “sum” are performed until the result does not change “a set of inscribed rectangles” obtained as a final result is not affected by a rectangle used in the “re-arranging” process. [0726]
However, it is possible to form a loop with unsuitable calculations rather than suitable calculations. In a normal case rather than such an extreme case, unnecessary calculations adversely affect the process speed. To prevent that, in the “re-arranging” process, it is important to use a suitable rectangle as a work rectangle and perform calculations for “sum” with other rectangles in a suitable order so as to form a required algorithm. [0727]
In the method of the process according to the embodiment, various intermediate rectangles are categorized as rectangles in the first level and rectangles in the second level. The generation order of these rectangles is strictly managed. [0728]
Each of rectangles in the first level was an element of “a set of inscribed rectangles” in the preceding stage. When a command for adding or subtracting a rectangle is input to the [0729] SM 12, it treats all intermediate rectangles that are newly generated as rectangles in the second level. The SM 12 calculates the sum of each of the intermediate rectangles with each of the other rectangles, checks the results, and performs the “raising” process to the first level.
In this process, some rectangles in the first level may generate another larger rectangle which include the original rectangle. Thus, they may be eliminated from the first level. By repeating the process, rectangles in the second level are lost. When a set of rectangles only in the first level is obtained, it becomes “a set of inscribed rectangles.”[0730]
In the embodiment, the [0731] SM 12 manages the generation order of rectangles so as to perform calculations for “sum” in the “re-arranging” process and thereby determines whether or not it is needed to verify interactions. In the process for “raising” rectangles from the second level to the first level, the interaction of each of the rectangles in the second level with each of the other rectangles therein is checked.
Thus, in the case that one rectangle in the second level is “raised” to the first level, it is not necessary to perform calculations for “sum” with rectangles in the first level that have been generated. Unless the generation order is managed in this manner, the process for calculating “sum” may enter into an endless loop with unnecessary processes. [0732]
The “affiliation” of rectangles in the second level to rectangles in the first level is managed because it is necessary to determine whether or not each of them should be added to each of other rectangles. A set of (up to four) rectangles as the calculated result of “sum” of two rectangles have the relation of a set of inscribed rectangles. Thus, it is not necessary to perform calculations for “sum” of these rectangles. Otherwise, the process result may be adversely affected. [0733]
When a rectangle B to be raised to the first level is absorbed by a larger rectangle D in a calculation for “sum” with another rectangle, calculations for “sum” with other rectangles are not performed so as to increase the process speed. In other words, the rectangle D that absorbs the rectangle B is treated as a rectangle to be “raised” to the first level as soon as possible. [0734]
In the “re-arranging” process, there may be a case in which a plurality of rectangles are the same or have an inclusion relation. Such rectangles may be combined and processed. However, although such a relation can be easily recognized by a user, a computer for such a process becomes complicated and thereby the process performance may deteriorate. [0735]
For example, in the case of rectangles i and h in FIG. 38, the description “although the two rectangles are the same, the algorithm does not know that.” means that such a recognition process is not provided. The “raising” process for rectangles spontaneously checks whether or not two rectangles are the same. [0736]
When a plurality of rectangles are included in the same “affiliation,” the rectangles may be the same or may have the inclusion relation. Alternatively, the rectangles may partly overlap or have adjacent positions. Thus, when rectangles in the second level are generated, it is determined whether or not the same “affiliation” has other rectangles in the second level. When the “affiliation” has such rectangles, if “sum” with each of them is calculated in a earlier stage, the process speed is expected to be improved. [0737]
As described above, it is known that the space managing process according to the embodiment of the present invention is always terminated or completed. Next, with reference to FIGS. [0738] 74 to 94, the space managing process will be described using an example of a complicated figure. FIG. 74 shows a figure composed of four rectangles connected in a chain shape. The figure has a blank area (hole) at the center. In this case, by precisely tracing the above-described algorithm, it is clear that the “re-arranging” process is competed without entering into a closed loop.
An area S of the figure shown in FIG. 74 is represented as follows. [0739]
S=A□((0, 2), (2, 8))∪[0740]
B□((1, 5), (6, 10))∪[0741]
C□((4, 7), (3, 9))∪[0742]
D□((1, 6), (0, 4)) [0743]
When intermediate data that represents the sum of the rectangles A and B is obtained, the resultant area is represented as shown in FIG. 75. [0744]
S[0745] ²=A□((0, 2), (2, 8))∪
B□((1, 5), (6, 10)) [0746]
→[#A□((0, 2), (2, 8)) [0747]
#e□((1, 2), (2, 10)) [0748]
#f□((0, 5), (6, 8)) [0749]
#B□((1, 5), (6, 10)][0750]
When a rectangle C is added to the area S[0751] ², the resultant area is represented as shown in FIG. 76.
S[0752] ³=S²∪C□((4, 7), (3, 9))
→[#A□(0, 2), (2, 8)) [0753]
#e□((1, 2), (2, 10)) [0754]
#@g□((0, 7), (6, 8)) [0755]
#B□((1, 5), (6, 10)) [0756]
@h□((1, 7), (6, 9)) [0757]
@i□((4, 5), (3, 10)) [0758]
#C□((4, 7), (3, 9))][0759]
When the rectangle g is raised to the first level and interacted with each of the rectangles A, e, B, h, and i, the resultant area is represented as follows. [0760]
→[#A□((0, 2), (2, 8)) [0761]
#e□((1, 2), (2, 10)) [0762]
#B□((1, 5), (6, 10)) [0763]
@h□((1, 7), (6, 9)) [0764]
@i□((4, 5), (3, 10)) [0765]
#C□((4, 7), (3, 9)) [0766]
#g□((0, 7), (6, 8))][0767]
Next, when the rectangle h is raised to the first level and interacted with each of the rectangles A and e, the resultant area is represented as shown in FIG. 77. [0768]
→[#A□((0, 2), (2, 8)) [0769]
@j□((1, 2), (2, 9)) [0770]
@k□((0, 7), (6, 8)) [0771]
#e□((1, 2), (2, 10)) [0772]
#B□((1, 5), (6, 10)) [0773]
@i□((4, 5), (3, 10)) [0774]
#C□((4, 7), (3, 9)) [0775]
#g□((0, 7), (6, 8)) [0776]
#h□((1, 7), (6, 9))][0777]
When the rectangle i is raised to the first level and interacted with each of the rectangles A, j, k, and e, the resultant area is represented as follows. [0778]
→[#A□((0, 2), (2, 8)) [0779]
@j□((1, 2), (2, 9)) [0780]
@k□((0, 7), (6, 8)) [0781]
#e□((1, 2), (2, 10)) [0782]
#B□((1, 5), (6, 10)) [0783]
#C□((4, 7), (3, 9)) [0784]
#g□((0, 7), (6, 8)) [0785]
#h□((1, 7), (6, 9)) [0786]
#i□((4, 5), (3, 10))][0787]
Next, when the rectangle j is raised to the first level and interacted with each of the rectangles e, B, c, and g, the rectangle j is absorbed by the rectangle e and thereby eliminated as shown in FIG. 78. Thus, the resultant area is represented as follows. [0788]
→[#A□((0, 2), (2, 8)) [0789]
@k□((0, 7), (6, 8)) [0790]
#e□((1, 2), (2, 10)) [0791]
#B□((1, 5), (6, 10)) [0792]
#C□((4, 7), (3, 9)) [0793]
#g□((0, 7), (6, 8)) [0794]
#h□((1, 7), (6, 9)) [0795]
#i□((4, 5), (3, 10))][0796]
Next, when the rectangle k is raised to the first level and interacted with each of the rectangles e, B, C, and g, the rectangle k is absorbed by the rectangle g and thereby eliminated as shown in FIG. 79. Thus, the resultant area is represented as follows. [0797]
→[#A□((0, 2), (2, 8)) [0798]
#e□((1, 2), (2, 10)) [0799]
#B□((1, 5), (6, 10)) [0800]
#C□((4, 7), (3, 9)) [0801]
#g□((0, 7), (6, 8)) [0802]
#h□((1, 7), (6, 9)) [0803]
#i□((4, 5), (3, 10))][0804]
Next, when a rectangle D is added to the area S[0805] ³as shown in FIG. 80, the resultant area is represented as shown in FIG. 81.
S[0806] ⁴=S³∪D□((1, 6), (0, 4))
→[#A□((0, 2), (2, 8)) [0807]
@l□((1, 2), (0, 8)) [0808]
@m□((0, 6), (2, 4)) [0809]
#@n□((1, 2), (0, 10)) [0810]
#B□((1, 5), (6, 10)) [0811]
#C□((4, 7), (3, 9)) [0812]
@o□((4, 6), (0, 9)) [0813]
@p□((1, 7), (3, 4)) [0814]
#g□((0, 7), (6, 8)) [0815]
#h□((1, 7), (6, 9)) [0816]
#@q□((4, 5), (0, 10)) [0817]
#D□((1, 6), (0, 4))][0818]
Next, when the rectangle l is raised to the first level and interacted with each of the rectangles n, B, C, o, p, g, h, and q, the rectangle l is absorbed by the rectangle n and thereby eliminated as shown in FIG. 82. Thus, the resultant area is represented as follows. [0819]
→[#A□((0, 2), (2, 8)) [0820]
@m□((0, 6), (2, 4)) [0821]
#n□((1, 2), (0, 10)) [0822]
#B□((1, 5), (6, 10)) [0823]
#C□((4, 7), (3, 9)) [0824]
@o□((4, 6), (0, 9)) [0825]
@p□((1, 7), (3, 4)) [0826]
#g□((0, 7), (6, 8)) [0827]
#h□((1, 7), (6, 9)) [0828]
#@q□((4, 5), (0, 10)) [0829]
#D□((1, 6), (0, 4))][0830]
Next, when the rectangle m is raised to the first level and interacted with each of the rectangles n, B, C, o, p, g, h, and q, the resultant area is represented as shown in FIG. 83. [0831]
→[#A□((0, 2), (2, 8)) [0832]
#@n□((1, 2), (0, 10)) [0833]
#B□((1, 5), (6, 10)) [0834]
#C□((4, 7), (3, 9)) [0835]
@′r□((4, 6), (2, 9)) [0836]
@′s□((0, 7), (3, 4)) [0837]
@o□((4, 6), (0, 9)) [0838]
@p□((1, 7), (3, 4)) [0839]
#g□((0, 7), (6, 8)) [0840]
#h□((1, 7), (6, 9)) [0841]
#@q□((4, 5), (0, 10)) [0842]
#D□((1, 6), (0, 4)) [0843]
#m□((0, 6), (2, 4))][0844]
Next, when the rectangle n is raised to the first level and interacted with each of the rectangles A, B, C, r, s, o, p, g, h, and q, the resultant area is represented as follows. [0845]
→[#A□((0, 2), (2, 8)) [0846]
#B□((1, 5), (6, 10)) [0847]
#C□((4, 7), (3, 9)) [0848]
@′r□((4, 6), (2, 9)) [0849]
@′s□((0, 7), (3, 4)) [0850]
@o□((4, 6), (0, 9)) [0851]
@p□((1, 7), (3, 4)) [0852]
#g□((0, 7), (6, 8)) [0853]
#h□((1, 7), (6, 9)) [0854]
#@q□((4, 5), (0, 10)) [0855]
#D□((1, 6), (0, 4)) [0856]
#m□((0, 6), (2, 4)) [0857]
#n□((1, 2), (0, 10))][0858]
Next, when the rectangle o is raised to the first level and interacted with each of the rectangles A, B, r, s, g, h, and q, the rectangle r is absorbed by the rectangle o and thereby eliminated as shown in FIG. 84. Thus, the resultant area is represented as follows. [0859]
→[#A□((0, 2), (2, 8)) [0860]
[0861] 190 B□((1, 5), (6, 10))
@t□((4, 5), (0, 10)) [0862]
@u□((1, 6), (6, 9)) [0863]
#C□((4, 7), (3, 9)) [0864]
@′s□((0, 7), (3, 4)) [0865]
@p□((1, 7), (3, 4)) [0866]
#g□((0, 7), (6, 8)) [0867]
#h□((1, 7), (6, 9)) [0868]
#@q□((4, 5), (0, 10)) [0869]
#D□((1, 6), (0, 4)) [0870]
#m□((0, 6), (2, 4)) [0871]
#n□((1, 2), (0, 10)) [0872]
#o□((4, 6), (0, 9))][0873]
Next, when the rectangle p is raised to the first level and interacted with each of the rectangles A, B, t, u, s, g, h, and q, the rectangle p is interacted with the rectangle A and a rectangle v is generated as shown in FIG. 85. Thus, the rectangle p is eliminated. Consequently, the resultant area is represented as follows. [0874]
→[#A□((0, 2), (2, 8)) [0875]
@v□((0, 7), (3, 4)) [0876]
#B□((1, 5), (6, 10)) [0877]
@t□((4, 5), (0, 10)) [0878]
@u□((1, 6), (6, 9)) [0879]
#C□((4, 7), (3, 9)) [0880]
@′s□((0, 7), (3, 4)) [0881]
#g□((0, 7), (6, 8)) [0882]
#h□((1, 7), (6, 9)) [0883]
#@q□((4, 5), (0, 10)) [0884]
#D□((1, 6), (0, 4)) [0885]
#m□((0, 6), (2, 4)) [0886]
#n□((1, 2), (0, 10)) [0887]
#o□((4, 6), (0, 9))][0888]
Next, when the rectangle q is raised to the first level and interacted with each of the rectangles A, v, B, t, u, C, s, g, and h, the rectangle t is absorbed by the rectangle q and eliminated as shown in FIG. 86. Thus, the resultant area is represented as follows. [0889]
→[#A□((0, 2), (2, 8)) [0890]
@v□((0, 7), (3, 4)) [0891]
#B□((1, 5), (6, 10)) [0892]
@u□((1, 6), (6, 9)) [0893]
#C□((4, 7), (3, 9)) [0894]
@′s□((0, 7), (3, 4)) [0895]
#g□((0, 7), (6, 8)) [0896]
#h□((1, 7), (6, 9)) [0897]
#D□((1, 6), (0, 4)) [0898]
#m□((0, 6), (2, 4)) [0899]
#n□((1, 2), (0, 10)) [0900]
#o□((4, 6), (0, 9)) [0901]
#q□((4, 5), (0, 10))][0902]
Next, when the rectangle s is raised to the first level and interacted with each of the rectangles A, v, B, u, g, h, and D, the rectangle v is absorbed by the rectangle s and eliminated as shown in FIG. 87. Thus, the resultant area is represented as follows. [0903]
→[#A□((0, 2), (2, 8)) [0904]
#B□((1, 5), (6, 10)) [0905]
@u□((1, 6), (6, 9)) [0906]
#C□((4, 7), (3, 9)) [0907]
#g□((0, 7), (6, 8)) [0908]
#h□((1, 7), (6, 9)) [0909]
#D□((1, 6), (0, 4)) [0910]
#m□((0, 6), (2, 4)) [0911]
#n□((1, 2), (0, 10)) [0912]
#o□((4, 6), (0, 9)) [0913]
#q□((4, 5), (0, 10)) [0914]
#s□((0, 7), (3, 4))][0915]
Next, when the rectangle u is raised to the first level and interacted with each of the rectangles A, C, g, h, D, m, and n, the rectangle u is absorbed by the rectangle h and eliminated as shown in FIG. 88. Thus, the resultant area is represented as follows. [0916]
→[#A□((0, 2), (2, 8)) [0917]
@w□((1, 2), (2, 9)) [0918]
@x□((0, 6), (6, 8)) [0919]
#B□((1, 5), (6, 10)) [0920]
#C□((4, 7), (3, 9)) [0921]
@y□((1, 7), (6, 9)) [0922]
#g□((0, 7), (6, 8)) [0923]
#h□((1, 7), (6, 9)) [0924]
#D□((1, 6), (0, 4)) [0925]
#m□((0, 6), (2, 4)) [0926]
#n□((1, 2), (0, 10)) [0927]
#o□((4, 6), (0, 9)) [0928]
#q□((4, 5), (0, 10)) [0929]
#s□((0, 7), (3, 4))][0930]
Next, when the rectangle w is raised to the first level and interacted with each of the rectangles B, C, y, g, h, D, m, n, o, q, and s, the rectangle w is interacted with the rectangle B and a rectangle z is generated as shown in FIG. 89. Thus, the rectangle w is eliminated. Consequently, the resultant area is represented as follows. [0931]
→[#A□((0, 2), (2, 8)) [0932]
@x□((0, 6), (6, 8)) [0933]
#B□((1, 5), (6, 10)) [0934]
@z□((1, 2), (2, 10)) [0935]
#C□((4, 7), (3, 9)) [0936]
@y□((1, 7), (6, 9)) [0937]
#g□((0, 7), (6, 8)) [0938]
#h□((1, 7), (6, 9)) [0939]
#D□((1, 6), (0, 4)) [0940]
#m□((0, 6), (2, 4)) [0941]
#n□((1, 2), (0, 10)) [0942]
#o□((4, 6), (0, 9)) [0943]
#q□((4, 5), (0, 10)) [0944]
#s□((0, 7), (3, 4))][0945]
Next, when the rectangle x is raised to the first level and interacted with each of the rectangles B, z, C, y, g, h, D, m, n, o, q, and s, the rectangle x is interacted with the rectangle C and a rectangle α is generated as shown in FIG. 90. Thus, the rectangle x is eliminated. Consequently, the resultant area is represented as follows. [0946]
→[#A□((0, 2), (2, 8)) [0947]
#B□((1, 5), (6, 10)) [0948]
@z□((1, 2), (2, 10)) [0949]
#C□((4, 7), (3, 9)) [0950]
@′α□((0, 7), (6, 8)) [0951]
@y□((1, 7), (6, 9)) [0952]
#g□((0, 7), (6, 8)) [0953]
#h□((1, 7), (6, 9)) [0954]
#D□((1, 6), (0, 4)) [0955]
#m□((0, 6), (2, 4)) [0956]
#n□((1, 2), (0, 10)) [0957]
#o□((4, 6), (0, 9)) [0958]
#q□((4, 5), (0, 10)) [0959]
#s□((0, 7), (3, 4))][0960]
Next, when the rectangle y is raised to the first level and interacted with each of the rectangles A, B, z, α, g, h, D, m, n, o, q, and s, the rectangle y is interacted with the rectangle A and rectangles β and γ are generated as shown in FIG. 91. The rectangle y is absorbed by the rectangle h and eliminated. Thus, the resultant area is represented as follows. [0961]
→[#A□((0, 2), (2, 8)) [0962]
@β□((1, 2), (2, 9)) [0963]
@γ□((0, 7), (6, 8)) [0964]
#B□((1, 5), (6, 10)) [0965]
@z□((1, 2), (2, 10)) [0966]
#C□((4, 7), (3, 9)) [0967]
@′α□((0, 7), (6, 8)) [0968]
#g□((0, 7), (6, 8)) [0969]
#h□((1, 7), (6, 9)) [0970]
#D□((1, 6), (0, 4)) [0971]
#m□((0, 6), (2, 4)) [0972]
#n□((1, 2), (0, 10)) [0973]
#o□((4, 6), (0, 9)) [0974]
#q□((4, 5), (0, 10)) [0975]
#s□((0, 7), (3, 4))][0976]
Next, when the rectangle z is raised to the first level and interacted with each of the rectangles A, β, γ, C, α, g, h, D, m, n, o, q, and s, the rectangle z absorbs the rectangle β and interacts with the rectangle D as shown in FIG. 92. Thus, a rectangle δ is generated and the rectangle z is eliminated. Consequently, the resultant area is represented as follows. [0977]
→[#A□((0, 2), (2, 8)) [0978]
@γ□((0, 7), (6, 8)) [0979]
#B□((1, 5), (6, 10)) [0980]
#C□((4, 7), (3, 9)) [0981]
@′α□((0, 7), (6, 8)) [0982]
#g□((0, 7), (6, 8)) [0983]
#h□((1, 7), (6, 9)) [0984]
#D□((1, 6), (0, 4)) [0985]
@δ((1, 2), (0, 10)) [0986]
#m□((0, 6), (2, 4)) [0987]
#n□((1, 2), (0, 10)) [0988]
#o□((4, 6), (0, 9)) [0989]
#q□((4, 5), (0, 10)) [0990]
#s□((0, 7), (3, 4))][0991]
Next, when the rectangle a is raised to the first level and interacted with each of the rectangles A, γ, B, g, h, D, δ, m, n, o, q, and s, the rectangle γ is absorbed by the rectangle α and then the rectangle α is absorbed by the rectangle g as shown in FIG. 93. Thus, the rectangle α is eliminated. Consequently, the resultant area is represented as follows. [0992]
→[#A□((0, 2), (2, 8)) [0993]
#B□((1, 5), (6, 10)) [0994]
#C□((4, 7), (3, 9)) [0995]
#g□((0, 7), (6, 8)) [0996]
#h□((1, 7), (6, 9)) [0997]
#D□((1, 6), (0, 4)) [0998]
@δ□((1, 2), (0, 10)) [0999]
#m□((0, 6), (2, 4)) [1000]
#n□((1, 2), (0, 10)) [1001]
#o□((4, 6), (0, 9)) [1002]
#q□((4, 5), (0, 10)) [1003]
#s□((0, 7), (3, 4))][1004]
Next, when the rectangle δ is raised to the first level and interacted with each of the rectangles A, B, C, g, h, m, n, o, q, and s, the rectangle δ is absorbed by the rectangle n and eliminated as shown in FIG. 94. Thus, the resultant area is represented as follows. [1005]
→[#A□((0, 2), (2, 8)) [1006]
#B□((1, 5), (6, 10)) [1007]
#C□((4, 7), (3, 9)) [1008]
#g□((0, 7), (6, 8)) [1009]
#h□((1, 7), (6, 9)) [1010]
#D□((1, 6), (0, 4)) [1011]
#m□((0, 6), (2, 4)) [1012]
#n□((1, 2), (0, 10)) [1013]
#o□((4, 6), (0, 9)) [1014]
#q□((4, 5), (0, 10)) [1015]
#s□((0, 7), (3, 4))][1016]
Thus, in the case of a complicated figure as shown in FIG. 74, the process is completed without entering into a closed loop. Consequently, a set of inscribed rectangles can be obtained. [1017]
In addition, by an application of calculations for “sum” and “difference” of such rectangles, one or a plurality of closed figures can be added to any position of one or a plurality of other closed figures. In contrast, one or a plurality of closed figures can be removed from any position of one or a plurality of other closed figures. Thus, the shape of an “object” to be laid out is not limited to a rectangle, but any closed figure is used for the shape. [1018]
With the [1019] space managing unit 12 using a set of inscribed rectangles, a two-dimensional layout system that has the structure and function shown in FIG. 6 can be accomplished. Next, the layout process shown in FIG. 7 accomplished by the two-dimensional layout unit (LM) 11 and the space managing unit (SM) 12 will be described focusing on internal processes thereof. Unless otherwise mentioned, the process performed by the LM 11 will be described.
[0] Initial setting [1020]
(1) It is assumed that “objects” are laid out in the first quadrant of right-hand xy coordinate system. [1021]
(2) A “priority rule for layout positions” is input and stored. In this example, it is assumed that the “main direction” of the priority of layout positions is the down direction (the negative direction of the y axis) and that the “sub direction” thereof is the left direction (the negative direction of the x axis). [1022]
(3) A “container” is designated. In this example, a simple rectangle □(10, 8) is designated. The [1023] LM 11 causes the SM 12 to initialize a set S⁰of inscribed rectangles to be a rectangle □((0, 10), (0, 8)).
(4) A laid-out rectangle list is initialized to be Nil. [1024]
(5) Since the preparation has been completed, “objects” to be laid out are successively accepted. [1025]
[1] Laying out the first “object”[1026]
(1) The [1027] LM 11 receives a object a▪(2, 4)” and a layout command.
(2) The [1028] LM 11 asks the SM 12 for the set S⁰of inscribed rectangles of the current space and receives the following reply therefrom.
S[1029] ⁰={□((0, 10), (0, 8))}
(3) The [1030] LM 11 treats the inscribed rectangle “□((0, 10), (0, 8))” as the layout space and selects the lower left corner (0, 0) as the layout position according to the priority rule for layout positions.
(4) The [1031] LM 11 sends a command “layout: □((0, 2), (0, 4))” to the SM 12.
(5) The [1032] LM 11 receives a reply “layout OK, completed” from the SM 12.
(6) The [1033] LM 11 stores the “a▪((0, 2), (0, 4))” to the laid-out rectangle list.
[2] Laying out the second “object”[1034]
(1) The [1035] LM 11 receives a “object b▪(4, 2)” and a layout command.
(2) The [1036] LM 11 asks the SM 12 for a set S⁰of inscribed rectangles of the current space and obtains the following reply.
S[1037] ⁰={□((2, 10), (0, 8)), □((0, 10), (4, 8))}
(3) The [1038] LM 11 determines the first priority is “□((2, 10), (0, 8))” according to the priority rule for layout positions and selects the lower left corner (2, 0) as the layout position.
(4) The [1039] LM 11 sends a command “layout: b▪((2, 6), (0, 2))” to the SM 12.
(5) The [1040] LM 11 receives a reply “layout OK, completed” from the SM 12.
(6) The [1041] LM 11 adds and stores the “b▪((2, 6), (0, 2))” to the laid-out rectangle list.
[3] Laying out the third “object”[1042]
(1) The [1043] LM 11 receives a “object c▪(6, 2)” and a layout command.
(2) The [1044] LM 11 asks the SM 12 for a set S⁰of inscribed rectangles of the current space and receives the following reply from the SM 12.
S[1045] ⁰={□((6, 10), (0, 8)), □((2, 10), (2, 8)), □((0, 10), (4, 8))}
(3) The [1046] LM 11 determines that the first priority is “□((6, 10), (0, 8))” according to the priority rule for layout positions and selects the lower left corner (6, 0) as the layout position.
(4) The [1047] LM 11 sends a command “layout: c▪((6, 12), (0, 2))” to the SM 12.
(5) The [1048] LM 11 receives a reply “layout invalid, rejected” from the SM 12.
(6) The [1049] LM 11 determines that the second priority is “□((2, 10), (2, 8))” according to the priority rule for layout positions and selects the lower left corner (2, 2) as the layout position.
(7) The [1050] LM 11 sends a command “layout: c▪((2, 8), (2, 4))” to the SM 12.
(8) The [1051] LM 11 receives a reply “layout OK, completed” from the SM 12.
(9) The [1052] LM 11 adds and stores the “c▪((2, 8), (2, 4))” to the laid-out rectangle list.
[4] Laying out the fourth “object”[1053]
(1) The [1054] LM 11 receives a “object d▪(2, 6)” and a layout command.
(2) The [1055] LM 11 asks the SM 12 for a set S⁰of inscribed rectangles of the current space and receives the following reply.
S[1056] ⁰={□((6, 10), (0, 2)), □((8, 10), (0, 8)), □((0, 10), (4, 8))}
(3) The [1057] LM 11 determines that the first priority is “□((6, 10), (0, 2))” according to the priority rule for layout positions and selects the lower left corner (6, 0) as the layout position.
(4) The [1058] LM 11 sends a command “layout: d▪((6, 8), (0, 6))” to the SM 12.
(5) The [1059] LM 11 receives a reply “layout invalid, rejected” from the SM 12.
(6) The [1060] LM 11 determines that the second priority is “□((8, 10), (0, 8))” according to the priority rule for layout positions and selects the lower left corner (8, 0) as the layout position.
(7) The [1061] LM 11 sends a command “layout: d▪((8, 10), (0, 6))” to the SM 11.
(8) The [1062] LM 11 receives a reply “layout OK, completed” from the SM 12.
(9) The [1063] LM 11 adds and stores the “d▪((8, 10), (0, 6))” to the laid-out rectangle list.
[5] Laying out the fifth “object”[1064]
(1) The [1065] LM 11 receives a “object e▪(6, 4)” and a layout command.
(2) The [1066] LM 11 asks the SM 12 for a set S⁰of inscribed rectangles of the current space and receives the following reply.
S[1067] ⁰={□((6, 8), (0, 2)), □((0, 8), (4, 8)), □((0, 10), (6, 8))}
(3) The [1068] LM 11 determines that the first priority is “□((6, 8), (0, 2))” according to the priority rule for layout positions and selects the lower left corner (6, 0) as the layout position.
(4) The [1069] LM 11 sends a command “layout: e▪((6, 12), (0, 4))” to the SM 12.
(5) The [1070] LM 11 receives a reply “layout invalid, rejected” from the SM 12.
(6) The [1071] LM 11 determines that the second priority is “□((0, 8), (4, 8))” according to the priority rule for layout positions and selects the lower left corner (0, 4) as the layout position.
(7) The [1072] LM 11 sends a command “layout: e▪((0, 6), (4, 8))” to the SM 12.
(8) The [1073] LM 11 receives a reply “layout OK, completed” from the SM 12.
(9) The [1074] LM 11 adds and stores the “e▪((0, 6), (4, 8))” to the laid-out rectangle list.
[6] Laying out the sixth “object”[1075]
(1) The [1076] LM 11 receives an “object f▪(2, 2)” and a layout command.
(2) The [1077] LM 11 asks the SM 12 for a set S⁰of inscribed rectangles of the current space and receives the following reply.
S[1078] ⁰={□((6, 8), (0, 2)), □((6, 8), (4, 8)), □((6, 10), (6, 8))}
(3) The [1079] LM 11 determines that the first priority is “□((6, 8), (0, 2))” according to the priority rule for layout positions and selects the lower left corner (6, 0) as the layout position.
(4) The [1080] LM 11 sends a command “layout: f▪((6, 8), (0, 2))” to the SM 12.
(5) The [1081] LM 11 receives a reply “layout OK, completed” from the SM 12.
(6) The [1082] LM 11 adds and stores the “f▪((6, 8), (0, 2))” to the laid-out rectangle list.
[7] End process [1083]
(1) The [1084] LM 1 receives an “object” input end message.
(2) The [1085] LM 11 outputs the following laid-out rectangle list.
a▪((0, 2), (0, 4)), b▪((2, 6), (0, 2)), [1086]
c▪((2, 8), (2, 4)), d▪((8, 10), (0, 6)), [1087]
e▪((0, 6), (4, 8)), f▪((6, 8), (0, 2)) [1088]
(3) The [1089] LM 11 asks the SM 12 for a set S⁰of inscribed rectangles of the current space and receives the following reply.
S[1090] ⁰={□((6, 8), (4, 8)), □((6, 10), (6, 8))}
Thereafter, the [1091] LM 11 outputs the set S⁰of inscribed rectangles.
(4) The [1092] LM 11 completes the layout process.
In this example, the [1093] SM 12 determines whether or not an inscribed rectangle as a candidate for layout is smaller than a rectangle of a “object.” However, the LM 11 also has information necessary for this determination. Thus, the LM 11 can perform this determination, check inscribed rectangles in the priority order according to a layout rule, find an inscribed rectangle in which the “object” can be laid out, and cause the SM 12 to lay it out in the inscribed rectangle. Although the efficiency of the process in the latter case is higher than the efficiency of the process in the former case, in this example, from a view point of a functional distribution, the process in the former case was described.
FIG. 95 is a flowchart showing the process of the [1094] LM 11 that accomplishes the above-described layout process. When the process is started, the LM 1 performs an initial setting (at step ST111).
At step ST[1095] 111, the LM 11 sets a priority rule R for layout positions and receives a command for a “container.” The “container” is designated with one rectangle or a figure composed of a plurality of rectangles as shown, for example, in FIGS. 24, 28, 31, and 34. The LM 11 initializes the SM 12 and inputs the designated rectangle or the plurality of rectangles to the SM 12. Thus, the SM 12 internally forms the “container.” In addition, the LM 11 initializes the laid-out rectangle list L to be empty (φ).
Next, the [1096] LM 11 successively inputs “objects” and lays them out. The LM 11 determines whether or not an “object input completed” message has been received (at step ST112). When the determined result at step ST1 12 is No, the LM 11 receives one “object” and represents it as a “m▪(w, h)”, where the name of the “object” is m and the size thereof is (w, h), at step ST114.
Next, the [1097] LM 1 asks the SM 12 for a set S⁰of inscribed rectangles of the current blank space (at step ST115). Thereafter, the LM 11 receives a reply from the SM 12 (at step ST 116) and determines whether or not there is a blank space (at step ST 117). When the LM 11 has received the following reply as the blank space from the SM 12,
S[1098] ⁰={Q₁□((x₀, x₁), (y₀, y₁)) (where i=1, . . . , n₀: n₀represents the number of inscribed rectangles of the set S⁰)}
the [1099] LM 11 designates the first priority inscribed rectangle of the set S⁰as Q (at step ST118).
Next, the [1100] LM 11 determines the layout position (x₀′, y₀′) according to the priority rule R for layout positions (at step ST119). The LM 11 sends a command “layout: m▪((x₀′, x₀′+w), (y₀′, y₀′+h))” to the SM 12 (at step ST 120). The LM 11 checks a reply received from the SM 12 (at step ST121).
When the [1101] LM 11 has received a reply “layout invalid, rejected” from the LM 12, the LM 11 determines whether or not the set S⁰has the next priority inscribed rectangle (at step ST 122). When the determined result at step ST 122 is Yes, the LM 11 designates the inscribed rectangle as Q (at step ST123) and repeats the process at and after step ST119.
When the [1102] LM 11 has received a reply “layout OK, completed” from the SM 12, the LM 11 adds a “m▪((x₀′, x₀′+w), (y₀′, y₀′+h))” to the laid-out rectangle list L (at step ST 124) and repeats the process at and after step ST112.
When the [1103] LM 11 has received a message “object input completed”, it performs a normal end process (at step ST113). In this example, the LM 11 outputs the laid-out rectangle list L={m▪(x₀, x₁), (y₀, y₁)), . . . ) and asks the SM 12 for the set S⁰of inscribed rectangles of the remaining blank space. The LM 11 outputs the set S⁰of inscribed rectangles received from the SM 12 and completes the process.
When the determined result at step ST[1104] 117 is No and when the determined result at step ST122 is No, the LM 11 performs a layout unsuccessful end process (at step ST125).
In this case, the [1105] LM 11 outputs the laid-out rectangle list L={m▪((x₀, x₁), (y₀, y₁)), . . . } and the rectangle “m▪(w, h)” to be currently laid out along with a message “layout unsuccessful.” The LM 11 asks the SM 12 for the set S⁰of inscribed rectangles of the remaining blank space, outputs the set S⁰of inscribed rectangles received from the SM 12, and completes the process.
Next, examples of several additional functions of the [1106] LM 11 will be supplemented.
(1) As was described in the process at step ST[1107] 111, a “container” may be a figure composed of a plurality of rectangles rather than a simple rectangle. When a plurality of rectangles is input to the LM 11 with their position information, they are sent to the SM 12. Thus, the SM 12 automatically forms the complex figure from the rectangles and treats it as a “container.”
(2) A particular “object” can be easily laid out at a particular position with priority. To do this, when an “object” to be laid out is designated at step ST[1108] 114, the layout position should be explicitly designated along with the name and size thereof.
In this case, an “object” is input in the format of, for example, “m▪((x[1109] ₀, x₁), (y₀, y₁)).” The LM 11 skips the process from step ST115 to step ST119. At step ST120, the LM 11 outputs a command “layout: m▪((x₀, x₁), (y₀, y₁))” to the SM 12.
When the [1110] SM 12 sends a reply “layout invalid, rejected” to the LM 11, the layout process has failed and the process terminates. The layout according to the designation of this format can be securely and easily performed in an early stage of the layout process. Using such a designation a particular “object” can be two-dimensionally laid out at a desired position.
(3) With the process shown in FIG. 95, an “occupied blank” can be laid out as a “object.” In this case, it is necessary to distinguish the “occupied blank” with the name of the “object” or additional information thereof. After the “occupied blank” has been laid out, it can be easily distinguished with reference to the result of the two-dimensional layout. [1111]
(4) An “occupied blank area” can be additionally laid out in the vicinity of a “object in the following two manners. As the first manner, an “object” with an “occupied blank area” is designated at step ST[1112] 114.
In this first manner, the process of the [1113] LM 11 is not changed.
As the second manner, at step ST[1114] 111, a rule for adding an “occupied blank area” is stored as part of layout rule R beforehand. The additional rule is used in the process at steps ST119 and ST120. When a layout position is designated in one inscribed rectangle at step ST119, an appropriate “occupied blank area” is secured. In addition, an appropriate “occupied blank area” is secured for the size designated at step ST120.
This second manner is very flexible. In other words, depending on a layout position and a space, the “occupied blank area” can be adjusted. In this case, however, detailed designations should be described in the layout rule R and the process program thereof. [1115]
Next, with reference to FIGS. [1116] 96 to 116, a designation example of “a priority rule for layout positions” and a layout example thereof will be described. In this example, a problem for laying out 16 rectangles as shown in FIG. 96 on a plane will be considered.
These rectangles are denoted by “a□(2, 4), b□(4, 4), c□(2, 2), d□(5, 1), e□(4, 2), f□(3, 6), g□(2, 1), h□(2, 2), i□(5, 1), j□(2, 3), k□(4, 3), l□(2, 1), m□(1, 5), n□(2, 3), o□(5, 2), p□(3, 2).” The layout order of these rectangles is “a, e, i, m, b, f, j , n, c, g, k, o, d, h, [1117] 1, p.”
The basic method for designating “a priority rule for layout positions” is to designate a priority “main direction” and a “sub direction” that intersects perpendicularly therewith or at an angle thereto. The “main direction” may be selected from up, down, left, right, upper right, upper left, lower left, lower right, slope {fraction (1/2)} of lower left, and so forth. [1118]
An “object” is laid out at the farthest position in the “main direction” in the blank space. When the layout priority position cannot be uniquely designated only with the “main direction,” the “sub direction” is used. [1119]
Next, a problem for laying out 16 rectangles shown in FIG. 96 will be described as layout examples in the cases that the size of the “container” and the “main direction”/“sub direction” are varied. [1120]
FIG. 97 shows a layout in the case that the size of a “container” is 15×12 and that the layout rule is down first/left first. In this case, the rectangles h and l are laid out in closed blank spaces after they are formed. FIG. 98 shows a layout in the case that the size of a “container” is 13×11 and that the layout rule is down first/left first. FIG. 99 shows a layout in the case that the size of a “container” is 11×13 and that the layout rule is down first/left first. [1121]
FIG. 100 shows a layout in the case that the size of a “container” is 11×12 and that the layout rule is lower left first/left first. FIG. 101 shows a layout in the case that the size of a container” is 12×12 and that the layout rule is lower left first/down first. With these layout rules, the rectangles a and a are laid out as shown in FIG. 102. [1122]
To determine the next layout priority position, the farthest position in the lower left direction as the main direction is obtained. In FIG. 102, when lower left vertices P[1123] 1, P2, and P3 of inscribed rectangles of the blank space are compared, it is clear that the vertices P1 and P2 are laid out at the farthest lower left positions. Thus, the vertices P1 and P2 have higher priority than the vertex P3. However, with only the main direction, it is not determined which of the vertices P1 and P2 has priority to the other.
Thus, the sub direction of the layout rule is referenced. In the example shown in FIG. 100, since the sub direction is left, the vertex P[1124] 1 at the left of the vertex P2 is determined as the highest priority layout position. Thus, the next rectangle i is laid out at the position of the vertex P1. In contrast, in the example shown in FIG. 101, since the sub direction is down, the vertex P2 below the vertex P1 is determined as the highest priority layout position. Thus, the next rectangle i is laid out at the position of the vertex P2. The other directions such as upper left, upper right, and lower right are determined in the same manner.
FIG. 103 shows a layout in the case that the size of a “container” is 13×11 and that the layout rule is left first/down first. [1125]
In designating “a priority rule for layout positions,” whenever one “object” is laid out, the “main direction”/“sub direction” can be varied according to an appropriate rule. Thus, “objects” can be laid out at positions on the outer periphery of the “container” as priority positions. [1126]
For example, it is assumed that the lower left direction is designated as the first “main direction” and that whenever an “object” is laid out, the “main direction” is rotated clockwise by 90 deg. In addition, it is assumed that the phase of the “sub direction” always leads the phase of the “main direction” by 90 deg. Thus, the first “sub direction” is upper left. According to such a priority rule, the 16 rectangles shown in FIG. 96 are laid out as follows. [1127]
Assuming that the size of the “container” is 12×12 and that the layout rule is a clockwise rotation of the “main direction”, the rectangles a, e, i, m, b, f, and j are laid out as shown in FIG. 105. Next, the rectangles n, c, g, k, o, and d are laid out as shown in FIG. 106. Finally, the 16 rectangles are laid out as shown in FIG. 107. Thus, it is clear that “objects” are laid out inwardly from the outer periphery of the “container.”[1128]
Next, assuming that the size of a “container” is 11×12 and that the similar layout rule is applied, the last rectangle p is not laid out as shown in FIG. 108. Thus, the layout process is terminated as unsuccessful. [1129]
Alternatively, in designating “a priority rule for layout positions,” the distance from the outer peripheral sides of the “container” can be used instead of the priority direction of a layout. The distance can be designated in various manners. In this example, the distance is designated in the following manner. [1130]
(a) The distance between each side of each inscribed rectangle that composes the blank space and the corresponding outer peripheral side of the container is calculated in a direction perpendicular to the sides. A side of the inscribed rectangles with the smallest distance is selected as a priority side. [1131]
(b) When there are a plurality of sides with the minimum distance to the outer peripheral sides, a vertex of a vertical angle formed by two sides with the minimum distance to the outer peripheral sides is selected with priority. The position of such a vertex is treated as a priority layout position. The priority of the directions of the vertex is designated in the order of lower left, upper left, upper right, and lower right. [1132]
(c) On the other hand, when sides of inscribed rectangles do not form a vertical angle, the priority of the sides is designated in the order of left, up, right, and down. When there are a plurality of positions that satisfy the same condition on one side, the priority is designated to the nearest position in the clockwise direction. [1133]
Assuming that the size of a “container” is 12×12 and that a position with the smallest distance from the corresponding outer peripheral side has priority as the layout rule, the rectangles a, e, i, m, b, f, and j are laid out as shown in FIG. 110. Next, the rectangles n, c, g, k, o, and d are laid out as shown in FIG. 111. Finally, the 16 rectangles are laid out as shown in FIG. 112. [1134]
In the layout process, it is clear that “objects” are laid out inwardly from the outer periphery of the “container.” When the size of the “container” is 11×12 and the similar layout rule is applied, the 16 rectangles are laid out as shown in FIG. 113. [1135]
Next, an example in which “objects” are laid out in a closed blank space will be described. In this case, the closed space represents a blank space where a priority direction is blocked with another “object” that has been laid out or the like. [1136]
As an example for laying out “objects” with the “down first/left first” as “a priority rule for layout positions”, there is a layout as shown in FIG. 7. In this example, the rectangle f is laid out as the last rectangle. The rectangle f is laid out in a closed blank space surrounded by the rectangles b, c, and d. [1137]
In the two-dimensional layout system according to the embodiment of the present invention, regardless of whether the priority direction is open or closed, as long as there is a blank space in the direction, a process for laying out an “object” in the space can be very easily performed. With the algorithm of the process of the [1138] LM 11 shown in FIG. 95, just before the rectangle f is laid out, the SM 12 outputs the following set of inscribed rectangles of the blank space.
S[1139] ⁰={□((6, 8), (0, 2)), □((6, 8), (4, 8)), □((6, 10), (6, 8))}
When the set is examined with the priority rule of “main direction/sub direction,” the “□((6, 8), (0, 2))” is selected as the first priority inscribed rectangle. Since the [1140] SM 12 can freely handle a plurality of separated closed figures, it can easily lay out the rectangle to the closed blank space.
In the above-described layout process, a “container” is composed of one or more rectangles. However, a “container” in any shape surrounded by a curved line or the like can also be used. In this case, as shown in FIG. 114, the two-dimensional layout system approximates a FIG. 31 in any given shape with vertical sides and horizontal sides having a desired accuracy, generates a composite FIG. 32 composed of a plurality of rectangles, and uses the composite FIG. 32 as a “container.”[1141]
Alternatively, a rectangle circumscribed to a layout result of the two-dimensional layout system are input as part of “objects” to be newly laid out so as to lay out it to a larger “container.” Thus, a hierarchical two-dimensional layout can be accomplished. For example, in a layout example shown in FIG. 115, circumscribed [1142] rectangles 33 and 34 obtained as a layout result of small rectangles (hatched rectangles) are laid out as “objects” as well as other rectangles 35 and 36.
Next, the process of the two-dimensional layout [1143] reverse analyzing unit 15 shown in FIG. 13 will be described. In this example, as an object for a practical reverse analysis, a layout example shown in FIG. 98 will be employed. In this problem, the following information is input to the reverse analyzing apparatus 15.
Layout rule of reverse analysis: “down first/left first”[1144]
“container”: □((0, 13), (0, 11)) [1145]
Laid-out rectangle list: [1146]
a▪((0, 2), (0, 4)), e▪((2, 6), (0, 2)), i▪((6, 11), (0, 1)), m▪((11, 12), (0, 5)), b▪((6, 10), (1, 5)), f▪((2, 5), (2, 8)), j▪((0, 2), (4, 7)), n▪((5, 7), (5, 8)), c▪((7, 9), (5, 7)), g▪((9, 11), (5, 6)), k▪((9, 13), (6, 9)), o▪((0, 5), (8, 10)), d▪((5, 10), (9, 10), h▪((7, 9), (7, 9)), l▪((11, 13), (5, 6)), p▪((10, 13), (9, 11)) [1147]
Set S[1148] ⁰of inscribed rectangles of blank space:
{q[1149] ₁□((12, 13), (0, 5)), q₂□((10, 11), (1, 5)), q₃□((5, 6), (2, 5)), q₄□((0, 2), (7, 8)), q₅□((5, 7), (8, 9)), q₆□((0, 10), (10, 11))}
where the inscribed rectangles q[1150] ₁, q₂, q₃, q₄, q₅, and q₆of the blank space do not overlap with each other, but are independently laid out as shown in FIG. 116. As described earlier, to reversely analyze the layout as shown in FIG. 116, all laid-out rectangles and all inscribed rectangle of the blank space S⁰are extracted according to the “priority rule for layout positions” in the priority order.
At this point, normally, the [1151] space managing unit 12 manages the set S⁰. Whenever a rectangle of the blank space is extracted as an “occupied blank area,” the space managing unit 12 eliminates it from the set S⁰and finally verified that there is no blank space. However, in this example, since inscribed rectangles are not connected, there is no problem. Rectangles including inscribed rectangles of the blank space are extracted in the following order.
a, e, i, m, q[1152] ₁, b, q₂, f , q₃, j, n, c, g, l, k, q₄, h, o, q₅, d, p, q₆
When the method for extracting all rectangles and blank spaces is used, although its applications are limited, a reverse analyzing problem can be strictly solved. In other words, a solution of a reverse analysis problem can be uniquely obtained. When rectangles are re-laid out according to the “priority rule for layout positions” used in the reverse analysis in the obtained order, the ordinal two-dimensional layout can be always restored. [1153]
In this example, as blank spaces, many “occupied blank areas” are present. However, most of the “occupied blank areas” are redundant and unnecessary. If only “occupied blank areas”, which are necessary for restoring the original two-dimensional layout in re-laying out rectangles with the layout rule of “down first/left first,” are left, the reversely analyzed result is as follows. [1154]
a, e, i, m, b, f, j, n, c, g, l, k, q[1155] ₄, h, o, d, p
In other words, as an “occupied blank area,” it is necessary to leave only the rectangle q[1156] ₄. Thus, the reversely analyzed result with less redundancy is a desired representation for standardizing the layout order in varying the layout order and optimizing a two-dimensional layout.
To obtain such a result, the following process is performed. After a reversely analyzed result for extracting all “occupied blank areas” is obtained, while all the “occupied blank areas” are being neglected, the two-dimensional layout process is executed again using the reversely analyzed result, and the intermediate result is successively compared with the original two-dimensional layout. [1157]
If the layout position of an “object” differs between the original two-dimensional layout and the intermediate two-dimensional layout, a corresponding “occupied blank area” obtained in the reverse analysis is inserted. Thus, the other redundant “occupied blank areas” are removed. [1158]
In the reverse analysis of a two-dimensional layout, the result depends on how an “occupied blank area” formed between “objects” is handled. From this view point, the reverse analyzing method can be categorized as the following three types. [1159]
(a) Redundant reverse analysis: A reverse analysis of which all “objects” and all “occupied blank areas” are extracted. [1160]
(b) Non-redundant reverse analysis: A reverse analysis of which all “objects” and only necessary “occupied blank areas” are extracted. [1161]
(c) Approximately reverse analysis: A reverse analysis of which all “objects” and no occupied blank areas” are extracted. [1162]
When these reverse analyses are considered, the following points should be evaluated. [1163]
(1) How was layout data Layout[1164] 0 as an object of the reverse analysis created?
What is the designated priority rule Rule[1165] 0 for the layout positions?
What is an order Order[1166] 0 of the layout of “objects”?
Was an “occupied blank area” explicitly added?[1167]
(2) In what method is the reverse analysis performed?[1168]
What is the designated priority rule Rule[1169] 1 for layout positions?
Which of the above-described three methods is used for handling “occupied blank areas”?[1170]
(3) In what method is the two-dimensional layout performed with the reversely analyzed result?[1171]
What is the designated priority rule Rule[1172] 2 for layout positions?
Assuming that these three processes are called “original layout,” “reverse analysis,” and “relayout,” information is input and output as shown in FIG. 117. Normally, “occupied blank areas” are not required for the “original layout.” However, “occupied blank areas” can be added to Order[1173] 0. Focusing on the reverse analysis in the processes shown in FIG. 117, the following three points are common in the three reverse analyzing methods.
Object of reverse analysis: Any original layout result Layout[1174] 0 can be handled. Under one layout rule Rule0, the same layout result Layout0 can be obtained from a plurality of different layout orders Order0. In addition, the same original layout result Layout0 can be obtained from a plurality of different sets of “layout rule Rule0 and layout order Order0.”
Result of reverse analysis: A unique reversely analyzed result Order[1175] 1 can be obtained from one original layout result Layout0.
Use of reversely analyzed result: Even if the same reversely analyzed result Order[1176] 1 is used, when the re-layout rule Rule2 is different, a different re-layout result Layout2 is obtained normally.
In the simplest case, the layout rules of the three processes are the same. In this case (the first case), the three reverse analyzing methods have the following properties. [1177]
In the case (Rule[1178] 0=Rule1=Rule2):
(a) Redundant reverse analysis: Any original layout Layout[1179] 0 can be analyzed. The re-layout result Layout2 accords with the original layout Layout0.
(b) Non-redundant reverse analysis: Any original layout Layout[1180] 0 can be analyzed. The re-layout result Layout2 accords with the original layout Layout0.
(c) Approximate reverse analysis: Although any original layout Layout[1181] 0 can be analyzed, the re-layout result Layout2 does not always accord with the original layout Layout0. In other words, the original layout Layout0 is approximately restored.
In the second case, only the layout rule of the original layout process is different and the layout rule of the reverse analyzing process is the same as the layout rule of the re-layout process. In this case, as with the first case, the three reverse analyzing methods have the following properties. [1182]
In the case (Rule[1183] 0≠Rule1=Rule2):
(a) Redundant reverse analysis: Any original layout Layout[1184] 0 can be analyzed. The re-layout result Layout2 accords with the original layout Layout0.
(b) Non-redundant reverse analysis: Any original layout Layout[1185] 0 can be analyzed. The re-layout result Layout2 accords with the original layout Layout0.
(c) Approximate reverse analysis: Although any original layout[1186] 0 can be analyzed, the re-layout result Layout2 does not always accord with the original layout layout0.
In the third case, the layout rule in the reverse analyzing process is different from the layout rule in the re-layout process. The layout rule of the original layout is irrespective of the layout rule of the reverse analysis. In this case, the three reverse analyzing methods have the following properties. [1187]
In the case (Rule[1188] 1≠Rule 2) (Rule0 is irrespective):
(a) Redundant reverse analysis: Although any original layout Layout[1189] 0 can be analyzed, the re-layout result Layout2 depends on the layout rule Rule2 of the re-layout. Due to excessive blank spaces, the re-layout result Layout2 does not accord with the original layout Layout0 in many cases.
(b) Non-redundant reverse analysis: Although any original layout Layout[1190] 0 can be analyzed, the re-layout result Layout2 depends on the layout rule Rule2 of the re-layout. Due to excessive blank spaces, the re-layout result Layout2 does not accord with the original layout Layout0 in many cases.
(c) Approximate reverse analysis: Although any original layout Layout[1191] 0 can be analyzed, the re-layout result Layout2 depends on the layout rule Rule2 of the re-layout. Thus, the re-layout result Layout2 does not accord with the original layout Layout0 in many cases. The re-layout result Layout2 may be superior to or inferior to the original layout Layout0 in a packing density.
Next, the process of the two-dimensional [1192] layout evaluating unit 16 shown in FIG. 14 will be described. There are many evaluating methods for two-dimensional layouts corresponding to applications. In a real application, an “object” has a lot of additional information. In particular, information such as connection relation of “objects” becomes an important element. The connection relation of “objects” represents, for example, a wiring network of a circuit structure.
In the system according to the embodiment, an “object” is laid out as a simple rectangle. Only the layout position of the “object” is directly handled. In the following examples, evaluation relating to this system will be roughly described. [1193]
(a) Evaluation by the size of a two-dimensional layout: A condition of that the maximum width of the layout result does not exceed a predetermined value, a condition of that the area of a circumscribed rectangle of a layout result does not exceed a predetermined value, etc. are used for evaluation. [1194]
(b) Evaluation by the packing ratio of a two-dimensional layout: The ratio of the total area of “objects” to the area of a “container”, the ratio of the total area of “objects” to the area of the circumscribed rectangle of a “container”, etc. are calculated and used for evaluation. [1195]
(c) Evaluation by the layout position of a particular “object”: A condition of that a particular “object” is present at a particular position, a condition of that a particular “object” is present in the vicinity of a particular position, a condition of that a particular “object” is present at a corner or in the vicinity of sides of a “container,” etc. are used for evaluation. [1196]
(d) Evaluation by the relative position of particular “objects”: A condition of that a plurality of particular “objects” are in contact, a condition of that a plurality of particular “objects” are in contact in the vertical direction, a condition of that a plurality of particular “objects” are arranged (spaced) in vertical positions, a condition of that a plurality of particular “objects” are within a predetermined distance, a condition of that a plurality of particular “objects” are spaced by a predetermined distance, a condition of that a plurality of particular “objects” are arranged in a predetermined order, etc. are used for evaluation. [1197]
(e) Evaluation by the distribution of “objects”: A condition of that “objects” are categorized in attributes, types, and so forth and laid out correspondingly thereto, a condition of that “objects” are laid out without deviations of attributes, types, and so forth, etc. are used for evaluation. [1198]
(f) Evaluation by space between “objects”: A condition of that a space (such as a path) is present between particular “objects,” a condition of that a space is laid out between “objects” without a deviation, etc. are used for evaluation. [1199]
The two-dimensional [1200] layout evaluating unit 16 can use the simulated annealing method (SA) as a general basis for automatically optimizing a two-dimensional layout.
FIG. 118 is a flowchart showing an automatic optimizing process for a two-dimensional layout based on the SA method in which a layout order of “objects” is used for a search space. When the process is started, as an initial setting, the two-dimensional [1201] layout evaluating unit 16 receives a designated “container”, one type or a plurality of types of designated “priority rule for layout positions,” and an “object” list (at step ST131).
Next, as an initial state of the layout order of “objects,” the two-dimensional [1202] layout evaluating unit 16 designates an arbitrary layout order to a state X, causes the two-dimensional layout unit 11 to perform a two-dimensional layout in the initial state, and calculates an evaluation value E(X) of the layout result (at step ST132). The two-dimensional layout evaluating unit 16 sets a temperature parameter T of the SA method to a high temperature (at step ST133). The two-dimensional layout evaluating unit 16 repeats the process from step ST134 to step ST139 a sufficient number of times.
First, the two-dimensional [1203] layout evaluating unit 16 selects a state change process for changing an order position of “objects”, changes the layout order of the state X, and generates a changed state X′ (at step ST134). Next, the two-dimensional layout evaluating unit 16 causes the two-dimensional layout unit 11 to perform a two-dimensional layout in the state X′ and obtains an evaluation value E (X′) of the result (at step ST135).
Next, with the difference of the evaluation values A=E(X′)−E(X), the two-dimensional [1204] layout evaluating unit 16 obtains σ(−Δ/T) using Sigmoid function σ(where σ(x)=1/(1+exp(−x))) (at step ST136). Correspondingly to the value of σ(−Δ/T), the two-dimensional layout evaluating unit 16 performs a relevant selection operation. With probability σ(−Δ/T), the two-dimensional layout evaluating unit 16 selects the changed state X′ and thereby sets X=X′. With probability 1−σ(−Δ/T), the two-dimensional layout evaluating unit 16 selects the original state X (at step ST137).
Next, the two-dimensional [1205] layout evaluating unit 16 determines whether or not the process from step ST134 to step ST137 has been repeated the predetermined number of times (at step ST137 a). When the determined result at step ST137 a is No, the two-dimensional layout evaluating unit 16 repeats the process.
When the determined result at step ST[1206] 137 a is Yes, the flow advances to step ST138. At step ST138, the two-dimensional layout evaluating unit 16 slightly decreases the value of the temperature parameter T. Next, the two-dimensional layout evaluating unit 16 determines whether or not the value T is sufficiently low (at step ST139). When the determined result at 20 step ST139 is No, the two-dimensional layout evaluating unit 16 repeats the process of step ST134 and after. When the determined result at step ST139 is Yes, the two-dimensional layout evaluating unit 16 outputs the layout order of “objects” and the two-dimensional layout result (at step ST140).
Thereafter, the two-dimensional [1207] layout evaluating unit 16 completes the process.
In this automatic optimizing process, particularly, the selection of a changing operation at step ST[1208] 134 is important. It is preferred to select this operation from the following two types as mentioned before.
(a) The order of “objects” is exchanged between an order position i that is randomly selected and the next order position (i+1). [1209]
(b) The order of “objects” is exchanged between two order positions i and j that are randomly selected. [1210]
As with the SA method, the genetic algorithm (GA) is well known as a general basis for optimization. FIG. 119 is a flowchart showing an automatic optimizing process for a two-dimensional layout based on a GA such that a layout order of objects correspond to a gene and the GA searches for an optimum gene. [1211]
When the process is started, the two-dimensional [1212] layout evaluating unit 16 receives a two-dimensional layout problem and control information and performs an appropriate preprocess (at step ST151). The two-dimensional layout evaluating unit 16 randomly generates a plurality of layout orders and treats them as an initial gene group (at step ST152).
Next, the two-dimensional [1213] layout evaluating unit 16 supplies the layout orders described as the genes of the generated gene group to the two-dimensional layout unit 11. The two-dimensional layout unit 11 two-dimensionally lays out “objects.” The two-dimensional layout unit 11 outputs a layout result to the two-dimensional layout evaluating unit 16. The two-dimensional layout evaluating unit 16 calculates the evaluation value of the layout result corresponding to each gene (at step ST153).
The two-dimensional [1214] layout evaluating unit 16 summarizes each gene and the evaluation value thereof, describes the generation thereof (at step ST154), and determines whether or not to perform a calculation for the next generation (at step ST155). When the determined result at step ST155 is Yes, the two-dimensional layout evaluating unit 16 performs a genetic operation for the next generation (at step ST156) and repeats the process of step ST153 for the new gene group.
When a predetermined condition (for example, an attainment of a predetermined generation) is satisfied, the two-dimensional [1215] layout evaluating unit 16 outputs each gene of the generation, the layout result thereof, and the evaluation value thereof (at step ST157). Thereafter, the two-dimensional layout evaluating unit 16 completes the process.
As the genetic operation performed at step ST[1216] 156, it is preferred to use a combination of the following operations as mentioned before.
(a) The order of “objects” is exchanged between an order position i that is randomly selected in a gene and the next order position (i+1) (mutation). [1217]
(b) The order of “objects” is exchanged between two order positions i and j that are randomly selected in a gene (mutation). [1218]
(c) One order position i is randomly selected in a gene. Entire “objects” from the order position i to the last order position are moved to the top of the gene. This operation is referred to as selective circulating operation (mutation). [1219]
(d) One order position i is randomly selected in two genes A and B that are appropriately selected. While portions of the [1220] order position 1 to the order position (i−1) of the genes A and B are being reserved, remaining portions of the genes A and B are interchanged.
(e) One order position i is randomly selected in two genes A and B that are appropriately selected. While portions of the order position i to the last order position of the two genes are being reserved, remaining portions of the two genes A and B are interchanged. [1221]
Correspondingly to a combination of the three layout rules shown in FIG. 117, the reverse analysis has the above-described properties. Thus, when a two-dimensional layout is optimized with SA and GA, the reverse analysis can be used in the following manners. [1222]
[1223] Manner 1. In the case that only one layout rule is consistently handled in SA or GA:
To normalize parameters of SA or genes of GA, the non-redundant reverse analyzing method or approximate reverse analyzing method can be used. Although the accuracy of the process of the non-redundant reverse analyzing method is higher than that of the approximate reverse analyzing method, the speed of the process of the former is lower than that of the latter. In other words, although the speed of the process of the approximately reverse analyzing method is very high, the accuracy thereof is not always high. [1224]
By normalizing parameters or genes, a complicated layout order can be converted into a simple order. Thus, an optimized layout of “objects” can be searched for systematically under a standard layout rule. A complicated layout order represents an order in which many “objects” are laid out at layout positions with low priority. A simple order represents an order in which many “objects” are smoothly laid out at layout positions with the highest priority. [1225]
[1226] Manner 2. In the case that a plurality of layout rules are used separately or together in SA or GA:
Separated worlds for individual layout rules (gene groups in GA) are generated. For each layout rule, the non-redundant reverse analyzing method or approximate reverse analyzing method is used. A pair of a layout rule and a layout order is handled as a parameter of SA or a gene of GA. [1227]
[1228] Manner 3. In the case that a plurality of layout rules are used together in SA or GA:
A plurality of layouts in each layout order are attempted using a plurality of layout rules together. One of the layout rules is selected as a standard layout rule. Under the selected standard layout rule, parameters of SA or genes of GA are normalized according to the non-redundant reverse analyzing method. [1229]
Although the process speed of the reverse analyzing process in this case is relatively slow, it can handle a two-dimensional layout that cannot be represented with one layout rule. [1230]
In the above-described automatic optimization, although a plurality of layout rules are applied, the standard layout rule is gradually emphasized and thereby the normalized layout order is employed. The layout order includes a small number of essential “occupied blank areas.”[1231]
[1232] Manner 4. In the case that a plurality of layout rules are used together in SA or GA:
As with the [1233] manner 3, with a plurality of layout rules, a plurality of layouts for each layout order are attempted. One of the layout rules is selected as a standard layout rule. Under the standard layout rule, the approximately reverse analyzing method is applied and a normalizing process for parameters of SA or genes of GA is performed. Although a plurality of layout rules are applied, the standard layout rule has higher precedence than the other layout rules. Logically, the manner 2 is superior to the manner 4.
Thus, it is considered that the [1234] manner 1 or manner 2 is more practical than the other manners. In particular, when the approximate reverse analyzing method is applied correspondingly to the individual layout rules, a property of approximation is not apparently observed. Parameters of SA or genes of GA that are a search space can be normalized at relatively high speed. Thus, the optimizing process can be performed at high speed.
As described above, according to the present invention, a method for compactly laying out many rectangular “objects” with various shapes and sizes and optimizing the layout under an appropriate evaluation standard and an apparatus thereof are provided. [1235]
As a basic method according to the present invention, a blank space is represented and managed in the format of “a set of inscribed rectangles.” This format has the following theoretical features. [1236]
(a) Generality: The method according to the present invention can be generally applied for “any closed figure represented by vertical sides and horizontal sides.” The figure may have a concaved portion. The figure may have a hole (obstacle). The figure may be separated into a plurality of closed sub-figures. [1237]
(b) Non-inclusion: Each of the members of a set of inscribed rectangles corresponding to one closed figure may overlap with each other, but not be included in another member. [1238]
(c) Uniqueness: A set of inscribed rectangles is unique against a given closed figure and does not depend on “a priority rule for layout positions.”[1239]
(d) Necessity: When one rectangle A is laid out in a given closed figure S, if the orientation of the rectangle A is not changed, the rectangle A is included in at least one of the inscribed rectangles of the given closed figure S. [1240]
(e) Sufficiency: When one rectangle A is included in one inscribed rectangle Q of a given closed figure S, the rectangle A can be laid out in the given closed figure S. [1241]
Because of such features, it can be said that representing and managing a blank space with “a set of inscribed rectangles” have a substantial aptitude for solving a two-dimensional problem. [1242]
Management of a blank space with “a set of inscribed rectangles” is realized by a precise computer algorithm rather than an engineer's intuition. Since the layout and managing processes performed by the computer do not involve uncertain or probability factors, the processes can be precisely executed. Thus, the present invention provides an important basis on which the layout design work is performed by a computer instead of an experienced engineer. [1243]
In addition, according to the present invention, to determine a two-dimensional layout, after a “container” and “objects” are designated, “a priority rule for layout positions” and “a layout order” are used. In the case that “a priority rule for layout positions” has been designated, when “objects” to be laid out are successively received, they can be successively laid out. At this point, an “object” can be laid out in such a manner that it does not overlap with other “objects” that have been laid out, and without the need to move these “objects” and form unnecessary closed blank spaces. [1244]
This process can be automatically performed by a predetermined algorithm. Since the layout result depends on the order of received “objects,” by repeating trial and error in computer simulations, the optimum layout order can be selected from among various layout orders. According to the present invention, such an automatic optimizing method is presented and a practical process thereof is accomplished. [1245]
It should be noted that the “priority rule for layout positions” is not limited to one type. Besides the method for designating the priority direction of a layout, a method for rotating the priority direction clockwise and laying out “objects” in the vicinity of the outer periphery of a “container” first, a method for laying out an “object” at a position near the outer periphery, and so forth, can be considered. [1246]
These designating methods have been considered so that “objects” are laid out as compactly as possible regardless of the order of the “objects.” In reality, “objects” are smoothly laid out without need to perform, for example, a backtracking process and the layout result becomes compact in the examples described above. [1247]
According to the embodiment of the present invention, to automatically optimize a layout, conventional optimizing methods such as the simulated annealing method and the genetic algorithm are used as a basis. In these methods, by treating the layout order of “objects” as a search space, a two-dimensional layout can be very smoothly and flexibly optimized. [1248]
In addition, it is easy to lay out “objects” by varying the “orientation” of each of the “objects.” The layout order as a search space has the number of candidates that are equal to the factorial of the number N of “objects.” In addition, when the orientation of an “object” is represented with two values corresponding to vertical and horizontal directions, the orientation has [1249] ₂N combinations. Thus, it is necessary to substantially search a very large search space. However, the SA method and GA method allow such a searching process to be accomplished.
The flexibility of the optimizing process of a two-dimensional layout according to the present invention is notable for the following points. [1250]
(a) According to the embodiment, although rectangles are used as “objects,” the shape and size thereof are not limited. [1251]
(b) The shape of a “container” is not limited to a simple rectangle. However, as long as the “container” is composed of vertical sides and horizontal sides, it may be a closed figure of any shape. The “container” may have a concaved portion. The “container may have a hole (obstacle). Alternatively, the “container” may be separated into a plurality of figures. [1252]
(c) Particular “objects” can be laid out at particular positions with priority. [1253]
(d) “Occupied blank areas” can be laid out around “objects” or at suitable positions. [1254]
(e) The “orientations” of “objects” can be varied so as to optimize the layout thereof. [1255]
(f) A layout rule for a two-dimensional layout can be selected from a variety of layout rules, not fixed. [1256]
(g) An evaluation standard for a two-dimensional layout can be designated correspondingly to an application. [1257]
For example, the present invention can be applied to the following fields. [1258]
(a) Layout problem for stock items in a warehouse [1259]
(b) Layout problem for parts on a printed circuit board [1260]
(c) Cell layout problem in designing a VLSI [1261]
To practically apply the present invention to such industrial fields, individual evaluation standards should be designated for problems thereof. However, since the present invention can be applied to any two-dimensional layout problem, it is expected that a technology based on the present invention becomes important. [1262]
In addition, the technology of the present invention can be easily extended to object layout problems in a multi-dimensional space, not limited to two-dimensional layout problems. For example, in the case of a three-dimensional layout problem in which objects in a rectangular parallelepiped figure with any shape and size are successively laid out in a “container” represented by a three-dimensional closed figure, a priority rule for layout positions in the three-dimensional layout space is designated and objects are automatically laid out according to the priority rule. [1263]
According to the present invention, a layout problem for laying out many objects in a space can be accurately and effectively solved. Thus, a layout of objects in a warehouse, a layout of parts on a printed circuit board, a layout of cells in a VLSI, and so forth, can be effectively designed. [1264]

Claims

1. A layout apparatus laying out objects, comprising:

a storing unit storing a placement rule including information of a direction designated by a vector in a coordinate system for a layout space and specifying at least one layout position in the layout space; and

a layout unit in communication with the storing unit and generating an object layout result representing the objects laid out in the layout space by successively receiving, as an object, information of each object from an input unit in communication with the layout unit and for each object received from the input unit determining a layout position in the layout space by repeatedly applying the placement rule according to a priority order based on the placement rule and by repeatedly selecting a farthest position in the designated direction among positions in the layout space.

2. The layout apparatus as set forth in claim 1, wherein said layout unit lays out a new object not overlapping with other objects that have been laid out and without need to move the other objects.

3. The layout apparatus as set forth in claim 1, further comprising:

a space managing unit in communication with the layout unit and managing the layout space and laying out a designated object to a designated position, and

wherein said layout unit determines the layout position with reference to the layout space managed by said space managing unit and instructs said space managing unit to lay out the object received from the input unit as the designated object in the layout position as the designated position.

4. The layout apparatus as set forth in claim 3, wherein said space managing unit manages the initial space composed of at least one closed figure surrounded by vertical sides and horizontal sides with a set of inscribed rectangles inside the closed figure, all sides of each of the inscribed rectangles partially congruent with corresponding sides of the closed figure, respectively, and treats as the layout space an area generated by excluding from the initial space a space of an object that has been laid out in the initial space.

5. The layout apparatus as set forth in claim 1,

wherein said storing unit stores information of the initial space that is generated by replacing a figure of an arbitrary shape with a figure represented by vertical and horizontal sides with a predetermined accuracy, and

wherein said layout unit treats as the layout space an area generated by excluding from the initial space a space of an object that has been laid out in the initial space.

6. The layout apparatus as set forth in claim 1, wherein said layout unit designates an initial space, lays out at least one object according to the placement rule at a predetermined position having highest priority, and lays out other objects according to the placement rule.

7. The layout apparatus as set forth in claim 1, wherein said layout unit treats a blank area as an object to be laid out and lays out the blank area in the layout space generating a desired blank area in the object layout result.

8. The layout apparatus as set forth in claim 1, wherein said layout unit attaches a blank area around an object generating a desired blank area in the object layout result.

9. The layout apparatus as set forth in claim 1, wherein said layout unit treats a circumscribed rectangle of a generated object layout result as an object to be newly laid out and lays out the circumscribed rectangle in a new layout space generating a hierarchical two-dimensional layout.

10. The layout apparatus as set forth in claim 1,

wherein said storing unit stores information of a main direction and a sub direction as the information of the direction, and

wherein if there are a plurality of farthest positions in the main direction, said layout unit lays out each object at a farthest position in the sub direction among the farthest positions in the main direction.

11. A layout apparatus laying out objects in a layout space, comprising:

a storing unit storing a placement rule specifying at least one layout position in the layout space, the layout space corresponding to an initial space having corners at an initial state and the storing unit storing, as the placement rule one of the corners in the initial space and a position on the outer periphery thereof to specify a layout position; and

a layout unit in communication with the storing unit and generating an object layout result representing the objects laid out in the layout space by successively receiving, as an object, information of each object from an input unit in communication with the layout unit and for each object received from the input unit determining a layout position in the layout space by repeatedly applying the placement rule according to a priority order based on the placement rule, the layout unit using, as the priority order to select from among one or more layout positions, the criteria of laying out each object in the vicinity of the layout position.

12. The layout apparatus as set forth in claim 11, wherein said storing unit stores as the placement rule a layout position with a short distance to one of the outer peripheral sides of the initial space and for each object determining the layout position according to a predetermined priority order of four corners and four sides when there are two or more layout positions with the same distance.

13. The layout apparatus as set forth in claim 11, wherein said short distance is shortest normalized distance generated by normalizing a distance from one of outer peripheral sides of the initial space with a predetermined ratio in a vertical direction and a horizontal direction of the initial space, and for each object determining the layout position according to a predetermined priority order of the corners and sides of the initial space when there are two or more layout positions with the same normalized shortest distance.

14. The layout apparatus as set forth in claim 1,

wherein said storing unit stores a rule for rotating the designated direction by a predetermined angle as the placement rule, and

wherein said layout unit lays out each object by determining the layout position of each object by repeatedly applying the rotated layout direction of the object according to a criteria of laying each object.

15. The layout apparatus as set forth in claim 1, wherein said layout unit lays out each object in an available blank space in the designated direction.

16. An analysis apparatus, comprising:

a storing unit storing a placement rule specifying at least one layout position in a layout space; and

an analyzing unit analyzing a layout result of objects in the layout space by generating a layout order of the objects that reproduces the layout result according to the placement rule by repeatedly extracting, using the layout result, the objects laid out in the layout space by applying the placement rule in a priority order based on the placement rule and laying out the objects in the layout space according to the placement rule applied to each object in the priority order.

17. The analysis apparatus as set forth in claim 16, wherein said analyzing unit extracts the objects and blank areas in the layout result according to the placement rule and generates a layout order of the objects and the blank areas that reproduces the layout result.

18. The analysis apparatus as set forth in claim 17, wherein said analyzing unit generates a layout order that reproduces a layout result of the objects, the layout result having least number of blank areas.

19. The analysis apparatus as set forth in claim 16, wherein said analyzing unit generates the layout order which reproduces at least a part of the layout result.

20. A layout evaluating apparatus designing a layout of objects, comprising:

an inputting unit successively inputting information of the objects;

a layout unit in communication with the inputting unit and generating a layout result representing the objects laid out in a layout space by repeatedly determining a layout position in the layout space according to a placement rule including information of a direction designated by a vector in a coordinate system for the layout space and specifying at least one layout position in the layout space, the placement rule applied in a priority order based on the placement rule for laying out each object in the layout space and a farthest position selected in the designated direction among positions in the layout space; and

an evaluating unit in communication with the layout unit and evaluating the layout result.

21. The layout evaluating apparatus as set forth in claim 20, wherein said evaluating unit evaluates the layout result according to at least one of information of the entire size of the layout result, information of a layout position of a particular object, information of relative layout positions of two or more particular objects, information of a distribution of the layout of the objects, and information of a layout of blank spaces between the objects.

22. A layout optimizing apparatus designing a layout of objects, comprising:

a storing unit storing a placement rule including information of a direction designated by a vector in a coordinate system for a layout space and specifying at least one layout position in the layout space;

an inputting unit successively inputting information of the objects; and

a layout unit in communication with the storing unit and the inputting unit and generating a layout result of the objects representing the objects laid out in the layout space by repeatedly for each object determining a layout position in the layout space by applying the placement rule according to a priority order based on the placement rule and by selecting a farthest position in the designated direction among positions in the layout space, the layout space generated by excluding from an initial layout space in which objects have been laid out, space of the objects laid out; and

an evaluating unit in communication with the layout unit and evaluating layout results generated by the layout unit by varying at least one of a layout order of the objects, the placement rule, and the initial layout space, and selecting a most compact layout result.

23. The layout optimizing apparatus as set forth in claim 22, wherein said layout unit includes layout units generating layout results in parallel.

24. The layout optimizing apparatus as set forth in claim 22,

wherein said storing unit stores placement rules; and

said layout unit generates one of the layout results according to one of the placement rules.

25. The layout optimizing apparatus as set forth in claim 22, wherein said layout unit generates the layout results using initial spaces having different shapes or sizes.

26. A layout optimizing apparatus designating a layout of objects, comprising:

a storing unit storing at least one placement rule including information of a direction designated by a vector in a coordinate system for a layout space and specifying at least one layout position in the layout space;

a layout unit in communication with the storing unit and generating an object layout result representing the objects laid out in the layout space by successively receiving, as an object, information of each object from an input unit in communication with the layout unit and for each object received from the input unit determining a layout position in the layout space by repeatedly applying the placement rule according to a priority order based on the placement rule and by repeatedly selecting a farthest position in the designated direction among positions in the layout space;

an evaluating unit evaluating the object layout result generated by said layout unit; and

a searching unit representing a layout order of objects as gene data, performing a genetic operation for a gene group including data of at least one gene according to a genetic algorithm, and obtaining a layout result corresponding to an obtained layout order.

27. The layout optimizing apparatus as set forth in claim 26, wherein said searching unit further represents the priority rule for layout positions as the gene data and performs the genetic operation for the gene group.

28. The layout optimizing apparatus as set forth in claim 26, wherein said searching unit further represents an orientation of an object as the gene data and performs the genetic operation for the gene group.

29. A layout optimizing apparatus, comprising:

storing means for storing at least one placement rule for layout positions;

input means successively inputting information of objects;

layout means for generating an object layout result representing the objects laid out in a layout space by successively receiving, as an object, information of each object from the input means and for each object received from the input means designating a layout position of each object in the layout space according to the placement rule for layout positions every time information of each object is input;

evaluating means for evaluating a layout result generated by said layout means;

searching means for representing a layout order of objects as gene data, performing a genetic operation for a gene group including data of at least one gene according to a genetic algorithm, and automatically obtaining a layout result;

analyzing means for analyzing a layout result obtained by said layout means, and obtaining a predetermined layout order of objects reproducing the layout result by laying out the objects according to a predetermined placement rule for layout positions, and

wherein said searching means substitutes the predetermined layout order with the gene data and performs a process corresponding to the predetermined placement rule for layout position.

30. The layout optimizing apparatus as set forth in claim 29,

wherein said analyzing means obtains a layout order which reproduces at least a part of the layout result obtained by said layout means according to the predetermined priority rule for layout positions, and

wherein said searching means substitutes the obtained layout order with the gene data.

31. The layout optimizing apparatus as set forth in claim 26, wherein said searching unit exchanges order positions of two objects that are successively included in a layout order and have been randomly designated by performing the genetic operation for the gene data.

32. The layout optimizing apparatus as set forth in claim 26, wherein said searching unit exchanges order positions of two objects each of which has been randomly designated by performing the genetic operation for the gene data.

33. The layout optimizing apparatus as set forth in claim 26, wherein said searching unit moves objects at and after an order position that has been randomly designated in the gene data to a top position of the gene data by performing the genetic operation for the gene data.

34. The layout optimizing apparatus as set forth in claim 26, wherein said searching unit selects one order position with respect to two genes and interchanges gene data of the two genes with respect to the selected order position by performing the genetic operation for the gene data.

35. A computer-readable storage medium used to direct a computer and including a process of successively receiving information of objects and generating an object layout result representing layout of the objects in a layout space by determining a layout position of each object in the layout space according to a placement rule including information of a direction designated by a vector in a coordinate system for the layout space and specifying at least one layout position in the layout space, for each object the placement rule being applied repeatedly in a priority order based on the placement rule and a farthest position in the designated direction among positions in the layout space being selected.

36. A computer-readable storage medium used to direct a computer to perform a process comprising:

representing an area of a two-dimensional space composed of at least one closed figure surrounded by vertical sides and horizontal sides with a set of inscribed rectangles inside the closed figure, all sides of each of the inscribed rectangles partially congruent with corresponding sides of the closed figure, respectively; and

managing the space with the set of inscribed rectangles by laying out a designated rectangular object in a designated position of the space, generating an area by excluding a rectangle of the rectangular object from the space, and representing the generated area with a set of inscribed rectangles.

37. A computer-readable storage medium used to direct a computer to perform a process comprising:

analyzing a layout result of objects in a layout space; and

generating a layout order of the objects that reproduces the layout result layout position in the layout space by repeatedly laying out the objects according to a placement rule specifying at least one layout position in the layout space.

38. A computer-readable storage medium used to direct a computer for designating a layout of a plurality of objects to perform a process comprising:

receiving successively information of the objects;

generating object layout results representing the objects laid out in a layout space by repeatedly determining a layout position in the layout space according to a placement rule including information of a direction designated by a vector in a coordinate system for the layout space and specifying at least one layout position in the layout space, for each object the placement rule being applied repeatedly in a priority order based on the placement rule and a farthest position in the designated direction among positions in the layout space being selected, and the layout space generated by excluding spaces of objects that have been laid out from an initial space; and

evaluating the object layout results by varying at least one of a layout order of the objects, the placement rule, and the initial space, so as to select one of the object layout results.

39. A layout method designing a layout of objects, comprising:

receiving successively information of the objects; and

generating an object layout result representing the objects laid out in a layout space by repeatedly determining a layout position in the layout space according to a placement rule including information of a direction designated by a vector in a coordinate system for the layout space and specifying at least one layout position in the layout space, for each object the placement rule being applied repeatedly in a priority order based on the placement rule and a farthest position in the designated direction among positions in the layout space being selected.

40. A space managing method, comprising:

41. An analysis method, comprising:

analyzing a layout result of objects in a layout space; and

generating a layout order of the objects that reproduces the layout result by repeatedly laying out the objects in the layout space according to a placement rule specifying at least one layout position in the layout space.

42. A layout optimizing method designing a layout of objects, comprising:

receiving successively information of the objects;

generating object layout results representing the objects laid out in a layout space by determining a layout position in the layout space according to a placement rule including information of a direction designated by a vector in a coordinate system for the layout space and specifying at least one layout position in the layout space, for each object the placement rule being applied repeatedly in a priority order based on the placement rule and a farthest position in the designated direction among positions in the layout space being selected, and the layout space being generated by excluding spaces of objects that have been laid out from an initial space;

varying at least one of a layout order of the objects, the placement rule, and the initial space; and

evaluating the object layout results to select one of the object layout results.

43. A computer system laying out objects in an initial space, comprising:

a processor, successively receiving information of the objects, and to generate, using the information of the objects, an object layout result representing layout of each object in the initial space by repeatedly determining an area in the initial space as a layout space and determining a layout position of each object in the layout space without moving other objects in the initial space, the layout position being determined according to a placement rule including information of a direction designated by a vector in a coordinate system for the layout space and specifying at least one layout position in the layout space, for each object the placement rule being repeatedly applied according to a priority order based on the placement rule and the priority order being determined by selecting a closest position to the designated direction among positions in the layout space.

44. A layout optimizing apparatus, comprising:

a storing unit storing at least one placement rule for layout positions;

an inputting unit in communication with the storing unit and successively inputting information of objects;

a layout unit in communication with the storing unit and generating an object layout result representing the objects laid out in the layout space by successively receiving, as an object, information of each object from the inputting device and for each object received from the inputting device determining a layout position of each object in the layout space according to the placement rule for layout positions every time information of each object is input;

an evaluating unit in communication with the layout unit and evaluating a layout result generated by said layout unit;

an analyzing unit in communication with the layout unit and analyzing a layout result generated by said layout unit, and obtaining a predetermined layout order of objects reproducing the layout result by laying out the objects according to a predetermined placement rule for layout positions; and

a searching unit in communication with the analyzing unit and searching a layout order of objects while varying the layout order by a probability operation according to a simulated annealing method, and obtaining a layout result by the probability operation, wherein the searching unit further searches for the predetermined layout order of the objects using the predetermined placement rule for layout positions.

45. A layout optimizing apparatus, comprising:

a storing unit storing at least one placement rule for layout positions;

a layout unit in communication with the storing unit and generating an object layout result representing the objects laid out in a layout space by successively receiving, as an object, information of each object from the inputting device and for each object received from the inputting device designating a layout position of each object in the layout space according to the placement rule for layout positions every time information each object is input;

a searching unit in communication with the analyzing unit and representing a layout order of objects as gene data, performing a genetic operation for a gene group including data of at least one gene according to a genetic algorithm, and automatically obtaining a layout result, wherein the searching unit substitutes the standard layout order with the gene data and performs a process corresponding to the predetermined placement rule for layout position.