JP3505360B2 - Animation creation device and recording medium - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an apparatus for controlling, for example, creation / editing of CG animation.

[0002]

2. Description of the Related Art Improving the processing performance of personal computers (PCs) is making it possible to handle real-time computer graphic animations (CG animations) on PCs. Along with this, the number of various CG applications operating on a PC is increasing, and the number of opportunities for general individuals to create and appreciate CG content is also increasing. With the increase in such opportunities, various applications for creating CG animation on a PC have been devised.

Means for creating a CG animation on a PC include those based on a three-dimensional coordinate data set (three-dimensional CG animation) and those based on a bitmap data set (two-dimensional CG animation). .

Among these, in the case of creating a CG animation based on a bitmap data set, a bitmap data set corresponding to each scene is prepared, and these bitmap data are displayed while being switched. , Display CG animation. One scene may be configured by preparing a plurality of bitmap data called sprites corresponding to each display object to be displayed and displaying the sprites in an overlapping manner. In this case, an animation is generated by changing the display position of the sprite for each scene or by switching and displaying a plurality of sprites corresponding to each scene.

Since the two-dimensional CG animation is composed of a bitmap data set, each scene can be created by simply drawing a picture. Therefore, anyone can create it as long as it takes time. Further, since only the bitmap image is displayed, the processing amount when the animation is reproduced is constant regardless of the fineness and complexity of the display object of each scene (contents of the bitmap image).

However, in order to create a two-dimensional CG animation having a complicated motion as intended by the user, it is necessary to create each bit map image. It will take a lot of trouble. Of course, a two-dimensional CG animation that only creates a small number of bitmap images and moves them as sprites, or switches and displays them can be created without much effort, but as a result, it is a fairly simple animation. Only that can be displayed.

Even if a huge amount of bitmap images can be created, a storage device of a considerable size is required to store all the bitmap data.
To efficiently compress such data, dedicated hardware having an encoding function such as Objective MPEG is also required.

On the other hand, there is a means called "warping" which can generate different scenes by deforming one bit map image as an original image. As shown in FIG. 28, in warping, control points called control points are arranged in a grid on the original image, the positions of the control points are changed, and the control points are located in the area surrounded by the control points. By transforming the existing bitmap image according to the change of the area surrounded by the control points, a new scene will be generated.

However, since the warping means is a means for creating a new scene only by deforming a mesh-shaped rectangular area surrounded by control points, there are considerable restrictions on the scenes that can be created. For example, since the movable range of the control points is limited to the area surrounded by the adjacent control points, it is extremely difficult to greatly move only the image area corresponding to the hand of the human figure, as shown in FIG. is there. Further, when the moved hand portion overlaps the face portion, the shape of the image area corresponding to the face cannot be kept as it is.

In order to avoid this, the original image must be separated into sprites composed of a plurality of parts such as a hand part and a face part. Therefore, one existing bitmap original image is In order to use it, it is necessary to divide the original bitmap image into a plurality of sprites in advance, and it is necessary to perform a considerably complicated preprocessing.

Even if the scene is not exactly the way one desires, even if the warping process is forcibly performed, a huge number of control points are operated one by one in order to create a CG animation like a joint motion of a hand. There is a need. In that case, it is difficult to call it a practical means because it is necessary to move the position of each control point while considering the condition to be saved such as not changing the balance of the shape of the hand.

A means to which "warping" is applied,
A method called "morphing" can generate different images by generating an interpolated image of two bitmap images. As shown in FIG. 30A, in morphing, it is necessary to specify a control point for each of the two bitmap images so as to indicate the corresponding positional relationship between the two bitmap images. In FIG. 30 (b), the control points a1 and b1 that correlate the hand positions of the scene A and the scene B are designated, but the interior division point m1 is determined on the straight line connecting the control points a1 and b1. ,
A1 → m1 in scene A, b1 → m in scene B
By changing the control point to 1 and then performing the warping process, the positions of the hands of both scenes can be moved to almost the same position. And the generated 2
By blending two warping scenes at an appropriate ratio, it is possible to automatically generate an interpolated scene.

Here, when an intermediate scene is created and continuously displayed while moving the interior division point m1 along the straight line a1 → b1 little by little, the CG animation changes from scene A to scene B. Becomes

However, since the morphing means is an application of the warping means to the last, there are restrictions similar to those of the warping means in the scenes that can be created. For example, due to the restriction of the movable range of the control point in the warping means, even if the scene where the hand is opened and the scene where the hand is crossed are morphed, a natural animation cannot be generated.
Furthermore, it is necessary to set the control points indicating the same position between the two images in a one-to-one correspondence, so when setting a large number of controls, etc.
Even just grasping the correspondences would be quite troublesome.

Further, in order to create a CG animation like another joint motion, two bitmap images differing only in the degree of hand bending are prepared, and the positional relationship between the two bitmap images is controlled. It is difficult to say that it is a practical means because it is necessary to specify a considerable number of control points one by one in order to realize a natural animation in addition to the operation of specifying .

Anyone can use the intuitive and simple operation
In order to generate a G animation, a means for generating an animation having all motions from one bitmap image is desired, but as described above, conventional CG animation creation based on a bitmap data set. Means could not meet such demands.

[0017]

As described above, in the conventional CG animation creating apparatus based on the bitmap data set, one bitmap image serving as the original image or the original image is constructed. It was not possible to generate a CG animation having an arbitrary motion only by performing an intuitive and simple operation on a bitmap image as one sprite.

Now, let us consider the case of creating a CG animation that performs joint motion of a human hand. In the method based on 3D CG animation, a human body model (skeleton model) in which 3D coordinate data representing the shape of a hand is set is created, and the motion is called inverse kinematics (inverse dynamics) for each joint angle. It was generated by calculating the inverse operation. These processes are very heavy, and interactive animation that requires real-time processing was impossible.

If a stroke-based animation for expressing the movement of the hand is performed based on the above-mentioned movement based on the bitmap data set, the whole shape is not saved, so that the animation is unnatural. turn into. If you try to create an animation for a subject (hand movement) that these humans usually see, this looks strange.

On the other hand, if the keyframes of the animation are broken into small pieces, the above-mentioned unnaturalness becomes inconspicuous, but the keyframe setting know-how to make it look like that and the animation creation process increase. You will not be able to create animations with intuitive operations. In addition, if a start point stroke and an end point stroke are defined and an interpolation stroke between them is automatically generated, it is not satisfactory for expressing a complicated animation.

Conventionally, when three-dimensional shape data obtained by using a distance measuring device such as a range finder is displayed on a screen in a grid pattern, the unevenness of the shape can be recognized from the spatial density of the grid. . However, this is for the purpose of grasping the shape, and the use of creating animation by changing the lattice state with time is not considered.

Further, since it is impossible to control the stroke state between key frames temporally and spatially, the animation shape is considerably restricted. In particular, the mapping method of the bitmap image assigned to the stroke cannot be changed according to the shape and position of the stroke.

In view of the above problems, the present invention provides a target bitmap image for one bitmap image serving as an original image or one sprite bitmap image forming the original image. It is an object of the present invention to provide an animation creating apparatus that can easily generate an animation having an arbitrary motion only by performing an intuitive and simple operation of inputting a stroke that expresses a series of motions.

Also, by changing the interpolation stroke shape between key frames and the mapping of the bitmap image according to it in time and space, a highly expressive animation accompanied by a three-dimensional image effect. It is an object of the present invention to provide an animation creating device capable of creating an animation.

[0025]

Animation of the present invention
The creation device is an animation creation device that creates an animation by creating an image that interpolates between a plurality of frame images, and a first input unit that inputs one or a plurality of strokes to each of the frame images, Constraint information (e.g., constraint stroke, constraint function) of the stroke change shape when the stroke input by the first input means is interpolated between the plurality of frame images.
A second input unit for inputting a stroke, an interpolation position for interpolating a stroke input by the first input unit between the plurality of frame images, the constraint information, and the first input unit. And a generating means for generating an interpolation stroke based on the stroke and the keystroke and the keystroke because the interpolation stroke between the input keystrokes is generated based on the constrained stroke that defines the positions of both end points thereof. By saving the entire shape of the neighborhood, animations with natural movement can be easily generated.

Also, the animation creating apparatus of the present invention
Is an animation creating apparatus for creating an animation by creating an image that interpolates between a plurality of frame images, the first creating means inputting one or a plurality of strokes to each of the frame images; Quantizing means for quantizing each of the strokes input by the first input means associated with each other between the frame images into a unit vector of a predetermined length, and the stroke input by the first input means. Second input means for inputting a constraint condition for constraining a change shape of a stroke when interpolating between the plurality of frame images, an interpolation position for interpolating between the associated strokes, and the constraint information. An interpolation vector is generated based on the corresponding unit vector of the associated stroke, and based on the generated interpolation vector Generating means for generating an interpolated strokes interpolating between serial associated stroke, by provided with the, deforms with constraint function interpolation stroke produced, for example, 3 such swelling and uneven
It is possible to easily generate an animation that promotes a three-dimensional visual effect.

Furthermore, the animation creating apparatus of the present invention
Is moved or deformed, or moved and deformed, in accordance with the position and shape of the interpolation stroke generated by the generation means, into an image of the region near the stroke input by the first input means to form the frame image. By further comprising interpolation image generation means for generating an image that interpolates between the frame images by synthesizing, an interpolation stroke between input keystrokes is generated based on a constraint stroke that defines the positions of both end points thereof. Because
Save the keystroke and the entire shape around it,
Animations with natural movements can be easily generated. In addition, the generated interpolation stroke can be transformed using a constraint function to easily generate an animation that promotes a three-dimensional visual effect such as rising and unevenness. In addition, when an image near the cut out stroke is mapped to an interpolation stroke, by performing processing such as deformation and blurring, it is possible to easily create an expressive animation having a special video effect.

[0028]

BEST MODE FOR CARRYING OUT THE INVENTION Embodiments of the present invention will be described below with reference to the drawings.

(First Embodiment) First, the case of creating an animation of a line drawing (an image composed of a plurality of line segments called a plurality of strokes) will be described.

FIG. 1 schematically shows a configuration example of an animation creating apparatus according to the first embodiment of the present invention. As shown in FIG. 1, the animation creation device
A keystroke input means 1 for inputting a stroke to be registered in a keyframe, a keystroke quantization means 2 for decomposing (quantizing) a stroke into a unit vector of an arbitrary length, and a unit vector storage for storing the unit vector. Means 3, constraint stroke input means 4 for inputting a constraint stroke that constrains deformation of an interpolation stroke generated for interpolating the keystroke input by the keystroke input means 1 between keyframes, and a key Interpolation frame number input means 5 for inputting the number of interpolation frames for interpolating between frames, constraint stroke quantization means 5 for decomposing (quantizing) constraint strokes into the same number of unit vectors as the number of interpolation frames, and a key Interpolate between keyframes based on stroke unit vector and constraint stroke unit vector An interpolation vector generation means 7 for generating an interpolation vector, and the generated animation, etc. from the image presentation means 8 which is displayed on a predetermined display device.

Here, terms used in the following description will be explained.

A key frame is a line drawing (consisting of (curved) line segments forming the skeleton of an animation) which the user has input as a key stroke of a change in movement through the key stroke input means 1.

The interpolation frame is a frame image interpolated between key frames.

The interpolation stroke is a stroke composed of the interpolation vector generated by the interpolation vector generating means 7 when the key stroke is interpolated between the key frames.

The reproduction interval is a reproduction time interval between interpolation frames.

With such a configuration, the keystroke input means 1 inputs a keystroke indicating a change in movement to each key frame, and the constrained stroke input means 4 inputs a constrained stroke for constraining the deformation of the interpolation stroke. Then, an animation is created by generating an interpolation stroke that interpolates between key frames based on the key stroke and the constraint stroke.

Next, the processing operation of the animation creating apparatus of FIG. 1 will be described with reference to FIGS.

2 to 5 are flowcharts showing the overall processing operation of the animation creating apparatus of FIG.

First, the key frame number i (i = 0 to 0)
n), the number of interpolated frames f and the reproduction interval t are initialized (step S1), and the state shifts to the input waiting state (step S2). At this time, the user gives an image reading instruction (step S3) and a keystroke input instruction (step S3).
4), constraint stroke input instruction (step S5), animation playback instruction (step S6), interpolation frame number f instruction via interpolation frame number input means 5 (step S7), end instruction (step S8), Other processing instructions (step S9) can be given.

The case where the user gives a keystroke input instruction (step S4) will be described with reference to the flowchart shown in FIG.

First, if the instruction is for the i = 0th key frame (step S21), the stroke number j input to the key frame is initialized (step S22). The stroke number is an identifier for identifying a plurality of strokes input by the user.

The user draws a stroke (curve) corresponding to the skeleton at a portion on the prepared bitmap image to be animated, using a mouse, a tablet or the like via the user interface of the keystroke input means 1. Then, desired strokes are input one after another, and each time a stroke number is attached to each stroke (step S23 to step S24).

When the keystroke input for one keyframe is completed (step S24), each keystroke input by the keystroke quantization means 2 is decomposed (quantized) into a unit vector of a fixed length (step S25). . For example, as shown in FIG. 6A, the key frame number i = 0
When the keystroke quantization means 2 quantizes the keystroke 21 registered in the keyframe (first keyframe) of the unit vector 23a, a unit vector 23a is generated as shown in FIG. 6B.
~ 23c is generated.

The unit vector of the keystroke generated by the keystroke quantization means 2 is stored in the unit vector storage means 3 (step S26). In the unit vector storage means 3, for example, as shown in FIG. 7, for each key frame, a key frame number (i) which is an identifier of the key frame, and a stroke number which is an identifier of a stroke input to the key frame. (J), the identifier of the unit vector of the stroke (Vjhi, h = 1, 2, 3, ...)
It is stored as an array whose elements are. The unit vector identifiers are numbers h (= 1, 1,
2, 3, ...)

When stroke input is performed with respect to keyframes after the keyframe number i = 0 (step S2)
1) That is, when inputting a keystroke for transforming each keystroke registered on the keyframe number i = 0, first, the stroke display number k is initialized and the keyframe number i is set to 1 The number is incremented by one and, for example, a keystroke of the keyframe with the keyframe number i = 1 (second keyframe) is awaited (step S28). Then, the key frame of the key frame number (i-1) immediately before that (in this case,
The key frame with the key frame number i = 0 (first key frame) is displayed on a predetermined display device. At this time, the stroke number given to each stroke drawn on the first key frame is set as the stroke display number k. When the keystroke on the second keyflake corresponding to the keystroke of the stroke display number k on the first keyframe is input, the display color of the kth keystroke is changed or blinking is displayed. For example,
The input of the keystroke of the second keyframe corresponding to the kth keystroke of the keyframe is prompted (step S29). The user inputs the keystroke 22 of the second keyframe corresponding to the keystroke 21 of the first keyframe, for example, as shown in FIG. 6A (step S30). At this time, there may be a plurality of keystrokes of the second keyframe corresponding to the kth keystroke of the first keyframe. When the user instructs the second keyframe to end the input of the keystroke corresponding to the kth keystroke of the first keyframe (step S31), the next display number on the first keyframe is displayed. The k + 1 keystrokes are highlighted to prompt the user for k + 1 of the first keyframe.
The keystroke of the second keyframe corresponding to the th keystroke is prompted, and the key of the second keyframe input corresponding to the keystroke of the previous keystroke (that is, the kth stroke). The stroke is divided into unit vectors by the keystroke quantization means 2 (see FIG. 6B) and stored in the unit vector storage means 3 (step S32).

The unit vector of the keystroke of the second keyframe corresponding to the keystroke of the first keyframe is, for example, as shown in FIG. 7, the unit of the keystroke j = 1 of the first keyframe. A jump destination address "p1" is added to the end of the vector array, and a key frame number (i = 1), a stroke number (j = 1), a unit vector identifier (Vjhi, h =) from the address "p1".
(1, 2, 3, ...) are stored as an array having elements as elements.

For all the keystrokes drawn on the first keyframe, the steps S29 to S are executed.
The process of 32 is repeated (step S33).

Next, a case where the user gives an instruction to input a restricted stroke (step S5) will be described with reference to the flowchart shown in FIG.

The constraint stroke input means 4 is for inputting a stroke representing a constraint when the keystroke input by the keystroke input means 1 is deformed. For example, the end points of the keystroke are set along the stroke. Input by drawing strokes on the bitmap image along the desired path.

First, in the case where there is only one key frame, input of a constraint stroke is shown (I = 0). First
The keystroke registered in the keyframe is displayed on a predetermined display device, and the input of a constraint stroke is awaited (step S41). Each time a constraint stroke is input, a constraint stroke number g is attached to each constraint stroke (steps S42 to S43). g is incremented by 1 and the next keystroke is sequentially highlighted to prompt the input of a constraint stroke. Here, when an instruction is given to end the input of the constraint strokes for all the keystrokes, the constraint stroke quantization unit 6 has the same number of units as the interpolation frame number f designated via the interpolation frame number input unit 5. Each constraint stroke is quantized into a vector and the unit vector of the constraint stroke is stored (step S44 to step S45).

Next, in the case where there are a plurality of key frames, the input of the constraint stroke is shown (step S41).
The stroke display number k is initialized (step S4
6) The keystroke having the first correspondence between the previous key frame and the current key frame is displayed on a predetermined display device. Here, the input of a restricted stroke is awaited for the displayed key strokes in the corresponding relationship (step S47). When the user inputs a constrained stroke for the keystroke having the first correspondence, k is incremented by 1, and the keystrokes having the next correspondence are sequentially highlighted. Input is prompted (step S48)
-Step S49). When it is instructed to finish inputting the constraint strokes to all the keystrokes having the corresponding relationship, the constraint stroke quantizing means 6 causes the same number as the interpolation frame number f designated through the interpolation frame number input means 5. Quantize each constraint stroke into the unit vector of (1) and store the unit vector of the constraint stroke (step S5).
0).

Next, the case where the user gives an instruction to reproduce the animation (step S6), that is, the generation of the interpolation frame will be described with reference to the flowchart shown in FIG.

The number s of the key frame used to generate the interpolation frame, the number t of the interpolation frame to be generated, the number u of the key stroke to be processed, etc. are initialized (step S61). Then, according to the above-mentioned example, the unit vectors of the keystrokes having the corresponding relationships registered in the first and second keyframes are taken out from the unit vector storage means 3 in order from the smallest keystroke number, and the interpolated vector strokes are obtained. Are sequentially generated (step S62).

First, regarding the procedure for generating the interpolation vector in the interpolation vector generation means 7 when the constrained stroke is defined as the trajectory through which the end points of each keystroke from the first key frame to the second key frame pass in the animation process. , FIG. 8 and FIG. 9.

As shown in FIG. 8A, the keystroke (first keystroke) 31 of the first keyframe 31
And a keystroke (second keystroke) 32 of the second keyframe corresponding thereto, and the constraint stroke at the time of generating the interpolation stroke of the keystrokes 31 and 32 is the constraint stroke connecting the respective end points. It is assumed that these are indicated by 33 and 34.

At this time, the end point position of the interpolation stroke is defined by sequentially connecting the restricted stroke unit vectors generated by the restricted stroke quantization means 6 from the first and second keystroke end points (step S63). ). That is, as shown in FIG. 8B, when the interpolation frame number f input from the interpolation frame number input means 5 is “2”, the interval between the end points of the constraint strokes 33 and 34 is equally divided by f + 1 = 3. And quantize the constraint stroke. Of the two interpolation strokes, the end points of the first interpolation stroke are points 35a and 36a that internally divide the constraint strokes 33 and 34 from the end points of the first keystroke 31 in a one-to-two manner. End points are points 35b and 36b that internally divide the constraint strokes 33 and 34 into 2 to 1 from the end points of the first keystroke 31. Here, the starting point and the ending point of the first keystroke 31 are connected to form a baseline 37 of the first keystroke,
The endpoints 35a and 36a of the first interpolation stroke are linked to form the baseline of the first interpolation stroke, and the endpoints 35b and 36b of the second interpolation stroke are linked to form the baseline of the second interpolation stroke, and the second key Stroke 32
The starting point and the ending point of are linked to form the baseline of the second keystroke.

Next, the keystroke (first keyframe) of the first keyframe obtained by the keystroke quantization means 2
Keystroke) of the second keyframe and the corresponding unit vector of the second keyframe of the second keyframe (second keystroke). In consideration of the stroke and the baseline length connecting the end points of the interpolation stroke, vector synthesis is performed at a ratio corresponding to the position of the target interpolation frame, and the interpolation vector is obtained. A specific example is shown in FIG. First keystroke 5
It is assumed that there is one unit vector Vs and the corresponding unit vector Ve of the second keystroke 53. A case where the second interpolation stroke 55 is generated when the designated number f of interpolation frames is “2” will be described. First, f between the end points of the constraint strokes 57 and 58 is
+ 1 = 3 equally divided and the end point 59 of the second interpolation stroke
a and 59b are obtained, and a first keystroke baseline 52, a second keystroke baseline 54, and a second interpolation stroke baseline 56 are obtained. At this time, the ratio S corresponding to the position of the second interpolation stroke
Is S = 2/3.

First, using the unit vector Vs of the first keystroke, the length Ls of the baseline 52 of the first keystroke, the length Lx of the baseline 56 of the second interpolation stroke, and the ratio S, The unit vector Vs' is obtained from the equation (1).

Vs ′ = (1−S) · (Lx / Ls) · Vs (1) Next, the unit vector Ve of the second keystroke and the second
Of the key stroke baseline 54 of the
Using the length Lx of the baseline 56 of the interpolation stroke and the ratio S, the unit vector Ve ′ is obtained from the equation (2).

Ve ′ = S · (Lx / Le) · Ve (2) The unit vector Vx of the second interpolation stroke 55 is a combination of the unit vectors Vs ′ and Ve ′, that is, from the equation (3). You can ask.

Vx = Vs ′ + Ve ′ (3) If the number of unit vectors forming the first keystroke and the number of unit vectors forming the second keystroke do not match, the number of each unit vector is The keystroke quantization means 2 redistributes the keystrokes so that they are the same, and the unit vector information in the unit vector storage means 3 is updated.

Interpolation stroke 55 is generated by synthesizing the unit vector Vx of the second interpolation stroke, which can be obtained as shown in FIG. 9, from the end point position of the interpolation stroke in ascending order of the unit vector identifier. (See FIG. 10).

As described above, displaying the interpolation strokes generated between all the corresponding keystrokes of the first and second keyframes by the image presenting means 8 is repeated f times for the number of interpolation frames. , Between all keyframes (second (i = 1) and third (i =
Between keyframes 2), 3rd (i = 2) and 4th (i
= 3) between key frames ...) to create an animation (steps S64 to S7).
0).

In the first embodiment described above, a case has been described in which the constraint strokes define the positions of the end points of the generated interpolation stroke, but the present invention is not limited to this case.
A constraint stroke that defines the position of the center point of the interpolation stroke is also conceivable. In this case, when generating with the baseline of the interpolation stroke of FIG. 8, based on the number f of interpolation frames of the line segment connecting the respective end points of the corresponding two keystrokes of the first and second keyframes, etc. The baseline of each interpolation stroke may be obtained from the minutiae and the position of the restricted stroke that defines the center position of the interpolation stroke.

As described above, according to the first embodiment, the stroke changing shape when interpolating one or a plurality of keystrokes input to a keyframe among a plurality of keyframe images is restricted. When a constrained stroke (specifically, for example, one that defines the positions of both end points of the generated interpolated stroke) is input, the interpolated position and the constrained stroke when interpolating the stroke between a plurality of key frame images are input. By generating the interpolation stroke based on the keystroke, the interpolation stroke between the input keystrokes is generated based on the constrained strokes that define the positions of both end points, so the entire shape of the keystroke and its vicinity is saved. Thus, an animation having natural movement can be easily generated.

(Second Embodiment) FIG. 11 schematically shows a configuration example of an animation creating apparatus according to a second embodiment of the present invention. The same parts as those in FIG. 1 are designated by the same reference numerals, and different parts will be described. Figure 1
The animation creating apparatus shown in FIG. 1 includes a keystroke input unit 1, a keystroke management unit 11, a stroke shape deforming unit 12, an interpolation frame number input unit 5, and
The constraint function input unit 13, the constraint function management unit 14, the interpolation stroke generation unit 7, and the image presentation unit 8 are included.

The keystroke input means 1 is for inputting a plurality of keystrokes to be registered in a key frame of animation, and it is desired to perform animation on a prepared bitmap image using a mouse or a tablet. Input by drawing a stroke (curve) that corresponds to the skeleton in the part. As shown in FIG. 12A, it is assumed that the keystroke 61 is registered in the first keyframe and the keystroke 62 is registered in the second keyframe correspondingly. The keystrokes 61 and 62 input by the keystroke input means 1 are shown in FIG.
As shown in (b), Bezier curve and B-spl
It is approximated by a parameter curve such as an ine curve, and its control point information (in the keystroke 61, the control points 63a, 63
b, 63c, keystroke 62, control points 64a, 6
4b and 64c) are registered in the keystroke management means 11 together with the stroke identifier. In this way, by treating the input keystroke as a set of points found by approximating with such a parameter curve,
Calculations can be easily performed with keystroke deformation and combination and control functions as will be described later.

For example, as shown in FIG. 13, the keystroke management means 11 uses the keyframe number (i), which is the identifier of the keyframe for each keyframe, and the identifier of the stroke input to the keyframe. It is stored as an array having a certain stroke number (j) and the identifier (Vjhi, h = 1, 2, 3 ...) Of the control point vector of that stroke as an element. The control point vector identifiers are numbers h (= 1, 2, 3) in order from the stroke drawing start end point.
...) is added.

When the keystroke of the second keyframe corresponding to the keystroke of the first keyframe is input, as shown in FIG. 13, for example, the keystroke of j = 1 of the first keyframe is input. The jump destination address “p1” is added to the end of the control point vector array, and the key frame number (i = 1), stroke number (j = 1), control point vector identifier (Vjhi, h) from the address “p1”.
= 1, 2, 3 ...) are stored as an array having elements.

The constraint function input means 13 is for inputting a constraint function for constraining the deformation of the interpolation stroke generated for interpolating the keystrokes input by the keyframe input means 1 between keyframes. Is. This constraint function is described by a one-dimensional parameter corresponding to the position t and the stroke position s of the interpolation frame. As the type of the constraint function, for example, Be
There are a Zier curve, a B-spline curve, and the like. Of these approximate curves, the desired one is the constraint function input means 1
Specify from 3. Then, the constraint function of the desired approximate curve corresponding to the control point of each keystroke with the position t of the interpolation frame and the stroke position s according to the number of interpolation frames input from the interpolation frame number input means 5 as parameters. Is required. This constraint function can be used, for example, when it is desired to add speed to the movement of a stroke.

As shown in FIG. 14, the constraint function management means 14 stores, for each key frame, a key frame number (i) which is the identifier of the key frame, and a stroke which is the identifier of the stroke input to the key frame. The pointer (Fjhi) to the substance of the constraint function based on the number (j), the position s of the stroke, and the position t of the interpolation frame.
It is stored as an array having (s, t), h = 1, 2, 3, ...

When the keystroke of the second keyframe corresponding to the keystroke of the first keyframe is input and another constraint function is required, as shown in FIG. 14, for example, the first keyframe is used. The jump destination address "p1" is added to the end of the array of pointers to the keystroke constraint function of j = 1, and the keyframe number (i = 1) and stroke number (j = 1) are added from the address "p1". ,
A pointer to the constraint function (Fjhi (s, t), h = 1,
2, 3, ...) are stored as an array having elements as elements.

The constraint function input means 13 inputs the constraint stroke as described in the first embodiment, and uses it as a Bezier curve or B-
By approximating with a parameter curve such as a spline curve,
A constraint function based on the control point may be registered in the constraint function management means 14.

The stroke shape transforming means 12 transforms the keystroke shape in accordance with the position of the interpolation frame, and the interpolation stroke generating means 7 synthesizes the interpolation strokes from the transformed keystrokes, and further, the synthesized interpolation. As shown in FIG. 14, the constraint function stored in the constraint function management unit 14 is applied to the stroke to generate an interpolation stroke.

Next, the procedure for generating the interpolation stroke will be described with reference to FIGS. As shown in FIG. 15A, the keystroke 71 of the first keyframe and the corresponding keystroke 7 of the second keyframe.
2 and the number of interpolation frames is f = 2, and when an animation composed of a total of four frames including the first key frame to the second key frame is created, the second of the four frames is generated. The frame will be described as an example, that is, the case where the interpolation stroke at the frame position t = 2 is generated.

First, the end points 76a of the keystroke 71,
76b and end points 77a, 77b of the keystroke 72
Since the number of interpolation frames input from the interpolation frame number input unit 5 is f = 2 in the line segment connecting each of the two, the end points of the keystrokes 71 and 72 are equally divided into f + 1 = 3, and the keystroke 71 End point 76a of
Points 78a and 78b that are internally divided from 76b in a ratio of 1: 2
Is determined as the end point of the interpolation stroke (first interpolation stroke) at the frame position t = 2. The frame position t
The end points of the second interpolation stroke of = 3 are points that are internally divided into 2 to 1 from the end points 76a and 76b of the key stroke 71. Here, the starting point and the ending point of the first keystroke 71 are connected, and the baseline 73 of the first keystroke
The end points 78a and 78a of the first interpolation stroke are connected to form a baseline 75 of the first interpolation stroke, and the start point and the end point of the second keystroke 72 are connected to form a baseline 74 of the second keystroke. .

In the stroke shape deforming means 12, FIG.
As shown in (b), the first keystroke baseline 73 and the second keystroke baseline 7
The rotation processing is performed on the first keystroke 71 and the second keystroke 72 so that 4 matches the baseline 75 of the first interpolation stroke previously obtained.
Then, in order to make the distance between the end points of the keystrokes 71 and 72 the same as the distance between the end points 78a and 78b of the interpolation stroke, the keystroke 7 is performed.
1. The key stroke 72 is applied. The following two methods are conceivable, and either one may be used.

(1) As shown in FIG. 16A, when the length of the interpolation stroke baseline 75 is a and the length of the key stroke baseline is b, the length of the interpolation stroke baseline is In addition, a method of performing a transformation operation in which key strokes are multiplied by b / a in the baseline direction (x direction) of the interpolation stroke and the direction (y direction) perpendicular to the interpolation strokes, and the key strokes are enlarged / reduced similarly.

(2) As shown in FIG. 16 (b), the keystroke is enlarged by b / a only in the interpolation stroke baseline direction (x direction) in accordance with the length of the interpolation stroke baseline. A method of transforming to reduce.

In the interpolation frame generation means 7, the amplitude values of the keystrokes of the first keyframe and the keystrokes of the second keyframe after this deformation operation are calculated along the interpolation stroke base line 75. Interpolation strokes are generated by adding up at a ratio corresponding to the frame position t = 2. That is, FIG.
As shown in (c), the keystrokes of the first keyframe may be "2" and the keystrokes of the second keyframe may be added at a ratio of "1", and the respective amplitude values may be added. Then, the constraint function registered in the constraint function management means 14 is added to the position t (=
2) is given as a parameter, and the constraint function is applied to the interpolation stroke obtained above to generate a modified interpolation stroke.

Displaying the interpolated strokes generated between all the keystrokes in the first and second keyframes in the corresponding relationship by the image presenting means 8 is repeated f times for the number of interpolated frames, and this is further performed for all of them. By repeating between keyframes (between the second (i = 1) and third (i = 2) keyframes, between the third (i = 2) and fourth (i = 3) keyframes ...), As shown in FIG. 17 for creating an animation, the animation generating apparatus may be configured by adding the constraint stroke input means 4 and the constraint stroke quantization means 6 described in the first embodiment to the configuration of FIG. Good. In this case, as shown in FIG. 18A, a constraint stroke 83a indicating a constraint when the keystroke 81 is deformed between the first keyframe and the second keyframe from the constraint stroke input means 4. , 83
Input b along the path that the end point of the keystroke 81 is desired to follow. After that, similarly to the description of FIG. 8, the constraint stroke quantization unit 6 quantizes the constraint stroke to obtain the end points and the baseline of the interpolation stroke. That is, the constraint stroke is used to find the baseline of the interpolation stroke. Then, as described above, the stroke shape deforming means 12 deforms the shapes of the stroke 81 of the first key frame and the key stroke 82 of the second key frame, and the interpolation stroke generating means 7 deforms the shape after the deformation operation. By adding the amplitude values of the keystrokes of the first keyframe and the keystrokes of the second keyframe along the baseline of the interpolation stroke at a ratio corresponding to the frame position t of the interpolation frame,
Generate interpolation strokes.

In FIG. 18B, a modification operation is performed in which key strokes 81 and 82 are similarly scaled up / down in the direction of the baseline of the interpolation stroke and in the direction perpendicular thereto in accordance with the length of the baseline of the interpolation stroke. Then, the keystrokes after the transformation are combined to interpolate the stroke 84.
The case where a and 84b are generated is shown.

FIG. 18 (c) shows that the keystrokes 81 and 82 are deformed in accordance with the length of the interpolation stroke baseline so that the keystrokes 81 and 82 are enlarged / reduced only in the direction of the interpolation stroke baseline. Is generated to generate interpolation strokes 85a and 85b.

Next, another example of the method of applying the constraint function will be described with reference to FIG.

In FIG. 19, since the keystroke 91 of the first keyframe and the keystroke 92 of the second keyframe are parallel and line segments having the same length, the generated interpolation stroke is the keystroke 91,
The line segment is parallel to the other side of 92 and has the same length (reference interpolation strokes 93a, 93b, 93c, 93d, 93).
e). At this time, the position t of the interpolation frame (which indicates which interpolation frame of all the generated interpolation frames is generated) as a constraint function, and the distance s from one end point position of the interpolation stroke The constraint function F (s, t) based on the sin function with the parameter is, for example,
It is defined as shown in the following equation (4).

F (s, t) = (Lf / 2) sin (2 (f−t) π) · sin ((Ls−s) π) f: Number of interpolation frames Lf: First key frame and second Distance between keystrokes of keyframe of Ls: length of keyframe (4) The constraint function of the equation (4) is specified from the constraint function input means 13 and added to the reference interpolation strokes 93a to 93e obtained above. By matching, the reference interpolation stroke is deformed, and the interpolation strokes 94a to 94e are generated.

This addition effect produces the same deformation effect even if a constraint function is applied to the control points (curve control parameters) expressing the keystroke shape stored in the keystroke management means 11. can do. By such a modification, an animation having an effect of looking through a fisheye lens can be generated.

An animation is created by repeating the display of the interpolation stroke generated as described above by the image presenting means for the total number of interpolation frames.

(Third Embodiment) FIG. 20 schematically shows a configuration example of an animation creating apparatus according to a third embodiment of the present invention. The same parts as those in FIG. 1 are designated by the same reference numerals, and different parts will be described. That is, the animation creating apparatus shown in FIG. 20 is the same as the animation creating apparatus shown in FIG. 1 except that the constraint function input means 13 and the constraint function managing means 1 described in the second embodiment are used.
4 is added, and when the interpolation vector generating means 7 generates the interpolation vector forming the interpolation stroke, for example, a constraint function according to the number of divisions of the keystroke unit vector is applied to the generated interpolation vector. After transformation, they are combined and an interpolation stroke is generated.

As described above, the second and third
According to the embodiment of the present invention, when a constraint function that constrains a changing shape of a stroke when one or a plurality of keystrokes input to a keyframe is interpolated between a plurality of keyframe images is input, the plurality of keyframes are input. By generating an interpolation stroke based on an interpolation position when interpolating a stroke between images, a constraint function, and a keystroke, the generated interpolation stroke is transformed using the constraint function, and, for example, three points, such as rising and unevenness, are generated. It is possible to easily generate an animation that promotes a three-dimensional visual effect.

(Fourth Embodiment) Next, a case of creating an animation based on an original image having a general area will be described.

FIG. 21 schematically shows a configuration example of an animation creating device according to the fourth embodiment of the present invention. The same parts as those in FIG. 1 are designated by the same reference numerals, and different parts will be described. That is, the image chunk storage means 1 is added to the animation creating apparatus shown in FIG.
5. The image chunk generation means 16 is added.

The keystroke input means 1 is for inputting a plurality of keystrokes to be registered in a key frame of animation, and it is desired to use a mouse or a tablet to perform animation on a prepared bitmap image. Input by drawing a stroke (curve) that corresponds to the skeleton in the part.

The plurality of keystrokes input by the keystroke input means 1 are decomposed by the keystroke quantization means 2 into unit vectors having a fixed length and registered in the unit vector storage means. At the same time, FIG.
As shown in step S27, the image in the region near the unit vector is cut out and registered in the image chunk storage means 15 as an image chunk.

Here, the quantization of strokes and the extraction of image chunks will be described. FIG. 23A shows a keystroke 101 drawn by the user. A keystroke 101 is, for example, a unit vector 102 of length "1".
FIG. 23B shows a case where quantization is performed into a to 102c.
Further, FIG. 23C shows an example of image regions (image chunks) 103a to 103c of a predetermined size along the unit vectors 102a to 102c of the key strokes, which are extracted from the original image.

In the unit vector storage means 3, the substance of the image chunk corresponding to each unit vector or the pointer pointing to the substance is associated with the stroke identifier and the unit vector identifier (for example, the stroke identifier and the unit vector identifier in the correspondence relationship are associated with each other). Registered with one unique ID). The unit vector identifiers are numbered in order from the stroke drawing start end point as described above.

Next, the extraction of image chunks from the original image and the correspondence between the extracted image chunks and unit vectors will be described with reference to FIG.

As shown in FIG. 24, when the user inputs a skeletal keystroke to the portion to which the original image presented by the image presenting means 8 is to be moved, the keystroke quantizing means 2 outputs the keystroke. The keystroke is quantized to generate a unit vector sequence, and the data of the unit vector is stored in the unit vector storage means 3 itself or a pointer to the storage area of the data of each unit vector is a unit vector identifier ( It is stored together with the unique ID). Further, an image area around each unit vector of the keystroke is cut out from the original image, rotated (affine transformation) and normalized to generate an image chunk. Each chunk generated in this way is assigned a unique ID of a corresponding unit vector, and the image chunk storage means 15 stores the image data of the chunk itself or a pointer to the storage area of the image data of the chunk. To be done.

Similar to the first embodiment, the restricted stroke input means 4 is for inputting a stroke representing a restriction when the stroke shape input by the key frame input means 1 is deformed. Input by drawing a constrained stroke on the bitmap image along the path you want the end points of the stroke to follow.

The interpolation frame number input means 5 is for inputting the interpolation frame number f between key frames, as in the first embodiment.

The constrained stroke input by the constrained stroke input means 4 is decomposed by the constrained stroke quantization means 6 into the same number of unit vectors as the interpolated frame number f input by the interpolated frame number input means 5, and constrained. A stroke unit vector is generated.

Here, a process for generating an interpolation frame for interpolating between two key frames to which a keystroke is input will be described with reference to FIG. Here, the number of interpolations f = 1, that is, the case where the number of interpolation frames generated between two key frames is one is shown.

As shown in FIG. 25, unit vectors 231a to 231 obtained by quantizing the keystrokes on the first keyframe stored in the unit vector storage means 3.
The data of d and the second corresponding to the stroke of the first key frame, which is also stored in the unit vector storage unit 3.
Based on the data of the unit vectors 241a to 241d obtained by quantizing the strokes on the key frame and the constrained stroke unit vector generated by the constrained stroke quantization unit 6, the interpolated vector generation unit generates the interpolated vector. The procedure to be performed is similar to the description of FIGS. 8 to 10 of the first embodiment.

When the interpolation vector is generated, the image chunk generation means 16 causes the image chunk storage means 1 to operate.
5, the image chunk stored in association with the unique ID of the unit vector of the key frame corresponding to the interpolation vector is read out, and the image chunk is moved or deformed according to the position and shape of the interpolation vector, Alternatively, an interpolation frame is generated by moving and transforming the image and combining it with the key frame stored in the image presenting means 8 to form an image. In addition, by adding blurring processing to the image chunk that maps to the interpolation vector according to the angular velocity of the unit vector that forms the interpolation stroke, you can easily create a speedy animation with the same video effect as motion blur. can do.

(Fifth Embodiment) As shown in FIG.
The image generation apparatus may be configured by adding the image chunk generation means 16 and the image chunk storage means 15 described in the fourth embodiment to the configuration of FIG. Then, when the image area in the vicinity of the keystroke is cut out as an image chunk, it is registered in the image chunk storage means 15 in association with the keystroke registered in the keystroke management means 11. When transforming the shape of the stroke by the stroke shape transforming means 12 or generating the interpolation stroke by the interpolation stroke generating means 7, the image chunk generating means 16 reads the corresponding image chunk from the image chunk storing means 15 and moves it. , Or deformed, or moved and deformed to be combined with the key frame image to generate an interpolated frame.

Similarly, the animation generating apparatus may be configured by adding the image chunk generating means 16 and the image chunk storing means 15 described in the fourth embodiment to the configuration of FIG. Other combinations can be realized as described above.

As described above, the fourth and fifth
According to an embodiment of the present invention, when a constrained stroke and / or a constrained function for constraining a change shape of a stroke when interpolating one or a plurality of keystrokes input to a keyframe among a plurality of keyframe images are input, An interpolation stroke is generated based on an interpolation position and a constraint stroke and / or a constraint function and a keystroke when a stroke is interpolated between a plurality of keyframe images, and an image of a region near the keystroke is generated and the position of the generated interpolation stroke and Depending on the shape, move or transform, or move and transform to synthesize keyframes to create an interpolated frame image that interpolates between keyframe images. Since it is generated based on the constraint stroke that defines the position of the point, Save the overall shape of keystrokes and its vicinity, animation can be easily created with natural movement. In addition, the generated interpolation stroke can be transformed using a constraint function to easily generate an animation that promotes a three-dimensional visual effect such as rising and unevenness. In addition, by adding blurring processing to the image to be mapped to the interpolation stroke according to the angular velocity of the unit vector constituting the interpolation stroke, it is possible to easily create a speedy animation with the same video effect as motion blur. You can

(Sixth Embodiment) In the animation creating methods described in the first to fifth embodiments, a computer-executable program is recorded on a floppy disk, a hard disk, a CD-ROM, a semiconductor memory or the like. It can also be stored in a medium and distributed.

FIG. 27 shows the configuration of a computer system for realizing the animation creating method according to the present invention. This computer system is, for example, a personal computer, and a CPU 1001 that controls arithmetic processing.
An input unit 1002 such as a keyboard, a pointing device and a mouse, an output unit 1003 such as a display and a speaker, and a ROM 100 as a main memory.
4, a RAM 1005, a hard disk device 1006 as an external storage device, and a floppy disk device 10.
07 and the optical disk device 1008 are connected by a bus 1009.

Here, the hard disk device 1006, the floppy disk device 1007 and the optical disk device 1
A program and image data for executing the animation creating method described in the above-described embodiment is stored in any of the recording media 008. Then, according to this program, the CPU 1001 performs an animation creating process on the image data read from the recording medium such as the keystrokes, the constraint strokes, the constraint functions, etc. input from the input unit 1001. 5, Figure 2
2) is executed, and the resulting animation is output from the output unit 003. By doing so, the animation creating process of the present invention can be carried out using a normal personal computer.

[0111]

As described above, according to the present invention,
A stroke that represents a series of movements of a target bitmap image or a shape of the stroke is added to one bitmap image that is the original image or one bitmap image that is a sprite that constitutes the original image. Just enter the constraint information, which is an intuitive and simple operation.
It is also possible to easily generate an animation having a complicated movement that is natural and has a three-dimensional visual effect such as a bumpy or uneven surface.

[Brief description of drawings]

FIG. 1 is a diagram schematically showing a configuration example of an animation creating device according to a first embodiment of the present invention.

FIG. 2 is a flowchart for explaining the overall processing operation of the animation creating device.

FIG. 3 is a flowchart for explaining a keystroke input processing operation.

FIG. 4 is a flowchart for explaining a restriction stroke input processing operation.

FIG. 5 is a flowchart for explaining an animation reproduction processing operation.

FIG. 6 is a diagram for explaining quantization of keystrokes.

FIG. 7 is a diagram showing a storage example of a unit vector in a unit vector storage means.

FIG. 8 is a diagram for explaining a procedure for generating an interpolation stroke from a constraint stroke and a key stroke.

FIG. 9 is a diagram for explaining a method of generating an interpolation vector by combining unit vectors.

FIG. 10 is a diagram for explaining a method of generating an interpolation stroke from the generated interpolation vector.

FIG. 11 is a diagram schematically showing a configuration example of an animation creating device according to a second embodiment of the present invention.

FIG. 12 is a diagram for explaining a process of approximating a keystroke with a predetermined parameter curve.

FIG. 13 is a diagram showing an example of storage of keystroke control points in the keystroke management means.

FIG. 14 is a diagram showing a storage example of a constraint function in a constraint function management means.

FIG. 15 is a diagram for explaining a method of deforming and synthesizing a keystroke according to an interpolation position when interpolating between the keystrokes to generate an interpolation stroke.

FIG. 16 is a diagram for explaining a keystroke modification method.

FIG. 17 is a diagram showing a configuration example of an animation creating device that creates an interpolation stroke based on a constraint stroke and a constraint function.

FIG. 18 is a diagram for specifically explaining a case where an interpolation stroke is generated based on a constraint stroke and a constraint function.

FIG. 19 is a diagram showing a specific example of generating an interpolation stroke using a constraint function.

FIG. 20 is a diagram schematically showing a configuration example of an animation creating device according to a third embodiment of the present invention, showing a modified example of the configuration of the animation creating device according to the second embodiment.

FIG. 21 is a diagram schematically showing a configuration example of an animation creating device according to a fourth embodiment of the present invention.

FIG. 22 is a flowchart for explaining keystroke input processing of the animation creating device according to the fourth embodiment.

FIG. 23 is a diagram for explaining stroke quantization and image chunk extraction.

FIG. 24 is a diagram for explaining extraction of an image chunk from an original image and correspondence between the extracted image chunk and a unit vector.

FIG. 25 is a diagram for explaining a process of generating an interpolation frame that interpolates between two key frames in which keystrokes are input.

FIG. 26 is a diagram schematically showing a configuration example of an animation creating device according to a fifth embodiment of the present invention, showing a modified example of the configuration of the animation creating device according to the fourth embodiment.

FIG. 27 is a diagram showing a configuration example of a computer system that executes a program for creating an animation of the present invention.

FIG. 28 is a diagram for explaining the generation of an animation by warping in the conventional animation creating device.

FIG. 29 is a diagram showing an example of an animation created by warping.

FIG. 30 is a diagram for explaining the creation of an animation by morphing in a conventional animation creating device.

[Explanation of symbols]

1. Keystroke input means 2 ... Keystroke quantization means 3 ... Unit vector storage means 4 ... Constraint stroke input means 5 ... Interpolation frame number input means 6 ... Constraint stroke quantization means 7 ... Interpolation vector generation means 8 ... Image presenting means 11 ... Keystroke management means 12: Stroke shape deforming means 13 ... Constraint function input means 14 ... Constraint function management means , 15 ... Image chunk storage means 16 ... Image chunk generation means

─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Miwako Doi 1 Komukai Toshiba-cho, Komukai-shi, Kawasaki-shi, Kanagawa, Toshiba Research and Development Center, Ltd. Kazumi and Masaki Nakagawa, Simple Movie Creation System Using Pen Interface, Research Report of Information Processing Society of Japan 96-HI-67, Nihon, Information Processing Society of Japan, July 11, 1996, p17-22 ( 58) Fields investigated (Int.Cl. ⁷ , DB name) G06T 13/00

Claims (10)

(57) [Claims] 1. An animation creating apparatus for creating an animation by creating an image that interpolates between a plurality of frame images, comprising first input means for inputting one or a plurality of strokes to each of the frame images. At least one of a constraint stroke and a constraint function for constraining the changed shape of the stroke as constraint information of the changed shape of the stroke when the stroke input by the first input means is interpolated between the plurality of frame images. A second input means for inputting one of the plurality of frame images, an interpolation position for interpolating a stroke input by the first input means between the plurality of frame images, the constraint information, and the first input means. And an animation generating means for generating an interpolation stroke based on the stroke Location. 2. The generating unit deforms and combines the strokes input by the first input unit based on the interpolation position and the constraint information when the strokes are interpolated to generate an interpolated stroke. Claim 1 characterized by the above-mentioned.
The described animation creation device. 3. An animation creating apparatus for creating an animation by creating an image that interpolates between a plurality of frame images, comprising first input means for inputting one or a plurality of strokes to each of the frame images. A quantizing means for quantizing each of the strokes input by the first input means associated with the plurality of frame images into a unit vector of a predetermined length; and input by the first input means The changed shape of the stroke is used as a constraint condition for restricting the changed shape of the stroke when the generated stroke is interpolated between the plurality of frame images.
At least one of the constraint strokes and constraint functions that constrain
Second input means for inputting one of them, and an interpolation vector is generated based on an interpolation position when interpolating between the associated strokes, the constraint information, and a corresponding unit vector of the associated strokes. ,
An animation creating apparatus comprising: a creating unit that creates an interpolation stroke that interpolates between the associated strokes based on the created interpolation vector. 4. The constraint information is a constraint stroke that constrains a changing shape of a stroke when the stroke input by the first input means is interpolated between the plurality of frame images. Item 3. The animation creating device according to item 3. 5. The constraint information is a constraint function that constrains a stroke changing shape when the stroke input by the first input means is interpolated between the plurality of frame images. Item 3. The animation creating device according to item 3. 6. The constraint information is a constraint stroke and a constraint function that constrain a changing shape of the stroke when the stroke input by the first input means is interpolated between the plurality of frame images. The animation creating apparatus according to claim 3. 7. An image of a region near a stroke input by the first input means is moved or deformed, or moved and deformed according to the position and shape of the interpolation stroke generated by the generation means, The animation creating apparatus according to claim 1 or 3, further comprising: an interpolation image creating unit that creates an image that interpolates between the frame images by synthesizing the frame images. 8. A machine-readable recording medium in which a program for creating an animation by generating an image that interpolates between a plurality of frame images is recorded, wherein one or a plurality of the frame images input to each of the frame images are recorded. When at least one of a constraint stroke and a constraint function for constraining a stroke change shape is input as constraint information of a stroke change shape when a stroke is interpolated between the plurality of frame images, the plurality of frame images A recording medium recording a program that executes a generation unit that generates an interpolation stroke based on an interpolation position when interpolating the stroke between the strokes, the constraint information, and the stroke. 9. A machine-readable recording medium recording a program for creating an animation by generating an image that interpolates between a plurality of frame images, wherein one or a plurality of strokes are input to each of the frame images. Then, a quantizing means for quantizing each of the strokes associated with each other among the plurality of frame images into a unit vector of a predetermined length, and a case of interpolating the stroke between the plurality of frame images As a constraint condition that restricts the changing shape of the stroke ,
A constraint stroke that constrains the changing shape of the stroke
When at least one of the constraint functions is input, an interpolation vector is generated based on an interpolation position when interpolating between the associated strokes, the constraint information, and a corresponding unit vector of the associated strokes. And a recording medium recording a program for executing an interpolation stroke that interpolates between the associated strokes based on the generated interpolation vector. 10. An image of a region near the input stroke is moved or deformed, or moved and deformed in accordance with the position and shape of the interpolation stroke generated by the generating means, and is combined with the frame image. The recording medium according to claim 8 or 9, further comprising a program for executing an interpolation image generating unit that generates an image for interpolating between the frame images.