Perceptual hashing algorithm in PHP

The advantage of perceptual hashing is that it is simple and fast, and is not affected by the scaling of the image size. The disadvantage is that the content of the image cannot be changed. In practical applications, the more powerful pHash algorithm and SIFT algorithm are often used, which can identify the deformation of images. As long as the distortion does not exceed 25%, they can match the original image.

Perceptual Hash Algorithm

count < =5 matches the most similar
count > 10 two different images
var_dump(ImageHash:: run('./1.png', './psb.jpg'));

<?php
class ImageHash {
  const FILE_NOT_FOUND = &#39;-1&#39;;
  const FILE_EXTNAME_ILLEGAL = &#39;-2&#39;;
  private function __construct() {}
  public static function run($src1, $src2) {
    static $self;
    if(!$self) $self = new static;
    if(!is_file($src1) || !is_file($src2)) exit(self::FILE_NOT_FOUND);
    $hash1 = $self->getHashValue($src1);
    $hash2 = $self->getHashValue($src2);
    if(strlen($hash1) !== strlen($hash2)) return false;
    $count = 0;
    $len = strlen($hash1);
    for($i = 0; $i < $len; $i++) if($hash1[$i] !== $hash2[$i]) $count++;
    return $count <= 10 ? true : false;
  }
  public function getImage($file) {
    $extname = pathinfo($file, PATHINFO_EXTENSION);
    if(!in_array($extname, [&#39;jpg&#39;,&#39;jpeg&#39;,&#39;png&#39;,&#39;gif&#39;])) exit(self::FILE_EXTNAME_ILLEGAL);
    $img = call_user_func(&#39;imagecreatefrom&#39;. ( $extname == &#39;jpg&#39; ? &#39;jpeg&#39; : $extname ) , $file);
    return $img;
  }
  public function getHashValue($file) {
    $w = 8;
    $h = 8;
    $img = imagecreatetruecolor($w, $h);
    list($src_w, $src_h) = getimagesize($file);
    $src = $this->getImage($file);
    imagecopyresampled($img, $src, 0, 0, 0, 0, $w, $h, $src_w, $src_h);
    imagedestroy($src);
    $total = 0;
    $array = array();
    for( $y = 0; $y < $h; $y++) {
      for ($x = 0; $x < $w; $x++) {
        $gray = (imagecolorat($img, $x, $y) >> 8) & 0xFF;
        if(!isset($array[$y])) $array[$y] = array();
        $array[$y][$x] = $gray;
        $total += $gray;
      }
    }
    imagedestroy($img);
    $average = intval($total / ($w * $h * 2));
    $hash = &#39;&#39;;
    for($y = 0; $y < $h; $y++) {
      for($x = 0; $x < $w; $x++) {
        $hash .= ($array[$y][$x] >= $average) ? &#39;1&#39; : &#39;0&#39;;
      }
    }
    var_dump($hash);
    return $hash;
  }
}
var_dump(ImageHash::run(&#39;./1.png&#39;, &#39;./psb.jpg&#39;));

Method 2:

hash($f);
 }
 return $isString ? $result[0] : $result;
 }
 public function checkIsSimilarImg($imgHash, $otherImgHash){
 if (file_exists($imgHash) && file_exists($otherImgHash)){
  $imgHash = $this->run($imgHash);
  $otherImgHash = $this->run($otherImgHash);
 }
 if (strlen($imgHash) !== strlen($otherImgHash)) return false;
 $count = 0;
 $len = strlen($imgHash);
 for($i=0;$i<$len;$i++){
  if ($imgHash{$i} !== $otherImgHash{$i}){
  $count++;
  }
 }
 return $count <= (5 * $rate * $rate) ? true : false;
 }
 public function hash($file){
 if (!file_exists($file)){
  return false;
 }
 $height = 8 * $this->rate;
 $width = 8 * $this->rate;
 $img = imagecreatetruecolor($width, $height);
 list($w, $h) = getimagesize($file);
 $source = $this->createImg($file);
 imagecopyresampled($img, $source, 0, 0, 0, 0, $width, $height, $w, $h);
 $value = $this->getHashValue($img);
 imagedestroy($img);
 return $value;
 }
 public function getHashValue($img){
 $width = imagesx($img);
 $height = imagesy($img);
 $total = 0;
 $array = array();
 for ($y=0;$y<$height;$y++){
  for ($x=0;$x<$width;$x++){
  $gray = ( imagecolorat($img, $x, $y) >> 8 ) & 0xFF;
  if (!is_array($array[$y])){
   $array[$y] = array();
  }
  $array[$y][$x] = $gray;
  $total += $gray;
  }
 }
 $average = intval($total / (64 * $this->rate * $this->rate));
 $result = &#39;&#39;;
 for ($y=0;$y<$height;$y++){
  for ($x=0;$x<$width;$x++){
  if ($array[$y][$x] >= $average){
   $result .= &#39;1&#39;;
  }else{
   $result .= &#39;0&#39;;
  }
  }
 }
 return $result;
 }
 public function createImg($file){
 $ext = $this->getFileExt($file);
 if ($ext === &#39;jpeg&#39;) $ext = &#39;jpg&#39;;
 $img = null;
 switch ($ext){
  case &#39;png&#39; : $img = imagecreatefrompng($file);break;
  case &#39;jpg&#39; : $img = imagecreatefromjpeg($file);break;
  case &#39;gif&#39; : $img = imagecreatefromgif($file);
 }
 return $img;
 }
 public function getFileExt($file){
 $infos = explode(&#39;.&#39;, $file);
 $ext = strtolower($infos[count($infos) - 1]);
 return $ext;
 }
}

The calling method is as follows:

 require_once "Imghash.class.php";
$instance = ImgHash::getInstance();
$result = $instance->checkIsSimilarImg('chenyin/IMG_3214.png', 'chenyin/IMG_3212.JPG');

If $ If the result value is true, it indicates that the two pictures are similar, otherwise they are not similar.

Summary: The above is the entire content of this article, I hope it will be helpful to everyone's study.

Related recommendations:

Detailed explanation of infinite level classification using PHP (iterative recursion)

Singleton in PHP Detailed explanation and examples of mode and factory mode

Detailed explanation and examples of connecting Mongodb to remote database under PHP

The above is the detailed content of Perceptual hashing algorithm in PHP. For more information, please follow other related articles on the PHP Chinese website!