System and method for dynamic checksum generation and validation with customizable levels of integrity verification - Patents.com

Dynamic checksum generation systems efficiently verify the integrity of large files and point clouds by selectively focusing on important data subsets, using AI/ML to exclude unimportant data, thus reducing processing time and maintaining data integrity.

JP2024544944AInactive Publication Date: 2024-12-05ILLUSCIO INC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
JP2024527643
Authority / Receiving Office
JP · JP
Patent Type
Applications
Current Assignee / Owner
Priority Date
2021-11-12
Filing Date
2022-11-04
Publication Date
2024-12-05
Estimated Expiration
Not applicable · inactive patent

AI Technical Summary

Technical Problem

Generating and verifying checksums for large files or files with varying data importance becomes computationally expensive and burdensome, leading to delays in user experience.

Method used

Dynamic checksum generation and verification systems that selectively focus on important data subsets, using AI/ML to identify and exclude unimportant data, thereby reducing computational load and ensuring efficient integrity verification.

Benefits of technology

Faster and more efficient integrity verification of large files and point clouds by focusing on critical data, reducing processing time and maintaining data integrity without unnecessary computational overhead.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 2024544944000001_ABST
    Figure 2024544944000001_ABST
Patent Text Reader

Abstract

A checksum generation and validation system with customizable levels of integrity validation and an associated method for dynamically generating and validating checksums is disclosed. The system receives a file having data points defined with location and non-location values ​​and distinguishes a first set of data points from a second set of data points. The system generates a checksum based on a combination of two or more values ​​from the location and non-location values ​​of each data point from the first set of data points and further based on the exclusion of the location and non-location values ​​of the second set of data points from the checksum. The system may use the checksum to validate the integrity of the data associated with the first set of data points.
Need to check novelty before this filing date? Find Prior Art

Description

[Background technology]

[0001] Checksums may be used to verify data integrity and / or determine whether the contents of a file have been altered. Common checksum generation algorithms include the Message Digest Algorithm ("MD5"), the Secure Hash Algorithm ("SHA") family, and the Cyclic Redundancy Check ("CRC") algorithm.

[0002] A checksum may be generated by performing a hash or other calculation over all of the data in a file. A checksum is a fixed-size value that can be used to verify whether any portion of the data has been altered.

[0003] As file sizes increase, generating a checksum from calculations involving the entire file data can become computationally expensive, and validating such checksums may impose too great a delay in the user experience.

[0004] Therefore, an update to the general-purpose approach for checksum generation and validation is required. [Brief description of the drawings]

[0005] [Figure 1] 1 illustrates an example of dynamic generation and validation of checksums based on a user-defined level of integrity verification, according to some embodiments presented herein.

[0006] [Diagram 2] FIG. 1 illustrates an example of dynamic checksum generation and validation based on a custom level of integrity verification specified for a file and a set of data automatically selected from the file as a result of the specified custom level of integrity verification, according to some embodiments presented herein.

[0007] [Diagram 3] 1 illustrates an example of dynamic checksum generation and validation to verify the structure and amount of data in a file without including all the data in the checksum calculation or validation, according to some embodiments presented herein.

[0008] [Figure 4] 1 illustrates an example of dynamic checksum generation and verification to verify the integrity of all point cloud data based on checksum calculation involving less than all of the point cloud data, according to some embodiments presented herein.

[0009] [Diagram 5] 1 illustrates an example of generating a unique checksum based on a hash of a first set of values ​​from the point cloud data points sorted according to a second set of values ​​from the point cloud data points according to some embodiments presented herein.

[0010] [Figure 6] FIG. 1 illustrates another example of generating a unique checksum to verify the integrity of all the data in a file using less than all the data from the file, according to some embodiments presented herein.

[0011] [Figure 7] According to some embodiments presented herein, a process is presented for dynamically generating a checksum based on an automatically identified subset of data in a point cloud or file.

[0012] [Figure 8] 1 illustrates an example of automatic file data separation according to certain embodiments presented herein.

[0013] [Figure 9]According to some embodiments presented herein, a process is presented for dynamic checksum generation based on a hybrid selection of critical and non-critical data sampling from a file.

[0014] [Figure 10] 1 presents a process for dynamic checksum verification according to some embodiments presented herein.

[0015] [Figure 11] 1 illustrates one or more integrations of a checksum generation and verification system as part of a device, according to some embodiments presented herein.

[0016] [Figure 12] 1 illustrates example components of one or more devices according to one or more embodiments described herein. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0017] In the following detailed description, reference will be made to the accompanying drawings, in which the same reference numbers in different drawings may identify the same or similar elements.

[0018] Systems and methods are provided for dynamic generation and validation of checksums with customizable levels of integrity validation. Dynamic checksum generation and validation with customizable levels of integrity validation may provide efficient data integrity validation for files of different sizes, files with different amounts of data, and / or files that include data with different levels of importance. The systems and methods may comprise dynamically generating and / or validating checksums based on designated important or critical data from a file, omitting other data from the same file from the checksum calculation and / or validation.

[0019] In some embodiments, artificial intelligence and / or machine learning ("AI / ML") may be used to automatically distinguish and / or classify data from different files and to dynamically generate different checksums based on different subsets of the distinguished and / or classified data from the different files. In some such embodiments, AI / ML may be trained to identify important data and file types within different files and to efficiently calculate checksums to maintain the integrity of important data while omitting non-critical data from checksum calculation and / or verification. Thus, checksums may be customized based on the contents and / or data of each file such that a checksum can be generated and / or verified in less time for that file than if all data from that file were included in the checksum, and such that the checksum cannot be regenerated for an altered data set without knowledge of the subset of data used for the checksum calculation.

[0020] In some embodiments, the above dynamic generation and verification of checksums may be used to efficiently verify the integrity of large files and / or files containing data with various levels of importance. An example of such a file may be represented by a point cloud.

[0021] A point cloud may include data points (e.g., thousands, millions, billions, etc.) in three-dimensional space ("3D") that correspond to imaged points of a 3D object or environment. Point clouds and individual data points may be generated by 3D or depth-sensing cameras, light detection and ranging ("LiDAR") sensors, magnetic resonance imaging ("MRI") devices, positron emission tomography ("PET") scanning devices, computed tomography ("CT") scanning devices, time-of-flight devices, and / or other imaging equipment for 3D objects, volumetric objects, or 3D environments. A point cloud may be generated from the output of two or more devices. For example, a first imaging device (e.g., a LiDAR sensor) may determine a position for each data point in 3D space, and a second imaging device (e.g., a high-resolution camera) may measure or capture visual characteristics or other non-positional information for each data point.

[0022] In some embodiments, the point cloud and the individual data points of the point cloud may be computer-generated and may correspond to a digitally created 3D object or environment, hi some embodiments, the point cloud may include a combination of imaged real-world objects or environments and digitally created objects or environments.

[0023] Point cloud data points may differ from pixels of a two-dimensional ("2D") image, since certain regions of a point cloud may have no data points, a lower density of data points, and / or a higher density of data points based on the varying amount of information detected in those regions when imaging a 3D object, volumetric object, or 3D environment. For example, a point cloud imaging device may capture an object closer to the point cloud imaging device with more data points (e.g., higher resolution) than if the same object were located further away from the point cloud imaging device, since a greater number of emission beams (e.g., light, laser, etc.) from the device may contact closer objects than more distant objects, and measurements from each beam result in different data points in the point cloud. In contrast, pixels of a 2D image have a uniform density and fixed arrangement defined by the resolution of the 2D image. Also, point cloud data points may have a non-uniform distribution, arrangement, or positioning, while a 2D image has pixel data for each pixel of a defined resolution (e.g., 640x480, 800x600, etc.).

[0024] Each point cloud data point may include a position and a non-position value. The position value may include coordinates in 3D space. For example, each point cloud data point may include x-, y-, and z-coordinate data point values ​​for each imaged point, feature, element, object of the 3D environment. The non-position values ​​may include values ​​for descriptive properties of the data point. The descriptive properties may include visual properties of the imaged point, feature, element, or object. The visual properties may correspond to a detected color. The color may be represented using red, green, and blue ("RGB") values. In some embodiments, the descriptive properties may include chromaticity and / or brightness of the imaged point, feature, element, or object. In some other embodiments, the descriptive properties may include attributes of the imaging device used to capture the 3D environment. For example, the descriptive properties may include a Tesla intensity value to quantify the strength of the magnetic field used to detect and / or image a particular point of the 3D environment. In some embodiments, the descriptive properties may include energy, audible sound or voice, and / or other properties of the imaging device or the object being imaged. Thus, non-positional values ​​may include any characteristic or descriptive property of the imaged object portion (e.g., hue, saturation, brightness, reflectance, etc.) or any characteristic or descriptive property of the imaging device used to capture the object portion at the corresponding data point in 3D space.

[0025] The position and non-position values ​​for each particular data point may be stored in an array and associated with that particular data point using one or more of some identifier or data value. For example, a point cloud data point may be accessed via a lookup of x, y, and z coordinate values, such that the data point may be identified by its x, y, and z coordinate values, as well as non-positional information such as red, green, blue, chromaticity, brightness, Tesla, and / or other values.

[0026] Generating and / or verifying a checksum with each value (e.g., location and non-location values) of millions or billions of data points from a point cloud may take several seconds to complete and may disrupt the user experience by adding delays to other resource- and / or time-consuming tasks associated with using the point cloud, including loading, rendering, editing, and / or processing the point cloud data points. Also, some of the data points may correspond to background and / or irrelevant features of the 3D environment represented by the point cloud. The inclusion of these data points and whether they remain unchanged or are changed may not adversely affect the key or important data points or portions of the point cloud. Thus, generating a checksum that includes all values ​​from all point cloud data points may simply increase the time and cost associated with verifying point cloud integrity without providing any additional benefit in maintaining and / or verifying the integrity of the key or important data points or portions of the point cloud.

[0027] In some embodiments, dynamic checksum generation and validation may be used instead of a generic approach where all data from a file is used for checksum generation and / or validation. Dynamic checksum generation and validation of some embodiments may include generating a checksum based on a subset of point cloud data points and / or a subset of values ​​from all or the subset of point cloud data points based on a custom level of integrity validation specified for the point cloud or file. In doing so, dynamic checksum generation and validation may focus integrity validation on key or important data points or portions of the point cloud, thereby providing a faster and more efficient methodology for validating the integrity of point clouds, large files, and / or files that include data with various levels of importance. Dynamic checksum generation and validation may support a variety of manual and automated techniques for customizing the level of integrity validation and / or focusing integrity validation on different subsets of file data.

[0028] 1 illustrates an example of dynamic generation and validation of checksums based on a user-defined level of integrity validation, according to some embodiments presented herein. A checksum generation and validation system ("CGVS") 100 may receive (at 102) a large file that stores 3D images, objects, and / or environments as a point cloud. The CGVS 100 may render the point cloud (e.g., render the point cloud data points) and present (at 104) a 3D image, animation, and / or visualization of the environment on a display or interface.

[0029] A user may interact with the visualization and / or interface via keyboard, mouse, touch, and / or other input and may select a volume or region within the visualization and / or interface (at 106). The user selection may identify a set of point cloud data points that are critical and / or selected for data integrity validation. In particular, the user selection may encompass a region of 3D space within a 3D image rendered from the point cloud that includes the set of point cloud data points.

[0030] Rendering the point cloud on a display or interface may allow a user to visually identify important portions of the point cloud and / or to visually identify important file data. For example, a point cloud may include a high-resolution scan of a particular component within an overall assembly. The scan may also capture portions of other nearby components in the assembly, background features, open space, and / or other features not related to the particular component. User selection may include a boundary drawn around a particular component that excludes many of the nearby components, background, open space, and / or other features not related to the particular component. User selection may be made via a freeform drawing tool or by inserting and resizing various volumes or shapes into the visualization.

[0031] The CGVS 100 may determine a set of point cloud data points within the user selection. In some embodiments, the CGVS 100 may calculate coordinates for the volume or region selected by the user. Calculating the coordinates may include mapping the user-defined region to spatial coordinates in the 3D space represented by the presented visualization. The CGVS 100 may determine a set of data points having position values ​​that fall within the coordinates of the selected volume or region.

[0032] The CGVS 100 may tag (at 108) a set of data points for inclusion or exclusion from dynamic checksum calculation and / or verification. Tagging (at 108) a set of data points may include adding a non-position value indicating whether the data point is included as part of the checksum calculation. For example, a value of 0 for a checksum indicator in a non-position value of a data point may exclude the data point from the checksum calculation, while a value of 1 may include the data point in the checksum calculation. In some embodiments, the CGVS 100 may use one or more encoded values ​​to tag (at 108) a data point for inclusion or exclusion from the checksum calculation. For example, an even value for a checksum indicator in a non-position value of a data point may exclude the data point from the checksum calculation, while an odd value may include the data point in the checksum calculation. The provided tag identifies a set of data for checksum calculation and also a set of data for performing a subsequent verification of the checksum calculated for the received file.

[0033] The CGVS 100 may calculate (at 110) a checksum based on one or more of the position and / or non-position values ​​of the set of data points selected (at 106) and / or tagged (at 108) for inclusion as part of the checksum calculation. Thus, the CGVS 100 may dynamically calculate (at 110) a checksum with a customized level of integrity validation based on user-identified identified data points of the point cloud. Calculating (at 110) the checksum may include performing a hash on data from each data point of the set of data points, where the data may include various position and non-position values ​​associated with each data point of the set of data points. A Message Digest Algorithm ("MD5"), a Secure Hash Algorithm ("SHA"), a Cyclic Redundancy Check ("CRC") algorithm, and / or other algorithms may be used to calculate the hash and / or generate the checksum based on data from the selected set of data points.

[0034] The checksums may be included with the point cloud and may be used later to verify whether any data of the set of data points in the point cloud has been altered. For example, the point cloud with the generated point cloud may be provided to a different device over a data network. The device may run an instance of CGVS100 that extracts the checksums associated with the point cloud, calculates the checksums based on data of the set of data points from the point cloud that have been tagged for inclusion as part of the checksum calculation, and compares the extracted checksum to the calculated checksum. Any difference between the compared checksums may indicate that one or more data points in the tagged set of data points (e.g., identified critical data for the point cloud) have been altered, or one or more values ​​or data from one or more of the tagged sets of data points have been altered. More generally, any detected alterations may indicate that the data of the point cloud has been corrupted, altered without authorization, and / or altered such that the accuracy and / or completeness of the data can no longer be trusted or verified.

[0035] In some embodiments, dynamic checksum generation and validation of checksums may support automated techniques for customizing the level of integrity validation. In some such embodiments, the level of integrity validation may be defined based on an algorithmically selected set of data from the file (e.g., a set of data points from the point cloud). For example, the CGVS 100 may select a level of integrity validation for the data of the file from different defined levels of integrity validation and programmatically select a different set of data from the file to include as part of the checksum generation and validation based on the selected level of integrity validation. Each level of integrity validation may include sampling a different set of data from the file or a different set of data points from the point cloud for the resulting checksum, where the sampling includes less than all of the data or data points of the file or point cloud.

[0036] 2 illustrates an example of dynamic checksum generation and validation based on a custom level of integrity verification specified for a file and a set of data automatically selected from the file as a result of the specified custom level of integrity verification, according to some embodiments presented herein. As shown in FIG. 2, CGVS 100 may receive a file (at 202) and may determine a level of integrity verification for the data of the file based on one or more attributes associated with the file and / or a user selection of a desired level of integrity verification (at 204).

[0037] In some embodiments, CGVS 100 may be configured to provide different levels of integrity verification for files having different file extensions or different file types. A higher, first level of integrity verification may include selecting more or different data from the file to include in the checksum calculation and / or verification than a lower, second level of integrity verification. For example, CGVS 100 may be configured to provide a higher, first level of integrity verification for documents, images, and / or point clouds than for video and / or audio files, where changes to the video and / or audio files may have less impact on the overall file and / or presentation of the file than changes to the documents, images, and / or point clouds. As another example, CGVS 100 may inspect file metadata to determine where the file originated from, and may be configured to provide a higher level of integrity verification for files originating from a first set of sources (e.g., legal and engineering) than for files originating from a second set of sources (e.g., quality assurance and marketing).

[0038] Each level of integrity verification may be associated with a different data selection algorithm, methodology, or technique for ensuring the integrity or sampling of a different amount of data from the file. As shown in FIG. 2, the CGVS 100 may determine (at 204) a particular level of integrity verification for the received point cloud file that is associated with selecting (at 206) data points in various planes defined from a center point of the point cloud. Specifically, the CGVS 100 may identify a center point in the 3D space represented by the point cloud and select (at 206) data points that are a first value away from the x coordinate of the center point, a second value away from the y coordinate of the center point, and a third value away from the z coordinate of the center point. Increasing the level of integrity verification may include increasing one or more of the first value, the second value, and the third value to increase the number of data points selected for checksum calculation. Reducing the level of integrity verification may include decreasing one or more of the first value, the second value, and the third value to decrease the number of data points selected for checksum calculation.

[0039] In some embodiments, the CGVS 100 may tag (at 208) each data point of the automatically selected set of data points for inclusion as part of the checksum calculation. Tagging (at 208) the set of data points may include modifying a non-position value used to identify whether a data point is included in the checksum calculation.

[0040] The CGVS 100 may calculate (at 210) a checksum based on one or more of the position and / or non-position values ​​of the automatically selected (at 206) and / or tagged (at 208) set of data points. The checksum may be included and / or embedded with the point cloud and may be used later to verify whether any data of the set of data points in the point cloud has been altered.

[0041] In some embodiments, CGVS 100 may omit the tagging (at 208) operation and may dynamically select a set of data from a file during checksum generation and / or verification based on a set of data that CGVS 100 automatically selected from the file as a result of a custom level of integrity verification that CGVS 100 determined for the file using file attributes. In some such embodiments, CGVS 100 may calculate the checksum (at 210) by defining a plane and / or volume from a center point of the point cloud for a particular level of integrity verification, filter and / or select a set of data points that fall within the defined plane and / or volume, and generate a checksum based on data and / or values ​​from the set of data points.

[0042] CGVS100 may include a particular level of integrity verification (e.g., a custom level of integrity verification determined for a file) as a value in the calculated checksum. For example, a two-digit or letter code representing a particular level of integrity verification may be embedded in the checksum. The code may be extracted from the checksum when performing data integrity verification and used to identify the particular level of integrity verification originally used to calculate the checksum and to reselect a set of data points for recalculating the checksum and for comparing the calculated checksum to the included checksum. In some embodiments, the code may be omitted from the calculated checksum because CGVS100 may determine the particular level of integrity verification used for a file directly from the file extension, file type, and / or other attributes of the file.

[0043] 1 and 2 may detect changes that have occurred in manually selected data, data identified as important or critical (either through manual selection, algorithmic selection, or otherwise), and / or data that is within an area of ​​a file or point cloud defined according to a selected level of integrity verification for the file or point cloud. The resulting checksum may not be used for integrity verification of data or data points that were not selected and included as part of the checksum calculation.

[0044] In some embodiments, CGVS 100 may perform dynamic and efficient calculation of checksums that may be used to verify that data and / or data points have not been added or removed from a file and / or point cloud. 3 illustrates an example of dynamic checksum generation and validation to validate the structure and amount of data in a file without including all the data in the checksum calculation or validation, according to some embodiments presented herein. The resulting checksum, calculated from less than all the data, may be further used to validate whether any data points have been added or removed from the point cloud, or whether one or more of the data points have been modified.

[0045] The CGVS 100 may receive (at 302) a file storing a plurality of data points for point cloud encoding of a 3D image, object, and / or environment. The CGVS 100 may sort (at 304) the point cloud data points. The sorting (at 304) may include ordering the data points according to their position values ​​based on position values ​​that define a unique ordering of the data points. If the file and / or point cloud data remain unchanged, the unique ordering of the data points will be maintained, so the sorting (at 304) may ensure that subsequent checksum calculations can be reproduced. The sorting (at 304) may include organizing, arranging, and / or otherwise changing the ordering of the data points in the file. For example, the data points may be stored and / or accessed from the received (at 302) file in a first order that is not based on the position values ​​of the data points, and sorting (at 304) may include organizing, arranging, and / or otherwise changing the ordering of the data points from the first order into a different second order that is based on the position values ​​of the data points. In some embodiments, the point cloud file format may provide and / or store the data points in a sorted order. For example, the point cloud file format may store the point cloud data points in an array based on ascending order of the x-, y-, and z-coordinate position values ​​of the data points.

[0046] CGVS 100 may calculate (at 306) a checksum for the file using a single position or non-position value from each data point of the sorted data points. As shown in FIG. 3, CGVS 100 may iteratively select a first value (e.g., an x-coordinate value) from the position and non-position values ​​of a first ordered data point 301, a second value (e.g., a y-coordinate value) from the position and non-position values ​​of a second ordered data point 303 adjacent to the first ordered data point 301, a third value (e.g., a z-coordinate value) from the position and non-position values ​​of a third ordered data point 305 adjacent to the second ordered data point 303, a fourth value (e.g., a chromaticity value) from the position and non-position values ​​of a fourth ordered data point 307 adjacent to the third ordered data point 305, a fifth value (e.g., a luminance value) from the position and non-position values ​​of a fifth ordered data point 309 adjacent to the fourth ordered data point 307, and so on.

[0047] Computing the checksum (at 306) may include hashing (e.g., summing, combining, XORing Boolean operations, etc.) some combination of selected values ​​or a subset of values ​​from each data point in the respective order. For example, the CGVS 100 may XOR a selected first value of a first ordered data point 301 with a selected second value of a second ordered data point 303 with a selected third value of a third ordered data point 305, etc., in a specified order of the data points. The resulting value after XORing the selected values ​​of the data points with the specified ordering of the data points may result in a value that can be used as a checksum or may result in a value that can be hashed using a hash function to generate a checksum. In either case, the resulting value after XORing the selected values ​​of the data points with the specified ordering of the data points results in a unique value that changes if the ordering of the data points changes (e.g., a data point is moved to a new location, removed from the point cloud, or added to the cloud) or if any of the selected values ​​in the ordering change (e.g., the same selected values ​​are XORed together in different sequences). As another example, the CGVS 100 may sum a selected first value of a first ordered data point 301 with a selected second value of a second ordered data point 303 with a selected third value of a third ordered data point 305, and so on, in a specified ordering of the data points. The CGVS 100 may discard leading or trailing bits of the resulting total after each summation, such that a sequence of adding the selected values ​​results in a different value than would be obtained from summing the same selected values ​​in a different sequence or order. The resulting value may generate a checksum or may result in a value that can be hashed using a hash function to generate a checksum. In some embodiments, the CGVS 100 may hash some combination of the same position or non-position values ​​from each data point to generate a checksum.

[0048] The resulting checksum can be used to verify that data points have not been added or removed from the point cloud, that the positioning or ordering of the data points has not been changed, and / or that the selected values ​​for each data point have not been changed. In particular, any data points that are moved, added, or removed from the point cloud will change the value or ordering of values ​​used to calculate the checksum (at 306), thus generating a different checksum that identifies that some data in the file has been changed.

[0049] The resulting checksum may provide these and other integrity verifications without the processing effort and / or time required to calculate a checksum based on every value and / or data of every data point. For example, if each data point includes 10 distinct position and non-position values, a checksum generated via dynamic sampling of values ​​as shown in FIG. 3 may be completed in 1 / 10 the time it would take to calculate a checksum using every value of every data point.

[0050] The level of integrity verification may be increased by increasing the number of position and non-position values ​​sampled from each data point and included in the checksum calculation. For example, rather than using a single value from each data point in a sorted ordering of the data points, the CGVS 100 may cycle through and sample two or more values ​​from each data point and hash some combination of the two or more selected values ​​from each data point to generate a checksum that provides integrity verification for the additional values ​​of the data point.

[0051] However, some users, point clouds, and / or files may require validation of all the data in the point cloud and / or file. CGVS100 may adapt dynamic checksum generation and validation to provide integrity validation for an entire data set and / or all values ​​of all data points that is faster and more efficient than techniques that include hashing all values ​​of an entire data set and / or all data points of a point cloud.

[0052] 4 illustrates an example of dynamic checksum generation and validation to verify the integrity of all point cloud data based on a checksum calculation involving less than all of the point cloud data, according to some embodiments presented herein. The CGVS 100 may receive (at 402) a request to generate a checksum to verify that a point cloud and / or data point values ​​or data points within the point cloud have not been altered.

[0053] The CGVS 100 may sort the point cloud data points according to their position values ​​(at 404). As shown in FIG. 4, the point cloud data points may be ordered first based on ascending x coordinate position values, then based on ascending y coordinate position values, and then based on ascending z coordinate position values. If the point cloud does not have data points defined with respect to the same exact position in 3D space, sorting may produce a unique ordering of the point cloud data points that is reproducible if no data points have been moved, added, or removed from the point cloud. In other words, the same ordering of the point cloud data points may be reproduced regardless of the order in which the data points are stored in the point cloud file, as long as the integrity of the point cloud is unchanged. In some embodiments, the point cloud received by the CGVS 100 may have a file format that already stores the point cloud data points in a sorted order.

[0054] CGVS 100 may use the combination of non-position values ​​from each data point in sorted order to generate a checksum (at 406) and may exclude the position values ​​from each data point from the checksum or the combination of values ​​used to generate the checksum, but the resulting checksum may be used to verify whether any data points have been added or removed from the entire data and / or point cloud of all point cloud data points including their position and non-position values.

[0055] The calculated checksum may be embedded or included in the point cloud, and the integrity of the entire point cloud data may be verified by sorting the point cloud data points according to their position values, calculating a new checksum based on a combination of the non-position values ​​from each data point in the sorted order, and comparing the new checksum with the checksum provided with the point cloud to determine if any differences exist. Any change to the positioning of any single data point, to any single non-position value, or to the number of data points will change the checksum value.

[0056] Even if the point cloud data points are not stored in the desired sorted order, the sorting can be performed in less time and with less computational effort than including the position value of each data point in a hash calculation. For example, the time complexity of sorting via an efficient sorting algorithm (e.g., quicksort, mergesort, etc.) may be as low as O(nlogn), while the time complexity of computing a SHA256 hash may be O(n).

[0057] In some embodiments, CGVS100 may further optimize the checksum calculation by sorting the data points based on their position values ​​and a first set of non-position values, and by calculating the checksum based on a hash of some combination of a second set of non-position values ​​from the sorted ordering of the data points, where the second set of non-position values ​​is not used in the sorting and is different from the first set of non-position values.

[0058] 5 illustrates an example of generating a unique checksum based on a hash of a first set of values ​​from the point cloud data points sorted according to a second set of values ​​from the point cloud data points, according to some embodiments presented herein. As previously discussed, sorting (at 502) the data points according to their position values ​​(e.g., the second set of values) provides a unique ordering for the data points.

[0059] CGVS100 may combine the non-positional values ​​of the sorted data points (e.g., a first set of values) based on their sorted ordering, one or more calculations, and / or bit operations to generate a unique value. As shown in FIG. 5, CGVS100 may sum (at 504) a first non-positional value of a first ordered data point to a second non-positional value of the first ordered data point bit-shifted by a first value (e.g., one bit to the left), to a third non-positional value of the first ordered data point bit-shifted by a second value (e.g., two bits to the left or one bit to the right), to a fourth non-positional value of the first ordered data point bit-shifted by a third value (e.g., three bits to the left or two bits to the right), and to a fifth non-positional value of the first ordered data point bit-shifted by a fourth value (e.g., four bits to the left or three bits to the right). The CGVS 100 may calculate (at 504) the same sum for each data point in the sorted set of data points.

[0060] The CGVS 100 may then sum (at 506) the resulting value of the first data point to the resulting value of the second data point bit-shifted by the first value, to the resulting value of the third data point bit-shifted by the second value, to the resulting value of the fourth data point bit-shifted by the third value, and so on. The CGVS 100 may discard any leading or trailing bits of each value that exceed the specified number of bits. The value resulting from the sum of the non-position values ​​of all the bit-shifted data points may correspond to a checksum or may be hashed to generate a checksum. If any of the data point values ​​(e.g., position or non-position values), the order of the data points, or the number of data points change, the resulting sum and / or the calculated checksum will be different and the integrity verification of the data, point cloud, and / or file will fail.

[0061] FIG. 6 illustrates another example of generating a unique checksum to verify the integrity of all data in a file using less than all data from the file, according to some embodiments presented herein. The checksum generation may include CGVS100 sorting (at 602) the point cloud data points using a first set of data point values ​​(e.g., position values) that provide a unique and reproducible ordering for the data points. The checksum generation may further include generating (at 604) a unique combination for a second set of data point values ​​(e.g., non-position values) based on the unique ordering generated by the first set of values. As shown in FIG. 6, CGVS100 may count the number of distinct values ​​in the second set of data point values ​​for each data point and may select a prime number that is less than the number of distinct values. For example, if each data point is defined with 5 distinct non-position values, CGVS100 may select the prime number 3. The CGVS may then sequentially sum the second set of values ​​with each next value bit-shifted by increasing the number of bits up to the selected prime number. For example, the CGVS 100 may add the first non-positional value of the first ordered data point to the second non-positional value of the first ordered data point bit-shifted left by 1 bit, to the third non-positional value of the first ordered data point bit-shifted left by 2 bits, to the fourth non-positional value of the first ordered data point bit-shifted left by 3 bits, to the fifth non-positional value of the first ordered data point bit-shifted left by 0 bits, to the first non-positional value of the second ordered data point bit-shifted left by 1 bit, and so on.

[0062] CGVS 100 may discard any leading or trailing bits after any summation operation that results in more than a specified number of bits. For example, the sum from the bit-shifted non-positional values ​​of a first data point may be 65,500, represented as a 16-bit value 1111111111011100, and the addition of the bit-shifted non-positional value of a second data point may then change that value to 65,600, which may overflow to a 17-bit value of 10000000001000000. Rather than keeping the 17-bit value, CGVS 100 may remove the leading bits to generate a 16-bit value of 0000000001000000, or may remove the trailing bits to generate a 16-bit value of 1000000000100000, and continue the summation operation with the trimmed 16-bit value.

[0063] The result is a unique value that cannot be reproduced when any of the values ​​change or the order of the values ​​changes. The result may be used as a checksum or may be hashed to generate a checksum.

[0064] In some embodiments, the checksum may be generated via an otherwise unique, computationally inexpensive combination of non-position values ​​from data points sorted according to their position values. For example, the CGVS 100 may sort the data points and sum the results of XORing a first non-position value of a first ordered data point with a second non-position value of a second ordered data point, XORing a second non-position value of the first ordered data point with a third non-position value of the second ordered data point, etc., until the sum of all XORed pairs of alternating non-position values ​​from adjacently ordered data points is calculated. The resulting value may be used as a checksum or may be hashed to generate a checksum that may be used to verify the integrity of all data from a point cloud or file.

[0065] CGVS100 may use AI / ML to increase the level of integrity verification without increasing the computational cost and / or time associated with generating and / or verifying checksums. In some embodiments, CGVS100 may train AI / ML techniques to automatically distinguish between a first classification and at least a second classification of data (e.g., critical data and non-critical data) in different files and / or critical and non-critical regions in different point clouds. CGVS100 may dynamically generate and / or verify checksums based on the critical data and / or critical regions identified by AI / ML. Thus, checksum calculation and / or verification based on the critical data and / or critical regions identified by AI / ML may be performed more quickly than checksum calculation and / or verification including the entire file and / or point cloud data, and may provide a checksum that can be used to dynamically and reproducibly verify the integrity of data in the identified critical data and / or critical regions. Changes to non-critical data and / or data in non-critical areas may not have importance or significance in the use of the file and / or point cloud or to the user involved, and therefore the time and processor savings of calculating dynamic checksums on data differentiated by AI / ML are outweighed by any loss of integrity from not including non-critical data and / or areas in the checksum calculation and / or validation.

[0066] 7 presents a process 700 for dynamically generating a checksum based on an automatically identified subset of data in a point cloud or file, according to some embodiments presented herein. Process 700 may be performed by CGVS 100.

[0067] Process 700 may include receiving (at 702) a request to generate a checksum to verify the integrity of a point cloud or file and / or a subset of AI / ML classified data from the point cloud or file. In some embodiments, CGVS 100 may calculate a dynamic checksum for critical data of a received file if the file size exceeds a threshold limit (e.g., the file is larger than 1 gigabyte in size) or if the file is of a particular type (e.g., a point cloud representing a 3D image or scan of a 3D environment, a video, etc.).

[0068] The process 700 may include distinguishing (at 704) a first set of data in the received point cloud or file from a second set of data using one or more AI / ML techniques. The first set of data may correspond to point cloud data points or data that the AI / ML techniques classify as important or integral to the subject matter represented, captured, and / or presented by the point cloud or file. The second set of data may correspond to point cloud data points or data that the AI / ML techniques classify as unimportant or non-integral to the subject matter represented, captured, and / or presented by the point cloud or file. In other words, the AI / ML techniques may classify the first set of data as data that cannot be changed without changing the subject matter being presented, while changes to the second set of data may not adversely affect or impact the subject matter being presented.

[0069] Process 700 may include tagging (at 706) the first set of data differently from the second set of data. For example, CGVS 100 may add a first non-location value to the data points in the first set of data and a second non-location value to the data points in the second set of data to distinguish between the two data sets.

[0070] The process 700 may include generating (at 708) a checksum based on values ​​and / or data from the first set of data while omitting the second set of data from the checksum generation. Generating (at 708) the checksum may include performing a hash based on some combination of one or more values ​​and / or data from the first set of data. The combining may include summing the values ​​from the first set of data in a specified order (e.g., the order in which the first set of data was encoded or formatted in a file, a sorted order based on position values ​​of the first set of data, or another order that can be recreated if the first set of data remains unchanged). The values ​​resulting from the combining may be hashed with a hash function to generate the checksum.

[0071] Process 700 may include associating (at 710) a checksum with the point cloud and / or file. In some embodiments, CGVS 100 may embed the checksum as part of the point cloud and / or file or may link the checksum to the point cloud and / or file such that whenever the point cloud and / or file is accessed, the checksum for the point cloud and / or file may be accessed and / or obtained in advance to verify the integrity of the point cloud and / or file.

[0072] In some embodiments, CGVS100 may train AI / ML techniques to distinguish between first and second classifications (e.g., important data and non-important data) based on different commonalities, patterns, and / or trends present in the location and non-location values ​​of the point cloud data points, and / or based on the file names, file types, and metadata associated with the files. For example, the AI / ML techniques may be trained to detect commonalities, patterns, and / or trends that distinguish between dense clusters of data points and sparse clusters of data points, foreground data points and background data points, data points with different commonalities in color content, etc.

[0073] In some embodiments, an AI / ML technique may be provided with an example point cloud, where certain dense clusters of data points in the example are labeled as important data or with a first classification, and other less dense clusters of data points are labeled as unlabeled or unimportant data or with a second classification. The AI / ML technique may analyze the location and / or non-location values ​​of the data points to determine that data points labeled as important data are within a threshold distance from at least one neighboring data point, while data points labeled as unimportant data are farther than a threshold distance from their nearest neighboring data point. Thus, the AI / ML technique may detect similar commonalities in the location values ​​of data points from the unlabeled point cloud, and may use the presence or absence of such commonalities to distinguish between important and unimportant data of the point cloud.

[0074] In some embodiments, the AI / ML techniques may perform unsupervised learning on the unlabeled example point cloud to distinguish between important and unimportant data. In some such embodiments, the AI / ML techniques may be configured to analyze location values ​​of the data points and detect distinct commonalities, patterns, and / or trends in the location values. For example, the AI / ML techniques may detect distinct patterns between a first set of data points that are clustered together and within a threshold distance of at least one neighboring data point and a second set of data points that are farther than a threshold distance from a nearest neighboring data point. The AI / ML technique may classify each set of data points differently based on the location distinctions found from the analysis and may determine that a dense clustering of data points may represent important and / or foreground data and that a coarse clustering of data points may represent unimportant and / or background data based on a high number of tracked user edits made for densely clustered data points and a low number of tracked user edits made for loosely clustered data points, and / or other criteria found by the AI / ML from monitoring the example point clouds and / or from other commonalities, patterns, and / or trends detected within or from use of the point clouds.

[0075] In some embodiments, AI / ML techniques may analyze position and non-position values ​​of point cloud data points to distinguish different objects. For example, data points that are within a first threshold of each other, generate non-planar shapes, have color components that are within a second threshold of each other (e.g., red values ​​between neighboring data points vary by less than 15%), and / or have color components that are different from recurring background color components may be determined to be part of the same object. These distinguished objects may be classified as significant data, while data points with background color components may be classified as non-significant data.

[0076] AI / ML techniques may distinguish between different objects and / or object and background elements based on models for edge detection and / or continuous surface detection. The edge detection and / or continuous surface detection models may identify commonalities, patterns, and / or trends in position and / or non-positional values ​​where edges of objects or continuous surfaces of objects may be detected and distinguished. For example, data points having color components within a threshold range of each other may be part of a continuous surface, and data points having color component similarity with data points on a first side and color component dissimilarity with data points on an opposing second side may be classified as edge data points representing edges and / or edges of objects.

[0077] In some embodiments, the AI / ML techniques may use file names, file types, and / or metadata to help distinguish between important and non-important data. For example, the file name and / or metadata may identify that the file contains data about a particular vehicle. The AI / ML techniques may search databases, the Internet, and / or other sources to obtain information about the particular vehicle (e.g., shape, dimensions, coloring, etc.) and may analyze the file to distinguish important data about the particular vehicle from other non-important data (e.g., background data points, data points about other unrelated objects, etc.).

[0078] 8 illustrates an example of AI / ML discrimination of file data for dynamic checksum generation according to some embodiments presented herein. As shown in FIG. 8, CGVS 100 may receive an unclassified point cloud (at 802) and may use one or more AI / ML techniques to discriminate between critical and non-critical data within the point cloud.

[0079] One or more AI / ML techniques may be trained to recognize certain commonalities, patterns, and / or trends in important data. The AI / ML techniques may define models for commonalities, patterns, and / or trends in location and / or non-location values ​​of data points that distinguish important data from other data. The CGVS 100 may compare (at 804) different combinations of data points from the received (at 802) point cloud to the AI / ML generated models to determine whether any combinations contain the modeled commonalities, patterns, and / or trends that are classified as important or distinguished data.

[0080] 7, the first AI / ML technique may classify (at 806) a first set of data points as significant data based on the first set of data points having location commonality consistent with modeling a dense cluster of data points classified as significant or distinct data by the AI / ML model. The CGVS 100 may distinguish (at 806) the first set of data points from other sets of data points in the point cloud. The distinguishing (at 806) may include tagging the first set of dense data points as different from other data points in the point cloud.

[0081] A second AI / ML technique may detect (at 808) a second set of data points that form a particular shape and / or have color components similar to the modeled significant data, and may distinguish (at 808) the second set of data points from other data points in the point cloud. For example, the file metadata may identify the point cloud as a landscape image, and CGVS100 may obtain an AI / ML generative model trained to detect shapes, patterns, and / or characteristics of significant features in landscape imaging. CGVS100 may use the AI / ML generative model to detect (at 808) that the second set of data points form the shape and have color components related to tree trunks and tree branches that are classified as significant or distinct data in the model.

[0082] The CGVS 100 may calculate (at 810) a checksum using the values ​​of the first set of data points and the second set of data points. The values ​​of other data points in the received (at 802) point cloud may be excluded from the checksum calculation.

[0083] In some embodiments, user input may be used to train the AI / ML techniques in distinguishing important data from unimportant data. For example, the CGVS 100 may present a visualization of a point cloud, and the user may select one or more points in the point cloud that represent important data. The AI / ML techniques may then perform an outward expansion from the user-selected point to further select any nearby and / or surrounding data points that have a particular location and / or non-location value commonality with the user-selected point. For example, the CGVS 100 may identify all data points that form the same feature or continuous features that include the user-selected point. Thus, the user may select a single data point in the point cloud, and the AI / ML techniques may determine and select a set of data points that are part of the same feature or object and / or share other location and / or non-location value commonality with the user-selected data point.

[0084] To mitigate the possibility of misclassifying data in a file and critical data from a checksum calculation, the CGVS 100 may implement a hybrid approach to generate checksums by using one or more AI / ML techniques to automatically select a first set of data for the checksum and sampling an unselected second set of data for the checksum. The resulting checksums may be used to verify the integrity of all values ​​and / or data from the first set of data (e.g., classified as critical data, foreground data, and / or with a first classification) and values ​​and / or data from a subset of the second set of data (e.g., classified as non-critical data, background data, and / or with a second classification).

[0085] 9 presents a process 900 for dynamic checksum generation based on a hybrid selection of critical and non-critical data sampling from a file, according to some embodiments presented herein. Process 900 may be implemented by CGVS 100.

[0086] The process 900 may include receiving (at 902) a request to generate a checksum to verify the integrity of a file and / or file data. The process 900 may include distinguishing (at 904) a first set of data in the received file from a second set of data using one or more AI / ML techniques. Again, the AI / ML techniques may distinguish (at 904) the file data based on different commonalities, patterns, and / or trends that the AI / ML is trained to detect in the file data (e.g., location and / or non-location values ​​of point cloud data points). More specifically, the AI / ML techniques may distinguish (at 904) commonalities, patterns, and / or trends in first data classified as important and / or that would affect the subject matter of the file if changed from second data classified as unimportant and / or that would not affect the subject matter of the file if changed.

[0087] The process 900 may include selecting (at 906) a subset of the distinct second set of data to be included as part of the checksum calculation. The selecting (at 906) may include sampling less than all of the data from the second set of data in a reproducible manner for the checksum verification, provided that the file data does not change from the time the original checksum was calculated to the time the checksum is verified. For example, the CGVS 100 may use one or more of the methodologies described above with reference to FIGS. 1-5 and / or other described sampling methodologies described herein to select (at 906) the subset of the distinct second set of data. In some embodiments, the selecting (at 906) the subset of data may include selecting all other or a third data point from the distinct second set of data. In some embodiments, selecting (at 906) the subset of data may include selecting all values ​​from the position values ​​and / or non-position values ​​of a first set of point cloud data points representing the first set of data to include as part of the checksum calculation, while selecting a subset of values ​​from the position values ​​and / or non-position values ​​of a second set of data to include as part of the checksum calculation.

[0088] In some embodiments, distinguishing the data (at 904) and selecting the subset of the data (at 906) may include tagging each data point included in the first set of data and each data point included in the subset of the second set of data with a particular value that indicates inclusion of that data point in the checksum calculation. All other data may not be tagged with the particular value or may be tagged with a different value that indicates exclusion of that data or those data points from the checksum calculation.

[0089] The process 900 may include calculating (at 908) a checksum based on the first set of data and a subset of the second set of data. The checksum calculation (at 908) may include using all or less than all values ​​and / or data from the first set of data and the subset of the second set of data. For example, the file data may correspond to point cloud data points having a set of location and non-location values, and the checksum calculation (at 908) may be based on a combination of some or all of the location and non-location values ​​from the first set of data and the subset of the second set of data.

[0090] Process 900 may include distributing (at 910) the calculated checksum along with the file such that the checksum may be used to verify the integrity of the first set of data and a subset of the second set of data. FIG. 10 presents a process 1000 for dynamic checksum verification according to some embodiments presented herein. Process 1000 may be performed by the same or a different instance of CGVS 100 used to generate the checksum distributed with the file. In some embodiments, process 1000 may be performed with CGVS 100 integrated as part of a file system or application that performs a checksum verification before opening or accessing a file that has an included checksum.

[0091] Process 1000 may include receiving (at 1002) a request to access a file. In response to the request, process 1000 may include obtaining (at 1004) the requested file and a checksum for the file. The checksum may be embedded in the file, distributed with the file, or otherwise linked to the file.

[0092] The process 1000 may include selecting (at 1006) a sampling approach to be used to select data to be included as part of the checksum calculation. The selection (at 1006) may be based on one or more of a static checksum generation configuration for the CGVS 100, a file name, a file type, file metadata, and / or characteristics associated with the checksum. For example, the first two bits or the last two bits of the included checksum may identify the sampling approach as one of the methodologies described with reference to the previous figures. In this case, the sampling approach may correspond to a hybrid selection of critical and non-critical data sampling used for checksum generation in the process 900. In some embodiments, all instances of the CGVS 100 may be configured to perform checksum generation and validation based on the hybrid approach of the process 900 or another statically configured approach.

[0093] Process 1000 may include distinguishing (at 1008) a first set of data from a second set of data in the received file, and / or sampling (at 1010) a subset of data from the distinguished second set of data based on one or more AI / ML and / or sampling techniques associated with the selected (at 1006) sampling approach. If the file and / or file data has not been altered, the subset of the first set of data and the second set of data will be the same as the data used to calculate a checksum included with the file.

[0094] To verify whether the file data has been modified, the process 1000 may include combining (at 1012) values ​​and / or data from the first set of data with a subset of the second set of data designated for checksum calculation. For example, combining (at 1012) the values ​​and / or data may include sorting the data according to their position values ​​and summing one or more non-positional values ​​from the sorted data with any bit shifting and / or overflow correction operations.

[0095] Process 1000 may include hashing (at 1014) a result from combining (at 1012) the values ​​and / or data to generate a verification checksum. Process 1000 may include comparing the verification checksum to a checksum included with the file. The comparison may include determining (at 1016) whether the two checksum values ​​match or differ.

[0096] In response to the verification checksum differing from the included checksum (at 1016--no), the process 1000 may include determining (at 1018) that the file has been altered and / or that the integrity of the file data cannot be verified. Accordingly, the process 1000 may include performing (at 1020) at least a first action in response to the failed integrity check. In some embodiments, performing (at 1020) the first action may include blocking access to the file as a result of the integrity check revealing that the file data has been altered. In some embodiments, performing (at 1020) the first action may include generating a notification to alert a user of the failed integrity check and / or obtaining the file from a different trusted source.

[0097] In response to the verification checksum matching the included checksum (at 1016—Yes), process 1000 may include verifying the integrity of the file data (at 1022) and / or determining that the verified data has not been altered. Thus, process 1000 may include performing at least a second action (at 1024) responsive to the successful integrity check. In some embodiments, performing the second action (at 1024) may include opening, processing, and / or otherwise providing access to the file.

[0098] 11 illustrates one or more integrations of CGVS 100 as part of a device 1100 according to some embodiments presented herein. Device 1100 may include computers, tablets, smartphones, sensors, Internet-of-Things ("IoT") devices, and / or other devices that access or use files and / or data.

[0099] As shown in FIG. 11, CGVS 100 may be integrated as part of the device file system 1101 and / or operating system 1103. As part of the file system 1101 and / or operating system 1103, CGVS 100 may verify the integrity of all or specific files with checksums before allowing access to those files. In this manner, CGVS 100 may protect device 1100 from malicious, modified, unverified, and / or downloaded content. Additionally, CGVS 100 may automatically generate and associate checksums with each file when the file is newly created, stored, and / or not already associated with a checksum. In doing so, CGVS 100 may verify that a stored file is not corrupted after storage on the device and / or before the next access of the file.

[0100] In some embodiments, CGVS 100 may be integrated as part of different applications 1105 executing on device 1100. For example, a point cloud creation, rendering, and / or editing application 1105 may be integrated with CGVS 100 to verify the integrity of any point cloud loaded or executed with that application 1105. Similarly, CGVS 100 may dynamically generate checksums for point clouds created, edited, or otherwise modified with application 1105 and may include the generated checksums with the modified point cloud. In other words, CGVS 100 may generate a new checksum and / or update an existing checksum for a file whenever the file is modified with one of the applications 1105.

[0101] 12 is a diagram of example components of a device 1200. Device 1200 may be used to implement one or more of the devices or systems described above (e.g., CGVS 100, device 1100, etc.). Device 1200 may include a bus 1210, a processor 1220, memory 1230, input components 1240, output components 1250, and a communication interface 1260. In another implementation, device 1200 may include additional, fewer, different, or differently arranged components.

[0102] Bus 1210 may include one or more communication paths that enable communication between components of device 1200. Processor 1220 may include a processor, microprocessor, or processing logic that may interpret and execute instructions. Memory 1230 may include any type of dynamic storage device that may store information and instructions for execution by processor 1220, and / or any type of non-volatile storage device that may store information for use by processor 1220.

[0103] Input components 1240 may include mechanisms that allow an operator to input information into device 1200, such as a keyboard, keypad, buttons, switches, etc. Output components 1250 may include mechanisms that output information to an operator, such as a display, a speaker, one or more LEDs, etc.

[0104] Communications interface 1260 may include any transceiver-like mechanism that enables device 1200 to communicate with other devices and / or systems. For example, communications interface 1260 may include an Ethernet interface, an optical interface, a coaxial interface, etc. Communications interface 1260 may include wireless communications devices such as infrared ("IR") receivers, Bluetooth radios, etc. Wireless communications devices may be coupled to external devices such as remote controls, wireless keyboards, mobile phones, etc. In some embodiments, device 1200 may include more than one communications interface 1260. For example, device 1200 may include an optical interface and an Ethernet interface.

[0105] The device 1200 may perform certain operations related to one or more processes described above. The device 1200 may perform these operations in response to the processor 1220 executing software instructions stored in a computer-readable medium, such as the memory 1230. The computer-readable medium may be defined as a non-transitory memory device. The memory device may include space in a single physical memory device or may be distributed across multiple physical memory devices. The software instructions may be loaded into the memory 1230 from another computer-readable medium or from another device. The software instructions stored in the memory 1230 may cause the processor 1220 to perform multiple processes described herein. Alternatively, hardwired circuitry may be used in place of or in combination with software instructions to perform the processes described herein. Thus, the implementations described herein are not limited to any particular combination of hardware circuitry and software.

[0106] The above description of implementations provides illustration and description, but is not intended to be exhaustive or to limit possible implementations to the precise form disclosed. Modifications and variations are possible in light of the above disclosure or may be acquired from practice of the above implementations.

[0107] The actual software code or specialized control hardware used to implement the embodiments is not a limitation of the embodiments, and thus the operation and behavior of the embodiments will be described without reference to specific software code, it being understood that the software and control hardware can be designed based on the description herein.

[0108] For example, although a sequence of messages, blocks, and / or signals may be described in connection with some of the above figures, the order of the messages, blocks, and / or signals may be modified in other implementations. Further, non-dependent blocks and / or signals may be executed in parallel. Furthermore, while a figure may be described in the context of a particular device performing certain functions, in reality one or more other devices may perform some or all of those functions instead of, or in addition to, the device(s) referenced above.

[0109] Although particular combinations of features are recited in the claims and / or disclosed in the specification, these combinations are not intended to limit the disclosure of possible implementations. Indeed, many of these features may be combined in ways not specifically recited in the claims and / or specifically disclosed in the specification. Although each dependent claim listed below may depend directly on only one other claim, the disclosure of possible implementations includes each dependent claim in combination with all other claims in the claim set.

[0110] Further, while particular connections or devices are shown, in reality additional, fewer, or different connections or devices may be used. Further, while various devices and networks are shown separately, in reality the functionality of multiple devices may be performed by a single device or the functionality of one device may be performed by multiple devices. Further, while several devices are shown in communication with a network, several such devices may be incorporated, in whole or in part, as part of the network.

[0111] To the extent that the above embodiments collect, store, or utilize personal information provided by an individual, it should be understood that such information will be used in accordance with all applicable laws regarding the protection of personal information. Furthermore, the collection, storage, and use of such information may be subject to the individual's consent to such activities, for example, through known "opt-in" or "opt-out" processes, as may be appropriate for the context and type of information. The storage and use of personal information may be in an appropriately secure manner that reflects the type of information, for example, through various encryption and anonymization techniques, particularly for sensitive information.

[0112] Some implementations described herein may be described in conjunction with a threshold value. The term "greater than" (or similar term), when used herein to describe the relationship of a value to a threshold value, may be used interchangeably with the term "greater than or equal to" (or similar term). Similarly, the term "less than" (or similar term), when used herein to describe the relationship of a value to a threshold value, may be used interchangeably with the term "less than or equal to" (or similar term). "Exceeding" a threshold value (or similar term), when used herein, may be used interchangeably with "greater than the threshold value," "greater than or equal to the threshold value," "less than the threshold value," "less than or equal to the threshold value," or other similar terms, depending on the context in which the threshold value is used.

[0113] No element, act, or instruction used in this application should be construed as critical or essential unless expressly described as such. The instance of the use of the term "and", when used herein, does not necessarily preclude the interpretation that the term "and / or" is intended in this instance. Similarly, the instance of the use of the term "or", when used herein, does not necessarily preclude the interpretation that the term "and / or" is intended in this instance. Also, the article "a", when used herein, is intended to include one or more items and may be used interchangeably with the phrase "one or more". When only one item is intended, the terms "a", "single", "only" or similar language is used. Additionally, the phrase "based on" is intended to mean "based at least in part on" unless expressly specified otherwise.

Claims

1. receiving a file including a plurality of data points defined by positional and non-positional values; setting a particular level of integrity verification for the file based on one or more attributes associated with the file or user input; determining a data point selection criterion associated with a particular level of said integrity verification; distinguishing the first set of data points from the second set of data points, where distinguishing the first set of data points comprises determining that one or more of the position values ​​and the non-position values ​​of the first set of data points meet the data point selection criteria and that the position values ​​and the non-position values ​​of the second set of data points do not meet the data point selection criteria; generating the checksum based on a combination of two or more values ​​from the position values ​​and the non-position values ​​of each data point from the first set of data points and further based on the exclusion of the position values ​​and the non-position values ​​of the second set of data points from the checksum; and verifying the integrity of the data associated with the first set of data points using the checksum. A method for providing the above.

2. presenting a visualization of the plurality of data points; detecting a selection of a particular region in the visualization; Further equipped with 2. The method of claim 1, wherein distinguishing the first set of data points further comprises determining that the position values ​​of the first set of data points are within the particular region and that the position values ​​of the second set of data points are outside the particular region.

3. The step of generating a checksum comprises: sorting the first set of data points according to the position values ​​of the first set of data points; and generating said checksum from a value generated from combining said non-position values ​​of said first set of data points in a particular order determined after sorting said first set of data points. The method according to claim 1 or 2, comprising:

4. The step of generating a checksum comprises: calculating a unique value from a combination of a subset of the position values ​​and the non-position values ​​of the first set of data points, where the subset of the position values ​​and the non-position values ​​of the first set of data points uses fewer than all of the position values ​​and the non-position values ​​of the first set of data points. The method according to claim 1 or 2, comprising:

5. The step of generating a checksum comprises: hashing the unique value with a hashing value; and storing the result from said hashing as said checksum. The method of claim 4 further comprising:

6. The step of generating a checksum comprises: sampling different values ​​from the position values ​​and the non-position values ​​of different subsets of the first set of data points; and calculating the checksum based on the different values ​​sampled from the different subsets of the first set of data points; The method according to claim 1 or 2, comprising:

7. The step of distinguishing the first set of data points comprises: detecting a first commonality in one or more of the position values ​​and the non-position values ​​of the first set of data points and classifying the first set of data points with a first classification based on the first commonality satisfying the data point selection criterion; and classifying the second set of data points with a second, different classification based on the location values ​​and the non-location values ​​of the second set of data points lacking the first commonality and failing to satisfy the data point selection criterion. The method of claim 1 or 2, further comprising:

8. The step of verifying the integrity of the data comprises: receiving the file along with the checksum; determining a sampling approach associated with the file; selecting a third set of data points from the file in response to the sampling approach; calculating a validation checksum based on a combination of two or more values ​​from the position values ​​and the non-position values ​​of each data point from the third set of data points; and verifying that the first set of data points of the file has not been altered in response to the checksum received with the file matching the verification checksum. The method according to claim 1 or 2, comprising:

9. the checksum is a first checksum generated for a first time, The step of verifying the integrity of the data comprises: generating a second checksum based on the combination of the two or more values ​​from the position values ​​and the non-position values ​​of each data point from a particular set of data points distinguished from the plurality of data points at a second time after the first time; performing a first action in response to verifying that the plurality of data points has not been altered based on the second checksum matching the first checksum; and performing a second, different action in response to verifying that the plurality of data points have been altered based on the second checksum differing from the first checksum. The method according to claim 1 or 2, comprising:

10. analyzing the position values ​​and the non-position values ​​of data points from different files; modeling commonalities in one or more of the location values ​​and the non-location values ​​that distinguish different data in the different files; Further equipped with Distinguishing the first set of data points further comprises determining that the position values ​​and the non-position values ​​of the first set of data points have the commonality and that the position values ​​and the non-position values ​​of the second set of data points do not have the commonality. The method according to claim 1 or 2.

11. determining the size of the file; Further equipped with The step of generating a checksum comprises: in response to the size of the file being greater than a threshold, calculating a first checksum based on the combination of the two or more values ​​from the position values ​​and the non-position values ​​of each data point from the first set of data points; and responsive to the size of the file being less than the threshold, calculating a second checksum based on all of the position values ​​and the non-position values ​​of the plurality of data points. The method according to claim 1 or 2, comprising:

12. one or more processors; and When executed by the one or more processors, the one or more processors receiving a file including a plurality of data points defined by positional and non-positional values; setting a particular level of integrity verification for the file based on one or more attributes associated with the file or user input; determining a data point selection criterion associated with a particular level of the integrity verification; distinguishing a first set of the plurality of data points from a second set of the plurality of data points, where distinguishing the first set of data points includes determining that one or more of the position values ​​and the non-position values ​​of the first set of data points meet the data point selection criteria and that the position values ​​and the non-position values ​​of the second set of data points do not meet the data point selection criteria; generating the checksum based on a combination of two or more values ​​from the position values ​​and the non-position values ​​of each data point from the first set of data points and further based on the exclusion of the position values ​​and the non-position values ​​of the second set of data points from the checksum; and verifying the integrity of data associated with the first set of data points using the checksum; MEMORY HAVING COMPUTER-READABLE MEDIUM CONTAINING PROCESSING INSTRUCTIONS - Patent application A system comprising:

13. generating the checksum sorting the first set of data points according to the position values ​​of the first set of data points; and generating the checksum from a value generated from combining the non-position values ​​of the first set of data points in a particular order determined after sorting the first set of data points. The system of claim 12 , comprising:

14. generating the checksum calculating a unique value from a combination of a subset of the position values ​​and the non-position values ​​of the first set of data points, where the subset of the position values ​​and the non-position values ​​of the first set of data points uses fewer than all of the position values ​​and the non-position values ​​of the first set of data points. The system of claim 12 , comprising: