Créer une image sans la stocker en tant que fichier local

La plupart des gens à l'aide de PHP choisir ImageMagick ou Gd2

Je n'ai jamais utilisé Imagemagick; le Gd2 méthode:

<?php

//assuming your uploaded file was 'userFileName'

if ( ! is_uploaded_file(validateFilePath($_FILES[$userFileName]['tmp_name'])) ) {
    trigger_error('not an uploaded file', E_USER_ERROR);
}
$srcImage = imagecreatefromjpeg( $_FILES[$userFileName]['tmp_name'] );

//Resize your image (copy from srcImage to dstImage)
imagecopyresampled($dstImage, $srcImage, 0, 0, 0, 0, RESIZED_IMAGE_WIDTH, RESIZED_IMAGE_HEIGHT, imagesx($srcImage), imagesy($srcImage));

//Storing your resized image in a variable
ob_start(); //start a new output buffer
  imagejpeg( $dstImage, NULL, JPEG_QUALITY);
  $resizedJpegData = ob_get_contents();
ob_end_clean(); //stop this output buffer

//free up unused memmory (if images are expected to be large)
unset($srcImage);
unset($dstImage);

//your resized jpeg data is now in $resizedJpegData
//Use your Undesigned method calls to store the data.

//(Many people want to send it as a Hex stream to the DB:)
$dbHandle->storeResizedImage( $resizedJpegData );
?>

Espère que cette aide.

Cela peut être fait à l'aide de la librairie GD et le tampon de sortie. Je ne sais pas comment efficace, c'est en comparaison avec d'autres méthodes, mais il ne nécessite pas explicite création de fichiers.

//$image contains the GD image resource you want to store

ob_start();
imagejpeg($image);
$jpeg_file_contents = ob_get_contents();
ob_end_clean();

//now send $jpeg_file_contents to S3

Rends compte que c'est un vieux thread, mais j'ai passé un certain temps à se taper la tête contre le mur sur ce sujet aujourd'hui, et pensé que je pourrais capturer ma solution ici pour le gars à côté.

Cette méthode utilise SDK AWS pour PHP 2 et GD pour l'image resize (Imagick pourrait également être utilisée).

require_once('vendor/aws/aws-autoloader.php');

use Aws\Common\Aws;

define('AWS_BUCKET', 'your-bucket-name-here');

//Configure AWS factory 
$aws = Aws::factory(array(
    'key' => 'your-key-here',
    'secret' => 'your-secret-here',
    'region' => 'your-region-here'
));

//Create reference to S3
$s3 = $aws->get('S3');
$s3->createBucket(array('Bucket' => AWS_BUCKET));
$s3->waitUntilBucketExists(array('Bucket' => AWS_BUCKET));
$s3->registerStreamWrapper();

//Do your GD resizing here (omitted for brevity)

//Capture image stream in output buffer
ob_start();
imagejpeg($imageRes);
$imageFileContents = ob_get_contents();
ob_end_clean();

//Send stream to S3
$context = stream_context_create(
  array(
    's3' => array(
      'ContentType'=> 'image/jpeg'
    )
  )
);
$s3Stream = fopen('s3://'.AWS_BUCKET.'/'.$filename, 'w', false, $context);
fwrite($s3Stream, $imageFileContents);
fclose($s3Stream);

unset($context, $imageFileContents, $s3Stream);

Je rencontre le même problème, à l'aide de openstack magasin d'objets et php-opencloud bibliothèque.

Voici ma solution, qui ne pas utiliser le ob_start et ob_end_clean fonction, mais stocker l'image dans la mémoire et dans le fichier temp. La taille de la mémoire et les fichiers temporaires peuvent être adaptées à l'exécution.

//$image is a resource created by gd2
var_dump($image); //resource(2) of type (gd)

//we create a resource in memory + temp file 
$tmp = fopen('php://temp', '$r+');

//we write the image into our resource
\imagejpeg($image, $tmp);

//the image is now in $tmp, and you can handle it as a stream
//you can, then, upload it as a stream (not tested but mentioned in doc http://docs.aws.amazon.com/aws-sdk-php/v2/guide/service-s3.html#uploading-from-a-stream)
$s3->putObject(array(
   'Bucket' => $bucket,
   'Key'    => 'data_from_stream.txt',
   'Body'   => $tmp
));

//or, for the ones who prefers php-opencloud :
$container->createObject([
    'name'  => 'data_from_stream.txt',
    'stream' => \Guzzle\Psr7\stream_for($tmp),
    'contentType' => 'image/jpeg'
]);

Sur php://temp (à partir de la documentation officielle de php):

php://mémoire et php://temp sont des flux en lecture /écriture qui permettent de stocker des données temporaires dans un gestionnaire de fichiers. La seule différence entre les deux est que php://mémoire sera toujours stocker ses données en mémoire, alors que php://temp va utiliser un fichier temporaire une fois que la quantité de données stockées atteint une limite prédéfinie (par défaut est de 2 MO). L'emplacement de ce fichier temporaire est déterminé de la même manière que la fonction sys_get_temp_dir ().

La limite de la mémoire de php://temp peut être contrôlée en ajoutant /maxmemory:NN, où NN est la quantité maximale de données à conserver en mémoire avant d'utiliser un fichier temporaire, en octets.