|
|
<?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(); |
|
|
?> |
|
|
|
