Image Compression and Lossless Reconstruction of Digital Image

Abstract

The present invention is related to a system and method that provides 100% numerically lossless reconstruction of the image as compared from its uncompressed source. The method of the present invention is configured to compress the raw Red-Green-Blue (RGB) data from a digital image stored on a device and the method further comprises the steps of compressing the pixel (P c ) only if the RGB component of the pixel (P c ) to be compressed is predictable using the RGB component of the neighboring pixels (P N ) by using the methods (m 01 -m 16 ) else the pixel (P c ) is retained.

What is claimed is: 
     
         1 . A method that compresses the raw Red-Green-Blue (RGB) data from a digital image comprises the steps of:
 a) identifying the pixel (P c ) to be compressed;   b) identifying the neighboring pixels (P N ) preceding the pixel (P c ) to be compressed;   c) checking if the RGB component of the pixel (P c ) to be compressed is predictable using the RGB component of the neighboring pixels (P N );   d) compressing the pixel (P c ) if the RGB component of the pixel (P c ) to be compressed is predictable using the RGB component of the neighboring pixels (P N ), else
 retaining the pixel (P c ) if the RGB component of the pixel (P c ) to be compressed is not predictable using the RGB component of the neighboring pixels (P N ). 
   
     
     
         2 . The method as claimed in  claim 1 , wherein the method provides lossless reconstruction of the image when applied to a digital image. 
     
     
         3 . The method as claimed in  claim 1 , wherein the RGB component of the pixel (P c ) to be compressed is predictable using the RGB component of the neighboring pixels (P N ) by using any one of the methods (m 01 -m 16 ). 
     
     
         4 . The method as claimed in  claim 1 , wherein the method for predicting the RGB component of the pixel (P c ) to be compressed by using any one of the methods (m 01 -m 16 ) further comprises the steps of:
 a) identifying the RGB components of the pixel (P c ) to be compressed as P cRed , P cGreen  and P cBlue  wherein:
 P cRed =red component of the pixel (P c ) to be compressed, 
 P cGreen =green component of the pixel (P c ) to be compressed, 
 P cBlue =blue component of the pixel (P c ) to be compressed; 
   b) identifying the RGB components of the neighboring pixels (P N ) to be compressed as P NRed , P NGreen  and P NBlue  wherein:
 P NRed =red component of the neighboring pixel of (P c ) to be compressed, 
 P NGreen =green component of the neighboring pixel of (P c ) to be compressed, 
 P NBlue =blue component of the neighboring pixel of (P c ) to be compressed; 
   c) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using the method m 01 , wherein the method m 01  further comprises the steps of:
 checking if P cRed =P NRed  and P cGreen =P NGreen  and P cBlue =P NBlue  and the indices of the neighboring pixels (P N ) are equal, then 
 updating the neighbor map with corresponding neighboring pixel (P N ); 
 updating the method map with the corresponding method (m 01 ), else 
   d) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 02 , wherein the method m 02  further comprises the steps of:
 identifying P AvgRed , P AvgGreen , P AvgBlue , P ind  wherein:
 P AvgRed =average of the red component of the neighboring pixels (P N ) and P PrevRed , wherein P PrevRed  is the red component of the previous pixel of (P N ) along the horizontal scan line, 
 P AvgGreen =average of the green component of the neighboring pixels (P N ) and P PrevGreen , wherein P PrevGreen  is the green component of the previous pixel of (P N ) along the horizontal scanline, 
 P AvgBlue =average of the blue component of the neighboring pixels (P N ) and P PrevBlue , wherein P PrevBlue  is the blue component of the previous pixel of (P N ) along the horizontal scanline, 
 P ind =index value of the neighboring pixels (P N ); 
 
 checking if P cRed =P AvgRed +P ind , P cGreen =P AvgGreen +P ind  and P cBlue =P AvgBlue +P ind  and the indices of the neighboring pixels (P N ) are equal; then
 updating the sign bit map with one; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) and updating the method map with method (m 02 ), else
 checking if P cRed =P AvgRed −P ind , P c-Green =P AvgGreen −P ind  and P c-Blue =P AvgBlue −P ind  and the indices of the neighboring pixels (P N ) are equal; then 
 updating the sign bit map with zero; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) and updating the method map with method (m 02 ); else 
 
 
   e) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 03 , wherein the method m 03  further comprises the steps of:
 checking if P cRed =P NRed +P ind  and P cGreen =P NGreen +P ind  and P cBlue =P NBlue +P ind  and the indices of the neighboring pixels (P N ) are equal, then
 updating the sign bit map with one; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) and updating the method map with method (m 03 ), else 
 checking if P cRed =P NRed −P ind  and P cGreen =P NGreen −P ind  and P cBlue =P NBlue −P ind  and the indices of the neighboring pixels (P N ) are equal; then 
 updating the sign bit map with zero; 
 updating the method map with method (m 03 ) and updating the neighbor map with the corresponding neighboring pixel (P N ), else 
 
   f) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 04 , wherein the method m 04  further comprises the steps of:
 identifying P AvgRed , P AvgGreen , P AvgBlue ; 
 calculating P DiffRed , P DiffGreen  and P DiffBlue , wherein:
     P   DiffRed   =P   NRed   −P   prevRed , 
     P   DiffGreen   =P   NGreen   −P   prevGreen , 
     P   DiffBlue   =P   NBlue   −P   PrevBlue ; 
 
 checking if P cRed =P AvgRed +P DiffRed  and P cGreen =P AvgGreen +P DiffGreen  and P cBlue =P AvgBlue +P DiffBlue  and the indices of the neighboring pixels (P N ) are equal; then
 updating the sign bit map with one; 
 updating the method map with method (m 04 ) and updating the neighbor map with the corresponding neighboring pixel (P N ), else 
 checking if P cRed =P AvgRed −P DiffRed  and P cGreen =P AvgGreen −P DiffGreen  and P cBlue =P AvgBlue −P DiffBlue  and the indices of the neighboring pixels (P N ) are equal; then 
 updating the sign bit map with zero; 
 updating the method map with method (m 04 ) and updating the neighbor map with the corresponding neighboring pixel (P N ); 
 
   g) else checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 05 , wherein the method m 05  further comprises the steps of:
 checking if P cRed =P AvgRed +P DiffRed +P ind  and P cGreen =P AvgGreen +P DiffGreen +P ind  and P cBlue =P AvgBlue +P DiffBlue +P ind  and the indices of the neighboring pixels (P N ) are equal; then
 updating the sign bit map with one; 
 updating the method map with method (m 05 ); 
 updating the neighbor map with the corresponding neighboring pixel (P N ), else 
 checking if P cRed =P AvgRed −P DiffRed −P ind  and P cGreen =P AvgGreen −P DiffGreen −P ind  and P cBlue =P AvgBlue −P DiffBlue −P ind  and the indices of neighboring pixels (P N ) are equal, then 
 updating the sign bit map with zero; 
 updating the method map with method (m 05 ) and updating the neighbor map with the corresponding neighboring pixel (P N ); 
 
   h) else checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 06 , wherein the method m 06  further comprises the steps of:
 calculating D NRed , D NGreen  and D NBlue , wherein: 
   
       ti  D   NRed   =P   cRed   −P   NRed ,
     D   NGreen   =P   cGreen   −P   NGreen , 
     D   NBlue   =P   cBlue   −P   NBlue ; 
   checking if D NRed =D NGreen  and D NRed =D NBlue  and the value of D NRed  lies between 1 and 8; then
 updating the sign bit map with one; 
 updating the component difference map with D NRed ; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) and updating the method map with method (m 06 ), else 
 checking if D NRed =D NGreen  and D NRed =D NBlue  and the value of D NRed  lies between −1 and −8; then 
 updating the sign bit map with zero; 
 updating the component difference map with D NRed ; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) and updating the method map with method (m 06 ), else 
   
 i) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 07 , wherein the method m 07  comprises the steps of:
 calculating D NRed , D NGreen  and D NBlue  wherein:
     D   NRed   =P   cRed   −P   AvgRed   +P   ind , 
     D   NGreen   =P   cGreen   −P   AvgGreen   +P   ind , 
     D   NBlue   =P   cBlue   −P   AvgBlue   +P   ind ; 
 
 checking if D NRed =D NGreen  and D NRed =D NBlue  and the value of D NRed  lies between 1 and 8;
 updating the sign bit map with one; 
 updating the component difference map with D NRed ; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) and updating the method map with method (m 07 ); or else 
 checking if D NRed =D NGreen  and D NRed =D NBlue  and the value of D NRed  lies between −1 and −8; 
 updating the sign bit map with zero; 
 updating the component difference map with D NRed ; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) and updating the method map with method (m 07 ), else 
 
 
 j) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 08 , wherein the method m 08  further comprises the steps of:
 identifying P PrevRed , P PrevGreen  and P PrevBlue  wherein:
 P PrevRed =red component of the previous pixel of P N  along the horizontal scanline, 
 P PrevGreen =green component of the previous pixel of P N  along the horizontal scanline, 
 P PrevBlue =blue component of the previous pixel of P N  along the horizontal scanline; 
 
 checking if P cRed =P PrevRed +P ind  and P cGreen =P PrevGreen +P ind  and P cBlue =P PrevBlue +P ind  and the indices of the neighboring pixels (P N ) are not equal; then
 updating the sign bit map with one; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method m 08 , else 
 checking if P cRed =P PrevRed −P ind  and P cGreen =P PrevGreen −P ind  and P cBlue =P PrevBlue −P ind  and the indices of the neighboring pixels (P N ) are not equal; 
 updating the sign bit map with zero; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method m 08 , else 
 
 
 k) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 09 , wherein the method m 09  further comprises the steps of:
 checking if P cRed =P PrevRed +P ind +P DiffRed  and P cGreen =P PrevGreen +P ind +P DiffGreen  and P cBlue =P PrevBlue +P ind +P DiffBlue  and the indices of the neighboring pixels (P N ) are not equal then;
 updating the sign bit map with one; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method m 09 ; or else 
 checking if P cRed =P PrevRed =P ind −P DiffRed  and P cGreen =P PrevGreen −P ind −P DiffGreen  and P cBlue =P PrevBlue −P ind −P DiffBlue  and the indices of the neighboring pixels (P N ) are not equal then; 
 updating the sign bit map with zero; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method m 09 ; else 
 
 
 l) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 10 , wherein the method m 10  further comprises the steps of:
 checking if P cRed =P NRed −P ind  and P cGreen =P NGreen +P ind  and P cBlue =P NBlue  P ind  and the indices of the neighboring pixels (P N ) are not equal then;
 updating the sign bit map with one; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method m 10 , or else 
 checking if P cRed =P NRed −P ind  and P cGreen =P NGreen −P ind  and P cBlue =P NBlue −P ind  and the indices of the neighboring pixels (P N ) are not equal then; 
 updating the sign bit map with zero; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method m 10 , else 
 
 
 m) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 12 , wherein the method m 11  further comprises the steps of:
 identifying P NPrevRed , P NPrevGreen  and P NPrevBlue  wherein:
     P   NPrevRed   =P   (NRed−Pind) , 
     P   NPrevGreen   =P   (NGreen−Pind) , 
     P   NPrevBlue   =P   (NBlue−Pind) ; 
 
 checking if P cRed =P NPrevRed +P ind  and P cGreen =P NPrevGreen +P ind  and P cBlue =P NPrevBlue +P ind  and the indices of the neighboring pixels (P N ) are not equal then;
 updating the sign bit map with one; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method m 11 , else 
 checking if P cRed =P NPrevRed −P ind  and P CGreen =P NPrevGreen −P ind  and P cBlue =P NPrevBlue −P ind  and the indices of the neighboring pixels (P N ) are not equal then; 
 updating the sign bit map with zero; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method m 11 ; else 
 
 
 n) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 12 , wherein the method m 12  further comprises the steps of:
 identifying P CPrevred , P CPrevgreen , P CPrevblue , wherein:
 P CPrevred =red component of the previous pixel of P c , 
 P CPrevgreen =green component of the previous pixel of P c , 
 P CPrevblue =blue component of the previous pixel of P c ; 
 
 calculating D CPrevDiffRed , D CPrevDiffBlue  and D CPrevDiffGreen  wherein:
     D   CPrevDiffRed   =P   cRed   −P   CPrevred , 
     D   CPrevDiffBlue   =P   cBlue   −P   CPrevblue , 
     D   CPrevDiffGreen   =P   cGreen   −P   cPrevGreen ; 
 
 checking if D CPrevDiffRed , D CPrevDiffBlue  and D CPrevDiffGreen  lies between 1 and 8; then
 updating the sign bit map with one; 
 updating the component difference map with D CPrevDiffRed , D CPrevDiffBlue  and 
 D CPrevDiffGreen ; 
 updating the method map with method m 12 , or else 
 checking if D CPrevDiffRed , D CPrevDiffBlue  and D CPrevDiffGreen  lies between −1 and −8 then 
 updating the sign bit map with zero; 
 updating the component difference map with D CPrevDifed , D CPrevDiffBlue  and D CPrevDiffGreen ; 
 updating the method map with method m 12 , else 
 
 
 o) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method M 13 , wherein the method m 13  further comprises the steps of:
 calculating D DiffRed , D DiffGreen  and D DiffBlue , wherein:
     D   DiffRed   =P   cRed   −P   NRed   +P   ind , 
     D   DiffBlue   =P   cBlue   −P   NBlue   +P   ind , 
     D   DiffGreen   =P   cGreen   −P   NGreen   +P   ind ; 
 
 checking if D DiffRed , D DiffBlue  and D DiffGreen  lies between 1 and 8;
 updating the sign bit map with one; 
 updating the component difference map with D DiffRed , D DiffBlue  and D DiffGreen ; 
 updating the neighbor map with the corresponding neighbor pixel (P N ); 
 updating the method map with the corresponding method m 13 , else 
 checking if D DiffRed , D DiffBlue  and D DiffGreen  lies between −1 and −8; 
 updating the sign bit element with zero; 
 updating the component difference map with D DiffRed , D DiffBlue  and D DiffGreen ; 
 updating the neighbor map with the corresponding neighbor pixel (P N ); 
 updating the method map with the corresponding method m 13 , else 
 
 
 p) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 14 , wherein the method m 14  further comprises the steps of:
 calculating D AvgDiffRed , D AvgDiffGreen  and D AvgDiffBlue , wherein:
     D   AvgDiffRed   =P   cRed   −P   AvgRed , 
     D   AvgDiffGreen   =P   cGreen   −P   AvgGreen , 
     D   AvgDiffBlue   =P   cBlue   −P   AvgBlue ; 
 checking if D AvgDiffRed  and D AvgDiffGreen  and D AvgDiffBlue  lies between 1 and 8; 
 updating the sign bit map with one; 
 updating the component difference map with D AvgDiffRed , D AvgDiffGreen  and D AvgDiffBlue ; 
 updating the neighbor map with the corresponding neighboring pixel (P N ); 
 updating the method map with method m 14 , else 
 checking if D AvgDiffRed  and D AvgDiffGreen  and D AvgDiffBlue  lies between −1 and −8; 
 updating the sign bit element with zero; 
 updating the component difference map with D AvgDiffRed , D AvgDiffGreen  and D AvgDiffBlue ; 
 updating the neighbor map with corresponding neighboring pixel (P N ); 
 updating the method map with method m 14 , else 
 
 
 q) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 15 , wherein the method m 15  further comprises the steps of:
 calculating D NDiffRed , D NDiffGreen  and D NDiffBlue , wherein:
     D   NDiffRed   =P   cRed   −P   NRed , 
     D   NDiffGreen   =P   cGreen   −P   NGreen , 
     D   NDiffBlue   =P   cBlue   −P   NBlue ; 
 
 checking if D NDiffRed  and D NDiffGreen  and D NDiffBlue  lies between 1 and 8;
 updating the sign bit map with one; 
 updating the component difference map with D NDiffRed  and D NDiffGreen  and D NDiffBlue ; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method m 15 ; or else 
 checking if D NDiffRed  and D NDiffGreen  and D NDiffBlue  lies between −1 and −8; 
 updating the sign bit map with zero; 
 updating the component difference map with D NDiffRed  and D NDiffGreen  and D NDiffBlue ; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method m 15 , else 
 
 
 r) checking if the RGB components of the pixel (P c ) to be compressed is predictable using the RGB components of the neighboring pixels (P N ) by using method m 16 , wherein the method m 16  further comprises the steps of:
 calculating D NDiffRed , D NDiffGreen  and D NDiffBlue  as:
     D   NDiffRed   =P   cRed   −P   NRed   +P   ind , 
     D   NDiffGreen   =P   cGreen   −P   NGreen   +P   ind , 
     D   NDiffBlue   =P   cBlue   −P   NBlue   +P   ind ; 
 
 checking if D NDiffRed  and D NDiffGreen  and D NDiffBlue  lies between 1 and 8;
 updating the sign bit map with one; 
 updating the component difference map with D NDiffRed , D NDiffGreen  and D NDiffBlue ; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method (m 16 ), else 
 checking if D NDiffRed  and D NDiffGreen  and D NDiffBlue  lies between −1 and −8; 
 updating the sign bit element with zero; 
 updating the component difference map with D NDiffRed , D NDiffGreen  and D NDiffBlue ; 
 updating the neighbor map with the corresponding neighboring pixel (P N ) for each Red, Green and Blue component; 
 updating the method map with method (m 16 ). 
 
 
 
     
     
         5 . The method as claimed in  claim 4 , wherein the method further comprises the steps of updating the compression map with one, if the RGB component of the pixel (P c ) to be compressed is predictable using any one of the methods (m 01 -m 16 ), else updating the compression map with zero. 
     
     
         6 . The method as claimed in  claim 4 , wherein the neighboring pixels (P N ) are taken within a cycle of four reference neighboring pixels preceding the pixel (P c ) to be compressed. 
     
     
         7 . The method as claimed in  claim 4 , wherein the neighbor map is the bit wise binary representation of each neighboring pixel ‘P N ’ that is used for predicting the RGB component of the pixel ‘P c ’ to be compressed. 
     
     
         8 . The method as claimed in  claim 4 , wherein the method map is the bit wise binary representation of method (m 01 -m 16 ) denoting how each pixel P c  to be compressed is related to its neighboring pixel ‘P N ’. 
     
     
         9 . The method as claimed in  claim 4 , wherein the sign bit map is the bit wise binary representation of the difference between the comparisons used in method (m 01 -m 16 ). 
     
     
         10 . The device as claimed in  claim 4 , wherein the component difference map is the bit wise binary representation of the difference between the RGB components of the pixel (P c ) to be compressed and the RGB components of the neighboring pixels (P N ). 
     
     
         11 . The method as claimed in  claim 1 , wherein the method is implemented in a personal computer, a laptop computer, a computer workstation, a server, a mainframe computer, a handheld computer, a personal digital assistant, a cellular/mobile telephone, a smart appliance, a gaming console, a digital camera, a digital camcorder, a camera phone, a iPod®, a video player, a DVD writer/player, a television or a home entertainment system.