proportionally - Cambiar el tamaño de la imagen en PHP

remove html tags php

Question

Estoy queriendo escribir un código PHP que redimensiona automáticamente cualquier imagen cargada a través de un formulario a 147x147px, pero no tengo idea de cómo hacerlo (soy un principiante relativo de PHP).

Hasta ahora, he cargado imágenes exitosamente, se han reconocido los tipos de archivos y se han limpiado los nombres, pero me gustaría agregar la funcionalidad de cambio de tamaño en el código. Por ejemplo, tengo una imagen de prueba que es de 2,3 MB y 1331 x 1331 en dimensión, y me gustaría que el código lo reduzca, lo que supongo que también comprimirá drásticamente el tamaño del archivo de la imagen.

Hasta ahora, tengo lo siguiente:

if ($_FILES) {
//Put file properties into variables
$file_name = $_FILES[''profile-image''][''name''];
$file_size = $_FILES[''profile-image''][''size''];
$file_tmp_name = $_FILES[''profile-image''][''tmp_name''];
//Determine filetype
switch ($_FILES[''profile-image''][''type'']) {
case ''image/jpeg'': $ext = "jpg"; break;
case ''image/png'': $ext = "png"; break;
default: $ext = ''''; break;
}
if ($ext) {
//Check filesize
if ($file_size < 500000) {
//Process file - clean up filename and move to safe location
$n = "$file_name";
$n = ereg_replace("[^A-Za-z0-9.]", "", $n);
$n = strtolower($n);
$n = "avatars/$n";
move_uploaded_file($file_tmp_name, $n);
} else {
$bad_message = "Please ensure your chosen file is less than 5MB.";
}
} else {
$bad_message = "Please ensure your image is of filetype .jpg or.png.";
}
}
$query = "INSERT INTO users (image) VALUES (''$n'')";
mysql_query($query) or die("Insert failed. " . mysql_error() . "<br />" . $query);

Answer 1

Creé una biblioteca fácil de usar para cambiar el tamaño de la imagen. Se puede encontrar aquí en Github .

Un ejemplo de cómo usar la biblioteca:

// Include PHP Image Magician library
require_once(''php_image_magician.php'');
// Open JPG image
$magicianObj = new imageLib(''racecar.jpg'');
// Resize to best fit then crop (check out the other options)
$magicianObj -> resizeImage(100, 200, ''crop'');
// Save resized image as a PNG (or jpg, bmp, etc)
$magicianObj -> saveImage(''racecar_small.png'');

Otras características, si las necesita, son:

• Cambio de tamaño rápido y fácil: cambiar el tamaño a horizontal, vertical o automático
• Cultivo fácil
• Añadir texto
• Ajuste de calidad
• Marca de agua
• Sombras y reflejos
• Soporte de transparencia
• Leer los metadatos EXIF
• Fronteras, esquinas redondeadas, rotación
• Filtros y efectos
• Nitidez de la imagen
• Conversión de tipo de imagen
• Soporte de BMP

Answer 2

Encontré una forma matemática para hacer este trabajo

Repo de Github - https://github.com/gayanSandamal/easy-php-image-resizer

Ejemplo en vivo - https://plugins.nayague.com/easy-php-image-resizer/

<?php
//path for the image
$source_url = ''2018-04-01-1522613288.PNG'';
//separate the file name and the extention
$source_url_parts = pathinfo($source_url);
$filename = $source_url_parts[''filename''];
$extension = $source_url_parts[''extension''];
//define the quality from 1 to 100
$quality = 10;
//detect the width and the height of original image
list($width, $height) = getimagesize($source_url);
$width;
$height;
//define any width that you want as the output. mine is 200px.
$after_width = 200;
//resize only when the original image is larger than expected with.
//this helps you to avoid from unwanted resizing.
if ($width > $after_width) {
//get the reduced width
$reduced_width = ($width - $after_width);
//now convert the reduced width to a percentage and round it to 2 decimal places
$reduced_radio = round(($reduced_width / $width) * 100, 2);
//ALL GOOD! let''s reduce the same percentage from the height and round it to 2 decimal places
$reduced_height = round(($height / 100) * $reduced_radio, 2);
//reduce the calculated height from the original height
$after_height = $height - $reduced_height;
//Now detect the file extension
//if the file extension is ''jpg'', ''jpeg'', ''JPG'' or ''JPEG''
if ($extension == ''jpg'' || $extension == ''jpeg'' || $extension == ''JPG'' || $extension == ''JPEG'') {
//then return the image as a jpeg image for the next step
$img = imagecreatefromjpeg($source_url);
} elseif ($extension == ''png'' || $extension == ''PNG'') {
//then return the image as a png image for the next step
$img = imagecreatefrompng($source_url);
} else {
//show an error message if the file extension is not available
echo ''image extension is not supporting'';
}
//HERE YOU GO :)
//Let''s do the resize thing
//imagescale([returned image], [width of the resized image], [height of the resized image], [quality of the resized image]);
$imgResized = imagescale($img, $after_width, $after_height, $quality);
//now save the resized image with a suffix called "-resized" and with its extension.
imagejpeg($imgResized, $filename . ''-resized.''.$extension);
//Finally frees any memory associated with image
//**NOTE THAT THIS WONT DELETE THE IMAGE
imagedestroy($img);
imagedestroy($imgResized);
}
?>

Answer 3

Espero que funcione para ti.

/**
* Image re-size
* @param int $width
* @param int $height
*/
function ImageResize($width, $height, $img_name)
{
/* Get original file size */
list($w, $h) = getimagesize($_FILES[''logo_image''][''tmp_name'']);
/*$ratio = $w / $h;
$size = $width;
$width = $height = min($size, max($w, $h));
if ($ratio < 1) {
$width = $height * $ratio;
} else {
$height = $width / $ratio;
}*/
/* Calculate new image size */
$ratio = max($width/$w, $height/$h);
$h = ceil($height / $ratio);
$x = ($w - $width / $ratio) / 2;
$w = ceil($width / $ratio);
/* set new file name */
$path = $img_name;
/* Save image */
if($_FILES[''logo_image''][''type'']==''image/jpeg'')
{
/* Get binary data from image */
$imgString = file_get_contents($_FILES[''logo_image''][''tmp_name'']);
/* create image from string */
$image = imagecreatefromstring($imgString);
$tmp = imagecreatetruecolor($width, $height);
imagecopyresampled($tmp, $image, 0, 0, $x, 0, $width, $height, $w, $h);
imagejpeg($tmp, $path, 100);
}
else if($_FILES[''logo_image''][''type'']==''image/png'')
{
$image = imagecreatefrompng($_FILES[''logo_image''][''tmp_name'']);
$tmp = imagecreatetruecolor($width,$height);
imagealphablending($tmp, false);
imagesavealpha($tmp, true);
imagecopyresampled($tmp, $image,0,0,$x,0,$width,$height,$w, $h);
imagepng($tmp, $path, 0);
}
else if($_FILES[''logo_image''][''type'']==''image/gif'')
{
$image = imagecreatefromgif($_FILES[''logo_image''][''tmp_name'']);
$tmp = imagecreatetruecolor($width,$height);
$transparent = imagecolorallocatealpha($tmp, 0, 0, 0, 127);
imagefill($tmp, 0, 0, $transparent);
imagealphablending($tmp, true);
imagecopyresampled($tmp, $image,0,0,0,0,$width,$height,$w, $h);
imagegif($tmp, $path);
}
else
{
return false;
}
return true;
imagedestroy($image);
imagedestroy($tmp);
}

Answer 4

Necesita usar las funciones ImageMagick o GD PHP para trabajar con imágenes.

Con GD, por ejemplo, es tan simple como ...

function resize_image($file, $w, $h, $crop=FALSE) {
list($width, $height) = getimagesize($file);
$r = $width / $height;
if ($crop) {
if ($width > $height) {
$width = ceil($width-($width*abs($r-$w/$h)));
} else {
$height = ceil($height-($height*abs($r-$w/$h)));
}
$newwidth = $w;
$newheight = $h;
} else {
if ($w/$h > $r) {
$newwidth = $h*$r;
$newheight = $h;
} else {
$newheight = $w/$r;
$newwidth = $w;
}
}
$src = imagecreatefromjpeg($file);
$dst = imagecreatetruecolor($newwidth, $newheight);
imagecopyresampled($dst, $src, 0, 0, 0, 0, $newwidth, $newheight, $width, $height);
return $dst;
}

Y podrías llamar a esta función, así que ...

$img = resize_image(‘/path/to/some/image.jpg’, 200, 200);

Por experiencia personal, el remuestreo de imagen de GD también reduce drásticamente el tamaño del archivo, especialmente cuando se remuestrean imágenes crudas de la cámara digital.

Answer 5

Puede probar con la biblioteca PHP TinyPNG. Al usar esta biblioteca, tu imagen se optimiza automáticamente durante el proceso de cambio de tamaño. Todo lo que necesita para instalar la biblioteca y obtener una clave API de https://tinypng.com/developers . Para instalar una biblioteca, ejecute el siguiente comando.

composer require tinify/tinify

Después de eso, tu código es el siguiente.

require_once("vendor/autoload.php");
/Tinify/setKey("YOUR_API_KEY");
$source = /Tinify/fromFile("large.jpg"); //image to be resize
$resized = $source->resize(array(
"method" => "fit",
"width" => 150,
"height" => 100
));
$resized->toFile("thumbnail.jpg"); //resized image

He escrito un blog sobre el mismo tema http://artisansweb.net/resize-image-php-using-tinypng

Answer 6

Si no le importa la relación de aspecto (es decir, desea forzar la imagen a una dimensión particular), aquí hay una respuesta simplificada

// for jpg
function resize_imagejpg($file, $w, $h) {
list($width, $height) = getimagesize($file);
$src = imagecreatefromjpeg($file);
$dst = imagecreatetruecolor($w, $h);
imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
return $dst;
}
// for png
function resize_imagepng($file, $w, $h) {
list($width, $height) = getimagesize($file);
$src = imagecreatefrompng($file);
$dst = imagecreatetruecolor($w, $h);
imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
return $dst;
}
// for gif
function resize_imagegif($file, $w, $h) {
list($width, $height) = getimagesize($file);
$src = imagecreatefromgif($file);
$dst = imagecreatetruecolor($w, $h);
imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
return $dst;
}

Ahora manejemos la parte de carga. Primer paso, cargue el archivo en su directorio deseado. Luego llamó a una de las funciones anteriores en función del tipo de archivo (jpg, png o gif) y pasó la ruta absoluta de su archivo cargado de la siguiente manera:

 // jpg change the dimension 750, 450 to your desired values
$img = resize_imagejpg(''path/image.jpg'', 750, 450);

El valor de retorno $img es un objeto de recurso. Podemos guardar en una nueva ubicación o anular el original de la siguiente manera:

 // again for jpg
imagejpeg($img, ''path/newimage.jpg'');

Espero que esto ayude a alguien. Consulte estos enlaces para obtener más información sobre el cambio de tamaño de Imagick::resizeImage y imagejpeg()

Answer 7

Simplemente use la función php: dado como

// read the img
$img = imagecreatefromjpeg("source_of_img.jpg");
// Now read the iamge width = 200 and height = 200
$imgresize = imagescale($dp,200,200);

Answer 8

También vale la pena considerar este recurso : un código muy ordenado que usa GD. Sin embargo, modifiqué su fragmento de código final para crear esta función que cumple con los requisitos de OP ...

function store_uploaded_image($html_element_name, $new_img_width, $new_img_height) {
$target_dir = "your-uploaded-images-folder/";
$target_file = $target_dir . basename($_FILES[$html_element_name]["name"]);
$image = new SimpleImage();
$image->load($_FILES[$html_element_name][''tmp_name'']);
$image->resize($new_img_width, $new_img_height);
$image->save($target_file);
return $target_file; //return name of saved file in case you want to store it in you database or show confirmation message to user
}

También necesitarás incluir este archivo PHP ...

<?php
/*
* File: SimpleImage.php
* Author: Simon Jarvis
* Copyright: 2006 Simon Jarvis
* Date: 08/11/06
* Link: http://www.white-hat-web-design.co.uk/blog/resizing-images-with-php/
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details:
* http://www.gnu.org/licenses/gpl.html
*
*/
class SimpleImage {
var $image;
var $image_type;
function load($filename) {
$image_info = getimagesize($filename);
$this->image_type = $image_info[2];
if( $this->image_type == IMAGETYPE_JPEG ) {
$this->image = imagecreatefromjpeg($filename);
} elseif( $this->image_type == IMAGETYPE_GIF ) {
$this->image = imagecreatefromgif($filename);
} elseif( $this->image_type == IMAGETYPE_PNG ) {
$this->image = imagecreatefrompng($filename);
}
}
function save($filename, $image_type=IMAGETYPE_JPEG, $compression=75, $permissions=null) {
if( $image_type == IMAGETYPE_JPEG ) {
imagejpeg($this->image,$filename,$compression);
} elseif( $image_type == IMAGETYPE_GIF ) {
imagegif($this->image,$filename);
} elseif( $image_type == IMAGETYPE_PNG ) {
imagepng($this->image,$filename);
}
if( $permissions != null) {
chmod($filename,$permissions);
}
}
function output($image_type=IMAGETYPE_JPEG) {
if( $image_type == IMAGETYPE_JPEG ) {
imagejpeg($this->image);
} elseif( $image_type == IMAGETYPE_GIF ) {
imagegif($this->image);
} elseif( $image_type == IMAGETYPE_PNG ) {
imagepng($this->image);
}
}
function getWidth() {
return imagesx($this->image);
}
function getHeight() {
return imagesy($this->image);
}
function resizeToHeight($height) {
$ratio = $height / $this->getHeight();
$width = $this->getWidth() * $ratio;
$this->resize($width,$height);
}
function resizeToWidth($width) {
$ratio = $width / $this->getWidth();
$height = $this->getheight() * $ratio;
$this->resize($width,$height);
}
function scale($scale) {
$width = $this->getWidth() * $scale/100;
$height = $this->getheight() * $scale/100;
$this->resize($width,$height);
}
function resize($width,$height) {
$new_image = imagecreatetruecolor($width, $height);
imagecopyresampled($new_image, $this->image, 0, 0, 0, 0, $width, $height, $this->getWidth(), $this->getHeight());
$this->image = $new_image;
}
}
?>

Answer 9

Tarta ZF:

<?php
class FkuController extends Zend_Controller_Action {
var $image;
var $image_type;
public function store_uploaded_image($html_element_name, $new_img_width, $new_img_height) {
$target_dir = APPLICATION_PATH . "/../public/1/";
$target_file = $target_dir . basename($_FILES[$html_element_name]["name"]);
//$image = new SimpleImage();
$this->load($_FILES[$html_element_name][''tmp_name'']);
$this->resize($new_img_width, $new_img_height);
$this->save($target_file);
return $target_file;
//return name of saved file in case you want to store it in you database or show confirmation message to user
public function load($filename) {
$image_info = getimagesize($filename);
$this->image_type = $image_info[2];
if( $this->image_type == IMAGETYPE_JPEG ) {
$this->image = imagecreatefromjpeg($filename);
} elseif( $this->image_type == IMAGETYPE_GIF ) {
$this->image = imagecreatefromgif($filename);
} elseif( $this->image_type == IMAGETYPE_PNG ) {
$this->image = imagecreatefrompng($filename);
}
}
public function save($filename, $image_type=IMAGETYPE_JPEG, $compression=75, $permissions=null) {
if( $image_type == IMAGETYPE_JPEG ) {
imagejpeg($this->image,$filename,$compression);
} elseif( $image_type == IMAGETYPE_GIF ) {
imagegif($this->image,$filename);
} elseif( $image_type == IMAGETYPE_PNG ) {
imagepng($this->image,$filename);
}
if( $permissions != null) {
chmod($filename,$permissions);
}
}
public function output($image_type=IMAGETYPE_JPEG) {
if( $image_type == IMAGETYPE_JPEG ) {
imagejpeg($this->image);
} elseif( $image_type == IMAGETYPE_GIF ) {
imagegif($this->image);
} elseif( $image_type == IMAGETYPE_PNG ) {
imagepng($this->image);
}
}
public function getWidth() {
return imagesx($this->image);
}
public function getHeight() {
return imagesy($this->image);
}
public function resizeToHeight($height) {
$ratio = $height / $this->getHeight();
$width = $this->getWidth() * $ratio;
$this->resize($width,$height);
}
public function resizeToWidth($width) {
$ratio = $width / $this->getWidth();
$height = $this->getheight() * $ratio;
$this->resize($width,$height);
}
public function scale($scale) {
$width = $this->getWidth() * $scale/100;
$height = $this->getheight() * $scale/100;
$this->resize($width,$height);
}
public function resize($width,$height) {
$new_image = imagecreatetruecolor($width, $height);
imagecopyresampled($new_image, $this->image, 0, 0, 0, 0, $width, $height, $this->getWidth(), $this->getHeight());
$this->image = $new_image;
}
public function savepicAction() {
ini_set(''display_errors'', 1);
ini_set(''display_startup_errors'', 1);
error_reporting(E_ALL);
$this->_helper->layout()->disableLayout();
$this->_helper->viewRenderer->setNoRender();
$this->_response->setHeader(''Access-Control-Allow-Origin'', ''*'');
$this->db = Application_Model_Db::db_load();
$ouser = $_POST[''ousername''];
$fdata = ''empty'';
if (isset($_FILES[''picture'']) && $_FILES[''picture''][''size''] > 0) {
$file_size = $_FILES[''picture''][''size''];
$tmpName = $_FILES[''picture''][''tmp_name''];
//Determine filetype
switch ($_FILES[''picture''][''type'']) {
case ''image/jpeg'': $ext = "jpg"; break;
case ''image/png'': $ext = "png"; break;
case ''image/jpg'': $ext = "jpg"; break;
case ''image/bmp'': $ext = "bmp"; break;
case ''image/gif'': $ext = "gif"; break;
default: $ext = ''''; break;
}
if($ext) {
//if($file_size<400000) {
$img = $this->store_uploaded_image(''picture'', 90,82);
//$fp = fopen($tmpName, ''r'');
$fp = fopen($img, ''r'');
$fdata = fread($fp, filesize($tmpName));
$fdata = base64_encode($fdata);
fclose($fp);
//}
}
}
if($fdata==''empty''){
}
else {
$this->db->update(''users'',
array(
''picture'' => $fdata,
),
array(''username=?'' => $ouser ));
}
}

Answer 10

Te recomendaría que utilizases piio.co , una vez que hayas subido tus imágenes a tu almacenamiento, simplemente usas la url de la imagen original en tu <img /> y la biblioteca automáticamente hará el cambio de tamaño por ti.

Su etiqueta de imagen se verá así:

<img data-piio="/image/gallery/p/image1.jpg" />

Luego, una vez que inicialice el script de Piio, se redimensionará automáticamente la imagen y se publicará desde un CDN.

Aquí hay un enlace a los docs

Si desea hacerlo manualmente , le recomiendo que use las funciones nativas de php, esto usará la biblioteca de GD. Por ejemplo, si desea cambiar el tamaño de un archivo JPEG, puede comenzar con:

list($width, $height) = getimagesize($filepath);
$original = imagecreatefromjpeg($filepath);
$thumb = imagecreatetruecolor($new_width, $new_height);
imagecopyresized($thumb, $original, 0, 0, 0, 0, $new_width, $new_height, $width, $height);

Para generar directamente la imagen:

imagejpeg($thumb);

Para guardar la imagen en un archivo:

imagejpeg($thumb, ''filepath/image.jpg'');