Automatic and interactive animation driven by change-based heuristics

By automatically matching and sorting artboard objects, combined with dragging and testing preview technology, the complexity problem of animators in animation design and preview is solved, and intuitive animation matching and preview across multiple artboards is achieved, improving the efficiency of animation production and user experience.

CN111045754BActive Publication Date: 2024-12-06ADOBE INC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN201910700115.4
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Priority Date
2018-10-14
Filing Date
2019-07-31
Publication Date
2024-12-06
Estimated Expiration
2039-07-31

AI Technical Summary

Technical Problem

In the prior art, when executing animations, animators need to manually input complex drag directions and attribute settings, and animation matching and preview control across multiple artboards is inconvenient, and there is a lack of intuitive interaction methods.

Method used

By determining sub-object matching in artboards, sorting and associating objects using distance metrics, automatic animation matching and drag-temptation preview technology is implemented, allowing animators to link multiple artboards through time series and use a mouse or touch screen for interactive previews.

Benefits of technology

It realizes automated multi-artboard animation matching and intuitive animation preview, simplifying the animation design and preview process, and improving the work efficiency and creative experience of animators.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN111045754B_ABST
    Figure CN111045754B_ABST
Patent Text Reader

Abstract

Embodiments of the present disclosure relate to automatic and interactive animation driven by change-based heuristics. A technique for performing automatic interactive animation by automatically matching objects between multiple artboards allows an animator to link multiple artboards in a temporal order using time as a trigger, and allows an animator to preview the animation using intuitive drag controls via an input device such as a mouse or touch screen. The automatic animation process is performed by matching objects / nodes between artboards by determining the ranking of similarities between objects based on a distance metric calculated for a set of one or more attributes associated with each object in the artboard. If enough matches are found, the matched objects can be treated as a single entity to be animated. In another embodiment, a dominant direction of movement relative to the matched objects is determined, and receiving a drag event (mouse input or touch screen gesture input) in the dominant direction causes a preview of the animation of the entity.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present disclosure relates to a technology for performing digital animation. Specifically, the present disclosure relates to a technology for performing automatic interactive animation by automatically matching objects between multiple artboards, which allows an animator to link multiple artboards in a time sequence using time as a trigger, and allows an animator to preview the animation using drag control via an input device such as a mouse or a touch screen. Background Art

[0002] The authoring animations seen in mobile and web applications are not intuitive for visual designers who do not specialize in animation. Designing animations triggered by interactions such as dragging and sliding is complex for creators and requires designers to understand very developer-oriented concepts. In more detail, in order to perform animations across one or more canvases, the same objects in each canvas need to be explicitly associated with each other. To achieve this, objects from one scene must be matched with the same objects in another scene in an automatic manner. For example, a drawing board may include any number of sub-objects such as shapes or images. The same object may appear in a second drawing board, in which case the animation algorithm animates the matching objects from their corresponding positions in the first drawing board to their positions in the second drawing board. Typically, objects in a drawing board are associated with various properties such as name, type, etc. Matching objects from one drawing board to another drawing board can be achieved by finding objects in two drawing boards that share the same name and type. However, performing such matching in an automatic manner may be problematic when, for example, there are repeated object names across multiple drawing boards.

[0003] After designing an animation by developing multiple artboards, the designer will often want to preview the animation. However, known techniques for designing animations often require the designer / animator to input a drag direction (such as left, up, right, down) in addition to the pose, which is inconvenient. In addition, these known techniques are generally limited in the types of animations they can generate. Other known techniques employ simple automatic animation techniques, such as the concept of "magic move", which animates an object from one slide to another. However, these known methods do not have complex interactions like dragging.

[0004] Other tools use a "timeline" and a single canvas in which the artwork is shown. The user is required to specify multiple options in the timeline UI to animate properties. Requiring the user to select and specify a large number of properties is often inconvenient and often impractical. Summary of the invention

[0005] According to some embodiments, a method for performing an animation includes: determining a first sub-object of a first artboard and a second sub-object of a second artboard; if multiple second sub-objects in the second sub-object match the first sub-object, then: adding the multiple second sub-objects to an initial list, sorting the initial list based on at least one distance metric associated with the first sub-object and the multiple second sub-objects to generate a sorted list, the at least one distance metric being based on at least one attribute associated with the first sub-object and the multiple second sub-objects, and generating an association between the first sub-object and the second sub-object corresponding to the first entry in the sorted list; and drawing an animation using the association, the animation including the first sub-object and the second sub-object corresponding to the first entry in the sorted list.

[0006] According to some embodiments, a method for previewing an animation includes: receiving a first object associated with a first artboard and a second object associated with a second artboard, wherein the first object and the second object represent a single entity at a first time and a second time, respectively; determining a dominant direction of movement relative to the first object and the second object; receiving a drag event in the dominant direction; and updating an animation state of a visual representation of the entity in response to the drag event.

[0007] According to some embodiments, a computer program product includes one or more non-transitory machine-readable media encoded with instructions, which, when executed by one or more processors, cause a process for performing an animation to be executed, the process including: determining a first sub-object of a first artboard and a second sub-object of a second artboard; if multiple second sub-objects in the second sub-objects match the first sub-object, then: adding the multiple second sub-objects to an initial list, sorting the initial list based on at least one distance metric associated with the first sub-object and the multiple second sub-objects to generate a sorted list, the at least one distance metric being based on at least one attribute associated with the first sub-object and the multiple second sub-objects, and generating an association between the first sub-object and the second sub-object corresponding to the first entry in the sorted list; and using the association to draw an animation, the animation including the first sub-object and the second sub-object corresponding to the first entry in the sorted list. BRIEF DESCRIPTION OF THE DRAWINGS

[0008] Figure 1a is a flow chart of an animated shape matching process according to one embodiment of the present disclosure.

[0009] Figure 1b is a more detailed flow chart of the animated shape matching process according to one embodiment of the present disclosure.

[0010] Figure 1c is a flowchart of a process for determining a best match for an object in a first artboard with respect to multiple objects in a second artboard according to one embodiment of the present disclosure.

[0011] Figure 2 is a flow chart of a process for performing drag heuristics according to one embodiment of the present disclosure.

[0012] Figure 3 is a flow chart depicting the operation of a time-triggered visualization process according to one embodiment of the present disclosure.

[0013] Figure 4 is a block diagram of an animation system according to one embodiment of the present disclosure.

[0014] Figure 5 Various aspects of a matching process according to one embodiment of the present disclosure are illustrated.

[0015] Figure 6a Depicted is an example operation of a drag heuristics process in accordance with one embodiment of the present disclosure.

[0016] Figure 6b Depicted is an example operation of a drag heuristic process in determining a dominant direction in accordance with one embodiment of the present disclosure.

[0017] Figure 7 An example of a multi-artboard time-triggered visualization process according to one embodiment of the present disclosure is depicted.

[0018] Figure 8a An initial configuration of a user interface for generating a multi-artboard time-triggered animation according to an embodiment of the present disclosure is shown.

[0019] Figure 8b A configuration of a user interface for generating a multi-artboard time-triggered animation that clearly indicates the relationship between artboards and frames according to an embodiment of the present disclosure is shown.

[0020] Figure 8c A configuration of a user interface for generating a multi-artboard time-triggered animation that clearly indicates the relationship between artboards and frames according to an embodiment of the present disclosure is shown.

[0021] Figure 8d The configuration of a user interface for generating a multi-artboard time-triggered animation according to an embodiment of the present disclosure is shown.

[0022] Figure 9a An example computing system that performs an animation process according to one embodiment of the present disclosure is illustrated.

[0023] Figure 9b An example integration of an animation system into a network environment according to one embodiment of the present disclosure is illustrated. DETAILED DESCRIPTION

[0024] Techniques for performing automatic animation between two or more artboards are disclosed. In an embodiment, as part of the automatic animation, a matching process is performed to associate objects between one artboard and another artboard. The matching process includes the identification of duplicate objects, all of which may share a common attribute or set of attributes, and the identification of true matches (based on some matching threshold or criteria). In one such embodiment, the automatic animation process is performed by matching objects / nodes between artboards by determining the ranking of similarities between objects based on a distance metric calculated for a set of attributes associated with each object in the artboard. According to one such embodiment, one or more distance metrics between objects in a first artboard and a second artboard are used to determine the best or sufficient match. In other distance metrics, the distance between two objects can be determined based on the relative number of layers separating the objects. Another example distance metric is the number of similar attributes or characteristics (of the objects being compared). The following example property values ​​can be compared: object position (e.g., position within an artboard and / or hierarchy of layers), object size, fill color associated with the object, stroke color associated with the object, visibility of the object (e.g., not hidden, partially hidden, fully hidden), corner radius or other unique geometric qualities associated with the object, line height or spacing associated with the object, character spacing associated with the object, and font type and / or size associated with the object, etc.

[0025] In addition, a technique for previewing an animation is disclosed. In particular, after completing the animation design, the animator may desire to interactively drive the preview of the animation via input from a mouse or keyboard or touch screen. However, it may be difficult to generate an appropriate control interface for previewing any animation because the trajectory of each animated object may change. Therefore, according to one embodiment of the present disclosure, a preview technique referred to as the drag heuristic in this article is adopted. The drag heuristic process attempts to determine the dominant direction in which one or more objects / shapes move between two drawing boards. The dominant direction can then be used as the trajectory of a single animated object, which in turn can be used to generate an intuitive or other appropriate control interface for previewing the animation of the object.

[0026] In addition, techniques for linking multiple artboards together in a seamless manner to generate a single animation are described. According to one embodiment, a graphical user interface ("GUI") allows a designer to work with multiple artboards and graphically link them together. The GUI performs analysis of the underlying objects within each artboard regarding their matching between adjacent artboards, and provides graphical and other design aids to facilitate the generation of animations from multiple artboards.

[0027] definition

[0028] Artboard: In addition to its literal and ordinary meaning, an artboard as used herein refers to a digital canvas on which an illustrator, artist, animator, etc. can draw or represent an object to be animated, such as a shape, image, or any other graphic.

[0029] Object / Node: In addition to its literal or ordinary meaning, a node or object refers to any entity that can be associated with an artboard, including the actual shape or image to be animated, including logical entities such as groups that operate as logical containers to represent the hierarchy or other relationship between the shapes that make up a given entity, or other groups. For the purposes of this disclosure, the terms node and object may be used interchangeably and effectively refer to any entity that can be associated with a canvas or artboard.

[0030] Layer: In addition to its literal or ordinary meaning, a layer is a logical construct that represents the ordering of shapes or groups in an imaginary z-dimension perpendicular to a 2-D screen or image. That is, a layer represents a virtual ordering of shapes or groups in a dimension perpendicular to the image (the 'z' dimension). It should be understood that when drawing an artboard, certain shapes may occlude other shapes depending on their respective positions on the imaginary z-axis. Therefore, layers provide a technique for representing the relative positions of objects within this imaginary z-dimension.

[0031] Group: In addition to its literal or ordinary meaning, a group refers to a logical collection of one or more objects, which can themselves be shapes or images or other groups. The use of groups allows objects to be arranged in a recursive structure. For the purposes of this disclosure, the term sub-object refers to an object contained within a group, which can include another group or any other object such as a graphic shape.

[0032] Duplicates: According to one embodiment of the present disclosure, each object may be associated with various attributes, including, for example, a name and a type. Since designers / animators may sometimes use the same name and type for multiple objects, a common scenario that arises in performing matching involves identification and elimination of duplicates. Therefore, in addition to its literal meaning, the term duplicate refers to at least two second objects that are associated with a first object due to one or more common attributes.

[0033] Methodology and Architecture

[0034] Figure 1ais a high-level flowchart for performing an animation shape matching process according to one embodiment of the present disclosure. According to one embodiment of the present disclosure, a designer or animator may first work in a design phase in which the animator designs multiple artboards, each of which represents a point in time during the animation process. Each artboard is associated with a collection of objects, which may include graphic objects or groups of graphic objects. In addition, shapes may be arranged in layers, and therefore, shapes may obscure other shapes due to their position in the hierarchy of the layers. According to one embodiment of the present disclosure, after the animator has designed a collection of artboards, the animator may call an automatic animation process, which may further call an animation shape matching process for associating shapes between multiple artboards in order to perform automatic animation. It will be further understood that each object in a artboard is associated with a collection of attributes, which may include a name, type, color, shape, etc.

[0035] Reference now Figure 1a , the process starts at 170. At 172, two artboards are received (artboard A 120(1) and artboard B 120(2)). Although the present description refers to only two artboards by way of example, it should be understood that Figure 1a The process shown in 174 can be extended to any number of artboards. At 174, it is determined whether there are any unchecked child objects in artboard A 120 (1). As previously described, a child object of an artboard can be an object, which can be a graphic object or a group object. If there are no unchecked child objects in artboard A 120 (1) (the 'no' branch of 174), the process ends at 184.

[0036] If there are unchecked child objects in artboard A 120 (1) ('yes' branch of 174), the process continues with 176 and the variable currentAChild is set to the next child object in artboard A 120 (1). At 178, any matches in artboard B 120 (2) corresponding to currentAChild are determined. According to one embodiment of the present disclosure, a match may include an object in artboard B that has one or more attributes that are the same as the attributes of currentAChild. For example, according to one embodiment of the present disclosure, a match between two objects may include two objects having the same name and type. According to one embodiment of the present disclosure, the animator may provide a name for each node / object defined on the artboard. The type attribute may include, for example, the type of shape or whether the object is a group.

[0037] At 180, all matches determined in 178 are sorted by calculating a distance metric based on the associated attributes of currentAChild and all matching objects determined in 178. According to one embodiment of the present disclosure, the following characteristic attributes can be utilized: position, size, fill color, stroke color, visibility, corner radius, line height, character spacing, and font size. These attributes are examples only, and any other attributes are possible. The relative layer distance of each object can be calculated by comparing the index of each object in artboard A 120 (1) and artboard B 120 (2). According to one embodiment of the present disclosure, Euclidean or other metrics can be utilized, for example, by calculating the sum of the squares of the differences of the attribute of currentAChild relative to each matching object determined in 178. If it is a layer attribute, the absolute value of the difference between the layer indices can be used. At 182, the highest ranked match (i.e., the match with the smallest distance) is selected. The process then continues with 174.

[0038] Figure 1b is a detailed flow chart of the animation shape matching process according to one embodiment of the present disclosure. Figure 1a Similar to the discussion of , assume that automatic animation is to be performed with respect to two artboards, referred to herein as artboard A 120(1) and artboard B 120(2). Each artboard 120 can be associated with one or more objects. The associated objects can include groups, which can themselves be associated with one or more objects, which can be groups, thereby generating a hierarchical relationship between the objects. In order to perform automatic animation with respect to artboard A 120(1) and artboard B 120(2), a matching process is performed, wherein each object in artboard A 120(1) is associated with a corresponding object in artboard B 120(2), if possible. In order to perform this matching efficiently, a process for eliminating duplication is performed. As previously discussed, duplication may occur due to the use of the same name / type for multiple objects.

[0039] Reference now Figure 1b , the animated shape matching process 100 is started in 102. In 104, various data structures are initialized. Figure 1aAs shown in the dashed box, according to one embodiment of the present disclosure, a map (dictionary) data structure matchedNodes140 is created and initialized. List data structures unMatchedNodes 142, newNodes 148, tempMatchedNodes 150 and matchedGroupNodes 146 are also created and initialized. The behavior of dictionary data structures and list data structures is well known and will not be discussed further herein. However, for the purposes of this discussion, matchedNodes 140 stores the association between the nodes or objects in the first canvas (canvas A) 120 (1) and the nodes or objects in the second canvas (canvas B) 120 (2). unMatchedNodes 142 is a list data structure that stores a list of unmatched nodes. tempMatchedNodes 150 is a list data structure that stores a sorted list of matching nodes in the second canvas with respect to the nodes / objects in the first canvas. According to one embodiment of the present disclosure, the sorting of tempMatchedNodes can be performed by applying one or more distance metrics described below. The matchedGroupNodes 146 stores a list of group objects in the second drawing board that have been matched to corresponding objects in the first drawing board. The newNodes 148 stores a list of objects that exist only in the second drawing board, but not in the first drawing board.

[0040] At 105, artboard A 120(1) and artboard B 120(2) are received. At 106, all child objects of artboard A 120(1) and artboard B 120(2) are determined. In particular, as previously described, objects may be arranged in a hierarchical manner within artboards, where groups contain objects and objects themselves may be groups, thereby providing a hierarchical or layered approach to the arrangement of objects / nodes.

[0041] As will be described, the sub-objects of artboard A 120(1) identified in 106 are now examined in a sequential manner. In particular, in 108, a determination is made as to whether there are any unexamined sub-objects in artboard A 120(1). If so (the 'yes' branch of 108), then in 112, the variable currentAChild is set to the next sub-object in artboard A 120(1). According to one embodiment of the present disclosure, the object identified by currentAChild is used to attempt to determine the best match in artboard B 120(2). In 116, the best match (if any) in artboard B 120(2) for currentAChild in artboard A 120(1) is determined by calculating a distance metric between currentAChild and each sub-object of artboard B 120(2). As will be described with reference to Figure 1bAs described in more detail, determining the best match in artboard B 120(2) may require eliminating duplicate sub-objects in artboard B 120(2) that may share the same name and type as currentAChild. Figure 1b As described in more detail, upon completion 118, matchedNodes 140 is updated for any matched nodes in artboard B 120(2) corresponding to currentAChild. Similarly, matchedGroupNodes 146 is also updated to include any group nodes that match currentAChild (if it is in fact a group). Additionally, unMatchedNodes 142 is updated to include any unmatched nodes. Flow then continues with 108, where it is determined whether there are any unchecked child objects in artboard A 120(1).

[0042] If all child objects in Artboard A 120(1) have been checked ('no' branch of 108), then the flow continues at 118 where it is determined whether there are any unchecked nodes / objects in matchedGroupNodes 146. Figure 1b As described, matchedGroupNodes 146 is a storage that has been Figure 1b (118) shows a list of group objects matched by the process shown. If there are no unchecked nodes / objects in matchedGroupNodes 146 (the 'no' branch of 118), the process continues with 124, where each child object in palette B 120(2) that is not in matchedNodes 140 is inserted into newNodes 148. If there are unchecked objects / nodes in matchedGroupNodes 146, the process continues with 120, where the variable matchedGroupNode is set to the next node in matchedGroupNodes 146. Then in 122, the recursive step is initialized by setting the current palette A 120(1) to matchedGroupNode, and palette B 120(2) is set to the value of the key in matchedNodes 140 corresponding to the key matchedGroupNode. The process then continues with 102, where the recursive operation is performed.

[0043] Figure 1c is a flowchart of a process for determining the best match for an object in a first artboard with respect to multiple objects in a second artboard according to an embodiment of the present disclosure. Figure 1b As described, Figure 1cThe process shown in 130 operates to determine the best match for the current child object in canvas A 120 (1) (currentAChild) and update various state variables. The process starts in 130. In 134, it is determined whether there are any remaining child objects in canvas B 120 (2). If so (the 'yes' branch of 134), then in 132, the variable currentBChild is set to the next child object in canvas B 120 (2). In 154, it is determined whether the object identified by the variable currentAChild matches the object identified by currentBChild. According to one embodiment of the present disclosure, if the object in canvas A 120 (1) shares at least the same name with the object in canvas B 120 (2), the match between the two objects is registered. According to an alternative embodiment, if the corresponding objects share the same name and the same type, the match is registered. According to an alternative embodiment, any attribute or combination of attributes associated with the objects in canvas A 120 (1) and canvas B 120 (2) can be used to determine whether a match exists. If no match is detected ('no' branch of 154), the flow continues with 134 where the remaining sub-objects in artboard B 120(2) are checked. If a match is detected ('yes' branch of 154), the flow continues with 133 where the node identified by currentBChild is inserted into tempMatchedNodes 150. A list variable tempMatchedNodes is utilized to maintain a running list of matching objects / nodes from artboard B 120(2) corresponding to currentAChild. The flow continues with 134 where it is determined whether there are any remaining sub-objects in artboard B 120(2).

[0044] If there are no remaining child objects in artboard B 120 (2) (the 'no' branch of 134), the process continues with 160, where the size of tempMatchedNodes 150 is determined. As previously described, tempMatchedNodes 150 stores nodes from artboard B 120 (2) that match currentAChild with respect to one or more attributes such as name and type. If the size of tempMatchedNodes 150 is 1, it indicates that a single match has been detected (i.e., there are no duplicates), and the process continues with 138, where the first entry in tempMatchedNodes (tempMatchedNodes[0]), which should be a unique node, is inserted into the list variable matchedNodes 140. The process continues with 160, where it is determined whether currentAChild is a group node. If currentAChild is a group node and a match has been detected with currentBChild, it means that currentBChild is also a group node because, according to some embodiments, the nodes must match on their type attributes. If currentAChild is not a group node (the 'no' branch of 160), the flow continues with 162 and the process ends. Otherwise (the 'yes' branch of 160), the flow continues with 162, where the node identified by currentAChild is inserted into the dictionary / map matchedGroupNodes146. According to one embodiment of the present disclosure, the key value is the identifier of currentAChild and the value is the identifier of currentBChild. Then, the flow continues with 162 and the process ends.

[0045] If the size of tempMatchedNodes is not equal to 1 (the 'No' branch of 160), the flow continues with 162, where it is determined whether the size of tempMatchedNodes is greater than 1. If not (the 'No' branch of 162), this means that no matching node is found in the drawing board B 120 (2), and the flow continues with 142, where the node identified by currentAChild is inserted into the list structure unmatchedNodes 144. The flow then continues with 162 and the process ends.

[0046] On the other hand, if the size of tempMatchedNodes is greater than 1 ('yes' branch of 162), the flow continues with 136 and tempMatchedNodes 150 are sorted based on one or more metrics. According to one embodiment of the present disclosure, tempMatchedNodes is sorted in descending order based on the following criteria:

[0047] (a) Number of similar attributes. The following attribute values ​​may be compared: position, size, fill color, stroke color, visibility, corner radius, line height, character spacing, and font size. Objects with a higher number of similar or matching attributes may be listed higher on the list (more likely to be a match) than objects with a lower number of similar / matching attributes.

[0048] (b) Relative layer distance of each child object. According to one embodiment of the present disclosure, the layer distance is calculated by checking the index of the child object in artboard 120(1) in its parent object and comparing it with the index of the child object in artboard B. Objects with smaller layer distance differences between them may be listed higher on the list (more likely to be a match) than objects with larger layer distance differences between them.

[0049] Then, at 139, the first entry in tempMatchedNodes (tempMatchedNodes[0]) is saved in matchedNodes 140. This represents the best match. The process then ends at 162.

[0050] Figure 2 is a flow chart of a process for performing drag heuristics according to one embodiment of the present disclosure. As previously described, the drag heuristics process can be performed as part of a preview process to facilitate or enhance the animator's ability to preview previously designed animations. According to one embodiment of the present disclosure, the drag heuristics process provides the animator with the ability to automate the scrubbing of designed animations. The drag heuristics process 200 is started in 202, whereby the user indicates an intention to perform a drag heuristics interaction. In particular, according to one embodiment of the present disclosure, a matchedNodes object 140 is received. The matchedNodes object 140 was previously described, and according to one embodiment of the present disclosure, it may include a dictionary or a map in which the keys are object identifiers in the first artboard 120 and the values ​​are object identifiers of matching objects in the second artboard 120.

[0051] In 206, the dominant direction is determined. The object may move in two dimensions in the X and Y planes. According to one embodiment of the present disclosure, the dominant drag direction may be determined as the larger of the distances that the object moves in the X and Y dimensions. For example, if the object moves 10 units in the X dimension and 25 units in the Y dimension, the dominant direction will be in the Y direction. At this point in the process, the user may interact with the animation preview operation using a device such as a mouse or a touch screen. In 208, it is determined whether a drag event is received. In particular, according to one embodiment of the present disclosure, the drag event may include the user moving a mouse or other input device (e.g., a touch screen) along the dominant direction determined according to 206. If no drag event is received (the 'no' branch of 208), the process continues with 208 and determines again whether a drag event is received. Otherwise (the 'yes' branch of 208), in 210, the drag distance in the dominant direction is determined. For example, if the drag event moves 5 units in the X dimension and 2 units in the Y dimension, and the dominant direction is in the Y dimension, the distance will be determined to be 2 units.

[0052] In 212, the matched object to be animated is updated (i.e., animated) based on the distance determined in 210. According to one embodiment of the present disclosure, the total drag distance may be defined based on the sensitivity of an input device such as a mouse or a touch screen. According to one embodiment of the present disclosure, the total drag distance may be the total number of units that the animated object travels in the dominant direction. The animation of the matched object may then be updated based on the ratio of the distance determined in 210 to the total drag distance and a scaling factor to adjust the sensitivity of the input device (such as a mouse or a touch screen). In other words, the animation may be updated in a manner similar to updating the playhead of a playback machine such as a tape deck or a VCR. In particular, the animator may "scrub" the virtual playhead to find different time points in the animation. For example, if the drag is halfway through and the animation duration is 1 second, the playhead may be moved to 0.5 seconds in the animation. In 214, it is determined whether the total drag distance has been reached. If so (the 'yes' branch of 214), the process ends at 216. Otherwise (the 'no' branch of 214), the flow continues with 208.

[0053] Figure 3 is a flow chart depicting the operation of a time-triggered visualization process according to one embodiment of the present disclosure. Figure 3 The process shown in can be found below about Figure 4The multi-artboard time-triggered visualization module 416 described above is implemented in the embodiment of the present disclosure. As previously described, the time-triggered process allows an animator to create a time sequence of multiple artboards that are treated as a single artboard for animation purposes, where time serves as a triggering event between the animation from one artboard to the next. To facilitate this functionality, according to one embodiment of the present disclosure, the GUI provides a visualization tool to allow the animator to link multiple artboards in a time sequence. In addition, the time-triggered visualization process can apply one or more heuristics to determine whether to include a particular artboard within the time sequence. Figure 3 The process depicted in the flowchart shown in relates to the operation of a GUI that allows an animator to generate a time sequence of multiple artboards.

[0054] Reference now Figure 3 The process starts in 302. In 304, a drawing board connection 410 is received. According to one embodiment of the present disclosure, a user can use a link indicator (hereinafter referred to as Figure 8a-8c Description) to indicate the linking of multiple artboards. In 306, determine whether all artboards have been considered. If so (the 'yes' branch of 306), the process ends in 312. Otherwise (the 'no' branch of 306), the process continues with 308, where the next artboard is set as the current artboard. In 312, determine whether the current artboard is the first artboard in the sequence. If so (the 'yes' branch of 312), add frames to the current artboard in 314. Otherwise (the 'no' branch of 312), in 316, for example, using the animation matching process 100, determine whether there is a matching object between the previous artboard and the current artboard. If not (the 'no' branch of 316), the process continues with 306. Otherwise (the 'yes' branch of 316), the process continues with 318, thereby adding frames to the current artboard. The process then continues with 306.

[0055] Figure 4 FIG. 1 is a block diagram of an animation system according to an embodiment of the present disclosure. Figure 4 As shown in FIG. 4 , the animation system further includes an animation design system 404 and an animation preview system 403. Animators or designers can use the animation design system 404 to design any animation including any number of drawing boards. After the animation has been designed using the animation design system 404, the animator can use the animation preview system 403 to preview the animation and evaluate its effect. Figure 4 As shown in FIG. 4 , the animation design system 404 further includes a matching module 402, a multi-artboard time-triggered visualization module 416, and a data repository 406. The matching module 402 can execute as shown in FIG. Figure 1a-Figure 1cThe animation matching process 100 is described. In particular, the artboard 120 can be received by the animation design system 404 and stored in the data repository 210. The matching module 402 can retrieve the artboard 120 from the data repository 406 and execute the animation matching process 100 to generate a matched object 408.

[0056] The operation of the multi-artboard time-triggered visualization module 416 will now be described. According to one embodiment of the present disclosure, the multi-artboard time-triggered visualization module 416 performs a visualization process and provides control for the animation of multiple artboards arranged in a time sequence. Figure 4 As shown in , the multi-artboard time-triggered visualization module 416 receives the artboard connection 410, which indicates that the specific artboards 120 are linked together in a sequential manner to provide a seamless animation. The multi-artboard time-triggered visualization module 416 can submit information about the specific artboard 120 under consideration to the matching module 402, and in turn receive matching information such as the matched object 408 from the matching module 402.

[0057] After the designer has completed the animation design, the designer can preview the animation using the animation preview system 403. Figure 4 As shown in FIG. 4 , the animation preview system 403 further includes a drag heuristics module 414 and an animator 420. The drag heuristics module performs the Figure 2 The drag heuristics process 200 is described. The animator 420 receives the matching objects 408 and the output from the drag heuristics module to draw the animation 422.

[0058] The operation of the drag heuristics module 414 will now be described. Figure 4 As shown in , the matched objects 408 and the drag events 412 are received by the drag heuristics module 414. The drag events 412 may include, for example, mouse-based events or touch-screen-based events (e.g., a swipe or drag gesture on a touch screen) or other input device drag events. As previously described, the matched objects 408 include objects from the artboard 120 that have been matched using the animated shape matching process 100.

[0059] Figure 5 Various aspects of the matching process according to one embodiment of the present disclosure are illustrated. In particular, Figure 5 A scenario in which the animation matching process 100 can be applied is depicted. Figure 5 As shown in FIG. 1 , two artboards 120 ( 1 ) and 120 ( 2 ) are presented, each artboard being associated with child objects 502 ( 1 ) -502 ( 7 ) and 502 ( 8 ) -502 ( 16 ). A name attribute and a layer index attribute are shown for each object 502 . For example, object 502 ( 2 ) has a name of 'A' and a layer index of 6 . Figure 5 The type property is inferred from the shapes of the objects shown in the drawing. For example, object 502(2) is of the same type as object 502(10) because they are both rectangular. In addition, group objects (e.g., 502(1) and 502(14)) are indicated by dashed boxes. The distance property between objects can be inferred as the two-dimensional distance between the objects shown in the drawing. Assume Figure 5 Each object 502 shown in FIG. 5 may be associated with any number of other attributes not explicitly depicted therein.

[0060] For the purposes of this example, assume that the other attributes used for matching are layer index and distance. In addition, assume that a match is to be determined for object 502(4) using animated matching process 100. Since 502(4) is of the square type with the name "A", the candidate matches are 502(12) and 502(10). To determine the best match, the layer index and distance between 502(4) and both 502(10) and 502(12) need to be evaluated. Using the Euclidean metric, the best match can be expressed as:

[0061] min i (ld i -3) 2 +(x i -x) 2 +(y i -y) 2

[0062] where x and y are the corresponding coordinates of 502(4), ld i is the layer index of the i-th child object in the drawing board 120(2), and x i and i are the corresponding x- and y-coordinates of the ith child object in the drawing board 120(2). Figure 5 The example in utilizes only two attributes (layer index and distance), but according to alternative embodiments, any number of attributes may be utilized.

[0063] Figure 6a Depicted is an example operation of a drag heuristic process according to one embodiment of the present disclosure. For the purpose of this example, assume that object 502 in artboard 120(1) is to be animated. Because object 502 obviously moves a large distance in the x-direction, the x-direction is the dominant direction. In particular, the determination of the dominant direction can be achieved by comparing the absolute values ​​of the distances moved in the x-dimension and the y-dimension, as follows:

[0064] If |xd|>|yd|, then x is the dominant direction.

[0065] Otherwise y is the dominant direction.

[0066] According to some embodiments, the layer index between two objects is processed separately from the spatial difference between the two objects. Thus, for example, when determining the best match between an object in a first artboard and several objects in a second artboard, the spatial distance between the object in the first artboard and the object in the second artboard may first be determined, and the objects in the second artboard may be sorted according to the spatial distance. Then, the layer index difference between the object in the first artboard and the object in the second artboard may be determined, and the list may be sorted based on the difference, while maintaining the first sorting operation with respect to the spatial distance.

[0067] Figure 6b 1 and 2. Depicted is an example operation of a drag heuristic process in determining a dominant direction according to one embodiment of the present disclosure. Note that object 502 is moving in the southeast direction between artboard 120(1) and artboard 120(2). Because the dominant direction in this example is in the x-direction, scrolling or scrubbing is only implemented in the x-dimension, such as Figure 6b . In particular, the user can preview the animation by dragging on object 502, and by moving the animation playback head to the corresponding time point, the position of object 502 will be updated in proportion to the distance dragged horizontally from west to east. For example, and according to an example embodiment, consider that object 502 moves in a southeast direction and the entire animation takes 1 second. When the user drags object 502 50% to the east, the system operates to move the animation playback head to 0.5 seconds. If the user drags back 25% to the west, the system operates to move the animation playback head to 0.25 seconds. The user can continue to drag back and forth until the mouse or finger is released.

[0068] Figure 7 An example of a multi-panel time-triggered visualization process according to an embodiment of the present disclosure is depicted. Figure 7 As shown in , artboards 120(1), 120(2), and 120(3) can be linked together so that a single animation can be drawn. Note that Figure 7 The object 502 shown in FIG. 1 is moving vertically from POS A to POS B between artboards 120(1) and 120(2). However, the object 502 is moving horizontally from POS B to POS C between artboards 120(2) to 120(3). Thus, using the time-triggered visualization process, the combined vertical and horizontal motion between artboards 120(1)-120(3) can be presented as an overall movement in a northeast direction.

[0069] Figure 8a-8d A user interface and an example scenario for generating a multi-artboard time-triggered animation according to an embodiment of the present disclosure are shown. Figure 8a FIG. 4 shows an initial configuration of a user interface for generating a multi-artboard time-triggered animation according to an embodiment of the present disclosure. Figure 8aAs shown in , a user can interact with the main window 800, which also includes a board link pane 808, a timeline pane 802, and a layer pane 804. Figure 8a As shown in FIG. 8 , four artboards 120 (1)-120 (4) are initially displayed in the artboard linking pane 808. According to one embodiment of the present disclosure, a user can drag or drop one or more artboards in the multiple artboard linking pane 808 to indicate that the animator wishes to work with multiple artboards. When triggered by time, each of the artboards 120 (1)-120 (4) will be automatically animated in sequence.

[0070] Figure 8a Also shown is a timeline pane 802, which further shows a layer pane 804. The timeline pane 802 provides a visual interface that allows an animator to work with multiple artboards as if they were a single artboard. After the animator has selected multiple artboards to work with, the animator can then establish a time sequence between the selected artboards by linking the selected artboards together using visual link indicators 810. For example, Figure 8a Artboards 120 ( 1 ) and 120 ( 2 ) are shown to include a sequence indicated by a visual link indicator 810 therebetween.

[0071] According to one embodiment of the present disclosure, the multi-time triggered visualization process 300 can apply one or more heuristics to determine which artboards should be added as frames in the animation sequence. In particular, if the animation can be completed between two different linked artboards (i.e., the matching algorithm determines at least one matching object 502 between the artboards 120), then the two artboards 120 will appear in the timeline pane 802 as corresponding frames 806. That is, if it makes sense to do so (i.e., there are matching objects with respect to other artboards in the sequence), each artboard does not exist as a different component, but becomes a frame in the time sequence. According to Figure 8a In the example shown in , a user has selected two artboards (120(1) and 120(2) and linked them together, as indicated by visual link indicator 810, which indicates to the system that a time trigger will be established between artboards 120(1) and 120(2). Accordingly, timeline pane 802 automatically displays corresponding frames 806(a) and 806(b) corresponding to respective artboards 120(1) and 120(2).

[0072] As currently in Figure 8aAs shown in FIG, because a link is established between two artboards 120(1) and 120(2), automatic animation can be initiated between the two artboards 120. Accordingly, after the designer has indicated that it is desired to start automatic animation, the animation matching process 100 will be initiated to determine matching objects between artboards 120(1) and 120(2), followed by drawing of the animation. If the designer indicates a link between artboards 120(1), 120(2), 120(3), and 120(4), these artboards will be treated as a single artboard if possible.

[0073] Figure 8b The configuration of a user interface for generating a multi-artboard time-triggered animation that clearly indicates the relationship between artboards and frames according to an embodiment of the present disclosure is shown. In particular, Figure 8b As shown in FIG. 8 , artboards 120 ( 1 ) and 120 ( 2 ) are explicitly represented in the timeline pane 802 as frames 806 ( a ) and 806 ( b ), respectively.

[0074] Figure 8c The configuration of a user interface for generating a multi-artboard time-triggered animation that clearly indicates the relationship between artboards and frames according to an embodiment of the present disclosure is shown. In particular, Figure 8c As shown in FIG. 8 , the third artboard 120 ( 3 ) has been added and a frame 806 ( c ) has been automatically generated in the timeline pane 802 .

[0075] Figure 8d FIG. 1 shows a configuration of a user interface for generating a multi-artboard time-triggered animation according to an embodiment of the present disclosure. In particular, Figure 8d , because the highlighted layer exists in artboard 120(1) but fades out in artboard 120(2), no transition will be generated for artboard 120(3). Because the layer no longer exists in artboard 120(2), no transition will appear on timeline 120 from artboard 120(2) to artboard 120(3).

[0076] The duration and sequencing time controls 820(a)-820(e) can be manipulated to change the "duration" and "start time" of the animation for each object. Because a single timeline for all three artboards is displayed, it is more intuitive to adjust these parameters in one place rather than by looking through a similar UI between artboard 1 and artboard 2 and another UI for artboard 2 and artboard 3.

[0077] Integration of computing systems and network environments

[0078] Figure 9a An example computing system that performs an animation process according to one embodiment of the present disclosure is illustrated. Figure 9a, computing device 500 may include a CPU 504 that executes one or more processes to execute animation system 400. In particular, CPU 504 may also be configured via program instructions to execute animation system 400 (as described differently herein). Other common components and modules of a common computing system (such as, for example, a coprocessor, a processing core, a graphics processing unit, a mouse, a touch pad, a touch screen, a display, etc.) are not shown but these are obvious. In view of the present disclosure, numerous computing environment variations will be obvious. Computing device 500 may be any independent computing platform, such as a desktop or workstation computer, a laptop computer, a tablet computer, a smart phone or a personal digital assistant, a game console, a set-top box, or other suitable computing platform. According to an alternative embodiment, CPU 504 may be replaced by a GPU.

[0079] Figure 9b An example integration of an animation system into a network environment according to an embodiment of the present disclosure is illustrated. Figure 9b As depicted in , computing device 500 may be collocated in a cloud environment, a data center, a local area network (“LAN”), and the like. Figure 9b The computing device 500 shown in FIG. Figure 9a The exemplary embodiments described are constructed identically. Figure 9b As shown in , client application 512 can interact with computing device 500 via network 510. In particular, client application 512 can issue requests and receive responses via API calls received at API server 506, which are transmitted via network 510 and network interface 508.

[0080] It should be understood that network 510 may include any type of public or private network, including the Internet or a LAN. It will be further readily understood that network 510 may include any type of public and / or private network, including the Internet, a LAN, a WAN, or some combination of these networks. In this example case, computing device 500 is a server computer, and client application 512 may be any common personal computing platform.

[0081] As will be further understood, computing device 500 (whether in Figure 9a Still in Figure 9b) includes and / or otherwise accesses one or more non-transient computer-readable media or storage devices, encoded with one or more computer-executable instructions or software, for implementing the techniques described differently in the present disclosure. The storage device may include any number of durable storage devices (e.g., any electronic, optical and / or magnetic storage devices, including RAM, ROM, flash memory, USB drive, onboard CPU cache, hard drive, server storage, tape, CD-ROM or other physical computer-readable storage media) for storing data and computer-readable instructions and / or software that implement the various embodiments provided herein. Any combination of memories may be used, and the various storage components may be located in a single computing device or distributed across multiple computing devices. In addition, and as previously explained, one or more storage devices may be provided separately from or remotely from one or more computing devices. Many configurations are possible.

[0082] In some example embodiments of the present disclosure, the various functional modules described herein and the specific training and / or testing of the network 510 may be implemented using software, such as a set of instructions (e.g., HTML, XML, C, C++, object-oriented C, JavaScript, Java, BASIC, etc.) encoded on any non-volatile computer-readable medium or computer program product (e.g., a hard drive, server, disk, or other suitable non-volatile memory or collection of memories), which, when executed by one or more processors, enables the execution of the various creator recommendation methods provided herein.

[0083] In other embodiments, a software-based engine is used to implement the techniques provided herein. In such embodiments, the engine is a functional unit comprising one or more processors that are programmed or otherwise configured with instructions encoding the creator recommendation process as variously provided herein. In this manner, the software-based engine is a functional circuit.

[0084] In other embodiments, the technology provided herein is implemented with hardware circuits, such as gate-level logic (FPGA) or dedicated semiconductors (e.g., application-specific integrated circuits or ASICs). Still other embodiments are implemented using a microcontroller having a processor, multiple input / output ports for receiving and outputting data, and multiple embedded routines of the processor for performing the functionality provided herein. In a more general sense, any suitable combination of hardware, software, and firmware can be used, which is obvious. As used herein, a circuit is one or more physical components and can be used to perform a task. For example, a circuit can be one or more processors programmed with software modules or otherwise configured, or a logic-based hardware circuit that provides a set of outputs in response to a specific set of input stimuli. Numerous configurations will be obvious.

[0085] Additional Example Embodiments

[0086] The following examples relate to further embodiments, of which numerous permutations and configurations will be apparent.

[0087] Example 1 is a method for performing an animation. The method includes determining a first sub-object of a first artboard and a second sub-object of a second artboard. If multiple second sub-objects in the second sub-object match the first sub-object, the method also includes adding the multiple second sub-objects to an initial list; sorting the initial list based on at least one distance metric associated with the first sub-object and the multiple second sub-objects to generate a sorted list, the at least one distance metric being based on at least one attribute associated with the first sub-object and the multiple second sub-objects; and generating an association between the first sub-object and the second sub-object corresponding to the first entry in the sorted list. The method also includes drawing an animation using the association, the animation including the first sub-object and the second sub-object corresponding to the first entry in the sorted list.

[0088] Example 2 includes the subject matter of Example 1, wherein at least one distance metric is based on a layer distance attribute associated with a first sub-object and a plurality of second sub-objects such that the sorting causes a first sub-object of the second sub-objects to be listed higher in the sorted list than a second sub-object of the second sub-objects, the first sub-object of the second sub-objects having a first number of layers by which it is separated from the first sub-object, and the second sub-object of the second sub-objects having a second number of layers by which it is separated from the first sub-object, the second number being greater than the first number. Note that the number of layers separating the first sub-object and the second sub-object can be related to layer 1 of a given layer hierarchy, or to some other layer within the hierarchy. To this end, the number of layers by which one sub-object is separated from another sub-object can be calculated in a variety of ways, as long as the layer differentiation techniques used are applied in a consistent manner, as will be understood in light of the present disclosure.

[0089] Example 3 includes the subject matter of Example 1 or Example 2, wherein at least one distance metric is based on the number of attributes associated with a first sub-object that match attributes associated with multiple second sub-objects, so that the sorting causes a first sub-object of the second sub-objects to be listed higher in the sorted list than a second sub-object of the second sub-objects, the first sub-object of the second sub-objects has a first number of matching attributes, and the second sub-object of the second sub-objects has a second number of matching attributes, the second number being less than the first number.

[0090] Example 4 includes the subject matter of any of the preceding examples, wherein at least one attribute includes one or more of position, size, fill color, stroke color, visibility, corner radius, line height, character spacing, and font size.

[0091] Example 5 includes the subject matter of any of the preceding examples, and further includes recursing using the first entry in the sorted list and the first child object if the first entry in the sorted list is a group.

[0092] Example 6 includes the subject matter of Example 5, and further includes setting the first artboard as a first entry in the sorted list, and setting the second artboard as an object associated with the first entry.

[0093] Example 7 includes the subject matter of Example 5 or Example 6, wherein drawing the animation comprises animating at least one pair of matching objects.

[0094] Example 8 includes the subject matter of any of the preceding examples, wherein a single one of the second sub-objects matches the first sub-object.

[0095] Example 9 includes the subject matter of any of Examples 8, wherein a match is determined if the first sub-object has the same name and type as a single sub-object in the second sub-object.

[0096] Example 10 is a method for previewing an animation, the method comprising: receiving a first object associated with a first artboard and a second object associated with a second artboard, wherein the first object and the second object represent a single entity at a first time and a second time, respectively; determining a dominant direction of movement relative to the first object and the second object; receiving a drag event in the dominant direction; and updating an animation state of a visual representation of the entity in response to the drag event.

[0097] Example 11 includes the subject matter of Example 10, wherein the dominant direction is one of a horizontal direction or a vertical direction.

[0098] Example 12 includes the subject matter of Example 11, wherein the dominant direction is determined by selecting a direction associated with a maximum absolute value in a displacement with the entity between the first time and the second time.

[0099] Example 13 includes the subject matter of any of Examples 10 to 12, wherein the drag event is caused by a mouse movement.

[0100] Example 14 includes the subject matter of any of Examples 10 to 13, wherein before receiving the first object and the second object, the method further comprises determining that the first object and the second object match each other with respect to a distance metric calculated based on at least one attribute associated with both the first object and the second object.

[0101] Example 15 includes the subject matter of Example 14, wherein the at least one property includes one or more of position, size, fill color, stroke color, visibility, corner radius, line height, character spacing, and font size.

[0102] Example 16 includes the subject matter of any of Examples 10 to 15, wherein updating the animation state further comprises drawing the entity on the graphical user interface to reflect the updated position.

[0103] Example 18 is a computer program product comprising one or more non-transitory machine-readable media encoded with instructions that, when executed by one or more processors, cause a process for performing an animation to be performed, the process including the subject matter of any one of Examples 1 to 9.

[0104] Example 19 is a computer program product comprising one or more non-transitory machine-readable media encoded with instructions that, when executed by one or more processors, cause a process for previewing an animation to be performed, the process comprising the subject matter of any of Examples 10 to 16.

[0105] The foregoing description of the example embodiments of the present disclosure has been drawn for the purpose of illustration and description. It is not intended to be exhaustive or to limit the present disclosure to the precise form disclosed. In view of the present disclosure, many modifications and variations are possible. The scope of the present disclosure is not intended to be limited by this detailed description, but rather by the appended claims.

Claims

1. A method for performing an animation, the method comprising: Determine a first sub-object of the first artboard and a second sub-object of the second artboard; If multiple second sub-objects in the second sub-object match the first sub-object, then: adding the plurality of second child objects to the initial list, sorting the initial list based on at least one distance metric associated with the first sub-object and the plurality of second sub-objects to generate a sorted list, the at least one distance metric being based on at least one attribute associated with the first sub-object and the plurality of second sub-objects, and generating an association between the first sub-object and the second sub-object corresponding to the first entry in the sorted list; as well as An animation is drawn using the association, the animation including the first sub-object and the second sub-object corresponding to the first entry in the sorted list.

2. A method according to claim 1, wherein the at least one distance metric is based on a layer distance attribute associated with the first sub-object and the multiple second sub-objects, so that the sorting causes the first second sub-object of the second sub-objects to be listed higher in the sorted list than the second second sub-object of the second sub-objects, the first second sub-object of the second sub-objects has a first number of layers, the first second sub-object of the second sub-objects is separated from the first sub-object by the first number of layers, and the second second sub-object of the second sub-objects has a second number of layers, the second second sub-object of the second sub-objects is separated from the first sub-object by the second number of layers, and the second number is greater than the first number.

3. A method according to claim 1, wherein the at least one distance metric is based on the number of attributes associated with the first sub-object that match the attributes associated with the multiple second sub-objects, so that the sorting causes the first second sub-object of the second sub-objects to be listed higher in the sorted list than the second second sub-object of the second sub-objects, the first second sub-object of the second sub-objects has a first number of matching attributes, and the second second sub-object of the second sub-objects has a second number of matching attributes, the second number being less than the first number.

4. The method of claim 1, wherein the at least one attribute comprises one or more of position, size, fill color, stroke color, visibility, corner radius, line height, character spacing, and font size.

5. The method according to claim 1, further comprising: If the first entry in the sorted list is a group, recursing using the first entry in the sorted list and the first sub-object. The method of claim 1 , wherein a single one of the second sub-objects matches the first sub-object.

7. The method of claim 6, wherein a match is determined if the first sub-object has the same name and type as the single second sub-object in the second sub-objects.

8. A computer program product comprising one or more non-transitory machine-readable media encoded with instructions that, when executed by one or more processors, cause a process for performing an animation to be performed, the process comprising: Determine a first sub-object of the first artboard and a second sub-object of the second artboard; If multiple second sub-objects in the second sub-object match the first sub-object, then: adding the plurality of second child objects to the initial list, sorting the initial list based on at least one distance metric associated with the first sub-object and the plurality of second sub-objects to generate a sorted list, the at least one distance metric being based on at least one attribute associated with the first sub-object and the plurality of second sub-objects, and generating an association between the first sub-object and the second sub-object corresponding to the first entry in the sorted list; as well as An animation is drawn using the association, the animation including the first sub-object and the second sub-object corresponding to the first entry in the sorted list.

9. A computer program product according to claim 8, wherein the at least one distance metric is based on a layer distance attribute associated with the first sub-object and the multiple second sub-objects, so that the sorting causes the first second sub-object of the second sub-objects to be listed higher in the sorted list than the second second sub-object of the second sub-objects, the first second sub-object of the second sub-objects has a first number of layers, the first second sub-object of the second sub-objects is separated from the first sub-object by the first number of layers, and the second second sub-object of the second sub-objects has a second number of layers, the second second sub-object of the second sub-objects is separated from the first sub-object by the second number of layers, and the second number is greater than the first number.

10. A computer program product according to claim 8, wherein the at least one distance metric is based on the number of attributes associated with the first sub-object that match the attributes associated with the multiple second sub-objects, so that the sorting causes a first second sub-object of the second sub-objects to be listed higher in the sorted list than a second second sub-object of the second sub-objects, the first second sub-object of the second sub-objects having a first number of matching attributes, and the second second sub-object of the second sub-objects having a second number of matching attributes, the second number being less than the first number.

11. The computer program product of claim 8, wherein the at least one property comprises one or more of position, size, fill color, stroke color, visibility, corner radius, line height, character spacing, and font size.

12. The computer program product of claim 8, the process further comprising: If the first entry in the sorted list is a group, recursing using the first entry in the sorted list and the first sub-object.

13. The computer program product of claim 8, wherein a single one of the second sub-objects matches the first sub-object.

14. The computer program product of claim 13, wherein a match is determined if the first sub-object has the same name and type as the single second sub-object of the second sub-object.