vendor/gregwar/captcha/src/Gregwar/Captcha/CaptchaBuilder.php line 453

  1. <?php
  3. namespace Gregwar\Captcha;
  5. use \Exception;
  7. /**
  8.  * Builds a new captcha image
  9.  * Uses the fingerprint parameter, if one is passed, to generate the same image
  10.  *
  11.  * @author Gregwar <g.passault@gmail.com>
  12.  * @author Jeremy Livingston <jeremy.j.livingston@gmail.com>
  13.  */
  14. class CaptchaBuilder implements CaptchaBuilderInterface
  15. {
  16.     /**
  17.      * @var array
  18.      */
  19.     protected $fingerprint = array();
  21.     /**
  22.      * @var bool
  23.      */
  24.     protected $useFingerprint = false;
  26.     /**
  27.      * @var array
  28.      */
  29.     protected $textColor = array();
  31.     /**
  32.      * @var array
  33.      */
  34.     protected $lineColor = null;
  36.     /**
  37.      * @var array
  38.      */
  39.     protected $backgroundColor = null;
  41.     /**
  42.      * @var array
  43.      */
  44.     protected $backgroundImages = array();
  46.     /**
  47.      * @var resource
  48.      */
  49.     protected $contents = null;
  51.     /**
  52.      * @var string
  53.      */
  54.     protected $phrase = null;
  56.     /**
  57.      * @var PhraseBuilderInterface
  58.      */
  59.     protected $builder;
  61.     /**
  62.      * @var bool
  63.      */
  64.     protected $distortion = true;
  66.     /**
  67.      * The maximum number of lines to draw in front of
  68.      * the image. null - use default algorithm
  69.      */
  70.     protected $maxFrontLines = null;
  72.     /**
  73.      * The maximum number of lines to draw behind
  74.      * the image. null - use default algorithm
  75.      */
  76.     protected $maxBehindLines = null;
  78.     /**
  79.      * The maximum angle of char
  80.      */
  81.     protected $maxAngle = 8;
  83.     /**
  84.      * The maximum offset of char
  85.      */
  86.     protected $maxOffset = 5;
  88.     /**
  89.      * Is the interpolation enabled ?
  90.      *
  91.      * @var bool
  92.      */
  93.     protected $interpolation = true;
  95.     /**
  96.      * Ignore all effects
  97.      *
  98.      * @var bool
  99.      */
  100.     protected $ignoreAllEffects = false;
  102.     /**
  103.      * Allowed image types for the background images
  104.      *
  105.      * @var array
  106.      */
  107.     protected $allowedBackgroundImageTypes = array('image/png', 'image/jpeg', 'image/gif');
  109.     /**
  110.      * The image contents
  111.      */
  112.     public function getContents()
  113.     {
  114.         return $this->contents;
  115.     }
  117.     /**
  118.      * Enable/Disables the interpolation
  119.      *
  120.      * @param $interpolate bool  True to enable, false to disable
  121.      *
  122.      * @return CaptchaBuilder
  123.      */
  124.     public function setInterpolation($interpolate = true)
  125.     {
  126.         $this->interpolation = $interpolate;
  128.         return $this;
  129.     }
  131.     /**
  132.      * Temporary dir, for OCR check
  133.      */
  134.     public $tempDir = 'temp/';
  136.     public function __construct($phrase = null, PhraseBuilderInterface $builder = null)
  137.     {
  138.         if ($builder === null) {
  139.             $this->builder = new PhraseBuilder;
  140.         } else {
  141.             $this->builder = $builder;
  142.         }
  143.         
  144.         $this->phrase = is_string($phrase) ? $phrase : $this->builder->build($phrase);
  145.     }
  147.     /**
  148.      * Setting the phrase
  149.      */
  150.     public function setPhrase($phrase)
  151.     {
  152.         $this->phrase = (string) $phrase;
  153.     }
  155.     /**
  156.      * Enables/disable distortion
  157.      */
  158.     public function setDistortion($distortion)
  159.     {
  160.         $this->distortion = (bool) $distortion;
  162.         return $this;
  163.     }
  165.     public function setMaxBehindLines($maxBehindLines)
  166.     {
  167.         $this->maxBehindLines = $maxBehindLines;
  169.         return $this;
  170.     }
  172.     public function setMaxFrontLines($maxFrontLines)
  173.     {
  174.         $this->maxFrontLines = $maxFrontLines;
  176.         return $this;
  177.     }
  179.     public function setMaxAngle($maxAngle)
  180.     {
  181.         $this->maxAngle = $maxAngle;
  183.         return $this;
  184.     }
  186.     public function setMaxOffset($maxOffset)
  187.     {
  188.         $this->maxOffset = $maxOffset;
  190.         return $this;
  191.     }
  193.     /**
  194.      * Gets the captcha phrase
  195.      */
  196.     public function getPhrase()
  197.     {
  198.         return $this->phrase;
  199.     }
  201.     /**
  202.      * Returns true if the given phrase is good
  203.      */
  204.     public function testPhrase($phrase)
  205.     {
  206.         return ($this->builder->niceize($phrase) == $this->builder->niceize($this->getPhrase()));
  207.     }
  209.     /**
  210.      * Instantiation
  211.      */
  212.     public static function create($phrase = null)
  213.     {
  214.         return new self($phrase);
  215.     }
  217.     /**
  218.      * Sets the text color to use
  219.      */
  220.     public function setTextColor($r, $g, $b)
  221.     {
  222.         $this->textColor = array($r, $g, $b);
  224.         return $this;
  225.     }
  227.     /**
  228.      * Sets the background color to use
  229.      */
  230.     public function setBackgroundColor($r, $g, $b)
  231.     {
  232.         $this->backgroundColor = array($r, $g, $b);
  234.         return $this;
  235.     }
  237.     public function setLineColor($r, $g, $b)
  238.     {
  239.         $this->lineColor = array($r, $g, $b);
  241.         return $this;
  242.     }
  244.     /**
  245.      * Sets the ignoreAllEffects value
  246.      *
  247.      * @param bool $ignoreAllEffects
  248.      * @return CaptchaBuilder
  249.      */
  250.     public function setIgnoreAllEffects($ignoreAllEffects)
  251.     {
  252.         $this->ignoreAllEffects = $ignoreAllEffects;
  254.         return $this;
  255.     }
  257.     /**
  258.      * Sets the list of background images to use (one image is randomly selected)
  259.      */
  260.     public function setBackgroundImages(array $backgroundImages)
  261.     {
  262.         $this->backgroundImages = $backgroundImages;
  264.         return $this;
  265.     }
  267.     /**
  268.      * Draw lines over the image
  269.      */
  270.     protected function drawLine($image, $width, $height, $tcol = null)
  271.     {
  272.         if ($this->lineColor === null) {
  273.             $red = $this->rand(100, 255);
  274.             $green = $this->rand(100, 255);
  275.             $blue = $this->rand(100, 255);
  276.         } else {
  277.             $red = $this->lineColor[0];
  278.             $green = $this->lineColor[1];
  279.             $blue = $this->lineColor[2];
  280.         }
  282.         if ($tcol === null) {
  283.             $tcol = imagecolorallocate($image, $red, $green, $blue);
  284.         }
  286.         if ($this->rand(0, 1)) { // Horizontal
  287.             $Xa   = $this->rand(0, $width/2);
  288.             $Ya   = $this->rand(0, $height);
  289.             $Xb   = $this->rand($width/2, $width);
  290.             $Yb   = $this->rand(0, $height);
  291.         } else { // Vertical
  292.             $Xa   = $this->rand(0, $width);
  293.             $Ya   = $this->rand(0, $height/2);
  294.             $Xb   = $this->rand(0, $width);
  295.             $Yb   = $this->rand($height/2, $height);
  296.         }
  297.         imagesetthickness($image, $this->rand(1, 3));
  298.         imageline($image, $Xa, $Ya, $Xb, $Yb, $tcol);
  299.     }
  301.     /**
  302.      * Apply some post effects
  303.      */
  304.     protected function postEffect($image)
  305.     {
  306.         if (!function_exists('imagefilter')) {
  307.             return;
  308.         }
  310.         if ($this->backgroundColor != null || $this->textColor != null) {
  311.             return;
  312.         }
  314.         // Negate ?
  315.         if ($this->rand(0, 1) == 0) {
  316.             imagefilter($image, IMG_FILTER_NEGATE);
  317.         }
  319.         // Edge ?
  320.         if ($this->rand(0, 10) == 0) {
  321.             imagefilter($image, IMG_FILTER_EDGEDETECT);
  322.         }
  324.         // Contrast
  325.         imagefilter($image, IMG_FILTER_CONTRAST, $this->rand(-50, 10));
  327.         // Colorize
  328.         if ($this->rand(0, 5) == 0) {
  329.             imagefilter($image, IMG_FILTER_COLORIZE, $this->rand(-80, 50), $this->rand(-80, 50), $this->rand(-80, 50));
  330.         }
  331.     }
  333.     /**
  334.      * Writes the phrase on the image
  335.      */
  336.     protected function writePhrase($image, $phrase, $font, $width, $height)
  337.     {
  338.         $length = mb_strlen($phrase);
  339.         if ($length === 0) {
  340.             return \imagecolorallocate($image, 0, 0, 0);
  341.         }
  343.         // Gets the text size and start position
  344.         $size = $width / $length - $this->rand(0, 3) - 1;
  345.         $box = \imagettfbbox($size, 0, $font, $phrase);
  346.         $textWidth = $box[2] - $box[0];
  347.         $textHeight = $box[1] - $box[7];
  348.         $x = ($width - $textWidth) / 2;
  349.         $y = ($height - $textHeight) / 2 + $size;
  351.         if (!$this->textColor) {
  352.             $textColor = array($this->rand(0, 150), $this->rand(0, 150), $this->rand(0, 150));
  353.         } else {
  354.             $textColor = $this->textColor;
  355.         }
  356.         $col = \imagecolorallocate($image, $textColor[0], $textColor[1], $textColor[2]);
  358.         // Write the letters one by one, with random angle
  359.         for ($i=0; $i<$length; $i++) {
  360.             $symbol = mb_substr($phrase, $i, 1);
  361.             $box = \imagettfbbox($size, 0, $font, $symbol);
  362.             $w = $box[2] - $box[0];
  363.             $angle = $this->rand(-$this->maxAngle, $this->maxAngle);
  364.             $offset = $this->rand(-$this->maxOffset, $this->maxOffset);
  365.             \imagettftext($image, $size, $angle, $x, $y + $offset, $col, $font, $symbol);
  366.             $x += $w;
  367.         }
  369.         return $col;
  370.     }
  372.     /**
  373.      * Try to read the code against an OCR
  374.      */
  375.     public function isOCRReadable()
  376.     {
  377.         if (!is_dir($this->tempDir)) {
  378.             @mkdir($this->tempDir, 0755, true);
  379.         }
  381.         $tempj = $this->tempDir . uniqid('captcha', true) . '.jpg';
  382.         $tempp = $this->tempDir . uniqid('captcha', true) . '.pgm';
  384.         $this->save($tempj);
  385.         shell_exec("convert $tempj $tempp");
  386.         $value = trim(strtolower(shell_exec("ocrad $tempp")));
  388.         @unlink($tempj);
  389.         @unlink($tempp);
  391.         return $this->testPhrase($value);
  392.     }
  394.     /**
  395.      * Builds while the code is readable against an OCR
  396.      */
  397.     public function buildAgainstOCR($width = 150, $height = 40, $font = null, $fingerprint = null)
  398.     {
  399.         do {
  400.             $this->build($width, $height, $font, $fingerprint);
  401.         } while ($this->isOCRReadable());
  402.     }
  404.     /**
  405.      * Generate the image
  406.      */
  407.     public function build($width = 150, $height = 40, $font = null, $fingerprint = null)
  408.     {
  409.         if (null !== $fingerprint) {
  410.             $this->fingerprint = $fingerprint;
  411.             $this->useFingerprint = true;
  412.         } else {
  413.             $this->fingerprint = array();
  414.             $this->useFingerprint = false;
  415.         }
  417.         if ($font === null) {
  418.             $font = __DIR__ . '/Font/captcha'.$this->rand(0, 5).'.ttf';
  419.         }
  421.         if (empty($this->backgroundImages)) {
  422.             // if background images list is not set, use a color fill as a background
  423.             $image   = imagecreatetruecolor($width, $height);
  424.             if ($this->backgroundColor == null) {
  425.                 $bg = imagecolorallocate($image, $this->rand(200, 255), $this->rand(200, 255), $this->rand(200, 255));
  426.             } else {
  427.                 $color = $this->backgroundColor;
  428.                 $bg = imagecolorallocate($image, $color[0], $color[1], $color[2]);
  429.             }
  430.             $this->background = $bg;
  431.             imagefill($image, 0, 0, $bg);
  432.         } else {
  433.             // use a random background image
  434.             $randomBackgroundImage = $this->backgroundImages[rand(0, count($this->backgroundImages)-1)];
  436.             $imageType = $this->validateBackgroundImage($randomBackgroundImage);
  438.             $image = $this->createBackgroundImageFromType($randomBackgroundImage, $imageType);
  439.         }
  441.         // Apply effects
  442.         if (!$this->ignoreAllEffects) {
  443.             $square = $width * $height;
  444.             $effects = $this->rand($square/3000, $square/2000);
  446.             // set the maximum number of lines to draw in front of the text
  447.             if ($this->maxBehindLines != null && $this->maxBehindLines > 0) {
  448.                 $effects = min($this->maxBehindLines, $effects);
  449.             }
  451.             if ($this->maxBehindLines !== 0) {
  452.                 for ($e = 0; $e < $effects; $e++) {
  453.                     $this->drawLine($image, $width, $height);
  454.                 }
  455.             }
  456.         }
  458.         // Write CAPTCHA text
  459.         $color = $this->writePhrase($image, $this->phrase, $font, $width, $height);
  461.         // Apply effects
  462.         if (!$this->ignoreAllEffects) {
  463.             $square = $width * $height;
  464.             $effects = $this->rand($square/3000, $square/2000);
  466.             // set the maximum number of lines to draw in front of the text
  467.             if ($this->maxFrontLines != null && $this->maxFrontLines > 0) {
  468.                 $effects = min($this->maxFrontLines, $effects);
  469.             }
  471.             if ($this->maxFrontLines !== 0) {
  472.                 for ($e = 0; $e < $effects; $e++) {
  473.                     $this->drawLine($image, $width, $height, $color);
  474.                 }
  475.             }
  476.         }
  478.         // Distort the image
  479.         if ($this->distortion && !$this->ignoreAllEffects) {
  480.             $image = $this->distort($image, $width, $height, $bg);
  481.         }
  483.         // Post effects
  484.         if (!$this->ignoreAllEffects) {
  485.             $this->postEffect($image);
  486.         }
  488.         $this->contents = $image;
  490.         return $this;
  491.     }
  493.     /**
  494.      * Distorts the image
  495.      */
  496.     public function distort($image, $width, $height, $bg)
  497.     {
  498.         $contents = imagecreatetruecolor($width, $height);
  499.         $X          = $this->rand(0, $width);
  500.         $Y          = $this->rand(0, $height);
  501.         $phase      = $this->rand(0, 10);
  502.         $scale      = 1.1 + $this->rand(0, 10000) / 30000;
  503.         for ($x = 0; $x < $width; $x++) {
  504.             for ($y = 0; $y < $height; $y++) {
  505.                 $Vx = $x - $X;
  506.                 $Vy = $y - $Y;
  507.                 $Vn = sqrt($Vx * $Vx + $Vy * $Vy);
  509.                 if ($Vn != 0) {
  510.                     $Vn2 = $Vn + 4 * sin($Vn / 30);
  511.                     $nX  = $X + ($Vx * $Vn2 / $Vn);
  512.                     $nY  = $Y + ($Vy * $Vn2 / $Vn);
  513.                 } else {
  514.                     $nX = $X;
  515.                     $nY = $Y;
  516.                 }
  517.                 $nY = $nY + $scale * sin($phase + $nX * 0.2);
  519.                 if ($this->interpolation) {
  520.                     $p = $this->interpolate(
  521.                         $nX - floor($nX),
  522.                         $nY - floor($nY),
  523.                         $this->getCol($image, floor($nX), floor($nY), $bg),
  524.                         $this->getCol($image, ceil($nX), floor($nY), $bg),
  525.                         $this->getCol($image, floor($nX), ceil($nY), $bg),
  526.                         $this->getCol($image, ceil($nX), ceil($nY), $bg)
  527.                     );
  528.                 } else {
  529.                     $p = $this->getCol($image, round($nX), round($nY), $bg);
  530.                 }
  532.                 if ($p == 0) {
  533.                     $p = $bg;
  534.                 }
  536.                 imagesetpixel($contents, $x, $y, $p);
  537.             }
  538.         }
  540.         return $contents;
  541.     }
  543.     /**
  544.      * Saves the Captcha to a jpeg file
  545.      */
  546.     public function save($filename, $quality = 90)
  547.     {
  548.         imagejpeg($this->contents, $filename, $quality);
  549.     }
  551.     /**
  552.      * Gets the image GD
  553.      */
  554.     public function getGd()
  555.     {
  556.         return $this->contents;
  557.     }
  559.     /**
  560.      * Gets the image contents
  561.      */
  562.     public function get($quality = 90)
  563.     {
  564.         ob_start();
  565.         $this->output($quality);
  567.         return ob_get_clean();
  568.     }
  570.     /**
  571.      * Gets the HTML inline base64
  572.      */
  573.     public function inline($quality = 90)
  574.     {
  575.         return 'data:image/jpeg;base64,' . base64_encode($this->get($quality));
  576.     }
  578.     /**
  579.      * Outputs the image
  580.      */
  581.     public function output($quality = 90)
  582.     {
  583.         imagejpeg($this->contents, null, $quality);
  584.     }
  586.     /**
  587.      * @return array
  588.      */
  589.     public function getFingerprint()
  590.     {
  591.         return $this->fingerprint;
  592.     }
  594.     /**
  595.      * Returns a random number or the next number in the
  596.      * fingerprint
  597.      */
  598.     protected function rand($min, $max)
  599.     {
  600.         if (!is_array($this->fingerprint)) {
  601.             $this->fingerprint = array();
  602.         }
  604.         if ($this->useFingerprint) {
  605.             $value = current($this->fingerprint);
  606.             next($this->fingerprint);
  607.         } else {
  608.             $value = mt_rand($min, $max);
  609.             $this->fingerprint[] = $value;
  610.         }
  612.         return $value;
  613.     }
  615.     /**
  616.      * @param $x
  617.      * @param $y
  618.      * @param $nw
  619.      * @param $ne
  620.      * @param $sw
  621.      * @param $se
  622.      *
  623.      * @return int
  624.      */
  625.     protected function interpolate($x, $y, $nw, $ne, $sw, $se)
  626.     {
  627.         list($r0, $g0, $b0) = $this->getRGB($nw);
  628.         list($r1, $g1, $b1) = $this->getRGB($ne);
  629.         list($r2, $g2, $b2) = $this->getRGB($sw);
  630.         list($r3, $g3, $b3) = $this->getRGB($se);
  632.         $cx = 1.0 - $x;
  633.         $cy = 1.0 - $y;
  635.         $m0 = $cx * $r0 + $x * $r1;
  636.         $m1 = $cx * $r2 + $x * $r3;
  637.         $r  = (int) ($cy * $m0 + $y * $m1);
  639.         $m0 = $cx * $g0 + $x * $g1;
  640.         $m1 = $cx * $g2 + $x * $g3;
  641.         $g  = (int) ($cy * $m0 + $y * $m1);
  643.         $m0 = $cx * $b0 + $x * $b1;
  644.         $m1 = $cx * $b2 + $x * $b3;
  645.         $b  = (int) ($cy * $m0 + $y * $m1);
  647.         return ($r << 16) | ($g << 8) | $b;
  648.     }
  650.     /**
  651.      * @param $image
  652.      * @param $x
  653.      * @param $y
  654.      *
  655.      * @return int
  656.      */
  657.     protected function getCol($image, $x, $y, $background)
  658.     {
  659.         $L = imagesx($image);
  660.         $H = imagesy($image);
  661.         if ($x < 0 || $x >= $L || $y < 0 || $y >= $H) {
  662.             return $background;
  663.         }
  665.         return imagecolorat($image, $x, $y);
  666.     }
  668.     /**
  669.      * @param $col
  670.      *
  671.      * @return array
  672.      */
  673.     protected function getRGB($col)
  674.     {
  675.         return array(
  676.             (int) ($col >> 16) & 0xff,
  677.             (int) ($col >> 8) & 0xff,
  678.             (int) ($col) & 0xff,
  679.         );
  680.     }
  682.     /**
  683.      * Validate the background image path. Return the image type if valid
  684.      *
  685.      * @param string $backgroundImage
  686.      * @return string
  687.      * @throws Exception
  688.      */
  689.     protected function validateBackgroundImage($backgroundImage)
  690.     {
  691.         // check if file exists
  692.         if (!file_exists($backgroundImage)) {
  693.             $backgroundImageExploded = explode('/', $backgroundImage);
  694.             $imageFileName = count($backgroundImageExploded) > 1? $backgroundImageExploded[count($backgroundImageExploded)-1] : $backgroundImage;
  696.             throw new Exception('Invalid background image: ' . $imageFileName);
  697.         }
  699.         // check image type
  700.         $finfo = finfo_open(FILEINFO_MIME_TYPE); // return mime type ala mimetype extension
  701.         $imageType = finfo_file($finfo, $backgroundImage);
  702.         finfo_close($finfo);
  704.         if (!in_array($imageType, $this->allowedBackgroundImageTypes)) {
  705.             throw new Exception('Invalid background image type! Allowed types are: ' . join(', ', $this->allowedBackgroundImageTypes));
  706.         }
  708.         return $imageType;
  709.     }
  711.     /**
  712.      * Create background image from type
  713.      *
  714.      * @param string $backgroundImage
  715.      * @param string $imageType
  716.      * @return resource
  717.      * @throws Exception
  718.      */
  719.     protected function createBackgroundImageFromType($backgroundImage, $imageType)
  720.     {
  721.         switch ($imageType) {
  722.             case 'image/jpeg':
  723.                 $image = imagecreatefromjpeg($backgroundImage);
  724.                 break;
  725.             case 'image/png':
  726.                 $image = imagecreatefrompng($backgroundImage);
  727.                 break;
  728.             case 'image/gif':
  729.                 $image = imagecreatefromgif($backgroundImage);
  730.                 break;
  732.             default:
  733.                 throw new Exception('Not supported file type for background image!');
  734.                 break;
  735.         }
  737.         return $image;
  738.     }
  739. }