JPH07200800A - Image deforming method and device therefor - Google Patents

Abstract

PURPOSE:To freely and smoothly deform the image of a bit array form with a small memory capacity. CONSTITUTION:When the vertexes of plural small polygons at the external frame of a deforming object are according to each parameter of a Bezier curve and the vertex (lattice point (p, q)) of one internal small polygon is moved, the vertexes of small other polygons are moved so that the whole of the deforming object may be smoothly deformed and the vertexes of the small other moved polygons are calculated based on the vertexes of the small polygon to be a reference after the moving. At this time, by using the both ends coordinates of the curve (xb1, yb1), (xb4, yb4), (xc1, yc1) and (xc4, yc4) and coordinates controlling the bending way of the curve (xb2, yb2), (xb3, yb3), (xc2, yc2) and (xc3, yc3) as the parameters of the curve and using the coordinate (xa, ya) after the lattic point is moved, the shape after a deformation corresponding to each calculated vertex is determined and an original image is deformed so as to correspond to the data of small polygon after the deformation.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an image transformation method and an apparatus therefor, and more specifically, it is composed of dots such as characters used in animation, games, background data, and the display color number for each dot. Alternatively, the present invention relates to an image transforming method for transforming an image by changing an array of so-called bit array format image data having a palette number, and an apparatus for realizing the method.

[0002]

2. Description of the Related Art Conventionally, image data in a bit array format is often used in animation, games, etc., and characters and background data are displayed by this image data. The image data in the bit array format is composed of dots, and each dot has a display color number or a palette number.

[0003]

By the way, in the conventional image transforming method, when a character or background is moved or changed in animation, game, etc., completely different image data is stored in the memory in advance, For example, when a motion is given, the image data itself on the memory is redisplayed at certain intervals or when the shape is changed, for some reason. Therefore, there is a drawback that it consumes a lot of memory. Further, simple transformation processing such as image enlargement / reduction processing or transformation from a quadrilateral of a certain shape to a quadrilateral of a different shape (for example, transformation from a square to a trapezoid) is often used in conventional games. However, the degree of deformation was limited, and smooth deformation was difficult. In addition, the range in which transformation is used is limited (it cannot be transformed freely), so there is no choice but to adopt a method of storing a large amount of data in memory in advance.
In this respect, the cost was high.

SUMMARY OF THE INVENTION Therefore, an object of the present invention is to provide an image transforming method and an image transforming apparatus capable of freely and smoothly transforming an image in a bit array format with a small memory capacity.

[0005]

In order to achieve the above object, the image transforming method according to the invention of claim 1 divides a transform object having image data in a bit array format into a plurality of small polygons, and The small polygons are transformed into different small polygons according to a predetermined transformation process, and the array of image data in the bit array format included in the small polygons before the transformation is processed for each small polygon according to a predetermined data conversion process. The whole image data after the change is created by sequentially changing so as to correspond to the data of the small polygon after deformation, and in the deformation processing of the small polygon,
The vertices of any small polygon on the outer frame to be deformed and the vertices of any small polygon on the inside of the deformable object are placed at least at any position where the outer frame is reconstructed after the deformation and at least again inside. When each of the small polygons is moved to an arbitrary position, the vertices of the other small polygons are moved according to the movement of the arbitrary small polygon, and the vertices of the other small polygons moved are moved to the plurality of small polygons. It is characterized in that it is calculated based on the vertices of the polygon after the movement, and each small polygon is deformed corresponding to the calculated vertices. In the image transforming method according to the second aspect of the present invention, a plurality of facing sides forming the outer frame to be transformed are selected, and a plurality of small polygon vertices on each of the selected sides are set to the respective sides. According to a predetermined curve parameter corresponding to, at least after the deformation, move to an arbitrary position that constitutes a plurality of opposite sides, and at the same time, at least after the deformation, revert the vertices of any small polygon inside the deformation target. When moved to an arbitrary position that is located inside, the vertices of other small polygons are moved according to the movement of the arbitrary small polygons, and the vertices of the other small polygons that have been moved are set to the plurality of It is characterized in that the small polygons are calculated based on the moved vertices, and each small polygon is deformed corresponding to the calculated vertices.

In a preferred embodiment, the predetermined curve parameter for moving and arranging the vertices of a plurality of small polygons in the transformation process is defined by at least one of Bezier curve and trigonometric function. It may be any parameter that is set. For example, as described in claim 4, the predetermined transforming process is a coordinate transforming process. In this coordinate transforming process, the coordinates of the vertices of each of the divided small polygons are obtained, and then each transformed small polygon is processed. Even if the divided small polygons are transformed into different small polygons by calculating the coordinates of the vertices of the polygon and determining the shape of the different small polygons after transformation based on the calculated coordinates. Good. For example, as described in claim 5, the predetermined data conversion process is a process of dividing the image data in the bit array format included in each small polygon to be transformed into a plurality of lines, and each of the divided lines. Of calculating the end points on the deformed small polygon, and enlarging or reducing each of the divided lines according to the size of the corresponding line of the deformed small polygon, Alternatively, a process of sequentially transferring and arranging the reduced lines with the end points on the corresponding lines of the deformed small polygon as the starting points may be included.

For example, as described in claim 6, the processing for calculating the end points is performed on the basis of the positions of the end points of the lines before and after the deformation, without changing the positions of the end points of the lines before the deformation. The process of sequentially accumulating the error when the position of the end point of the corresponding line of the deformed small polygon is calculated, and the position of the end point of the line is changed only when the error exceeds a predetermined value. And a process of subtracting a constant value from the calculated error. For example, as described in claim 7, the process of enlarging or reducing the number of image data in the bit array format included in the lines before and after the transformation and the image data in the bit array format included in the line after the transformation is performed. Based on the process of accumulating errors when sequentially designating and arranging each image data in the bit array format included in each line before deformation in the line after deformation,
When this error exceeds a predetermined value, the currently specified image data is transferred to the transformed line to specify the next image data, and the operation of subtracting a constant value from the accumulated error is performed. You may make it have the process repeated until an error becomes below a predetermined value, and the process of transferring the said designated image data to a line after a deformation | transformation, and arrange | positioning when the said error is below a predetermined value.

For example, according to the eighth aspect of the present invention, in the transfer processing, each line before deformation is designated based on the number of lines before and after deformation, and the corresponding line of the small polygon after deformation is designated. The process of accumulating the error when sequentially arranging at the position of, and when this error exceeds the predetermined value, the currently specified line is transferred and arranged as the modified small polygon line and the next line is specified. In addition, a process of subtracting a constant value from the accumulated error is repeated until the error is equal to or less than a predetermined value, and when the error is equal to or less than a predetermined value, the designated line is a modified line. And a process of arranging the transfer may be included.

According to a ninth aspect of the present invention, there is provided an image transformation apparatus which divides a transformation target having image data in a bit array format into a plurality of small polygons, and an arbitrary small polygon on an outer frame of the transformation target. When the vertices of and the vertices of any small polygon inside the deformation target are moved to at least any positions that again form the outer frame after deformation and at least any positions that are inside again, The vertices of the other small polygons are moved according to the movement of the arbitrary small polygon, and the vertices of the moved small polygons are calculated based on the moved vertices of the small polygons. Deformation means for transforming each small polygon divided by the dividing means into different small polygons corresponding to the calculated vertices, and an array of image data in the bit array format included in the small polygon before transformation are provided for each small polygon. For each polygon, According to another conversion process, characterized in that and an image data generation means for generating an entire image data after changed sequentially changed to correspond to the data of the small polygons after deformation.

According to a tenth aspect of the present invention, in the image transforming apparatus, the transforming means selects a plurality of facing sides forming an outer frame to be transformed, and selects a plurality of small polygons on each of the selected sides. According to the predetermined curve parameters corresponding to each side, the apex is moved to an arbitrary position that forms at least a plurality of sides that face again after deformation, and the apex of any small polygon inside the deformation target. Is deformed at least after the deformation to an arbitrary position that is located inside again. Also,
As a preferred embodiment, for example, as described in claim 11,
The predetermined curve parameter for moving and arranging the vertices of the plurality of small polygons in the deforming means may be an arbitrary parameter defined by at least one of Bezier curve and trigonometric function. For example, as described in claim 12, the transforming means includes coordinate transforming means capable of performing a predetermined transforming process of transforming each small polygon divided by the dividing means into different small polygons. , The coordinates of the vertices of the divided small polygons are calculated, the coordinates of the vertices of the deformed small polygons are calculated, and the shapes of the different small polygons after the deformation are determined based on the calculated coordinates. By doing so, each of the divided small polygons may be transformed into a different small polygon.

For example, as described in claim 13, the image data creating means is provided with a data converting means capable of executing the predetermined data converting process, and the data converting means applies to each small polygon to be deformed. A means for dividing the included image data in the bit array format into a plurality of lines, a means for calculating the end points of the respective divided lines on the deformed small polygon, and a means for deforming each of the divided lines. A means for enlarging or reducing according to the size of the corresponding line of the subsequent small polygon, and transferring this enlarged or reduced line sequentially starting from the end point on the corresponding line of the deformed small polygon. And means for arranging. For example, as described in claim 14, the means for calculating the end points is based on the positions of the end points of the pre-deformation line and the post-deformation line and does not change the positions of the end points of the pre-deformation lines. A means for sequentially accumulating the error when the position of the end point of the corresponding line of the small polygon, and the position of the end point of the line are changed only when this error exceeds a predetermined value,
Means for subtracting a constant value from the accumulated error.

For example, as described in claim 15, the means for enlarging or reducing is image data in bit array format included in lines before and after transformation and image data in bit array format included in lines after transformation. And a means for accumulating the error when sequentially designating and arranging each image data of the bit array format included in each line before transformation on the line after transformation, and this error exceeds a predetermined value. Sometimes, the currently specified image data is transferred to the transformed line, and the next image data is specified.
Means for repeating an operation of subtracting a constant value from the accumulated error until the error becomes a predetermined value or less; and, when the error is a predetermined value or less, transferring the designated image data to the transformed line And a means for arranging the same. For example, as described in claim 16, the transfer means specifies each line before deformation based on the number of lines before and after deformation and positions the corresponding lines of the small polygon after deformation. A means for accumulating the error when sequentially arranged, and when this error exceeds a predetermined value, the currently specified line is transferred and arranged as a deformed small polygonal line to specify the next line, A means for repeating an operation of subtracting a constant value from the accumulated error until the error becomes a predetermined value or less; and a transfer arrangement in which the designated line is a modified line when the error is a predetermined value or less. And a means for doing so.

For example, as described in claim 17, a display means for displaying the transformed image data created by the image data creating means may be further provided. For example, as set forth in claim 18, there is provided a modification mode designating unit for designating a modification mode when the modification target is modified,
The deforming means may deform the small polygons into different small polygons based on the output of the deforming mode designating means. For example, as described in claim 19, the modification mode designating means specifies a first modification mode for the modification target and a second modification switch for designating the modification target as the second modification mode. You may have and. For example, as described in claim 20, the image data in the bit array format to be transformed, the division data indicating how to divide the transformation target, and the how to transform each of the divided small polygons are shown. Storage means for storing the deformation data, and image deformation control means for reading out each data stored in the storage means and controlling the image deformation when the deformation mode is designated by the deformation mode designating means. May be.

[0014]

In the present invention, first, a transformation target having image data in the bit array format is divided into a plurality of small polygons, and each small polygon is transformed into different small polygons according to a predetermined transformation process (for example, coordinate conversion process). Each transforms. At this time, in the small polygon deforming process, the vertices of any small polygon on the outer frame to be deformed and the vertices of any small polygon inside the target to be deformed are reconfigured to form the outer frame at least after the deformation. When moving to an arbitrary position such as that described above and at least to an arbitrary position that is located inside again, the vertices of other small polygons are moved according to the movement of the arbitrary small polygon (for example, the deformation target). The vertices of the other small polygons are moved so that the whole is smoothly deformed), and the vertices of the other small polygons that have been moved are calculated based on the vertices after the movement of the arbitrary small polygon. Each small polygon is deformed corresponding to the vertex. Then, the array of the image data in the bit array format included in the small polygon before deformation is sequentially changed for each small polygon so as to correspond to the data of the small polygon after deformation according to a predetermined data conversion process. The whole image data after the change is created.

Therefore, since the image to be transformed is subjected to the transformation process for each small polygon, it is not necessary to previously have the totally different image data as in the prior art, and the image of bit array format can be formed with a small memory capacity. You can freely change the arrangement of data. Further, since the transformation target is divided into a plurality of small polygons and the transformation process is performed for each small polygon, there is a degree of freedom in the transformation, and the image can be smoothed even if there is not much data in memory beforehand. It can be transformed. In particular, the vertices of any small polygon on the outer frame to be deformed and the vertices of any small polygon on the inside of the deformable object are at least repositioned at least at any position such that the outer frame is formed again after the deformation. It is not necessary to have the position data (for example, the coordinates) of the vertices of all the small polygons after the deformation by using the deformation method in which each is moved to an arbitrary position such that it is located inside. Therefore, it is possible to perform smooth image deformation with a small amount of deformation data.

According to another aspect of the invention, a plurality of facing sides forming the outer frame to be deformed are selected, and a plurality of small polygon vertices on each selected side are respectively selected. According to a predetermined curve parameter corresponding to the side of, at least after the deformation, move to an arbitrary position that forms a plurality of opposite sides, and at least deform the vertex of any small polygon inside the deformation target. By using a modification method that moves to an arbitrary position so that it will be located inside again later, it is sufficient to have only a few points (for example, 4 points) of coordinates as the curve parameter, and all the small values after the modification can be used. Position data (eg, coordinates) of polygon vertices
You don't have to have one. Therefore, it is possible to perform smooth image deformation with a small amount of deformation data. Furthermore, when this transformation method is used, the shape of the outer frame to be transformed can be changed, and the small polygon inside can be transformed into an arbitrary shape, so the outer shape (for example, size) of the image data can be changed, and This is effective when you want to change the shape.

[0017]

Embodiments of the present invention will be described below with reference to the drawings. Description of Principle of the Present Invention First, the principle of the present invention will be described. FIG. 1 is a diagram showing the principle of the polygon division transformation method. FIG. 1A shows a transformation target having image data before transformation, and the transformation target image data is in a bit array format, and the image (picture) of the “eye” is shown.
It represents A. In order to transform this image data, first, the entire transformation target is divided into 4 vertically and 6 horizontally and a total of 2
Create four small rectangles (1), (2), (3), ... (24). At this time, each small rectangle (1), (2), (3), ... (2
The image data of 4) is composed of a plurality of dots, and each of the plurality of dots has a display color number or a palette number. And each small rectangle (1), (2), (3), ...
..The image in every (24) is displayed by the whole dot. Then, the small rectangles (1), (2), (3), ... (24) are subjected to a predetermined transformation process (for example, coordinate conversion process described later) so that the entire transformation target is smoothly transformed. ) To Figure 1
Different squares (1) ', (2)', as shown in (b),
It is transformed into (3) ', ... (24)'. For example, as shown in FIG. 2, the small rectangle (6) is transformed into a quadrangle (6) ', and the small rectangle (1) is transformed into a quadrangle (1)'.

In this process, each small rectangle (1), (2), (3),
.. (24), the array of the image data in the bit array format included in each small rectangle is modified according to a predetermined data conversion process (for example, so-called line pasting process described later). That is, the dot arrangement changes depending on the degree of deformation. Therefore, when the deformed squares (1) ', (2)', (3) ', ... (24)' are combined as a whole, as shown in FIG. An image (picture) B of “” is obtained. In this case, each small rectangle (1), (2), for the array of image data to be transformed,
(3) The transformation processing is performed for each (24), so there is no need to have completely different image data in advance as in the past, and a bit array image can be freely created with a small memory capacity. It can be transformed. In addition, the transformation target is a plurality of small rectangles (1),
It is divided into (2), (3), ... (24), and each small rectangle (1),
(2), (3), ... Since the deformation process is performed for each (24), there is a degree of freedom in the deformation, and the image can be smoothly deformed even if there is not much data in memory beforehand. It will be possible.

In particular, an arbitrary facing side (may be a plurality of facing sides) forming the outer frame to be deformed is selected, and the vertices of a plurality of small polygons on each selected side are
If you use the deformation method that moves according to the curve parameters corresponding to each side, and moves the vertices of any small polygon inside the deformation target to at least any position that is inside again after deformation , All the transformed rectangles (1) ', (2)', (3) ', ... (2
It is not necessary to have the position data (for example, coordinates) of 4) ′, and it is possible to perform smooth image deformation with a small amount of deformation data. Furthermore, when this transformation method is used, the shape of the outer frame to be transformed can be changed, and the small polygon inside can be transformed into an arbitrary shape, so the outer shape (for example, size) of the image data can be changed, and The shape can be changed.

Next, a specific embodiment of the present invention based on the above principle will be described. Configuration of Image Deformation Apparatus FIG. 3 is a configuration diagram showing a first embodiment of an image transformation apparatus for realizing the image transformation method according to the present invention. In FIG. 3, the image transformation apparatus is roughly divided into a CPU 31 and an input operator 3.
2. Storage device 33, image signal generation circuit (Video Display
Prosseser: VDP) 34, VRAM 35 and TV display 36. CPU
Reference numeral 31 controls the entire apparatus. When an image deformation command is input from the input operator 32, it is stored in the storage device 33 based on the control program stored in the internal memory so as to correspond to the command information. The image data 41 in the bit array format as the transformation target is read out by the VDP 34
In addition to outputting the image data 41 to the VDP 34, the image data 41 is subjected to the polygon division transformation process, and the transformed image data in the bit array format is output to the VDP 34. Also, the CPU 31
Has an internal register 31a.
In a, the coordinates of the grid points of each small rectangle as shown in FIG. 4 to be described later are stored.

The input operator (deformation mode designating means) 32 is operated by an operator and designates how the array of image data in the bit array format is to be deformed (that is, gives an opportunity to perform the deformation). (For the purpose) and a second deformation switch 52. The first transformation switch 51, for example, transforms the original image represented by the grid point coordinates 42 before the transformation into a transformation (transformation data 1) like the first transformed image represented by the grid point coordinates 43 after the transformation. ) Is output. The second transformation switch 52, for example, transforms the original image represented by the lattice point coordinates 42 before transformation into a second transformed image represented by the lattice point coordinates 44 after transformation (deformation data 2 ) Is output. Each of the transformation switches 51 and 52 may be a push switch that can be operated independently, or a switch board including a plurality of switches, a keyboard, or the like. As the input operator 32, a mouse, a trackball, or the like may be used instead of the switch board or the like.

The storage device (storage means) 33 stores the image data 41 in the bit array format to be deformed and the grid point coordinates before deformation (small coordinates before deformation) indicating how to divide the deformation target (original image) into rectangles. (The coordinates of the vertices of the polygon) 42, the coordinates of the grid points after the deformation corresponding to the deformation data 1 indicating how to deform each of the small rectangles that have been divided into rectangles (the coordinates of the vertices of the different small polygons after the deformation) 43 and the transformed grid point coordinates (the coordinates of the vertices of different small polygons after transformation) 44 corresponding to the transformation data 2 indicating how to transform each of the small rectangles divided into rectangles are stored. For example, the grid point coordinates 43
Corresponds to the first deformed image, the grid point coordinates 44 correspond to the second deformed image, and the commands for processing these deformed images are the first deforming switch 51 and the second deforming switch 52, respectively. Is output from. VDP34 is a CPU
The image data in the bit array format before the transformation and the image data in the bit array format after the transformation given from 31 are stored in the VRAM 3
Write to 4. A semiconductor memory, for example, is used as the VRAM 34, and stores an image to be displayed on a screen-by-screen basis. The image data written in the VRAM 34 is displayed on the TV display (display means) 36. C above
PU31 is a dividing means, a deforming means, an image data creating means,
The coordinate transformation means and the data transformation means are constituted, and further the image deformation control means is constituted.

Here, in this embodiment, as shown in FIG. 4, the transformation target having the image data in the bit array format before transformation is divided into a large number of small rectangles. In this case, the portions corresponding to the vertices of each of the rectangle-divided small rectangles will be referred to as grid points. In the example of FIG. 4, the transformation target is vertically divided into m parts and horizontally divided into n parts. Therefore, the transformation target is divided into (m × n) small rectangles, and the small rectangles (0, 0) and small rectangles (0, 1) go from the upper left end to the lower right end. , Small rectangle (0, 2),
..... Represented as small rectangles (m-1, n-1), respectively. Further, the grid point at the upper left end of the transformation target is called a grid point (0, 0), and the grid point on the right side thereof is called a grid point (0, 1). , Grid point (0, 3). Therefore, the grid point at the upper right end becomes the grid point (0, n). Next, the grid point immediately below the grid point (0, 0) is called a grid point (1, 0), and hereinafter, the grid point (2, 0) and the grid point (3, 0) are also called downward. I will decide. Therefore, the grid point at the lower left corner becomes the grid point (m, 0). The grid point at the lower right corner is the grid point (m, n).

The internal register 31a of the CPU 31 has the configuration shown in FIG.
The grid point coordinates of each small rectangle shown in are stored, and the state is shown in FIG. In FIG. 5, the internal register 31
a is each small rectangle (0, 0), small rectangle (0, 1), small rectangle (0, 2), ... Small rectangle (m-1, n-1)
The coordinates are stored as follows as the coordinates of the grid point corresponding to. The coordinates of each grid point are represented by two numerical values based on the X axis (horizontal direction) and the Y axis (vertical direction). X coordinate of grid point (0,0) Y coordinate of grid point (0,0) X coordinate of grid point (0,1) Y coordinate of grid point (0,1) X coordinate Y coordinate of grid point (m, n)

On the other hand, the storage device 33 stores the grid point coordinates 42 before the deformation which indicates how the object to be transformed (having the original image data) is divided into rectangles. The grid point coordinates 42 are stored in the CPU 31. Small rectangles (0, 0), small rectangles (0, 1), small rectangles (0, 2), ... Small rectangles (m-1, n-) stored in the internal register 31a of 1)
When shown in correspondence with the respective grid point coordinates of
It will be shown on the right edge of. That is, the two have the following correspondence. X coordinate of grid point (0, 0) ... 100 (grid point coordinate before deformation, the same applies below) Y coordinate of grid point (0, 0) ... 100 X coordinate of grid point (0, 1) ... 110 Y coordinate of grid point (0, 1) ... 100 ... X coordinate of grid point (m, n) ... 160 Y coordinate of grid point (m, n) ... 140

As described above, the storage device 33 stores the grid point coordinates 43 and the second transformation switch 52 when the first transformation image corresponding to the instruction from the first transformation switch 51 is divided into rectangles. Lattice point coordinates 44 when the second modified image corresponding to the command is divided into rectangles are stored. For example, when the first transformation switch 51 is operated,
The transformed grid point coordinates corresponding to the transformation number selected by the switch 51 are the internal register 31 of the CPU 31.
When the second deformation switch 52 is stored in a and the second deformation switch 52 is operated, the grid point coordinates after deformation corresponding to the deformation number selected by this switch 52 are stored in the internal register 31a of the CPU 31. These grid point coordinates 43, 44 are stored in the internal register 31a of the CPU 31 as small rectangles (0, 0), small rectangles (0, 1), small rectangles (0, 0).
2), ... Shown in correspondence with the grid point coordinates of the small rectangle (m-1, n-1), for example, it is represented as shown in the center of FIG. The modification 1 is the first image modification process corresponding to the command from the first modification switch 51, and the modification 2 is the second image modification process corresponding to the command from the second modification switch 52. This is image transformation processing.
Therefore, the grid point coordinates of modification 1 are the grid point coordinates when the first modified image corresponding to the command from the first modification switch 51 is divided into rectangles. Similarly, modification 2
The grid point coordinates are the grid point coordinates when the second modified image corresponding to the command from the second modification switch 52 is divided into rectangles.

Next, the operation will be described. Main Program FIG. 6 is a flowchart showing the main program of the image transformation process. When this program starts, first in step S10, key information fetching processing is performed. This is for inputting operation information of the first deformation switch 51 or the second deformation switch 52 in the input operator 32. Next, in step S12, it is determined whether or not the deformation switch is pressed. If neither switch is pressed, the routine of this time is ended, and step S10 is executed again in the next routine. At this time, for example, a switch flag is provided, and if none of the switches is pressed, the switch flag remains [0]. On the other hand, when any switch is pressed, the switch flag is set to [1].
And the number of the deformation switch pressed in step S14 is determined. After that, the lattice point coordinates after deformation corresponding to the number of the deformation switch pressed in step S16 or step S18 are stored in the internal register 31a of the CPU 31, and then the process proceeds to step S20.

Specifically, when the first deformation switch 51 is pressed, the process proceeds to step S16 and the storage device 33.
Internal coordinate 31a of the CPU 31 by copying the grid point coordinates (that is, the grid point coordinates after deformation corresponding to the deformation data 1) 43 when the first deformed image in the above is divided into rectangles.
It stores in every grid point in. Therefore, if the grid point coordinates before deformation as shown in FIG. 5 are stored, the values of the grid point coordinates 43 are sequentially stored in the internal register 31a as shown below. Lattice points (0,
0) X coordinate ... 90 (lattice point coordinate of deformation data 1, the same applies below) Y coordinate of lattice point (0, 0) ... 100 X coordinate of lattice point (0, 1) ... 105 Lattice point (0 1) Y coordinate ... 95 ... X coordinate of lattice point (m, n) ... 140 Y coordinate of lattice point (m, n) ... 130

On the other hand, if the second transformation switch 52 is pressed, the process proceeds to step S18, where the second transformation image in the storage device 33 is divided into rectangles, that is, the grid point coordinates (that is, transformation data 2 Corresponding lattice point coordinates after deformation) 44
Is stored in the internal register 31a of the CPU 31 for each grid point. Therefore, if the grid point coordinates before deformation as shown in FIG. 5 are stored, the value of the grid point coordinates 44 is stored in the internal register 31a as shown below.
Will be stored in sequence. X coordinate of grid point (0, 0) ... 90 (coordinate of grid point of deformation data 2, the same applies below) Y coordinate of grid point (0, 0) ... 100 X coordinate of grid point (0, 1). 105 Y coordinate of grid point (0, 1) ... 100 ... X coordinate of grid point (m, n) ... 170 Y coordinate of grid point (m, n) ... 140

After step S16 or step S18, the process proceeds to the following step S20, and the image data contained in the small rectangle (i, j) to be processed is read from the image data to be transformed from the storage device 33. Deformation processing of a small rectangle is performed (details will be described later in a subroutine). As a result, the array of image data in the bit array format for the small rectangle (i, j) is transformed, and the transformed image is obtained. The small rectangle (i, j) is, for example, a small rectangle (1) when the transformation target is divided into a plurality of pieces as shown in FIG.
(2), (3), ... It shows a general designated state indicating any one of (24). In the process of step S20, the transformed image data indicated by the small rectangle (i, j) is sequentially transferred to the VDP 34, and as a result,
Finally, the transformed image data corresponding to all the small rectangles (i, j) are combined to obtain a transformed image. Then, in step S22, all small rectangles (i,
It is determined whether or not the image transformation process is performed on j), and N
If it is O, the process returns to step S20 to repeat the same processing. When the image transformation processing is completed for all the small rectangles (i, j), the process exits from step S22 to YES, and this routine is completed. In this way, in steps S20 and S22, the image transformation process is performed for each small rectangle.

Subroutine of Small Rectangle Deformation Processing Next, FIG. 7 is a flowchart showing a subroutine of the small rectangle transformation processing (step S20) of the main program. In this subroutine, in step S30, the coordinates before deformation of the four points around the small rectangle (i, j) are obtained from the grid point coordinates 42 before deformation in the storage device 33. In other words, the four coordinates corresponding to the vertices of the small rectangle to be processed are read from the grid point coordinates 42 before deformation stored in the storage device 33. For example, in the case of a small rectangle (i, j), the vertices are grid points (i, j), (i, j + 1), grid points (i + 1, j), grid points (i + 1, j + 1), and these are The coordinates of the small rectangle.

Then, in step S32, a small rectangle (i,
Processing for obtaining the transformed coordinates of the four surrounding points of j) from the grid point coordinates of the internal register 31a in the CPU 31 is performed.
In other words, four coordinates corresponding to the vertices of the small rectangle to be processed are read from the transformed grid point coordinates stored in the internal register 31a of the CPU 31. For example, similarly, in the case of a small rectangle (i, j), the vertices are grid points (i, j), (i, j
j + 1), grid point (i + 1, j), grid point (i + 1, j
+1), which are the coordinates of the quadrangle after the transformation.
In steps S30 and S32, processing is performed to transform each small rectangle into a different quadrangle so that the entire image to be transformed is smoothly transformed. This process (corresponding to the transformation process) is a coordinate conversion process. In this coordinate conversion process, the coordinates of the vertices of the divided small rectangles are calculated,
Then, the coordinates of the vertices of each small quadrangle after the deformation are calculated so that the entire deformation target is smoothly deformed, and the shape of the different small quadrangle after the deformation is determined based on the calculated coordinates, so that the divided small quadrangle is divided. Each small rectangle is transformed into a different small rectangle.

Next, in step S34, the so-called line pasting method (corresponding to the data conversion process) is performed to modify the array of image data in each small rectangle. The line pasting method divides the array of the image data in the bit array format of each divided small polygon that is the transformation source into a plurality of lines,
Each of the divided lines is sequentially transferred to the corresponding position of each polygon of the transformation destination, and each line is pasted while being enlarged or reduced so as to fit the size of the destination at the time of the transformation. This refers to creating an array of image data for each small polygon. Note that the processing contents of the so-called line pasting method will be collectively described in detail after describing the embodiment (see FIGS. 13 to 30). Specifically, as shown in FIG. 8A, the line pasting method divides an array of image data of a small rectangle C having image data in a bit array format which is a transformation source into a plurality of lines 1 to n. ,
Each of the divided lines 1 to n is pasted as a line 1'to a line n'to a corresponding position of the transformation destination quadrangle D while enlarging or reducing it so as to match the size of the transfer destination. In this way, the original image can be smoothly deformed by performing the image deformation processing by dividing the array of the image data of the small rectangle C into a plurality of lines 1 to line n and attaching them while deforming them. become.

As a result, each small rectangle is transformed into a quadrangle, and finally the image data array corresponding to all the small rectangles (i, j) is transformed to obtain a transformed image. Next, in step S36, the transformed image data is sequentially transferred to the VDP 34. As a result, the transformed image data represented by the small rectangle (i, j) becomes VDP34.
Then, the transformed images corresponding to all the small rectangles (i, j) are finally combined to display the transformed image on the TV display 36. Step S36
After the processing of, returns to the main program.

Lattice Point Calculation Processing of the Present Embodiment Next, the transformation processing which is the characteristic part of the present embodiment (that is, when any one lattice point inside the transformation target is moved, the transformation target is smoothly transformed. Process of moving each other grid point as shown in the figure and calculating the coordinates of each grid point after the movement)
Will be described. First, FIG. 9A shows an example of a transformation target that is the target of this transformation processing, and FIG.
It is shown in (b). As shown in FIG. 9A, the transformation target is divided vertically m (for example, 4 divisions) and horizontal n (for example, 6 divisions) in advance, and a total of m × n (for example, 24) small rectangles. Split into. At this time, the image data of each small rectangle is composed of dots, and each dot has a display color number or a palette number. Then, the image for each small rectangle is displayed by the entire dots.

Now, a plurality of facing sides forming the outer frame to be deformed are selected, and the vertices of a plurality of small polygons on each of the selected sides are defined by predetermined curve parameters corresponding to the respective sides. According to the above, each vertex of one small polygon (lattice point (p, q)) inside the deformation target is moved to an arbitrary position that is inside again at least after the deformation. The process of calculating the coordinates of the vertices of a small rectangle will be described. In this example, the vertices of a plurality of small rectangles in the outer frame to be deformed are gently swollen outward, and the vertices (p, q) of one small rectangle inside are moved downward. Corresponds to the case. Here, in the present embodiment, the following arrangement is made regarding how to represent the grid points and the coordinates of the grid points.
The same applies to the examples described below. For example, in the case of a grid point (p, q), the first symbol indicates the position in the y-axis direction, and the second symbol indicates the position in the x-axis direction. That is, grid point (p, q) = (position in y-axis direction, position in x-axis direction), p corresponds to position in y-axis direction, and q corresponds to position in x-axis direction. On the other hand, the coordinates are displayed in the same manner as generally used in mathematics, with the first symbol indicating the position in the x-axis direction and the second symbol indicating the position in the y-axis direction. Therefore, when the coordinates of the grid point (p, q) are coordinates (xd, yd), xd is the position in the x-axis direction and yd is the position in the y-axis direction. That is, (xd,
yd) = (position in the x-axis direction, position in the y-axis direction).
As described above, since the display methods of the both are reversed, it is necessary to understand so as not to make a mistake in the flowchart described later. For convenience of description, only the coordinates of the corresponding grid point such as a grid point (coordinates: x2, yp) may be displayed as appropriate.

As shown in FIG. 9, the position data can be retained because the position is known in advance as the deformation data.
The position data of the two vertices of these outer frames are the vertices of the small rectangle to be transformed before the transformation shown in (a).
It is represented by the coordinates 1, y1) and (x2, y2). In addition, the position of one small rectangular vertex (p, q) inside the transformation target before transformation is known as transformation data in advance. In addition, the vertices of the small rectangle in the inside serve as a reference for movement, and are hereinafter referred to as movement reference grid points.
Then, when the position is expressed by coordinates, it becomes a grid point (p, q) shown in FIG. The vertices of the small rectangles as the movement reference lattice points after the deformation are referred to as the deformed movement lattice points, and when the position is represented by coordinates, they become lattice points (xa, ya) as shown in FIG. 9B. In addition, FIG.
The positions of the vertices of the small rectangle on the lower side of the outer frame shown in (b) are known in advance, and their position data are (x1, y2), (x
2, y2). The vertices of each small rectangle are referred to as grid points as appropriate. Further, in the description of the drawings, it is assumed that the horizontal direction is x-coordinate and the vertical direction is y-coordinate, and the x-coordinate increases from left to right and the y-coordinate increases from top to bottom in the drawing.

On the other hand, what is possessed as deformation data for moving the outer frame to be deformed in accordance with the curve parameters is necessary for moving the grid points on the outer frame as shown in FIG. 9B. In order to move the parameter of the curve 1 corresponding to the selected one side, the parameter of the curve 2 corresponding to the selected other side required to move the grid point on the outer frame, and the internal grid point It is each data about the internal movement reference lattice point (p, q) that performs the necessary movement and the coordinate (xa, ya) after the movement of the movement reference lattice point. In this case, the parameters of the curve 1 are the coordinates (xb1,
yb1), (xb4, yb4) and coordinates (xb2, yb2), (xb3, yb3) that control how the curve bends. The parameters of the curve 2 are the coordinates (xc1, yc1), (xc4, yc4) of both ends of the curve.
And the coordinates (xc2, yc
2) and (xc3, yc3).

As shown in FIG. 10, the storage device 33 has a modified data area for storing the above information. X-coordinate of parameter 1 of curve 1 ... xb1 y-coordinate of parameter 1 of curve 1 ... yb1 x-coordinate of parameter 2 of curve 1 ... xb2 y-coordinate of parameter 2 of curve 1 ... yb2 of parameter 3 of curve 1 x coordinate ... xb3 y coordinate of parameter 3 of curve 1 ... yb3 x coordinate of parameter 4 of curve 1 ... xb4 y coordinate of parameter 4 of curve 1 ... yb4 x coordinate of parameter 1 of curve 2 ... xc1 curve 2 parameter 1 y coordinate ... yc1 curve 2 parameter 2 x coordinate ... xc2 curve 2 parameter 2 y coordinate ... yc2 curve 2 parameter 3 x coordinate ... xc3 curve 2 parameter 3 y coordinate Coordinates ... yc3 x coordinate of parameter 4 of curve 2 ... xc4 y coordinate of parameter 4 of curve 2 ... yc4 Internal grid point to move ... lattice point (p, q) move y coordinate ...... ya after the movement of the x-coordinate ...... xa moving reference lattice points after the movement of the quasi-lattice points

FIG. 11 is a flow chart showing the routine of the lattice point coordinate calculation processing after the transformation. This routine
Select a plurality of facing sides (here, the upper side and the lower side) that make up the outer frame to be deformed, and set the vertices of the small polygons on each of the selected sides to a predetermined value corresponding to each side. While moving according to the curve parameters,
One small polygon (lattice point (p, p,
q)) is moved to an arbitrary position so that it is located inside again at least after the deformation, and the vertices of other small polygons are moved so that the whole deformation target is smoothly deformed, and the other moved The vertices of the small polygon are calculated based on the vertices of the arbitrary small polygon after the movement (appropriately referred to as deformed moving grid points). Then, the shape of each deformed small polygon is determined corresponding to each calculated vertex, and the original image is sequentially deformed so as to correspond to the deformed small polygon. Will be created.

First, a method of generating a Bezier curve will be described. As shown in FIG. 12, the coordinates (x1,
If y1), (x4, y4) and the coordinates (x2, y2), (x3, y3) that control the bending of the curve are determined, Bezier curves as shown in FIGS. 10
It is possible to draw 1, 102. In the case of a Bezier curve, its coordinates (x, y) are expressed by equations (1) and (2) below.
It can be calculated by a formula. ^{x = (1-t) 3} · x1 + 3t · (1-t) 2 · x2 + 3t 2 · (1-t) · x3 + t 3 · x4 ...... (1) y = (1-t) 3 · y1 + 3t · (1 -T) ² · y2 + 3t ² (1-t) · y3 + t ³ · y4 (2) where 0 ≦ t ≦ 1 where t = 0 is substituted into the above formulas (1) and (2). Then, x = x1 and y = y1, which represent one end point. Further, when t = 1, when substituting into the equations (1) and (2), x = x4 and y = y4, which represent the other end point.

In this routine, the grid points on the upper outer frame to be deformed are moved according to the parameters of the Bezier curve 1 on the basis of the generation method of the Bezier curve, and on the lower outer frame to be deformed. Other grid point when the grid point in is moved according to the parameter of the Bezier curve 2 and the grid point (p, q) inside the deformation target is moved to the position represented by the coordinates (xa, ya). The process of calculating the coordinates after the movement of will be described. First, the coordinates of the vertices of the outer frame on the upper left side of the transformation target are set to (x1, y1), and the coordinates of the vertices of the outer frame on the lower right side are set to (x2, y2). Step S10
The grid points (0, 0) to (m,
0) and coordinates (0, n) to (m, n) are obtained. This is the coordinates (x1, y1), (x2, y) of the vertices of the outer frame.
It is calculated by proportional calculation according to 2). Then, in step S110, the pointer j is set to [0]. The pointer j is for sequentially designating grid points along the x-axis direction. Next, the coordinates (xd (j), yd (j)) after movement of the grid point (0, j) (where 0 <j <n) on the upper side of the deformation target in step S112 are shown below ( 3)
It is calculated according to the formula and the formula (4). This grid point (0,
j) is indicated by a triangle mark in FIG. xd (j) = (1-j / n) ³ * xb1 + 3 (j / n) * (1-j / n) ² * xb2 + 3 (j / n) ² * (1-j / n) * xb3 + (j / N) ³ · xb 4 (3) yd (j) = (1-j / n) ³ · yb 1 + 3 (j / n) · (1-j / n) ² · yb ² + 3 (j / n) ² · ( 1-j / n) · yb3 + (j / n) 3 · yb4 ...... (4)

Since j = 1 in the first routine, the coordinates (xd (1), yd after movement of the grid point (0, 1) are moved.
(0)) is calculated according to equations (3) and (4). The coordinate position of this grid point (0, 1) is indicated by a mark in FIG. 9 (b). Next, in step S114, the grid point (m, j) on the lower side of the transformation target (where 0 <
Coordinates after movement of j <n) (xe (j), ye (j))
Is calculated according to the following equations (5) and (6). This lattice point (m, j) is indicated by a triangle mark in FIG. 9 (b). xe (j) = (1-j / n) ³ * xc1 + 3 (j / n) * (1-j / n) ² * xbc2 + 3 (j / n) ² * (1-j / n) * xc3 + (j / N) ³ · xc4 (5) ye (j) = (1-j / n) ³ · yc1 + 3 (j / n) · (1-j / n) ² · yc2 + 3 (j / n) ² · ( 1-j / n) · yc3 + (j / n) 3 · yc4 ...... (6)

Since j = 0 in the first routine, the coordinates (xe (0), ye) after the movement of the grid point (m, 0)
(M)) is calculated according to the equations (5) and (6). The coordinate position of this lattice point (m, 0) is indicated by a triangle mark in FIG. 9 (b). Next, in step S116, the pointer j is incremented (advanced by 1), and in the following step S118, it is determined whether or not the pointer j has become equal to n (that is, whether the right side of the outer frame has been reached).
Since this time is NO, the process returns to step S112 and the same loop is repeated. Therefore, in the next loop, the coordinates (xd (1), yd (0)) after the movement of the grid point (0, 1) on the upper side of the deformation target are calculated according to the equations (3) and (4). At the same time, the coordinate (xe (1), ye) after movement of the grid point (m, 1) on the lower side of the deformation target is moved.
(M)) is calculated according to the equations (5) and (6). Then, by repeating the same loop, j =
When it becomes n, the pointer j advances to the position of the grid point (0, n) and the position of the grid point (m, n), and the coordinates (xd (n), yd (0)) and (xe (n ),
When it is determined that each of ye (m)) has been calculated, the process proceeds to step S120. In this way, the coordinates (xd (j), yd (0)) after movement of the grid point (0, j) (where 0 <j <n) on the upper side of the deformation target and the lower side of the deformation target Existing grid point (m, j) (where 0 <j <n)
The coordinates (xe (1), ye (m)) after the movement of are all sequentially calculated. As a result, as shown in FIG. 9B, the outer frame upper side of the deformation target can be transformed into a curve according to the parameter of the Bezier curve 1, and the outer frame lower side of the deformation target can be transformed according to the parameter of the Bezier curve 2. It can be transformed into a curved line.

Next, the coordinates (xp1, yp1) of the grid point (p, 0) in the same row as the grid point (movement reference grid point) (p, q) that is inside the deformation target and serves as a reference for movement are set. Move on to the calculation process. In step S120, the coordinates (xp1, yp1) of the grid point (p, 0) in the same row as the internal movement reference grid point (p, q) are calculated according to the following expressions (7) and (8). . xp1 = xb1 · (m−p) / m + xc1 · p / m (7) yp1 = yb1 · (m−p) / m + yc1 · p / m (8) Similarly, inside the deformation target A process of calculating the coordinates (xp2, yp2) of the grid point (p, m) in the same row as the grid point (movement reference grid point) (p, q) that is the reference of movement is performed. That is, in step S122, the coordinates (xp2, yp2) of the grid point (p, m) in the same row as the internal movement reference grid point (p, q) are expressed by the following equations (9) and (1).
It is calculated according to the formula 0). xp2 = xb4 · (m−p) / m + xc4 · p / m (9) yp2 = yb4 · (m−p) / m + yc4 · p / m (10) Calculated grid points (p, 0) The coordinates (xp1, yp1) and the respective grid point (p, m) coordinates (xp2, yp21) are shown in FIG. 9 (b).

Next, in step S124, the pointer j is set to [1]. As a result, this time, the respective grid points from the left side to the right side of the outer frame are sequentially designated by the pointer j along the x-axis direction. Next, in step S126, by moving the internal movement reference grid point (p, q) (represented by ♦ in FIG. 9B), the grid point (p that was on the left side of this grid point (p, q) , J) (where 0 <j <q) coordinates (xf1, yfj) are calculated according to the following equations (11) and (12). This grid point (p, j)
Is indicated by a circle in FIG. xf (j) = xp1 * (q-j) / q + x2 * j / q ... (11) yf (j) = yp1 * (q-j) / q + y2 * j / q ... (12)

Then, in step S128, the pointer j is incremented (advanced by 1), and the subsequent step S1.
At 30, it is determined whether or not the pointer j has become equal to q (that is, has reached the position of the movement reference grid point (p, q)). Since this time is NO, the process returns to step S126 and the same loop is repeated. In the first routine, the coordinates (x) of the grid point (p, 1) on the line connecting the grid point (p, 0) on the left side of the transformation target and the movement reference grid point (p, q)
Since f1 and yfp) have been calculated, by incrementing the pointer j, next time, each grid on the line connecting the grid point (p, 0) on the left side of the transformation target and the movement reference grid point (p, q) The coordinates (xfj, yfj) of the point (p, j) are calculated. After that, steps S126 to S13
When j = q is finally obtained by repeating the loop of 0, grid points (p, p) on the line connecting the grid point (p, 0) on the left side of the transformation target and the movement reference grid point (p, q) Since all the coordinates (xfj, yfj) of j) (indicated by a circle in FIG. 9B) are calculated, Y is calculated from step S130.
Exit ES and proceed to step S132.

Next, a process of calculating the coordinates of the grid point (p, j) (where q <j <n) on the right side of the grid point (p, q) is performed. That is, the pointer j is set to q + 1 in step S132. As a result, this time, each grid point from the movement reference grid point (p, q) to the right side of the outer frame is sequentially designated by the pointer j along the x-axis direction. Then, in step S134, the internal movement reference grid point (p,
q) (represented by ♦ in FIG. 9B), the coordinates of the grid point (p, j) (where q <j <n) on the right side of this grid point (p, q) (Xf1, yfj) is calculated according to the following equations (13) and (14).
This lattice point (p, j) is indicated by a ● mark in FIG. xf (j) = xa · (n−j) / (n−q) + xp2 · (j−q) / (n−q) (13) yf (j) = ya · (n−j) / ( n−q) + yp2 · (j−q) / (n−q) (14)

Then, in step S136, the pointer j is incremented (advanced by 1), and the subsequent step S1.
At 38, it is determined whether or not the pointer j has become equal to n (that is, has reached the right side of the outer frame). Since this time is NO, the process returns to step S134 and the same loop is repeated. In the first routine, the moving reference grid points (p,
q) and the coordinates (xf1, yfp) of the lattice point (p, q + 1) on the line connecting the transformation target lattice point (p, n) on the right side.
Then, by incrementing the pointer j, next time, each grid point (p, p, n) on the line connecting the movement reference grid point (p, q) and the grid point (p, n) on the right side of the deformation target The coordinate (xfj, yfj) of j) is calculated. After that, by repeating the loop of steps S134 to S138, when finally j = n, the movement reference grid point (p, q) and the grid point (p,
n), the coordinates (xfj, of the grid point (p, j) on the line connecting
Since all yfj) (indicated by a black circle in FIG. 9B) have been calculated, the process exits YES from step S138 and proceeds to step S140.

Next, the grid point (0, j) and the grid point (p,
j) on each line (that is, on the line connecting the outer frame upper side and the grid point on the same row as the movement reference grid point) (i, j) (where 0 <i <p, 0 ≦ j A process of calculating coordinates (x, y) of ≦ n) is performed. First, step S1
At 40, the pointer j is set to [0]. This allows
The lattice points are sequentially designated by the pointer j along the x-axis direction. Then, in step S142, the coordinates (xd
(J), yd (j)) and the movement reference grid point (p, q)
Coordinates (xf1, yf) of the grid point (p, j) in the same row as
Read 1) together. Next, in step S144, the pointer i is set to [1]. The pointer i is the grid point y
It is specified sequentially along the axial direction. Then, in step S146, the grid point (0, j) and the movement reference grid point (p, q) are calculated according to the following expressions (15) and (16).
The coordinates of the grid point (i, j) on the line connecting the grid points (p, j) in the same row as are calculated. x = xd (j) · (p−i) / p + xf (j) · i / p …… (15) y = yd (j) · (p−i) / p + yf (j) · i / p …… ( 16)

Then, in step S148, the pointer i is incremented (advanced by 1), and the subsequent step S1.
At 50, it is determined whether or not the pointer i has become equal to p (that is, has reached the movement reference grid point (p, q)).
Since this time is NO, the process returns to step S146 and the same loop is repeated. In the first routine, the first point (that is, the uppermost point) on the line connecting the grid point (0, j) and the grid point (p, j) in the same row as the movement reference grid point (p, q) ) Since the coordinates (x, y) of the grid point (1, j) are calculated, by incrementing the pointer i, next time, the grid point (0, j) and the movement reference grid point (p, q) are calculated. )) On the line connecting the grid points (p, j) in the same row as the second (that is, the second) grid point (1,
The coordinates (x, y) of j) are calculated. After that, step S
When i = p is finally obtained by repeating the loop of 146 to step S150, the grid point (p, j) in the same row as the grid point (0, j) and the movement reference grid point (p, q).
Coordinates (x, y) of the grid point (i, j) on the line segment connecting
Since all have been calculated, YES from step S150
To go to step S152.

Then, in step S152, the pointer j is incremented (advanced by 1), and the subsequent step S1.
At 54, it is determined whether or not the pointer j has become equal to n + 1 (that is, has reached the right outer frame side). This time N
Since it is O, the process returns to step S142 and the same loop is repeated. In the first routine, the grid point (0, 1) and the grid point (p, q) in the same row as the moving reference grid point (p, q)
For the line segment connecting 1), the coordinates (x, y) of the grid point (1, j) on the line segment have been calculated, so by incrementing the pointer j, the next time it is shifted to the right by 1 The line segment connecting the grid point (0, 2) and the grid point (p, 2) in the same row as the movement reference grid point (p, q), the grid point (2, j) on the line segment The coordinates (x, y) are calculated. After that, when j = n + 1 is finally obtained by repeating the loop of steps S142 to S154, the grid point (0, j) and the grid point (p, q) in the same row as the grid point (p, q) of the movement reference The coordinates (x, y) of the grid point (p, j) on the line segment connecting j) (FIG. 9).
Since all the grid points indicated by ∇ in (b) have been calculated, the process exits from step S154 to YES and proceeds to step S156.

Next, the grid point (p, j) and the grid point (m,
j)) on each line (that is, on each line connecting the grid points in the same row as the movement reference grid point and the lower edge of the outer frame) (i, j) (where p <i <m, 0 ≦ The process of calculating the coordinates (x, y) of j ≦ n) is performed. First, step S1
At 56, the pointer j is set to [0]. This allows
The lattice points are sequentially designated by the pointer j along the x-axis direction. Next, in step S158, the grid point (p, j) in the same row as the movement reference grid point (p, q)
Coordinates (xf1, yf1) and coordinates (xc (j), yc (j)) of the grid point (m, j) on the lower side of the deformation target
Are read together. Next, in step S160, the pointer i is set to p + 1. As a result, it becomes possible to sequentially designate lattice points from the same line as the movement reference lattice point (p, q) toward the lower side of the outer frame by the pointer i along the y-axis direction. Then, in step S162, the grid point (p, j) and the grid point (m, j) in the same row as the movement reference grid point (p, q) are connected according to the following expressions (17) and (18). The coordinates of the grid point (i, j) on the line are calculated. x = xf (j) · (m−i) / (m−p) + xe (j) · (i−p) / (m−p) (17) y = yf (j) · (m−i) ) / (Mp) + ye (j) · (ip) / (mp) ... (18)

Next, in step S164, the pointer i is incremented (advanced by 1), and the subsequent step S1
At 66, it is determined whether or not the pointer i has become equal to m (that is, has reached the lower edge of the outer frame). Since this time is NO, the process returns to step S62 and the same loop is repeated. In the first routine, the first grid point (p + 1, j) on the line connecting the grid point (p, j) and the grid point (m, j) in the same row as the movement reference grid point (p, q) Since the coordinate (x, y) of 1 is calculated, by incrementing the pointer i, the grid point (p, j) and the grid in the same row as the movement reference grid point (p, q) will be displayed next time. The coordinates (x, y) of the second (that is, the second) lattice point (2, j) on the line connecting the point (m, j) are calculated.
After that, by repeating the loop of steps S162 to S166, when i = m finally, the grid points (p, j) and the grid points (m, m, in the same row as the movement reference grid point (p, q) j) and the grid point (i,
Since all the coordinates (x, y) of j) have been calculated, the process exits from step S166 to YES and proceeds to step S168.

Next, in step S168, the pointer j is incremented (advanced by 1), and the subsequent step S1
At 70, it is determined whether or not the pointer j has become equal to n + 1 (that is, has reached the right outer frame side). This time N
Since it is O, the process returns to step S58 and the same loop is repeated. In the first routine, the moving reference grid points (p,
grid point (p, 1) and grid point (m,
For the line segment connecting (1) and (1), the coordinates (x, y) of the grid point (1, j) on the line segment have been calculated. Regarding a line segment connecting the grid point (p, 2) and the grid point (m, 2) in the same row as the shifted reference grid point (p, q), the grid point (2, j) on the line segment ) Coordinates (x, y) are calculated. After that, by repeating the loop of steps S158 to S170, when finally j = n + 1, the grid point (p, 1) and the grid point (m, The coordinates (x, y) of the grid point (p, j) on the line segment connecting 1) (Fig. 9).
Since all of the grid points indicated by ▼ in (b) have been calculated, the process exits from step S170 to YES, and this routine ends.

By executing the above routine, the grid points on the upper outer frame to be deformed are moved according to the parameters of the Bezier curve 1, and the grid points on the lower outer frame are moved to the Bezier curve 2. When the vertices of one small polygon inside the transformation target are moved according to the parameters and the vertices of the other small polygonal points are moved, a process of calculating the moved coordinates of the other grid points is performed. In the above process, the grid points on the outer frame on the upper side of the transformation target are moved according to the parameters of the Bezier curve 1, and the grid points on the outer frame on the lower side are moved by the Bezier curve 2.
Although the calculation method of each grid point coordinate when moving according to the parameters of is not limited to the grid points on the upper and lower outer frames, for example, the grid on the left and right outer frames can be used. Even when the point is moved according to the parameter of the Bezier curve, the coordinate after the movement of each grid point can be calculated by the same process.

Next, the processing contents of the so-called line pasting method described above will be described in detail below. Subroutine of line pasting processing The specific contents of the line pasting method (method of transforming a rectangle into an arbitrary rectangle) in step S34 shown in FIG. 7 are as follows. FIG. 13 is a flowchart of a subroutine showing the processing of the line pasting method, and an example of image data to be processed by this subroutine is shown in FIG.
It is shown as (a) and (b). That is, FIG.
(A) shows the original image data before the deformation, and more specifically, into one small rectangular image data (that is, the small rectangular image data before the deformation) obtained by dividing the image data in the bit array format which is the deformation source. Correspond. In the line pasting method described here, as shown in FIG. 14A, an original image composed of 12 pixels in the vertical (Y) direction and 16 pixels in the horizontal (X) direction as small rectangular image data before transformation. Data (rectangle AB
(Represented by CD) is transformed into a quadrangle A'B'C'D 'as shown in FIG. 14 (b). In the transformation process, the original image data is first divided into 12 horizontal lines (line 0 to line 11). Then, the divided lines are sequentially attached to the transformed quadrangle according to the image transformation mode, and a transformed image is obtained.

The above processing will be described while advancing the steps of the subroutine. In this subroutine, first, in step S1100, line end point processing is performed on the side A'B '. This is to obtain the end points A′B ′ of the transformed rectangular line. Note that step S
The processing of 1100 (method for obtaining the position of the side A′B ′) will be described in detail in a subroutine described later. That is, as shown in FIGS. 14A and 14B, it is necessary to pay attention to the following state in the process of sequentially attaching the divided lines to the modified quadrangle according to the image modification mode. is there. One end of each line on side AB is side A '
The other end point on B ′ and on the side DC is the side D ′.
Move over C '. At this time, since the sides AB and A'B 'and the sides DC and D'C' have different lengths, the end points of the lines may overlap on the sides A'B 'and D'C'. Sometimes. This is a portion indicated by a star mark in FIG. 14B, and the lines 5 and 6 on the side A′B ′.
Are overlapping. Also, the same line may have to be attached more than once. This is shown in Fig. 14 (b).
The line 3 and the line 8 on the side D′ C ′ are repeated twice to form the lines 3 and 3 ′ and the lines 8 and 8 ′, respectively.

FIG. 15 shows how the lines are attached twice. FIG. 15A shows original image data before transformation, and more specifically, it corresponds to one small rectangular image data obtained by dividing the image data in the bit array format which is the transformation source. FIG. 15B shows image data of one quadrangle after transformation. After the transformation, the line 3 of the image data before transformation is pasted for two lines as the lines 3 and 3'only 6 dots to the right of the dots in the middle. Lines 5 and 6 of the image data before the deformation are pasted on the same dots from the first dot to the 7th dot (that is, 7 dots on the left side) after the deformation, and line 5 on the 7 dots on the right side thereafter. , Line 6 is attached separately. Note that FIG.
5 to 23 show a small rectangle before deformation and a quadrangle after deformation in a plurality of execution processes when the line pasting method is executed. Specific examples of each process will be described when a subroutine described later is described. Describe.

Then, in step S1102, the side D'C '
The end points of the line are processed. This is to obtain the end point D'C 'of the transformed quadrangular line. The process of step S1102 (method of obtaining the position of the side D'C ') will be described in detail in a subroutine described later. In this way, when the positions of the side A'B 'and the side D'C' where the end points of each line move are obtained, the end point positions of these lines are stored in the internal register 31a of the CPU 31, as shown in FIG. Store the data in an endpoint buffer. In this case, the internal register 31a has two storage areas, an end point buffer on the side A'B 'and an end point buffer on the side D'C'. Then, in each of these end point buffers, the coordinates of the end points of the line and the line number are stored in association with each other. The two end point buffers are used when reading the position of the end point and when determining the drawing position of the line.

Then, steps S1104 to S
At 1110, a process of drawing a line is performed. First, in step S1104, the same line number data is read from the two end point buffers. Next, in step S1106, when there are a plurality of lines having the same line number, the lines are combined so that the number of drawing is minimized. For example, as shown in FIG. 25, when there are three lines having the same line number on the side A′B ′ and two lines having the same line number on the side D′ C ′, the upper side The processing is such that each end point is drawn by one line, and two end points on the side A'B 'and one end point on the side D'C' are drawn by two lines. Next, in step S1108, drawing processing (details will be described later in a subroutine) is performed. Then, step S11
In step 10, it is determined whether or not all lines have been processed. If NO, the process returns to step S1104 to repeat the same processing. Then, when the processes of steps S1104 to S1108 have been completed for all the lines, the process exits from step S1110 to YES and ends the routine. In this way, each small rectangle is transformed into a different quadrangle, and the entire image to be transformed is transformed smoothly.

Subroutine for Line End Point Processing Next, the above steps S1100 and S110.
A subroutine of line end point processing in 2 will be described. FIG. 26 shows line end point processing (step S111).
It is a flowchart of a subroutine showing (process 0). First, side A'which is one end of the line to be pasted
The method of obtaining the position of B'will be described. The method of obtaining the position of the side D'C 'which is the other end point of the sticking line is also the same. In step S1200, the coordinate determination error e1, the line selection error e2, and the current line number are all initialized to [0]. The coordinate determination error e1 is a coordinate determination error used when determining the position of an end point or when determining the drawing position of a line. The line selection error e2 is a line selection error used when selecting a line to be assigned to an end point. This allows
Initially, each error is [0].

Next, in step S1202, the coordinates of the point (A 'or D') at which the processing is started are stored in an area called the current coordinates in the internal register 31a of the CPU 31. For example, side A'B 'that is one end of the line to be pasted
In the process of obtaining the position of, the coordinates of A ′ are stored. On the other hand, in the process of obtaining the position of the side D'C 'which is the other end point of the line to be attached, the coordinates of D'is stored. CPU
As shown in FIG. 24, the internal register 31a of 31 has the following storage areas in addition to the end point buffer. Area for coordinate determination error e1 Area for coordinate determination error increment Δe1 Area for current coordinates Area for line selection error e2 Area for line selection error increment Δe2 Current line number Also, as the storage area for dot selection, There is something like this. Area for dot selection error e3 Area for dot selection error increment Δe3 Area for current dot number

Then, in step S1204, it is determined whether the number of pixels in the Y direction is larger than the number of pixels in the X direction. Now, the side A'which is one end of the line to be pasted
A specific example of obtaining the position of B'is shown in FIG.
16A shows a side AB which is one end point of the line before deformation shown in FIG. 16A, FIG. 16B shows a state of a side A′B ′ which is one end point of the line to be attached, and FIG.
(C) shows changes in the number of pixels in the X and Y directions on the side A'B '. Considering this example, since the side A′B ′ is drawn over 11 pixels in the Y direction and 4 pixels in the X direction, the determination result of step S1204 is YES, and in this case, step S1
Proceed to 206. On the other hand, in the opposite case, the process branches to NO and proceeds to step S1238 shown in FIG. Further, in this case, in the case shown in FIG. 16, when the position where the X coordinate changes when the Y coordinate is changed by 1 from the point A ′ to the point B ′, the changed coordinate is the side A. It is in the position of'B '. Therefore, when 10 dots are laid unconditionally except for the starting point (point A ′) whose position is determined, three positions where the X coordinate changes are obtained as positions where the X coordinate changes.

In step S1206, the coordinate determination error increment Δe1 is initialized to (X pixel number -1) / (Y pixel number -1), and the line selection error increment Δe2 is (original line number -1). The initial setting is / (Y pixel count-1). Step S1200 to Step S120
The necessary initialization is completed by the processing of 6. Next, in step S1208, the current line number and current coordinates are stored in the end point buffer (see FIG. 39). Next, in step S1210, the Y coordinate of the current coordinate is changed. Next, in step S1212, the determination regarding the coordinate determination error e1 is performed as follows. That is, the selection error (initial value = 0) e is determined, and the error increment Δe is added to the selection error e (e = e + Δe). Δe is (number of pixels in X direction-1)
/ (The number of pixels in the Y direction-1).

In this case, since it is for determining coordinates, e
Is set as e1 and Δe is set as Δe1. Then, e1 = e1 + Δe1. It is determined whether this value is larger than 1/2. Then, the error increment Δe1
If the result of adding e1 is e1 ≧ (1/2), the process advances to step S1214 to change the X coordinate of the coordinate of the next hit point (corresponding to the next current coordinate). In this method, an error increment is added to the selection error, and the process is selected depending on whether the result is larger or smaller than 1/2, and the error is corrected when the selection error is 1/2 or more.

By doing so, when the Y coordinate is changed by 1 from the point A'to the point B ', the next coordinate is changed at least when the error increment Δe1 is larger than half of 1. , X-coordinate changing positions are smoothly connected. This method is used as a so-called Bresenham algorithm. Next, in step S1216, error correction is performed to set e1 = e1-1. This is because the selection error becomes 1/2 or more and the next coordinate is changed, so that by subtracting 1 from the next current coordinate, the error increment Δe is added again to start the same determination. Then, it progresses to step S1218. on the other hand,
If the result e1 of adding the error increment Δe1 is e1 <(1/2), the process jumps from step S1214 and step S1216 to step S1218. At this time, the X coordinate of the next hit point remains unchanged. Further, in this case, the selection error e1 is not corrected. Step S1210 above
By executing step S1216, the position of the side A′B ′ which is one end point of the sticking line is determined.

Here, in the case of FIG. 16 (when the position of the side A'B 'which is one end point of the sticking line is determined)
A specific example of will be described. First, the first end point A'is unconditionally determined. At this point, the selection error e is initialized to [0]. Further, from the end point A'to the end point B ', 11 pixels in the Y direction and 4 pixels in the X direction are drawn, so the error increment Δe is Δe = (4-1) /
(11-1) = 0.30. Next, since the selection error e is initially set to e = 0, it is left as it is. When Δe = 0.30 is added as the error increment Δe, e = 0 + 0.
30 = 0.30 <(1/2). Therefore, at this time, the X coordinate of the next hit point is not changed (see FIG. 16).
(See (c)). Since the selection error e is smaller than 1/2, the selection error e is not corrected. Next, Δe = 0.30 as the error increment Δe for the selection error e = 0.30 so far.
If 30 is added, e = 0.30 + 0.30 = 0.60 ≧
Since this is (1/2), the X coordinate of the next hit point is changed (see FIG. 16C). By repeating the above process, the X coordinate is changed at the position of
Finally, as shown in FIG. 16C, the position of the end point B ′ is determined.

On the other hand, if the number of pixels in the Y direction is smaller than the number of pixels in the X direction in step S1204 described above,
7, the process proceeds to step S1238 to change the Y coordinate. That is, in step S1238, the coordinate determination error increment Δe1 is set to (Y pixel number-1) / (X
Initially, the line selection error increment Δe2 is set to (original line number-1) / (X pixel number-1) as well as the pixel number-1). Next, in step S1240, the current line number and current coordinates are stored in the end point buffer (see FIG. 24). Next, in step S1242, the X coordinate of the current coordinate is changed. Next, in step S1244, the determination regarding the coordinate determination error e1 is performed as follows. That is, the selection error (initial value = 0) e is determined, and the error increment Δe is added to the selection error e (e = e + Δe). Δ
e is (the number of pixels in the Y direction-1) / (the number of pixels in the X direction-1). Note that, here, since the coordinate determination is performed similarly, e is set to e1 and Δe is set to Δe1. Then, e1 = e1 + Δe1. It is determined whether this value is larger than 1/2. If the result e1 obtained by adding the error increment Δe1 is e1 ≧ (1/2), the process advances to step S1246 to change the Y coordinate of the next hitting coordinate (corresponding to the next current coordinate). this is,
An error increment is added to the selection error, and the process is selected depending on whether the result is larger or smaller than 1/2. The error is corrected when the selection error is 1/2 or more.

In this way, when the X coordinate is changed by 1 from the point D ′ to the point C ′, the next coordinate is changed at least when the error increment Δe1 is larger than half of 1. , Y-coordinate changing positions are smoothly connected. Next, in step S1248, error correction is performed to set e1 = e1-1. This has a selection error of 1
This is because the Y coordinate of the next current coordinate is changed to / 2 or more, and therefore, 1 is subtracted, and the error increment Δe is added again from the next current coordinate to start the same determination. Then, it progresses to step S1250. On the other hand, the error increment Δe
If the result e1 of adding 1 is e1 <(1/2), the process jumps to steps S1246 and S1248 and proceeds to step S1250. In this case, the next Y to hit
The coordinates remain unchanged. Further, in this case, the selection error e1
Is not corrected. Steps S1242-S above
By executing 1248, the position of the side D′ C ′ that is one end point of the line to be attached is determined.

Here, in the case of FIG. 17 (when the position of the side D'C ', which is the other end point of the pasting line, is determined)
A specific example of will be described. FIG. 17A shows a side DC which is the other end point of the line before deformation, FIG. 17B shows a state of the side D′ C ′ which is the other end point of the line to be attached, and FIG. c) shows changes in the number of pixels in the X and Y directions on the side D'C '. Considering this example, the side D'C 'is drawn over 14 pixels in the Y direction and 5 pixels in the X direction.
When the position where the X coordinate changes when the Y coordinate is changed by 1 from the point D ′ to the point C ′ is obtained, the changed coordinate becomes the position of the side D′ C ′. Therefore, when the 13 dots except the starting point (point D ′) where the position is unconditionally decided, four positions where the X coordinate changes are obtained as the positions where the X coordinate changes.

First, the first end point D'is unconditionally determined.
At this point, the selection error e is initialized to [0]. Also, 1 from the end point D'to the end point C'in the Y direction.
Since it is drawn over 4 pixels and 5 pixels in the X direction, the error increment Δe is Δe = (5-1) / (14-1) =
It is 0.30. Next, since the selection error e is initially set to e = 0, the error is left as it is, and Δ is set as the error increment Δe.
Adding e = 0.30, e = 0 + 0.30 = 0.30
<(1/2). Therefore, at this time, the X coordinate of the next hit point is not changed (see FIG. 17C). Since the selection error e is smaller than 1/2, the selection error e is not corrected. Next, the selection error so far e = 0.
If Δe = 0.30 is added as an error increment Δe to 30,
Since e = 0.30 + 0.30 = 0.60 ≧ (1/2), the X coordinate of the next hit point is changed (FIG. 17).
See c)). By repeating the above process,
, (12) (Note that the numbers with a circle after 10 are difficult to display, so they are represented by parenthesized half-width numbers), the X coordinate is changed, and finally as shown in FIG. , The position of the end point C ′ is determined.

Now, returning to the flowchart of FIG. 27 again, when the end point positions are determined, step S1218 is performed.
Proceed to. In step S1218 to step S1236 and step S1250 to step S1266, of the horizontal lines divided into the side A'B 'and the side D'C',
A process for determining which line end point is to be assigned is performed.
First, as shown by the side A′B ′ in FIG.
The processing contents of allocating the end points of the line to be attached to the side shorter than the original side AB shown in (a) will be described. The number of horizontal lines in the original image data is 12, and the side A'B '
Since the number of lines that can be attached to 11 is 11, the end points of 2 lines among the 12 lines of the original image data overlap on the side A′B ′. The process of selecting overlapping lines is as follows.

In step S1218, the selection error (initial value =
0) e, and the error increment Δe is added to the selection error e (e
= E + Δe). Δe is (the number of lines of the original image-1) / (the number of pixels of the side A'B'-1). In addition, here
Since it is for line selection, e is set to e2 and Δe is set to Δe2. Then, e2 = e2 + Δe2. Next, it is determined in step S1220 whether this value has become larger than 1/2. Then, the error increment Δe
If the result e2 of adding 2 is e2 ≧ (1/2), the process advances to step S1224 to increment the current line number by [1] (that is, advances to the next line number). In this method, an error increment is added to the selection error, and the process is selected depending on whether the result is larger or smaller than 1/2, and the error is corrected when the selection error is 1/2 or more.
By advancing the current line number by 1, the next point on side A'B 'is assigned the endpoint of the next line.

In this way, when the X coordinate is changed by 1 from the point A ′ to the point B ′, at least when the error increment Δe2 is larger than half of 1, the line number is changed to the next line number. Therefore, the changing positions of the line end points are smoothly connected. If e2 is less than 1/2 in step S1220, the process jumps to step S1236. In step S1236, it is determined whether or not all the end points have been processed. If the processing has not been completed for all the end points, the process returns to step S1208 and the same processing is repeated. Therefore, when the error increment Δe2 becomes larger than half of 1, it does not jump to step S1236 but proceeds to step S1224.

After step S1224, error correction is performed in step S1224 to set e2 = e2-1. This is because since the selection error has become 1/2 or more and the line number has been changed to the next line number, by subtracting 1 from the next line number, the error increment Δe is added again and the same determination is started. Next, in step S1228, it is determined again whether the selection error e2 is 1/2 or more. This is because the selection error e2 is again calculated for the result of error correction.
Is to judge the size of. If the selection error e2 is still ½ or more as a result of the error correction, the process advances to step S1230 to store the current line number and the current coordinate in the end point buffer in the internal register 31a of the CPU 31. Next, in step S1232, the line number is incremented by [1] (that is, the line number is advanced to the next line number). Thereby, the end point of the next line is also assigned to the same point on the side A'B '. The end points of the next line are sequentially assigned to the same point until the selection error e2 becomes less than 1/2.

Then, in step S1234, error correction is performed to set e2 = e2-1. This is because the selection error becomes 1/2 or more and the line number is changed to the next line number in the same manner as described above. Therefore, by subtracting 1, the error increment Δe is added again from the next line number to start the same determination. Is.
Then, it returns to step S1228 and repeats the same processing. Therefore, the result of correcting the error (selection error) e
If 2 is still larger than 1/2, the line number is further advanced by 1 and the end point of the next line is assigned to the same point on the side A'B ', and the same is true until the selection error e2 becomes less than 1/2. The point will be assigned the endpoint of the next line.

On the other hand, in step S1228, the error increment Δe
If the result of adding 2 is e2 <(1/2), the process jumps to step S1236. At this time, the line number is not changed to the next line number and remains unchanged. Further, in this case, the selection error e2 is not corrected. Step S
At 1236, it is determined whether or not all the end points have been processed. If the process has not been completed for all the end points, the process returns to step S1208 to repeat the process. As a result, when the X coordinate is changed by 1 from the point A ′ toward the point B ′, the above processing is repeated according to the magnitude of the error increment Δe2. Error increment Δe2 is 1/2
If it is larger, it is changed to the next line number.
By executing the above steps S1218 to S1236, the position of each line end point when the end point of the line to be pasted is assigned to a side shorter than the original side AB such as the side A′B ′ is determined. .

A specific example in the case of FIG. 18 (when one end point of the line is assigned to a side shorter than the original side AB such as the side A'B ') will be described. FIG.
18A shows a side AB which is one end point of the line before deformation, FIG. 18B shows a state of a side A′B ′ which is one end point of the line to be attached, and FIG. Indicates a change in the number of pixels in the X direction and the Y direction on the side A′B ′. First, the end point of line 0 is determined on vertex A '. At this point, the line number is initialized to 0 and the selection error e is initialized to [0]. The error increment Δe is Δ
e = (12-1) / (11-1) = 1.10. Next, since the selection error e is initially set to e = 0, the error increment Δe is added to Δe = 1.10, so that e = 0 + 1.10 = 1.10 ≧ (1/2). .
This advances the line number by 1 (becomes line 1:
See FIG. 18C). Therefore, the end points of the line 1 are assigned to the points on the side A′B ′ (see FIG. 18B). At this time, the selection error e is corrected as follows. e = 1.10-1 = 0.10 <1/2

If the error increment Δe = 1.10 is added again to the selection error e = 0.10 so far, e = 0.10 +
1.10 = 1.20 ≧ (1/2). This allows
Advance line number by 1 (this time becomes line 2: Figure 18
(See (c)). Therefore, the end points of the line 2 are assigned to the points on the side A′B ′ (see FIG. 18B).
At this time, the selection error e is corrected as follows. e = 1.20-1 = 0.20 <1/2 Hereafter, the same processing is performed, and the point on the side A′B ′ is the end point of the line 3, the point is the end point of the line 4, and the point is the point. Are assigned the end points of line 5 (FIG. 18B).
reference). At this time, when the line 5 is allocated and the selection error e is corrected, the selection error e becomes 0.50. Since e ≧ 1/2 when the selection error e is corrected, the line number is further advanced by 1 (to become line 6) and the end point of line 6 is also assigned to the point. Next, the selection error e is further corrected as follows. e = 0.50−1 = −0.50 <1/2 By repeating the above processing, it is determined which end point of the original horizontal line divided into the side A′B ′ is assigned.

Now, returning to the flowchart of FIG. 27 again, description will be made. The above description is the processing content of allocating the end point of the line to be attached to the side shorter than the original side AB such as the side A'B ', but this time, the side D'shown in FIG. 19B. An original side D shown in FIG. 19A as in C ′
The contents of the process of assigning the end points of the line to be attached to the side longer than C will be described. In this case, the processing from step S1250 shown in FIG. 27 is executed. This corresponds to the case where the determination result of the previous step S1204 is NO, and when the determination result is NO, this is a case where the process proceeds to the side D'C 'longer than the original side DC. If the decision result in the step S1204 is NO, the process branches to a step S1238 in FIG. 27 to determine the position of the end point, and then execute the steps after the step S1250. First, the number of horizontal lines in the original image data is 12,
Since the number of lines that can be pasted on the side D'C 'is 14, the end points of two lines of the 12 lines of the original image data are pasted twice on the side D'C'. Become. The process of selecting the line to be pasted is as follows.

In step S1250, the selection error (initial value =
0) e, and the error increment Δe is added to the selection error e (e
= E + Δe). Δe is (the number of lines of the original image-1) / (the number of pixels of the side D'C'-1). In addition, here
Since it is for line selection, e is set to e2 and Δe is set to Δe2. Then, e2 = e2 + Δe2. Next, it is determined in step S1252 whether or not this value has become larger than 1/2. Then, the error increment Δe
If the result e2 of adding 2 is e2 ≧ (1/2), the flow advances to step S1254 to increment the current line number by [1] (that is, to advance to the next line number). In this method, an error increment is added to the selection error, and the process is selected depending on whether the result is larger or smaller than 1/2, and the error is corrected when the selection error is 1/2 or more.
By advancing the current line number by 1, the next point on the side D'C 'is assigned the endpoint of the next line.

In this way, when the X coordinate is changed by 1 from the point D ′ to the point C ′, at least when the error increment Δe2 is larger than half of 1, the line number is changed to the next line number. Therefore, the changing positions of the line end points are smoothly connected. In step S252, e
If 2 is less than 1/2, the process jumps to step S266. In step S1266, it is determined whether or not all the end points have been processed. If the processing has not been completed for all the end points, the process returns to step S1240 and the same processing is repeated. Therefore, when the error increment Δe2 becomes larger than half of 1, the process does not jump to step S1266 but proceeds to step S1254.

After step S1254, the error is corrected in the following step S1256 to set e2 = e2-1. This is because since the selection error has become 1/2 or more and the line number has been changed to the next line number, by subtracting 1 from the next line number, the error increment Δe is added again and the same determination is started. Then, in step S1258, it is determined again whether the selection error e2 is 1/2 or more. This is because the selection error e2 is again calculated for the result of error correction.
Is to determine the size of. If the selection error e2 is still ½ or more as a result of the error correction, the process advances to step S1260 to store the current line number and the current coordinate in the end point buffer in the internal register 31a of the CPU 31. Next, in step S1262, the line number is incremented by [1] (that is, the line number is advanced to the next line number). Thereby, the end point of the next line is also assigned to the same point on the side D'C '. The end points of the next line are sequentially assigned to the same point until the selection error e2 becomes less than 1/2.

Then, in step S1264, error correction is performed to set e2 = e2-1. This is because the selection error becomes 1/2 or more and the line number is changed to the next line number in the same manner as described above. Therefore, by subtracting 1, the error increment Δe is added again from the next line number to start the same determination. Is.
Then, the process returns to step S1258 and the same process is repeated. Therefore, if the error correction result (selection error) e2 is still larger than 1/2, the line number is further advanced by 1 and the end point of the next line is assigned to the same point on the side D'C '. . Then, the end points of the next line are assigned to the same point until the selection error e2 becomes less than 1/2.

On the other hand, in step S258, the error increment Δe2
If the result of adding e2 is e2 <(1/2), the process jumps to step S1266. At this time, the line number is not changed to the next line number and remains unchanged. Further, in this case, the selection error e2 is not corrected. Step S
At 1266, it is determined whether or not all the end points have been processed. If the processing has not been completed for all the end points, the processing returns to step S1240 and is repeated. As a result, when the X coordinate is changed by 1 from the point D ′ to the point C ′, the above processing is repeated according to the magnitude of the error increment Δe2. Error increment Δe2 is 1/2
If it is larger, it is changed to the next line number.
By executing the above steps S1250 to S1266, the position of each line end point when the end point of the line to be pasted is assigned to a side longer than the original side DC such as the side D'C 'is determined. .

Here, a specific example of the case of FIG. 19 (when one end point of the line is assigned to a side longer than the original side AB such as the side D'C ') will be described. FIG. 34
19A shows a side DC which is one end point of the line before deformation, FIG. 19B shows a state of a side D′ C ′ which is one end point of the line to be attached, and further, FIG. 19C. Indicates changes in the number of pixels in the X direction and the Y direction on the side D′ C ′. First, the end point of line 0 is apex and is determined on D '. At this point, the line number is initialized to 0 and the selection error e is initialized to [0]. The error increment Δe is Δ
e = (12-1) / (14-1) = 0.84. Next, since the selection error e is initially set to e = 0, it is left as it is, and when Δe = 0.84 is added as the error increment Δe, e = 0 + 0.84 = 0.84 ≧ (1/2). This advances the line number by 1 (becomes line 1: see FIG. 19C). Therefore, the end points of the line 1 are assigned to the points on the side D'C '(FIG. 19).
(See (b)). At this time, the selection error e is corrected as follows. e = 0.84-1 = -0.16 <1/2

Similarly, a line 2 is attached to a point on the side D'C '.
Of the line 3 is assigned to the point (see FIG. 19B). At the time when the line 3 is allocated and the selection error e is corrected, the selection error e is -0.48. If the error increment Δe = 0.84 is added again to the selection error e = −0.48 so far, e = −0.48 + 0.8
Since 4 = 0.36 <(1/2), line 3 is pasted again at the point (see FIG. 19 (c)). At this time, the selection error e is not corrected. By repeating the above processing, it is determined which end point of the original horizontal line divided into the side D'C 'is assigned. The data stored in the end point buffer at the time when the line end point processing is completed is as shown in FIG. In FIG. 30, side A'B '
The 12 end point positions of the upper line 0 to line 11 are stored in the end point buffer by coordinates. Line 0 to line 11 on the side D'C '(of which line 3 and line 8
14 end point positions are stored in the end point buffer by coordinates.

Subroutine for Line Drawing Process Then, after that, a plurality of lines having an end point of one line on the side A'B 'thus obtained and another end point on the side D'C' Original image data (rectangle ABC
If the corresponding lines of D) are attached in order, the image can be transformed. However, at this time, since the line length (the number of pixels) is different between the transfer destination and the transfer source, the lines are attached while expanding or reducing each line. Therefore, subsequently, step S1108 shown in FIG.
The subroutine of the line drawing process will be described.
FIG. 28 is a flowchart of a subroutine showing line drawing processing. First, the process of obtaining the position of the line to be attached will be described. As a specific example, a method of obtaining the sticking position of line 0 will be described later. The same applies to the attachment positions of other lines. First, step S
In 1300, the coordinate determination error e1 and the dot selection error e
3. Initialize all current dot numbers to [0]. The coordinate determination error e1 is a coordinate determination error used when determining the line drawing position. The dot selection error e3 is a dot selection error used when selecting a dot to be assigned to a line. As a result, each error initially becomes [0].

Then, in step S1302, the side A'B '
The coordinates of the upper end point are stored in an area called current coordinates in the internal register 31a of the CPU 31 (see FIG. 24). As related storage areas used in the process of the dot selection processing, the area of the dot selection error e3, the area of the dot selection error increment Δe3, and the area of the current dot number are used. Next, in step S1304, it is determined whether the number of pixels in the Y direction is larger than the number of pixels in the X direction. Now, a specific example of the case where the position of each dot is obtained in order to paste the line 0 is shown in FIG. Figure 20
20A shows the line AD before deformation, FIG. 20B shows the state of the line side A′D ′ after deformation, and FIG.
(C) shows a change in the number of pixels in the X direction and the Y direction on the side A′D ′. Considering this example, since the side A′D ′ is drawn over 10 pixels in the Y direction and 2 pixels in the X direction, the determination result of step S1304 is YES, and in this case, step S1
Proceed to 306. On the other hand, in the opposite case, the process branches to NO and proceeds to step S1338 shown in FIG. In this case, in the case shown in FIG. 20, when the position where the Y coordinate changes when the X coordinate is changed by 1 from the point A ′ to the point D ′, the changed coordinate is the line A. "D"
Is the position to paste. Therefore, when 9 dots except the starting point (point A ′) where the position is unconditionally decided, one position where the X coordinate changes is obtained as the position where the X coordinate changes.

In step S1306, the coordinate determination error increment Δe1 is initialized to (X pixel number-1) / (Y pixel number-1), and the dot selection error increment Δe3 is set to (source dot number-1). ) / (Number of transfer destination dots −
Initialize to 1). Step S1300 to Step S
The necessary initial settings are completed by the processing of 1306. Next, in step S1308, if it is not drawn at the current coordinates, the dot of the current dot number is drawn. As a result, the first point of the corresponding line is drawn as a dot. Next, in step S1310, the Y coordinate of the current coordinate is changed. Next, in step S1312, the determination regarding the coordinate determination error e1 is performed as follows. That is, the selection error (initial value = 0) e is determined, and the error increment Δe is added to the selection error e (e = e + Δe). Δe is (the number of pixels in the Y direction-1) / (the number of pixels in the X direction-1). Note that, here, since it is for determining the coordinates, e is set to e1 and Δe is set to Δe1. Then, e1
= E1 + Δe1. It is determined whether this value is larger than 1/2. If the result e1 of adding the error increment Δe1 is e1 ≧ (1/2), step S13
Go to step 14 and set the coordinates of the next hit point (corresponding to the next current coordinates)
Change the X coordinate of. In this method, an error increment is added to the selection error, and the process is selected depending on whether the result is larger or smaller than 1/2, and the error is corrected when the selection error is 1/2 or more.

By doing so, when the X coordinate is changed by 1 from the point A ′ to the point D ′, the next coordinate is changed at least when the error increment Δe1 is larger than half of 1. , Y-coordinate changing positions are smoothly connected. Next, in step S1316, error correction is performed to set e1 = e1-1. This has a selection error of 1
This is because since the next coordinate has been changed to / 2 or more, 1 is subtracted, and the error increment Δe is added again from the next current coordinate to start the same determination. Then, it progresses to step S1318. If the result e1 of adding the error increment Δe1 is e1 <(1/2), step S131
4, jump from step S1316 to step S13
Proceed to 18. At this time, the X coordinate of the next hit point remains unchanged. Further, in this case, the selection error e1 is not corrected. By executing the above steps S1310 to S1316, the paste position of the corresponding line when the number of pixels in the Y direction is larger than the number of pixels in the X direction is determined.

On the other hand, if the number of pixels in the Y direction is smaller than the number of pixels in the X direction in step S1304, the process shown in FIG.
Then, the processing proceeds to step S1328 of 4, and the processing for changing the X coordinate is performed. That is, in step S1328, the coordinate determination error increment Δe1 is set to (Y pixel number-1) / (X
Initially, the number of pixels-1) and the dot selection error increment Δe3 are initialized to (the number of transfer source dots-1) / (the number of transfer destination dots-1). Then, step S13
If it is not drawn at the current coordinates at 30, the dot of the current dot number is drawn. As a result, the first point of the corresponding line is drawn as a dot. Then, step S
At 1332, the X coordinate of the current coordinate is changed. Next, in step S1334, the determination regarding the coordinate determination error e1 is performed as follows.

That is, the selection error (initial value = 0) e is determined, and the error increment Δe is added to the selection error e (e = e + Δ
e). Δe is (the number of pixels in the Y direction-1) / (the number of pixels in the X direction-1). Note that, here, since it is for determining the coordinates, e is set to e1 and Δe is set to Δe1. Then, e1 = e1 + Δe1. It is determined whether this value is larger than 1/2. If the result e1 obtained by adding the error increment Δe1 is e1 ≧ (1/2), the process advances to step S1336 to change the Y coordinate of the coordinate of the next hit point (corresponding to the next current coordinate). this is,
An error increment is added to the selection error, and the process is selected depending on whether the result is larger or smaller than 1/2. The error is corrected when the selection error is 1/2 or more.

In this way, when the X coordinate is changed by 1 from the point A ′ to the point D ′, the next coordinate is changed at least when the error increment Δe1 is larger than half of 1. , Y-coordinate changing positions are smoothly connected. Next, in step S1340, error correction is performed to set e1 = e1-1. This has a selection error of 1
This is because since the next coordinate has been changed to / 2 or more, 1 is subtracted, and the error increment Δe is added again from the next current coordinate to start the same determination. Then, it progresses to step S1342. If the result e1 of adding the error increment Δe1 is e1 <(1/2), step S133.
8. Jump from step S1340 to step S13
Proceed to 42. At this time, the X coordinate of the next hit point remains unchanged. Further, in this case, the selection error e1 is not corrected. By executing the above steps S1332 to S1340, the paste position of the corresponding line when the number of pixels in the Y direction is smaller than the number of pixels in the X direction is determined.

The above-mentioned processing has the same processing contents as those in steps S1210 to S1216 shown in FIG. 26, but there is a portion in which X and Y are reversed as compared with the routine in FIG. This is because the consideration is based on the one having a larger number of pixels in the X direction and the Y direction. Figure 2
In the routine of FIG. 6, the Y coordinate having a large number of pixels is used as a reference, and it is determined how the X coordinate changes when the Y coordinate is changed one by one. Considering the X coordinate, which has a lot of values, as a reference, it is determined how the Y coordinate changes when the X coordinate is changed one by one. With respect to the pasting positions of other lines, the processing for obtaining by the same method is performed.

Since the pasting position of each line has been obtained, next, the processing contents for obtaining which dot is to be assigned (that is, to select a dot) among the dots of the original horizontal dot line will be described. explain. First, a method of reducing the line when the number of pixels of the transfer destination line is smaller than the number of pixels of the transfer source line in the processes from step S1318 shown as the dot selection process will be described. This method is shown in steps S1318 to S1326, which are dot selection processes. Assuming that the first dot (dot 0) on the transfer source line is unconditionally selected, the method for selecting other dots is as follows. That is, first, in step S1318, a selection error (initial value = 0) e is determined, and an error increment Δe is added to the selection error e (e = e + Δe). Δe is (the number of transfer source dots −
1) / (dot number of transfer destination-1). Here, since it is for dot selection, e is set to e3 and Δe is set to Δe.
Process as 3. Then, e3 = e3 + Δe3
Becomes

Then, it is determined in step S1320 whether this value has become larger than 1/2. If the result e3 obtained by adding the error increment Δe3 is e3 ≧ (1/2), the flow advances to step S1322 to increment the current dot number (dot number of the transfer source line) by [1] (that is, Go to the dot number). This is to add an error increment to the selection error and select processing depending on whether the result is larger or smaller than 1/2.
The error is corrected when / 2 or more. By advancing the dot number of the transfer source line by 1, the dot number of the transfer source line to be selected next on the side AD is assigned.

In this way, when the X coordinate is changed by 1 from the point A to the point D, if at least the error increment Δe3 is larger than half of 1, the dot number is changed to the next dot number. The changing positions of the dots are connected smoothly. Next, in step S1324, error correction is performed to set e3 = e3-1. This is because the selection error became 1/2 or more and the next dot number was changed.
This is because subtracting is added again to the error increment Δe from the next current dot number, and the same determination is started. Then, it returns to step S1344 and step S1344.
-The loop of step S1348 is repeated. Then, when e3 becomes less than 1/2 in step S1320, the process branches to step S1350.

On the other hand, if e3 is less than 1/2 from the beginning in step S1320, the process jumps to step S1326. In step S1326, it is determined whether or not all dots have been processed. If the processing has not been completed for all dots, the process returns to step S1330 and the same processing is repeated. Therefore, when the error increment Δe3 becomes larger than half of 1, it does not jump to step S1350 but proceeds to step S1346. In this way, if the result (selection error) e3 obtained by adding the error increment Δe3 is e3 <(1/2), the same data as the previous dot is transferred again to the next dot on the transfer destination line. . At this time, the horizontal dot number and the selection error e3 are not changed.

Here, a specific example of dot selection is shown in FIG.
2 will be described. 22A shows a state of dots on the transfer source line before the deformation, FIG. 22B shows a state of dots on the transfer destination line after the deformation, and FIG.
(C) shows changes in the number of pixels in the X and Y directions in the transfer line. In this example, when the number of pixels of the transfer destination line is larger than the number of pixels of the transfer source line,
That is, this corresponds to the process of enlarging the line. Considering this example, since the number of dots on the transfer source line is 16 and the number of dots on the transfer destination line is 17, one of the 17 dots at the transfer destination has the same data as the previous dot. Will be transferred. Assuming that the first dot (dot 0) of the transfer source line is transferred unconditionally, the process of transferring the other dots is performed as follows.

First, dot 0 is transferred first. At this point, the selection error e is initially set to [0] and the dot number is 0. The number of dots on the transfer source line is 1
Since the number of dots in the transfer destination line is 6, and the number of dots in the transfer destination line is 17, the error increment Δe is Δe = (16-1) / (17-1) = 0.
93. Next, since the selection error e is initially set to e = 0, it is left as it is, and Δe =
Adding 0.93, e = 0 + 0.93 = 0.93 ≧
(1/2). Therefore, at this time, the dot number is advanced by 1 (to become dot 1). At the same time, the selection error e is corrected as follows. e = 0.93-1 = -0.07 <(1/2) Since the selection error e becomes smaller than 1/2 at this point, dot 1 is transferred to the point (FIG. 22B, FIG. 22
(See (c)).

Similarly, the selection error so far e =-
If Δe = 0.93 is added as an error increment Δe to 0.07, e = −0.07 + 0.93 = 0.86 ≧ (1/2)
Therefore, the dot number is incremented by 1 (it becomes dot 2)
At the same time, the selection error e is corrected as follows. e = 0.86−1 = −0.14 <(1/2) At this point, the selection error e becomes smaller than 1/2, and the dot 2 is transferred as the dot to be displayed at the point (FIG. 2).
2 (b) and FIG. 22 (c)).

Thereafter, when the same processing is performed, dot 3 is assigned to point, dot 4 is assigned to point, dot 5 is assigned to point, dot 6 is assigned to point, and dot 7 is assigned to point. When the dot 7 is assigned, the selection error e is −
It becomes 0.49. If the error increment Δe = 0.93 is added to the selection error e = −0.49 so far, e = −0.49 +
Since 0.93 = 0.44 <(1/2), the dot number remains 7, and the selection error e is not changed. Therefore, dot 7 is transferred again to the point (FIG. 22).
(B) and FIG.22 (c)). By repeating the above process, one dot (dot 7) from the 16 dots of the transfer destination line is transferred twice, and 1 dot of the transfer destination line is transferred.
7 dots are determined. In this way, when the number of pixels of the transfer destination line is larger than the number of pixels of the transfer source line, the process of enlarging the line is performed.

By executing the above-mentioned programs, the process of pasting the lines of the image data before the transformation as the image data after the transformation is performed. At this time, the lines are pasted on the sides A'B 'and D'. The number of pixels of the longer side of'C 'is performed. For example, in the example of FIG. 14, comparing the numbers of pixels on the sides A′B ′ and D′ C ′, the number of pixels on the side A′B ′ is 11, and the number of pixels on the side D′ C ′ is 14, , D′ C ′ pixels (= 14). Specifically, as shown in FIG. 14B, line 0, line 0, line 1, line 2, line 3, line 3 ′, line 4, line corresponding to the number of pixels on side D′ C ′. 5, line 6, line 7, line 8, line 8 ', line 9, line 10, line 11
The line is pasted 14 times. The final state in which each line is attached is shown in FIG. 23 (b). Note that FIG. 23A is a line of image data before transformation. As shown in FIGS. 15 (a) and 15 (b), there is a portion where the two pasted lines overlap, but in the present embodiment, the one written earlier is given priority. In addition to this, there is also a method of giving priority to a later written one, or a processing method of adding the value every time the color codes of two dot data are combined in the overlapping portion and halving the value. When synthesizing color codes of dot data, the color codes are divided into R (red component), G (green component), and B (blue component), for example.

As described above, in this embodiment, the transformation target having the image data in the bit array format is divided into a plurality of small rectangles, and each small rectangle is subjected to the coordinate conversion processing so that the entire transformation target is smoothly transformed. It is transformed into different small squares. At this time, in the process of transforming a small rectangle, the facing upper and lower sides that form the outer frame to be transformed are selected, and the vertices of a plurality of small polygons on each selected side are associated with each side. When the vertex of one small polygon inside the deformation target is moved to at least an arbitrary position that is located inside after the deformation, the deformation is performed according to the parameters of the curve 1 and the parameters of the curve 1 The vertices of the other small rectangles are moved so that the entire object is smoothly deformed, and the vertices of the other small rectangles (coordinates: xd (j), yd (j)) that have been moved become the reference small rectangle vertices. Based on the calculated vertices, each small rectangle is transformed into a quadrangle. After that, the array of the image data in the bit array format included in the small rectangle before transformation is sequentially transformed for each small square according to the line pasting method so as to correspond to the data of the transformed small square, and the entire image after transformation is transformed. Is created. as a result,
By applying the processing of this embodiment, for example, FIG.
The "eye" image in the bit array format as shown in (a) can be smoothly transformed into the "eye" image as shown in FIG. 1 (b).

Therefore, since the transformation process is performed for each small rectangle with respect to the array of transformation-target image data, it is not necessary to previously have completely different whole image data as in the prior art, and a small memory capacity and bit An image having data in array format can be freely transformed. In addition, since the transformation target is divided into a plurality of small rectangles and the transformation process is performed for each small rectangle, there is a degree of freedom in the transformation and the image can be transformed smoothly even if the memory does not have much data in advance. be able to. In particular, the vertices of any small polygon on any side that constitutes the outer frame of the deformation target are moved according to the curve parameters, and the vertices of any small polygon inside the deformation target are re-integrated at least after the deformation. By using the transformation method that moves to an arbitrary position such as that located at, it suffices to have only the coordinates for four points and the data necessary to move the internal grid points as the curve parameters. It is not necessary to have position data (for example, coordinates) of the vertices of all the subsequent small polygons. Therefore, it is possible to perform complex and very smooth image transformation with extremely little transformation data. Furthermore, when this transformation method is used, the shape of the outer frame to be transformed can be changed, and the small polygon inside can be transformed into an arbitrary shape, so the outer shape (for example, size) of the image data can be changed, and The shape can be changed.

In addition, as a concrete ripple effect, by the application of the present invention, for example, a character such as an animation, a game, or background data is composed of dots, and a display color number or a palette number is set for each dot. It is possible to freely and smoothly transform an image in a bit array format such as. As a result, a plurality of image data in which a part or all of the original image data is smoothly transformed can be created from one original image data. Further, when applied to animation, the original image data is transformed by the transformation method of the present invention at regular time intervals, even if it is not necessary to previously store a plurality of image data of different shapes in the memory as in the conventional case. By doing so, it is possible to perform animation similar to the conventional one with a small memory capacity. Even when a plurality of characters appear in a game or the like, a plurality of completely different characters can be created from the image data of one character. Even when changing the shape of a part of a character appearing in a game or the like (for example, parts such as eyes, nose, hands, and feet), there is an effect that only one original image data is required. Even when adding special effects to the background of games, etc., it is possible to perform far more flexible and smooth transformations than the conventional enlargement, reduction, transformation from square to square, etc. Effects (for example, distorting the background to represent a different dimension world) can be added.

In the above embodiment, the Bezier curve parameter is used as the curve parameter, but the curve parameter is not limited to this, and an arbitrary curve such as a B-spline curve may be used. In addition to this, a parabola,
It is possible to employ an arbitrary mathematical expression such as a hyperbola, a trigonometric function or the like that allows the grid points on the outer frame to be arranged smoothly. In this case, in order to move the grid points on the outer frame, not only the equation of the curve but also an appropriate equation may be used according to the way of transforming the parabola, the hyperbola, the trigonometric function and the like. By doing so, appropriate deformation can be performed depending on the occasion.
Also, the movement reference grid points inside are not limited to one example,
For example, it is possible to move a plurality of internal movement reference grid points. Furthermore, not only when simply moving the moving reference grid points inside, but also when moving according to the parameters of mathematical expressions such as curves, and when moving the small polygon itself inside, The method of the invention can be applied.

In each of the above embodiments, the transformation target having the image data in the bit array format is divided into small rectangles and transformed into arbitrary rectangles. However, the present invention is not limited to this. The image data after deformation may be created by dividing the hexagon into different small hexagons, for example, according to a predetermined deformation processing procedure. Further, the shape for dividing the transformation target having the image data in the bit array format is not limited to the above two types, and various transformations are possible within the scope of the object of the present invention. Furthermore, the application of the present invention is not limited to animation, characters such as games, background data, etc.
It can be applied to other fields and other image data.

[0111]

According to the present invention, a transformation target is divided into a plurality of small polygons, and each small polygon is transformed into different small polygons according to a predetermined transformation process. At this time, the transformation process of the small polygons is performed. Then, the vertices of any small polygon on the outer frame to be deformed and the vertices of any small polygon on the inside of the deformable object are at least repositioned at any position such that the outer frame is formed again after the deformation. When each of the small polygons is moved to an arbitrary position inside, the vertices of the other small polygons are moved according to the movement of the arbitrary small polygon, and the vertices of the other small polygons moved are moved to the arbitrary position. Calculated based on the vertices after the movement of the small polygon, deform each small polygon corresponding to the calculated vertices, and further, the array of the image data in the bit array format included in the small polygon before the transformation, For each small polygon,
Since the whole image after the change is created by sequentially changing the data so as to correspond to the deformed small polygon data according to a predetermined data conversion process, the following effects can be obtained. The image data array of the transformation target is changed for each small polygon, so there is no need to have completely different image data in advance as in the conventional case, and a small memory capacity and bit array format image Can be freely transformed. Since the transformation target is divided into multiple small polygons and the transformation process is performed for each small polygon, there is a degree of freedom in transformation, and the image can be transformed smoothly even if there is not much data in memory beforehand. be able to. In particular, the vertices of any small polygon on the outer frame of the deformation target and the vertices of any small polygon inside the deformation target are
By using a deformation method of moving to an arbitrary position such that the outer frame is formed again after at least deformation and at least an arbitrary position that is located inside again, respectively,
It is not necessary to have position data (for example, coordinates) of the vertices of all the small polygons after transformation. Therefore, complex and very smooth image transformation can be performed with a small amount of transformation data. By using this transformation method, the shape of the outer frame to be transformed can be changed, and the small polygon inside can be transformed to any shape. Therefore, the outer shape (for example, size) of the image data can be changed, and the inner shape can also be changed. Can be changed.

According to another aspect of the present invention, in the small polygon deformation process, a plurality of facing sides forming the outer frame to be deformed are selected, and a plurality of sides on each selected side are selected. The vertices of the small polygons are moved to arbitrary positions at least so as to form a plurality of sides facing each other again after the deformation, according to the predetermined curve parameters corresponding to the respective sides, and at the same time, in an arbitrary position inside the deformation target. Since the transformation method of moving the vertices of the small polygon of at least to an arbitrary position that is located inside again after the transformation, the coordinates of several points (for example, 4 points) and the internal It is only necessary to have the data of the grid points, it is not necessary to have the position data (for example, coordinates) of the vertices of all the small polygons after the transformation, and smooth image transformation can be performed with a small amount of transformation data. It can be. Also, by using this transformation method, while changing the shape of the outer frame to be transformed,
Since the internal small polygon can be transformed into an arbitrary shape, it is possible to change the outer shape (for example, size) of the image data and further change the inner shape.

[Brief description of drawings]

FIG. 1 is a diagram illustrating the principle of a polygon division transformation method according to the present invention.

FIG. 2 is a diagram showing a modification example of a polygonal division modification method according to the present invention from a small rectangle to an arbitrary quadrangle.

FIG. 3 is a configuration diagram of a first embodiment of an image transformation apparatus according to the present invention.

FIG. 4 is a diagram showing an example in which the image data to be transformed in the embodiment is divided into a large number of small rectangles.

FIG. 5 is a diagram showing an example of storing data in an internal register of the CPU of the embodiment.

FIG. 6 is a flowchart showing a main program of image transformation processing of the embodiment.

FIG. 7 is a flowchart showing a subroutine of small rectangle transformation processing of the embodiment.

FIG. 8 is a diagram illustrating a line pasting method of the example.

FIG. 9 is a diagram illustrating a modification process of a modification target of the embodiment.

FIG. 10 is a diagram showing a storage example of data according to the embodiment.

FIG. 11 is a flowchart showing a routine of a grid point coordinate calculation process of the embodiment.

FIG. 12 is a diagram illustrating a Bezier curve generation method according to the same embodiment.

FIG. 13 is a flowchart showing a subroutine of line pasting processing of the above embodiment.

FIG. 14 is a diagram showing a modification of the image data of the above embodiment.

FIG. 15 is a diagram showing a modification of the image data of the above embodiment.

FIG. 16 is a diagram showing a modification of the image data of the above embodiment.

FIG. 17 is a diagram showing a modification of the image data of the above embodiment.

FIG. 18 is a diagram showing a modification of the image data of the above embodiment.

FIG. 19 is a diagram showing a modified example of the image data.

FIG. 20 is a diagram showing a modification of the image data of the above embodiment.

FIG. 21 is a diagram showing a modification of the image data of the above embodiment.

FIG. 22 is a diagram showing a modification of the image data of the above embodiment.

FIG. 23 is a diagram showing a modification of the image data of the above embodiment.

FIG. 24 is a diagram showing an example of storing data in an internal register of the CPU of the above embodiment.

FIG. 25 is a diagram illustrating an example of line drawing in the above embodiment.

FIG. 26 is a flowchart showing a part of a subroutine of line end point processing of the above embodiment.

FIG. 27 is a flowchart showing a part of a subroutine of line end point processing of the above embodiment.

FIG. 28 is a flowchart showing a part of a subroutine of the line drawing processing.

FIG. 29 is a flowchart showing a part of a subroutine of line drawing processing of the above embodiment.

FIG. 30 is a diagram showing an example of storing data in the end point buffer of the above embodiment.

[Explanation of symbols]

31 CPU (dividing means, transforming means, image data creating means, coordinate transforming means, data transforming means, image transforming control means) 32 Input operator (transformation mode designating means) 33 Storage device (storage means) 34 VDP 35 VRAM 36 TV Display (display means) 41 Image data in bit array format 42 Lattice point coordinates before deformation 43, 44 Lattice point coordinates after deformation 51 First transformation switch 52 Second transformation switch

Continuation of front page (51) Int.Cl. ⁶ Identification number Office reference number FI Technical display location G09G 5/36 520 D 9471-5G H04N 5/262 9365-5L G06F 15/72 350

Claims (20)

[Claims] 1. An object to be deformed having image data in a bit array format is divided into a plurality of small polygons, and each small polygon is deformed into different small polygons according to a predetermined deformation process. The whole image after the change is performed by sequentially changing the array of the image data in the bit array format included in the polygon to each small polygon according to the predetermined data conversion processing so as to correspond to the data of the deformed small polygon. In addition to creating the data, in the small polygon deformation process, the vertices of any small polygon on the outer frame of the deformation target and the vertices of any small polygon inside the deformation target are reconstructed at least after the deformation. When each is moved to an arbitrary position that constitutes the outer frame and at least to an arbitrary position that is again positioned inside, the vertex of another small polygon is moved according to the movement of the arbitrary small polygon, Other moved The method for transforming an image, characterized in that the vertices of the small polygon are calculated based on the vertices of the plurality of small polygons after the movement, and each small polygon is deformed corresponding to the calculated vertices. 2. In the small polygon deforming process, a plurality of facing sides constituting an outer frame to be deformed are selected, and a plurality of small polygon vertices on each selected side are respectively selected. According to a predetermined curve parameter corresponding to the side of, at least after the deformation, move to an arbitrary position that constitutes a plurality of opposite sides, and at least deform the vertex of any small polygon inside the deformation target. Later, when the small polygon is moved to an arbitrary position again inside, the vertices of the other small polygons are moved according to the movement of the small polygon, and the vertices of the other small polygons are moved to the plural positions. The image transforming method according to claim 1, wherein the calculation is performed based on the vertices of the respective small polygons after the movement, and each of the small polygons is transformed according to the calculated vertices. 3. The predetermined curve parameter for moving and arranging the vertices of a plurality of small polygons in the transforming process is an arbitrary parameter defined by at least one of a Bezier curve and a trigonometric function. Item 2
The described image transformation method. 4. The predetermined transforming process is a coordinate transforming process. In this coordinate transforming process, the coordinates of the vertices of each of the divided small polygons are obtained, and then the vertexes of the transformed small polygons are calculated. The divided small polygons are transformed into different small polygons by calculating coordinates and determining the shape of different small polygons after transformation based on the calculated coordinates. The described image transformation method. 5. The predetermined data conversion process is a process of dividing image data of a bit array format included in each small polygon to be deformed into a plurality of lines, and a process of deforming each of the divided lines. The process of calculating the end points on the small polygon, the process of enlarging or reducing each of the divided lines according to the size of the corresponding line of the deformed small polygon, and the process of enlarging or reducing 2. The image transforming method according to claim 1, further comprising: a process of sequentially transferring and arranging the line starting from an end point on a line corresponding to the deformed small polygon. 6. The process of calculating the end points is based on the positions of the end points of the lines before and after the deformation,
The process of sequentially accumulating the error when the position of the end point of each line before deformation is not changed and the position of the end point of the corresponding line of the small polygon after deformation is sequentially accumulated, and when this error exceeds a predetermined value 6. The image transformation method according to claim 5, further comprising: changing the position of the end point of the line and subtracting a constant value from the accumulated error. 7. The process of enlarging or reducing is modified based on the number of bit array format image data included in the lines before and after the modification and the bit array format image data included in the lines after the modification. The process of accumulating the error when the image data in the bit array format included in each previous line is sequentially specified and arranged in the modified line, and when this error exceeds a predetermined value, it is currently specified. A process of transferring and arranging the image data to the transformed line to specify the next image data, and repeating the operation of subtracting a constant value from the accumulated error until the error becomes a predetermined value or less; 6. The image transformation method according to claim 5, further comprising: a process of transferring the designated image data to a transformed line and arranging the designated image data when is less than or equal to a predetermined value. 8. The process of transferring, when each line before deformation is designated based on the number of lines before and after deformation and sequentially arranged at the position of the corresponding line of the small polygon after deformation. When the error exceeds a predetermined value, the currently specified line is transferred and arranged as a modified small polygon line to specify the next line, and the above-mentioned accumulation is performed. A process of repeating the operation of subtracting a constant value from the error until the error becomes a predetermined value or less; a process of transferring and arranging the designated line as a modified line when the error is a predetermined value or less; The image transformation method according to claim 5, further comprising: 9. A dividing means for dividing a deformation target having image data in a bit array format into a plurality of small polygons, and a vertex of an arbitrary small polygon on an outer frame of the deformation target and inside the deformation target. When the vertices of an arbitrary small polygon are respectively moved to at least an arbitrary position that again forms the outer frame after deformation and an arbitrary position that is at least inside again, the movement of the arbitrary small polygon According to the above, the vertices of the other small polygons are moved, the vertices of the moved other small polygons are calculated based on the moved vertices of the arbitrary small polygon, and the vertices of the calculated small vertices are divided. Deformation means for transforming each small polygon divided by the means into different small polygons, and the array of the bit array format image data included in the small polygons before the transformation is converted into predetermined data for each small polygon. After transformation, according to processing Image transformation apparatus characterized by comprising: the image data generation means for generating an entire image data after the change are sequentially changed to correspond to the data of the small polygons, the. 10. The deforming means selects a plurality of facing sides forming an outer frame to be deformed, and associates a plurality of small polygon vertices on each selected side with each side. According to a predetermined curve parameter to be moved to at least an arbitrary position that forms a plurality of sides facing each other again after the deformation, at the same time, at least after the deformation, the vertex of any small polygon inside the deformation target The image transforming device according to claim 9, wherein the transforming process is performed so as to move the image to an arbitrary position where the image is located. 11. The predetermined curve parameter for moving and arranging the vertices of a plurality of small polygons in the deforming means is an arbitrary parameter defined by at least one of a Bezier curve and a trigonometric function. Item 10. The image transformation device according to item 10. 12. The transforming means comprises coordinate transforming means capable of executing a predetermined transforming process for transforming each small polygon divided by the dividing means into different small polygons, and the coordinate transforming means is divided. By calculating the coordinates of the vertices of each small polygon, calculating the coordinates of the vertices of each small polygon after transformation, and determining the shape of the different small polygons after transformation based on these calculated coordinates. The image transformation apparatus according to claim 9, wherein each of the formed small polygons is transformed into a different small polygon. 13. The image data creating means includes a data converting means capable of executing the predetermined data converting process, and the data converting means includes an image in a bit array format included in each small polygon to be transformed. A means for dividing the data into a plurality of lines, a means for calculating the end points of each of the divided lines on the deformed small polygon, and a correspondence between each of the divided lines of the deformed small polygon. And a means for enlarging or reducing according to the size of the line to be formed, and a means for sequentially transferring and arranging the enlarged or reduced line starting from an end point on the corresponding line of the deformed small polygon. The image transformation device according to claim 9, wherein 14. The means for calculating the end points, based on the positions of the end points of the line before and after the deformation,
A means for sequentially accumulating errors when the positions of the end points of the lines before deformation are not changed and the positions of the end points of the corresponding lines of the small polygon after deformation are sequentially accumulated, and when this error exceeds a predetermined value. 14. The image transformation apparatus according to claim 13, further comprising means for changing the position of the end point of the line and subtracting a constant value from the accumulated error. 15. The means for enlarging or reducing is modified based on the number of bit array format image data included in the lines before and after modification and the bit array format image data included in the lines after modification. A means for accumulating an error when the image data in the bit array format included in each previous line is sequentially specified and arranged in the modified line, and when this error exceeds a predetermined value, it is currently specified. A means for transferring and arranging the image data to the transformed line to specify the next image data, and repeating the operation of subtracting a constant value from the accumulated error until the error becomes a predetermined value or less; 14. The image transformation apparatus according to claim 13, further comprising means for transferring the designated image data to a transformed line and arranging the designated image data when the is less than or equal to a predetermined value. 16. The transfer means specifies each line before deformation based on the number of lines before and after deformation and sequentially arranges the lines before the deformation at corresponding line positions of the small polygon after deformation. Means for accumulating the error, and when this error exceeds a predetermined value, the currently specified line is transferred and arranged as a deformed small polygon line to specify the next line, and the accumulated line is accumulated. Means for repeating the operation of subtracting a constant value from the error until the error becomes less than or equal to a predetermined value, and means for transferring and arranging the designated line as a modified line when the error is less than or equal to a predetermined value, The image transformation device according to claim 13, further comprising: 17. The image transformation apparatus according to claim 9, further comprising display means for displaying the transformed image data created by said image data creation means. 18. A small polygon different from each of the small polygons based on an output of the deforming means, wherein the deforming means has a deforming manner designating means for designating a deforming manner when deforming an object to be deformed. The image transforming apparatus according to claim 9, wherein the transforming process is performed on each of the images. 19. The deformation mode designating means includes a first modification switch for designating a modification target as a first modification mode and a second modification switch for designating a deformation target as a second modification mode. The image transformation apparatus according to claim 18, characterized in that. 20. Deformation target bit array format image data, division data indicating how to divide the transformation target, and deformation data indicating how to transform each of the divided small polygons. Storage means for storing, and image deformation control means for reading out each data stored in the storage means and controlling the image deformation when the deformation mode is specified by the deformation mode designating means. The image transformation device according to claim 9.