Français
Français
Dans le processus de développement Web, le traitement d'optimisation des images est une partie importante de l'amélioration de l'expérience utilisateur et des performances de la page Web. Parmi eux, les opérations de tranchage et d'épissage de l'image peuvent réduire efficacement le temps de chargement de l'image et améliorer la vitesse de réponse de la page. Avec ses puissantes capacités de traitement d'image, PHP peut facilement réaliser les deux opérations.
Les tranches d'image divisent une grande image en plusieurs petites images. Il est souvent utilisé pour charger des images par zone, créer des cartes graphiques ou atteindre un effet de chargement d'image paresseux.
Voici un exemple de code PHP qui montre comment trancher et enregistrer une grande image à une taille fixe:
<?php
// Chemin d'image d'origine
$srcPath = 'big_image.jpg';
// Slice Save Path
$savePath = 'sliced_images/';
// Tailler
$width = 200; // Largeur de tranche
$height = 200; // Tailler
// Chargez l'image d'origine
$srcImage = imagecreatefromjpeg($srcPath);
$srcWidth = imagesx($srcImage);
$srcHeight = imagesy($srcImage);
// Calculez le nombre de tranches
$numX = ceil($srcWidth / $width);
$numY = ceil($srcHeight / $height);
// Recadrer et économiser des tranches
for ($x = 0; $x < $numX; $x++) {
for ($y = 0; $y < $numY; $y++) {
// Créer une nouvelle toile
$sliceImage = imagecreatetruecolor($width, $height);
// Zone de copie
imagecopy($sliceImage, $srcImage, 0, 0, $x * $width, $y * $height, $width, $height);
// Sauver les tranches
imagejpeg($sliceImage, $savePath . 'slice_' . $x . '_' . $y . '.jpg');
// Nettoyer les ressources
imagedestroy($sliceImage);
}
}
// Nettoyer les ressources d'image originales
imagedestroy($srcImage);
?>Le code ci-dessus coupera la grande image en plusieurs petites images en fonction de la largeur et de la hauteur de l'ensemble, l'enregistrera dans le répertoire spécifié et nommez le nom de fichier en fonction des coordonnées, pour une gestion ultérieure facile.
La couture d'image consiste à combiner plusieurs petites images en une seule grande image, ce qui convient à la synthèse d'image, au carrelage d'arrière-plan ou à la restauration de grandes images.
Le code suivant montre comment lire les images en tranches et les épisser dans une grande image dans l'ordre:
<?php
// Catalogue d'image de tranche
$slicePath = 'sliced_images/';
// Chemin de sauvegarde d'image après les coutures
$mergedPath = 'merged_image.jpg';
// Tailler
$width = 200;
$height = 200;
// Nombre de tranches（Il doit être défini en fonction du nombre réel de tranches）
$numX = 3;
$numY = 3;
// Créer une toile synthétique
$mergedWidth = $width * $numX;
$mergedHeight = $height * $numY;
$mergedImage = imagecreatetruecolor($mergedWidth, $mergedHeight);
// Lisez les tranches un par un et fusionnez
for ($x = 0; $x < $numX; $x++) {
for ($y = 0; $y < $numY; $y++) {
$sliceImage = imagecreatefromjpeg($slicePath . 'slice_' . $x . '_' . $y . '.jpg');
imagecopy($mergedImage, $sliceImage, $x * $width, $y * $height, 0, 0, $width, $height);
imagedestroy($sliceImage);
}
}
// Enregistrer les images synthétiques
imagejpeg($mergedImage, $mergedPath);
imagedestroy($mergedImage);
?>Ce script suppose qu'il existe déjà une image de tranchage nommée dans l'ordre et la couvre en une image complète, la sortie comme fichier spécifié.
Grâce aux exemples de traitement d'image PHP fournis dans cet article, vous pouvez diviser une grande image en plusieurs petites images au besoin, ou recombiner l'image segmentée dans l'image d'origine. Cette technologie peut être largement utilisée dans l'optimisation du chargement d'images frontal, le division de la carte de jeu, le système de gestion d'images back-end et d'autres champs. Dans une utilisation réelle, les développeurs peuvent ajuster de manière flexible la taille de l'image et le nombre de tranches pour répondre aux différents besoins commerciaux.
