Get Intervention image manager.
@return ImageManager Intervention image manager.
763007
public function getImageManager()
    {
        $driver = 'gd';

        if (isset($this->config['driver'])) {
            $driver = $this->config['driver'];
        }

        return new ImageManager([
            'driver' => $driver,
        ]);
    }
1337828
public function getImageHandler()
    {
        if (!$this->imageHandler) {
            $this->imageHandler = new CaptchaImage();
            
            $object = $this->imageHandler;
            $object->width = 90;
            $object->height = 26;
            $object->background = 1;
            $object->adulterate = 1;
            $object->scatter = '';
            $object->color = 1;
            $object->size = 0;
            $object->shadow = 1;
            $object->animator = 0;
        }
        
        return $this->imageHandler;
    }
1007267
public BufferedImage getAsImage() {
        final BufferedImage IMAGE = UTIL.createImage(getWidth(), getHeight(), Transparency.TRANSLUCENT);
        final Graphics2D G2 = IMAGE.createGraphics();
        paintAll(G2);
        G2.dispose();
        return IMAGE;
    }
1249367
public PageManager getPageManager() {
        if (pageManager != null) {
            return pageManager;
        }
        pageManager = (PageManager) ContainerManager.getComponent("pageManager");
        return pageManager;
    }
617096
public function getBlockManager()
    {
        if (null === $this->blockManager) {
            $this->blockManager = new Manager\BlockManager(
                $this->config['default_block_plugin']
            );
            $this->blockManager->setEditor($this);
        }

        return $this->blockManager;
    }
904202
public Manager getObject() throws Exception {
		Manager manager;
		if (singleton) {
			manager = SimonManager.manager();
		} else {
			manager = new SwitchingManager();
		}
		registerCallbacks(manager);
		configureEnabled(manager);
		return manager;
	}
831855
public function Image()
    {
        if ($this->ActionImage()) {
            return $this->ActionImage();
        }
        if ($this->Type == 'SiteTree') {
            return $this->SiteTree()->ActionImage();
        }
    }
904229
final public function build()
    {
        return new ImageManager($this->getPath(), $this->getRootDir(), $this->getRootUrl(), $this->getConfig());
    }
480636
protected function getImageInstance()
    {
        //Tries to create the image instance
        try {
            $imageInstance = $this->ImageManager->make($this->path);
        } catch (NotReadableException $e) {
            $message = __d('thumber', 'Unable to read image from file `{0}`', rtr($this->path));

            if ($e->getMessage() == 'Unsupported image type. GD driver is only able to decode JPG, PNG, GIF or WebP files.') {
                $message = __d('thumber', 'Image type `{0}` is not supported by this driver', mime_content_type($this->path));
            }

            throw new RuntimeException($message);
        }

        return $imageInstance;
    }
633659
public function getCommandManager()
	{
	    if ($this->commandManager === null) {
	        $this->commandManager = new CommandManager();
	        $this->commandManager->setServiceLoader($this);
	    }
	     
	    return $this->commandManager;
	}
980348
public function getImagineImage()
    {
        if (null === $this->imagineImage) {
            $app = Application::getFacadeApplication();
            $resource = $this->getFileResource();
            $mimetype = $resource->getMimeType();
            $imageLibrary = $app->make(ImagineInterface::class);

            switch ($mimetype) {
                case 'image/svg+xml':
                case 'image/svg-xml':
                case 'text/plain':
                    if ($imageLibrary instanceof \Imagine\Gd\Imagine) {
                        try {
                            $imageLibrary = $app->make('image/imagick');
                        } catch (Exception $x) {
                            $this->imagineImage = false;
                        } catch (Throwable $x) {
                            $this->imagineImage = false;
                        }
                    }
                    break;
            }

            if (null === $this->imagineImage) {
                $metadataReader = $imageLibrary->getMetadataReader();
                if (!$metadataReader instanceof ExifMetadataReader) {
                    if ($app->make('config')->get('concrete.file_manager.images.use_exif_data_to_rotate_images')) {
                        try {
                            $imageLibrary->setMetadataReader(new ExifMetadataReader());
                        } catch (NotSupportedException $e) {
                        }
                    }
                }
                try {
                    $this->imagineImage = $imageLibrary->load($resource->read());
                } catch (FileNotFoundException $e) {
                    $this->imagineImage = false;
                }
            }
        }

        return $this->imagineImage ?: null;
    }
406031
public function imageFactory()
    {
        if ($this->imageFactory === null) {
            $this->imageFactory = $this->createImageFactory();
        }

        return $this->imageFactory;
    }
663929
public function getImagineImage()
    {
        if (empty($this->imagineImage)) {
            $this->assertImagine();
            $binaryContent = $this->getBinaryContent();
            if (empty($binaryContent)) {
                throw new ImageException('Empty image', ImageException::EMPTY_IMAGE);
            }
            $this->imagineImage = $this->getImagine()->load($binaryContent);
        }
        return $this->imagineImage;
    }
1231853
public function getImage() : ?string 
    {
        if ( ! $this->hasImage()) {
            $this->setImage($this->getDefaultImage());
        }
        return $this->image;
    }
1268166
public function image()
    {
        if ($this->relationLoaded('mediables')) {
            return $this->mediables->where('type', 'image')->first();
        }

        return $this->mediables()
            ->where('media.type', 'image')
            ->whereNull('mediables.type')
            ->first();
    }
801678
protected function getResourceDimensions(InterventionImage $resource)
    {
        /** @var Size $size */
        $size = $resource->getSize();
        return [
            $size->getWidth(),
            $size->getHeight()
        ];
    }
519247
protected function getResourceManager()
    {
        if ($this->resourceManager === null) {
            $this->resourceManager = Services::resourceManager();
        }
        return $this->resourceManager;
    }