# Patent

## Title
Compression of image ensembles using tensor decomposition

## Abstract

A computer-implemented method is provided for compressing a collection of images. The method includes: receiving image data for an image ensemble composed of a plurality of images; dividing the image data into a plurality of data blocks; decomposing each data block from the plurality of data blocks into a set of rank-one tensors by estimating each rank-one tensor individually, where each rank-one tensor is represented by three one-dimensional vectors; arranging the rank-one tensors for each of the plurality of data blocks into a two-dimensional matrix, where the decomposer is implemented by computer processor; compressing the two-dimensional matrix using a compression operation; and storing the compressed two-dimensional matrix in a non-transitory data store.

## Background
CROSS-REFERENCE TO RELATED APPLICATIONS
This application claims the benefit of U.S. Provisional Application No. 61/929,267, filed on Jan. 20, 2014. The entire disclosure of the above application is incorporated herein by reference.


FIELD
The present disclosure relates to compression of image ensembles using tensor decomposition.
BACKGROUND
Image databases represent a core component of many well-established and emerging applications and services including ecommerce and security. For example, image databases of faces, fingerprints, and eye retinas are used extensively for biometric and other security-related applications. Such databases store a vast number of images of the same type, and yet, traditional compression standards are used to compress and store these images without exploiting the correlation that potentially exists among the images within the same database. For example, the ISO/IEC 19794 standard on biometric data interchange format defined JPEG and JPEG2000 as admissible lossy compression methods. A key driver for encoding each image in isolation of other images within the same database is the ability to access and decode any image without the need to access/decode other images. Such requirement eliminates popular video coding standards as viable candidates for coding still-image databases.
In this disclosure, it is proposed to employ a tensor-decomposition framework that can achieve both: (a) random access to any image within a collection of images coded jointly and (b) coding efficiency by exploiting any potential correlation that may exist among the images within the same database. To bring focus to the problem addressed here, an image ensemble is defined as a set of images of the same type (e.g., images of human faces). Thus, the goal is to develop a compression approach for image ensembles while achieving full random access. The proposed tensor-based framework can access any image within an ensemble at different levels of quality (and corresponding scalable bitrates) without the need to reconstruct or access any other image from the same ensemble. This is crucial, not only for storage efficiency, but also to reduce bandwidth across networks for scalable search and retrieval engines. Experimental results show the viability of the proposed tensor-based framework for image-ensemble compression.
This section provides background information related to the present disclosure which is not necessarily prior art.
SUMMARY
This section provides a general summary of the disclosure, and is not a comprehensive disclosure of its full scope or all of its features.
A computer-implemented method is provided for compressing a collection of images. The method includes: receiving image data for an image ensemble composed of a plurality of images; dividing the image data into a plurality of data blocks, where each of the data blocks has three dimensions; decomposing each data block from the plurality of data blocks into a set of rank-one tensors by estimating each rank-one tensor individually, where each rank-one tensor is represented by three one-dimensional vectors; arranging the rank-one tensors for each of the plurality of data blocks into a two-dimensional matrix, where the decomposer is implemented by computer processor; compressing the two-dimensional matrix using a compression operation; and storing the compressed two-dimensional matrix in a non-transitory data store.
Further areas of applicability will become apparent from the description provided herein. The description and specific examples in this summary are intended for purposes of illustration only and are not intended to limit the scope of the present disclosure.



DRAWINGS
The drawings described herein are for illustrative purposes only of selected embodiments and not all possible implementations, and are not intended to limit the scope of the present disclosure.
FIG. 1 is a diagram depicting an example architecture for an image-ensemble coding system;
FIG. 2 is a flowchart depicting a proposed method for compressing a collection of images;
FIG. 3A is a flowchart depicting an example method for estimating rank-one tensors individually;
FIG. 3B is a flowchart depicting an alternative method for estimating rank-one tensors individually;
FIG. 4 is an illustration of an eigenfiber arrangement and rank values for 96 blocks of an image ensemble;
FIG. 5 is a graph showing the reconstruction PSNR averaged over 38 persons versus the average per image required space. For testing and simulation, the proposed method was applied to the Yale Face Database B; the database has images of 38 persons, each of them has 64 images.
FIGS. 6A and 6B are graphs showing PCP R values for the blocks on an image encoded at 288 bytes and 979 bytes, respectively; and
FIGS. 7A and 7B are graphs showing the average encoding and decoding time, respectively, of 38 persons' face images.



Corresponding reference numerals indicate corresponding parts throughout the several views of the drawings.
DETAILED DESCRIPTION
Example embodiments will now be described more fully with reference to the accompanying drawings.
FIG. 1 depicts a high-level architecture for the proposed image-ensemble coding system. An image ensemble 12 serves as an input to the system. In an example embodiment, the image ensemble is composed of a collection of similar still images which are organized into a 3D image-ensemble tensor 12. While reference is made to still images, it is readily understood that the concepts described herein are applicable to other types of image data, such as video. It is also understood that one or more of the still images has been captured by a camera or another type of imaging device and then stored in a database for subsequent processing.
The image data for the image ensemble is received by a decomposer 13. The decomposer 13 is operated to divide the image ensemble 12 into a plurality of 3D tensor-blocks. Each tensor block j is then decomposed by the decomposer 13 into a set of rank-one tensors. This process generates Rj rank-one tensors 14 for the corresponding original tensor-block j. The resulting rank-one tensors 14 are represented by three 1D vectors which are referred to herein as eigenfibers. These eigenfibers, which contain significantly smaller number of elements than the number of voxels in the original 3D image-ensemble, represent a compact representation of the entire 3D tensor data. It is noteworthy that any image (2D slice) within the 3D tensor-ensemble can be reconstructed entirely and independently of other images, directly from the eigenfibers (as explained further below). This compact representation provides random access capability.
To achieve high coding-efficiency, the system can include two more components. First, an optimal rank-allocation process is applied by the decomposer 13 to assign the appropriate number of rank-one tensors to each of the corresponding tensor blocks. This process is analogous to rate-allocation (or rate control) in traditional image/video coding systems. Second, one can further exploit the correlation that exists among the eigenfibers by applying some form of compression as performed by compressor 15. In an example embodiment, the eigenfibers are aligned into a two-dimensional (2D) matrix which is compressed using a 2D image compression method. Finally, the compressed two-dimensional matrix can be stored in a non-transistory data store 16.
Consequently, when access is desired to a single 2D image 20 of the image ensemble, the image 20 can be randomly accessed from the compressed two-dimensional matrix residing in the data store 16. More specifically, the two-dimensional matrix is first decompressed by a decoder 17. The single 2D image 20 is then retrieved by an image retriever 19 from the decompressed two-dimensional matrix. As will be further described below, a low-complexity eigenfiber multiplication may be used by the image retriever 19 to recover the 2D image 20. This is the same order of complexity required when reconstructing any 2D compressed image stored within a database using a traditional approach (e.g., JPEG or JPEG2000).
Image processing techniques, including the system components, described above may be implemented by one or more computer programs executed by one or more computer processors. The computer programs include processor-executable instructions that are stored on a non-transitory tangible computer readable medium (i.e., data store). Likewise, image data and other data may also be stored in a non-transitory tangible computer readable medium. Non-limiting examples of the non-transitory tangible computer readable medium include but are not limited to nonvolatile memory, magnetic storage, and optical storage.
FIG. 2 further illustrates an example method for compressing a collection of images. A tensor is a multi-dimensional set of data. For example, a vector is a one dimensional tensor and a matrix is a two dimensional tensor. In this example, the image ensemble is a three dimensional tensor (i.e., χ∈v1×v2×v3). Here a tensor is partitioned into a set of equal size 3D tensor blocks (i.e. v1×v2×v3). In an example embodiment, Progressive Canonical Parallel (PCP) tensor decomposition is employed to factorize each block into a set of rank-one tensors, each of which can be written as an outer product of three vectors as in

{circumflex over (χ)}j=Σr=1Rjλj,r(bj,r(1)°bj,r(2)°bj,r(3)).   (1)

where ° is an outer product; j is the block index; Rj is the number of rank-one tensors and λj,r is a normalization value. Other types of decomposition techniques may also be used within the broader aspects of this disclosure.

An alternative Least Square (ALS) algorithm may be used to compute bj,r(d) where d=1,2,3. It minimizes the reconstruction error as in




  
    
      
        
          b
          
            j
            ,
            r
          
          
            *
            
              (
              d
              )
            
          
        
        =
        
          arg
          ⁢
          
            
          
          ⁢
          
            
              min
              
                b
                
                  j
                  ,
                  r
                
                
                  (
                  d
                  )
                
              
            
            ⁢
            
              
                
                
                  
                    (
                    
                      
                        X
                        
                          (
                          d
                          )
                        
                      
                      -
                      
                        
                          ∑
                          
                            k
                            -
                            0
                          
                          
                            r
                            -
                            1
                          
                        
                        ⁢
                        
                          
                            X
                            ′
                          
                          
                            
                              (
                              d
                              )
                            
                            ,
                            k
                          
                        
                      
                    
                    )
                  
                  -
                  
                    
                      
                        b
                        
                          j
                          ,
                          r
                        
                        
                          (
                          d
                          )
                        
                      
                      ⁡
                      
                        (
                        
                          z
                          r
                          
                            (
                            d
                            )
                          
                        
                        )
                      
                    
                    T
                  
                
                
              
              F
            
          
        
      
    
    
      
        (
        2
        )
      
    
  




where zr(d)=bj,r(d1)bj,r(d2),  is the Kronecker product, d ∈ {1,2,3}, d1 ∈ {1,2,3}−{d}, and d2 ∈ {1,2,3}−{d, d1}. X(d) is a matrix that results from unfolding the block j with respect to the dth dimension. For example, X(1) ∈ v1×(v2v3) is a matrix that results from unfolding the block j with respect to the first dimension (i.e. v1) [1]. X′(d),k is the kth rank-one tensor unfolded over dimension d, and k ∈ {1,2, . . . , R}. X′(d),0=0,X′(d),k=λkbk(d)(zk(d))T. For a given rank parameter Rj, the ALS approach solves br(1) by fixing br(2) and br(3); and similarly for br(2) and br(3). Other types of estimation techniques also fall within the broader aspects of this disclosure.

Unlike traditional CP, the proposed PCP decomposition has an extra loop to solve for each rank one tensor progressively. With reference to FIG. 3A, PCP begins at 31 by estimating a given data block with a rank-one tensor. Next, an error is determined at 32 between the given data block and a reconstruction of the given data block from the rank-one tensor. The error is compared to a threshold at 33. If the error is higher than a threshold, another rank-one tensor is added at 34 to represent the given data block. These steps are repeated until the error is below the threshold or some maximum allowable number of tensors is reached. Thus, PCP estimates each rank-one tensor individually; whereas, traditional CP estimates all rank-one tensors at once.
An alternative approach for estimating rank-one tensors individually is shown in FIG. 3B. This approach begins by estimating each data block at 35 with a rank-one tensor. For each data block, an error is estimated at 36 between a given data block and an estimate of the given data block using an additional rank-one tensor. Next, the data block having the largest error reduction is identified at 37. The corresponding data block is estimated at 38 using an additional tensor and the error reduction is updated. These steps are repeated as indicated at 39 until the average error is below a threshold or some maximum allowable number of tensors is reached.
This example rank-distortion optimization algorithm is further described below. For a given tensor with N 3D blocks, the goal is to find the global optimum R, where R is a vector of dimension N. Each entry of R=(R1,R2, . . . ,RN) corresponds to the number of rank-one tensors which are used to reconstruct a 3D-block of the tensor.
The rank-distortion optimization problem is formulated to find the global optimum R as in




  
    
      
        
          
            
              
                R
                min
              
              ⁡
              
                (
                
                  
                    ∑
                    
                      j
                      =
                      1
                    
                    N
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    R
                    j
                  
                
                )
              
            
            ⁢
            
              
            
            ⁢
            
              s
              .
              t
              .
              
                

              
              ⁢
              
                1
                N
              
            
            ⁢
            
              
                ∑
                
                  j
                  =
                  1
                
                N
              
              ⁢
              
                
              
              ⁢
              
                
                  
                  
                    
                      χ
                      j
                    
                    -
                    
                      
                        ∑
                        
                          i
                          =
                          1
                        
                        Rj
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          λ
                          
                            j
                            ,
                            i
                          
                        
                        ⁡
                        
                          (
                          
                            
                              b
                              
                                j
                                ,
                                i
                              
                              
                                (
                                1
                                )
                              
                            
                            ∘
                            
                              b
                              
                                j
                                ,
                                i
                              
                              
                                (
                                2
                                )
                              
                            
                            ∘
                            
                              b
                              
                                j
                                ,
                                i
                              
                              
                                (
                                3
                                )
                              
                            
                          
                          )
                        
                      
                    
                  
                  
                
                F
              
            
          
          ≤
          
            ε
            max
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              
                ∑
                
                  j
                  =
                  1
                
                N
              
              ⁢
              
                
              
              ⁢
              
                R
                j
              
            
            <
            
              (
              
                
                  1
                  γ
                
                ⁢
                
                  
                    ∑
                    
                      j
                      =
                      1
                    
                    N
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      
                        v
                        1
                      
                      ⁢
                      
                        v
                        2
                      
                      ⁢
                      
                        v
                        3
                      
                    
                    
                      
                        
                          v
                          1
                        
                        +
                        
                          v
                          2
                        
                        +
                        
                          v
                          3
                        
                      
                      
                        
                      
                    
                  
                
              
              )
            
          
          ⁢
          
            =
            △
          
          ⁢
          
            R
            max
          
        
      
    
    
      
        (
        3
        )
      
    
  




where ∈max is the overall acceptable average error. The second inequality in (3) captures an upper bound for the total number of eigenfibers that can be used. γ is a regularization parameter where γ>1. Assuming that we use the same precision for the original tensor entries and for the elements of the PCP decomposition (e.g., eight bits/element), using the eigenfibers instead of the original block will result in the compaction ratio equal to v1v2v3/Rj(v1+v2+v3). The second inequality in (3) came from lower bounding the compaction ratio by γ. Note that Rmax can be simplified ((v1v2v3)N)/(γ(v1+v2+v3)).

A solution to this optimization problem can be found by searching for the optimum Rj which satisfies the constraints. A greedy algorithm is proposed to solve (3). The algorithm starts initially using R={right arrow over (1)}. This initialization is along with the fact that each 3D tensor block should be represented at least with one rank-one tensor. Define Dj as block j error decrement, corresponding to Rj increment by one (i.e. Dj=∈j,Rj−∈j,Rj+1). Initially Dj=∈j.1−εj.2 for j=1 . . . N. Iteratively find block j that has the maximum Dj and increase its corresponding Rj by one. This greedy choice provides the largest possible error reduction. After increasing Rj, the inequalities are checked to make sure they are satisfied. The details of the algorithm are outlined below.

    Data: A set of 3D blocks of a tensor (i.e. Xj, j=1, . . . N .), and γ.
    Result: A set of eigenfibers to represent the input tensor.
    Initialization:

R={right arrow over (1)}

    Find λj,rbj,r(1), bj,r(2), and bj,r(3) for r=1,2 and j=1 . . . N (2).

∈j,r=∥χj−Σi=1rλj,i(bj,i(1)°bj,i(2)°bj,i(3))∥F 

    for r=1,2and j=1 . . . N.

Dj=∈j,1−∈j,2. f or j=1. . . N 



While first inequality in (3) is not satisfied and the second inequality in (3) is satisfied:












do








| -
j = argmaxj Dj


| -
r = Rj + 1


| -
Find λj,r, bj,r(1), bj,r(2), and bj,r(3) from (2) and store them in matrices







B(1), B(2), and B(3).








| -
Find λj,r+1, bj,r+1(1), bj,r+1(2), and bj,r+1(3) from (2).


| -
∈j,r = ∥ χj − Σi=1r λj,i(bj,i(1) ∘ bj,i(2) ∘ bj,i(3)) ∥F


| -
∈j,r+1 = ∥ χj − Σi=1r+1 λj,i(bj,i(1) ∘ bj,i(2) ∘ bj,i(3)) ∥F


| -
Dj = ∈j,r+1 − ∈j,r


| -
Rj = r







end









Other types of optimization algorithms also fall within the scope of this disclosure.

Returning to FIG. 2, the eigenfibers for each data block are arranged at 24 into a two-dimensional matrix. In the example embodiment, the decomposed eigenfibers bj,r(d) are arranged into matrix B(d), where B(d)∈vd×Σj=1NRj, N is number of blocks, and d=1,2. The vectors λj,r(bj,r(3)) are arranged in matrix B(3). This will eliminate the need for coding λj,r parameters separately.
FIG. 4 shows an example arrangement of eigenfibers obtained from decomposing such an image ensemble. Consider an image ensembles of size 128×192×64 divided into 16×16>64 3D blocks, which results in 96 tensor blocks. All eigenfiber values are mapped from their normalized [−1, +1] range onto the traditional [0,255] pixel values.
In the example arrangement, the eigenfibers bj,r(1) are put at the top of the 2D image; each fiber is of height 16. Next, the second eigenfibers bj,r(2), also with height 16, are placed below bj,r(1). These two groups of eigenfibers capture the 16×16 spatial information of the tensor-blocks. Meanwhile, the third eigenfibers bj,r(3) with height 64 are placed below. These later eigenfibers capture the temporal information of the 3D tensor-blocks.
More importantly, the eigenfibers associated with the first rank-one tensors (i.e., for r=1) are separated horizontally from the remainder of all other eigenfibers with higher rank index (i.e. for r>1). This separation is analogous to differentiating between “DC” and “AC” coefficients in traditional image and video coding. For higher rank indices, r>1, the eigenfibers may be placed according to the blocks they belong to in a raster-scan order although other horizontal arrangements for eigenfibers with r>1 are also contemplated. For example, one can group eigenfibers with r=2, followed by ones with r=3, and so on.
As shown in FIG. 4, the temporal eigenfibers bj,r(3) are multiplied with the corresponding parameters λj,r. There are two benefits for absorbing these parameters onto the eigenfibers. First, the need for coding these parameters separately is eliminated. Second, this multiplication process improves the correlation among the eigenfibers within the 2D image.
The two-dimensional matrix is then compressed at 25 using a compression operation. The decomposed vectors can be coded by any 2D image compression method. In an example embodiment, the compression method is JPEG 2000 operation. From experience, it was found that the lossy mode with compression ratio equal to 2 yields good compression without major losses in the final image quality.
Lastly, the compressed two-dimensional matrix is stored at 26 for subsequent retrieval. The matrix is stored along with a header, where the header includes size of the image ensemble, size of each data block, and the R vector. In one embodiment, the header information can be entropy coded in a lossless manner. This information is required in decoding and retrieving an image.
Within the framework set forth above, a given image from the image ensemble can be randomly accessed from the stored two-dimensional matrix. The eigenfibers bj,r(1) and bj,r(2) can be considered as the basis dictionary for the image ensembles while each value in bj,r(3) is a coefficient. A single image reconstruction requires the basis from Bj,r(1) and Bj,r(2) and corresponding coefficients (i.e. single row) from Bj,r(3). Note that row i would reconstruct ith image in the ensembles. In the example embodiment, an image i of the ensemble can be decoded as in

IMAGEi,j=Σr=1Rj(Bj,r(1)°Bj,r(2))Bi,j,r(3)   (4)

where j is the block's index, Bj,r(d), d=1,2 is a vector Bi,j,r(3), is a single value from row i of matrix B(3). The column index (k) is calculated based on the value of j and r as in





  
    Column
    ⁢
    
      
    
    ⁢
    Index
  
  =
  
    {
    
      
        
          
            
              
                j
              
            
            
              
                
                  N
                  +
                  
                    
                      ∑
                      
                        z
                        =
                        1
                      
                      
                        j
                        -
                        1
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      R
                      z
                    
                  
                  +
                  r
                  -
                  
                    1
                    ⁢
                    
                      
                        
                          
                            
                              if
                              ⁢
                              
                                
                              
                              ⁢
                              r
                            
                            =
                            1
                          
                        
                      
                      
                        
                          
                            
                              if
                              ⁢
                              
                                
                              
                              ⁢
                              r
                            
                            >
                            1
                          
                        
                      
                    
                  
                
              
            
          
        
        
          
            
          
        
      
    
  




For demonstration purposes, the proposed method was applied to the Yale Face Database B. This database has images of 38 persons. Each of them has 64 images of size 192×168. These images vary in expression and illumination condition. After stacking the images on top of each other, there is a 3D tensor of size 192×168×2432. The resulting tensor is decomposed using PCP and the eigenfibers are arranged in 2D matrices. The result is then compressed by JPEG2000. Within the context of the proposed image-ensemble tensor based compression, a comparison is made between the proposed tensor decomposition approach and existing still-image compression standards used in image databases:

    
    
        1 Block-wise PCP-decomposition. The block size is 16×21×64 and the value of γ is changed to control the final storage size.
        2 Block-wise CP-decomposition. The block size is the same as in method (1) and the value of γ is changed to compare the results for different compaction ratios. Here, we used the same structure as in FIG. 1 except the decomposition method is replaced with CP and JPEG2000 lossless mode is used since small changes in the CP decomposed vectors can lead to large error in reconstruction.
        3 Storing each image separately using JPEG2000 standard. The MATLAB implementation is used.
    
    


FIG. 5 shows the reconstruction PSNR averaged over 38 persons versus the per image required space (in Bytes) averaged over all the 64 images of 38 persons. Over a wide-range of bitrates, PCP clearly outperforms the other methods. FIGS. 6A and 6B shows the PCP R values for the blocks of an image encoded at two different bit rates.
Based on the progressive nature of PCP, its time complexity is linear as a function of the number of rank-one tensors. CP factorization (i.e., the encoding side) has a quadratic complexity as a function of R. Either case (PCP or CP), the decoding complexity is on the same order as a traditional JPEG2000 decoding. FIGS. 7A and 7B show the time complexity for the different approaches, where the decomposition methods are evaluated at a desktop computer with 12 GB of memory and an Intel Core i7 2600 CPU (8 MB Cache, 3.4 GHz).
In conclusion, these simulations confirm the conjecture that one can achieve highly-efficient progressive coding of image ensembles while maintaining low-complexity random access to any desired image when employing tensor-based decomposition. The proposed system that is based on PCP factorization, optimal rank-allocation, and eigenfibers coding clearly shows its viability as an image-ensemble compression framework.
The techniques described herein may be implemented by one or more computer programs executed by one or more processors. The computer programs include processor-executable instructions that are stored on a non-transitory tangible computer readable medium. The computer programs may also include stored data. Non-limiting examples of the non-transitory tangible computer readable medium are nonvolatile memory, magnetic storage, and optical storage.
Some portions of the above description present the techniques described herein in terms of algorithms and symbolic representations of operations on information. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. These operations, while described functionally or logically, are understood to be implemented by computer programs. Furthermore, it has also proven convenient at times to refer to these arrangements of operations as modules or by functional names, without loss of generality.
Unless specifically stated otherwise as apparent from the above discussion, it is appreciated that throughout the description, discussions utilizing terms such as “processing” or “computing” or “calculating” or “determining” or “displaying” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system memories or registers or other such information storage, transmission or display devices.
Certain aspects of the described techniques include process steps and instructions described herein in the form of an algorithm. It should be noted that the described process steps and instructions could be embodied in software, firmware or hardware, and when embodied in software, could be downloaded to reside on and be operated from different platforms used by real time network operating systems.
The present disclosure also relates to an apparatus for performing the operations herein. This apparatus may be specially constructed for the required purposes, or it may comprise a general-purpose computer selectively activated or reconfigured by a computer program stored on a computer readable medium that can be accessed by the computer. Such a computer program may be stored in a tangible computer readable storage medium, such as, but is not limited to, any type of disk including floppy disks, optical disks, CD-ROMs, magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, application specific integrated circuits (ASICs), or any type of media suitable for storing electronic instructions, and each coupled to a computer system bus. Furthermore, the computers referred to in the specification may include a single processor or may be architectures employing multiple processor designs for increased computing capability.
The algorithms and operations presented herein are not inherently related to any particular computer or other apparatus. Various general-purpose systems may also be used with programs in accordance with the teachings herein, or it may prove convenient to construct more specialized apparatuses to perform the required method steps. The required structure for a variety of these systems will be apparent to those of skill in the art, along with equivalent variations. In addition, the present disclosure is not described with reference to any particular programming language. It is appreciated that a variety of programming languages may be used to implement the teachings of the present disclosure as described herein.
The foregoing description of the embodiments has been provided for purposes of illustration and description. It is not intended to be exhaustive or to limit the disclosure. Individual elements or features of a particular embodiment are generally not limited to that particular embodiment, but, where applicable, are interchangeable and can be used in a selected embodiment, even if not specifically shown or described. The same may also be varied in many ways. Such variations are not to be regarded as a departure from the disclosure, and all such modifications are intended to be included within the scope of the disclosure.

## Claims

1. A computer-implemented method for compressing a collection of images, comprising:
receiving, by a decomposer, image data for an image ensemble composed of a plurality of images;
dividing, by the decomposer, the image data into a plurality of data blocks, each of the data blocks having three dimensions;
decomposing, by the decomposer, each data block from the plurality of data blocks into a set of rank-one tensors by estimating each rank-one tensor individually, where each rank-one tensor is represented by three one-dimensional vectors;
arranging, by the decomposer, the rank-one tensors for each of the plurality of data blocks into a two-dimensional matrix, where the decomposer is implemented by computer processor;
compressing the two-dimensional matrix using a compression operation; and
storing the compressed two-dimensional matrix in a non-transitory data store.

2. The method of claim 1 further comprises decomposing each data block into a rank-one tensor represented as an outerproduct of three vectors as follows


{circumflex over (χ)}j=Σr=1Rjλj,r(bj,r(1)°bj,r(2)°bj,r(3))


where ° is an outer product; j is the block index; Rj is the number of rank-one tensors and λj,r is a normalization value.

3. The method of claim 2 wherein decomposing each data block further comprises
(a) representing a given data block with a given rank-one tensor;
(b) determining an error between the given data block and a reconstruction of the given data block from the rank-one tensor;
(c) adding another rank-one sensor to represent the given data block when the error is below a threshold; and
(d) repeating steps (b) and (c) until the error is below the threshold.

4. The method of claim 2 wherein decomposing each data block further comprises
(a) representing each data block with a rank-one tensor;
(b) for each block, estimate error reduction when an additional rank-one tensor is used;
(c) find a given data block with maximum error reduction;
(d) estimate a corresponding data block for the given data block using an additional tensor; and
(e) repeating steps (c) and (d) until an average error for the data blocks is below a threshold or a total number of rank-one tensors is larger than a maximum allowable value.

5. The method of claim 2 further comprises computing bj,r(d) using an alternative least square method.

6. The method of claim 3 wherein arranging the rank-one tensors by putting bj,r(1) at the top of the matrix, putting bj,r(3) at the bottom of the matrix, and placing bj,r(2) below bj,r(1) in the matrix and above bj,r(3) in the matrix.

7. The method of claim 5 wherein arranging the rank-one tensors further comprises separating rank-one tensors with a rank index of one from the remainder of the rank-one tensors and placing the rank-one tensors with a rank index of one on the left of the matrix.

8. The method of claim 6 wherein arranging the rank-one tensor further comprises placing the rank-one tensor with a rank greater than one according to the blocks they belong to in a raster-scan order.

9. The method of claim 1 further comprises compressing the two-dimensional matrix using JPEG 2000 operation.

10. The method of claim 1 further comprises storing the compressed twodimensional matrix with a header, where the header includes size of the image ensemble, size of each data block, and a vector having a dimension corresponding to the number of data blocks and each value of the vector is a number of rank-one tensors used to represent the corresponding data block in the plurality of data blocks.

11. The method of claim 1 further comprises randomly accessing a given image from the image ensemble.

12. The method of claim 11 further comprises decoding the given image as follows:


IMAGEi,j=Σr=1Rj(Bj,r(1)°Bj,r(2))Bi,j,r,(3) 


where ° is an outer product; j is the block index; Rj is the number of rank-one tensors, Bj,r(d), d=1,2 is a vector, and Bi,j,r(3), is a single value from row i of matrix B(3).

13. A computer-implemented method for compressing a collection of multi-dimensional data, comprising:
receiving, by a decomposer, multi-dimensional data for an ensemble composed of a plurality of multi-dimensional data entities;
dividing, by the decomposer, the multi-dimensional data into a plurality of data blocks, each of the data blocks having n dimensions, where n≧3;
decomposing, by the decomposer, each data block from the plurality of data blocks into a set of rank-one tensors by estimating each rank-one tensor individually, where each rank-one tensor is represented by n one-dimensional vectors;
concatenating, by the decomposer, the n one-dimensional vectors to form one composite vector for each of the plurality of data blocks and then arranging the composite vectors into a two dimensional data, where the decomposer is implemented by computer processor;
compressing the two-dimensional data using a compression operation; and
storing the compressed two-dimensional in a non-transitory data store.

14. A computer-implemented method for compressing a collection of images, comprising:
receiving, by a decomposer, image data for an image ensemble composed of a plurality of images;
dividing, by the decomposer, the image data into a plurality of data blocks, each of the data blocks having three dimensions;
decomposing, by the decomposer, each data block from the plurality of data blocks into a set of rank-one tensors by
(a) representing each data block with a rank-one tensor;
(b) for each block, estimate error reduction when an additional rank-one tensor is used;
(c) find a given data block with maximum error reduction;
(d) estimate a corresponding data block for the given data block using an additional tensor; and
(e) repeating steps (c) and (d) until an average error for the data blocks is below a threshold or a total number of rank-one tensors is larger than a maximum allowable value;

arranging, by the decomposer, the rank-one tensors for each of the plurality of data blocks into a two-dimensional matrix, where the decomposer is implemented by computer processor;
compressing the two-dimensional matrix using a compression operation; and
storing the compressed two-dimensional matrix in a non-transitory data store.

15. The method of claim 14 further comprises decomposing each data block into a rank-one tensor represented as an outerproduct of three vectors as follows


{circumflex over (χ)}j=Σr=1Rjλj,r(bj,r(1)°bj,r (2)°bj,r(3))


where ° is an outer product; j is the block index; Rj is the number of rank-one tensors and λj,r is a normalization value.

16. The method of claim 15 further comprises computing bj,r(d) using an alternative least square method.

17. The method of claim 15 wherein arranging the rank-one tensors by placing bj,r(1) at the top of the matrix, placing bj,r(3) at the bottom of the matrix, and placing bj,r(2) below bj,r(1) in the matrix and above bj,r(3) in the matrix.

18. The method of claim 17 wherein arranging the rank-one tensors further comprises separating rank-one tensors with a rank index of one from the remainder of the rank-one tensors and placing the rank-one tensors with a rank index of one on the left of the matrix.

19. The method of claim 18 wherein arranging the rank-one tensor further comprises placing the rank-one tensor with a rank greater than one according to the blocks they belong to in a raster-scan order.

20. The method of claim 14 further comprises compressing the two-dimensional matrix using JPEG 2000 operation.

21. The method of claim 14 further comprises storing the compressed twodimensional matrix with a header, where the header includes size of the image ensemble, size of each data block, and a vector having a dimension corresponding to the number of data blocks and each value of the vector is a number of rank-one tensors used to represent the corresponding data block in the plurality of data blocks.