WordPress.org

Plugin Directory

Changeset 1734833


Ignore:
Timestamp:
09/24/17 00:16:25 (5 months ago)
Author:
gagan0123
Message:

Tagging Version 2.1

Location:
fix-image-rotation
Files:
7 added
3 edited

Legend:

Unmodified
Added
Removed
  • fix-image-rotation/trunk/includes/class-fix-image-rotation.php

    r1718626 r1734833  
    11<?php 
    2  
    3 if ( !defined( 'ABSPATH' ) ) { 
    4     exit; // Exit if accessed directly 
     2/** 
     3 * Contains class to handle interactions with WordPress. 
     4 * 
     5 * @package Fix_Image_Rotation 
     6 */ 
     7 
     8if ( ! defined( 'ABSPATH' ) ) { 
     9    exit; // Exit if accessed directly. 
    510} 
    611 
    7 if ( !class_exists( 'Fix_Image_Rotation' ) ) { 
     12if ( ! class_exists( 'Fix_Image_Rotation' ) ) { 
    813 
    914    /** 
    1015     * Handles most of the interaction of the plugin with WordPress 
    11      *  
     16     * 
    1217     * @since 1.0 
    1318     */ 
     
    1621        /** 
    1722         * Array storing the file names that were processed, as keys. 
    18          *  
    19          * @since 1.0 
    20          *  
     23         * 
     24         * @since 1.0 
     25         * 
    2126         * @access private 
    22          *  
     27         * 
    2328         * @var array 
    2429         */ 
     
    2631 
    2732        /** 
    28          * Array storing the meta data of original files in case it  
     33         * Array storing the meta data of original files in case it 
    2934         * needs to be restored later. 
    30          *  
    31          * @since 1.0 
    32          *  
     35         * 
     36         * @since 1.0 
     37         * 
    3338         * @access private 
    34          *  
     39         * 
    3540         * @var array 
    3641         */ 
     
    3944        /** 
    4045         * The instance of the class Fix_Image_Rotation 
    41          *  
     46         * 
    4247         * @since 2.0 
    43          *  
     48         * 
    4449         * @access protected 
    45          *  
     50         * 
    4651         * @var Fix_Image_Rotation 
    4752         */ 
     
    4954 
    5055        /** 
    51          * Lets get started with the construct, registers hooks  
     56         * Lets get started with the construct, registers hooks 
    5257         * needed for the plugin. 
    53          *  
     58         * 
    5459         * @since 1.0 
    5560         */ 
    5661        public function __construct() { 
    5762            $this->orientation_fixed = array(); 
    58             $this->previous_meta    = array(); 
     63            $this->previous_meta    = array(); 
    5964            $this->register_hooks(); 
    6065        } 
     
    6368         * Returns the current instance of the class, in case some other 
    6469         * plugin needs to use its public methods. 
    65          *  
     70         * 
    6671         * @since 2.0 
    67          *  
    68          * @access public 
    69          *  
     72         * 
     73         * @access public 
     74         * 
    7075         * @return Fix_Image_Rotation Returns the current instance of the class 
    7176         */ 
     
    7378 
    7479            // If the single instance hasn't been set, set it now. 
    75             if ( null == self::$instance ) { 
    76                 self::$instance = new self; 
     80            if ( null === self::$instance ) { 
     81                self::$instance = new self(); 
    7782            } 
    7883 
     
    8287        /** 
    8388         * Registers the filters required for this plugin 
    84          *  
     89         * 
    8590         * @since 2.0 
    86          *  
    87          * @access public 
    88          *  
     91         * 
     92         * @access public 
     93         * 
    8994         * @return void 
    9095         */ 
     
    95100 
    96101        /** 
    97          * Checks the filename before it is uploaded to WordPress and  
     102         * Checks the filename before it is uploaded to WordPress and 
    98103         * runs the fix_image_orientation function in case its needed. 
    99          *  
    100          * @since 1.0 
    101          *  
    102          * @access public 
    103          *  
    104          * @param array  $file { 
    105          *     Array of upload data. 
     104         * 
     105         * @since 1.0 
     106         * 
     107         * @access public 
     108         * 
     109         * @hook wp_handle_upload 
     110         * 
     111         * @param array $file { 
     112         *    Array of upload data. 
    106113         * 
    107114         *     @type string $file Filename of the newly-uploaded file. 
     
    109116         *     @type string $type File type. 
    110117         * } 
    111          *  
    112          * @return array { 
    113          *     Array of upload data. 
    114          * 
    115          *     @type string $file Filename of the newly-uploaded file. 
    116          *     @type string $url  URL of the uploaded file. 
    117          *     @type string $type File type. 
     118         * 
     119         * @return array Array of upload data. 
     120         */ 
     121        public function filter_wp_handle_upload( $file ) { 
     122            $suffix = substr( $file['file'], strrpos( $file['file'], '.', -1 ) + 1 ); 
     123            if ( in_array( $suffix, array( 'jpg', 'jpeg', 'tiff' ), true ) ) { 
     124                $this->fix_image_orientation( $file['file'] ); 
     125            } 
     126            return $file; 
     127        } 
     128 
     129        /** 
     130         * Checks the filename before it is uploaded to WordPress and 
     131         * runs the fix_image_orientation function in case its needed. 
     132         * 
     133         * @since 1.0 
     134         * 
     135         * @access public 
     136         * 
     137         * @hook wp_handle_upload_prefilter 
     138         * 
     139         * @param array $file An array of data for a single file. 
     140         * 
     141         * @return array An array of data for a single file. 
     142         */ 
     143        public function filter_wp_handle_upload_prefilter( $file ) { 
     144            $suffix = substr( $file['name'], strrpos( $file['name'], '.', -1 ) + 1 ); 
     145            if ( in_array( $suffix, array( 'jpg', 'jpeg', 'tiff' ), true ) ) { 
     146                $this->fix_image_orientation( $file['tmp_name'] ); 
     147            } 
     148            return $file; 
     149        } 
     150 
     151        /** 
     152         * Fixes the orientation of the image based on exif data 
     153         * 
     154         * @since 1.0 
     155         * 
     156         * @access public 
     157         * 
     158         * @param string $file Path of the file. 
     159         * 
     160         * @return void 
     161         */ 
     162        public function fix_image_orientation( $file ) { 
     163            if ( is_callable( 'exif_read_data' ) && ! isset( $this->orientation_fixed[ $file ] ) ) { 
     164                $exif = exif_read_data( $file ); 
     165 
     166                if ( isset( $exif ) && isset( $exif['Orientation'] ) && $exif['Orientation'] > 1 ) { 
     167 
     168                    // Need it so that image editors are available to us. 
     169                    include_once( ABSPATH . 'wp-admin/includes/image-edit.php' ); 
     170 
     171                    // Calculate the operations we need to perform on the image. 
     172                    $operations = $this->calculate_flip_and_rotate( $file, $exif ); 
     173 
     174                    if ( false !== $operations ) { 
     175                        // Lets flip flop and rotate the image as needed. 
     176                        $this->do_flip_and_rotate( $file, $operations ); 
     177                    } 
     178                } 
     179            } 
     180        } 
     181 
     182        /** 
     183         * Calculate the flips and rotations image will need to do to fix its orientation. 
     184         * 
     185         * @since 2.1 
     186         * 
     187         * @access private 
     188         * 
     189         * @param string $file Path of the file. 
     190         * 
     191         * @param array  $exif Exif data of the image. 
     192         * 
     193         * @return array|bool Array of operations to be performed on the image, 
     194         *                    false if no operations are needed. 
     195         */ 
     196        private function calculate_flip_and_rotate( $file, $exif ) { 
     197 
     198            $rotator = false; 
     199            $flipper = false; 
     200 
     201            // Lets switch to the orientation defined in the exif data. 
     202            switch ( $exif['Orientation'] ) { 
     203                case 1: 
     204                    // We don't want to fix an already correct image :). 
     205                    $this->orientation_fixed[ $file ]    = true; 
     206                    return false; 
     207                case 2: 
     208                    $flipper                             = array( false, true ); 
     209                    break; 
     210                case 3: 
     211                    $orientation                         = -180; 
     212                    $rotator                             = true; 
     213                    break; 
     214                case 4: 
     215                    $flipper                             = array( true, false ); 
     216                    break; 
     217                case 5: 
     218                    $orientation                         = -90; 
     219                    $rotator                             = true; 
     220                    $flipper                             = array( false, true ); 
     221                    break; 
     222                case 6: 
     223                    $orientation                         = -90; 
     224                    $rotator                             = true; 
     225                    break; 
     226                case 7: 
     227                    $orientation                         = -270; 
     228                    $rotator                             = true; 
     229                    $flipper                             = array( false, true ); 
     230                    break; 
     231                case 8: 
     232                case 9: 
     233                    $orientation                         = -270; 
     234                    $rotator                             = true; 
     235                    break; 
     236                default: 
     237                    $orientation                         = 0; 
     238                    $rotator                             = true; 
     239                    break; 
     240            } 
     241 
     242            $operations = compact( 'orientation', 'rotator', 'flipper' ); 
     243            return $operations; 
     244        } 
     245 
     246        /** 
     247         * Flips and rotates the image based on the parameters provided. 
     248         * 
     249         * @since 2.1 
     250         * 
     251         * @access private 
     252         * 
     253         * @param string $file Path of the file. 
     254         * 
     255         * @param array  $operations { 
     256         *      Array of operations to be performed on the image. 
     257         * 
     258         *      @type bool       $rotator Whether to rotate the image or not. 
     259         *      @type int        $orientation Amount of rotation to be performed in degrees. 
     260         *      @type array|bool $flipper { 
     261         *          Whether to flip the image or not, false if no flipping needed. 
     262         * 
     263         *          @type bool $0 Flip along Horizontal Axis. 
     264         *          @type bool $1 Flip along Vertical Axis. 
     265         *      } 
    118266         * } 
    119          *  
    120          */ 
    121         public function filter_wp_handle_upload( $file ) { 
    122             $suffix = substr( $file[ 'file' ], strrpos( $file[ 'file' ], '.', -1 ) + 1 ); 
    123             if ( in_array( $suffix, array( 'jpg', 'jpeg', 'tiff' ) ) ) { 
    124                 $this->fix_image_orientation( $file[ 'file' ] ); 
    125             } 
    126             return $file; 
    127         } 
    128  
    129         /** 
    130          * Checks the filename before it is uploaded to WordPress and  
    131          * runs the fix_image_orientation function in case its needed. 
    132          *  
    133          * @since 1.0 
    134          *  
    135          * @access public 
    136          *  
    137          * @param array $file An array of data for a single file. 
    138          *  
    139          * @return array An array of data for a single file. 
    140          */ 
    141         public function filter_wp_handle_upload_prefilter( $file ) { 
    142             $suffix = substr( $file[ 'name' ], strrpos( $file[ 'name' ], '.', -1 ) + 1 ); 
    143             if ( in_array( $suffix, array( 'jpg', 'jpeg', 'tiff' ) ) ) { 
    144                 $this->fix_image_orientation( $file[ 'tmp_name' ] ); 
    145             } 
    146             return $file; 
    147         } 
    148  
    149         /** 
    150          * Fixes the orientation of the image based on exif data 
    151          *  
    152          * @since 1.0 
    153          *  
    154          * @access public 
    155          *  
    156          * @param string $file Path of the file 
    157          *  
    158          * @return void 
    159          */ 
    160         public function fix_image_orientation( $file ) { 
    161             if ( is_callable( 'exif_read_data' ) && !isset( $this->oreintation_fixed[ $file ] ) ) { 
    162                 $exif = exif_read_data( $file ); 
    163                 if ( isset( $exif ) && isset( $exif[ 'Orientation' ] ) && $exif[ 'Orientation' ] > 1 ) { 
    164                     include_once( ABSPATH . 'wp-admin/includes/image-edit.php' ); 
    165                     $rotator = false; 
    166                     $flipper = false; 
    167  
    168                     //Lets switch to the orientation defined in the exif data 
    169                     switch ( $exif[ 'Orientation' ] ) { 
    170                         case 1: 
    171                             //We don't want to fix an already correct image :) 
    172                             $this->orientation_fixed[ $file ]    = true; 
    173                             return; 
    174                         case 2: 
    175                             $flipper                             = array( false, true ); 
    176                             break; 
    177                         case 3: 
    178                             $orientation                         = -180; 
    179                             $rotator                             = true; 
    180                             break; 
    181                         case 4: 
    182                             $flipper                             = array( true, false ); 
    183                             break; 
    184                         case 5: 
    185                             $orientation                         = -90; 
    186                             $rotator                             = true; 
    187                             $flipper                             = array( false, true ); 
    188                             break; 
    189                         case 6: 
    190                             $orientation                         = -90; 
    191                             $rotator                             = true; 
    192                             break; 
    193                         case 7: 
    194                             $orientation                         = -270; 
    195                             $rotator                             = true; 
    196                             $flipper                             = array( false, true ); 
    197                             break; 
    198                         case 8: 
    199                         case 9: 
    200                             $orientation                         = -270; 
    201                             $rotator                             = true; 
    202                             break; 
    203                         default: 
    204                             $orientation                         = 0; 
    205                             $rotator                             = true; 
    206                             break; 
    207                     } 
    208  
    209                     $editor = wp_get_image_editor( $file ); 
    210  
    211                     //If GD Library is being used, then we need to store metadata to restore later 
    212                     if ( 'WP_Image_Editor_GD' == get_class( $editor ) ) { 
    213                         $this->previous_meta[ $file ] = wp_read_image_metadata( $file ); 
    214                         add_filter( 'wp_read_image_metadata', array( $this, 'restore_meta_data' ), 10, 2 ); 
    215                     } 
    216                     if ( !is_wp_error( $editor ) ) { 
    217                         //Lets rotate and flip the image based on exif orientation 
    218                         if ( $rotator === true ) { 
    219                             $editor->rotate( $orientation ); 
    220                         } 
    221                         if ( $flipper !== false ) { 
    222                             $editor->flip( $flipper[ 0 ], $flipper[ 1 ] ); 
    223                         } 
    224                         $editor->save( $file ); 
    225                         $this->orientation_fixed[ $file ] = true; 
    226                     } 
    227                 } // end if $exif 
    228             } // end is_callable('exif_read_data') 
     267         * 
     268         * @return bool Returns true if operations were successful, false otherwise. 
     269         */ 
     270        private function do_flip_and_rotate( $file, $operations ) { 
     271 
     272            $editor = wp_get_image_editor( $file ); 
     273 
     274            // If GD Library is being used, then we need to store metadata to restore later. 
     275            if ( 'WP_Image_Editor_GD' === get_class( $editor ) ) { 
     276                $this->previous_meta[ $file ] = wp_read_image_metadata( $file ); 
     277            } 
     278 
     279            if ( ! is_wp_error( $editor ) ) { 
     280                // Lets rotate and flip the image based on exif orientation. 
     281                if ( true === $operations['rotator'] ) { 
     282                    $editor->rotate( $operations['orientation'] ); 
     283                } 
     284                if ( false !== $operations['flipper'] ) { 
     285                    $editor->flip( $operations['flipper'][0], $operations['flipper'][1] ); 
     286                } 
     287                $editor->save( $file ); 
     288                $this->orientation_fixed[ $file ] = true; 
     289                add_filter( 'wp_read_image_metadata', array( $this, 'restore_meta_data' ), 10, 2 ); 
     290                return true; 
     291            } 
     292            return false; 
    229293        } 
    230294 
    231295        /** 
    232296         * Restores the meta data of the image after being processed. 
    233          *  
     297         * 
    234298         * WordPress' Imagick Library does not need this, but GD library 
    235          * removes metadata from the image upon rotation or flip so this  
     299         * removes metadata from the image upon rotation or flip so this 
    236300         * method restores those values. 
    237          *  
     301         * 
    238302         * @since 2.0 
    239          *  
     303         * 
    240304         * @hook wp_read_image_metadata 
    241          *  
     305         * 
    242306         * @param array  $meta Image meta data. 
    243307         * @param string $file Path to image file. 
    244          *  
     308         * 
    245309         * @return array Image meta data. 
    246310         */ 
    247311        public function restore_meta_data( $meta, $file ) { 
    248312            if ( isset( $this->previous_meta[ $file ] ) ) { 
    249                 return $this->previous_meta[ $file ]; 
    250             } else { 
     313                $meta = $this->previous_meta[ $file ]; 
     314 
     315                // Setting the Orientation meta to the new value after fixing the rotation. 
     316                $meta['orientation'] = 1; 
    251317                return $meta; 
    252318            } 
     319            return $meta; 
    253320        } 
    254321 
  • fix-image-rotation/trunk/init.php

    r1718626 r1734833  
    11<?php 
    2  
    3 /* 
    4   Plugin Name: Fix Image Rotation 
    5   Plugin URI: https://wordpress.org/plugins/fix-image-rotation/ 
    6   Description: Fix Image Rotation plugin fixes image orientation based on EXIF data.  This is primarily a patch for mis-oriented images delivered from iPhones.  Functionally it filters all uploads and if EXIF->Orientation is set to a number greater than 1, then the image is resaved with a new orientation before the image is processed by wordpress. 
    7   Author: Gagan Deep Singh 
    8   Version: 2.0 
    9   Author URI: http://gagan.pro 
    10   License: GPLv2 
    11   License URI: https://www.gnu.org/licenses/gpl-2.0.html 
    12   Text Domain: fix-image-rotation 
    13   Domain Path: /languages 
     2/** 
     3 * Plugin Name: Fix Image Rotation 
     4 * Plugin URI: https://wordpress.org/plugins/fix-image-rotation/ 
     5 * Description: Fix Image Rotation plugin fixes image orientation based on EXIF data.  This is primarily a patch for mis-oriented images delivered from iPhones.  Functionally it filters all uploads and if EXIF->Orientation is set to a number greater than 1, then the image is resaved with a new orientation before the image is processed by WordPress. 
     6 * Author: Gagan Deep Singh 
     7 * Version: 2.1 
     8 * Author URI: http://gagan.pro 
     9 * License: GPLv2 
     10 * License URI: https://www.gnu.org/licenses/gpl-2.0.html 
     11 * Text Domain: fix-image-rotation 
     12 * Domain Path: /languages 
     13 * 
     14 * @package Fix_Image_Rotation 
    1415 */ 
    1516 
    16 if ( !defined( 'ABSPATH' ) ) 
    17     exit; // Exit if accessed directly 
     17if ( ! defined( 'ABSPATH' ) ) { 
     18    exit; // Exit if accessed directly. 
     19} 
    1820 
    19 if ( !defined( 'GS_FIR_PATH' ) ) { 
     21if ( ! defined( 'GS_FIR_PATH' ) ) { 
    2022    define( 'GS_FIR_PATH', trailingslashit( plugin_dir_path( __FILE__ ) ) ); 
    2123} 
  • fix-image-rotation/trunk/readme.txt

    r1718626 r1734833  
    11=== Fix Image Rotation === 
    2 Contributors: gagan0123 
     2Contributors: gagan0123, shashwatmittal 
    33Tags: Image Rotation, iPhone 
    44Requires at least: 3.7 
    55Tested up to: 4.8.1 
    6 Stable tag: 2.0 
     6Stable tag: 2.1 
    77License: GPLv2 or later 
    88License URI: http://www.gnu.org/licenses/gpl-2.0.html 
     
    4646== Changelog == 
    4747 
     48= 2.1 = 
     49* Updates correct orientation of fixed images in WordPress metadata of the image. 
     50 
    4851= 2.0 = 
    4952* Fix for PNG files being sent for orientation correction while PNG files don't even have EXIF data. 
Note: See TracChangeset for help on using the changeset viewer.