JP2686758B2 - Graphic editing device - Google Patents

Description

The present invention relates to a general graphic editing device in a graphics system, and particularly to enlarging / reducing output of a large amount of graphic information and enlarging / expanding each graphic. The present invention relates to a graphic editing device suitable for high speed reduction / movement / copying / deletion.

(Prior art) In general companies, including ministries and agencies,
Instead of the conventional method of handwriting and saving a large amount of graphic information such as a residential map one by one on the original drawing, etc., drawing using a graphic display,
An electronic computer system for figure editing is being introduced, in which editing is performed and plotting is performed using a plotter or LBP (laser beam printer).

In order to realize such a graphics system (graphic editing method), each hardware including a graphic display has a range in which graphic information can be output (for example, in the case of a graphic display, 1).
When it exceeds the capacity of the frame buffer corresponding to the screen), it has a function of clipping the output graphic information and outputting it so as to fit within the range.

For example, when the graphic information drawn on one screen (screen) is enlarged and displayed and the graphic information is edited on the screen, even if the expanded coordinate conversion is performed on all the graphic information and output, It can be displayed correctly (without malfunction) on one screen by clipping to the screen area.

Further, in order to realize editing operations such as moving graphic information in a conversational manner using a graphic display, for example, a method as disclosed in Japanese Patent Laid-Open No. 62-57078 is used.
There is a method in which all graphic information is searched for based on the coordinates designated by a mouse or the like and the graphic information to be edited is picked.

The picked-up graphic information is re-displayed on the display by blinking or the like, and the operator is inquired whether or not each edit is possible. For example, when the operator gives an instruction to execute the movement, the blinked figure is erased by overwriting the blinked figure with the tube surface color (ground color) or the like.

When the erased figure overlaps the figure color portion other than the tube surface color, the erasure causes a toothless portion in that portion. In order to repair this missing tooth portion, after erasing, as shown in, for example, Japanese Patent Application Laid-Open No. 60-173677, the figure information overwritten with the tube surface color by the erased figure is searched from all the figure information. Then, a part of the erased figure is re-displayed only in the tooth-missing part in the color of the part. In this way,
After repairing the display screen with missing teeth, if the picked figure is displayed at the movement destination, the movement operation is completed.

(Problems to be Solved by the Invention) However, in the conventional graphic editing method, the following problems occur.

The first point occurs when displaying and displaying graphic information. Even if only a part of a large amount of graphic information is displayed and it is not the target of drawing, all graphic information must be processed and then output. This means that the display and output time will be very slow because it must be done.

The second point occurs when interactively editing graphic information, and it takes a long time to search because all graphic information must be searched for repairing after picking, deleting, or moving the graphic. Therefore, the responsiveness is poor and it may cause an erroneous operation.

The third point is that, because of the above problems, a large amount of graphic information cannot be centrally managed or edited in order to secure responsiveness, so a small amount (appropriate amount) of graphic information It has to be divided into files and edited individually. Therefore, especially for graphic information that spans division boundaries,
Since it is stored in a plurality of graphic information files or the like, it is necessary to edit the graphic information a plurality of times when changing the graphic information.

The fourth point can only display and output the divided graphic information units for the same reason as the third point, so it is very difficult to integrate and display and output them continuously.

As described above, in the conventional graphic editing method, if a large amount of graphic information is handled at once, it takes a huge amount of time,
The poor responsiveness makes it extremely inconvenient for the operator.

On the other hand, if the graphic information is divided and handled in order to secure responsiveness, there is a problem that an extremely complicated work is required at the time of editing the graphic information and the graphic information with good visibility cannot be output.

An object of the present invention is to solve the above problems of the conventional method, and to provide a graphic editing method in which responsiveness to an operator, centralized management / editing of information, and output of graphic information with good visibility are all satisfied. To provide.

(Means for Solving the Problem) In the present invention, in order to retrieve a huge amount of graphic information, rectangular coordinates surrounding the graphic information and circumscribing the graphic information (diagonal vertices of the rectangle, for example, coordinates of lower left and upper right vertices of the rectangle) are used. Introduce a binary tree composed of a plurality of nodes (each corresponding to one piece of graphic information) that holds the Search for.

When searching, not all tree nodes are searched, but the search is performed according to the priority order of the nodes. As a key indicating the priority order, a pair of x coordinates or a pair of y coordinates among rectangular coordinates surrounding the graphic information is used.

Furthermore, each node corresponds to a section coordinate in which graphic information exists. The structure is defined below.

k ₁ (n), k ₂ (n): x-coordinate or y-coordinate pair of node n.

However, k ₁ (n) ≦ k ₂ (n) α, β: section corresponding to the node a: node b: left node of node a c: right node of node a Each node of the binary tree of satisfies the following conditions.

1) For node a, k ₁ (a) ≦ k ₁ (b), k ₁ (a) ≦ k ₁ (c) α ≦ k ₂ (a) ≦ β 2) For node b, α ≦ k ₂ (b) ≦ (α + β) / 2 3) For node c, (α + β) / 2 <k ₂ (c) ≦ β The above condition is recursively applied to all nodes of this tree. By doing so, a binary tree can be constructed.

According to this structure, a node is searched and a subtree that does not need to be searched is checked, so that target graphic information can be determined at high speed without performing unnecessary search.

(Operation) When retrieving graphic information, the above-mentioned binary tree structure is used and unnecessary graphic information is not retrieved, so that desired graphic information can be accessed at high speed.

(Example) Hereinafter, one example of the present invention will be described in detail.

FIG. 1 shows the structure of graphic information according to the present invention. FIG. 1A shows an example of a binary tree, and FIG. 1B shows a concrete graphic represented by the binary tree. It is a figure which shows an example of an information group. FIG. 2 is a system configuration example for implementing the present invention.

First, the schematic configuration of the interactive figure editing apparatus according to the present invention will be described with reference to FIG.

Input of graphic information to the graphic editing apparatus of the present invention uses the graphic display 11, the keyboard 12, etc.
The interactive figure editing program stored in the electronic computer 13 is started, and various information is input while talking with the program, such as the mouse 14, the light pen 15, the digitizer 16 and the keyboard 12 (coordinate input means). ) Is used.
20 is a batch type input device.

The started program is the graphic information according to the operator's instruction (for example, a residential map of 1-chome Omika-cho, Hitachi City).
Is displayed on the graphic display 11.

At the time of display, all graphic information (Hitachi City all-house map) stored in the secondary storage device 17 is read out, and the graphic information (Omika 1-chome) that has been instructed is searched for and appropriate coordinate conversion (enlargement
Reduction and conversion to hardware coordinate system) and output to the graphic display 11.

When the target screen is displayed, the operator can edit the graphic information (add a new house and delete a demolished house, etc.) by giving instructions using various input devices in an interactive manner with this program. )I do.

For example, when a new line segment is drawn, a desired straight line is additionally displayed by clicking the desired start point and end point on the graphic display 11 using the mouse 14. You can also click on a line segment that is already displayed to pick that line segment, delete the line segment, or click another position to move the line segment. Or

The program displays a graphic on the graphic display 11 and updates the graphic information according to each editing operation. When the operator gives an instruction to end editing, the program stores the updated graphic information in the secondary storage device 17.
Store in and stop.

It also has a function of selectively outputting (for example, a house map of Hitachi City Omika 1-chome) from the information stored in the secondary storage device 17 to the LBP 18 or the plotter 19 according to the instruction of the operator. .

Next, the configuration of the graphic information of this system will be described.

FIG. 1A shows an example of the structure of a binary tree (hereinafter abbreviated as a tree) 1 according to the present invention, and FIG. 1B shows an example of graphic information 2 represented by this tree. .

Here, each node 3 of the tree is associated with each piece of graphic information 4 (the information included in the node 3 will be described later). The correspondence is shown by a circled frame number 5 written on the left (or right) of each node and a circled frame number 6 written on the upper left of each graphic information.

The structure of the tree is such that the x-coordinates of the lower left and upper right of the one diagonal of the rectangle 7 circumscribing each figure information (hereinafter, x ₁ (i), x
₂ (i): abbreviated as i = 1,2,3, etc.), and the x coordinate section 8 associated with each node is followed. Here,
To simplify the explanation, the coordinate space of all figure information is
As shown in FIG. 1 (B), it is assumed that the coordinates are normalized to integer coordinates of [0, N] / [0, M].

The root node 9 of the tree has a plurality of pieces of graphic information in which the upper right coordinate x ₂ (i) is included in the section [0, N] (that is,
Smallest lower left coordinate in each figure shown in Fig. 1 (B)
Graphic information with x ₁ (i) (in the example of FIG. 1, a polygonal line graphic)
Corresponds.

The left node of the root node 9 (child node branched to the left in the binary tree) is x ₂ (j) in the interval [0, N / 2].
(However, the smallest x among those that include j ≠ i
₁ (j) (where j ≠ i) has corresponding graphic information (diamond shape in the example of FIG. 1), and the right node (child node branched to the right in the binary tree) is the interval [N / 2 +
1, N] includes x ₂ (k) (where k ≠ i), the figure information (the rectangle in the example of FIG. 1 has the smallest x ₁ (k) (where k ≠ i). (Figure) corresponds.

As can be seen from the above description, the general definition of this tree structure is as follows.

(1) The root node of a subtree is the interval [α,
β] includes x ₂ (i) and corresponds to the graphic information having the smallest x ₁ (i).

(2) The left node of the root node is a section [α,
Among (α + β) / 2] including x ₂ (j) (j ≠ i), the graphic information having the smallest x ₁ (j) (j ≠ i) corresponds.

(3) The right node is in the interval [(α + β) / 2 + 1, β]
x ₂ (k) (k ≠ i) is included, the smallest
The graphic information having x ₁ (k) (k ≠ i) corresponds.

The binary tree of FIG. 1 (A) is formed by sequentially and repeatedly applying the above definition to all the figures of FIG. 1 (B) so that all subtrees are satisfied. In addition,
A node 10 having a root node as a child node is a dummy node for facilitating a tree operation (for example, in FIG. 1, deleting the root node 9).

As shown in FIG. 1A, each node of the tree has a pointer for holding the figure information, upper left and lower right coordinates of a rectangle circumscribing the figure, and coordinates to the figure information. (For example, the start address of the memory, the data length), the pointer to the left or right child node, and the like are held. Further, as a result of output, when the figure depends on the drawing order, a bidirectional pointer or the like connecting the nodes in the drawing order can be held.

Next, before explaining the overall operation of the present invention, first,
A procedure for searching graphic information using a binary tree, which is the center of operation, and adding / deleting graphic information will be described with an emphasis on tree traverse and node operation. An example in which these operation procedures are applied to the specific binary tree in FIG. 1 will be described later.

First, referring to the flow chart shown in FIG. 4, the search for graphic information according to the structure of the binary tree will be described.

The range to be displayed on the graphic display is
As shown in Fig. 13, the range of [X ₁ , Y ₁ ] × [X ₂ , Y ₂ ] on the area 30 [0, N] x [0, M] (for example, the map of the entire Hitachi city)
32 (for example, the range including Omika 1-chome).
That is, all or part of the graphic information to be displayed is in the range of [X ₁ , Y ₁ ] × [X ₂ , Y ₂ ] (indicated by reference numerals 34 and 36 in FIG. 13). ) Is searched from all the graphic information.

The tree traverse (search) at the time of search is performed by using the given coordinates X ₁ , Y ₁ , X ₂ , Y ₂ as a reference and comparing the coordinates of a rectangular area surrounding each piece of graphic information with this. Also, tree traversal is performed from the root node of the tree. The traced node (the node currently being searched) is n (401),
The interval [α, β] corresponding to the node is set to [0, N] (40
2).

Next, it is checked whether or not the node n under search is an empty node, in other words, whether or not it has a child node to be traced next (403). If it is an empty node, 410 is determined, and if it is not an empty node, 404 is determined.

Here, the coordinates of the lower left and upper right corners of the rectangular area surrounding the graphic information corresponding to the search target node are {x ₁ (n), y ₁ (n)}, {x as shown in FIG. 1 (B). ₂ (n), y ₂ (n)}
And x ₁ (n) ≦ x ₂ (n), y ₁ (n) ≦ y ₂ (n)
And

Further, as is apparent from the following description, tree traversal is performed with depth priority. In other words, the determination of 403 is negative, and as long as there are child nodes in the search target node, the tree is traced downward, and the nodes and sections are stored in a stack (last in, first out) method.

As is clear from the configuration of the binary tree, if the lower left x coordinate x ₁ (n) of the rectangle of the current search target node is on the right side of the output range (for example, rectangle 38 in FIG. 13), {X ₂ <
Since x ₁ (n)} and the subtrees under the node are all outside the output range, they are not searched (the first half condition of 404).

If the end point (β) of the section [α, β] corresponding to the current node is on the left side of the output range (β <X ₁ ), all subtrees below it will be on the left side, that is, outside the range, and will not be searched. (Conditions in the latter half of 404).

For the nodes other than the nodes that are out of the range in the determination 404, the rectangle of the node is the output range [X ₁ , Y ₁ ]
It is determined whether it is included in × [X ₂ , Y ₂ ] (405). That is, if the determination of 405 is not satisfied, it is out of the range, while the node for which the determination is satisfied is within the range, and thus is held as an output target (406).

Next, the current search target node and its section [α, β]
Is pushed (input) by stack method (407), and [α,
[β] is calculated and the node to the left of the [β] is traversed (408, 409) and the process returns to the determination 403.

At this time, if the determination of 403 is established and it is determined that there is no node and the node is an empty node, it is determined at 410 whether the stack is empty. When it is determined that the stack is not empty (410), the stack is popped (411), the node is traversed to the right node (412, 413), the process returns to the determination 403, and the determination and operations after 404 are repeated. If the result of judgment 403 is affirmative and there are no nodes (empty node), and the result of judgment 410 is affirmative and the stack is empty, it means that the search for all the desired nodes is completed, so the processing is stopped. To do.

Next, with reference to the flowchart shown in FIG. 5, tree node generation and addition processing will be described. n, α,
β, x, y, etc. are the same as the assumption in the case of the search processing. In order to realize the node generation operation more easily, it is assumed here that processing is started from a dummy node having a root node on the left.

The node to be newly inserted is set to new (501), and each node is traced according to the tree structure. That is, Pn is a dummy node (10 in FIG. 1) (502), and the left node of Pn is set to n (503). A flag value indicating "left" is set in in (504), and (0, N) is set in the interval (α, β) (505).

In the next judgment 506, it is checked whether or not n is an empty node, and if not n, a judgment 507 is made. This decision 507
In, the lower left x coordinate x ₁ of the rectangle of the current search target node
(N) is the lower left x coordinate x ₁ (ne of the rectangle of the node to be inserted
If it is larger than w), the position to insert is the position of the current node. Therefore, by exchanging the pointers of the current node and the node to be inserted, both nodes are exchanged (508,509), and the current node is replaced. Is a node to be inserted (510).

Furthermore, the upper right x-coordinate of the rectangle of the node to be inserted x ₂ (ne
If w) is included in [α, (α + β) / 2], it is inserted into the left subtree (512,513 to 515), otherwise it is inserted into the right subtree (512,516 to 518).

Finally, since the node to be inserted is always generated as a leaf of the tree (519), the left and right child nodes are made empty nodes (520), and the process ends.

As another example of the tree node operation process, a node deletion process will be described with reference to the flowchart of FIG. n, α, β, x ₁ , y _1, etc. are the same as the above assumption.
In addition, starting processing from a dummy node is also the same as described above (602 to 605).

The node to be deleted is searched and confirmed by the above-described search processing, and this is designated as del (601). Since this tree is constructed according to the definitions and methods detailed above, the nodes designated as del are traced according to the structure of the tree in the same way as when the nodes were created (606 to 614). The position (parent node Pn of del, left / right distinction dn) can be searched.

If del is found (606), delete it from the tree. That is, in order to maintain the structure of the tree, the node is replaced by the child (left, right) nodes of del as follows.

If there is no right node of del (empty node) (616), or if the lower left rectangle x coordinate of the left node of del is smaller than the lower left rectangle x coordinate of the right node (618), replace it with the left node of del . The replacement in this case is to connect the left node of del to the parent node of del (626), make the right node of del the right node of the left node (625,630), and let del hold the pointer of the left node of del ( 629).

Also, when replacing with the right node of del (617, 618), it is similarly performed (619 to 624).

In this way, the node to be deleted is replaced step by step toward the leaf (615), and when the leaf node is deleted (631), this processing ends.

Next, based on the graphic information shown in FIG. 1, the history of the state of the tree through each of the above-mentioned editing operations, that is, each operation of newly creating, adding and deleting graphic information will be specifically described.

First, an example of a case of newly generating graphic information will be described with reference to FIGS. 7 and 5.

When newly generating graphic information, a dummy tree node 10 is first generated (701).

After that, assuming that the graphic information in FIG. 1 is input by the operator (for example, by clicking each vertex of the polygon on the graphic display with the mouse 14 or the like), the circumscribed rectangle coordinates {x ₁ (2), y
₁ (2)}, {x ₂ (2), y ₂ (2)} are obtained and stored in the new node 3.

After that, according to the flowchart shown in FIG. 5, the stored node is set as new (= node) (501), and Pn is set as the first node.
As the dummy node 10 in the figure (502), a tree is generated (702).

In this case, since Pn (dummy node) has no left and right nodes and is an empty node, an empty node is set in n (503), and immediately after processing 504 to 506, Insert processing, new (= node) is set to in (= left) node of Pn (= dummy node) (519) (703), n
Set left and right nodes of ew to "empty node" (520)
Perform (704). This is the end of the procedure for newly generating graphic information.

Next, a case will be described with reference to FIGS. 8, 9 and 10 in which the graphic information of, shown in FIG. 1 is inputted in this order from the above state and the graphic information is added.

After the figure information is input and the circumscribed rectangle coordinates are generated, it is stored in a new node. Then, according to the flowchart shown in FIG. 5 and the history chart shown in FIG. 8, the node storing is set as new (501), and Pn is the dummy node shown in FIG.
As 10 (502), a tree is generated (802).

In this case, since the root node (node thereof) is set in the left node of Pn, the node of is set in n (503). After the processing of 504 to 505, n, that is, the node is not an empty node (506), so x ₁ (new)
{= X ₁ (3)} is compared with x ₁ (n) {= x ₁ (2)} (507).

Since x ₁ (new) <x ₁ (n) is not established, n (= node) is set to Pn (511), and then x ₂ (new) and (α +)
β) / 2 (= N / 2) is compared (512). x ₂ (new) ≤ (α
+ Β) / 2, so the node to the left of n (empty node) is n
(513), and [α, (α + β) / 2] (=
[0, N / 2]) (514), and a flag value indicating left is set (515) in (803).

Then, since it is found that an empty node is set in n (506), node insertion processing (519,520) is performed (804,805).

After the node is inserted, in order to maintain the drawing order, set the node pointer of (to indicate that the next is drawn) to the node that stores, and the node that stores to A node pointer (indicating that is drawn before) is set (806).

As a result, the graphic information can be displayed in the drawing order, and even if the graphic information is input and drawn in such a position as to overlap, it can be displayed as input.
For example, on a rectangle filled in red, white letters
It is possible to draw A, B, C, etc. to emphasize these characters.

Then, the insertion of the node when the graphic information of is input is performed according to the flowchart shown in FIG. 5 and the history chart shown in FIG. 9 as in the case of inputting.

That is, the node of is set as new (501), and tree generation is started by dummy nodes (502 to 505) (901,
902). Since n is a node of and the decision 506 is not established, x ₁ (new) {= x ₁ (5)} and x ₁ (n) {= x
₁ (2)} is compared (507). x ₁ (new) <x ₁ (n)
Is not so set n to Pn (511), x ₂ (new)
Compare {= x ₂ (5)} with (α + β) / 2 (= N / 2) (5
12).

x ₂ (new)> (α + β) / 2, that is, the determination 512 is negative, so n is set to the node to the right of n (empty node) (516), and [α, β] is set to [(α + β) / 2 + 1, β]
(= [N / 2 + 1, N] is set (517), and the flag value indicating the right is set to in (518) (903).

Subsequently, since it is found that an empty node is set in n (506), node insertion processing (519,520) is performed (904,905). After inserting the node, a pointer for holding the drawing order is generated.

That is, the node pointer of is stored in the node of. As a result, as shown at 906 in FIG.
Two node pointers indicating the previous graphic information of and the node pointer indicating the next graphic information are held. Further, the node pointer of is set to the node of (906).

The insertion of the node into the graphic information is performed according to the flow chart shown in FIG. 5 and the history chart shown in FIG. 10, as in the case of the graphic information described above.

The node of is set as new (501), and tree generation is started from dummy nodes (502 to 505) (1001, 1002). Here, since n is a node of (50
6), x ₁ (new) {= x ₁ (1)} <x ₁ (n) {= x
_{Since 1} (2)} (507), new left and right nodes are set to n left node (node) and right node (node) (508) (1003).

At this stage, the left node of new is set to, and the right node is set to.

Next, ne in the in (= left) node of Pn (= dummy node)
w (= node) is set (509) (1004). Then, n and new are exchanged (510) (1005). in this case,
n becomes a node of and new becomes a node of.

That is, when a node is inserted at a position in the middle of the tree, the density to be inserted is exchanged, and the tree is traced at the same time as the node insertion.

That is, n (= node) is set in Pn, and x ₂ (ne
Since w) {= x ₂ (2)} ≦ (α + β) / 2 (= N / 2) (512), n is the left node (node of n), [α,
[[alpha], ([alpha] + [beta]) / 2] (= [0, N / 2]) is set to [beta]], and the flag value indicating the left is set to in (513 to 515) (1006).

Further, similarly, n (= node) is determined. (506). x ₁ (new) {= x ₁ (2)} <x ₁ (n) {=
Since x ₁ (3)} (507), the left and right nodes of new (= node) are set to n left and right nodes (both are empty nodes) (508) (1007), and Pn (= Node) i
The n (= left) node is set to new (509), and n and new are exchanged (510) (1008). Where new = node,
It is a node of n =.

Then, n (= node) is set in Pn (51
1) (1009). x ₂ (new) {= x ₂ (3)} ≦ (α + β) / 2
Since (= N / 4) (512), n is the left node (empty node) of n, and [α, β] is [α, (α + β) / 2] (= [0,
N / 4]) to in and set the flag value indicating left (513 to 51)
5) (1010).

Since n is an empty node (506), new (= node) is set to the in (= left) node of Pn (= node) (519) (1011), and the left and right nodes of new are made empty nodes. Set (520) (1012).

After the above tree generation processing,
Set the node of and the node of by the same procedure as when inputting (1013).

As described above in detail, in the present invention, when a tree is generated, a branch that is divided into two for each node does not pass through one path. That is, since one path from the root of the tree to the leaves is traced for inserting one node, the number of nodes to trace is almost log when the total number of nodes (that is, the total number of graphic information) is K. ₂ K is good.

Therefore, even if the total figure information is a large number of about 100000, the operation can be completed by about 17 times (≈log ₂ 100000) of node searches.

At the end of the specific example, the case of deleting the graphic information will be described below.

When deleting graphic information, the tree search process shown in FIG. 4 is used based on the coordinates input by the operator (for example, the position where the vicinity of the graphic to be deleted is clicked with the mouse). , The tree node corresponding to the target graphic information is determined, the node is deleted in the tree node deletion processing shown in FIG. 6, and the graphic information is also deleted.

When the tree and the graphic information shown in FIG. 1 are stored, and the coordinates on the lower right side of the diamond of the graphic information are given as the deletion target, An example is given below.

First, it is assumed that the input coordinates are (x, y), N / 4 <x ≦ N / 2, and x ₁ (4) <x <x ₂ (4).
Furthermore, let ε be a sufficiently small number compared to N (for example,
If N = 1024, then ε = 8), and X ₁ = x−ε, Y ₁ = y−ε, X ₂ = x + ε, Y ₂ = y + ε.

Based on these conditions, an example of tracing the tree shown in FIG. 1 will be described first according to the flowchart shown in FIG. Furthermore, Fig. 11 shows the trajectory of what kind of tree can be traced.

In FIG. 11, a double circle node, is a node searched for whether or not the graphic information is to be deleted, and a single circle node is a node searched in the process of tree traverse. Also, the nodes in the triangle frame are the nodes that are not searched. Reference numeral 1108 is an arrow line indicating the order in which the nodes are traced.

First, in the flowchart of FIG. 4, n is the root node (node thereof) (401), and [α, β] is [0, N] (402). n is a root node, not an empty node (403), and X ₂ > x ₁ (n) {= x
₁ (1)} and X ₁ <β (= N), so (404),
[X ₁ , Y ₁ ] × [X ₂ , Y ₂ ] and [x ₁ (n), y ₁ (n)] × [x ₂
It is determined whether or not the areas (n), y ₂ (n)] (n = 1) overlap each other (405).

Since these areas do not overlap, n (=
1), [α, β] (= [0, N]) is pushed and held (407), and the left node (node thereof) of n (= node) is set to n (408). Then, in order to set the section corresponding to the next node, [α, β] is set to [α,
Set (α + β) / 2] (= [0, N / 2]) (409),
Return to decision 403.

n (= node) is not an empty node (403), X ₂
> X ₁ (n) {= x ₁ (2)} and X ₁ <β (= N / 2) (404), and [X ₁ , Y ₁ ] × [X ₂ , Y ₂ ] and [x ₁ (N), y
_{Since the area of 1} (n)] × [x ₂ (n), y ₂ (n)] (n = 2) overlaps (405), the node indicated by n is the searched node (406). .

Similarly, n, [α, β] are pushed and held on the stack (407), n is set to (the node of) the left node of n (408), and [α, β] is set to [α, β]. (Α + β) /
2] (= [0, N / 4]), and the process returns to the determination 403 again.

n (= node) is not an empty node (403), X ₁
> Β (= N / 4) (404) or the stack is not empty (410), so the stack is popped, the node and the interval are extracted and set to n, [α, β] (411). At this time, n is a node and [α, β] is [0, N / 2].

Set the right node (node of n) to n (41
2), [(α + β) / 2 + 1, β] (= [N / 4 +
1, N / 2]) is set (413).

Further, the process returns to the decision 403 and follows the tree. Also at this time, n (= node) is not an empty node (403), and X ₂ > x
₁ (n) {= x ₁ (4)} and X ₁ <β (= N / 2), and (40
4), [X ₁ , Y ₁ ] × [X ₂ , Y ₂ ] and [x ₁ (n), y ₁ (n)] ×
The regions do not overlap with [x ₂ (n), y ₂ (n)] (n = 4) (405).

Therefore, n, [α, β] is pushed and held on the stack (407), the left node (empty node) of n is set to n (408), and [α, (α + β] is set to [α, β]. ) / 2] (= [N
/ 4 + 1, (N / 4 + 1 + N / 2) / 2]) is set (409),
Return to decision 403.

In the next judgment, since it is an empty node of n (403) and it is not an empty stack (410), the stack is popped to extract the node and the section and set to n, [α, β] (41
1). At this time, n is a node of and [α, β] is
[N / 4 + 1, (N / 4 + 1 + N / 2) / 2].

Set n's right node (empty node) to n (412),
[(Α + β) / 2, β] (= [{N / 4 + 1 +
(N / 4 + 1 + N / 2) / 2} 2 + 1, (N / 4 + 1 + N / 2) / 2]) is set (413) and the process returns to the determination 403.

In this case as well, n is an empty node (403) and the stack is not empty (410). Therefore, the stack is further popped to extract the node and the section and set to n, [α, β] (41
1). At this time, n is a node and [α, β] is [0, N].

Let n be (the node of) the right node of n (412),
[Α, β] is [(α + β) / 2 + 1, β] (= [N / 2, N])
(413). After that, the process returns to the determination 403.

n (= node) is not an empty node (403), X ₂ <x ₁
(N) {= x ₁ (5)} (404) and the stack is empty (4
10), so the tree search ends.

From the above processing, it is found that the graphic information to be deleted corresponds to the node.

Here, the actually searched nodes are as follows.

,,: The node that checked whether it is the target graphic information.

,: Nodes searched as a process of tree traverse.

From this, it can be seen that only one path of the branch bisected for each node is passed in order to search for the target graphic information. That is, as in the case of the tree generation, it can be seen that the number of search target nodes is approximately log ₂ K when the total number of nodes (total graphic information number) is K.

Therefore, in the prior art, all graphic information is, for example, 1000
If there were 00 pieces, it was necessary to retrieve the same number of pieces of graphic information 100,000 times, but with this method, only about 17 times (≈log ₂
100000). Even if the overhead of the tree traverse, that is, the number of nodes searched in the process of the tree traverse is added to this, it can be seen that the number of times of the search has a large difference.

Next, a specific example of deleting the node of the graphic information to be deleted from the tree will be described with reference to the flowchart shown in FIG. 6 and the history chart of FIG.

First, set del to the node of (601) (120
1). Pn is the dummy node 10 in FIG. 1 (602), and n is Pn.
The left node (node that is the root node) is set (603), and the flag value indicating "left" is set to dn (6
04), set [0, N] to the interval [α, β] (605)
(1202).

Next, n (= node) is del (= node)
Since it is not (606), n (= node) is set in Pn (607). x ₂ (del) {= x ₂ (2) ≦ (α + β) / 2
Since (= N / 2), the determination 608 is affirmative, and n is n (=
The left node (= node) of (node of) is set (609).

[Α, (α + β) / 2] (= [0, N / 2]) in [α, β]
Is set (610), and a flag value indicating "left" is set in dn (611) (1203).

At this time, n (= node) is del (606),
The left and right nodes of del are not empty nodes (616 to 61)
7), so x ₁ (the left node of del) {= x ₁ (3)} and x ₁ (de
The right node of l) {= x ₁ (4)} is compared to make a decision 618.

Here x ₁ (the left node of del) <x ₁ (the right node of del)
Since the judgment 618 is established, the right node (node of) of del is set to n (625) (1204), and the left node of del (node of) is set to the dn (left) node of Pn (= node). ) Is set (626) (1205).

Set left node (node) of del to Pn (627)
(1206), a flag value indicating "left" is set to dn (62
8). Set left and right nodes (both empty nodes) of Pn (= node) to left and right nodes of del (629) (1207,120)
8), n (= node) is set to the right node of Pn (= node) (630).

The tree node can be reconstructed by performing the above processing operation (1209). After this, the decision 61
Returning to 5, but at this time, the left and right nodes of del (= node) are both empty nodes (615), so Pn
Set an empty node to dn (left) of (= node) (63
1) Complete the node deletion process (1210).

Further, the pointer for holding the drawing order is deleted. That is, the pointer is set so that the graphic information input immediately before the graphic information of (which does not exist in this case) is arranged next to the graphic information input immediately after the graphic information of. Before the graphic information (the graphic information) input immediately after the graphic information of, the pointer is set so that the graphic information (immediately does not exist in this case) input immediately before (1211).

 This is the end of the procedure for deleting graphic information.

As described above, when deleting a node from the tree, only one path passes through the branch divided into two for each node. That is, for the same reason as the tree generation, the number of nodes traced is almost lo when the total number of nodes (total number of graphic information) is K.
It turns out that it is g ₂ K.

The interactive figure editing program of this system is started by an operator, and when an instruction to edit figure information is received, figure information in the editing range is searched from all figure information at high speed by the tree search processing, Display on the display.

In addition, when the graphic information is overlapped at the time of display and the displayed graphics depend on the drawing order, the retrieved node pointers are held in an appropriate array, sorted in the drawing order, and then displayed. Furthermore, it can be used to restore the display screen by deleting.

Further, when new graphic information is generated by drawing a graphic, the circumscribed rectangular coordinates are calculated based on the new graphic information, and the graphic information is generated using the node generation processing.

When deleting the already generated graphic information, the graphic information near the designated coordinates is searched at high speed by an appropriate means.

In this case, a small rectangle containing the specified coordinate position (for example, if the whole space is [0,1024] x [0,1024] and the specified coordinate position is x, y, [x-8, y- 8] × [x +
8, y + 8]) can be used to search for candidate figures.

Further, in order to further improve the search accuracy, it is possible to calculate the distances from the designated coordinate points to a plurality of candidate figures and prioritize them.

According to this embodiment, repeated retrieval of a large amount of graphic information can be performed extremely quickly, and a comfortable editing work environment can be provided to the operator.

Further, it is obvious that the present invention can be applied to the case of outputting graphic information for LBP or plotter, and it is possible to select and output any range in a huge amount of graphic information at high speed.

Furthermore, instead of inputting graphic information interactively, a large amount of graphic information can be input all at once through a medium such as a card or a floppy disk, and tree generation time (assuming that the number of input information is K is approximately Klog ₂ K). Is sufficiently short, that is possible.

Further, as shown in FIG. 3, even when the tree cannot be stored because the capacity of the secondary storage device 21 is insufficient, the tree is constructed and edited by the tree generation program 22 in the main memory at the start of conversation editing. It is also possible to secure responsiveness during operation.

The structure of the tree described in this embodiment focuses on the x-coordinate of a rectangle, but the coordinate system of all graphic information is [0,
N] × [0, M], and if M >> N, then obviously y
The tree should be constructed focusing on the coordinates. This way you can keep the tree level low. It is also possible to extend the coordinate system [0, N] × [0, M] to an arbitrary real number space.

(Effects of the Invention) As is apparent from the above description, the introduction of the binary tree in the method of searching and editing and outputting the graphic information using the coordinate as a key makes it possible to obtain a high-speed response that was impossible in the past. Became possible.

That is, assuming that the conventional response time is kK, (k +
k ') can be shortened to log ₂ K. However, in the above, K is the number of graphic information, k is the overhead of search processing, and k'is the overhead of tree search.

Furthermore, since the search is speeded up and the time required for the search is shortened, it is possible to manage a large amount of graphic information in a unified manner, and the editing and output of the arbitrary range are secured by the conventional technology. Since it can be secured almost unchanged from the response time, higher operability can be achieved.

As a result, the performance of the graphics system will be dramatically improved.

[Brief description of the drawings]

FIG. 1 is a diagram showing an outline of the structure and graphic information of a binary tree which is an essential part of the present invention, and FIGS. 2 and 3 are block diagrams showing a schematic configuration example of a graphics system to which the present invention is applied. FIG. 4 is a flowchart showing a tree searching process according to the present invention, FIG. 5 is a flowchart showing a tree generating process, FIG. 6 is a flowchart showing a process of deleting a node from a tree, and FIG. 7 is a new binary tree. The figure which shows the change state of the tree structure at the time of creation, 8th-
Fig. 10 is a diagram showing the state of change in the tree structure when a binary tree node is added in accordance with the addition of drawing information, Fig. 11 is a diagram showing the binary tree search path, and Fig. 12 is accompanying the deletion of drawing information. FIG. 13 is a diagram showing a changed state of the tree structure when a node of the binary tree is deleted, and FIG. 13 is a diagram showing a coordinate system for explaining a procedure for searching for graphic information using the binary tree. 1 ... Overall structure of tree, 2 ... Overall structure of graphic information,
3 ... Tree node, 4 ... Graphic information, 7 ... Enclosing rectangle surrounding graphic information, 8 ... Section [0, N] corresponding to root node, 11 ... Graphic display, 12 ...
… Keyboard, 13… Computer, 14… Mouse, 15…
… Light pen, 16 …… Digitizer, 17,21 …… Secondary storage device, 18 …… LBP, 19 …… Plotter, 20 …… Batch type input device, 22 …… Tree generation program

Claims (2)

(57) [Claims] 1. A means for inputting and storing graphic information, a means for displaying the graphic information at a designated position, and coordinates of a pair of diagonal vertices of a rectangle surrounding and surrounding the graphic information. Means for calculating and storing for each figure, and means for generating a binary tree based on the normalized values of the pair of diagonal vertex coordinates of the rectangle for each figure on one coordinate axis. And each node of the binary tree has a pair of diagonal vertex coordinates of a rectangle k ₁ (n), k ₂ (n) corresponding to a certain node n.
{However, k ₁ (n) ≦ k ₂ (n)}, the section corresponding to the node n is (α, β), the node is a, its left node is b, and its right node is c. In this case, the graphic editing apparatus is characterized in that the nodes a, b, and c satisfy the following conditions. B) Nodes a, k ₁ (a) ≦ k ₁ (b), k ₁ (a) ≦ k ₁ (c), α ≦ k
₂ (a) ≦ β, b) node b, α ≦ k ₂ (b) ≦ (α + β) / 2, c) node c, (α + β) / 2 <k ₂ (c) ≦ β, 2. The graphic editing apparatus according to claim 1, wherein the binary tree is not stored together with the graphic information and is generated at the start of an editing operation.