I18N_Arabic
[ class tree: I18N_Arabic ] [ index: I18N_Arabic ] [ all elements ]

Source for file CompressStr.php

Documentation is available at CompressStr.php

  1. <?php
  2. /**
  3.  * ----------------------------------------------------------------------
  4.  *  
  5.  * Copyright (c) 2006-2016 Khaled Al-Sham'aa.
  6.  *  
  7.  * http://www.ar-php.org
  8.  *  
  9.  * PHP Version 5
  10.  *  
  11.  * ----------------------------------------------------------------------
  12.  *  
  13.  * LICENSE
  14.  *
  15.  * This program is open source product; you can redistribute it and/or
  16.  * modify it under the terms of the GNU Lesser General Public License (LGPL)
  17.  * as published by the Free Software Foundation; either version 3
  18.  * of the License, or (at your option) any later version.
  19.  *  
  20.  * This program is distributed in the hope that it will be useful,
  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  * GNU Lesser General Public License for more details.
  24.  *  
  25.  * You should have received a copy of the GNU Lesser General Public License
  26.  * along with this program.  If not, see <http://www.gnu.org/licenses/lgpl.txt>.
  27.  *  
  28.  * ----------------------------------------------------------------------
  29.  *  
  30.  * Class Name: Compress string using Huffman-like coding
  31.  *  
  32.  * Filename:   CompressStr.php
  33.  *  
  34.  * Original    Author(s): Khaled Al-Sham'aa <khaled@ar-php.org>
  35.  *  
  36.  * Purpose:    This class will compress given string in binary format
  37.  *             using variable-length code table (derived in a particular way
  38.  *             based on the estimated probability of occurrence for each
  39.  *             possible value of the source symbol) for encoding a source symbol
  40.  *              
  41.  * ----------------------------------------------------------------------
  42.  *  
  43.  * Arabic Compress String Class
  44.  *
  45.  * Compress string using Huffman-like coding
  46.  *
  47.  * This class compresses text strings into roughly 70% of their original size
  48.  * by benefit from using compact coding for most frequented letters in a given
  49.  * language. This algorithm associated with text language, so you will find 6
  50.  * different classes for the following languages: Arabic, English, French,
  51.  * German, Italian and Spanish language.
  52.  * 
  53.  * Benefits of this compress algorithm include:
  54.  * 
  55.  * - It is written in pure PHP code, so there is no need to any
  56.  *   PHP extensions to use it.
  57.  * - You can search in compressed string directly without any need uncompress
  58.  *   text before search in.
  59.  * - You can get original string length directly without need to uncompress
  60.  *   compressed text.
  61.  * 
  62.  * Note:
  63.  * Unfortunately text compressed using this algorithm lose the structure that
  64.  * normal zip algorithm used, so benefits from using ZLib functions on this
  65.  * text will be reduced.
  66.  * 
  67.  * There is another drawback, this algorithm working only on text from a given
  68.  * language, it does not working fine on binary files like images or PDF.
  69.  * 
  70.  * Example:
  71.  * <code>
  72.  * include('./I18N/Arabic.php');
  73.  * $obj = new I18N_Arabic('CompressStr');
  74.  * 
  75.  * $obj->setInputCharset('windows-1256');
  76.  * $obj->setOutputCharset('windows-1256');
  77.  * 
  78.  * $file = 'Compress/ar_example.txt';
  79.  * $fh   = fopen($file, 'r');
  80.  * $str  = fread($fh, filesize($file));
  81.  * fclose($fh);
  82.  * 
  83.  * $zip = $obj->compress($str);
  84.  * 
  85.  * $before = strlen($str);
  86.  * $after  = strlen($zip);
  87.  * $rate   = round($after * 100 / $before);
  88.  * 
  89.  * echo "String size before was: $before Byte<br>";
  90.  * echo "Compressed string size after is: $after Byte<br>";
  91.  * echo "Rate $rate %<hr>";
  92.  * 
  93.  * $str = $obj->decompress($zip);
  94.  * 
  95.  * if ($obj->search($zip, $word)) {
  96.  *     echo "Search for $word in zipped string and find it<hr>";
  97.  * } else {
  98.  *     echo "Search for $word in zipped string and do not find it<hr>";
  99.  * }
  100.  * 
  101.  * $len = $obj->length($zip);
  102.  * echo "Original length of zipped string is $len Byte<hr>";
  103.  * 
  104.  * echo '<div dir="rtl" align="justify">'.nl2br($str).'</div>';
  105.  * </code>
  106.  *                
  107.  * @category  I18N
  108.  * @package   I18N_Arabic
  109.  * @author    Khaled Al-Sham'aa <khaled@ar-php.org>
  110.  * @copyright 2006-2016 Khaled Al-Sham'aa
  111.  *    
  112.  * @license   LGPL <http://www.gnu.org/licenses/lgpl.txt>
  113.  * @link      http://www.ar-php.org
  114.  */
  115.  
  116. /**
  117.  * This PHP class compress Arabic string using Huffman-like coding
  118.  *  
  119.  * @category  I18N
  120.  * @package   I18N_Arabic
  121.  * @author    Khaled Al-Sham'aa <khaled@ar-php.org>
  122.  * @copyright 2006-2016 Khaled Al-Sham'aa
  123.  *    
  124.  * @license   LGPL <http://www.gnu.org/licenses/lgpl.txt>
  125.  * @link      http://www.ar-php.org
  126.  */ 
  127. {
  128.     private static $_encode;
  129.     private static $_binary;
  130.     
  131.     private static $_hex;
  132.     private static $_bin;
  133.    
  134.     /**
  135.      * Loads initialize values
  136.      *
  137.      * @ignore
  138.      */         
  139.     public function __construct()
  140.     {
  141.         self::$_encode iconv('utf-8''cp1256'' الميوتة');
  142.         self::$_binary '0000|0001|0010|0011|0100|0101|0110|0111|';
  143.     
  144.         self::$_hex '0123456789abcdef';
  145.         self::$_bin '0000|0001|0010|0011|0100|0101|0110|0111|1000|';
  146.         self::$_bin self::$_bin '1001|1010|1011|1100|1101|1110|1111|';
  147.     }
  148.  
  149.     /**
  150.      * Set required encode and binary hash of most probably character in
  151.      * selected language
  152.      *      
  153.      * @param string $lang [en, fr, gr, it, sp, ar] Language profile selected
  154.      *      
  155.      * @return object $this to build a fluent interface
  156.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  157.      */
  158.     public function setLang($lang
  159.     {
  160.         switch ($lang{
  161.         case 'en':
  162.             self::$_encode ' etaoins';
  163.             break;
  164.         case 'fr':
  165.             self::$_encode ' enasriu';
  166.             break;
  167.         case 'gr':
  168.             self::$_encode ' enristu';
  169.             break;
  170.         case 'it':
  171.             self::$_encode ' eiaorln';
  172.             break;
  173.         case 'sp':
  174.             self::$_encode ' eaosrin';
  175.             break;
  176.         default:
  177.             self::$_encode iconv('utf-8''cp1256'' الميوتة');
  178.         }
  179.  
  180.         self::$_binary '0000|0001|0010|0011|0100|0101|0110|0111|';
  181.         
  182.         return $this;
  183.     }
  184.     
  185.     /**
  186.      * Compress the given string using the Huffman-like coding
  187.      *      
  188.      * @param string $str The text to compress
  189.      *                    
  190.      * @return binary The compressed string in binary format
  191.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  192.      */
  193.     public static function compress($str
  194.     {
  195.         $str  iconv('utf-8''cp1256'$str);
  196.  
  197.         $bits self::str2bits($str);
  198.         $hex  self::bits2hex($bits);
  199.         $bin  pack('h*'$hex);
  200.  
  201.         return $bin;
  202.     }
  203.  
  204.     /**
  205.      * Uncompress a compressed string
  206.      *       
  207.      * @param binary $bin The text compressed by compress().
  208.      *                    
  209.      * @return string The original uncompressed string
  210.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  211.      */
  212.     public static function decompress($bin
  213.     {
  214.         $temp  unpack('h*'$bin);
  215.         $bytes $temp[1];
  216.  
  217.         $bits self::hex2bits($bytes);
  218.         $str  self::bits2str($bits);
  219.         $str  iconv('cp1256''utf-8'$str);
  220.  
  221.         return $str;
  222.     }
  223.  
  224.     /**
  225.      * Search a compressed string for a given word
  226.      *      
  227.      * @param binary $bin  Compressed binary string
  228.      * @param string $word The string you looking for
  229.      *                    
  230.      * @return boolean True if found and False if not found
  231.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  232.      */
  233.     public static function search($bin$word
  234.     {
  235.         $word  iconv('utf-8''cp1256'$word);
  236.         $wBits self::str2bits($word);
  237.  
  238.         $temp  unpack('h*'$bin);
  239.         $bytes $temp[1];
  240.         $bits  self::hex2bits($bytes);
  241.  
  242.         if (strpos($bits$wBits)) {
  243.             return true;
  244.         else {
  245.             return false;
  246.         }
  247.     }
  248.  
  249.     /**
  250.      * Retrieve the original string length
  251.      *      
  252.      * @param binary $bin Compressed binary string
  253.      *      
  254.      * @return integer Original string length
  255.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  256.      */
  257.     public static function length($bin
  258.     {
  259.         $temp  unpack('h*'$bin);
  260.         $bytes $temp[1];
  261.         $bits  self::hex2bits($bytes);
  262.  
  263.         $count 0;
  264.         $i     0;
  265.  
  266.         while (isset($bits[$i])) {
  267.             $count++;
  268.             if ($bits[$i== 1{
  269.                 $i += 9;
  270.             else {
  271.                 $i += 4;
  272.             }
  273.         }
  274.  
  275.         return $count;
  276.     }
  277.  
  278.     /**
  279.      * Convert textual string into binary string
  280.      *      
  281.      * @param string $str The textual string to convert
  282.      *       
  283.      * @return binary The binary representation of textual string
  284.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  285.      */
  286.     protected static function str2bits($str
  287.     {
  288.         $bits  '';
  289.         $total strlen($str);
  290.  
  291.         $i = -1;
  292.         while (++$i $total{
  293.             $char $str[$i];
  294.             $pos  strpos(self::$_encode$char);
  295.  
  296.             if ($pos !== false{
  297.                 $bits .= substr(self::$_binary$pos*54);
  298.             else {
  299.                 $int   ord($char);
  300.                 $bits .= '1'.substr(self::$_bin(int)($int/16)*54);
  301.                 $bits .= substr(self::$_bin($int%16)*54);
  302.             }
  303.         }
  304.  
  305.         // Complete nibbel
  306.         $add   strlen($bits4;
  307.         $bits .= str_repeat('0'$add);
  308.  
  309.         return $bits;
  310.     }
  311.  
  312.     /**
  313.      * Convert binary string into textual string
  314.      *      
  315.      * @param binary $bits The binary string to convert
  316.      *       
  317.      * @return string The textual representation of binary string
  318.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  319.      */
  320.     protected static function bits2str($bits
  321.     {
  322.         $str '';
  323.         while ($bits{
  324.             $flag substr($bits01);
  325.             $bits substr($bits1);
  326.  
  327.             if ($flag == 1{
  328.                 $byte substr($bits08);
  329.                 $bits substr($bits8);
  330.  
  331.                 if ($bits || strlen($code== 8{
  332.                     $int  base_convert($byte210);
  333.                     $char chr($int);
  334.                     $str .= $char;
  335.                 }
  336.             else {
  337.                 $code substr($bits03);
  338.                 $bits substr($bits3);
  339.  
  340.                 if ($bits || strlen($code== 3{
  341.                     $pos  strpos(self::$_binary"0$code|");
  342.                     $str .= substr(self::$_encode$pos/51);
  343.                 }
  344.             }
  345.         }
  346.  
  347.         return $str;
  348.     }
  349.  
  350.     /**
  351.      * Convert binary string into hexadecimal string
  352.      *      
  353.      * @param binary $bits The binary string to convert
  354.      *       
  355.      * @return hexadecimal The hexadecimal representation of binary string
  356.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  357.      */
  358.     protected static function bits2hex($bits
  359.     {
  360.         $hex   '';
  361.         $total strlen($bits4;
  362.  
  363.         for ($i 0$i $total$i++{
  364.             $nibbel substr($bits$i*44);
  365.  
  366.             $pos  strpos(self::$_bin$nibbel);
  367.             $hex .= substr(self::$_hex$pos/51);
  368.         }
  369.  
  370.         return $hex;
  371.     }
  372.  
  373.     /**
  374.      * Convert hexadecimal string into binary string
  375.      *      
  376.      * @param hexadecimal $hex The hexadezimal string to convert
  377.      *       
  378.      * @return binary The binary representation of hexadecimal string
  379.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  380.      */
  381.     protected static function hex2bits($hex
  382.     {
  383.         $bits  '';
  384.         $total strlen($hex);
  385.  
  386.         for ($i 0$i $total$i++{
  387.             $pos   strpos(self::$_hex$hex[$i]);
  388.             $bits .= substr(self::$_bin$pos*54);
  389.         }
  390.  
  391.         return $bits;
  392.     }
  393. }

Documentation generated on Fri, 01 Jan 2016 10:25:55 +0200 by phpDocumentor 1.4.0