Intelligent change summary for designer

Abstract

Embodiments for generating intelligent change summaries are disclosed. In some embodiments, a method of generating an intelligent change summary includes obtaining representations of a plurality of versions of a document; determining a distance score based on a comparison of a first version of the document and a second version of the document, the distance score representing a magnitude of changes made from the first version of the document to the second version of the document; and generating a change summary for the document based on the distance score.

Description

Background Technology

[0001] Collaborative editing is a key goal of collaboration, allowing multiple creators to design simultaneously on the same canvas. An increasing number of design workflows are shifting to digital platforms, enabling the geographical distribution of collaborators. Therefore, scenarios where designers with varying levels of expertise work together on a shared canvas are becoming more common. This can take the form of cloud-based documents, which can be maintained remotely and accessed by multiple users. Cloud documents enable collaboration—in some cases, enabling real-time collaborative editing. Cloud documents are often automatically saved, and these previous saves are available to users via document history or version history. This allows users to browse, access, and restore previous states of the document they are collaborating on. However, managing changes, especially long-term documents, is complex, and it can be difficult to identify versions of documents that made specific changes without knowing when those changes were made.

[0002] There are these and other issues regarding collaborative design in electronic systems. Summary of the Invention

[0003] This section describes methods / techniques for providing automated approaches to display changes over time in cloud documents. This enables different ways to browse changes and identify points that can represent inflection points in a document's lifecycle. In some embodiments, the management system is designed to compare document versions to clearly identify changes that a user might be interested in when deciding which version of the document to open or which version to mark as a milestone. These identified inflection points can then be utilized by the user to increase navigation ease and to bookmark versions for archiving and future use.

[0004] Additional features and advantages of the exemplary embodiments of this disclosure will be set forth in the following description, and will be apparent in part from the description, or may be learned by practice of such exemplary embodiments. Attached Figure Description

[0005] Please refer to the accompanying drawings for a detailed description, in which:

[0006] Figure 1 The illustration is a schematic diagram of the process of summarizing intelligent changes according to one or more embodiments;

[0007] Figure 2 The diagram illustrates the structure of a document according to one or more embodiments;

[0008] Figure 3 The diagram illustrates the process of calculating the distance between versions of a document according to one or more embodiments;

[0009] Figure 4The illustration shows an example of changes to documents discovered based on a distance metric, according to one or more embodiments;

[0010] Figure 5 The illustration shows an example of a high-importance change according to one or more embodiments;

[0011] Figure 6 The illustration shows an example of a change in importance according to one or more embodiments;

[0012] Figure 7 The illustration shows an example of a low-importance change according to one or more embodiments;

[0013] Figure 8 The diagram illustrates a process for associating identifiers with edit types made between versions of a document, according to one or more embodiments.

[0014] Figure 9 The diagram illustrates the process of summarizing changes to the generated document according to one or more embodiments;

[0015] Figure 10 The illustration shows an example user interface according to one or more embodiments;

[0016] Figure 11 The illustration shows a schematic diagram of a design management system according to one or more embodiments;

[0017] Figure 12 The diagram illustrates a series of actions in a method for summarizing intelligent changes according to one or more embodiments;

[0018] Figure 13 The illustration shows a schematic diagram of an exemplary environment in which an image processing system according to one or more embodiments may operate; and

[0019] Figure 14 A block diagram of an exemplary computing device according to one or more embodiments is illustrated. Detailed Implementation

[0020] Tracking changes, version control, and saving checkpoints are common features of many software applications. For example, GitHub tracks changes made to code via commits and provides tools to visually compare which lines were added and deleted. ViusalStudio Code follows a similar routine to describe the differences between two code instances. Various applications provide users with timestamped versions and highlighted changes. Online design applications also offer version control, but these primarily enable synchronized workflows with no conflicts across versions. Such typical applications do not attempt to build and / or semantically understand the changes made by multiple users on their canvases beyond the timestamp index. Other applications may identify conflicting edits, but rely on user comments in other ways to identify which changes are important.

[0021] As discussed, existing systems do not address the problem of understanding changes in complex digital design spaces, where changes can range from minute (changing the border thickness of a rectangle) to significant (changing the emotional theme of a canvas). No attempt has been made to derive the intent and / or ranking of changes (e.g., by quality, importance, etc.). Text-editing and image-editing models apply a limited range of simple changes across short time periods. Implementations collect and summarize changes across much longer time periods, such as the entire or partial lifecycle of a design document.

[0022] The implementation automatically identifies significant edits / changes in collaborative documents / designs. These changes are scored to identify inflection points in the various edits and changes available in the document. The scoring can also be used to distinguish between regular (e.g., minor) changes and inflection points (e.g., major changes) in a document or design. This enables rapid navigation to key points and automatic identification of important document versions.

[0023] While existing technologies typically track change, these tools require users to manually inspect hundreds of versions of a given document to navigate through changes that occur along the way and identify versions that introduced significant changes. Furthermore, because changes and edits often occur across multiple dimensions, identifying the semantic importance of changes within the context of the rest of the design is not straightforward. This implementation allows significant changes to a document to be identified, tagged according to the type of change made, and sorted by score, change type, etc. This makes it easier for users to track and report updates and, if necessary, revert to a specific change.

[0024] Figure 1 The diagram illustrates the process of summarizing intelligent changes according to one or more embodiments. Figure 1As shown, the embodiments may include a design management system 100. In some embodiments, the design management system 100 may be integrated into a design application, application suite, etc., or it may be implemented as a standalone system that interfaces with the design application, application suite, etc., to provide version tracking and management services to the applications(s) it interfaces with. The design management system 100 is responsible for ranking and classifying document versions based on changes that occur across document versions.

[0025] For example, at number 1, the design management system 100 may receive a design version history 102. The design version history 102 may include multiple timestamped versions of a particular document. In some embodiments, the design version history may be a data structure that points to or otherwise links to multiple timestamped versions of a document, which may be stored in a central storage location or across multiple electronic devices (e.g., desktop computers, laptops, servers, mobile devices, etc.). In some embodiments, each version of the document may be a separate file saved by one or more users or automatically saved by an application editing the document. In some embodiments, the design version history 102 may be specific to the type of document and / or application and may be available to the design management system 100 through the application.

[0026] When design version history 102 is received by design management system 100, it can be processed by representation manager 104. In some embodiments, at number 2, representation manager 104 can generate a representation of the document based on its version history 102. For example, as discussed further below, the design version history can be converted to JSON, XML, or other formats. The representation format allows various versions of the document in version history 102 to be compared to identify changes from one version to the next. By comparing the representation of the document's versions with the representation of previous versions of the document, the progression of how the document has been changed (e.g., when what was added, at what point some items changed, some items were deleted, etc.) can be determined by design management system 100. After identifying these changes, embodiments score these changes and identify delta or differences across successive changes to mark inflection points in the document using unsupervised scoring and distance calculation techniques described further below.

[0027] As previously mentioned, collaborative document editing produces multiple versions, which are automatically saved after a series of changes. At number 3, distance manager 106 receives a representation of design version history 102 from representation manager 104. In some embodiments, input to design management system 100 may be a representation of design version history 102 (e.g., so that reformatting is not required). In this case, representation manager 104 can be bypassed. Alternatively, representation manager 104 may determine that the input design version history 102 has been correctly formatted (e.g., based on file type or other attributes) and pass it across the representation to distance manager 106.

[0028] At number 4, distance manager 106 determines a distance metric value, which indicates the degree of difference between two versions of a document. Distance manager 106 can determine the distance metric for each consecutive version pair in the design version history. As discussed, the design version history 102 can include multiple saved versions. A saved version can be defined as v i Let i = 1, ..., T. Each of these versions can include a sequence of changes to previous versions. To determine the inflection point among multiple versions, a distance function d(v) is defined between version i and version i+1. i v i+1 ).

[0029] The embodiments described pertain to user interface design documents, such as those generated by a user interface design application like Adobe XD. This is for simplicity of explanation and is not intended to be limiting. The embodiments can similarly be applied to other design document types associated with different design applications. As mentioned above, document versions may include multiple artboards, such as b1, b2, ..., b n In some embodiments, b ij This represents data corresponding to the j-th canvas in the i-th version, including attributes defining the state of various elements on the canvas at that time step. Elements can include shapes (rectangles, ellipses, lines, etc.), text, or groups such as components. As new object definitions are added to the design / creation platform, this method can be adapted to extend to other types of elements. Depending on the element type, various attributes can include size, position, strokes, color, text, etc. The following symbols are defined:

[0030] It is drawing board b ij The k-th element in the array, where k = 1, 2, ..., K.

[0031] It is the first The p-th attribute of an element, where p = 1, 2, ..., P.

[0032] For changes to the existing canvas and objects, the distance d(v) between the i-th version and the (i+1)-th version is... i v i+1 It was assessed as,

[0033]

[0034] The first term here determines the change distance between different attributes (such as "fill", "text", "shape") across version i and version i+1. For example, when considering the "text" attribute, the first term produces a weighted Levenshtein distance. The second term corresponds to the addition or deletion of an artboard. K(j′) is the number of elements added / deleted on artboard j′, where Intuitively, this captures the differences between elements on the artboard and the differences in properties across those elements. This helps to quantify change based on well-defined steps.

[0035] To identify inflection point versions, the top k (k=5) versions with the highest distance metric value between the next (i) version and the current (i+1) version (e.g., the version that has changed the most compared to its predecessor) are considered. In some embodiments, the value of K is determined empirically based on the score distribution associated with the document being analyzed. Based on the delta (i.e., distance value) in the scores, inflection point versions or points are further classified as high importance, medium importance, and low importance. These values ​​are provided as guidance relative to very strict metrics, as they are often subjective for designers and their needs within the document context.

[0036] While all edit markers across a document facilitate easy navigation, it is also necessary to distinguish the types of edits appearing on the document. In some embodiments, at number 5, the edit manager 108 is responsible for identifying the types of edits associated with changes made between versions of the document. In some embodiments, the edit manager 108 may receive a list of changes between versions identified by the distance manager 106 as described above. The edit manager may then identify the “keys” associated with the change attributes in the version representation to determine the type of change that has been made.

[0037] The ability to navigate changes by the type of edit made improves reviewers' ability to focus on changes that are important to them. For example, color edits might be more important to a reviewer of a design document than to a reviewer of a text document. On the other hand, changes in text fields might be more important to a reviewer of a text-heavy document where semantics are crucial. Therefore, changes between versions are further categorized into at least the following types: additions, artboard additions, artboard deletions, color changes, deletions, and text changes. Equation 1 above can also be applied to inflection point detection on local subsets of type-specific changes. This allows users to navigate through their history and changes using terms such as "take me to a color change" or "component addition." Note that these changes do not occur in isolation and therefore require some formulas regarding inflection point identification.

[0038] In some embodiments, the edit manager receives a list or other data structure that identifies changes made between versions, such as those identified by the distance manager at number 4. Alternatively, the edit manager may perform its own comparison of representations of two versions of the document obtained from the representation manager 104. As discussed, the representation manager may convert the document's versions from the design version history 102 into a format for analysis. For example, the representation manager 104 may convert the artboard AGC file to JSON format, using existing keys as indicators of the change type. For example, all changes to the value of the "fill" key are categorized as color changes. Any changes to the value of the "text" key in the AGC-JSON document can be categorized as text changes. Newly added artboards are categorized as "artboard added" changes, and removed artboards are categorized as "artboard deleted." When a version of the document does not have a corresponding artboard, the artboard is identified as either added or deleted. Similarly, if an element is removed from a version of the document compared to a previous version, the change is categorized as "deleted." Likewise, if an element is added compared to a previous version of the document, the change is categorized as "added."

[0039] In some embodiments, different keys can be weighted according to their importance. For example, the "fill" key can be weighted at different levels of abstraction with hierarchical importance. This allows "fill" changes at the artboard level to receive higher weight than "fill" changes at the graphics object level. In some embodiments, a sequence matcher is used to align JSON elements and categorize changes into corresponding types. This ensures that "fill" or "text" key-value pairs for the same artboard are compared across two versions.

[0040] After the changes between versions have been identified and the distance score and edit type have been determined, this information can be provided to the summary manager 110 at number 6. At number 7, the summary manager 110 can generate a visual representation of the changes, identifying the changes made between versions of the document. As discussed further, the resulting change summary 120 can highlight high, medium, and low importance changes, allowing users to revert to previous versions of changes made to specific elements, etc. At number 8, the change summary can be output to the user. This can include displaying the change summary as part of the graphical user interface of a design application, displaying the change summary as a standalone design management or version control application, etc. In some embodiments, the change summary can be generated in a format that can be reviewed outside the design application, such as a portable document format (PDF) document.

[0041] Figure 2 The diagram illustrates the structure of a document 200 according to one or more embodiments. In some embodiments, each document may be indexed using a unique identifier, which can be used to query related document data from a storage location. The document data may include a list of versions, and each version may include a set of components and / or interactions. Figure 2 In the example, document 200 is associated with M-1 versions: version 1 202 to version M 208. Each version is associated with one or more artboards. For example, version 3 206 includes N-1 artboards: artboard 1 210 to artboard N 216. Each artboard may also include one or more interactive components. For example, artboard 2 212 includes K-1 components: component 1 218 to component K 220 and interaction 222. Other types of documents can be organized differently. For example, document 200 could be a user interface design document. If a text document is being presented, each version may not include an artboard.

[0042] The design management system 100 uses manifest files to iterate over components and downloads components and / or interactions for each version within a release. Components are converted from their existing formats (such as AGC format) to representation formats (such as JSON format) for processing. Each component has characteristics such as shape, size, color, relative and absolute position within the canvas, artboard ID, name, text, etc. Components can be grouped together based on their artboard IDs. This provides textual context for canvases to be analyzed across versions. In some embodiments, visual context can be naturally obtained from document data when the artboard's rendering is stored. Alternatively or additionally, screenshots of the artboard can be obtained (manually or automatically) and used for visual context.

[0043] Figure 3The diagram illustrates the process of calculating the distance between versions of a document according to one or more embodiments. As discussed, distance manager 106 is responsible for identifying changes between document versions (such as versions AD 300-306). As mentioned above, versions 300-306 can be obtained from version history. Versions can be representations of document versions, and the document has been converted to a JSON or other format file to capture the elements of each version. These versions can be received by difference manager 308, which compares corresponding elements from each consecutive version pair. For example, as... Figure 3 As shown, the difference manager 308 can calculate three differences from four input versions. These differences include difference BA 312, difference CB 314, and difference DC 316. More or fewer differences can be calculated depending on the number of versions received by the distance manager.

[0044] Each difference 312-314 can include a list of all changes between the two versions. This could include different padding values, different text values, new or removed elements, etc. These differences can be fed to a distance function 318. The distance function 318 can calculate the distance between the changes quantified between versions. For example, Equation 1 above shows such a distance function 318 that can be used to calculate the distance value. In the example of Equation 1, the distance value is a combination of changes in element attribute values ​​and the total number of new or removed elements. However, alternative distance functions can also be used. For example, weights can be applied to the values ​​of certain types of elements.

[0045] Figure 4 The illustration shows an example of changes to documents discovered based on a distance metric, according to one or more embodiments. Figure 4 The sample file and its version scores are shown. Table 400 on the left shows version 402 (named by date / timestamp) and the calculated distance 404 from the previous version on the right. Note that these numbers are distances or score differences relative to absolute values. For the highlighted image, the design management system lists the highlighted artboard changes as one of the most significant changes indexed by "February 3, 2:59 AM," with a distance of 400 points from the previous snapshot. Here, as can be seen, compared to the version "February 3, 1:27 AM," the version "February 3, 2:59 AM" added three new artboards 406 that are highlighted in the zoomed view, and no existing artboards were modified. Therefore, based on Equation 1, the distance score of 400 points will include the total number of elements from the three new artboards, which equals 400 in this example. If other existing artboards were modified, these changes are also considered as factors in the distance score, as discussed above regarding Equation 1.

[0046] Figure 5Examples of highly important changes according to one or more embodiments are illustrated. Figure 5 As shown, specific inflection points can also be identified based on changes within the artboard. For example, in a previous version of the document, artboard 500 included a prom banner element 502. In a later version, the artboard was modified to artboard 504, which now depicts a mood board / creative board 506. This indicates a change of high importance to the document because the entire artboard has been altered. This resulted in the addition and removal of numerous elements on the artboard, producing high distance scores. In some embodiments, the number of attributes associated with the new elements can be summed to determine the distance scores of these new elements. In some embodiments, the values ​​of the attributes of the new elements can be used to determine the distance scores. For example, larger new elements, due to having larger size attributes, can contribute higher distance scores than smaller elements.

[0047] Figure 6 Examples of changes in importance according to one or more embodiments are illustrated. Figure 6 In the image, some changes are shown within artboard set 600, where design blocks (i.e., color and opacity elements) have been added. For example... Figure 6 As shown, the previous artboard did not include any elements in area 602. In a later version, the updated artboard 604 now includes a design block 606 with several user interface controls that allow users to interact with the document. This represents a change in the relative importance of the document, as elements are added to the document but most of the artboard remains unchanged. This produces a distance score corresponding to the number of elements added. In some embodiments, each element may contribute the same amount to the distance score (e.g., a new element equals an additional score added to the distance score). Alternatively, different types of elements may have different scores, contributing that different amount to the distance score. For example, user-interactive elements may be associated with a higher score compared to passive elements (e.g., images, etc.). Additionally or alternatively, the attributes of added or removed elements may contribute to the distance score. For example, larger elements (as indicated by their "size" attribute) may contribute a larger distance score than smaller elements.

[0048] Figure 7 The illustration shows an example of a low-importance change according to one or more embodiments. Figure 7 This illustrates a change that was detected as having low importance. Figure 7In the example, elements in the previous version artboard 700 have been scaled in the subsequent version artboard 702. In this example, it is a small scaling change, as indicated at 704. In the context of other changes observed in this particular design and various other variations, this particular scaling change is referred to as a change of low importance. This means a low-importance change because the elements are only slightly scaled within one artboard of the artboard.

[0049] Figure 8 The diagram illustrates a process of associating identifiers with edit types associated with changes made between versions of a document, according to one or more embodiments. As discussed, edit manager 108 may receive differences 310-316 generated by distance manager 106. The edit manager may include key manager 800, which identifies keys associated with attributes of each change in each difference. As discussed, keys may include “fill” or “text” key-value pairs, or may include other keys associated with the value of the change represented in the difference. After the keys associated with the changes have been identified by key manager 800, they may be classified into edit types by edit type classifier 802. The edit type classifier may include a data structure that maps keys to specific edit types. For example, a fill key may be mapped to a color edit type, a text key may be mapped to a text edit type, etc. After the changes have been mapped to their edit types, edit type counter 804 may determine the number of edit types for each difference. For example, the edit type counter may include multiple counters (e.g., one counter per edit type) that increment as the edit type is identified.

[0050] Figure 9 The diagram illustrates a process for summarizing changes to a generated document according to one or more embodiments. For example... Figure 9 As shown, the summary manager 119 can receive difference data 900 (e.g., differences 312-316 mentioned above) and distance data 902 (e.g., distance values ​​322-326 mentioned above) from the distance manager 106 and the edit type counter 804, and can also receive edit type data 903 from the edit manager 108. Using this data, the summary manager 110 can generate a smart change summary of the document.

[0051] In some embodiments, the summary manager 110 may include a cluster manager 904. The cluster manager 904 may identify clusters of distance values ​​to indicate high, medium, and low importance changes. Typically, most versions have little or no change compared to previous versions. Therefore, the distance values ​​associated with these versions are expected to be zero or close to zero. These versions can generally be ignored by the summary manager. Instead, the cluster manager 904 may identify clusters of distance scores, including the K largest distance scores corresponding to high importance changes, followed by clusters of medium and low scores. The size of these clusters may vary depending on the distribution of distance scores in the documents being analyzed.

[0052] Summary manager 110 may further include label manager 906. Label manager 906 may receive edit type data 903, which may include edit types associated with changes in the difference data, as determined by the edit type classifier described above. Label manager 906 may generate one or more labels to be associated with distance scores. In some embodiments, each edit type that contributes to the distance score of a given version may be labeled with that version. Alternatively, the edit type that contributes the largest amount of distance to the score of that version may be labeled. Furthermore, label manager 906 may label versions that have been clustered with an identifier associated with its cluster. For example, versions in a high-importance cluster may be labeled as having high importance, and so on for each cluster. The labels and distance data may then be provided to summary generator 908, which generates a visual representation of the version history, including the distance score and label associated with each version.

[0053] Figure 10 An example user interface 1000 according to one or more embodiments is illustrated. Figure 10 As shown, the user interface 1000 allows users to view version history chronologically or sort versions according to a specific editing type 1002. When sorting, the version with the highest score along the selected dimension (e.g., text, color, etc.) can be displayed first. For users, this simplifies the review of version history, allowing them to quickly identify relevant versions for inspection.

[0054] In some embodiments, the user interface 1000 may include a table comprising a version number / rank 1004, a version timestamp 1006, thumbnails of changes 1008, and labels 1010. For example, version 8 is shown as having a change. This is illustrated in thumbnail 1012, which may be selected to show the user an easily comparable view of the version to previous versions. Furthermore, changes are marked with text change labels 1014, indicating changes including, but not limited to, textual changes compared to previous versions. In some embodiments, the user interface 1000 may also include a global summary 1016, which includes edit type counter data in a visual form, indicating the number of each type of change that appears in the version history.

[0055] Figure 11 The illustration shows a schematic diagram of a design management system (e.g., the "Design Management System" above) according to one or more embodiments. As shown, the design management system 1100 may include, but is not limited to, a user interface manager 1102, a presentation manager 1104, a distance manager 1106, an editing manager 1108, a summary manager 1110, and a storage manager 1112. The storage manager 1112 includes a design version history 1118 and a change summary 1120.

[0056] like Figure 11 As shown, the design management system 1100 includes a user interface manager 1102. For example, the user interface manager 1102 allows a user to select one or more documents or document version histories to be processed by the design management system. In some embodiments, the user interface manager 1102 enables a user to select one or more files that include a design version history 1118 and are stored or accessed by a storage manager 1112. In some embodiments, the user interface manager 1102 enables a user to select a specific version to compare from the design version history (e.g., selecting a range based on timestamp data, version identifiers, etc.). Furthermore, the user interface manager 1102 allows a user to request the design management system to generate a change summary 1120 for the selected design version history. Additionally, the user interface manager 1102 allows a user to view the change summary, restore all or part of the document's state to an earlier state represented in different versions of the document, etc. In some embodiments, the change summary may be presented to the user via user interface elements managed by the user interface manager 1102, such as sidebars, pop-ups, or other visual elements. This can be provided through a graphical user interface of a digital design application, as a standalone design management application, or other applications.

[0057] like Figure 11As further shown, the design management system 1100 may also include a representation manager 1104. The representation manager 1104 can receive a design version history and can generate a representation for each version associated with the version history. In some embodiments, as described above, this may include converting the version history from a first format to a second format. For example, the canvas may be stored as an AGC format file. The representation manager 1104 can convert the AGC file to a JSON or other format file and represent the design version history in a tree structure. This allows for comparison of attributes of similar elements from different versions.

[0058] like Figure 11 As further shown, the design management system 1100 may also include a distance manager 1106. As discussed, the distance manager 1106 is responsible for comparing successive versions of the document being processed based on the document's version history. The distance manager 1106 may first calculate a difference representing all changes between a version and its previous versions. These may include additions, attribute value changes (e.g., size, position, padding, line width, text, etc.). These changes may then be processed by a distance function that assigns a score to each change. For example, the distance function may assign a score to each added element and remove a score from each deleted element. In some embodiments, scores may be assigned to new elements based on their attributes. For example, based on the size attribute of each element, larger elements may contribute a greater total score to the distance score compared to smaller elements. For changed elements, the score may be based on the change. For example, if the element's size attribute changes by X pixels, X scores may be added to the distance. Similarly, if the fill color of an element changes, these hexadecimal values ​​of the colors may be compared, and the difference is used to assign a score to the color change. In some embodiments, all changes may be weighted equally. Alternatively, some types of changes can be weighted more heavily than others. For example, color-forward documents can be weighted more heavily for color changes than for text changes, while text-forward documents can be weighted even more heavily for text changes.

[0059] like Figure 11As further shown, the design management system 1100 may also include an edit manager 1108. As discussed, the edit manager 1108 is responsible for identifying the edit type associated with changes found between versions. In some embodiments, the edit manager 1108 may receive differences generated by a distance manager and identify the keys associated with the changes. The edit manager 1108 may include a data structure that maps keys to edit types. For example, a change to a fill key corresponds to a color change, a change to a text key corresponds to a text change, and so on. The edit manager 1108 may additionally maintain an edit type counter, which increments as an edit type is identified for a change in a difference.

[0060] like Figure 11 As further shown, the design management system 1100 may also include a summary manager 1110. The summary manager 1110 may receive distance scores, edit type data, and counter data from the distance manager and the edit manager, and generate a visual representation of changes reflected in the version history (e.g., a change summary 1120). For example, the change summary 1120 may enable users to navigate from one version to another and may be presented with a description and / or depiction of the changes associated with that version. As discussed, the summary manager 1110 may tag versions based on the types of changes found. Furthermore, the summary manager 1110 may include thumbnails of the version and previous versions indicating the found changes. In some embodiments, the change summaries may be sorted based on the type of change, distance score, importance of the distance score, etc. In some embodiments, the change summary 1120 may include a data structure indicating the number of each type of change made in the version history or one or more selected versions.

[0061] like Figure 11 As shown, the design management system 1100 also includes a storage manager 1112. The storage manager 1112 maintains data used by the design management system 1100. The storage manager 1112 can maintain data of any type, size, or kind required to perform the functions of the design management system 1100. Figure 11As shown, storage manager 1112 includes design version history 1118. Design version history 1118 may include multiple timestamped versions of a particular document. In some embodiments, design version history may be a data structure that points to or otherwise links to multiple timestamped versions of a document, which may be stored in a central storage location or across multiple electronic devices (e.g., desktop computers, laptops, servers, mobile devices, etc.). In some embodiments, each version of a document may be a separate file saved by one or more users or automatically saved by an application editing the document. In some embodiments, design version history may be specific to the type of document and / or application and may be available to design management system 100 through the application.

[0062] like Figure 11 As further shown, the storage manager 1112 also includes a change summary 1120. The change summary 1120 may include a visualization of changes made across versions in the design version history being analyzed by the design management system. For example, the change summary 1120 may be implemented as a user interface element of the application's graphical user interface. As discussed, the change summary 1120 allows users to navigate from one version to another and is presented with descriptions and / or depictions of the changes associated with that version. As discussed, the summary manager 1110 may tag versions based on the type of changes found. Furthermore, the summary manager 1110 may include thumbnails of the version and previous versions indicating the found changes. In some embodiments, the change summaries may be sorted based on the type of change, distance score, importance of the distance score, etc. In some embodiments, the change summary 1120 may include a data structure indicating the number of each type of change made in the version history or one or more selected versions.

[0063] Each component and its corresponding element in components 1102-1112 of the design management system 1100 (such as...) Figure 11 (As shown) can communicate with each other using any suitable communication technology. It should be recognized that, although components 1102-1112 and their corresponding elements are... Figure 11 While shown as separate, any component of components 1102-1112 and its corresponding elements may be combined into fewer components (such as combined into a single facility or module), divided into more components, or configured as different components that can serve a particular embodiment.

[0064] Components 1102-1112 and their corresponding elements may include software, hardware, or both. For example, components 1102-1112 and their corresponding elements may include one or more instructions stored on a computer-readable storage medium and executable by a processor of one or more computing devices. When executed by one or more processors, the computer-executable instructions of the system 1100 designed to manage the system 1100 may cause client devices and / or server devices to perform the methods described herein. Alternatively, components 1102-1112 and their corresponding elements may include hardware, such as dedicated processing devices for performing specific functions or groups of functions. Additionally, components 1102-1112 and their corresponding elements may include a combination of computer-executable instructions and hardware.

[0065] Furthermore, components 1102-1112 of the design management system 1100 can be implemented, for example, as one or more standalone applications, one or more modules of an application, one or more plugins, one or more library functions, or functions that can be called by other applications, and / or a cloud computing model. Therefore, components 1102-1112 of the design management system 1100 can be implemented as standalone applications, such as desktop or mobile applications. Additionally, components 1102-1112 of the design management system 1100 can be implemented as one or more web-based applications hosted on a remote server. Alternatively or additionally, components of the design management system 1100 can be implemented within a suite of mobile applications or "apps". For illustration, components of the design management system 1100 can be implemented as part of an application or a suite of applications, including but not limited to Adobe Creative Cloud, Adobe Photoshop, Adobe Acrobat, Adobe Illustrator, Adobe Lightroom, and Adobe InDesign. “ADOBE”, “CREATIVE CLOUD”, “PHOTOSHOP”, “ACROBAT”, “ILLUSTRATOR”, “LIGHTROOM” and “INDESIGN” are registered trademarks or trademarks of Adobe Systems Incorporated in the U.S. and / or other countries.

[0066] Figures 1 to 11 The corresponding text and examples provide many different systems and devices that allow for intelligent change summaries. In addition to the foregoing, embodiments can also be described using flowcharts, which include actions and steps in methods for achieving specific results. For example, Figure 12 A flowchart illustrating an exemplary method according to one or more embodiments is shown. Figure 12The described method can be performed with fewer or more steps / actions, or the steps / actions can be performed in a different order. Additionally, the steps / actions described herein can be repeated or performed in parallel with each other, or in parallel with different instances of the same or similar steps / actions.

[0067] Figure 12 A flowchart illustrating a series of actions in a method for summarizing intelligent changes according to one or more embodiments is shown. In one or more embodiments, method 1200 is performed in a digital media environment including a design management system 100. Method 1200 is intended to illustrate one or more methods according to this disclosure and is not intended to limit potential embodiments. Figure 12 Compared to the steps illustrated in the figures, alternative embodiments may include additional, fewer, or different steps.

[0068] like Figure 12 As shown, method 1200 includes the action 1202 of obtaining a representation of multiple versions of a document. In some embodiments, the version history of the document is obtained (e.g., from a user, from a file system, from an application associated with the document, etc.). As discussed, the version history can be a data structure pointing to multiple versions of a particular document. In some embodiments, the representation of multiple versions of a document includes a tree structure comprising: a root representing the document; a first set of nodes from the root representing versions of the document; a second set of nodes from the first set representing canvases; and a third set of nodes from the second set representing elements of the canvases.

[0069] like Figure 12 As shown, method 1200 further includes an action 1204 of determining a distance score based on a comparison of a first version of the document and a second version of the document, the distance score representing the magnitude of the change made from the first version of the document to the second version of the document. In some embodiments, determining the distance score further includes: determining one or more differences between one or more attribute values ​​associated with one or more elements in the first version of the document and one or more attribute values ​​associated with one or more elements in the second version of the document, and combining the one or more differences to determine the distance score.

[0070] In some embodiments, the method further includes determining that a new canvas has been added to a second version of the document, determining the number of elements associated with the new canvas, and combining the number of elements with one or more differences to determine a distance score.

[0071] In some embodiments, combining differences to determine a distance score includes calculating the sum of one or more differences. In some embodiments, combining differences to determine a distance score includes calculating a weighted sum of one or more differences, wherein the one or more differences are weighted based on an edit type associated with the difference. In some embodiments, the edit type includes at least one of the following: text change, color change, or object change.

[0072] like Figure 12 As shown, method 1200 also includes an action 1206 of generating a change summary of the document based on a distance score. In some embodiments, generating a change summary includes: tagging one or more versions of the document in the change summary based on the type of edits associated with changes represented by distance scores between successive versions of the document.

[0073] In some embodiments, each version of a document includes multiple attributes that define the state of multiple corresponding elements of the document, wherein the multiple corresponding elements include one or more of shape, text, or group. In some embodiments, the multiple attributes include one or more of size, position, stroke, color, or text.

[0074] In some embodiments, identifying inflection points in the version history of a document based on multiple distance scores further includes determining a subset of multiple versions with the highest distance scores. In some embodiments, the size of the subset of multiple versions is determined based on the distribution of the multiple distance scores. In some embodiments, the method further includes classifying the subset of multiple versions into high importance, medium importance, and low importance.

[0075] In some embodiments, the method further includes: determining the edit type associated with changes made between successive versions of the document, determining multiple distance scores associated with each edit type, and identifying the inflection point of each edit type.

[0076] In some embodiments, the method further includes: iterating over a plurality of versions of the representation to determine a plurality of distance scores, each distance score being associated with changes between successive versions of the document; identifying at least one subset of the plurality of distance scores based on the values ​​of the plurality of distance scores; determining at least one subset of the plurality of versions corresponding to at least one subset of the distance scores; and classifying at least one subset of the plurality of versions as high importance, medium importance, or low importance.

[0077] Figure 13The illustration shows a schematic diagram of an exemplary environment 1300 in which a design management system 1100 may operate according to one or more embodiments. In one or more embodiments, environment 1300 includes a service provider 1302, which may include one or more servers 1304 connected to a plurality of client devices 1306A-1306N via one or more networks 1308. The client devices 1306A-1306N, one or more networks 1308, service provider 1302, and one or more servers 1304 may communicate with each other or with other components using any communication platform and technology suitable for transmitting data and / or communication signals, including any known communication technologies, devices, media, and protocols supporting remote data communication, examples of which will be described below. Figure 14 It is described in more detail.

[0078] although Figure 13 The illustration shows a specific arrangement of client devices 1306A-1306N, one or more networks 1308, a service provider 1302, and one or more servers 1304, but various additional arrangements are possible. For example, client devices 1306A-1306N may bypass network 1308 and communicate directly with one or more servers 1304. Alternatively, client devices 1306A-1306N may communicate directly with each other. Service provider 1302 may be a public cloud service provider that owns and operates its own infrastructure in one or more data centers and provides that infrastructure to customers and end users on demand to host applications on one or more servers 1304. Servers may include one or more hardware servers (e.g., hosts), each with its own computing resources (e.g., processors, memory, disk space, network bandwidth, etc.), which may be securely partitioned among multiple customers, each of whom may host its own applications on one or more servers 1304. In some embodiments, the service provider may be a private cloud provider that maintains cloud infrastructure for a single organization. One or more servers 1304 may similarly include one or more hardware servers, each with its own computing resources, which are partitioned among applications hosted by one or more servers for use by members of the organization or their customers.

[0079] Similarly, although Figure 13 Environment 1300 is described as having various components, but environment 1300 may have additional or alternative components. For example, environment 1300 may be implemented on a single computing device having design management system 1100. In particular, design management system 1100 may be implemented wholly or partially on client device 1306A.

[0080] like Figure 13 As shown, environment 1300 may include client devices 1306A-1306N. Client devices 1306A-1306N may include any computing device. For example, client devices 1306A-1306N may include one or more personal computers, laptops, mobile devices, mobile phones, tablets, dedicated computers, TVs, or other computing devices, including those described below. Figure 14 The computing device described. Although in Figure 13 Three client devices are shown, but it should be understood that client devices 1306A-1306N may include any number of client devices (greater or less than those shown).

[0081] In addition, such as Figure 13 As shown, client devices 1306A-1306N and one or more servers 1304 can communicate via one or more networks 1308. One or more networks 1308 can represent a single network or a collection of networks (such as the Internet, corporate intranet, Virtual Private Network (VPN), Local Area Network (LAN), Wireless Local Area Network (WLAN), Cellular Network, Wide Area Network (WAN), Metropolitan Area Network (MAN), or a combination of two or more such networks). Therefore, one or more networks 1308 can be any suitable network, and client devices 1306A-1306N can access service provider 1302 and server 1304 through one or more networks 1308, and vice versa. This will be discussed below regarding... Figure 14 Discuss one or more networks 1308 in detail.

[0082] In addition, environment 1300 may also include one or more servers 1304. One or more servers 1304 may generate, store, receive, and transmit data of any type, including design version history 1118, change summary 1120, or other information. For example, server 1304 may receive data from a client device such as client device 1306A and send data to another client device such as client device 1306B and / or 1306N. Server 1304 may also transmit electronic messages between one or more users of environment 1300. In one example embodiment, server 1304 is a data server. Server 1304 may also include a communication server or a web hosting server. Additional details about server 1304 will be provided below. Figure 14 Let's have a discussion.

[0083] As described, in one or more embodiments, one or more servers 1304 may include or implement at least a portion of the design management system 1100. Specifically, the design management system 1100 may include applications running on one or more servers 1304, or a portion of the design management system 1100 may be downloaded from one or more servers 1304. For example, the design management system 1100 may include a web-hosted application that allows client devices 1306A-1306N to interact with content hosted on one or more servers 1304. For illustration, in one or more embodiments of environment 1300, one or more client devices 1306A-1306N may access web pages supported by one or more servers 1304. Specifically, client device 1306A may run a web application (e.g., a web browser) to allow users to access, view, and / or interact with web pages or websites hosted on one or more servers 1304.

[0084] When client device 1306A accesses a webpage or other web application hosted on one or more servers 1304, in one or more embodiments, the one or more servers 1304 may provide access to a design version history (e.g., design version history 1118) stored on the one or more servers 1304. Furthermore, client device 1306A may receive (i.e., via user input) a request for a summary of changes to documents associated with the design version history and provide the request to the one or more servers 1304. Upon receiving the request, the one or more servers 1304 may automatically execute the methods and processes described above to generate a summary of changes to the design version history. The one or more servers 1304 may provide the summary of changes to client device 1306A for display to the user / user interaction.

[0085] As just described, the design management system 1100 can be implemented wholly or partially by individual elements 1302-1308 of the environment 1300. It should be understood that although certain components of the design management system 1100 have been described with respect to specific elements of the environment 1300 in the previous examples, various alternative implementations are possible. For example, in one or more embodiments, the design management system 1100 is implemented on any of the client devices 1306A-1306N. Similarly, in one or more embodiments, the design management system 1100 can be implemented on one or more servers 1304. Furthermore, different components and functions of the design management system 1100 can be implemented separately among the client devices 1306A-1306N, one or more servers 1304, and the network 1308.

[0086] Embodiments of this disclosure may include or utilize a dedicated or general-purpose computer, including computer hardware such as, for example, one or more processors and system memory, as discussed in more detail below. Embodiments within the scope of this disclosure also include physical and other computer-readable media for carrying or storing computer-executable instructions and / or data structures. In particular, one or more processes described herein may be implemented at least in part as instructions embodied in a non-transitory computer-readable medium and executable by one or more computing devices (e.g., any media content access device described herein). Typically, a processor (e.g., a microprocessor) receives instructions from a non-transitory computer-readable medium (e.g., memory, etc.) and executes those instructions to perform one or more processes, including one or more processes described herein.

[0087] Computer-readable media can be any available medium that can be accessed by a general-purpose or special-purpose computer system. A computer-readable medium storing computer-executable instructions is a non-transitory computer-readable storage medium (device). A computer-readable medium carrying computer-executable instructions is a transmission medium. Therefore, by way of example and not limitation, embodiments of this disclosure may include at least two distinctly different kinds of computer-readable media: non-transitory computer-readable storage media (devices) and transmission media.

[0088] Non-transitory computer-readable storage media (devices) include RAM, ROM, EEPROM, CD-ROM, solid-state drive (“SSD”) (e.g., RAM-based), flash memory, phase-change memory (“PCM”), other types of memory, other optical disk storage, magnetic disk storage or other magnetic storage, or any other medium that can be used to store desired program code components in the form of computer-executable instructions or data structures and that can be accessed by a general-purpose or special-purpose computer.

[0089] A “network” is defined as one or more data links that enable the transmission of electronic data between computer systems and / or modules and / or other electronic devices. When information is transmitted or provided to a computer via a network or other communication connection (hardwired, wireless, or a combination of hardwired and wireless), the computer correctly recognizes that connection as a transmission medium. The transmission medium may include networks and / or data links that can be used to carry desired program code components in the form of computer-executable instructions or data structures, and which can be accessed by general-purpose or special-purpose computers. Combinations of the above should also be included within the scope of computer-readable media.

[0090] Furthermore, upon arrival at various computer system components, program code components in the form of computer-executable instructions or data structures can be automatically transferred from the transmission medium to a non-transitory computer-readable storage medium (device) (or vice versa). For example, computer-executable instructions or data structures received via a network or data link can be buffered in RAM within a network interface module (e.g., a "NIC") and then ultimately transferred to the computer system RAM and / or a less volatile computer storage medium (device) at the computer system. Therefore, it should be understood that a non-transitory computer-readable storage medium (device) can be included in computer system components that also (or even primarily) utilize the transmission medium.

[0091] Computer-executable instructions include, for example, instructions and data that, when executed at a processor, cause a general-purpose computer, a special-purpose computer, or a special-purpose processing device to perform certain functions or groups of functions. In some embodiments, the computer-executable instructions are executed on a general-purpose computer to transform the general-purpose computer into a special-purpose computer that implements the elements of this disclosure. The computer-executable instructions may be, for example, binary, intermediate format instructions (such as assembly language), or even source code. Although the subject matter has been described in language specific to structural features and / or methodological actions, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the features or actions described above. Rather, the described features and actions are disclosed as exemplary forms for implementing the claims.

[0092] Those skilled in the art will understand that this disclosure can be practiced in network computing environments with many types of computer system configurations, including personal computers, desktop computers, laptop computers, message processors, handheld devices, multiprocessor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, mobile phones, PDAs, tablet computers, pagers, routers, switches, etc. This disclosure can also be practiced in distributed system environments, where local and remote computer systems perform tasks via network links (via hardwired data links, wireless data links, or a combination of hardwired and wireless data links). In a distributed system environment, program modules can reside on both local and remote storage devices.

[0093] The embodiments of this disclosure can also be implemented in a cloud computing environment. In this description, "cloud computing" is defined as a model for enabling on-demand network access to a shared pool of configurable computing resources. For example, cloud computing can be adopted in the market to provide ubiquitous and convenient on-demand access to a shared pool of configurable computing resources. The shared pool of configurable computing resources can be rapidly provisioned via virtualization and released with less management effort or service provider interaction, and then scaled accordingly.

[0094] Cloud computing models can include various characteristics, such as on-demand self-service, broad network access, resource pooling, rapid elasticity, and measured service. Cloud computing models can also expose various service models, such as Software as a Service (“SaaS”), Platform as a Service (“PaaS”), and Infrastructure as a Service (“IaaS”). Different deployment models (such as private cloud, community cloud, public cloud, hybrid cloud, etc.) can also be used to deploy cloud computing models. In this description and claims, a “cloud computing environment” is an environment in which cloud computing is employed.

[0095] Figure 14 An exemplary computing device 1400 is illustrated in block diagram form. The computing device 1400 can be configured to perform one or more of the processes described above. It should be understood that one or more computing devices, such as computing device 1400, can implement an image processing system. (As illustrated by...) Figure 14 As shown, the computing device may include a processor 1402, a memory 1404, one or more communication interfaces 1406, a storage device 1408, and one or more "I / O" devices / interfaces 1410. In some embodiments, the computing device 1400 may include a processor 1402, a memory 1404, one or more communication interfaces 1406, a storage device 1408, and one or more "I / O" devices / interfaces 1410. Figure 14 The components shown are fewer or more components. They will now be described in additional detail. Figure 14 The components of the computing device 1400 shown.

[0096] In a particular embodiment, processor(s) 1402 includes hardware for executing instructions, such as those constituting a computer program. By way of example and not limitation, in order to execute instructions, processor(s) 1402 may retrieve (or fetch) instructions from internal registers, internal cache, memory 1404, or storage device 1408, and decode and execute them. In various embodiments, processor(s) 1402 may include one or more central processing units (CPUs), graphics processing units (GPUs), field-programmable gate arrays (FPGAs), system-on-a-chip (SoCs), or other processors or combinations of processors.

[0097] Computing device 1400 includes memory 1404 coupled to processor(s) 1402. Memory 1404 can be used to store data, metadata, and programs for execution by processor(s). Memory 1404 may include one or more of volatile and non-volatile memory, such as random access memory (“RAM”), read-only memory (“ROM”), solid-state drive (“SSD”), flash memory, phase-change memory (“PCM”), or other types of data storage. Memory 1404 may be internal or distributed memory.

[0098] The computing device 1400 may also include one or more communication interfaces 1406. The communication interface 1406 may include hardware, software, or both. The communication interface 1406 may provide one or more interfaces for communication (such as, for example, packet-based communication) between the computing device and one or more other computing devices 1400 or one or more networks. By way of example and not limitation, the communication interface 1406 may include a network interface controller (NIC) or network adapter for communication with Ethernet or other wired-based networks, or may include a wireless NIC (WNIC) or wireless adapter for communication with wireless networks (such as Wi-Fi). The computing device 1400 may also include a bus 1412. The bus 1412 may include hardware, software, or both for coupling components of the computing device 1400 to each other.

[0099] Computing device 1400 includes storage device 1408, which includes storage for storing data or instructions. By way of example and not limitation, storage device 1408 may include the aforementioned non-transitory storage media. Storage device 1408 may include hard disk drive (HDD), flash memory, universal serial bus (USB) drive, or combinations of these or other storage devices. Computing device 1400 also includes one or more input or output (“I / O”) devices / interfaces 1410, which are provided to allow a user to provide input to computing device 1400 (such as drawing lines), receive output from computing device 1400, and otherwise transfer data to and from computing device 1400. These I / O devices / interfaces 1410 may include a mouse, keypad or keyboard, touchscreen, camera, optical scanner, network interface, modem, other known I / O devices, or combinations of such I / O devices / interfaces 1410. Touchscreens may be activated using a stylus or finger.

[0100] I / O device / interface 1410 may include one or more devices for presenting output to a user, including but not limited to a graphics engine, a display (e.g., a screen), one or more output drivers (e.g., display drivers), one or more audio speakers, and one or more audio drivers. In some embodiments, I / O device / interface 1410 is configured to provide graphics data to a display for presentation to a user. The graphics data may represent one or more graphical user interfaces and / or any other graphical content that may serve a particular implementation.

[0101] In the foregoing specification, embodiments have been described with reference to specific exemplary embodiments of the invention. Various embodiments have been described with reference to the details discussed herein, and various embodiments are illustrated in the accompanying drawings. The above description and drawings are illustrative of one or more embodiments and should not be construed as limiting. Numerous specific details have been described to provide a thorough understanding of various embodiments.

[0102] Embodiments may include other specific forms without departing from the spirit or essential characteristics of the invention. The described embodiments should be considered illustrative rather than restrictive in all respects. For example, the methods described herein may be performed using fewer or more steps / actions, or the steps / actions may be performed in a different order. Additionally, the steps / actions described herein may be repeated or performed in parallel with each other or with different instances of the same or similar steps / actions. Therefore, the scope of the invention is indicated by the appended claims rather than the foregoing description. All modifications falling within the meaning and scope of equivalents of the claims should be included within their scope.

[0103] In the various embodiments described above, unless otherwise specifically indicated, disjunctive language such as the phrase “at least one of A, B, or C” is intended to be understood as referring to A, B, or C, or any combination thereof (e.g., A, B, and / or C). Therefore, disjunctive language is not intended and should not be construed as implying that a given embodiment requires the presence of at least one A, at least one B, or at least one C.

Claims

1. A computer-implemented method, comprising: Obtain a representation of multiple versions of a document, wherein the representation of the multiple versions of the document includes a tree structure, the tree structure including: a root representing the document; a first set of nodes from the root representing versions of the document; a second set of nodes from the first set representing a canvas; and a third set of nodes from the second set representing elements of the canvas. The representations of the plurality of versions are converted into a JavaScript object representation JSON file, the JSON file including a plurality of key-value pairs, the plurality of key-value pairs representing one or more attribute values ​​associated with one or more elements in each of the plurality of versions; Identify the key among the plurality of key-value pairs that is associated with a changed attribute value, wherein the changed attribute value is at least one of a size attribute, a position attribute, a stroke attribute, or a color attribute associated with a shape change between successive versions of the document; Map the keys to edit types; A distance score is determined using a distance function based on a first version and a second version of the document. The first version of the document includes one or more attribute values ​​associated with a first shape, the one or more attribute values ​​including values ​​of at least one of a first size attribute, a first position attribute, a first stroke attribute, or a first color attribute. The first shape is an element of one or more elements in the first version of the document. The second version of the document includes one or more attribute values ​​associated with a second shape, the one or more attribute values ​​including values ​​of at least one of a second size attribute, a second position attribute, a second stroke attribute, or a second color attribute. The second shape is an element of one or more elements in the second version of the document. The distance score represents the difference between the one or more attribute values ​​associated with the first shape in the first version of the document and the one or more attribute values ​​associated with the second shape in the second version of the document. Based on the distance score and the edit type, a summary of changes to the document is generated.

2. The computer-implemented method of claim 1, wherein the distance score is determined based on a comparison between a first version of the document and a second version of the document, the distance score representing the magnitude of the change made from the first version of the document to the second version of the document, further comprising: Determine one or more differences between the one or more attribute values ​​associated with the one or more elements in the first version of the document and the one or more attribute values ​​associated with the one or more elements in the second version of the document; as well as The one or more differences are combined to determine the distance score.

3. The computer-implemented method of claim 2, wherein combining the one or more differences to determine the distance score further comprises: Calculate the sum of the one or more differences.

4. The computer-implemented method of claim 2, wherein combining the one or more differences to determine the distance score further comprises: Calculate a weighted sum of the one or more differences, wherein the one or more differences are weighted based on the edit type associated with the differences.

5. The computer-implemented method according to claim 4, wherein the editing type includes at least one of the following: text change, color change, or object change.

6. The computer-implemented method of claim 1, wherein generating the change summary of the document based on the distance score further comprises: One or more versions of the document are tagged in the change summary based on the edit type associated with changes made between successive versions of the document, as represented by the distance score.

7. The computer-implemented method according to claim 2, further comprising: Confirm that a new canvas has been added to the second version of the document; Determine the number of elements associated with the new canvas; as well as The number of elements is combined with the one or more differences to determine the distance score.

8. The computer-implemented method according to claim 1, further comprising: The representation is iterated over multiple versions to determine multiple distance scores, each distance score being associated with a change between successive versions of the document; Based on the values ​​of the plurality of distance scores, identify at least one subset of the plurality of distance scores; Determine at least one subset of the plurality of versions corresponding to at least one subset of the distance scores; as well as The at least one subset of the multiple versions is classified as high importance, medium importance, or low importance.

9. A non-transitory computer-readable storage medium comprising instructions stored thereon, the instructions, when executed by a processor, causing the processor to: Obtaining representations of multiple versions of a document, wherein the representations of the multiple versions of the document include a tree structure, the tree structure comprising: The root of the document; the first set of nodes from the root, representing versions of the document; The second set of nodes representing the canvas, derived from the first set of nodes; And a third set of nodes from the second set of nodes, representing elements of the canvas; The representations of the plurality of versions are converted into a JavaScript object representation JSON file, the JSON file including a plurality of key-value pairs, the plurality of key-value pairs representing one or more attribute values ​​associated with one or more elements in each of the plurality of versions; Identify the key among the plurality of key-value pairs that is associated with a changed attribute value, wherein the changed attribute value is at least one of a size attribute, a position attribute, a stroke attribute, or a color attribute associated with a shape change between successive versions of the document; Map the keys to edit types; A distance score is determined using a distance function based on a first version and a second version of the document. The first version of the document includes one or more attribute values ​​associated with a first shape, the one or more attribute values ​​including values ​​of at least one of a first size attribute, a first position attribute, a first stroke attribute, or a first color attribute. The first shape is an element of one or more elements in the first version of the document. The second version of the document includes one or more attribute values ​​associated with a second shape, the one or more attribute values ​​including values ​​of at least one of a second size attribute, a second position attribute, a second stroke attribute, or a second color attribute. The second shape is an element of one or more elements in the second version of the document. The distance score represents the difference between the one or more attribute values ​​associated with the first shape in the first version of the document and the one or more attribute values ​​associated with the second shape in the second version of the document. Based on the distance score and the edit type, a summary of changes to the document is generated.

10. The non-transitory computer-readable storage medium of claim 9, wherein, in order to determine the distance score, the processor further comprises: Determine one or more differences between the one or more attribute values ​​associated with the one or more elements in the first version of the document and the one or more attribute values ​​associated with the one or more elements in the second version of the document; and The one or more differences are combined to determine the distance score.

11. The non-transitory computer-readable storage medium of claim 10, wherein, in order to combine the one or more differences to determine the distance score, the instructions, when executed, further cause the processor to: Calculate the sum of the one or more differences.

12. The non-transitory computer-readable storage medium of claim 10, wherein, in order to combine the one or more differences to determine the distance score, the instructions, when executed, further cause the processor to: Calculate a weighted sum of the one or more differences, wherein the one or more differences are weighted based on the edit type associated with the differences.

13. The non-transitory computer-readable storage medium of claim 12, wherein the editing type includes at least one of the following: text change, color change, or object change.

14. The non-transitory computer-readable storage medium according to claim 12, wherein, In order to generate the change summary of the document based on the distance score, the instruction, when executed, also causes the processor to: One or more versions of the document are tagged in the change summary based on the edit type associated with changes made between successive versions of the document, as represented by the distance score.

15. The non-transitory computer-readable storage medium of claim 10, wherein the instructions, when executed, further cause the processor to: Confirm that a new canvas has been added to the second version of the document; Determine the number of elements associated with the new canvas; and The number of elements is combined with the one or more differences to determine the distance score.

16. The non-transitory computer-readable storage medium of claim 9, wherein the instructions, when executed, further cause the processor to: The representation is iterated over multiple versions to determine multiple distance scores, each distance score being associated with a change between successive versions of the document; Based on the values ​​of the plurality of distance scores, identify at least one subset of the plurality of distance scores; Determine at least one subset of the plurality of versions corresponding to at least one subset of the distance scores; as well as The at least one subset of the multiple versions is classified as high importance, medium importance, or low importance.

17. A system for modifying the generation of summaries, comprising: processor; as well as The memory includes instructions that, when executed by the processor, cause the system to: Obtain a representation of multiple versions of a document, wherein the representation of the multiple versions of the document includes a tree structure, the tree structure including: a root representing the document; a first set of nodes from the root representing versions of the document; a second set of nodes from the first set representing a canvas; and a third set of nodes from the second set representing elements of the canvas. The representations of the plurality of versions are converted into a JavaScript object representation JSON file, the JSON file including a plurality of key-value pairs, the plurality of key-value pairs representing one or more attribute values ​​associated with one or more elements in each of the plurality of versions; Identify the key among the plurality of key-value pairs that is associated with a changed attribute value, wherein the changed attribute value is at least one of a size attribute, a position attribute, a stroke attribute, or a color attribute associated with a shape change between successive versions of the document; Map the keys to edit types; A distance score is determined using a distance function based on a first version and a second version of the document. The first version of the document includes one or more attribute values ​​associated with a first shape, the one or more attribute values ​​including values ​​of at least one of a first size attribute, a first position attribute, a first stroke attribute, or a first color attribute. The first shape is an element of one or more elements in the first version of the document. The second version of the document includes one or more attribute values ​​associated with a second shape, the one or more attribute values ​​including values ​​of at least one of a second size attribute, a second position attribute, a second stroke attribute, or a second color attribute. The second shape is an element of one or more elements in the second version of the document. The distance score represents the difference between the one or more attribute values ​​associated with the first shape in the first version of the document and the one or more attribute values ​​associated with the second shape in the second version of the document. Based on the distance score and the edit type, a summary of changes to the document is generated.

18. The system of claim 17, wherein the instructions, when executed, further cause the system to: The representation is iterated over multiple versions to determine multiple distance scores, each distance score being associated with a change between successive versions of the document; Based on the values ​​of the plurality of distance scores, identify at least one subset of the plurality of distance scores; Determine at least one subset of the plurality of versions corresponding to at least one subset of the distance scores; as well as The at least one subset of the multiple versions is classified as high importance, medium importance, or low importance.

Images