JPH07192122A - Image deforming method and device therefor - Google Patents

Abstract

PURPOSE:To provide an image deforming method which is capable of freely and smoothly deforming image of a bit array form with a little memory capacity, and a device for the method. CONSTITUTION:When the vertexes of plural small polygons forming the same line (p line) inside a deforming object are moved according to the parameter of a Bezier curve, the vertexes of small other polygons are moved so that the whole of the deforming object may be smoothly deformed and the vetexes of the other small moved polygons are calculated based on the vertex after the small polygon of the p line is moved. At this time, as the parameters of a curve, the both ends cordinates of the curve (xb1, yb1) and (xb4, yb4) and cordinates of (xb2, yb2) and (xb3, yb3) controlling the bending way of the curve are used. The shape of each small polygon after a deformation corresponding to each calculated vertex is determined, an original image is deformed so as to correspond to the data of the small polygon after the deformation and the whole of the image is prepared.

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,
Arbitrary positions where the vertices of a plurality of small polygons forming at least one of the same row or the same column inside the deformation target are positioned inside again at least after the deformation according to predetermined curve parameters. When the plurality of small polygons are moved, the vertices of the other small polygons are moved according to the movement of the plurality of small polygons, and the vertices of the other small polygons that are moved are the vertices after the movement of the plurality of small polygons. It is characterized in that each small polygon is deformed according to the calculated vertices.
The image transformation method according to the present invention is the image transformation method according to claim 2, wherein in the transformation processing of the small polygon, a plurality of small polygons forming at least one of a plurality of rows or a plurality of columns inside the transformation target. When the vertices of each small polygon of the group of are moved to an arbitrary position such that they are located inside again at least after the deformation, according to the predetermined curve parameters, other small polygons are moved according to the movement of the plurality of small polygons. The vertices of the small polygon are moved, the vertices of the other small polygons that have been moved are calculated based on the vertices after the movement of the plurality of small polygons, and each small polygon is calculated in correspondence with the calculated vertices. It is characterized by being deformed.

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 object having image data in a bit array format into a plurality of small polygons, and a dividing means inside the transformation object in the same row or the same column. When the vertices of a plurality of small polygons forming at least one of the plurality of small polygons are moved to an arbitrary position such that they are located inside again after at least deformation, according to a predetermined curve parameter, The vertices of the other small polygons are moved according to the movement, and the vertices of the other small polygons that have been moved are calculated based on the moved vertices of the plurality of small polygons. The deforming means for deforming each small polygon divided by the dividing means into different small polygons, and the array of the image data in the bit array format included in the small polygons before the deformation are provided in a predetermined manner for each small polygon. According to the data 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 form.

According to a tenth aspect of the present invention, in the image transformation apparatus, the transformation means includes a group of a plurality of small polygons forming at least one of a plurality of rows or a plurality of columns inside the transformation target. It is characterized in that the apex of each small polygon is deformed according to a predetermined curve parameter so as to be moved to an arbitrary position that is located inside again at least after the deformation. In a preferred aspect, for example, the predetermined curve parameter for moving and arranging the vertices of a plurality of small polygons in the deforming means is defined by at least one of Bezier curve and trigonometric function. Parameter may be used. 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 deformation process, at least one of the vertices of the small polygons forming at least one of the same row or the same column inside the deformation target is deformed at least according to a predetermined curve parameter. When it moves to an arbitrary position that is located inside again later, the vertices of the other small polygons are moved according to the movement of the plurality of small polygons (for example, the entire deformation target is smoothly deformed). As described above, the vertices of the other small polygons are moved), and the vertices of the moved other small polygons are calculated based on the moved vertices of the arbitrary small polygons. Deformation of the small polygon is performed. 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, by using a deformation method in which the vertices of a plurality of small polygons forming at least one of the same row or the same column inside the deformation target are moved according to a predetermined curve parameter, It is only necessary to have coordinates for several points (for example, four points), and it is not necessary to have position data (for example, coordinates) of the vertices of all the small polygons after transformation.
Therefore, it is possible to perform a very smooth image transformation with very little transformation data.

According to another aspect of the present invention, each small polygon of a group of a plurality of small polygons forming at least one of a plurality of rows or a plurality of columns inside the deformation target. Even when using the deformation method that moves the vertices of the vertices according to the predetermined curve parameters, it is not necessary to have the position data (for example, coordinates) of the vertices of all the small polygons after the transformation as well. It is possible to make smooth image transformation. Furthermore, when the coordinates of both ends of the curve are set on the outer frame to be transformed by the above-mentioned transformation method, only the small polygon inside can be transformed without changing the shape of the outer frame, and the outer shape of the image data ( For example, without changing the size)
This is effective when you want to change only the internal shape. Further, if a curve parameter is assigned to each of a plurality of rows or a plurality of columns, a more complicated transformation can be performed.

[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. The image (picture) B is obtained. In this case, each small rectangle (1), (2), (3), for the array of image data to be transformed,
Since the transformation process is performed for each (24), it is not necessary to previously have completely different whole image data as in the conventional case, and a bit array format image can be freely transformed with a small memory capacity. In addition, the transformation target is a plurality of small rectangles (1), (2),
Divide into (3), (24) and each small rectangle (1), (2),
(3) The deformation process is performed every (24), so there is a degree of freedom in deformation, and it is possible to smoothly deform an image without having a large amount of data in memory beforehand. Become.

In particular, if the deformation method of moving the vertices of a plurality of small polygons forming at least one of the same row or the same column inside the object to be deformed according to a predetermined curve parameter is used, All subsequent squares (1) ',
Position data of (2) ', (3)', ... (24) (for example,
It is not necessary to have the coordinates), and for example, only the coordinates of several points (for example, four points) need to be provided as the curve parameters, and smooth image transformation can be performed with a small amount of transformation data. Furthermore, if the coordinates of both ends of the curve are set on the outer frame to be transformed by this transformation method, only the small polygon inside can be transformed without changing the shape of the outer frame. For example, without changing the size)
This is effective when you want to change only the internal shape.

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. X coordinate of grid point (0, 0) ... 90 (coordinate of grid point of deformation data 1, 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) ... 95 ... X coordinate of grid point (m, n) ... 140 Y coordinate of grid 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. The processing contents of the so-called line pasting method will be described in detail collectively after describing the embodiment (see FIGS. 19 to 36). 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 this embodiment Next, a modification processing (that is, a plurality of forming at least one of the same row or the same column inside the object to be modified) which is a characteristic part of this embodiment. When the vertices of the small polygon are moved according to the prescribed curve parameters, the other grid points are moved so that the deformation target is smoothly deformed, and the coordinates of the moved grid points are calculated. explain.
First, an example of a transformation target that is the target of this transformation processing is shown in FIG.
FIG. 9B shows the example shown in FIG. 9A after the deformation.
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, the process of calculating the coordinates of the vertices of other small rectangles when the vertices of a plurality of small polygons forming the same line inside the transformation target are moved according to a predetermined curve parameter will be described. . This example corresponds to a case in which the vertices of a plurality of small rectangles in the same line inside the deformation target are gently lifted upward. 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, grid points (p,
In the case of 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,
Lattice 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). Further, the positions of the vertices (x1, p) and (x2, p) of the two small polygons forming the same row to be deformed before the deformation are known in advance as the deformation data. The vertices of these small rectangles serve as a reference for movement, and are hereinafter referred to as movement reference grid points. The vertices of each small rectangle are referred to as grid points as appropriate. Further, in the description of the drawings, the horizontal direction is x coordinate,
It is assumed that the vertical direction is the y coordinate, the x coordinate is larger from left to right and the y coordinate is larger from top to bottom on the drawing.

On the other hand, a plurality of small polygons forming the same row to be deformed, which have deformation data for moving in accordance with the curve parameters, have a curve as a curve parameter as shown in FIG. 9B. Coordinates of both ends (xb
1, yb1), (xb4, yb4), and coordinates (xb2, yb2), (xb3, yb) that control how the curve bends.
The data is 3). 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 ... xb1 y-coordinate of parameter 1 of curve ... yb1 x-coordinate of parameter 2 of curve ... xb2 y-coordinate of parameter 2 of curve ... yb2 x-coordinate of parameter 3 of curve ... xb3 Y-coordinate of parameter 3 of curve ... yb3 x-coordinate of parameter 4 of curve ... xb4 y-coordinate of parameter 4 of curve ... yb4

FIG. 11 is a flow chart showing the routine of the lattice point coordinate calculation processing after the transformation. This routine
When the vertices of a plurality of small polygons forming the same line inside the transformation target are moved according to the predetermined curve parameters, the vertices of the other small polygons are moved so that the transformation target is deformed smoothly. The calculated vertexes of the other small polygons are calculated based on the vertexes after the movement of the lattice points serving as the reference (appropriately referred to as deformed movement lattice 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 same line (p) included in the inside of the transformation target is based on the generation method of the Bezier curve.
Lattice points (p, j) forming a row (where 0 ≦ j ≦
The process of calculating the coordinate after movement of another grid point when n) is moved according to the parameter of the Bezier curve will be described. First, let the coordinates of the vertex of the outer frame on the upper left side of the transformation target be (x
1, y1), and the coordinates of the vertex of the lower right outer frame are (x2,
y2). 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. Then, step S
At 112, the coordinates (xd (j), yd (j)) of the lattice point (p, j) (where 0 ≦ j ≦ n) forming the same row (p row) included in the transformation target after movement are moved. Is calculated according to the following equations (3) and (4). This lattice point (p, j) is indicated by a mark in FIG. 9 (b). xd (j) = (1-j / n) ³ xb1 + 3 (j / n)
・ (1-j / n) ²・ xb2 + 3 (j / n) ²・ (1-j
/ N) · xb3 + (j / n) 3 · xb4 ...... (3) yd (j) = (1-j / n) 3 · yb1 + 3 (j / n)
・ (1-j / n) ²・ yb2 + 3 (j / n) ²・ (1-j
/ N) ・ yb3 + (j / n) ³・ yb4 …… (4)

Since j = 0 in the first routine, the coordinates (xd (0), yd after the movement of the grid point (p, 0) are moved.
(0)) is calculated according to equations (3) and (4). The coordinate position of this lattice point (p, 0) is indicated by a triangle mark in FIG. 9 (b). Next, in step S114, the pointer j is incremented (advanced by 1), and in the following step S116, it is determined whether or not the pointer j has become equal to n + 1 (that is, has reached the right side of the outer frame). 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 after movement of the grid points (p, 1) forming the same row (p row) included in the deformation target are moved.
(1)) is calculated according to equations (3) and (4). Then, by repeating the same loop, j =
When it becomes n + 1, the pointer j advances to the position of the grid point (p, n), and the coordinates (xd (n), yd after the movement).
It is determined that (n)) has been calculated, and the process proceeds to step S118. In this way, lattice points (p, j) forming the same row (p row) included in the transformation target (where 0 ≦
All the coordinates (xd (j), yd (j)) after the movement of j ≦ n) are sequentially calculated. As a result, as shown in FIG. 9B, each lattice point forming the same row (p row) included in the transformation target can be transformed into a curve according to the parameters of the Bezier curve.

Then, in step S118, the pointer j is set to [1] again. As a result, preparation is made for sequentially specifying the lattice points by the pointer j along the x-axis direction. Then, in step S120, the grid point (0, j) and the grid point (m, j) are calculated according to the following equation (5).
The x coordinate (xe (j)) of is calculated. xe (j) = x1 · (n−j) / n + x2 · j / n (5) At this time, the y coordinates of the grid point (0, j) and the grid point (m, j) are y1 and y2, respectively. Becomes Then, step S
At 122, the pointer i is set to [1]. Pointer i
Indicates that grid points are sequentially designated along the y-axis direction.
Next, in step S124, the value of the pointer i is determined. This is the same line (p lines) included inside the transformation target.
In order to calculate the coordinates of the grid points (i, j) existing above and below the grid point (p, j) forming the boundary, it is determined where the position of the pointer i is with respect to the p row. It is for.

A. When the grid point (i, j) is above the p row In this case, 0 <i <p, and thus step S124.
To S126. And step S
The coordinates of the grid point (i, j) (where 0 <i <p) on the line segment connecting the grid point (0, j) and the grid point (p, j) at 126 are expressed by the following formula (6). And calculated according to equation (7). x = xe (j). (m-i) / m + xd (j) .i / m (6) y = y1. (m-i) / m + yd (j) .i / m .. (7) The grid point (i, j) is in the same upper region as the grid point indicated by a circle in FIG. 9B. Next, in step S130, the pointer i is incremented (advanced by 1), and in the following step S132, it is determined whether or not the pointer i has become equal to m (that is, has reached the lower side of the outer frame). Since the first routine is NO, the routine returns to step S124 and the same loop is repeated. In the first routine, the coordinates (x, y) of the first (that is, the uppermost) grid point (1, j) on the line connecting the grid point (0, j) and the grid point (p, j) are set. ) Is calculated, by incrementing the pointer i, next time, the second (that is, the second) position on the line connecting the grid point (1, j) and the grid point (p, j) will be calculated. The coordinates (x, y) of the grid point (2, j) are calculated. After that, by repeating the loop of steps S124 to S132, i = p
Then, since all the coordinates (x, y) of the grid points (i, j) on the line connecting the grid points (1, j) and the grid points (p, j) have been calculated, steps S24 to S130.
Jump to. This is because when i = p, the same row (p row) included inside the transformation target is designated.
Next, the process returns to step S124 again from the determination result of step S132.

B. When the grid point (i, j) is below the p-th row In this case, p <i <m, and thus step S124.
To S128. And step S
The coordinate of the grid point (i, j) (where p <i <m) on the line segment connecting the grid point (p, j) and the grid point (m, j) at 128 is expressed by the following formula (8). And calculated according to equation (9). x = xd (j) · (m−i) / (m−p) + xe (j) · (i−p) / (m−p) (8) y = yd (j) · (m−i) ) / (M-p) + y2. (I-p) / (m-p) (9) This grid point (i, j) is the same as the grid point indicated by the ● mark in FIG. 9 (b). In the lower area. Next, in step S130, the pointer i is incremented (advanced by 1), and in the following step S132, it is determined whether or not the pointer i has become equal to m (that is, has reached the lower side of the outer frame). Since the first routine is NO in step S128, the process returns to step S124 and the same loop is repeated. At this time, in the first routine that passes through step S128, the first grid point (1, j) on the line segment connecting the grid point (p, j) and the grid point (m, j)
Since the coordinates (x, y) of the grid point are calculated, the pointer i is incremented, so that the second time on the line segment connecting the grid point (p, j) and the grid point (m, j) next time.
(That is, the second) grid point (2, j) coordinates (x,
y) is calculated. After that, by repeating the loop of steps S124 to S132, when i = m, the grid point (i, j) on the line segment connecting the grid point (p, j) and the grid point (m, j) Since all the coordinates (x, y) have been calculated, the process branches from step S124 to step S132 to YES and proceeds to step S134.

In step S134, the pointer j is incremented (advanced by 1), and in the following step S136, it is determined whether or not the pointer j is equal to n + 1 (that is, whether the right side of the outer frame has been reached). In the first routine, the coordinates of the grid point (i, j) on the line segment connecting (0, 1) and the grid point (p, 1) are all calculated in the upper and lower regions of the same line (p line). Therefore, this time is NO, and the process returns to step S120 to repeat the same loop. Therefore, in the next loop, (0, 2) and the grid point (p,
The coordinates of the grid point (i, j) on the line segment connecting 2) will be calculated. Thereafter, similarly, the pointer j is sequentially incremented and the same loop is repeated, so that j =
At n + 1, the pointer j advances to the position of the grid point (0, n) and the position of the grid point (p, n), and the grid point on the line segment connecting (0, j) and the grid point (p, j) When it is determined that all the coordinates (i, j) have been calculated, this routine ends. By executing the above routine, when the vertices of a plurality of small polygons forming the same line (p lines) inside the deformation target are moved according to the parameters of the Bezier curve, after moving other grid points. The process of calculating the coordinates is performed, and as a result, the inside of the transformation target can be transformed into a curve according to the parameters of the Bezier curve, as shown in FIG. 9B.

In the above process, the coordinates (xb1, yb1), (xb4, yb4) at both ends of the curve are set on the left and right outer frames of the deformation target, that is, xb1 = x1,
If xb4 = x2 is set, only the small polygon inside can be deformed without changing the shape of the outer frame. Further, the above example describes a routine for calculating the coordinates of each grid point when the grid points forming the same line included in the transformation target are moved according to the parameters of the Bezier curve, but the present invention is not limited to this. Alternatively, for example, even when the grid points included in the deformation target and forming the same column are moved according to the parameters of the Bezier curve, the coordinates of the moved grid points can be calculated by the same process.

Further, although the Bezier curve parameter is used as the curve parameter in this embodiment, the curve parameter is not limited to this, and it is also possible to use an arbitrary curve such as a B-spline curve. In addition to this, a parabola,
It is possible to employ an arbitrary mathematical expression such as a hyperbola that allows the grid points forming the same row included in the deformation target to be smoothly arranged. In this case, in order to move the lattice points forming the same row included in the deformation target, not only a curved line expression, but also an appropriate mathematical expression depending on how to deform a parabola or a hyperbola. By doing so, it is possible to perform appropriate deformation depending on the occasion.

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 deforming the small rectangle, the vertices of a plurality of small polygons forming at least one of the same row or the same column inside the deformation target are
According to the predetermined curve parameters, at the time of moving to an arbitrary position that is located inside again after deformation, move the vertices of other small rectangles so that the entire deformation target is smoothly deformed, and move the other It is possible to calculate the vertices (coordinates: xd (j), yd (j)) of the small rectangles based on the vertices of the reference small rectangles, and transform each small rectangle into a quadrangle corresponding to the calculated vertices. Be seen. 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 the present embodiment, for example, an image of “eyes” in a bit array format as shown in FIG. 1A is smoothed to an image of “eyes” as shown in FIG. 1B. Can be transformed into

Therefore, since the transformation process is performed for each small rectangle on the array of transformation-target image data, it is not necessary to previously have totally different image data as in the conventional case, 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, by using a deformation method in which the vertices of a plurality of small polygons forming at least one of the same row or the same column inside the deformation target are moved according to a predetermined curve parameter, It is only necessary to have coordinates for several points (for example, 4 points), and the position data of the vertices of all the small polygons after transformation (for example,
You don't have to have the coordinates. Therefore, it is possible to perform a very smooth image transformation with very little transformation data. Furthermore, when this transformation method is used and the coordinates of both ends of the curve are set on the outer frame to be transformed, only the small polygon inside can be transformed without changing the shape of the outer frame. Without changing the outer shape (for example, size) of
This is effective when you want to change only the internal shape.

In addition, as a concrete ripple effect, by the application of the present invention, it is composed of dots such as characters of animation, games, etc. or background data, and the display color number or palette number 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. Some of the characters that appear in games, such as eyes, nose,
Even if you change the shape of parts such as hands and feet)
The effect is that only one image data needs to be stored. Even when adding special effects to the background of games, etc.,
Compared with the conventional expansion, reduction, and transformation from quadrilateral to quadrilateral, it is possible to perform much more free and smooth transformation, and special effects that have never existed (for example, distorting the background to express a different dimensional world). Etc.) can be added.

Second Embodiment Next, as a second embodiment of the present invention, a process of smoothly arranging the grid points on the outer frame by using a trigonometric function will be described. First, an example of a transformation target that is the target of this transformation process is shown in FIG. 13A, and an example after transformation is shown in FIG. 13B. As shown in FIG. 13 (a), the deformation target is previously set to m
Division (for example, 4 divisions), horizontal n division (for example, 6 divisions)
Then, it is divided into m × n (for example, 24) small rectangles in total. 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, when small polygons forming the same row inside the transformation target are selected and the vertices of the selected plural small polygons are moved according to the trigonometric curve parameters shown in the following equation (10): The process of calculating the coordinates of the vertices of each of the other small rectangles is performed by the same routine (FIG. 11) as in the above embodiment. y = a · sin πb (x−c) + d (10) That is, the same row (for example, P
What is possessed as deformation data for moving the vertices of a small polygon forming a line in accordance with the curve parameter of the trigonometric function is the curve parameter data shown in FIG. , The grid point before deformation (x
1, p), (x2, p)) and the trigonometric function data shown in the equation (10) for controlling the bending of the curve.

At this time, as shown in FIG. 14, the storage device 33 has a modified data area for storing the information of the trigonometric function represented by the equation (10). Amplitude of trigonometric function ... a Period of trigonometric function ... b Phase of trigonometric function ... c Offset in y direction ... d Therefore, in the second embodiment, coordinates of both ends of the curve (x1,
p), (x2, p) and control how the curve bends (1
Based on the trigonometric function data shown in equation (0), the vertices of the small polygons forming the same row inside the transformation target can be smoothly transformed, and the coordinates of the vertices of the other small rectangles can be determined in correspondence with the transformation. It can be calculated. As a result, the same effect as that of the above-described embodiment can be obtained. In particular, since the parameters of the trigonometric function are used, it is possible to perform image transformation in a mode different from that of the above-described embodiment.

Third Embodiment Next, a modification process of the third embodiment of the present invention will be described. In this embodiment, the vertices of a plurality of small polygons forming a plurality of lines (here, two lines) inside the transformation target are moved in accordance with the parameters of the Bezier curve. This is a process for calculating the coordinates of the vertices of. First, an example of a transformation target that is the target of this transformation process is shown in FIG. 15A, and an example after the transformation is shown in FIG.
It is shown in (b). As shown in FIG. 15A, the transformation target is divided into m parts vertically (for example, 4 parts) and n parts horizontally (for example, 6 parts) 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, the process of calculating the coordinates of the vertices of other small rectangles when a plurality of vertices forming two identical lines inside the transformation target are moved according to a predetermined curve parameter will be described. . This example corresponds to a case in which the vertices of a plurality of small rectangles forming two same rows inside the deformation target are deformed such that one is lowered toward the right and the other is raised. In this case, since the position is known in advance as the deformation data, the position data can be held are the vertices of the small rectangle to be deformed before the deformation shown in FIG. Of 2
The position data of one vertex is (x1, y1), (x2, y
2) is represented by coordinates. In addition, the vertices (x1, p1), (x2, p1), and (x1, p of the two small polygons forming the same two rows to be deformed before the deformation
The positions of 2) and (x2, p2) are known in advance as deformation data. On the other hand, what is held as deformation data in order to move each of the plurality of small polygons forming two same lines to be deformed according to the curve parameters is:
It is the data of the curve parameters shown in FIG. First, as the parameters of curve 1 corresponding to one row,
Coordinates (xb1, yb1) at both ends of the curve 1 (xb4, y
b4) and the coordinates (xb2, y) that control how the curve bends.
b2) and (xb3, yb3). Further, as the parameter of the curve 2 corresponding to the other selected line, the curve 2
Coordinates of both ends of (xc1, yc1), (xc4, yc4)
And the coordinates (xc2, yc
2) and (xc3, yc3).

As shown in FIG. 16, 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

17 and 18 are flowcharts showing the routine of the lattice point coordinate calculation processing after the deformation. The method of generating the Bezier curve used in this routine is the same as that in the above-described embodiment, and thus the duplicated description will be omitted. In this routine, the vertices (lattice points) of a plurality of small polygons forming two identical lines to be deformed are respectively moved according to the Bezier curve parameters based on the above Bezier curve generation method. A process of calculating the coordinate after movement of another grid point at this time 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). First, the processing regarding the lattice points forming the p1 row on the upper side will be described.

A. Processing of grid points forming row p1 In step S200, the pointer j is set to [0].
The pointer j is for sequentially designating grid points along the x-axis direction. Next, in step S202, the coordinates (xd (j), after movement of the grid points (p1, j) (where 0 ≦ j ≦ n) forming the same row (here, row p1) included in the transformation target, yd (j)) is calculated according to the equations (11) and (12) shown below. 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) 3 · xb4 ...... (11) yd (j) = (1-j / n) 3 · yb1 + 3 (j / n)
・ (1-j / n) ²・ yb2 + 3 (j / n) ²・ (1-j
/ N) ・ yb3 + (j / n) ³・ yb4 …… (12)

Since j = 0 in the first routine, the coordinates (xd (0), yd after the movement of the grid point (p1, 0) are moved.
(0)) is calculated according to equations (11) and (12). The coordinate position of this grid point (p1, 0) is shown in FIG.
It is indicated by a triangle mark in (b). Then, step S2
In 04, the pointer j is incremented (advanced by 1), and in the following step S206, 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). This time is NO, so step S202
Return to and repeat the same loop. Therefore, in the next loop, the same line (line p1) included inside the transformation target
Of the grid point (p, 1) forming the
(1) and yd (1) are calculated according to the equations (11) and (12). Then, by repeating the same loop, when j = n + 1, the pointer j advances to the position of the grid point (p1, n), and the coordinate (xd
It is determined that (n), yd (n)) have been calculated, and the process proceeds to step S208. In this way, the lattice points (p1, p1) that form the same row (row p1) included inside the transformation target
j) (where 0 ≦ j ≦ n) after movement (xd
(J) and yd (j)) are all sequentially calculated. As a result, as shown in FIG. 15B, each lattice point forming the same row (row p1) included inside the transformation target is set to the Bezier curve 1
It can be transformed into a curve according to the parameters of.

Next, the processing for the lattice points forming the p2 row on the lower side will be described. B. In the processing step S208 of the lattice points forming the p2 row, the pointer j is set to [0] again.
Set to. As a result, each grid point is again moved to the pointer j
By this, designation is made sequentially along the x-axis direction. Then, in step S210, grid points (p) that form the same row (here, p2 row) included inside the transformation target
2, j) (where 0 ≦ j ≦ n) after movement (xd
2 (j) and yd2 (j)) are calculated according to the following equations (13) and (14). This grid point (p2,
j) is indicated by a triangle mark in FIG. xd2 (j) = (1-j / n) ³ * xc1 + 3 (j /
n) · (1-j / n) ² · xc2 + 3 (j / n) ² · (1
-J / n) * xc3 + (j / n) ³ * xc4 ... (1
3) yd2 (j) = (1-j / n) ³ · yc1 + 3 (j /
n) ・ (1-j / n) ²・ yc2 + 3 (j / n) ²・ (1
-J / n) · yc3 + ( j / n) 3 · yc4 ...... (1
4)

Since j = 0 in the first routine, the coordinates (xd2 (0), yd after the movement of the grid point (p2, 0) are moved.
2 (0)) is calculated according to the equations (13) and (14). The coordinate position of this lattice point (p2, 0) is shown in FIG.
It is indicated by a triangle mark in (b). Then, step S2
The pointer j is incremented by 12 (advance by 1), and the pointer j becomes equal to n + 1 in the subsequent step S214 (that is, whether the right side of the outer frame is reached).
Determine whether or not. This time is NO, so step S2
Return to 10 and repeat the same loop. Therefore, in the next loop, the same line (p2
Coordinates (x) after movement of grid points (p2, 1) forming a row
d2 (1) and yd2 (1) are expressed by equation (13) and (1
It is calculated according to the equation 4). Then, by repeating the same loop, when j = n + 1, the grid point (p
The pointer j is advanced to the position of (2, n) and it is determined that the coordinates (xd2 (n), yd2 (n)) after the movement are calculated, and the process proceeds to step S216. In this manner, the coordinates (xd2 (j), yd2 (, j)) are all calculated sequentially. As a result, as shown in FIG. 15B, each lattice point forming the same row (row p2) included in the transformation target can be transformed into a curve according to the parameters of the Bezier curve 2.

Then, in step S216, the pointer j is set to [0] again. As a result, preparation is made for sequentially specifying the lattice points by the pointer j along the x-axis direction. Next, at step S218, the grid point (0, j) and the grid point (m,
The x coordinate (xe (j)) of j) is calculated. xe (j) = x1 · (n−j) / n + x2 · j / n (15) At this time, the y coordinates of the grid point (0, j) and the grid point (m, j) are y1 and y2, respectively. Becomes Then, step S
At 220, the pointer i is set to [1]. Pointer i
Indicates that grid points are sequentially designated along the y-axis direction.
18, the value of pointer i is determined in step S222. This is because grid points (p1, j) and (p2, j) that form two identical rows (row p1 and row p2) included in the transformation target are the grid points existing above and below those grid points. In order to calculate the coordinates of (i, j),
This is for judging where the position of the pointer i is located on the basis of the p1 and p2 lines.

C. In the case where the grid point (j, i) is above the p1 row In this case, 0 <i <p1 is established, so step S22
It branches from 2 to step S224. Then, in step S224, the grid point (i, j) on the line segment connecting the grid point (0, j) and the grid point (p1, j) (where 0 <i <p1)
The coordinate of is calculated according to the following equations (16) and (17). x = xe (j). (p1-i) / p1 + xd (j) .i / p1 ... (16) y = y1. (p1-i) / p1 + yd (j) .i / p1 .. (17) This The grid point (i, j) is in the upper region of the p1 row in FIG. 15 (b). Next, in step S230, the pointer i is incremented (advanced by 1), and in the following step S232, it is determined whether or not the pointer i has become equal to m (that is, has reached the lower side of the outer frame). Since the answer is NO in the first routine, the process returns to step S222 and the same loop is repeated.

In the first routine, the first (that is, the following) on the line connecting the grid point (0, j) and the grid point (p1, j):
Since the coordinates (x, y) of the grid point (uppermost) (1, j) are calculated, by incrementing the pointer i, next time the grid point (1, j) and the grid point ( The coordinates (x, y) of the second (that is, the second) lattice point (2, j) on the line connecting p1, j) are calculated.
After that, the loop of steps S222 to S232 is repeated, but when i = p1 is reached midway, step S22
According to the determination result of 2, the process directly jumps to step S230. This is because when i = p1, the same row (row p1) included inside the transformation target is designated.
After that, through steps S230 and S232,
It returns to step S222 again.

D. When the grid point (i, j) is between the p1 row and the p2 row In this case, since the state of i = p1 is exceeded and p1 <i <p2, the process branches from step S222 to step S226. Then, in step S226, the grid point (p1,
j) and the grid point (p2, j) on the line segment (i,
j) (However, p1 <i <p2) coordinates are calculated according to the following equations (18) and (19). x = xd1 (j). (p2-i) / (p2-p1) + x
d2 * (i-p1) / (p2-p1) ... (18) y = yd1 (j) * (p2-i) / (p2-p1) + y
d2 ・ (i-p2) / (p2-p1) (19)

This lattice point (i, j) is located in the area between the p1 row and the p2 row in FIG. 15 (b).
Next, in step S230, the pointer i is incremented (advanced by 1), and in the following step S232, it is determined whether or not the pointer i has become equal to m (that is, has reached the lower side of the outer frame). Since it is NO in the first routine that passes through step S226, step S222
Return to and repeat the same loop. At this time, step S
In the first routine passing through 226, the grid points (p1,
Since the coordinates (x, y) of the first grid point (1, j) on the line segment connecting j) and the grid point (p2, j) are calculated, by incrementing the pointer i ,
Next time, the second (that is, the second) grid point (2, on the line segment connecting the grid point (p1, j) and the grid point (p2, j))
The coordinates (x, y) of j) are calculated. After that, step S
By repeating the loop of 222, step S226, step S230, and step S232, the grid point (p
1, j) and the grid point (p2, j) on the line segment connecting the grid points (i, j) coordinates (x, y) are all calculated, at the time point i = p2 in step S232, Step S22
According to the determination result of 2, the process directly jumps to step S230. This is because when i = p2, the same row (row p2) included inside the transformation target is designated.
After that, through steps S230 and S232,
It returns to step S222 again.

E. When the grid point (i, j) is on the lower side of p2 In this case, p2 <i <m, and therefore step S22.
It branches from 2 to step S228. Then, in step S228, the grid point (i, j) on the line segment connecting the grid point (p2, j) and the grid point (m, j) (where p2 <i <m)
The coordinates of are calculated according to the following equations (20) and (21). x = xd2 (j) · (m−i) / (m−p2) + xe
(J) · (i−p2) / (m−p2) (20) y = yd2 (j) · (m−i) / (m−p2) + y2 ·
(I-p2) / (m-p2) (21)

This lattice point (i, j) is on the lower side of the p2 row in FIG. 15 (b). Then, step S230
The pointer i is incremented by 1 (advance by 1), and it is determined in a succeeding step S232 whether or not the pointer i becomes equal to m (that is, the lower edge of the outer frame is reached).
Since the first routine is NO in step S228, the process returns to step S222 to repeat the same loop. At this time, in the first routine that passes through step S228, the coordinates (x, x) of the first grid point (1, j) on the line segment connecting the grid point (p2, j) and the grid point (m, j) are set.
Since y) is calculated, by incrementing the pointer i, next time, the second (that is, the following) is obtained on the line segment connecting the grid point (p2, j) and the grid point (m, j).
The coordinates (x, y) of the (second) grid point (2, j) are calculated. After that, when i = m by repeating the loop of steps S222 to S232, the grid point (i, j) on the line segment connecting the grid point (p2, j) and the grid point (m, j) Since all coordinates (x, y) have been calculated, the process branches from step S232 to YES and step S232 is performed.
Proceed to 234.

In step S234, the pointer j is incremented (advanced by 1), and in the following step S236, it is determined whether or not the pointer j has become equal to n + 1 (that is, whether the right side of the outer frame has been reached). In the first routine, the coordinates of the grid point (i, j) on the line segment connecting (0, 1) and the grid point (m, 1) are all calculated in the vertical direction by passing through the rows p1 and p2. Therefore, this time is NO, and the process returns to step S222 to repeat the same loop. Therefore, in the next loop, the coordinates of the grid point (i, j) on the line segment connecting (0, 2) and the grid point (m, 2) will be calculated. Thereafter, similarly, the pointer j is sequentially incremented and the same loop is repeated. When j = n + 1, the pointer j advances to the position of the grid point (0, n) and the position of the grid point (m, n). All coordinates of the grid point (i, j) on the line segment connecting (0, j) and the grid point (m, j) are calculated, that is, p1
It is determined that the coordinates of each grid point in all areas including the row and the p2 row have been calculated, and this routine ends. By executing the above routine, the vertices of a plurality of small polygons forming two identical rows (rows p1 and p2) inside the transformation target are moved according to the parameters of Bezier curve 1 and Bezier curve 2. When this is done, the process of calculating the coordinates after the movement of the other grid points is performed, and as a result, the inside of the deformation target follows the parameters of Bezier curve 1 and Bezier curve 2 as shown in FIG. It can be transformed into a curved line.

In the above processing, the coordinates (xb1, yb1), (xb4, yb4), (xc) at both ends of the curve are obtained.
1, yc1) and (xc4, yc4) are set on the left and right outer frames of the deformation target before deformation, that is, xc1 = x1,
By setting xc4 = x2 and xc4 = x2, it is possible to deform only the inner small polygon without changing the shape of the outer frame. In the above process, the lattice points forming the p1 row inside the transformation target are moved according to the parameters of the first Bezier curve, and the lattice points forming the p2 row are moved according to the parameters of the second Bezier curve. However, the arrangement of the curve parameters may be arbitrary. For example, when the respective grid points forming a plurality of rows inside the deformation target are moved according to the curve parameters corresponding to the respective grid points, the same processing is performed. The coordinates after the movement of the grid points can be calculated.

Therefore, also in the third embodiment, it is possible to obtain the same effect as the above-mentioned embodiment. In this case, in particular, if curve parameters are assigned to each of a plurality of rows or to each of a plurality of columns, a more complicated transformation can be performed. Although the Bezier curve parameters are used as the first and second curve parameters in the above embodiment, the present invention is not limited to this, and it is also possible to use an arbitrary curve such as a B-spline curve. In addition to this, parabola, hyperbola,
It is possible to employ an arbitrary mathematical expression such as a trigonometric function that can smoothly arrange the grid points forming a plurality of rows or columns inside the transformation target. In this case, in order to move each lattice point, not only a curved line expression, but an appropriate mathematical expression may be used according to the way of deforming a parabola, a hyperbola, a trigonometric function, or the like. By doing so, appropriate deformation can be performed depending on the occasion.

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. 19 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. 20A, 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. 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 process 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. 20 (a) and 20 (b), it is necessary to pay attention to the following state in the process of sequentially attaching each of the divided lines to the transformed quadrangle according to the image transformation 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 part indicated by a star mark in FIG. 20 (b), and 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.
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. 21 shows how the lines are attached twice. FIG. 21A shows original image data before transformation, and more specifically, it corresponds to one small rectangular image data obtained by dividing the transformation-source image data in the bit array format. FIG. 21B 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.
1 to 28 show a small rectangle before deformation and a quadrangle after deformation in a plurality of execution processes when the line pasting method is executed, and specific examples of each process will be described when a subroutine described later is described. Describe.

Next, 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.

Next, 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. As shown in FIG. 31, for example, 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. 32 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 to be started are stored in an area called 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. 30, 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

Next, 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.
22A shows a side AB that is one end point of the line before deformation shown in FIG. 22A, FIG. 22B shows a state of a side A′B ′ that 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. 22, 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).

It should be noted that here, since it is for coordinate determination, 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.

In this way, 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. 22 (when the position of the side A'B 'which is one end point of the pasting 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, and thus the error increment Δe is Δe = (4-1) / (11-1) = It is 0.30. Next, since the selection error e is initially set to e = 0, it is left as it is, and 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. 22 (c)). Also, the selection error e is 1
Since it is less than / 2, the selection error e is not corrected. Next, the error increment Δe is set to the selection error e = 0.30 so far.
.DELTA.e = 0.30 is added, then e = 0.30 + 0.
Since 30 = 0.60 ≧ (1/2), the X coordinate of the next hit point is changed (see FIG. 22C). By repeating the above process, the X coordinate is changed at the positions of and, and finally, as shown in FIG.
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,
In step S1238, the process for changing the Y coordinate is performed. 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 coordinate are stored in the end point buffer (see FIG. 30). 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. 23 (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. 23A shows a side DC which is the other end point of the line before deformation, FIG. 23B 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 the image is drawn over 4 pixels and 5 pixels in the X direction, the error increment Δe is Δe = (5-1) / (14-1) = 0.30. Next, since the selection error e is initially set to e = 0, it is left as it is, and when Δe = 0.30 is added as the error increment Δe, e = 0 + 0.30 = 0.3
0 <(1/2). Therefore, at this time, the X coordinate of the next hit point is not changed (see FIG. 23 (c)). 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. 23).
See c)). By repeating the above process,
, (12) (Note that the numbers with a circle from 10 onward are difficult to display, so they are represented by parenthesized half-width numbers), and the X coordinate is changed, and finally as shown in FIG. 23 (c). , The position of the end point C ′ is determined.

Now, returning to the flowchart of FIG. 33 again, when the end point positions are determined, step S1218
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.

Next, 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. .

Here, a specific example in the case of FIG. 24 (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. Figure 24
FIG. 24A shows a side AB which is one end point of the line before deformation, FIG. 24B 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). . As a result, the line number is advanced by 1 (becomes line 1: see FIG. 24 (c)). Therefore, the end points of the line 1 are assigned to the points on the side A′B ′ (FIG. 24).
(See (b)). At this time, the selection error e is corrected as follows. e = 1.10-1 = 0.10 <1/2

When 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 24)
(See (c)). Therefore, the end points of the line 2 are assigned to the points on the side A′B ′ (see FIG. 24B).
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 endpoints of line 5 (FIG. 24 (b)).
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. 33 again, description will be made. The above description is the processing content of allocating the end points of the pasting line to a side shorter than the original side AB such as the side A′B ′, but this time, the side D ′ shown in FIG. An edge D as shown in FIG.
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 onward shown in FIG. 33 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. 33 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, error correction is performed in 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. 25 (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. Figure 25
25A shows a side DC that is one end point of the line before deformation, FIG. 25B shows a state of a side D′ C ′ that is one end point of the line to be attached, and FIG. 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. 25 (c)). Therefore, the end points of the line 1 are assigned to the points on the side D'C '(FIG. 25).
(See (b)). At this time, the selection error e is corrected as follows. e = 0.84-1 = -0.16 <1/2

Similarly, the line 2 is located at a point on the side D'C '.
, And the end point of line 3 is assigned to the point (see FIG. 25B). 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 a point (see FIG. 25 (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. 36, 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. 34 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].

Next, 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. 30). 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. FIG. 26 shows a specific example in which the position of each dot is obtained in order to paste the line 0. FIG. 26
26A shows the line AD before the deformation, FIG. 26B shows the state of the line side A′D ′ after the 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 S1328 shown in FIG. Further, in this case, in the case shown in FIG. 26, 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.

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 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, then the process shown in FIG.
In step S1328 of step 5, 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. 32, 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 3
In the routine of No. 2, 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, whereas in the routine of FIG. 34, the number of pixels is changed. 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 as described above, next, the processing content for obtaining which dot in the dots of the original horizontal dot line is to be assigned (that is, the dot is selected) is 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, the dot number is changed to the next dot number at least when the error increment Δe3 is larger than half of 1. 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.
This will be described with reference to FIG. FIG. 28 (a) shows the dots on the transfer source line before the deformation, FIG. 28 (b) shows the 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 there are 6 dots and the number of dots on 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 when Δe = 0.93 is added as the error increment Δe, 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. 28 (b), FIG. 28
(See (c)).

Then, similarly, the selection errors e up to this point 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).
8 (b) and FIG. 28 (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. 28).
(B) and FIG. 28 (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. 24, comparing the numbers of pixels on sides A'B 'and D'C', the number of pixels on side A'B 'is 11, and the number of pixels on side D'C' is 14, , D′ C ′ pixels (= 14). Specifically, as shown in FIG. 24B, 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. 29 (b). Note that FIG. 29A is a line of image data before transformation. As shown in FIGS. 21 (a) and 21 (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.

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 quadrilaterals. 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.

[0123]

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 a plurality of small polygons forming at least one of the same row or the same column inside the object to be deformed are subjected to predetermined curve parameters, and at least after being deformed, they are positioned inside again. When moved to an arbitrary position, the vertices of the other small polygons are moved according to the movement of the plurality of small polygons, and the vertices of the other moved small polygons are moved after the movement of the arbitrary small polygons. Calculate based on the vertices of, and transform each small polygon corresponding to the calculated vertices,
Further, the array of the bit array format image data included in the small polygon before transformation is sequentially changed for each small polygon so as to correspond to the data of the transformed small polygon according to a predetermined data conversion process. Since the whole image after the change is created,
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, by using a deformation method in which the vertices of a plurality of small polygons forming at least one of the same row or the same column inside the deformation target are moved according to a predetermined curve parameter, It is only necessary to have coordinates for several points (for example, 4 points), and the position data (for example, coordinates) of the vertices of all the small polygons after transformation.
You don't have to have one. Therefore, it is possible to perform complex and very smooth image transformation with very little transformation data. Using this transformation method, it is possible to transform only the small polygon inside without changing the shape of the outer frame to be transformed,
This is effective when it is desired to change only the internal shape without changing the outer shape (for example, size) of the image data.

According to another aspect of the present invention, in the small polygon deforming process, a plurality of rows forming at least one of a plurality of rows or a plurality of columns inside the object to be deformed is formed. Since the transformation method of moving the vertices of each small polygon of the group of small polygons according to the predetermined curve parameters is used, the position data (for example, the coordinates) of the vertices of all the small polygons after transformation are also used. It is not necessary to hold the image, and it is possible to perform smooth image transformation with a small amount of transformation data. Furthermore, in the above modification method, if the coordinates of both ends of the curve are set on the outer frame to be deformed, without changing the shape of the outer frame,
Only the inner small polygon can be transformed, which is effective when it is desired to change only the inner shape without changing the outer shape (for example, size) of the image data. Further, if a curve parameter is assigned to each of a plurality of rows or a plurality of columns, a more complicated transformation can be performed.

[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 diagram illustrating a modification process of a modification target according to the second embodiment of the present invention.

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

FIG. 15 is a diagram illustrating a modification process of a modification target according to the third embodiment of this invention.

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

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

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

FIG. 19 is a flowchart showing a subroutine of a line pasting process of each of the above embodiments.

FIG. 20 is a diagram showing a modified example of the image data of each of the embodiments.

FIG. 21 is a diagram showing a modified example of the image data of each of the above embodiments.

FIG. 22 is a diagram showing a modified example of the image data of each of the above embodiments.

FIG. 23 is a diagram showing a modified example of the image data of each of the embodiments.

FIG. 24 is a diagram showing a modified example of the image data of each of the embodiments.

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

FIG. 26 is a diagram showing a modified example of the image data of each of the embodiments.

FIG. 27 is a diagram showing a modified example of the image data of each of the embodiments.

FIG. 28 is a diagram showing a modified example of the image data of each of the embodiments.

FIG. 29 is a diagram showing a modified example of the image data of each of the embodiments.

FIG. 30 is a diagram showing an example of storing data in an internal register of the CPU of each of the above embodiments.

FIG. 31 is a diagram illustrating an example of line drawing in each of the embodiments.

FIG. 32 is a flowchart showing a part of a subroutine of line end point processing in each of the embodiments.

FIG. 33 is a flowchart showing a part of a subroutine of line end point processing in each of the above embodiments.

FIG. 34 is a flowchart showing a part of a subroutine of the line drawing process of each of the embodiments.

FIG. 35 is a flowchart showing a part of a subroutine of the line drawing process of each of the embodiments.

FIG. 36 is a diagram showing an example of storing data in the end point buffer of each of the embodiments.

[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 array of the image data in the bit array format included in the polygon is sequentially changed for each small polygon according to the predetermined data conversion process so as to correspond to the deformed small polygon data, and the whole image after the change In addition to creating data, in the processing for transforming the small polygon, the vertices of the plurality of small polygons forming at least one of the same row or the same column inside the transformation target are set to predetermined curve parameters. According to the above, at least after being deformed, when moved to an arbitrary position that is located inside again, the vertices of the other small polygons are moved in accordance with the movement of the plurality of small polygons, and the other small polygons are moved. The top of An image transforming method, characterized in that calculation is performed based on the vertices of several small polygons after movement, and each small polygon is transformed corresponding to the calculated vertices. 2. The small polygon deforming process, wherein each small polygon of a group of a plurality of small polygons forming at least one of a plurality of rows or a plurality of columns inside the object to be deformed. When the vertices of the plurality of small polygons are moved to an arbitrary position such that they are located again inside at least after the deformation according to the predetermined curve parameters, the vertices of the other small polygons are moved according to the movement of the plurality of small polygons. Then, the vertices of the other moved small polygons are calculated based on the moved vertices of the plurality of small polygons,
The image transforming method according to claim 1, wherein each small polygon is transformed corresponding to the calculated vertex. 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 1
Alternatively, the image transformation method described in 2. 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. Alternatively, the image transformation method described in 2. 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 3. The image transformation method according to claim 1 or 2, further comprising: a process of sequentially transferring and arranging a line starting from an end point on a line corresponding to the transformed 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 transformation target having bit array image data into a plurality of small polygons, and at least one of the same row or the same column inside the transformation target. When the vertices of the plurality of small polygons are moved to arbitrary positions that are located inside again after the deformation at least according to the predetermined curve parameters, the other small polygons are moved according to the movement of the plurality of small polygons. The vertices of the polygon are moved, the vertices of the other moved small polygons are calculated based on the moved vertices of the plurality of small polygons, and each small polygon divided by the dividing means corresponds to the calculated vertices. Deformation means for transforming a polygon into different small polygons, and an array of image data in the bit array format included in the pre-deformation small polygon are processed for each small polygon according to a predetermined data conversion process. For small polygon data Image transformation apparatus, wherein the image data generating means, further comprising a creating entire image data after the change are sequentially changed to. 10. The deforming means defines a vertex of each small polygon of a group of a plurality of small polygons forming at least one of a plurality of rows or a plurality of columns inside the object to be deformed, The image transforming apparatus according to claim 9, wherein the transforming process is performed according to a predetermined curve parameter such that the transforming process is performed such that the transforming process is moved to an arbitrary position that is located inside again after the transforming. 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 9. The image transformation device according to item 9 or 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 transforming device according to claim 9 or 10, 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. 11. The method according to claim 9 or 10, wherein
The image transformation device described. 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 controlling the image deformation by reading out each data stored in the storage means when the deformation mode is specified by the deformation mode designating means. The image transformation device according to claim 9.