ti-enxame.com

Use LiipImagineBundle para redimensionar a imagem após o upload?

Estou usando o LiipImagineBundle com o Symfony 2.1 e gostaria de redimensionar as imagens enviadas pelos usuários após o upload antes de salvá-las no local permanente do sistema de arquivos (para remover metadados, impor o formato jpeg e limitar o tamanho do arquivo ) Preciso chamar um filtro 'strip' e 'redimensionar' do controlador e salvar a imagem filtrada de um local temporário em uma pasta de minha escolha no sistema de arquivos.

Tentei usar o LiipImageBundle Controller como um serviço, conforme indicado no leia-me do pacote mas a ação chamada é principalmente para criar uma imagem filtrada no diretório de cache quando é feita uma solicitação para exibir a imagem (usando-a para filtrar durante o upload é outro caso). Tentei implementá-lo da seguinte maneira e consegui que funcionasse. Eu tive que primeiro mover o arquivo do diretório temporário php do servidor da web para um diretório na pasta da web para poder aplicar o filtro. Em segundo lugar, apliquei o filtro e excluí (desvinculei ()) o arquivo não filtrado inicial. Por fim, tive que mover (renomear ()) o arquivo filtrado para o local permanente no sistema de arquivos. Era necessário mover o arquivo duas vezes, aplicar o filtro uma vez e excluir (desvincular) 1 arquivo para que tudo funcionasse. Existe uma maneira melhor (sem exigir a movimentação intermediária) de usar o pacote configurável no upload?

class MyController extends Controller
{
    public function new_imageAction(Request $request)
    {
        $uploadedFile = $request->files->get('file');
        $tmpFolderPathAbs = $this->get('kernel')->getRootDir() . '/../web/uploads/tmp/';
        $tmpImageNameNoExt = Rand();
        $tmpImageName = $tmpImageNameNoExt . '.' . $fileExtension;
        $uploadedFile->move($tmpFolderPathAbs, $tmpImageName);
        $tmpImagePathRel = '/uploads/tmp/' . $tmpImageName;
        // Create the filtered image in a tmp folder:
        $this->container->get('liip_imagine.controller')->filterAction($request, $tmpImagePathRel, 'my_filter');
        unlink($tmpFolderPathAbs . $tmpImageName);
        $filteredImagePathAbs = $this->get('kernel')->getRootDir() . '/../web/uploads/cache/my_filter/uploads/tmp/' . $tmpImageNameNoExt . '.jpeg';
        $imagePath = $imageManagerResponse->headers->get('location');
        // define permanent location ($permanentImagePathAbs)...
        rename($filteredImagePathAbs, $permanentImagePathAbs);
    }
}

Meu filtro no app/config/config.yml é o seguinte:

liip_imagine:
    filter_sets:
        my_filter:
            format: jpeg
            filters:
                strip: ~
                thumbnail: { size: [1600, 1000], mode: inset }

ma pergunta semelhante foi feita para o ImagineAvalancheBundle mas não há muitos detalhes. Talvez implementar outro serviço da lista fornecida aqui é uma solução melhor?

19
RayOnAir

Então, aqui está uma maneira de criar miniaturas no upload com LiipImagineBundle. O truque é usar alguns de seus outros serviços:

    /**
     * Write a thumbnail image using the LiipImagineBundle
     * 
     * @param Document $document an Entity that represents an image in the database
     * @param string $filter the Imagine filter to use
     */
    private function writeThumbnail($document, $filter) {
        $path = $document->getWebPath();                                // domain relative path to full sized image
        $tpath = $document->getRootDir().$document->getThumbPath();     // absolute path of saved thumbnail

        $container = $this->container;                                  // the DI container
        $dataManager = $container->get('liip_imagine.data.manager');    // the data manager service
        $filterManager = $container->get('liip_imagine.filter.manager');// the filter manager service

        $image = $dataManager->find($filter, $path);                    // find the image and determine its type
        $response = $filterManager->get($this->getRequest(), $filter, $image, $path); // run the filter 
        $thumb = $response->getContent();                               // get the image from the response

        $f = fopen($tpath, 'w');                                        // create thumbnail file
        fwrite($f, $thumb);                                             // write the thumbnail
        fclose($f);                                                     // close the file
    }

Isso também pode ser feito chamando diretamente as funções da biblioteca Imagine se você não tiver outro motivo para incluir o LiipImagineBundle. Provavelmente analisarei isso no futuro, mas isso funciona para o meu caso e funciona muito bem.

17
Peter Wooster

Versão modificada do @Peter Wooster, e a tornou mais genérica, de modo que, se alguém a estiver usando sem a entidade Image, poderá facilmente tirar o benefício dele. Estou dando aqui duas versões, uma que pode ser usada mantida na classe utilidade ou não-controlador. E a outra versão é para classes de controladores. Cabe a você agora onde você gosta :)

Para usar fora do controlador, por exemplo mantendo-o nas classes de utilidade

/**
 * Write a thumbnail image using the LiipImagineBundle
 * 
 * @param Document $fullSizeImgWebPath path where full size upload is stored e.g. uploads/attachments
 * @param string $thumbAbsPath full absolute path to attachment directory e.g. /var/www/project1/images/thumbs/
 * @param string $filter filter defined in config e.g. my_thumb
 * @param Object $diContainer Dependency Injection Object, if calling from controller just pass $this
 */
public function writeThumbnail($fullSizeImgWebPath, $thumbAbsPath, $filter, $diContainer) {
    $container = $diContainer; // the DI container, if keeping this function in controller just use $container = $this
    $dataManager = $container->get('liip_imagine.data.manager');    // the data manager service
    $filterManager = $container->get('liip_imagine.filter.manager'); // the filter manager service
    $image = $dataManager->find($filter, $fullSizeImgWebPath);                    // find the image and determine its type
    $response = $filterManager->applyFilter($image, $filter);

    $thumb = $response->getContent();                               // get the image from the response

    $f = fopen($thumbAbsPath, 'w');                                        // create thumbnail file
    fwrite($f, $thumb);                                             // write the thumbnail
    fclose($f);                                                     // close the file
}

Para usar no controlador, por exemplo CommonController ou qualquer outro controlador.

/**
 * Write a thumbnail image using the LiipImagineBundle
 * 
 * @param Document $fullSizeImgWebPath path where full size upload is stored e.g. uploads/attachments
 * @param string $thumbAbsPath full absolute path to attachment directory e.g. /var/www/project1/images/thumbs/
 * @param string $filter filter defined in config e.g. my_thumb
 */
public function writeThumbnail($fullSizeImgWebPath, $thumbAbsPath, $filter) {
    $container = $this->container;
    $dataManager = $container->get('liip_imagine.data.manager');    // the data manager service
    $filterManager = $container->get('liip_imagine.filter.manager'); // the filter manager service
    $image = $dataManager->find($filter, $fullSizeImgWebPath);                    // find the image and determine its type
    $response = $filterManager->applyFilter($image, $filter);

    $thumb = $response->getContent();                               // get the image from the response

    $f = fopen($thumbAbsPath, 'w');                                        // create thumbnail file
    fwrite($f, $thumb);                                             // write the thumbnail
    fclose($f);                                                     // close the file
}
9
Imran Zahoor

Em vez de carregar o arquivo usando o liip data manager, crie um objeto binário liip a partir do arquivo carregado:

use Liip\ImagineBundle\Model\Binary;

então use o seguinte código:

                // Generate a unique name for the file before saving it
                $fileName = md5(uniqid()) . '.' . $uploadedFile->guessExtension();

                $contents = file_get_contents($uploadedFile);

                $binary = new Binary(
                    $contents,
                    $uploadedFile->getMimeType(),
                    $uploadedFile->guessExtension()
                );

                $container = $this->container;
                $filterManager = $container->get('liip_imagine.filter.manager');    // the filter manager service
                $response = $filterManager->applyFilter($binary, 'my_thumb');

                $thumb = $response->getContent();                               // get the image from the response

                $f = fopen($webRootDir .'/images_dir/' . $fileName, 'w');                                        // create thumbnail file
                fwrite($f, $thumb);                                             // write the thumbnail
                fclose($f);                                                     // close the file
1
Kinan

Eu escrevi um pacote que resolve exatamente esse problema. Enquanto VichUploaderBundle facilita o upload usando retornos de chamada do ciclo de vida do ORM, LiipImagine faz um ótimo trabalho no redimensionamento.

Aqui está a combinação disso: https://github.com/RSSfeed/VichImagineBundle

Veja o leia-me curto sobre como implementá-lo em apenas alguns minutos.

0
Dennis

Como não encontrei uma maneira melhor, mantive a solução descrita na descrição da pergunta. Essa solução não parece a ideal do ponto de vista do desempenho (requer mover o arquivo duas vezes, aplicar o filtro uma vez e desvincular 1 arquivo), mas realiza o trabalho.

ATUALIZAR:

Alterei meu código para usar os serviços indicados na resposta de Peter Wooster, como mostrado abaixo (essa solução é mais ideal, pois a imagem filtrada é salva diretamente no destino final):

class MyController extends Controller
{
    public function new_imageAction(Request $request)
    {
        $uploadedFile = $request->files->get('file');
        // ...get file extension and do other validation...
        $tmpFolderPathAbs = $this->get('kernel')->getRootDir() . '/../web/uploads/tmp/'; // folder to store unfiltered temp file
        $tmpImageNameNoExt = Rand();
        $tmpImageName = $tmpImageNameNoExt . '.' . $fileExtension;
        $uploadedFile->move($tmpFolderPathAbs, $tmpImageName);
        $tmpImagePathRel = '/uploads/tmp/' . $tmpImageName;
        // Create the filtered image:
        $processedImage = $this->container->get('liip_imagine.data.manager')->find('my_filter', $tmpImagePathRel);
        $filteredImage = $this->container->get('liip_imagine.filter.manager')->get($request, 'my_filter', $processedImage, $tmpImagePathRel)->getContent();
        unlink($tmpFolderPathAbs . $tmpImageName); // eliminate unfiltered temp file.
        $permanentFolderPath = $this->get('kernel')->getRootDir() . '/../web/uploads/path_to_folder/';
        $permanentImagePath = $permanentFolderPath . 'my_image.jpeg';
        $f = fopen($permanentImagePath, 'w');
        fwrite($f, $filteredImage); 
        fclose($f);
    }
}
0
RayOnAir