PHP Image::mime方法代码示例

 /**
  * Handle request to convert it to a Response object.
  */
 public function handle()
 {
     try {
         if (!$this->request->query->has('image')) {
             throw new FileNotFoundException("No valid image path found in URI", 1);
         }
         $nativePath = $this->configuration->getImagesPath() . '/' . $this->request->query->get('image');
         $this->nativeImage = new File($nativePath);
         $this->parseQuality();
         if ($this->configuration->hasCaching()) {
             $cache = new FileCache($this->request, $this->nativeImage, $this->configuration->getCachePath(), $this->logger, $this->quality, $this->configuration->getTtl(), $this->configuration->getGcProbability(), $this->configuration->getUseFileChecksum());
             $cache->setDispatcher($this->dispatcher);
             /** @var Response response */
             $this->response = $cache->getResponse(function (InterventionRequest $interventionRequest) {
                 return $interventionRequest->processImage();
             }, $this);
         } else {
             $this->processImage();
             $this->response = new Response((string) $this->image->encode(null, $this->quality), Response::HTTP_OK, ['Content-Type' => $this->image->mime(), 'Content-Disposition' => 'filename="' . $this->nativeImage->getFilename() . '"', 'X-Generator-First-Render' => true]);
             $this->response->setLastModified(new \DateTime('now'));
         }
     } catch (FileNotFoundException $e) {
         $this->response = $this->getNotFoundResponse($e->getMessage());
     } catch (\RuntimeException $e) {
         $this->response = $this->getBadRequestResponse($e->getMessage());
     }
 }

 public function getFormat(Image $image)
 {
     $allowed = ['gif' => 'image/gif', 'jpg' => 'image/jpeg', 'pjpg' => 'image/jpeg', 'png' => 'image/png'];
     if (array_key_exists($this->fm, $allowed)) {
         return $this->fm;
     }
     if ($format = array_search($image->mime(), $allowed, true)) {
         return $format;
     }
     return 'jpg';
 }

 /**
  * Resolve format.
  * @param  string $format The format.
  * @return string The resolved format.
  */
 public function getFormat(Image $image, $format)
 {
     $allowed = ['image/jpeg' => 'jpg', 'image/png' => 'png', 'image/gif' => 'gif'];
     if (in_array($format, $allowed, true)) {
         return $format;
     }
     $mime = $image->mime();
     if (isset($allowed[$mime])) {
         return $allowed[$mime];
     }
     return 'jpg';
 }

 /**
  * Save file to database and to our filesystem.
  */
 public static function make(Picture $picture, Image $image, $identifier)
 {
     $file = new self();
     $file->picture_id = $picture->id;
     $file->identifier = $identifier;
     $file->mime = $image->mime();
     $file->extension = $image->extension;
     $file->width = $image->width();
     $file->height = $image->height();
     self::checkDirPermission();
     $image->save($file->getFilePath());
     $file->save();
 }

 /**
  * Save an Picture object to the file system.
  * Runs OptimizeFileJob on the file after it is saved.
  *
  * @param Picture        $picture
  * @param string         $directory One of the *_DIR constants.
  * @param string         $filename
  * @param ImageFile|null $originalImageFile
  *
  * @throws Exception
  * @return ImageFile
  */
 public function savePicture(Picture $picture, $directory = self::IMAGE_DIR, $filename = null, ImageFile $originalImageFile = null)
 {
     if (!$filename) {
         $mime = $picture->mime();
         if (empty($mime)) {
             $mime = 'image/jpeg';
         }
         $extension = $this->getExtensionForMime($mime);
         $filename = $this->generateFilename($extension);
     }
     $relativePath = $directory . '/' . $filename;
     // Save locally
     if (!$this->savePictureLocally($picture, $relativePath)) {
         throw new Exception('Unable to save file locally.');
     }
     $imageFile = new ImageFile(['originalImageFileId' => $originalImageFile ? $originalImageFile->getId() : null, 'directory' => $directory, 'filename' => $filename, 'width' => $picture->getWidth(), 'height' => $picture->getHeight(), 'size' => $picture->filesize()]);
     $imageFile->save();
     // Optimize and copy to remote storage
     $this->dispatch(new OptimizeFileJob($imageFile));
     return $imageFile;
 }

 public function getInfo()
 {
     return ['mime' => $this->image->mime(), 'width' => $this->image->width(), 'height' => $this->image->height(), 'extension' => $this->image->extension, 'filename' => $this->image->filename, 'filesize' => $this->image->filesize()];
 }

 /**
  * Guess extension .
  *
  * @param Image $image
  * @return string
  */
 protected function guessExtension(Image $image)
 {
     $guesser = ExtensionGuesser::getInstance();
     return $guesser->guess($image->mime());
 }

 /**
  * Create image record.
  *
  * @return Image
  */
 protected function createDatabaseRecord()
 {
     return Image::create(['hash' => $this->hash, 'mime_type' => $this->image->mime(), 'uploaded_at' => $this->uploaded_at->timestamp]);
 }

 private function buildAssetFromImage(\Intervention\Image\Image $image, $organization, $name, $type)
 {
     $mime = $image->mime();
     $name = new Name($name);
     $guid = Guid::generate();
     $asset = Asset::register($name, $guid, $mime, $organization);
     $asset->setTitle($name);
     if (isset($type)) {
         $asset->setType($type);
     }
     return $asset;
 }