<h2>File Contents: /home/planet5/public_html/wp-content/plugins/wordpress-seo/inc/class-wpseo-image-utils.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-content/plugins/wordpress-seo/inc/class-wpseo-image-utils.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
/**
 * WPSEO plugin file.
 *
 * @package WPSEO
 */

/**
 * WPSEO_Image_Utils.
 */
class WPSEO_Image_Utils {

	/**
	 * Find an attachment ID for a given URL.
	 *
	 * @param string $url The URL to find the attachment for.
	 *
	 * @return int The found attachment ID, or 0 if none was found.
	 */
	public static function get_attachment_by_url( $url ) {
		/*
		 * As get_attachment_by_url won&#039;t work on resized versions of images,
		 * we strip out the size part of an image URL.
		 */
		$url = preg_replace( &#039;/(.*)-\d+x\d+\.(jpg|png|gif)$/&#039;, &#039;$1.$2&#039;, $url );

		static $uploads;

		$uploads ??= wp_get_upload_dir();

		// Don&#039;t try to do this for external URLs.
		if ( strpos( $url, $uploads[&#039;baseurl&#039;] ) !== 0 ) {
			return 0;
		}

		if ( function_exists( &#039;wpcom_vip_attachment_url_to_postid&#039; ) ) {
			// @codeCoverageIgnoreStart -- We can&#039;t test this properly.
			return (int) wpcom_vip_attachment_url_to_postid( $url );
			// @codeCoverageIgnoreEnd -- The rest we _can_ test.
		}

		return self::attachment_url_to_postid( $url );
	}

	/**
	 * Implements the attachment_url_to_postid with use of WP Cache.
	 *
	 * @param string $url The attachment URL for which we want to know the Post ID.
	 *
	 * @return int The Post ID belonging to the attachment, 0 if not found.
	 */
	protected static function attachment_url_to_postid( $url ) {
		$cache_key = sprintf( &#039;yoast_attachment_url_post_id_%s&#039;, md5( $url ) );

		// Set the ID based on the hashed URL in the cache.
		$id = wp_cache_get( $cache_key );

		if ( $id === &#039;not_found&#039; ) {
			return 0;
		}

		// ID is found in cache, return.
		if ( $id !== false ) {
			return $id;
		}

		// Note: We use the WP COM version if we can, see above.
		$id = attachment_url_to_postid( $url );

		if ( empty( $id ) ) {
			/**
			 * If no ID was found, maybe we&#039;re dealing with a scaled big image. So, let&#039;s try that.
			 *
			 * @see https://core.trac.wordpress.org/ticket/51058
			 */
			$id = self::get_scaled_image_id( $url );
		}

		if ( empty( $id ) ) {
			wp_cache_set( $cache_key, &#039;not_found&#039;, &#039;&#039;, ( 12 * HOUR_IN_SECONDS + wp_rand( 0, ( 4 * HOUR_IN_SECONDS ) ) ) );
			return 0;
		}

		// We have the Post ID, but it&#039;s not in the cache yet. We do that here and return.
		wp_cache_set( $cache_key, $id, &#039;&#039;, ( 24 * HOUR_IN_SECONDS + wp_rand( 0, ( 12 * HOUR_IN_SECONDS ) ) ) );
		return $id;
	}

	/**
	 * Tries getting the ID of a potentially scaled image.
	 *
	 * @param string $url The URL of the image.
	 *
	 * @return int|false The ID of the image or false for failure.
	 */
	protected static function get_scaled_image_id( $url ) {
		$path_parts = pathinfo( $url );
		if ( isset( $path_parts[&#039;dirname&#039;], $path_parts[&#039;filename&#039;], $path_parts[&#039;extension&#039;] ) ) {
			$scaled_url = trailingslashit( $path_parts[&#039;dirname&#039;] ) . $path_parts[&#039;filename&#039;] . &#039;-scaled.&#039; . $path_parts[&#039;extension&#039;];

			return attachment_url_to_postid( $scaled_url );
		}

		return false;
	}

	/**
	 * Retrieves the image data.
	 *
	 * @param array $image         Image array with URL and metadata.
	 * @param int   $attachment_id Attachment ID.
	 *
	 * @return array|false {
	 *     Array of image data
	 *
	 *     @type string $alt      Image&#039;s alt text.
	 *     @type string $path     Path of image.
	 *     @type int    $width    Width of image.
	 *     @type int    $height   Height of image.
	 *     @type string $type     Image&#039;s MIME type.
	 *     @type string $size     Image&#039;s size.
	 *     @type string $url      Image&#039;s URL.
	 *     @type int    $filesize The file size in bytes, if already set.
	 * }
	 */
	public static function get_data( $image, $attachment_id ) {
		if ( ! is_array( $image ) ) {
			return false;
		}

		// Deals with non-set keys and values being null or false.
		if ( empty( $image[&#039;width&#039;] ) || empty( $image[&#039;height&#039;] ) ) {
			return false;
		}

		$image[&#039;id&#039;]     = $attachment_id;
		$image[&#039;alt&#039;]    = self::get_alt_tag( $attachment_id );
		$image[&#039;pixels&#039;] = ( (int) $image[&#039;width&#039;] * (int) $image[&#039;height&#039;] );

		if ( ! isset( $image[&#039;type&#039;] ) ) {
			$image[&#039;type&#039;] = get_post_mime_type( $attachment_id );
		}

		/**
		 * Filter: &#039;wpseo_image_data&#039; - Filter image data.
		 *
		 * Elements with keys not listed in the section will be discarded.
		 *
		 * @param array $image_data {
		 *     Array of image data
		 *
		 *     @type int    id       Image&#039;s ID as an attachment.
		 *     @type string alt      Image&#039;s alt text.
		 *     @type string path     Image&#039;s path.
		 *     @type int    width    Width of image.
		 *     @type int    height   Height of image.
		 *     @type int    pixels   Number of pixels in the image.
		 *     @type string type     Image&#039;s MIME type.
		 *     @type string size     Image&#039;s size.
		 *     @type string url      Image&#039;s URL.
		 *     @type int    filesize The file size in bytes, if already set.
		 * }
		 * @param int   $attachment_id Attachment ID.
		 */
		$image = apply_filters( &#039;wpseo_image_data&#039;, $image, $attachment_id );

		// Keep only the keys we need, and nothing else.
		return array_intersect_key( $image, array_flip( [ &#039;id&#039;, &#039;alt&#039;, &#039;path&#039;, &#039;width&#039;, &#039;height&#039;, &#039;pixels&#039;, &#039;type&#039;, &#039;size&#039;, &#039;url&#039;, &#039;filesize&#039; ] ) );
	}

	/**
	 * Checks a size version of an image to see if it&#039;s not too heavy.
	 *
	 * @param array $image Image to check the file size of.
	 *
	 * @return bool True when the image is within limits, false if not.
	 */
	public static function has_usable_file_size( $image ) {
		if ( ! is_array( $image ) || $image === [] ) {
			return false;
		}

		/**
		 * Filter: &#039;wpseo_image_image_weight_limit&#039; - Determines what the maximum weight
		 * (in bytes) of an image is allowed to be, default is 2 MB.
		 *
		 * @param int $max_bytes The maximum weight (in bytes) of an image.
		 */
		$max_size = apply_filters( &#039;wpseo_image_image_weight_limit&#039;, 2_097_152 );

		// We cannot check without a path, so assume it&#039;s fine.
		if ( ! isset( $image[&#039;path&#039;] ) ) {
			return true;
		}

		return ( self::get_file_size( $image ) &lt;= $max_size );
	}

	/**
	 * Find the right version of an image based on size.
	 *
	 * @param int          $attachment_id Attachment ID.
	 * @param string|array $size          Size name, or array of width and height in pixels (e.g [800,400]).
	 *
	 * @return array|false Returns an array with image data on success, false on failure.
	 */
	public static function get_image( $attachment_id, $size ) {
		$image = false;
		if ( $size === &#039;full&#039; ) {
			$image = self::get_full_size_image_data( $attachment_id );
		}

		if ( ! $image ) {
			$image = image_get_intermediate_size( $attachment_id, $size );
		}

		if ( ! is_array( $image ) ) {
			$image_src = wp_get_attachment_image_src( $attachment_id, $size );
			if ( is_array( $image_src ) &amp;&amp; isset( $image_src[1] ) &amp;&amp; isset( $image_src[2] ) ) {
				$image           = [];
				$image[&#039;url&#039;]    = $image_src[0];
				$image[&#039;width&#039;]  = $image_src[1];
				$image[&#039;height&#039;] = $image_src[2];
				$image[&#039;size&#039;]   = &#039;full&#039;;
			}
		}

		if ( ! $image ) {
			return false;
		}

		if ( ! isset( $image[&#039;size&#039;] ) ) {
			$image[&#039;size&#039;] = $size;
		}

		return self::get_data( $image, $attachment_id );
	}

	/**
	 * Returns the image data for the full size image.
	 *
	 * @param int $attachment_id Attachment ID.
	 *
	 * @return array|false Array when there is a full size image. False if not.
	 */
	protected static function get_full_size_image_data( $attachment_id ) {
		$image = wp_get_attachment_metadata( $attachment_id );
		if ( ! is_array( $image ) ) {
			return false;
		}

		$image[&#039;url&#039;]  = wp_get_attachment_image_url( $attachment_id, &#039;full&#039; );
		$image[&#039;path&#039;] = get_attached_file( $attachment_id );
		$image[&#039;size&#039;] = &#039;full&#039;;

		return $image;
	}

	/**
	 * Finds the full file path for a given image file.
	 *
	 * @param string $path The relative file path.
	 *
	 * @return string The full file path.
	 */
	public static function get_absolute_path( $path ) {
		static $uploads;

		$uploads ??= wp_get_upload_dir();

		// Add the uploads basedir if the path does not start with it.
		if ( empty( $uploads[&#039;error&#039;] ) &amp;&amp; strpos( $path, $uploads[&#039;basedir&#039;] ) !== 0 ) {
			return $uploads[&#039;basedir&#039;] . DIRECTORY_SEPARATOR . ltrim( $path, DIRECTORY_SEPARATOR );
		}

		return $path;
	}

	/**
	 * Get the relative path of the image.
	 *
	 * @param string $img Image URL.
	 *
	 * @return string The expanded image URL.
	 */
	public static function get_relative_path( $img ) {
		if ( $img[0] !== &#039;/&#039; ) {
			return $img;
		}

		// If it&#039;s a relative URL, it&#039;s relative to the domain, not necessarily to the WordPress install, we
		// want to preserve domain name and URL scheme (http / https) though.
		$parsed_url = wp_parse_url( home_url() );
		$img        = $parsed_url[&#039;scheme&#039;] . &#039;://&#039; . $parsed_url[&#039;host&#039;] . $img;

		return $img;
	}

	/**
	 * Get the image file size.
	 *
	 * @param array $image An image array object.
	 *
	 * @return int The file size in bytes.
	 */
	public static function get_file_size( $image ) {
		if ( isset( $image[&#039;filesize&#039;] ) ) {
			return $image[&#039;filesize&#039;];
		}

		if ( ! isset( $image[&#039;path&#039;] ) ) {
			return 0;
		}

		// If the file size for the file is over our limit, we&#039;re going to go for a smaller version.
		if ( function_exists( &#039;wp_filesize&#039; ) ) {
			return wp_filesize( self::get_absolute_path( $image[&#039;path&#039;] ) );
		}

		return file_exists( $image[&#039;path&#039;] ) ? (int) filesize( $image[&#039;path&#039;] ) : 0;
	}

	/**
	 * Returns the different image variations for consideration.
	 *
	 * @param int $attachment_id The attachment to return the variations for.
	 *
	 * @return array The different variations possible for this attachment ID.
	 */
	public static function get_variations( $attachment_id ) {
		$variations = [];

		foreach ( self::get_sizes() as $size ) {
			$variation = self::get_image( $attachment_id, $size );

			// The get_image function returns false if the size doesn&#039;t exist for this attachment.
			if ( $variation ) {
				$variations[] = $variation;
			}
		}

		return $variations;
	}

	/**
	 * Check original size of image. If original image is too small, return false, else return true.
	 *
	 * Filters a list of variations by a certain set of usable dimensions.
	 *
	 * @param array $usable_dimensions {
	 *    The parameters to check against.
	 *
	 *    @type int    $min_width     Minimum width of image.
	 *    @type int    $max_width     Maximum width of image.
	 *    @type int    $min_height    Minimum height of image.
	 *    @type int    $max_height    Maximum height of image.
	 * }
	 * @param array $variations        The variations that should be considered.
	 *
	 * @return array Whether a variation is fit for display or not.
	 */
	public static function filter_usable_dimensions( $usable_dimensions, $variations ) {
		$filtered = [];

		foreach ( $variations as $variation ) {
			$dimensions = $variation;

			if ( self::has_usable_dimensions( $dimensions, $usable_dimensions ) ) {
				$filtered[] = $variation;
			}
		}

		return $filtered;
	}

	/**
	 * Filters a list of variations by (disk) file size.
	 *
	 * @param array $variations The variations to consider.
	 *
	 * @return array The validations that pass the required file size limits.
	 */
	public static function filter_usable_file_size( $variations ) {
		foreach ( $variations as $variation ) {
			// We return early to prevent measuring the file size of all the variations.
			if ( self::has_usable_file_size( $variation ) ) {
				return [ $variation ];
			}
		}

		return [];
	}

	/**
	 * Retrieve the internal WP image file sizes.
	 *
	 * @return array An array of image sizes.
	 */
	public static function get_sizes() {
		/**
		 * Filter: &#039;wpseo_image_sizes&#039; - Determines which image sizes we&#039;ll loop through to get an appropriate image.
		 *
		 * @param array&lt;string&gt; $sizes The array of image sizes to loop through.
		 */
		return apply_filters( &#039;wpseo_image_sizes&#039;, [ &#039;full&#039;, &#039;large&#039;, &#039;medium_large&#039; ] );
	}

	/**
	 * Grabs an image alt text.
	 *
	 * @param int $attachment_id The attachment ID.
	 *
	 * @return string The image alt text.
	 */
	public static function get_alt_tag( $attachment_id ) {
		return (string) get_post_meta( $attachment_id, &#039;_wp_attachment_image_alt&#039;, true );
	}

	/**
	 * Checks whether an img sizes up to the parameters.
	 *
	 * @param array $dimensions        The image values.
	 * @param array $usable_dimensions The parameters to check against.
	 *
	 * @return bool True if the image has usable measurements, false if not.
	 */
	private static function has_usable_dimensions( $dimensions, $usable_dimensions ) {
		foreach ( [ &#039;width&#039;, &#039;height&#039; ] as $param ) {
			$minimum = $usable_dimensions[ &#039;min_&#039; . $param ];
			$maximum = $usable_dimensions[ &#039;max_&#039; . $param ];

			$current = $dimensions[ $param ];
			if ( ( $current &lt; $minimum ) || ( $current &gt; $maximum ) ) {
				return false;
			}
		}

		return true;
	}

	/**
	 * Gets the post&#039;s first usable content image. Null if none is available.
	 *
	 * @param int|null $post_id The post id.
	 *
	 * @return string|null The image URL.
	 */
	public static function get_first_usable_content_image_for_post( $post_id = null ) {
		$post = get_post( $post_id );

		// We know get_post() returns the post or null.
		if ( ! $post ) {
			return null;
		}

		$image_finder = new WPSEO_Content_Images();
		$images       = $image_finder-&gt;get_images( $post-&gt;ID, $post );

		return self::get_first_image( $images );
	}

	/**
	 * Gets the term&#039;s first usable content image. Null if none is available.
	 *
	 * @param int $term_id The term id.
	 *
	 * @return string|null The image URL.
	 */
	public static function get_first_content_image_for_term( $term_id ) {
		$term_description = term_description( $term_id );

		// We know term_description() returns a string which may be empty.
		if ( $term_description === &#039;&#039; ) {
			return null;
		}

		$image_finder = new WPSEO_Content_Images();
		$images       = $image_finder-&gt;get_images_from_content( $term_description );

		return self::get_first_image( $images );
	}

	/**
	 * Retrieves an attachment ID for an image uploaded in the settings.
	 *
	 * Due to self::get_attachment_by_url returning 0 instead of false.
	 * 0 is also a possibility when no ID is available.
	 *
	 * @param string $setting The setting the image is stored in.
	 *
	 * @return int|bool The attachment id, or false or 0 if no ID is available.
	 */
	public static function get_attachment_id_from_settings( $setting ) {
		$image_id = WPSEO_Options::get( $setting . &#039;_id&#039;, false );
		if ( $image_id ) {
			return $image_id;
		}

		$image = WPSEO_Options::get( $setting, false );
		if ( $image ) {
			// There is not an option to put a URL in an image field in the settings anymore, only to upload it through the media manager.
			// This means an attachment always exists, so doing this is only needed once.
			$image_id = self::get_attachment_by_url( $image );
		}

		// Only store a new ID if it is not 0, to prevent an update loop.
		if ( $image_id ) {
			WPSEO_Options::set( $setting . &#039;_id&#039;, $image_id );
		}

		return $image_id;
	}

	/**
	 * Retrieves the first possible image url from an array of images.
	 *
	 * @param array $images The array to extract image url from.
	 *
	 * @return string|null The extracted image url when found, null when not found.
	 */
	protected static function get_first_image( $images ) {
		if ( ! is_array( $images ) ) {
			return null;
		}

		$images = array_filter( $images );
		if ( empty( $images ) ) {
			return null;
		}

		return reset( $images );
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Fwordpress-seo%2Finc'>⬅ Back to Directory</a>