Answers true if the meta image link is to the image file.

@return boolean
333686
public function isMetaImageFileLink()
    {
        if ($this->owner->hasMetaImage()) {
            return ($this->owner->getMetaImageLink() == $this->owner->getMetaImageURL());
        }
        
        return false;
    }
111363
public function isImage()
	{
		$mime = $this->getMimeType();
		
		// The $imageMimes property contains an array of file extensions and
		// their associated MIME types. We will loop through them and look for 
		// the MIME type of the current SymfonyUploadedFile.
		foreach ($this->imageMimes as $imageMime)
		{
			if (in_array($mime, (array) $imageMime))
			{
				return true;
			}
		}

		return false;
	}
117394
public function add_to_media_library()
    {
        if ($this->upload_path === false) {
            return false;
        }

        $attachment = [
            'guid' => $this->upload_url,
            'post_mime_type' => $this->upload_type,
            'post_title' => \pathinfo($this->upload_path, PATHINFO_FILENAME),
            'post_content' => '',
            'post_status' => 'inherit',
        ];

        // Insert the attachment.
        $attach_id = \wp_insert_attachment($attachment);

        if ($attach_id == 0 || $attach_id instanceof \WP_Error) {
            return false;
        }

        // Make sure that this file is included, as wp_generate_attachment_metadata() depends on it.
        require_once(ABSPATH . 'wp-admin/includes/image.php');

        // Generate the meta for the attachment.
        $attach_data = \wp_generate_attachment_metadata($attach_id, $this->upload_path);

        // Update attachment meta.
        \wp_update_attachment_metadata($attach_id, $attach_data);
        \update_attached_file($attach_id, $this->upload_path);

        $this->attachment_id = $attach_id;

        return true;
    }
526404
private function _get_file_extension()
    {

        if (empty($this->u_mime_type)) return false;

        $tmp                  = explode('/', $this->u_mime_type);
        $this->file_extension = array_pop($tmp);

        unset($tmp);

        return true;
    }
727356
public function deleteImages() 
    {		
    	$thumb = false;
    	$img = false;
    	
    	if(file_exists($this->path)) {
			unlink($this->path);
		}
		
		if(file_exists($this->thumbnailPath)) {
			unlink($this->thumbnailPath);
		}
		
		$img = !file_exists($this->path);
		$thumb = !file_exists($this->thumbnailPath);
		
		return $img && $thumb;
    }
1311913
public function hasValidSourceFile()
    {
        $sourcefile = $this->getSourceFile();

        return (true === is_readable($sourcefile) && false === is_dir($sourcefile));
    }
454185
public function exists()
    {
        try {
            $path = $this->getPrefix();

            if ($this->getFileSystem()->has($path)) {
                $metadata = $this->getFileSystem()->getMetadata($this->getPrefix());
                return $metadata['type'] === 'file';
            }
        } catch (FileNotFoundException $e) {
        }
        return false;
    }
80490
protected function _isMetadatasFile($fileName)
    {
        $id = $this->_fileNameToId($fileName);
        if (substr($id, 0, 21) == 'internal-metadatas---') {
            return true;
        } else {
            return false;
        }
    }
645693
private function verifyExtensionFile()
    {
        $supported_image = array(
            'gif',
            'jpg',
            'jpeg',
            'png'
        );

        $fileName = $_SERVER['HTTP_X_FILE_NAME'];

        $ext = strtolower(pathinfo($fileName, PATHINFO_EXTENSION));
        if (in_array($ext, $supported_image)) {
            return true;
        }
        return false;
    }
433502
public function isFile(): bool
    {
        if ($this->caching == false) {
            return is_file($this->getAbsoluteFilePath());
        }

        if ($this->isFile == null) {
            $this->isFile = is_file($this->getAbsoluteFilePath());
        }

        return $this->isFile;
    }
314948
public function isImage($mimeType)
    {
        $isValid = false;

        $allowedType = array('image/jpeg' , 'image/png' ,'image/gif');

        if (\in_array($mimeType, $allowedType)) {
            $isValid = true;
        }

        return $isValid;
    }
1063301
function is_file()
    {
        if (!empty($this->_attributes['file'])){
            return true;
        }
        if (($proto = $this->is_default_file(null, true)) && $proto->is_exists()){
           return $proto->is_file();
        }
        return false;
    }
805818
public function getMetaImageFooter()
    {
        if ($this->owner->hasMetaImageCaption()) {
            return $this->owner->obj('MetaImageCaption')->Plain();
        }
        
        return $this->owner->getMetaSummaryLimited();
    }
976166
public function checkPageSubjectInMetaDescription() {
        if ($this->checkPageSubjectDefined()) {

            if (preg_match('/' . preg_quote($this->owner->SEOPageSubject, '/') . '/i', $this->owner->MetaDescription)) {
                return true;
            }
            else {
                return false;
            }
        }
        return false;

    }
12017
private function checkPageHasImages() {

        $html = $this->getPageContent();

        // for newly created page
        if ($html == '') {
            return false;
        }

        $dom = $this->createDOMDocumentFromHTML($html);

        $elements = $dom->getElementsByTagName('img');
        return ($elements->length) ? true : false;

    }
544066
public function getMetaImageLinkAttributes()
    {
        $attributes = [
            'href' => $this->owner->MetaImageLink,
            'class' => $this->owner->MetaImageLinkClass,
            'title' => $this->owner->MetaTitle
        ];
        
        if ($extra = Config::inst()->get(self::class, 'image_link_attributes')) {
            
            foreach ($extra as $name => $value) {
                
                // Process Attribute Value:
                
                $attributes[$name] = ViewTools::singleton()->processAttribute(
                    $value,
                    $this->owner,
                    $this->owner->Renderer
                );
                
            }
            
        }
        
        return $attributes;
    }
1063976
function isImageOwner()
    {
        $originalData = $this->originalAttributeData();
        return ( $originalData['attribute_id'] == false ||
                 ( $originalData['attribute_id'] == $this->ContentObjectAttributeData['id'] &&
                   $originalData['attribute_version'] == $this->ContentObjectAttributeData['version'] &&
                   $originalData['attribute_language'] == $this->ContentObjectAttributeData['language_code'] ) );
    }