| | <?php |
| |
|
| | header('Content-Type: text/html; charset=utf-8'); |
| | mb_internal_encoding('UTF-8'); |
| |
|
| | function convertToUnicode($text) { |
| | $persianChars = [ |
| | 'آ' => '\u0622', |
| | 'ا' => '\u0627', |
| | 'ب' => '\u0628', |
| | 'پ' => '\u067e', |
| | 'ت' => '\u062a', |
| | 'ث' => '\u062b', |
| | 'ج' => '\u062c', |
| | 'چ' => '\u0686', |
| | 'ح' => '\u062d', |
| | 'خ' => '\u062e', |
| | 'د' => '\u062f', |
| | 'ذ' => '\u0630', |
| | 'ر' => '\u0631', |
| | 'ز' => '\u0632', |
| | 'ژ' => '\u0698', |
| | 'س' => '\u0633', |
| | 'ش' => '\u0634', |
| | 'ص' => '\u0635', |
| | 'ض' => '\u0636', |
| | 'ط' => '\u0637', |
| | 'ظ' => '\u0638', |
| | 'ع' => '\u0639', |
| | 'غ' => '\u063a', |
| | 'ف' => '\u0641', |
| | 'ق' => '\u0642', |
| | 'ک' => '\u06a9', |
| | 'گ' => '\u06af', |
| | 'ل' => '\u0644', |
| | 'م' => '\u0645', |
| | 'ن' => '\u0646', |
| | 'و' => '\u0648', |
| | 'ه' => '\u0647', |
| | 'ی' => '\u06cc', |
| | ' ' => '\u0020', |
| | '۰' => '\u06f0', |
| | '۱' => '\u06f1', |
| | '۲' => '\u06f2', |
| | '۳' => '\u06f3', |
| | '۴' => '\u06f4', |
| | '۵' => '\u06f5', |
| | '۶' => '\u06f6', |
| | '۷' => '\u06f7', |
| | '۸' => '\u06f8', |
| | '۹' => '\u06f9' |
| | ]; |
| | |
| | $unicodeText = ''; |
| | $chars = mb_str_split($text); |
| | |
| | foreach ($chars as $char) { |
| | if (isset($persianChars[$char])) { |
| | $unicodeText .= $persianChars[$char]; |
| | } else { |
| | $unicodeText .= $char; |
| | } |
| | } |
| | |
| | return $unicodeText; |
| | } |
| |
|
| | function generateTextImage() { |
| | $text = $_GET['text'] ?? ''; |
| | $image_url = $_GET['image_url'] ?? ''; |
| | |
| | if (empty($text)) { |
| | createErrorImage('text is empty'); |
| | return; |
| | } |
| |
|
| | $tokensFile = __DIR__ . '/tokens.json'; |
| | $fontsFile = __DIR__ . '/fonts.json'; |
| | |
| | if (!file_exists($tokensFile)) { |
| | createErrorImage('tokens not found'); |
| | return; |
| | } |
| | |
| | if (!file_exists($fontsFile)) { |
| | createErrorImage('fonts not found'); |
| | return; |
| | } |
| |
|
| | $tokensContent = file_get_contents($tokensFile); |
| | $fontsContent = file_get_contents($fontsFile); |
| | |
| | $tokens = json_decode($tokensContent, true); |
| | $fonts = json_decode($fontsContent, true); |
| | |
| | if ($tokens === null) { |
| | createErrorImage('error in read tokens'); |
| | return; |
| | } |
| | |
| | if ($fonts === null) { |
| | createErrorImage('error in read font'); |
| | return; |
| | } |
| | |
| | foreach (mb_str_split($text) as $char) { |
| | $found = false; |
| | foreach ($tokens as $token) { |
| | if ($token['word'] === $char) { |
| | $found = true; |
| | break; |
| | } |
| | } |
| | if (!$found) { |
| | createErrorImage('Illegal characters in text'); |
| | return; |
| | } |
| | } |
| |
|
| | $lang = 'en'; |
| | foreach (mb_str_split($text) as $char) { |
| | foreach ($tokens as $token) { |
| | if ($token['word'] === $char && $token['language'] === 'persian/farsi/iran') { |
| | $lang = 'fa'; |
| | break 2; |
| | } elseif ($token['word'] === $char && $token['language'] === 'English') { |
| | $lang = 'en'; |
| | break 2; |
| | } |
| | } |
| | } |
| |
|
| | $langFonts = array_filter($fonts, function($font) use ($lang) { |
| | return $font['lang'] === $lang; |
| | }); |
| | $langFonts = array_values($langFonts); |
| | |
| | if (empty($langFonts)) { |
| | createErrorImage('font not found for this language'); |
| | return; |
| | } |
| | |
| | $selectedFont = $langFonts[array_rand($langFonts)]; |
| | |
| | $fontPath = __DIR__ . '/' . ($lang === 'fa' ? 'PersianFonts/' : 'EnglishFonts/') . $selectedFont['font-name']; |
| | if (!file_exists($fontPath)) { |
| | createErrorImage('font selected . not found'); |
| | return; |
| | } |
| |
|
| | $ratios = [ |
| | [1, 1], |
| | [1, 1], |
| | [1, 1] |
| | ]; |
| | $ratio = $ratios[array_rand($ratios)]; |
| | $baseSize = 2000; |
| | $width = $ratio[0] * ($baseSize / 2); |
| | $height = $ratio[1] * ($baseSize / 2); |
| |
|
| | $image = imagecreatetruecolor($width, $height); |
| | imagesavealpha($image, true); |
| | $transparent = imagecolorallocatealpha($image, 0, 0, 0, 127); |
| | imagefill($image, 0, 0, $transparent); |
| |
|
| | $externalImage = null; |
| | if (!empty($image_url)) { |
| | $externalImage = loadExternalImage($image_url); |
| | } |
| |
|
| | if ($externalImage) { |
| | $extW = imagesx($externalImage); |
| | $extH = imagesy($externalImage); |
| | $scale = max($width / $extW, $height / $extH); |
| | $newW = (int)($extW * $scale); |
| | $newH = (int)($extH * $scale); |
| | $bg = imagecreatetruecolor($width, $height); |
| | imagesavealpha($bg, true); |
| | $transparent = imagecolorallocatealpha($bg, 0, 0, 0, 127); |
| | imagefill($bg, 0, 0, $transparent); |
| | imagecopyresampled($bg, $externalImage, (int)(($width - $newW)/2), (int)(($height - $newH)/2), 0, 0, $newW, $newH, $extW, $extH); |
| | imagecopy($image, $bg, 0, 0, 0, 0, $width, $height); |
| | imagedestroy($bg); |
| | } else { |
| | $bgType = mt_rand(0, 1); |
| | if ($bgType === 0) { |
| | do { |
| | $bgColor = imagecolorallocate($image, mt_rand(0, 255), mt_rand(0, 255), mt_rand(0, 255)); |
| | } while ($bgColor === false); |
| | imagefill($image, 0, 0, $bgColor); |
| | } else { |
| | $gradientColors = mt_rand(0, 1) ? 2 : 4; |
| | $baseHue = mt_rand(0, 360); |
| | $colors = []; |
| | for ($i = 0; $i < $gradientColors; $i++) { |
| | $hue = $baseHue + mt_rand(-15, 15); |
| | $hue = max(0, min(360, $hue)); |
| | $colors[] = hslToRgb($hue / 360, mt_rand(80, 100) / 100, mt_rand(50, 80) / 100); |
| | } |
| | $directions = ['horizontal', 'vertical', 'diagonal', 'radial']; |
| | $direction = $directions[array_rand($directions)]; |
| | createUltraGradient($image, $colors, $direction, $width, $height); |
| | } |
| | } |
| |
|
| | $hasCircles = (mt_rand(1, 10) === 1); |
| | if ($hasCircles) { |
| | $circleCount = mt_rand(3, 8); |
| | for ($i = 0; $i < $circleCount; $i++) { |
| | $circleColor = imagecolorallocatealpha($image, mt_rand(150, 255), mt_rand(150, 255), mt_rand(150, 255), mt_rand(30, 70)); |
| | $circleSize = mt_rand(40, min($width, $height) / 4); |
| | $circleX = mt_rand(-$circleSize, $width + $circleSize); |
| | $circleY = mt_rand(-$circleSize, $height + $circleSize); |
| | imagefilledellipse($image, $circleX, $circleY, $circleSize, $circleSize, $circleColor); |
| | } |
| | } |
| |
|
| | $hasPattern = mt_rand(0, 3) === 0; |
| | if ($hasPattern && !$externalImage) { |
| | createGeometricPattern($image, $width, $height); |
| | } |
| |
|
| | $processedText = $text; |
| | if ($lang === 'fa') { |
| | $chars = preg_split('//u', $text, -1, PREG_SPLIT_NO_EMPTY); |
| | $reversed = array_reverse($chars); |
| | $processedText = implode('', $reversed); |
| | $rtlMarkers = ""; |
| | $processedText = $rtlMarkers . $processedText . $rtlMarkers; |
| | } |
| |
|
| | $fontSize = calculateOptimalFontSize($processedText, $fontPath, $width, $height, $externalImage); |
| | $angle = 0; |
| | $bbox = imagettfbbox($fontSize, $angle, $fontPath, $processedText); |
| | if ($bbox === false) { |
| | createErrorImage('Error in calculating text size'); |
| | return; |
| | } |
| | $textWidth = $bbox[2] - $bbox[0]; |
| | $textHeight = $bbox[1] - $bbox[7]; |
| | $margin = 40; |
| | if ($textWidth + $margin * 2 > $width) { |
| | $scale = ($width - $margin * 2) / $textWidth; |
| | $fontSize = max(12, (int)($fontSize * $scale)); |
| | $bbox = imagettfbbox($fontSize, $angle, $fontPath, $processedText); |
| | $textWidth = $bbox[2] - $bbox[0]; |
| | $textHeight = $bbox[1] - $bbox[7]; |
| | } |
| | $textX = ($width - $textWidth) / 2; |
| | $textY = ($height - $textHeight) / 2 + $textHeight; |
| |
|
| | $textColor = null; |
| | if ($externalImage) { |
| | $avg = estimateAverageColor($image); |
| | $lum = ($avg[0] * 0.299 + $avg[1] * 0.587 + $avg[2] * 0.114); |
| | $textColor = $lum > 128 ? imagecolorallocate($image, 0, 0, 0) : imagecolorallocate($image, 255, 255, 255); |
| | } else { |
| | $textColor = imagecolorallocate($image, 255, 255, 255); |
| | } |
| |
|
| | $hasShadow = false; |
| | $hasGlow = false; |
| | $hasBorder = false; |
| | $hasTextGradient = false; |
| |
|
| | if ($hasShadow) { |
| | $shadowIntensity = mt_rand(2, 4); |
| | $shadowColor = imagecolorallocatealpha($image, 0, 0, 0, mt_rand(30, 60)); |
| | for ($i = 1; $i <= $shadowIntensity; $i++) { |
| | imagettftext($image, $fontSize, $angle, $textX + $i, $textY + $i, $shadowColor, $fontPath, $processedText); |
| | } |
| | } |
| |
|
| | if ($hasGlow) { |
| | $glowColor = imagecolorallocatealpha($image, mt_rand(100, 255), mt_rand(100, 255), mt_rand(100, 255), mt_rand(20, 40)); |
| | $glowSize = mt_rand(3, 6); |
| | for ($i = -$glowSize; $i <= $glowSize; $i++) { |
| | for ($j = -$glowSize; $j <= $glowSize; $j++) { |
| | if (abs($i) + abs($j) <= $glowSize) { |
| | imagettftext($image, $fontSize, $angle, $textX + $i, $textY + $j, $glowColor, $fontPath, $processedText); |
| | } |
| | } |
| | } |
| | } |
| |
|
| | if ($hasBorder) { |
| | $borderColor = imagecolorallocate($image, mt_rand(0, 255), mt_rand(0, 255), mt_rand(0, 255)); |
| | $borderThickness = mt_rand(1, 3); |
| | for ($i = -$borderThickness; $i <= $borderThickness; $i++) { |
| | for ($j = -$borderThickness; $j <= $borderThickness; $j++) { |
| | if (abs($i) + abs($j) <= $borderThickness * 1.5) { |
| | imagettftext($image, $fontSize, $angle, $textX + $i, $textY + $j, $borderColor, $fontPath, $processedText); |
| | } |
| | } |
| | } |
| | } |
| |
|
| | imagettftext($image, $fontSize, $angle, (int)$textX, (int)$textY, $textColor, $fontPath, $processedText); |
| |
|
| | header('Content-Type: image/png'); |
| | imagepng($image, null, 9); |
| | imagedestroy($image); |
| | } |
| |
|
| | function calculateOptimalFontSize($text, $fontPath, $width, $height, $externalImage) { |
| | $maxSize = min($width, $height) / 3; |
| | $minSize = 24; |
| | if ($externalImage) { |
| | $maxSize = min($width, $height) / 5; |
| | } |
| | for ($size = $maxSize; $size >= $minSize; $size -= 1) { |
| | $bbox = imagettfbbox($size, 0, $fontPath, $text); |
| | if ($bbox === false) continue; |
| | $textWidth = $bbox[2] - $bbox[0]; |
| | $textHeight = $bbox[1] - $bbox[7]; |
| | if ($textWidth < $width * 0.85 && $textHeight < $height * 0.6) { |
| | return $size; |
| | } |
| | } |
| | return $minSize; |
| | } |
| |
|
| | function loadExternalImage($url) { |
| | $ch = curl_init(); |
| | curl_setopt($ch, CURLOPT_URL, $url); |
| | curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); |
| | curl_setopt($ch, CURLOPT_TIMEOUT, 30); |
| | curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true); |
| | curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); |
| | curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/5.0'); |
| | curl_setopt($ch, CURLOPT_ENCODING, ''); |
| | $imageData = curl_exec($ch); |
| | $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); |
| | curl_close($ch); |
| | if (!$imageData || $httpCode !== 200) { |
| | return null; |
| | } |
| | $image = @imagecreatefromstring($imageData); |
| | if (!$image) { |
| | return null; |
| | } |
| | return $image; |
| | } |
| |
|
| | function makeImageRounded($image) { |
| | $width = imagesx($image); |
| | $height = imagesy($image); |
| | $rounded = imagecreatetruecolor($width, $height); |
| | imagesavealpha($rounded, true); |
| | $transparent = imagecolorallocatealpha($rounded, 0, 0, 0, 127); |
| | imagefill($rounded, 0, 0, $transparent); |
| | $radius = min($width, $height) / 4; |
| | for ($x = 0; $x < $width; $x++) { |
| | for ($y = 0; $y < $height; $y++) { |
| | $distance = sqrt(pow($x - $width/2, 2) + pow($y - $height/2, 2)); |
| | if ($distance <= $radius) { |
| | $color = imagecolorat($image, $x, $y); |
| | imagesetpixel($rounded, $x, $y, $color); |
| | } |
| | } |
| | } |
| | imagedestroy($image); |
| | return $rounded; |
| | } |
| |
|
| | function drawUltraGradientText($image, $text, $fontPath, $fontSize, $angle, $x, $y, $width, $height) { |
| | $baseHue = mt_rand(0, 360); |
| | $color1 = hslToRgb($baseHue / 360, 0.9, 0.6); |
| | $color2 = hslToRgb(($baseHue + mt_rand(30, 120)) / 360, 0.9, 0.6); |
| | $bbox = imagettfbbox($fontSize, $angle, $fontPath, $text); |
| | if ($bbox === false) return; |
| | $textWidth = $bbox[2] - $bbox[0]; |
| | $textHeight = $bbox[1] - $bbox[7]; |
| | $textImage = imagecreatetruecolor($textWidth, $textHeight); |
| | imagesavealpha($textImage, true); |
| | $transparent = imagecolorallocatealpha($textImage, 0, 0, 0, 127); |
| | imagefill($textImage, 0, 0, $transparent); |
| | $gradientType = mt_rand(0, 2); |
| | if ($gradientType === 0) { |
| | for ($i = 0; $i < $textWidth; $i++) { |
| | $ratio = $i / $textWidth; |
| | $r = $color1[0] + ($color2[0] - $color1[0]) * $ratio; |
| | $g = $color1[1] + ($color2[1] - $color1[1]) * $ratio; |
| | $b = $color1[2] + ($color2[2] - $color1[2]) * $ratio; |
| | $color = imagecolorallocate($textImage, $r, $g, $b); |
| | imageline($textImage, $i, 0, $i, $textHeight, $color); |
| | } |
| | } else { |
| | for ($i = 0; $i < $textHeight; $i++) { |
| | $ratio = $i / $textHeight; |
| | $r = $color1[0] + ($color2[0] - $color1[0]) * $ratio; |
| | $g = $color1[1] + ($color2[1] - $color1[1]) * $ratio; |
| | $b = $color1[2] + ($color2[2] - $color1[2]) * $ratio; |
| | $color = imagecolorallocate($textImage, $r, $g, $b); |
| | imageline($textImage, 0, $i, $textWidth, $i, $color); |
| | } |
| | } |
| | $maskColor = imagecolorallocate($textImage, 255, 255, 255); |
| | imagettftext($textImage, $fontSize, $angle, 0, $bbox[1], $maskColor, $fontPath, $text); |
| | imagecopymerge($image, $textImage, $x, $y - $bbox[1], 0, 0, $textWidth, $textHeight, 100); |
| | imagedestroy($textImage); |
| | } |
| |
|
| | function createUltraGradient($image, $colors, $direction, $width, $height) { |
| | $colorCount = count($colors); |
| | switch ($direction) { |
| | case 'horizontal': |
| | for ($i = 0; $i < $width; $i++) { |
| | $ratio = $i / ($width - 1); |
| | $colorIndex = $ratio * ($colorCount - 1); |
| | $index1 = floor($colorIndex); |
| | $index2 = min($index1 + 1, $colorCount - 1); |
| | $fraction = $colorIndex - $index1; |
| | $r = $colors[$index1][0] + ($colors[$index2][0] - $colors[$index1][0]) * $fraction; |
| | $g = $colors[$index1][1] + ($colors[$index2][1] - $colors[$index1][1]) * $fraction; |
| | $b = $colors[$index1][2] + ($colors[$index2][2] - $colors[$index1][2]) * $fraction; |
| | $color = imagecolorallocate($image, $r, $g, $b); |
| | imageline($image, $i, 0, $i, $height, $color); |
| | } |
| | break; |
| | case 'vertical': |
| | for ($i = 0; $i < $height; $i++) { |
| | $ratio = $i / ($height - 1); |
| | $colorIndex = $ratio * ($colorCount - 1); |
| | $index1 = floor($colorIndex); |
| | $index2 = min($index1 + 1, $colorCount - 1); |
| | $fraction = $colorIndex - $index1; |
| | $r = $colors[$index1][0] + ($colors[$index2][0] - $colors[$index1][0]) * $fraction; |
| | $g = $colors[$index1][1] + ($colors[$index2][1] - $colors[$index1][1]) * $fraction; |
| | $b = $colors[$index1][2] + ($colors[$index2][2] - $colors[$index1][2]) * $fraction; |
| | $color = imagecolorallocate($image, $r, $g, $b); |
| | imageline($image, 0, $i, $width, $i, $color); |
| | } |
| | break; |
| | case 'diagonal': |
| | for ($i = 0; $i < $width; $i++) { |
| | for ($j = 0; $j < $height; $j++) { |
| | $ratio = ($i + $j) / ($width + $height - 2); |
| | $colorIndex = $ratio * ($colorCount - 1); |
| | $index1 = floor($colorIndex); |
| | $index2 = min($index1 + 1, $colorCount - 1); |
| | $fraction = $colorIndex - $index1; |
| | $r = $colors[$index1][0] + ($colors[$index2][0] - $colors[$index1][0]) * $fraction; |
| | $g = $colors[$index1][1] + ($colors[$index2][1] - $colors[$index1][1]) * $fraction; |
| | $b = $colors[$index1][2] + ($colors[$index2][2] - $colors[$index1][2]) * $fraction; |
| | $color = imagecolorallocate($image, $r, $g, $b); |
| | imagesetpixel($image, $i, $j, $color); |
| | } |
| | } |
| | break; |
| | case 'radial': |
| | $centerX = $width / 2; |
| | $centerY = $height / 2; |
| | $maxRadius = sqrt($centerX * $centerX + $centerY * $centerY); |
| | for ($i = 0; $i < $width; $i++) { |
| | for ($j = 0; $j < $height; $j++) { |
| | $dx = $i - $centerX; |
| | $dy = $j - $centerY; |
| | $distance = sqrt($dx * $dx + $dy * $dy); |
| | $ratio = min(1, $distance / $maxRadius); |
| | $colorIndex = $ratio * ($colorCount - 1); |
| | $index1 = floor($colorIndex); |
| | $index2 = min($index1 + 1, $colorCount - 1); |
| | $fraction = $colorIndex - $index1; |
| | $r = $colors[$index1][0] + ($colors[$index2][0] - $colors[$index1][0]) * $fraction; |
| | $g = $colors[$index1][1] + ($colors[$index2][1] - $colors[$index1][1]) * $fraction; |
| | $b = $colors[$index1][2] + ($colors[$index2][2] - $colors[$index1][2]) * $fraction; |
| | $color = imagecolorallocate($image, $r, $g, $b); |
| | imagesetpixel($image, $i, $j, $color); |
| | } |
| | } |
| | break; |
| | } |
| | } |
| |
|
| | function createGeometricPattern($image, $width, $height) { |
| | $patternType = mt_rand(0, 2); |
| | $patternColor = imagecolorallocatealpha($image, mt_rand(200, 255), mt_rand(200, 255), mt_rand(200, 255), mt_rand(10, 30)); |
| | switch ($patternType) { |
| | case 0: |
| | for ($i = 0; $i < $width; $i += 20) { |
| | imageline($image, $i, 0, $i, $height, $patternColor); |
| | } |
| | for ($i = 0; $i < $height; $i += 20) { |
| | imageline($image, 0, $i, $width, $i, $patternColor); |
| | } |
| | break; |
| | case 1: |
| | for ($i = -$width; $i < $width * 2; $i += 30) { |
| | imageline($image, $i, 0, $i + $height, $height, $patternColor); |
| | } |
| | break; |
| | case 2: |
| | $circleSpacing = min($width, $height) / 10; |
| | for ($i = $circleSpacing; $i < $width; $i += $circleSpacing) { |
| | for ($j = $circleSpacing; $j < $height; $j += $circleSpacing) { |
| | imagefilledellipse($image, $i, $j, 8, 8, $patternColor); |
| | } |
| | } |
| | break; |
| | } |
| | } |
| |
|
| | function addVignetteEffect($image, $width, $height) { |
| | $centerX = $width / 2; |
| | $centerY = $height / 2; |
| | $maxDistance = sqrt($centerX * $centerX + $centerY * $centerY); |
| | for ($i = 0; $i < $width; $i++) { |
| | for ($j = 0; $j < $height; $j++) { |
| | $dx = $i - $centerX; |
| | $dy = $j - $centerY; |
| | $distance = sqrt($dx * $dx + $dy * $dy); |
| | $ratio = $distance / $maxDistance; |
| | $vignette = imagecolorallocatealpha($image, 0, 0, 0, $ratio * 60); |
| | imagesetpixel($image, $i, $j, $vignette); |
| | } |
| | } |
| | } |
| |
|
| | function hslToRgb($h, $s, $l) { |
| | $r = $l; |
| | $g = $l; |
| | $b = $l; |
| | $v = ($l <= 0.5) ? ($l * (1.0 + $s)) : ($l + $s - $l * $s); |
| | if ($v > 0) { |
| | $m = $l + $l - $v; |
| | $sv = ($v - $m) / $v; |
| | $h *= 6.0; |
| | $sextant = floor($h); |
| | $fract = $h - $sextant; |
| | $vsf = $v * $sv * $fract; |
| | $mid1 = $m + $vsf; |
| | $mid2 = $v - $vsf; |
| | switch ($sextant) { |
| | case 0: |
| | $r = $v; $g = $mid1; $b = $m; |
| | break; |
| | case 1: |
| | $r = $mid2; $g = $v; $b = $m; |
| | break; |
| | case 2: |
| | $r = $m; $g = $v; $b = $mid1; |
| | break; |
| | case 3: |
| | $r = $m; $g = $mid2; $b = $v; |
| | break; |
| | case 4: |
| | $r = $mid1; $g = $m; $b = $v; |
| | break; |
| | case 5: |
| | $r = $v; $g = $m; $b = $mid2; |
| | break; |
| | } |
| | } |
| | return [round($r * 255), round($g * 255), round($b * 255)]; |
| | } |
| |
|
| | function createErrorImage($message) { |
| | $width = 500; |
| | $height = 500; |
| | $image = imagecreatetruecolor($width, $height); |
| | $bgColor = imagecolorallocate($image, 255, 200, 200); |
| | $textColor = imagecolorallocate($image, 255, 0, 0); |
| | imagefill($image, 0, 0, $bgColor); |
| | $font = 5; |
| | $textWidth = imagefontwidth($font) * strlen($message); |
| | $textHeight = imagefontheight($font); |
| | $x = ($width - $textWidth) / 2; |
| | $y = ($height - $textHeight) / 2; |
| | imagestring($image, $font, $x, $y, $message, $textColor); |
| | header('Content-Type: image/png'); |
| | imagepng($image); |
| | imagedestroy($image); |
| | } |
| |
|
| | if (!function_exists('mb_str_split')) { |
| | function mb_str_split($string, $length = 1) { |
| | $result = []; |
| | for ($i = 0; $i < mb_strlen($string); $i += $length) { |
| | $result[] = mb_substr($string, $i, $length); |
| | } |
| | return $result; |
| | } |
| | } |
| |
|
| | function estimateAverageColor($image) { |
| | $w = imagesx($image); |
| | $h = imagesy($image); |
| | $stepX = max(1, (int)($w / 10)); |
| | $stepY = max(1, (int)($h / 10)); |
| | $r = $g = $b = 0; |
| | $count = 0; |
| | for ($x = 0; $x < $w; $x += $stepX) { |
| | for ($y = 0; $y < $h; $y += $stepY) { |
| | $c = imagecolorat($image, $x, $y); |
| | $r += ($c >> 16) & 0xFF; |
| | $g += ($c >> 8) & 0xFF; |
| | $b += $c & 0xFF; |
| | $count++; |
| | } |
| | } |
| | return [ (int)($r / $count), (int)($g / $count), (int)($b / $count) ]; |
| | } |
| |
|
| | function processPersianText($text) { |
| | $normalized = normalizer_is_normalized($text, Normalizer::FORM_C) ? $text : normalizer_normalize($text, Normalizer::FORM_C); |
| | if (function_exists('fribidi_log2vis')) { |
| | $res = @fribidi_log2vis($normalized); |
| | if ($res !== false && is_string($res)) { |
| | return $res; |
| | } |
| | } |
| | if (class_exists('IntlChar')) { |
| | $rtlMarkers = "\xE2\x80\x8F"; |
| | return $rtlMarkers . $normalized; |
| | } |
| | return $normalized; |
| | } |
| |
|
| | set_time_limit(300); |
| | generateTextImage(); |
| | ?> |
| |
|
