Image storage system for images with overlapping sections

Abstract

An image storage system image storage space management for images having overlaps is provided. A plurality of processor units identify a benchmark image in a similar image group. A plurality of other images in the similar image group that were not identified as a benchmark image are a set of similar images. A plurality of processor units create an image mapping tree. The image mapping tree has a root block for the benchmark image and blocks arranged in a set of layers below the root block based on the set of similar images; the blocks represent portions of the benchmark image; and a plurality of lower blocks in the blocks in the lower layer correspond to subdivisions in higher blocks in the blocks in the higher layer. The plurality of processor units store a set of selected blocks having differences from a corresponding set of blocks in the image mapping tree for the benchmark image in the set of similar images. The plurality of processor units store metadata for the selected set of blocks describing a set of paths in the image mapping tree from the corresponding set of blocks in the image mapping tree to the root block.

Description

Technical Field

[0001] The present invention generally relates to improvements in computer systems, and more specifically to a computer system that efficiently stores images having overlapping portions.

Background Art

[0002] With the development of the Internet and social networking platforms, an enormous amount of information is being stored. Images can constitute a large proportion of the information stored on social networking platforms. For example, users of social media platforms can upload a very large number of images, such as over 1.8 billion images per day. Storing images on the Internet can be done for creating training datasets for image recognition training for artificial intelligence systems and for other purposes for which a large number of images may be required.

[0003] Storing these images requires a huge amount of storage space and incurs a high cost. In managing the storage space for images, compression techniques can be applied to the images to reduce the amount of storage space. When data compression is applied to digital images, the size of the images can be reduced, and as a result, the cost for storage or transmission can be reduced. In the case of image compression, the compression can be either lossless compression or lossy compression. Lossless compression is preferred, but it may not generate the desired degree of image size reduction.

[0004] Furthermore, in managing the storage space for images, duplicate images can be identified. By identifying duplicate images, deduplication for deleting duplicate copies of the images can be performed. One image can be retained as a shared copy. However, since the number of images being stored continues to increase rapidly, deduplication of the same image may not provide the desired reduction in the storage space for images.

Summary of the Invention

[0005] According to one exemplary embodiment, a computer implementation method for managing image storage space is provided. Multiple processor units identify a benchmark image within a group of similar images. Multiple other images within the group of similar images that are not identified as benchmark images constitute a set of similar images. Multiple processor units create an image mapping tree. The image mapping tree has a root block for the benchmark image and blocks arranged in a set of layers below the root block based on the set of similar images. A block represents a portion of the benchmark image, and multiple subblocks within a block in a lower layer correspond to sub-partitions within a higher block in a block in a higher layer. Multiple processor units store a selected set of blocks in the set of similar images that have differences from the corresponding set of blocks in the image mapping tree for the benchmark image. Multiple processor units store metadata about the selected set of blocks that describes a set of paths in the image mapping tree from the corresponding set of blocks in the image mapping tree to the root block. According to another exemplary embodiment, a computer system and computer program product for managing image storage space are provided. As a result, the exemplary embodiment may provide a technical effect of improving performance in the computer system by reducing the amount of image storage space required through storing portions of similar images.

[0006] An exemplary embodiment may also tolerate storing in the image mapping tree a new set of blocks for a new image that is different from the new corresponding set of blocks in the benchmark image, and may store in the image mapping tree new metadata for the new set of blocks that describes a new set of paths from the new corresponding set of blocks in the image mapping tree to the root block for the benchmark image. The exemplary embodiment may further tolerate storing the new set of images using the image mapping tree if the new set of images is within the maximum threshold for images in the image mapping tree. The exemplary embodiment may also tolerate reconstruct the image mapping tree using the new set of images and the images in the similar image group if the new set of images is equal to or exceeds a new image threshold. In creating an image mapping tree for a similar image group, the exemplary embodiment may tolerate dividing the benchmark image to form sub-parts within the benchmark image, creating a layer above the upper blocks within a layer below the root block, where each upper block within the upper blocks corresponds to a sub-part within a sub-part in the benchmark image. In creating an image mapping tree for a group of similar images, the exemplary embodiment allows for further determining the number of similar images in a set of similar images that have different similar blocks from the corresponding upper blocks within the upper blocks, in order to form a set of corresponding upper blocks; dividing each corresponding upper block within the set of corresponding upper blocks into sub-partitions; and creating lower layers of lower blocks, where each lower block within a lower block corresponds to a sub-partition within a sub-partition in the set of corresponding upper blocks. As a result, the exemplary embodiment provides a technical effect that enables a reduction in storage for similar images through the use of an image mapping tree for storing blocks of similar images and metadata about those blocks.

[0007] In another exemplary example, a computer implementation method for managing image storage space is provided. Multiple processor units receive new images to store using an image mapping tree having a root block for a benchmark image and blocks arranged in a set of layers below the root block based on a set of similar images. The blocks represent portions of the benchmark image within multiple lower blocks, where blocks in the lower layers correspond to sub-partitions within blocks in the upper layers. Multiple processor units store a new set of blocks for the new image, different from the corresponding set of blocks in the image mapping tree. Multiple processor units store new metadata in the image mapping tree for the new set of blocks, describing a new set of paths from the corresponding set of blocks in the image mapping tree to the root block for the benchmark image. According to other exemplary embodiments, a computer system and computer program product for managing image storage space are provided. As a result, the exemplary embodiments may provide a technical effect of improving performance in the computer system by reducing the amount of image storage space required through storing portions of similar images. [Brief explanation of the drawing]

[0008] [Figure 1] This figure shows a cloud computing environment in which exemplary embodiments may be implemented.

[0009] [Figure 2] This figure shows an abstraction model layer according to an exemplary embodiment.

[0010] [Figure 3] This is a diagrammatic representation of a network of a data processing system, in which exemplary embodiments may be implemented.

[0011] [Figure 4] This is a block diagram of an image environment according to an exemplary embodiment.

[0012] [Figure 5] It is an explanatory diagram of a similar image group according to an exemplary embodiment.

[0013] [Figure 6] It is an image mapping tree according to an exemplary embodiment.

[0014] [Figure 7] It is metadata used to describe blocks stored for images according to an exemplary embodiment.

[0015] [Figure 8] It is a mapping of a new image to an image mapping tree according to an exemplary embodiment.

[0016] [Figure 9] It is a flowchart of a process for managing an image storage space tree according to an exemplary embodiment.

[0017] [Figure 10] It is a flowchart of a process for storing a new image according to an exemplary embodiment.

[0018] [Figure 11] It is a flowchart of a process for processing a new set of images according to an exemplary embodiment.

[0019] [Figure 12] It is a flowchart of a process for creating an image mapping tree according to an exemplary embodiment.

[0020] [Figure 13] It is a flowchart of a process for creating an image mapping tree according to an exemplary embodiment.

[0021] [Figure 14A] A flowchart of a process for creating an image mapping tree according to an exemplary embodiment. [Figure 14B] A flowchart of a process for creating an image mapping tree according to an exemplary embodiment.

[0022] [Figure 15] A flowchart of a process for managing an image storage space tree according to an exemplary embodiment.

[0023] [Figure 16A] A flowchart of a process for managing an image storage space tree for processing a new image according to an exemplary embodiment. [Figure 16B] A flowchart of a process for managing an image storage space tree for processing a new image according to an exemplary embodiment.

[0024] [Figure 17] A block diagram of a data processing system according to an exemplary embodiment.

Best Mode for Carrying Out the Invention

[0025] Exemplary embodiments recognize and consider multiple different considerations. For example, when attempting to reduce storage space, exemplary embodiments recognize and consider that it may be difficult to handle images with some overlapping parts. Those embodiments recognize and consider that it is necessary to store all images even if there are overlapping parts between images. Exemplary environments recognize and consider that this situation is a common problem in different scenarios including cloud storage, social networking platforms, image recognition training data, and other scenarios.

[0026] Therefore, it is desirable to have computer implementation methods, apparatus, computer systems, and computer program products that take into account at least some of the above-mentioned problems, as well as other possible problems. For example, it is desirable to have methods and apparatus that overcome the technical problems associated with managing image storage in a single location when there are overlapping portions between images.

[0027] The present invention may be an integrated system, method, and / or computer program product at any possible level of technical detail. The computer program product may include a computer-readable storage medium (or a set of mediums) having computer-readable program instructions thereon for causing a processor to perform aspects of the present invention.

[0028] A computer-readable storage medium can be a tangible device capable of holding and storing instructions for use by an instruction-executing device. A computer-readable storage medium may, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any preferred combination thereof. A non-exclusive list of more specific examples of computer-readable storage media may include: portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital multipurpose disks (DVDs), memory sticks, floppy disks, mechanically encoded devices such as punch cards or grooved raised structures on which instructions are recorded, and any preferred combination thereof. When used herein, computer-readable storage media shall not be interpreted as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through optical fiber cables), or electrical signals transmitted through wires.

[0029] The computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to each computing / processing device, or they may be downloaded to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, and / or a wireless network. The network may include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface within each computing / processing device receives computer-readable program instructions from the network and transfers such computer-readable program instructions for storage in a computer-readable storage medium within each computing / processing device.

[0030] The computer-readable program instructions for performing the operations of the present invention may be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, configuration data for integrated circuits, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk® or C++, and procedural programming languages ​​such as the C programming language or similar programming languages. The computer-readable program instructions may be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider). In some embodiments, to carry out aspects of the present invention, an electronic circuit including, for example, a programmable logic circuit, a field-programmable gate array (FPGA), or a programmable logic array (PLA) can execute a computer-readable program instruction by personalizing the electronic circuit using state information of the computer-readable program instruction.

[0031] Aspects of the present invention are described herein with reference to flowcharts and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the present invention. It will be understood that each block in the flowcharts and / or block diagrams, and combinations of blocks in the flowcharts and / or block diagrams, can be implemented by computer-readable program instructions.

[0032] These computer-readable program instructions may be provided to a computer processor or other programmable data processing device that generates machines, thereby creating means for implementing functions / operations specified in one or more blocks of a flowchart and / or block diagram. These computer-readable program instructions may also be stored on a computer-readable storage medium, which may instruct a computer, programmable data processing device and / or other device to function in a particular manner, thereby providing a product containing instructions that implement modes of functions / operations specified in one or more blocks of a flowchart and / or block diagram.

[0033] Computer-readable program instructions may also be loaded into a computer, other programmable data processing device, or other device to execute a series of operational steps on the computer, other programmable device, or other device to generate a computer implementation process, thereby enabling the instructions executed on the computer, other programmable device, or other device to implement a function / operation specified in one or more blocks of a flowchart and / or block diagram.

[0034] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of the system, method, and computer program product according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagram may represent a module, segment, or portion of instructions containing one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions described within a block may occur in an order different from the order shown in the drawings. For example, two consecutively shown blocks may actually be realized as a single stage, executed simultaneously, substantially simultaneously, partially or entirely, or in a manner that overlaps in time, or blocks may, in some cases, be executed in reverse order depending on the functions involved. It should also be noted that each block in the block diagram and / or flowchart, and combinations of blocks in the block diagram and / or flowchart, may be implemented by a dedicated hardware-based system that performs a specified function or operation, or executes a combination of dedicated hardware and computer instructions.

[0035] While this disclosure includes a detailed description of cloud computing, it should be understood that the implementations of the teachings enumerated herein are not limited to cloud computing environments. Rather, embodiments of the present invention can be implemented in conjunction with any other type of computing environment currently known or to be developed in the future.

[0036] Cloud computing is a service delivery model that enables convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and deployed with minimal management effort or interaction with service providers. This cloud model may include at least five characteristics, at least three service models, and at least four deployment models.

[0037] The characteristics are as follows:

[0038] On-demand self-service: Cloud consumers can unilaterally provision computing power, such as server time and network storage, automatically as needed, without requiring human interaction with service providers.

[0039] Broad network access: Capabilities are available over the network and accessed through standard mechanisms that facilitate use by heterogeneous thin-client or thick-client platforms (e.g., mobile phones, laptops, and PDAs®).

[0040] Resource pooling: A provider's computing resources are pooled to serve multiple consumers using a multi-tenant model, with different physical and virtual resources dynamically allocated and reallocated according to demand. Consumers generally do not have control or knowledge of the exact location of the resources provided, but they may be able to specify the location at a higher level of abstraction (e.g., country, state, or data center), thus demonstrating location independence.

[0041] Rapid resilience: Capabilities are provisioned quickly and flexibly, sometimes automatically, allowing for rapid scaling out or rapid release and rapid scaling in. To consumers, the available capacity for provisioning often appears unlimited and can be purchased in any quantity at any time.

[0042] Measurement Services: Cloud systems automatically control and optimize resource usage by leveraging measurement capabilities appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts) at a certain level of abstraction. Resource usage can be monitored, controlled, and reported, thereby providing transparency to both service providers and consumers.

[0043] The service model is as follows:

[0044] Software as a Service (SaaS): The capability offered to consumers is the use of a provider's applications running on cloud infrastructure. These applications are accessible from various client devices through thin client interfaces such as web browsers (e.g., web-based email). Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, storage, or even individual application capabilities, with the conceivable exception of limited, user-specific application configuration settings.

[0045] Platform as a Service (PaaS): The capability offered to consumers is the ability to deploy applications they have created or acquired, written using programming languages ​​and tools supported by the provider, onto a cloud infrastructure. Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but they have control over the deployed applications and, in some cases, the configuration of the application hosting environment.

[0046] Infrastructure as a Service (IaaS): The ability provided to consumers is to provision processing, storage, networking, and other basic computing resources, allowing consumers to deploy and run any software, including operating systems and applications. Consumers do not manage or control the underlying cloud infrastructure, but they have control over the operating system, storage, and deployed applications, and in some cases, limited control over selected networking components (e.g., host firewalls).

[0047] The deployment model is as follows:

[0048] Private Cloud: Cloud infrastructure is operated solely for the benefit of an organization. It may be managed by the organization or a third party, and may reside on-premises or off-premises.

[0049] Community Cloud: A cloud infrastructure is shared by multiple organizations to support a specific community that shares common interests (e.g., mission, security requirements, policies, and compliance considerations). It may be managed by those organizations or third parties and may reside on-premises or off-premises.

[0050] Public cloud: Cloud infrastructure is made available to the general public or large industry groups and is owned by organizations that sell cloud services.

[0051] Hybrid Cloud: This cloud infrastructure is a combination of two or more clouds (private, community, or public) that remain unique entities but are joined together by standardized or proprietary technologies that enable data and application portability (e.g., cloud bursting for load balancing across clouds).

[0052] Cloud computing environments are service-oriented, emphasizing statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing lies an infrastructure that includes a network of interconnected nodes.

[0053] Referring here to Figure 1, a diagram is shown illustrating a cloud computing environment in which an exemplary embodiment may be implemented. In this exemplary example, the cloud computing environment 100 includes a set of one or more cloud computing nodes 110 to which local computing devices used by cloud consumers, such as a personal digital assistant or smartphone 120A, a desktop computer 120B, a laptop computer 120C, and / or an automotive computer system 120N, can communicate.

[0054] The cloud computing nodes 110 may communicate with each other and may be physically or virtually grouped into one or more networks, such as private clouds, community clouds, public clouds, or hybrid clouds, or combinations thereof, as described above. This enables the cloud computing environment 100 to provide infrastructure, platforms, and / or software as a service, which does not require cloud consumers to maintain resources on local computing devices such as local computing devices 120A-120N. The types of local computing devices 120A-120N are intended to be illustrative only, and it is understood that the cloud computing nodes 110 and the cloud computing environment 100 may communicate with any type of computerized device via any type of network and / or network addressable connections, such as using a web browser.

[0055] Referring now to Figure 2, a diagram illustrating an abstraction model layer according to an exemplary embodiment is shown. The set of functional abstraction layers shown in this exemplary example may be provided by a cloud computing environment, such as cloud computing environment 100 in Figure 1.

[0056] As used herein, “set of ~” means one or more items when used in reference to an item. For example, “set of functional abstractions” is one or more functional abstractions.

[0057] It should be understood in advance that the components, layers, and functions shown in Figure 2 are for illustrative purposes only, and embodiments of the present invention are not limited thereto. The following layers and corresponding functions are provided as described.

[0058] The abstraction layer 200 of the cloud computing environment includes a hardware and software layer 202, a virtualization layer 204, a management layer 206, and a workload layer 208. The hardware and software layer 202 includes hardware and software components of the cloud computing environment. Hardware components may include, for example, a mainframe 210, a RISC (Reduced Instruction Set Computer) architecture-based server 212, a server 214, a blade server 216, a storage device 218, and network and networking components 220. In some exemplary embodiments, software components may include, for example, network application server software 222 and database software 224.

[0059] The virtualization layer 204 provides an abstraction layer that may provide the following examples of virtual entities: virtual servers 226; virtual storage 228; virtual networks 230 including virtual private networks; virtual applications and operating systems 232; and virtual clients 234.

[0060] In one example, the management layer 206 may provide the functions described below. Resource provisioning 236 provides dynamic procurement of computing and other resources used to perform tasks within the cloud computing environment. Measurement and pricing 238 provides cost tracking as resources are used within the cloud computing environment and billing or invoicing for the consumption of these resources. In one example, these resources may include application software licenses. Security provides identity verification of cloud consumers and tasks, as well as protection of data and other resources. User portal 240 provides consumers and system administrators with access to the cloud computing environment. Service level management 242 provides cloud computing resource allocation and management to ensure that required service levels are met. Service level agreement (SLA) planning and execution 244 provides advance preparation and procurement of cloud computing resources where future requirements are anticipated in accordance with the SLA.

[0061] The workload layer 208 provides examples of functions that may be available in a cloud computing environment. For example, workloads and functions that may be provided by the workload layer 208 may include mapping and navigation 246, software development and lifecycle management 248, virtual classroom education delivery 250, data analysis processing 252, transaction processing 254, and image management 256.

[0062] In this exemplary example, the image management system 256 manages the storage of images in the cloud computing environment 100. The image management system 256 can manage storage in a manner that reduces the storage space required for images that have some overlapping parts.

[0063] Referring now to Figure 3, a graphical representation of a network of a data processing system in which an exemplary embodiment may be implemented is shown. The network data processing system 300 is a network of computers in which an exemplary embodiment may be implemented. The network data processing system 300 houses a network 302, which is a medium used to provide communication links between various devices and computers connected together within the network data processing system 300. The network 302 may include connections such as wired, wireless, or fiber optic cables.

[0064] In the example described, server computers 304 and 306 are connected to network 302 along with storage unit 308. In addition, client devices 310 are connected to network 302. As described, client devices 310 include client computers 312, 314, and 316. Client devices 310 may be, for example, computers, workstations, or network computers. In the example described, server computer 304 provides client devices 310 with information such as boot files, operating system images, and applications. Furthermore, client devices 310 may also include other types of client devices, such as mobile phones 318, tablet computers 320, and smart glasses 322. In this exemplary example, server computers 304, 306, storage unit 308, and client devices 310 are network devices connected to network 302, where network 302 is the communication medium for these network devices. Some or all of the client devices 310 may form the Internet of Things (IoT), in which these physical devices can connect to a network 302 and exchange information with each other over the network 302.

[0065] In this example, client device 310 is a client of server computer 304. The network data processing system 300 may include additional server computers, client computers, and other devices not shown. Client device 310 connects to network 302 using at least one of wired, fiber optic, or wireless connections.

[0066] Program code located within the network data processing system 300 can be stored on a computer recordable storage medium and downloaded to the data processing system or other devices for use. For example, program code can be stored on a computer recordable storage medium on the server computer 304 and downloaded to the client device 310 via the network 302 for use on the client device 310.

[0067] In the example described, the network data processing system 300 is the Internet, using network 302, which represents a global collection of networks and gateways communicating with each other using the Transmission Control Protocol / Internet Protocol (TCP / IP) protocol suite. At the core of the Internet is a backbone of high-speed data communication lines between major nodes or host computers, consisting of thousands of commercial, government, educational, and other computer systems routing data and messages. Naturally, the network data processing system 300 can also be implemented using several different types of networks. For example, network 302 could consist of at least one of the following: the Internet, an intranet, a local area network (LAN), a metropolitan area network (MAN), or a wide area network (WAN). Figure 3 is intended as an example, not as an architectural limitation for different exemplary embodiments.

[0068] As used herein, “multiple” means one or more items when used in reference to an item. For example, “multiple different types of networks” means one or more different types of networks.

[0069] Furthermore, the phrase "at least one of" when used with a list of items means that one or more different combinations of the listed items may be used, and that only one of each item in the list may be required. In other words, "at least one of" means that any combination and any number of items from the list may be used, but not all of the items in the list may be required. An item can be a specific object, thing, or category.

[0070] For example, but not limited to, “at least one of item A, item B, or item C” could include item A, item A and item B, or item B. This example could also include item A, item B, and item C, or item B and item C. Naturally, any combination of these items is possible. In some exemplary examples, “at least one of ~” could be, for example, two of item A, one of item B, ten of item C, four of item B, and seven of item C, or other preferred combinations.

[0071] In this exemplary example, the image management system 330 may manage the storage of images 332 in a storage area network (SAN) 334. The storage area network 334 is a network of storage devices that can be accessed via network 302. As described, when storing images 332, the image management system 330 may manage the image storage space 336 in the storage area network 334.

[0072] As described, the image management system 330 can handle the storage of images 332 with overlapping areas using less space than it would take to store all images with overlapping areas. For example, both the first image 338 and the second image 340 can be divided into blocks. This division of the first image 338 and the second image 340 can be performed such that the second image 340 has blocks corresponding to the blocks in the first image 338. For example, both images can be divided into 2x2 so that each image has 4 blocks. This example assumes that both images have the same size. This division of the first image 338 and the second image 340 can be performed such that each block in the first image 338 has a corresponding block in the second image 340.

[0073] In managing the image storage space 336, the image management system 330 may store the first image 338 in the storage area network 334. With respect to the second image 340, the image management system 330 may compare a block in the second image 340 with a corresponding block in the first image 338. If a block in the second image 340 is the same as the corresponding block in the first image 338, that block in the second image 340 is not stored in the storage area network 334. If a block in the second image 340 is similar to but not identical to the corresponding block in the first image 338, that block in the second image 340 is stored in the storage area network 334. Metadata may also be stored for the block in the second image 340 to identify the correspondence between the stored block and the corresponding block in the first image 338. As a result, less storage space is required to handle images that are sufficiently similar and may be duplicates of each other.

[0074] In this example, the analysis can be facilitated by using an image mapping tree 342 having layers that provide the ability to map blocks stored in the second image 340 to corresponding blocks in the first image 338. As a result, the amount of space required in the image storage space 336 to store image 332 can be reduced if similar images exist within image 332.

[0075] This reduction in the use of image storage space 336 may provide the ability to store more images in the same amount of storage space. Furthermore, when similar images are transferred over the network 302, the speed of image transfer may be improved through the ability to transfer only portions of the image.

[0076] A diagram illustrating the management of images 332 and the storage area network 334 by the image management system 330 is presented as one possible form in which the storage of images 332 can be managed, according to an exemplary example. This example is not intended to limit the forms in which other examples can be implemented. For example, in another relative example, a solid-state disk drive connected to a server computer 304 may be used instead of the storage area network 334. Furthermore, in yet another exemplary example, multiple storage components distributed through a network 302 may store images 332.

[0077] Referring now to Figure 4, a block diagram of an image environment according to an exemplary embodiment is shown. In this exemplary example, the image environment 400 includes components that may be implemented in hardware, such as the hardware shown in the network data processing system 300 in Figure 3. The image management system 402 may manage images 404 in the image environment 400.

[0078] As described, the image management system 402 comprises a computer system 406 and an image manager 408. The image manager 408 is located within the computer system 406.

[0079] In this exemplary example, the image manager 408 may be implemented in software, hardware, firmware, or a combination thereof. If software is used, the operations performed by the image manager 408 may be implemented in program instructions configured to run on hardware such as a processor unit. If firmware is used, the operations performed by the image manager 408 may be implemented in program instructions and data, and stored in persistent memory to run on a processor unit. If hardware is employed, the hardware may include circuitry that operates to perform the operations in the image manager 408.

[0080] In exemplary examples, the hardware can take the form of at least one of a circuit system, an integrated circuit, an application-specific integrated circuit (ASIC), a programmable logic device, or any other suitable type of hardware configured to perform multiple operations. In the case of a programmable logic device, the device may be configured to perform multiple operations. The device may be reconfigured at a later time, or it may be permanently configured to perform multiple operations. Programmable logic devices include, for example, programmable logic arrays, programmable array logic, field-programmable logic arrays, field-programmable gate arrays, and other suitable hardware devices. In addition, the process can be implemented in organic components integrated with inorganic components, or it can consist entirely of organic components without human intervention. For example, the process can be implemented as a circuit in an organic semiconductor.

[0081] The computer system 406 is a physical hardware system and includes one or more data processing systems. If there are more than one data processing systems in the computer system 406, those data processing systems communicate with each other using a communication medium. The communication medium may be a network. The data processing systems may be selected from at least one of computers, server computers, tablet computers, or any other suitable data processing systems.

[0082] As described, the computer system 406 includes a plurality of processor units 410 capable of executing program instructions 412 that implement the process in the exemplary example. As used herein, a processor unit in the plurality of processor units 410 is a hardware device and consists of hardware circuits, such as those on an integrated circuit, that process instructions and program code that operate the computer. When the plurality of processor units 410 execute program instructions 412 for a process, the plurality of processor units 410 are one or more processor units that may be on the same computer or different computers. In other words, the process may be distributed among processor units on the same or different computers within the computer system. Furthermore, the plurality of processor units 410 may be of the same or different types of processor units. For example, the plurality of processor units may be at least one of a single-core processor, a dual-core processor, a multi-core processor, a central processing unit (CPU), a graphics processing unit (GPU), a digital signal processor (DSP), or some other type of processor unit.

[0083] In this example, the image manager 408 uses the image mapping tree 414 to manage the image storage space 416 in the storage system 418 for storing the image 404. As depicted, the storage system 418 may consist of one or more storage devices. For example, the storage system 418 may include at least one of the following: network attached storage (NAS), storage area network (SAN), memory, disk drive, solid-state (SSD), disk array, or other types of storage. If there are more than one storage component, those components may be connected to each other through communication links or networks.

[0084] In the exemplary example, the image manager 408 identifies a benchmark image 420 within a similar image group 422. In this exemplary example, the similar image group 422 contains two or more images 404. Multiple other images within the similar image group 422 that were not identified as the benchmark image 420 constitute a set of similar images 424. In this modified example, images within the set of similar images 424 can be considered similar because portions of these images may be the same between two or more images within the similar image group 422.

[0085] In this modified example, the benchmark image 420 can be determined from multiple similar images within a similar image group 422 based on the minimum overall difference between multiple similar images. In this example, the multiple similar images include the benchmark image 420 and a set of similar images 424 within the similar image group 422. For example, the minimum overall difference can be determined using at least one of the following methods: RGB color histogram, keypoint matching, image hashing, bit calculation, or other preferred techniques.

[0086] The image manager 408 creates an image mapping tree 414. In this example, the image mapping tree 414 has a hierarchical structure.

[0087] As described, the image mapping tree 414 has a root block 428 for the benchmark image 420, and blocks 430 arranged in a set of layers 432 below the root block 428 based on a set of similar images 424. In this exemplary example, block 430 represents a portion of the benchmark image 420. Multiple subblocks 434 within block 430 in the lower layer 436 correspond to sub-partitions 438 within upper block 440 within block 430 in the upper layer 442. In this exemplary example, multiple subblocks 434 can be subsets of block 430 in the lower layer 436. For example, if a block in the upper layer 442 is divided into four sub-partitions, then multiple blocks 430 corresponding to the block in the upper layer 442 exist in the lower layer 436. Each of these multiple blocks 430 represents several corresponding blocks in the upper layer 442.

[0088] In this exemplary example, each block within block 430 represents a portion or sub-section of the benchmark image 420. Blocks 430 in lower layers have a higher granularity compared to blocks 430 in upper layers within layer 432 of the image mapping tree 414. In other words, blocks in lower layer 436 correspond to smaller portions of the benchmark image 420 compared to blocks in upper layer 442.

[0089] In creating the image mapping tree 414, the image manager 408 divides the benchmark image 420 to form sub-partitions 444 within the benchmark image 420. Each sub-partition may correspond to a block 430 within layer 432. The image manager 408 creates a layer 442 above the upper block 440 within the layer below the root block 428, where each upper block within the upper block 440 corresponds to a sub-partition within sub-partition 444 in the benchmark image 420.

[0090] The image manager 408 can determine the number of similar images 424 in a set of similar images 424 that have different similar blocks 446 from the corresponding upper block 448 in the upper block 440, in order to form a set of corresponding upper blocks 448. The image manager 408 can divide each corresponding upper block in the set of corresponding upper blocks 448 into sub-compartments 438. In addition, the image manager 408 can create a lower layer 436 of lower blocks 434, where each lower block in lower block 434 corresponds to a sub-compartment in a sub-compartment 438 in the set of corresponding upper blocks 448.

[0091] The number of blocks 430 formed by dividing a top block may be based on the number of similar images 424 that have similar top blocks to the top block being divided. For example, if the top block being divided has five similar images that have that top block, the top block may be divided into nine subblocks. As another example, if the top block being divided has two similar images that have that top block, the top block may be divided into four subblocks. In other exemplary cases, the top block may be divided into 16, 25, 36, or any other number of blocks 430. As a result, the number of blocks created by the division may be based on the number of similar images that have similar top blocks to be divided.

[0092] In this exemplary example, when creating a subsequent sublayer 450, the lower block 434 becomes the upper block 440 when the determination, division, and creation steps are performed to form the subsequent sublayer 450. This determination, division, and creation process can be repeated a different number of times to form the subsequent sublayer.

[0093] The number of subsequent sublayers created can be determined based on the storage reduction and processing resources used. As the number of sublayers increases, the time to reach the image mapping tree 414 increases, and the size of the metadata used to store the blocks increases. These factors can be used to determine how many subsequent sublayers will be created. Considerations that compare how much storage for the image is reduced by creating additional sublayers with the amount of processing resources used to create those layers, traverse the image mapping tree 414 with those layers, and collect and store the metadata can be used to determine how many subsequent sublayers will be used. These parameters can be used to generate conditions for determining how many sublayers will be created. These conditions may include, for example, at least one of the following: a ratio of time to space, a time threshold, and a threshold for the maximum number of layers in the image mapping tree 414.

[0094] Using the image mapping tree 414, portions of the set of similar images 424 can be mapped to the benchmark image 420. In an exemplary example, the image manager 408 may store in the set of similar images 424 a set of selected blocks 452 that have differences from the corresponding set of blocks 454 in the image mapping tree 414 for the benchmark image 420. Blocks 456 from the similar images 424, rather than the entire image, may be stored. Blocks 456 correspond to blocks or sub-partitions 444 for the benchmark image 420. In other words, portions of the image that are not exactly the same as the corresponding portion of the benchmark image 420 are stored.

[0095] In addition, the image manager 408 stores metadata 458 about a selected set of blocks 452 that describes a set of paths 460 within the image mapping tree 414 from a corresponding set of blocks 454 within the image mapping tree 414 to the root block 428.

[0096] Furthermore, the image mapping tree 414 can be used to store new images. For example, the image manager 408 may store in the image mapping tree 414 a new set of blocks 462 for a new image 464, which is different from the new set of corresponding blocks 466 for the benchmark image 420. In addition, the image manager 408 may store new metadata 470 for a new set of blocks 462 that describes a new set of paths 468 from the new set of corresponding blocks 466 in the image mapping tree 414 to the root block 428 for the benchmark image 420 in the image mapping tree 414.

[0097] Furthermore, the image manager 408 can selectively store new images. For example, the image manager 408 can store a new set of images using the image mapping tree 414 if the new set of images is less than a new image threshold for images in the image mapping tree 414. If the new set of images exceeds the maximum image threshold for images in the image mapping tree 414, the image manager 408 can recreate the image mapping tree 414 using the new set of images and the images 404 in the similar image group 422, provided that the new set of images is equal to or greater than the new image threshold.

[0098] In an exemplary example, there exists one or more technical solutions that overcome the technical problems related to image storage space when storing images. As a result, one or more technical solutions may provide a technical effect that reduces the amount of storage space required to store similar images that do not overlap with each other. In an exemplary example, there exists one or more technical solutions that provide a technical effect that enables the storage of parts of an image different from a benchmark image, such that the image storage space required to store an image and a benchmark image is reduced compared to current techniques for storing images. Furthermore, one or more technical solutions may also be used in conjunction with current techniques for reducing the use of image storage space, such as image compression techniques. In addition, one or more technical solutions provide a technical effect that reduces the amount of image storage space required. As a result, the exemplary embodiment provided a technical effect that enables the reduction of storage for similar images through the use of an image mapping tree for storing blocks of similar images and metadata about those blocks, such that only parts of the image are stored.

[0099] Computer system 406 may be configured to perform at least one of the steps, operations, or actions described in different exemplary examples using software, hardware, firmware, or a combination thereof. As a result, computer system 406 operates as a dedicated computer system, enabling the image manager 408 within computer system 406 to manage storage space using a decision tree and store similar images more efficiently. In particular, the image manager 408 transforms computer system 406 into a dedicated computer system compared to currently available general-purpose computer systems that do not have the image manager 408.

[0100] In an exemplary example, the use of the image manager 408 within the computer system 406 integrates the process into a practical application for managing image storage space, improving the performance of the computer system 406 by allowing similar images to use less storage space through storing portions of similar images that are similar to corresponding portions of a benchmark image, while not storing other portions of similar images that are identical to the corresponding portions of the benchmark image. In other words, the image manager 408 within the computer system 406 targets a practical application of the process integrated into the image manager 408 within the computer system 406, where one or more image mapping trees store images. The use of decision trees allows the decision tree to store portions of images that are similar to other images from which it was created. In an exemplary example, the decision tree allows the image manager 408 to store blocks about portions of an image. As the decision tree has more layers, an increase in granularity is exhibited, and as a result, the amount of image storage space used can be increasingly saved.

[0101] In this exemplary example, the image manager 408 within the computer system 406 can store images using a decision tree in a manner that improves the performance of the computer system 406, and in particular, improves the utilization of storage space for storing images in the computer system 406. In this way, the image manager 408 within the computer system 406 provides a practical application for managing image storage space to improve the functionality of the computer system 406.

[0102] The explanatory diagram of the image environment 400 in Figure 4 is not intended to suggest any physical or architectural limitations on how the exemplary embodiment may be implemented. Other components may be used in addition to or instead of those shown. Some components may be unnecessary. Also, the blocks are presented to show several functional components. One or more of these blocks may be combined, separated, or combined and separated into different blocks when implemented in the exemplary embodiment.

[0103] For example, in addition to or instead of image mapping tree 414, one or more image mapping trees may be created and exist. In this example, different image mapping trees may have different benchmark images for different groups of similar images. In this way, new images can be matched with the appropriate image mapping tree to improve efficiency and store the new images.

[0104] Referring now to Figure 5, an explanatory diagram of a similar image group according to an exemplary embodiment is shown. For example, similar image group 500 is an example of similar image group 422 shown in block form in Figure 4. In this exemplary example, similar image group 500 includes four images: benchmark image 502, image 1 504, image 2 506, and image 3 508. Benchmark image 502 is an example of benchmark image 420 in Figure 4. Image 1 504, image 2 506, and image 3 508 are examples of similar images 424 in Figure 4.

[0105] As depicted, benchmark image 502 can be divided or subdivided into smaller sections. In this example, the smaller sections are four blocks: block 1 510, block 2 512, block 3 514, and block 4 516. In this illustrative example, these blocks may also be referred to as smaller sections.

[0106] In the illustrative example, images 1 504, 2 506, and 3 508 are also divided into blocks corresponding to blocks created by dividing benchmark image 502 for comparison to determine which parts of these images should be stored and which parts do not need to be stored. A comparison is performed to determine if a block from a particular image is different from its corresponding block in benchmark image 502.

[0107] In this illustrative example, Figure 1 504 has four blocks: block 1 518, block 2 520, block 3 522, and block 4 524. As depicted, block 1 518 corresponds to block 1 510, block 2 520 corresponds to block 2 512, block 3 522 corresponds to block 3 514, and block 4 524 corresponds to block 4 516.

[0108] In this particular example, block 1 518 is the same as block 1 510, block 2 520 is the same as block 2 512, and block 4 524 is the same as block 4 516. However, between image 1 504 and benchmark image 502, block 3 522 is not the same as block 3 514.

[0109] When storing Image 1 504, blocks 1 518, 2 520, and 4 524 do not need to be stored because they are the same as the corresponding blocks created by subdividing benchmark image 502. Block 3 522 in Image 1 504 is stored because it is not the same as block 3 514, which is the corresponding block in benchmark image 502.

[0110] In this exemplary example, further subdivision of blocks 3 514 and 3 522 for comparison can lead to further savings in storing image 1 504. In this example, each of these blocks can be divided into nine blocks, the corresponding blocks of which are compared with each other. In this comparison, all blocks are the same except for block 530 in image 1 504 and block 532 in benchmark image 502 within their corresponding blocks. As a result, this further subdivision of the blocks increases the granularity and reduces the amount of storage required.

[0111] Image identification, and the identification of sub-partitions in the form of blocks created by dividing the image, can be managed using an image mapping tree. This image mapping tree can be used to identify the location of stored blocks and images relative to the corresponding blocks formed by subdividing the benchmark image 502.

[0112] In this example, block 534 in image 2 506 is saved along with metadata that identifies block 535 in benchmark image 502, whose location is the corresponding block. In another example, blocks 536 and 538 are saved in image 3 508. Once a mapping of corresponding boxes between image 3 508 and benchmark image 502 is provided, metadata that identifies the corresponding locations, blocks 540 and 542, and benchmark image 502 is saved.

[0113] Referring to Figure 6, an image mapping tree according to an exemplary embodiment is shown. In a social example, the image mapping tree 600 is an example of the image mapping tree 414 shown in block form in Figure 4. The image mapping tree 600 can be created using the similar image group 500 in Figure 5.

[0114] As depicted, the image mapping tree 600 has a root block 602 and a layer 604. In this example, layer 604 includes a first layer 606 and a second layer 608. The first layer 606 is an example of the upper layer 442 in Figure 4, and the second layer 608 is an example of the lower layer 436 in Figure 4.

[0115] Each successive layer provides additional granularity for subdividing the image. For example, the benchmark image 502 in Figure 5 can be subdivided into four blocks or subdivisions of the root block 602 in the image mapping tree 600. These subdivisions of the benchmark image 502 into four subdivisions can be represented by blocks in the first layer 606. As depicted, the first layer 606 includes blocks 1 610, 2 612, 3 614, and 4 616. Each of these blocks corresponds to a subdivision of the benchmark image 502 within the root block 602.

[0116] In the second layer 608, the blocks in the first layer 606 may be further divided into additional sub-partitions such that the group of blocks in the second layer 608 corresponds to the sub-partitions within the blocks in the first layer 606. For example, block 1 610 in the first layer 606 may be divided into four sub-partitions. The sub-partitions of block 1 610 are represented in the second layer 608 as a group of blocks including block 1 620, block 2 622, block 3 624, and block 4 626. In other words, these four blocks in the second layer 608 have corresponding sub-partitions within block 610.

[0117] The number of subdivisions created for each block in the first layer 606 must be the same. As depicted, block 614 can be subdivided into nine subdivisions instead of four. As a result, the group of blocks for block 614 could be nine blocks in the second layer 608. In this example, only one of the nine blocks, block 7 628, and the second layer 608 are shown. Furthermore, the group of blocks for block 2 612 and block 4 616 are also not shown in this explanatory diagram of the image mapping tree 600. These other blocks are not shown in the second layer 608 to avoid obscuring the explanatory diagram and description of the features in the exemplary example.

[0118] In this example, each block at each level has an identifier that indicates the block's position relative to the corresponding block at a higher level. These identifiers can be used to generate metadata that identifies the path from the blocks stored for the image to the root block. These identifiers and paths can be used to identify a specific block in benchmark image 502 that corresponds to the blocks stored for the image without storing the entire image.

[0119] For example, block 1 610 has label [4.1], block 2 612 has label [4.2], block 3 614 has label [4.3], and block 4 616 has label [4.4]. Another example is block 7 628, which has label [9.7]. In this example, the first number in the label indicates the existence of a subdivision from a block in a higher layer. The second number in the label indicates the location of the block within the subdivision.

[0120] For example, in Figure 5, for image 1 504, the location of block 530 within image 1 504 and the location of this block within benchmark image 502 may be represented as a new block [4.3, 9.7]. This metadata indicates the path from block 7 628 to block 1 614, and then to root block 602. As a result, block 530 may be stored with metadata in this example, the metadata being a reference to benchmark image 502 and the new block [4.3, 9.7].

[0121] Next, referring to Figure 7, metadata used to describe blocks stored for images according to an exemplary embodiment is shown. Metadata 700 is an example of metadata 458 shown in block form in Figure 4. In this exemplary example, metadata 700 is generated by storing images 1 504, 2 506, and 3 508 in Figure 5 using the image mapping tree 600 in Figure 6.

[0122] As described, metadata 700 can be organized as tables 702 and 704. Table 702 identifies benchmark images. Table 702 has columns containing benchmark image ID 706 and image path 708. Benchmark image ID 706 identifies the benchmark image, and image path 708 identifies the location of the benchmark image.

[0123] In an exemplary example, Table 704 has columns containing Image ID 710, Image Name 712, Benchmark ID 714, and Path 716. Image ID 710 identifies the image, and Image Name 712 is the name of the saved image. Benchmark ID 714 identifies the benchmark image of the saved image. Path 716 identifies the path from the block saved for the image identified by Image ID 710 and Image Name 712 to the benchmark image identified by Benchmark ID 714. This path provides identification of the sub-section in the benchmark image corresponding to the block saved for the image.

[0124] In this exemplary example, line 718 is for the benchmark image. Line 720 is metadata for image 1 504 in Figure 5. In this example, block 530 in image 1 520 is stored with this metadata. In line 720, the path from block 628 through block 614 to root block 602 is identified so that the corresponding block for block 530 and the sub-block for block 535 in benchmark image 502 can be identified. As a result, reconstruction of image 1 520 can be performed by using all the blocks from benchmark image 502 and inserting block 530 into the benchmark image 502 at the location and using the location identified by the path in line 720.

[0125] As described, line 722 pertains to image 2 506 in Figure 5. In this example, block 534 in image 2 506 is stored with this metadata, identifying the path from block 620 through block 610 to root block 602. This metadata in line 722 allows for the recreation of image 2 506 using benchmark image 502 and block 534 stored for image 2 506.

[0126] As another example, line 724 pertains to image 3 508 in Figure 5. Blocks 536 and 538 are saved for image 3 508. The metadata in line 724 describes the correspondence between these blocks and block 540 in block 542 in benchmark image 502. The path in line 724 identifies a path in the image mapping tree 600 that allows us to know the corresponding location for these blocks in order to reconstruct image 3 508 from benchmark image 502 using blocks 536 and 538 saved for image 3 508.

[0127] The depiction of metadata 700 in the table is presented as an example of the form in which metadata 700 may be implemented. In another exemplary example, metadata 700 may be organized using other types of data structures, including arrays, flat files, containers, or some other preferred type of data structure.

[0128] Figure 8 shows the mapping of a new image to an image mapping tree according to an exemplary embodiment. In the exemplary example, the same reference number may be used in more than one figure. Such reuse of reference numbers in different figures represents the same element in different figures.

[0129] In this example, the new image 800 has a size of 12 MB and can be stored using the image mapping tree 600. In this example, the new image 800 can be stored using either the first layer 606 or the second layer 608 within the image mapping tree 600. The second layer 608 provides increased granularity, resulting in the new image 800 being stored using less storage space.

[0130] For example, if the first layer 606 is used, blocks 802 and 804 with metadata generated using the first layer 606 may be saved so that only a portion of the new image 800 is saved. The metadata includes a reference to benchmark image 502. The metadata also includes that the path for block 802 is [4.2] and the path for block 802 is [4.3]. Each of these blocks is 3MB in size, and saving these two blocks uses 6MB of storage space compared to 12MB.

[0131] If a second layer 608 is used, the new image 800 may be further subdivided so that blocks 806 and 808 are stored instead of blocks 802 and 804. The metadata includes a reference to benchmark image 502. The metadata also includes that the path for block 806 is [4.1, 4.1] and the path for block 808 is [4.4, 9.7]. In this example, block 806 is 3 / 4MB and block 808 is 3 / 9MB, totaling 13 / 12MB, resulting in greater savings than using the first layer 606.

[0132] Referring now to Figure 9, a flowchart of a process for managing an image storage space tree according to an exemplary embodiment is shown. The process in Figure 9 can be implemented in hardware, software, or both. When implemented in software, the process may take the form of program instructions executed by one or more processor units located in one or more hardware devices within one or more computer systems. For example, the process may be implemented in the image manager 408 within the computer system 406 in Figure 4.

[0133] The process begins by identifying a benchmark image within a group of similar images (stage 900). In stage 900, several other images within the group of similar images that were not identified as benchmark images constitute a set of similar images. In stage 900, it may be performed to identify a benchmark image from several similar images based on the minimum overall difference between the several similar images. In an exemplary example, the minimum overall difference is determined using at least one of the following methods: RGB color histogram, keypoint matching, image hashing, or bitwise computation.

[0134] The process creates an image mapping tree (stage 902). The image mapping tree in stage 902 has a root block for the benchmark image, and blocks arranged in a set of layers below the root block based on a set of similar images. A block represents a portion of the benchmark image, and multiple subblocks within a block in a lower layer correspond to sub-parts within a block in a higher layer.

[0135] The process stores a set of selected blocks in a set of similar images that have differences from the corresponding set of blocks in the image mapping tree for the benchmark image (step 904). The process stores metadata for the selected set of blocks that describes the set of paths in the image mapping tree from the corresponding set of blocks to the root block (step 906). The process then terminates. The metadata may include a set of image identifiers for the selected set of blocks, references to the benchmark image, and a set of paths in the image mapping tree from the corresponding set of blocks to the root block.

[0136] Referring to Figure 10, a flowchart of the process for storing a new image is shown according to an exemplary embodiment. This flowchart is an example of additional steps that may be performed in the process shown in Figure 9.

[0137] The process stores in the image mapping tree a new set of blocks for a new image that is different from the new set of corresponding blocks in the benchmark image (step 1000). The process stores in the image mapping tree new metadata for the new set of blocks that describes a new set of paths from the new set of corresponding blocks in the image mapping tree to the root block for the benchmark image (step 1002). The process then terminates.

[0138] Next, referring to Figure 11, a flowchart of a process for processing a new set of images is shown according to an exemplary embodiment. This flowchart is an example of additional steps that may be performed in the process in Figure 9.

[0139] The process stores the new set of images using the image mapping tree if the new set of images falls within the maximum threshold for images in the image mapping tree (step 1100). The process recreates the image mapping tree using the new set of images and images in similar image groups if the new set of images is equal to or exceeds the new image threshold (step 1102). The process then terminates.

[0140] Next, referring to Figure 12, a flowchart of the process for creating an image mapping tree according to an exemplary embodiment is shown. The process shown in Figure 12 is an example of one implementation for creating an image mapping tree in step 902 in Figure 9.

[0141] The process begins by dividing the benchmark image to form sub-sections within it (stage 1200). The process creates a layer above the upper block within a layer below the root block, where each upper block within the upper block corresponds to a sub-section within a sub-section in the benchmark image (stage 1202). The process then terminates.

[0142] Referring to Figure 13, a flowchart of the process for creating an image mapping tree is shown according to an exemplary embodiment. This process shown in Figure 13 is an additional step that may be performed in the process in Figure 12 to create an image mapping tree.

[0143] The process determines the number of similar images in a set of similar images that have different similar blocks from the corresponding upper block within the upper block, in order to form a set of corresponding upper blocks (step 1300). The process divides each corresponding upper block in the set of corresponding upper blocks into sub-sub

[0144] A determination is made as to whether another sub-layer will be formed (step 1306). This determination can be made in any number of different ways. For example, the determination may be based on the storage generated and the processing resources used. The balance between these two factors may be analyzed to determine whether the storage reduced, in comparison to the processing resources used, justifies creating another layer for the image decision tree.

[0145] If another sublayer is to be formed for the image decision tree, the subblock becomes an upper block for the purpose of splitting when creating subsequent sublayers, and the process then returns to step 1300. Referring back to step 1306, if no further layer is to be created, the process terminates.

[0146] Next, referring to Figures 14A and 14B, a flowchart of the process for creating an image mapping tree according to an exemplary embodiment is shown. The process shown in Figures 14A and 14B is an example of one implementation for creating an image mapping tree in step 902 in Figure 9.

[0147] The process begins by setting the benchmark image as the root node in the image mapping tree (step 1402). The process then divides the benchmark image into sub-sections (step 1404). In step 1404, the benchmark image may be divided into four sub-sections. The process then uses the sub-sections in the benchmark image to create the first layer of blocks in the image mapping tree (step 1406). In step 1406, each block corresponds to a sub-section in the benchmark image. For example, if the benchmark image is divided into four sub-sections, there will be four blocks in the first layer of blocks, with each block corresponding to one of the four sub-sections.

[0148] The process then selects an unprocessed block in the first layer of blocks to be processed and sets the similar image counter S for that unprocessed block to 0 (step 1408). The process then selects an unprocessed image in the similar image group from which the benchmark image was identified (step 1410). The process compares the selected block with the corresponding block in the selected image (step 1412). If the corresponding block in the selected image is not the same as the selected block, the process increments the similar image counter S for the selected block (step 1414).

[0149] The process determines whether another unprocessed image exists within the similar image group for the selected block (step 1416). If another unprocessed image exists for this selected block, the process then returns to step 1410. Otherwise, it determines whether another unprocessed block exists within the first layer block (step 1418). If another unprocessed block exists, the process then returns to step 1408 as described above.

[0150] In step 1418, if no other unprocessed blocks exist, the process selects an unprocessed block in the first layer to process (step 1420). The process determines whether the similar image counter S is less than the threshold X (step 1422). If the similar image counter S is less than the threshold X, the process divides the selected block into a first number of blocks with respect to the lower layers of the block (step 1424). If the similar image counter S is equal to or greater than the threshold X, the process divides the selected block into a second number of blocks with respect to the lower layers of the block (step 1426).

[0151] In one example, a block can be divided into four blocks by a first number of blocks. A block can be divided into nine blocks by a second number of blocks. In those examples, all sub-sections within a single block are the same size. All sub-sections have the same dimensions within the block.

[0152] The type of division may vary depending on the specific implementation. In other examples, the first number of blocks could be nine blocks, and the second number of blocks could be 25 or 36 blocks, or any other number of blocks. The number of blocks may vary depending on the specific implementation. In other illustrative examples, a single number of blocks may be used, or three or more different numbers of blocks may be used.

[0153] After splitting the block selected in step 1424 or step 1426, the process proceeds to select an unprocessed block within the lower layer block and set the similar image counter S containing the selected block to equal to 0 (step 1427). The process then selects an unprocessed image within the similar image group (step 1428).

[0154] The process compares the selected block with the corresponding block in the selected image (step 1430). If the corresponding block in the selected image is not the same as the selected block, the process increments the similar image counter S for the selected block (step 1432).

[0155] The process determines whether another unprocessed image exists within the similar image group for the selected block (step 1434). If another unprocessed image exists for this selected block, the process then returns to step 1428. Otherwise, it determines whether another unprocessed block exists within the first layer block (step 1436). If another unprocessed block exists, the process then returns to step 1427 as described above.

[0156] Otherwise, a check is performed to determine if a set of conditions exists to create another layer (step 1438). If a set of conditions exists to create another layer, the process returns to step 1420. Otherwise, the process terminates and the image mapping tree is completed.

[0157] In step 1436, the set of conditions may be one or more conditions based on the amount of storage to be reduced and the amount of processing resources used. These factors may be used to determine whether the demand for the storage to be generated justifies creating that layer in relation to the processing resources used to create that layer. The set of conditions may include at least one of the following: whether the ratio of time to image size is less than a predefined threshold R; whether the time is less than a predefined threshold T (the maximum time to build the decision tree); whether the number of current layers is less than a predefined threshold L (the maximum number of layers); or some other expression that takes into account the amount of storage to be reduced and the amount of processing resources used.

[0158] Referring now to Figure 15, a flowchart of a process for managing an image storage space tree according to an exemplary embodiment is shown. The process in Figure 15 may be implemented in hardware, software, or both. When implemented in software, the process may take the form of program instructions executed by one or more processor units located in one or more hardware devices within one or more computer systems. For example, the process may be implemented in the image manager 408 within the computer system 406 in Figure 4.

[0159] The process begins by receiving a new image to store using an image mapping tree that has a root block for a benchmark image and blocks arranged in a set of layers below the root block based on a set of similar images (stage 1500). In stage 1500, a block represents a portion of the benchmark image, and multiple subblocks within a block in a lower layer correspond to sub-parts within a higher block in a higher layer.

[0160] The process stores a new set of blocks in the image mapping tree for a new image that is different from the corresponding set of blocks (step 1502). The process stores new metadata in the image mapping tree for the new set of blocks that describes a new set of paths from the corresponding set of blocks in the image mapping tree to the root block for the benchmark image (step 1504). The process then terminates.

[0161] Referring here to Figures 16A and 16B, flowcharts of a process for managing an image storage space tree for processing new images are shown according to an exemplary embodiment. The process in Figures 16A and 16B may be implemented in hardware, software, or both. When implemented in software, the process may take the form of program instructions executed by one or more processor units located in one or more hardware devices within one or more computer systems. For example, the process may be implemented in an image manager 408 within computer system 406 in Figure 4 for storage. This process may be executed for each new image received for processing. The new image may be received as an already stored image in order to determine whether further efficiency can be obtained. The process may also be executed for new images received for storage.

[0162] The process begins by receiving a new image to process (stage 1600). The process identifies similar image groups for the new image (stage 1602). In stage 1602, similar image groups may be used by comparing the new set of images with images in different similar image groups. For example, the minimum overall difference may be used to identify the similar image group that is most similar to the new image. If only one similar image group exists, that group is identified in stage 1602.

[0163] The process determines whether the number of new images is less than the threshold M (step 1604). If the number of new images is equal to or greater than the threshold M, a new benchmark image is identified, the image mapping tree is recreated (step 1606), and the subsequent process is determined. The recreation of the image mapping tree is performed in the steps shown in Figure 13 or Figures 14A and 14B.

[0164] If the number of new images is less than the new image threshold M, the process selects new unprocessed images to process (step 1607). The process identifies the first unprocessed layer in the image mapping tree for the identified similar image group as the layer to process (step 1608). The first unprocessed layer is the first layer in the image mapping tree that has not been used to determine whether a match exists between blocks in the layer and corresponding blocks in the image.

[0165] The process selects unprocessed blocks for the benchmark image within the layer (step 1610). The process compares the selected blocks with their corresponding blocks in the new image (step 1612). A determination is made as to whether the selected blocks are the same as their corresponding blocks in the new image (step 1614). In step 1614, blocks that are the same between the benchmark image and their corresponding blocks in the new image do not need to be saved.

[0166] If the selected block is not the same as the corresponding block in the new image, the process places the corresponding block from the new image into array A for later processing (step 1616). In other words, there is one or more differences between the selected block and the corresponding block. When saving the corresponding block, metadata may also be saved. For example, a reference to the root block containing the benchmark image, an identifier for the new image, and the path from the selected block to the root image may be saved as metadata.

[0167] The process determines whether another block exists within the layer (step 1618). If another block exists, the process returns to step 1610. The process also proceeds from step 1614 to step 1618 if the selected block is the same as the corresponding block.

[0168] Otherwise, the process determines whether another next layer exists in the image mapping tree (step 1620). If another next layer exists, the process selects the next layer to process (step 1622).

[0169] The process selects an unprocessed block from array A that corresponds to a block from the next layer (step 1624). In step 1624, the selected block is a subdivision of a block previously stored in array A for the new image. In this step, a smaller block is selected to perform a comparison with a block in the next layer.

[0170] The process compares a block selected from array A with a corresponding block in the next layer (step 1626). The process determines whether the block selected from array A is the same as the corresponding block from the next layer (step 1628).

[0171] If the block selected from array A is not the same as the corresponding block in the next layer, the process saves the selected block from array A to array B for the new image (step 1630). A check is made to see if there are any other unprocessed blocks in array A (step 1632). If there are any other unprocessed blocks in array A, the process returns to step 1624.

[0172] If no other unprocessed blocks exist in Array A, the process clears Array A and stores the contents of Array B in Array A (step 1634). The process returns to step 1620 as described above.

[0173] Referring again to step 1620, if no other next layer exists in the image mapping tree, the process stores any blocks for new images in array A, and metadata about those blocks (step 1636). The metadata may identify benchmark images and information identifying the path from the blocks to the root block containing the benchmark images. The process increments the count for new images C (step 1638). In step 1638, this count is used to count the number of new images that can be stored using the image mapping tree. In other words, the counter is not reset after the process ends, but rather to track new images presented for processing using the image mapping tree. The process then terminates.

[0174] The flowcharts and block diagrams in the differently depicted embodiments illustrate the architecture, function, and operation of several possible implementations of the apparatus and method in the exemplary embodiments. In this regard, each block in the flowchart or block diagram may represent at least one of a module, segment, function, or part of an operation or stage. For example, one or more of these blocks may be implemented as program instructions, hardware, or a combination of program instructions and hardware. When implemented in hardware, the hardware may take the form of an integrated circuit manufactured or configured to perform one or more operations in the flowchart or block diagram, for example. When implemented as a combination of program instructions and hardware, the implementation may take the form of firmware. Each block in the flowchart or block diagram may be implemented using a dedicated hardware system that performs a different operation, or using a combination of dedicated hardware and program instructions executed by the dedicated hardware.

[0175] In some alternative implementations of the exemplary embodiments, one or more functions described in a block may be performed in an order different from that shown in the drawing. For example, in some cases, two consecutively shown blocks may be executed substantially simultaneously, depending on the functions involved, or these blocks may be executed in reverse order, depending on the circumstances. In addition, other blocks may be added to those shown in the flowchart or block diagram.

[0176] Referring now to Figure 17, a block diagram of a data processing system according to an exemplary embodiment is shown. The data processing system 1700 may be used to implement the cloud computing node 110 in Figure 1, the personal digital assistant (PDA) or smartphone 120A in Figure 1, the desktop computer 120B, the laptop computer 120C and / or the automotive computer system 120N. The data processing system 1700 may be used to implement the computers in the hardware and software layer 202 in Figure 2, as well as the server computers 304, 306 and the client device 310 in Figure 3. The data processing system 1700 may also be used to implement the computer system 406 in Figure 4. In this exemplary example, the data processing system 1700 includes a communication framework 1702 that provides communication between a processor unit 1704, memory 1706, persistent storage 1708, a communication unit 1710, an input / output (I / O) unit 1712 and a display 1714. In this example, the communication framework 1702 takes the form of a bus system.

[0177] The processor unit 1704 functions to execute instructions for software that can be loaded into memory 1706. The processor unit 1704 comprises one or more processors. For example, the processor unit 1704 may be selected from at least one of a multicore processor, a central processing unit (CPU), a graphics processing unit (GPU), a physical processing unit (PPU), a digital signal processor (DSP), a network processor, or any other suitable type of processor. Furthermore, the processor unit 1704 may be implemented using one or more heterogeneous processor systems in which a primary processor and secondary processors reside on a single chip. As another exemplary example, the processor unit 1704 may be a symmetrical multiprocessor system housing multiple processors of the same type on a single chip.

[0178] Memory 1706 and persistent storage 1708 are examples of storage device 1716. A storage device is any number of hardware capable of storing information, such as, for example, data, program instructions in a functional form, or at least one of other suitable information, either temporarily, permanently, or both temporarily and permanently. In these exemplary examples, storage device 1716 may also be referred to as computer-readable storage device. Memory 1706 in these examples may be, for example, random-access memory or any other suitable volatile or non-volatile storage device. Persistent storage 1708 can take various forms depending on the particular implementation.

[0179] For example, persistent storage 1708 may contain one or more components or devices. For example, persistent storage 1708 may be a hard drive, a solid-state drive (SSD), flash memory, a rewritable optical disk, a rewritable magnetic tape, or any combination of the above. The medium used by persistent storage 1708 may be removable. For example, a removable hard drive may be used for persistent storage 1708.

[0180] In these exemplary examples, the communication unit 1710 provides communication with other data processing systems or devices. In these exemplary examples, the communication unit 1710 is a network interface card.

[0181] The input / output unit 1712 enables the input and output of data to and from other devices that may be connected to the data processing system 1700. For example, the input / output unit 1712 may provide a connection for user input through at least one of a keyboard, mouse, or any other suitable input device. Furthermore, the input / output unit 1712 may send output to a printer. The display 1714 provides a mechanism for displaying information to the user.

[0182] Instructions for at least one of an operating system, an application, or a program may reside in a storage device 1716 that communicates with the processor unit 1704 through a communication framework 1702. Processes of different embodiments may be executed by the processor unit 1704 using computer implementation instructions that may reside in memory, such as memory 1706.

[0183] These instructions are referred to as program instructions, computer-readable program instructions, or computer-readable program instructions, which can be read and executed by the processor in the processor unit 1704. In different embodiments, the program instructions may be implemented on different physical storage media or computer-readable storage media, such as memory 1706 or persistent storage 1708.

[0184] The program instruction 1718 is functionally located on a computer-readable medium 1720 that is selectively removable and can be loaded or transferred onto a data processing system 1700 for execution by a processor unit 1704. In these exemplary examples, the program instruction 1718 and the computer-readable medium 1720 form a computer program product 1722. In these exemplary examples, the computer-readable medium 1720 is a computer-readable storage medium 1724.

[0185] The computer-readable storage medium 1724 is not a medium for propagating or transmitting program instructions 1718, but a physical or tangible storage device used to store program instructions 1718. As used herein, the computer-readable storage medium 1724 shall not be interpreted as a transient signal itself, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through optical fiber cables), or electrical signals transmitted through wires.

[0186] Alternatively, program instructions 1718 may be transmitted to a data processing system 1700 using a computer-readable signal medium. The computer-readable signal medium is a signal, and may, for example, a propagating data signal containing program instructions 1718. For example, the computer-readable signal medium may be at least one of an electromagnetic signal, an optical signal, or any other suitable type of signal. These signals may be transmitted via a connection, such as a wireless connection, an optical fiber cable, a coaxial cable, a wire, or any other suitable type of connection.

[0187] Furthermore, as used herein, “computer-readable medium 1720” may be singular or plural. For example, program instructions 1718 may reside within computer-readable medium 1720 in the form of a single storage device or storage system. In another example, program instructions 1718 may reside within computer-readable medium 1720 distributed across multiple data processing systems. In other words, some instructions within program instructions 1718 may reside within one data processing system, while other instructions within program instructions 1718 may reside within one data processing system. For example, some parts of program instructions 1718 may reside within computer-readable medium 1720 in a server computer, while other parts of program instructions 1718 may reside within computer-readable medium 1720 located within a set of client computers.

[0188] The different components shown for data processing system 1700 are not intended to impose architectural restrictions on the manner in which different embodiments may be implemented. In some exemplary examples, one or more components may be incorporated into another component, or otherwise form part of another component. For example, memory 1706 or a portion thereof may be incorporated into processor unit 1704 in some exemplary examples. Different exemplary embodiments may be implemented in data processing systems that include components in addition to, or instead of, those shown for data processing system 1700. Other components shown in Figure 17 may be modified from the exemplary examples shown. Different embodiments may be implemented using any hardware device or hardware system capable of executing program instructions 1718.

[0189] Therefore, exemplary embodiments of the present invention provide a computer implementation method, a computer system, and a computer program product for managing image storage space. Multiple processor units identify a benchmark image within a group of similar images. Multiple other images within the group of similar images that are not identified as benchmark images constitute a set of similar images. Multiple processor units create an image mapping tree. The image mapping tree has a root block for the benchmark image and blocks arranged in a set of layers below the root block based on the set of similar images; each block represents a portion of the benchmark image; and multiple subblocks within a block in a lower layer correspond to sub-partitions within a higher block in a block in a higher layer. Multiple processor units store a set of selected blocks in the set of similar images that have differences from the corresponding set of blocks in the image mapping tree for the benchmark image. Multiple processor units store metadata about the set of selected blocks that describe a set of paths in the image mapping tree from the corresponding set of blocks in the image mapping tree to the root block.

[0190] As a result, exemplary embodiments may provide a technical effect that improves performance in a computer system by reducing the amount of image storage space required through storing portions of similar images. In one or more exemplary examples, an image mapping tree is used to identify blocks in an image that are similar to blocks in a benchmark image. These blocks are stored in the image mapping tree along with metadata that identifies the benchmark image and a path to the benchmark image. As a result, by using this image mapping tree, it is possible to identify stored blocks in an image that are the same as or different from the corresponding blocks in the benchmark image, while not storing blocks that are the same between the image and the corresponding blocks in the benchmark image, thereby reducing the amount of storage space required to store the image.

[0191] As a result, one or more exemplary examples demonstrate that employing image mapping trees can reduce the amount of storage required to store images by improving upon current techniques for storing images. Storing images using image mapping trees can not only improve the speed at which images can be transferred, but also reduce the amount of storage space required. Furthermore, another example can be used to balance improved efficiency in processor resource usage with increased storage, resulting in an optimal storage solution.

[0192] The descriptions of different exemplary embodiments are presented for illustrative and descriptive purposes and are not intended to be comprehensive or to limit the embodiments in the disclosed form. Different exemplary examples describe components that perform an action or operation. In exemplary embodiments, components may be configured to perform the described action or operation. For example, a component may have a structural configuration or design that provides the component with the ability to perform the action or operation described in the exemplary example as performed by the component. Furthermore, to the extent that the terms “includes,” “include,” “has,” “contains,” and their variations are used herein, such terms are intended to be comprehensive in a similar manner to the term “comprises” as an open-ended term, without excluding any additional or other elements.

[0193] The descriptions of various embodiments of the present invention are presented for illustrative purposes only and are not intended to be comprehensive or limitless. Not all embodiments include all features described in the exemplary examples. Furthermore, different exemplary embodiments may offer different features compared to other exemplary embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope of the described embodiments. The terminology used herein has been selected to best describe the principles of the embodiments, their practical applications, or technical improvements to the technology found in the market, or to enable other persons skilled in the art to understand the embodiments disclosed herein.

Claims

1. In the step where multiple processor units identify a benchmark image within a group of similar images, where multiple other images within the group of similar images that are not identified as the benchmark image constitute a set of similar images; The plurality of processor units create an image mapping tree, where the image mapping tree has a root block for the benchmark image, and blocks arranged in a set of layers below the root block based on the set of similar images; the blocks represent portions of the benchmark image; and multiple lower blocks within the block in the lower layer correspond to sub-parts within the upper block in the block in the upper layer; and The step in which the plurality of processor units store a set of selected blocks in the set of similar images, wherein the set of selected blocks in the set of similar images has differences from the set of blocks for the benchmark image located in the corresponding location in the image mapping tree; and The step involves the plurality of processor units storing metadata about the set of selected blocks in the set of similar images, which describes a set of paths in the image mapping tree from the set of blocks at corresponding locations in the image mapping tree to the root block. A computer implementation method for managing image storage space, comprising the following features.

2. The step in which the plurality of processor units store a new set of blocks for the new image in the image mapping tree, wherein the new set of blocks for the new image is different from the set of blocks in the corresponding location in the benchmark image; and The step involves the plurality of processor units storing new metadata in the image mapping tree for the new set of blocks, which describes a new set of paths from the set of blocks at corresponding locations in the image mapping tree to the root block for the benchmark image. The computer implementation method according to claim 1, further comprising the following:

3. The step in which the plurality of processor units store the new set of images using the image mapping tree when the new set of images falls within the maximum threshold for images in the image mapping tree. The computer implementation method according to claim 1 or 2, further comprising the above.

4. The step in which the plurality of processor units recreate the image mapping tree using the new set of images and the images in the similar image group when the new set of images is equal to or exceeds a new image threshold. The computer implementation method according to claim 3, further comprising the above.

5. The steps by which the multiple processor units create the image mapping tree are as follows: The steps of the plurality of processor units dividing the benchmark image to form sub-sections within the benchmark image; and The step of creating a layer above the upper block within the layer below the root block, wherein each upper block within the upper block corresponds to the sub-sub A computer implementation method according to claim 1 or 2, comprising:

6. The steps by which the multiple processor units create the image mapping tree are as follows: The step of the plurality of processor units determining the number of similar images in the set of similar images that have similar blocks different from the corresponding upper blocks in the upper blocks, in order to form a set of corresponding upper blocks; The steps of the plurality of processor units dividing each corresponding upper block within the corresponding set of upper blocks into the sub-partitions; and In the step where the plurality of processor units create the lower layer of the lower block, each lower block within the lower block corresponds to the sub-partition within the sub-partition within the set of the corresponding upper block. The computer implementation method according to claim 5, further comprising the above.

7. For the purpose of creating subsequent lower layers, the lower block becomes the upper block. The plurality of processor units repeatedly perform the determination step, the division step, and the creation step to form the subsequent lower layer. The computer implementation method according to claim 6, further comprising the above.

8. The plurality of processor units repeatedly perform the steps of determining, dividing, and creating, forming another lower layer based on the reduced storage and processing resources used. The computer implementation method according to claim 6, further comprising the above.

9. The computer implementation method according to claim 6, wherein the number of lower blocks formed by dividing the upper block is based on the number of similar images having similar blocks for the upper block to be divided.

10. The computer implementation method according to claim 1 or 2, wherein the metadata comprises a set of image identifiers for the set of selected blocks, a reference to the benchmark image, and a set of paths in the image mapping tree from the set of corresponding blocks in the image mapping tree to the root block.

11. The step in which the plurality of processor units identify the benchmark image within the similar image group is: The step in which the plurality of processor units identify the benchmark image from the plurality of similar images based on the minimum overall difference between the plurality of similar images. A computer implementation method according to claim 1 or 2, comprising:

12. The computer implementation method according to claim 11, wherein the minimum overall difference is determined using at least one of the following methods: RGB color histogram method, keypoint matching method, image hash method, or bit calculation method.

13. A step in which a plurality of processor units receive a new image to store; A step in which multiple processor units store a new set of blocks for the new image using an image mapping tree having a root block for a benchmark image and blocks arranged in a set of layers below the root block based on a set of similar images; where the set of new blocks for the new image is different from the set of blocks in the corresponding location in the image mapping tree, the blocks in the lower layers represent portions of the benchmark image, and multiple lower blocks within the block in the lower layer correspond to sub-partitions within the upper block within the block in the upper layer; and The step in which the plurality of processor units store in the image mapping tree new metadata for the new set of blocks, which describes a new set of paths from the set of blocks at corresponding locations in the image mapping tree to the root block for the benchmark image. A computer implementation method for managing image storage space, comprising the following features.

14. A computer system comprising multiple processor units, wherein the multiple processor units are: The procedure involves the plurality of processor units identifying a benchmark image within a group of similar images, wherein any other images within the group of similar images that are not identified as the benchmark image constitute a set of similar images; The steps of the plurality of processor units to create an image mapping tree, wherein the image mapping tree has a root block for the benchmark image, and blocks arranged in a set of layers below the root block based on the set of similar images; the blocks represent portions of the benchmark image; and multiple lower blocks within the block in the lower layer correspond to sub-parts within the upper block in the block in the upper layer; and The procedure for the plurality of processor units to store a set of selected blocks in the set of similar images, wherein the set of selected blocks in the set of similar images has differences from the set of blocks for the benchmark image located in the corresponding location in the image mapping tree; and Procedure for storing metadata about the set of selected blocks in the set of similar images, which describes a set of paths in the image mapping tree from the set of blocks at corresponding locations in the image mapping tree to the root block, for the plurality of processor units. A computer system that executes program instructions for carrying out the aforementioned procedure.

15. The procedure involves the plurality of processor units storing a new set of blocks for a new image in the image mapping tree, wherein the new set of blocks for the new image is different from the set of blocks in the corresponding locations in the benchmark image; and The procedure involves the plurality of processor units storing new metadata in the image mapping tree for the new set of blocks, which describes a new set of paths from the set of blocks at corresponding locations in the image mapping tree to the root block for the benchmark image. The computer system according to claim 14, further comprising:

16. The procedure for the plurality of processor units to store the new set of images using the image mapping tree when the new set of images falls within the maximum threshold for images in the image mapping tree. The computer system according to claim 14 or 15, further comprising:

17. The procedure for the plurality of processor units to recreate the image mapping tree using the new set of images and the images in the similar image group when the new set of images is equal to or exceeds a new image threshold. The computer system according to claim 16, further comprising:

18. The procedure by which the aforementioned multiple processor units create the image mapping tree is as follows: The procedure for the plurality of processor units to divide the benchmark image and form sub-sections within the benchmark image; and A procedure for creating a layer above A computer system according to claim 14 or 15, having the following features.

19. The procedure by which the multiple processor units create the image mapping tree is as follows: A procedure for determining the number of similar images in a set of similar images that have similar blocks different from the corresponding upper blocks within the upper blocks, in order for the plurality of processor units to form a set of corresponding upper blocks; The procedure for the plurality of processor units to divide each corresponding upper block in the corresponding set of upper blocks into the sub-partitions; and A procedure for creating a sub-layer of a sub-block, wherein each sub-block within the sub-block corresponds to the sub-compartment within the sub-compartment within the set of the corresponding upper block. The computer system according to claim 18, further comprising:

20. For the purpose of creating subsequent lower layers, the lower block becomes the upper block. The procedure by which the plurality of processor units repeatedly perform the determination procedure, the division procedure, and the creation procedure to form the subsequent lower layer. The computer system according to claim 19, further comprising:

21. The plurality of processor units repeat the determination procedure, the partitioning procedure, and the creation procedure to form another lower layer based on the reduced storage and the processing resources used. The computer system according to claim 19, further comprising:

22. The computer system according to claim 19, wherein the number of lower blocks formed by dividing a higher block is based on the number of similar images having similar blocks for the higher block that is divided.

23. The computer system according to claim 14 or 15, wherein the metadata comprises a set of image identifiers for the set of selected blocks, a reference to the benchmark image, and a set of paths in the image mapping tree from the set of corresponding blocks in the image mapping tree to the root block.

24. A computer system comprising multiple processor units, wherein the multiple processor units are: The stage of receiving a new image to be stored; A new set of blocks for the new image is stored using an image mapping tree having a root block for a benchmark image and blocks arranged in a set of layers below the root block based on a set of similar images; where the new set of blocks for the new image is different from the set of blocks in the corresponding location in the image mapping tree, the blocks in the lower layers represent portions of the benchmark image, and the multiple subblocks within the block in the lower layer correspond to sub-parts within the upper block within the block in the upper layer; and The image mapping tree stores new metadata for the new set of blocks that describes a new set of paths from the set of blocks at corresponding locations in the image mapping tree to the root block for the benchmark image. A computer system that executes program instructions for a given purpose.

25. A computer program for managing image storage space, which is installed on a computer system: A procedure for identifying a benchmark image within a group of similar images, where any other images within the group that are not identified as the benchmark image constitute a set of similar images; A procedure for creating an image mapping tree, wherein the image mapping tree has a root block for the benchmark image, and blocks arranged in a set of layers below the root block based on the set of similar images; the blocks represent portions of the benchmark image; and multiple subblocks within the block in the lower layer correspond to sub-parts within the upper block in the block in the upper layer; and A procedure for storing a set of selected blocks in the set of similar images, wherein the set of selected blocks in the set of similar images has differences from the set of blocks for the benchmark image located at the corresponding location in the image mapping tree; and A procedure for storing metadata about a set of selected blocks in a set of similar images, which describes a set of paths in the image mapping tree from the set of blocks at corresponding locations in the image mapping tree to the root block. A computer program designed to execute something.

Images