Изменение размера изображения в php только для просмотра - PullRequest
5 голосов
/ 06 марта 2012

Хорошо, я написал это потому, что не знал, что искать. Я постараюсь объяснить это как можно яснее.

Скажем, у меня есть изображение размером 800x600. Ящик, выделенный для изображения, имеет размер 150x150 и должен быть всегда удовлетворен. Я могу разрешить показ только изображения с максимальным размером 150 пикселей по высоте и ширине. Таким образом, технически, изображение должно быть уменьшено до 200x150.

Теперь вопрос :

Можно ли обрезать высоту, чтобы она показала только 150x150? Это только для просмотра. Мне не нужно сохранять изображение как новый файл.

Хорошим примером является страница вашего профиля в Twitter. Он показывает изображение вашего профиля обрезанным, но когда вы нажимаете на него, вы все равно получаете изображение, которое вы изначально загрузили.

[EDIT] Вот чего я пытаюсь достичь. Получите меньшую сторону с точки зрения пикселей, измените ее размер до 150px, затем скройте переполненную часть другой стороны. Опять же, нет сбережений. Просто для удовольствия людей.

What I'm trying to accomplish

Ответы [ 15 ]

28 голосов
/ 14 марта 2012

Я использую простой класс PHP, который имеет несколько вариантов изменения размера.Вы можете легко хранить эскизы с помощью этого класса.Как сказал @jeroen, вы должны сделать это только один раз, и они могут быть кэшированы.Это просто требует PHP5 и библиотеки GD.Вот пример использования:

// *** Include the class
include("resize-class.php");

// *** 1) Initialise / load image
$resizeObj = new resize('sample.jpg');

// *** 2) Resize image (options: exact, portrait, landscape, auto, crop)
$resizeObj -> resizeImage(150, 150, 'crop');

// *** 3) Save image ('image-name', 'quality [int]')
$resizeObj -> saveImage('sample-resized.jpg', 100);

И это тот класс:

<?php
        Class resize
        {
            // *** Class variables
            private $image;
            private $width;
            private $height;
            private $imageResized;

            function __construct($fileName)
            {
                // *** Open up the file
                $this->image = $this->openImage($fileName);

                // *** Get width and height
                $this->width  = imagesx($this->image);
                $this->height = imagesy($this->image);
            }

            ## --------------------------------------------------------

            private function openImage($file)
            {
                // *** Get extension
                $extension = strtolower(strrchr($file, '.'));

                switch($extension)
                {
                    case '.jpg':
                    case '.jpeg':
                        $img = @imagecreatefromjpeg($file);
                        break;
                    case '.gif':
                        $img = @imagecreatefromgif($file);
                        break;
                    case '.png':
                        $img = @imagecreatefrompng($file);
                        break;
                    default:
                        $img = false;
                        break;
                }
                return $img;
            }

            ## --------------------------------------------------------

            public function resizeImage($newWidth, $newHeight, $option="auto")
            {
                // *** Get optimal width and height - based on $option
                $optionArray = $this->getDimensions($newWidth, $newHeight, $option);

                $optimalWidth  = $optionArray['optimalWidth'];
                $optimalHeight = $optionArray['optimalHeight'];


                // *** Resample - create image canvas of x, y size
                $this->imageResized = imagecreatetruecolor($optimalWidth, $optimalHeight);
                imagecopyresampled($this->imageResized, $this->image, 0, 0, 0, 0, $optimalWidth, $optimalHeight, $this->width, $this->height);


                // *** if option is 'crop', then crop too
                if ($option == 'crop') {
                    $this->crop($optimalWidth, $optimalHeight, $newWidth, $newHeight);
                }
            }

            ## --------------------------------------------------------

            private function getDimensions($newWidth, $newHeight, $option)
            {

               switch ($option)
                {
                    case 'exact':
                        $optimalWidth = $newWidth;
                        $optimalHeight= $newHeight;
                        break;
                    case 'portrait':
                        $optimalWidth = $this->getSizeByFixedHeight($newHeight);
                        $optimalHeight= $newHeight;
                        break;
                    case 'landscape':
                        $optimalWidth = $newWidth;
                        $optimalHeight= $this->getSizeByFixedWidth($newWidth);
                        break;
                    case 'auto':
                        $optionArray = $this->getSizeByAuto($newWidth, $newHeight);
                        $optimalWidth = $optionArray['optimalWidth'];
                        $optimalHeight = $optionArray['optimalHeight'];
                        break;
                    case 'crop':
                        $optionArray = $this->getOptimalCrop($newWidth, $newHeight);
                        $optimalWidth = $optionArray['optimalWidth'];
                        $optimalHeight = $optionArray['optimalHeight'];
                        break;
                }
                return array('optimalWidth' => $optimalWidth, 'optimalHeight' => $optimalHeight);
            }

            ## --------------------------------------------------------

            private function getSizeByFixedHeight($newHeight)
            {
                $ratio = $this->width / $this->height;
                $newWidth = $newHeight * $ratio;
                return $newWidth;
            }

            private function getSizeByFixedWidth($newWidth)
            {
                $ratio = $this->height / $this->width;
                $newHeight = $newWidth * $ratio;
                return $newHeight;
            }

            private function getSizeByAuto($newWidth, $newHeight)
            {
                if ($this->height < $this->width)
                // *** Image to be resized is wider (landscape)
                {
                    $optimalWidth = $newWidth;
                    $optimalHeight= $this->getSizeByFixedWidth($newWidth);
                }
                elseif ($this->height > $this->width)
                // *** Image to be resized is taller (portrait)
                {
                    $optimalWidth = $this->getSizeByFixedHeight($newHeight);
                    $optimalHeight= $newHeight;
                }
                else
                // *** Image to be resizerd is a square
                {
                    if ($newHeight < $newWidth) {
                        $optimalWidth = $newWidth;
                        $optimalHeight= $this->getSizeByFixedWidth($newWidth);
                    } else if ($newHeight > $newWidth) {
                        $optimalWidth = $this->getSizeByFixedHeight($newHeight);
                        $optimalHeight= $newHeight;
                    } else {
                        // *** Sqaure being resized to a square
                        $optimalWidth = $newWidth;
                        $optimalHeight= $newHeight;
                    }
                }

                return array('optimalWidth' => $optimalWidth, 'optimalHeight' => $optimalHeight);
            }

            ## --------------------------------------------------------

            private function getOptimalCrop($newWidth, $newHeight)
            {

                $heightRatio = $this->height / $newHeight;
                $widthRatio  = $this->width /  $newWidth;

                if ($heightRatio < $widthRatio) {
                    $optimalRatio = $heightRatio;
                } else {
                    $optimalRatio = $widthRatio;
                }

                $optimalHeight = $this->height / $optimalRatio;
                $optimalWidth  = $this->width  / $optimalRatio;

                return array('optimalWidth' => $optimalWidth, 'optimalHeight' => $optimalHeight);
            }

            ## --------------------------------------------------------

            private function crop($optimalWidth, $optimalHeight, $newWidth, $newHeight)
            {
                // *** Find center - this will be used for the crop
                $cropStartX = ( $optimalWidth / 2) - ( $newWidth /2 );
                $cropStartY = ( $optimalHeight/ 2) - ( $newHeight/2 );

                $crop = $this->imageResized;
                //imagedestroy($this->imageResized);

                // *** Now crop from center to exact requested size
                $this->imageResized = imagecreatetruecolor($newWidth , $newHeight);
                imagecopyresampled($this->imageResized, $crop , 0, 0, $cropStartX, $cropStartY, $newWidth, $newHeight , $newWidth, $newHeight);
            }

            ## --------------------------------------------------------

            public function saveImage($savePath, $imageQuality="100")
            {
                // *** Get extension
                $extension = strrchr($savePath, '.');
                $extension = strtolower($extension);

                switch($extension)
                {
                    case '.jpg':
                    case '.jpeg':
                        if (imagetypes() & IMG_JPG) {
                            imagejpeg($this->imageResized, $savePath, $imageQuality);
                        }
                        break;

                    case '.gif':
                        if (imagetypes() & IMG_GIF) {
                            imagegif($this->imageResized, $savePath);
                        }
                        break;

                    case '.png':
                        // *** Scale quality from 0-100 to 0-9
                        $scaleQuality = round(($imageQuality/100) * 9);

                        // *** Invert quality setting as 0 is best, not 9
                        $invertScaleQuality = 9 - $scaleQuality;

                        if (imagetypes() & IMG_PNG) {
                             imagepng($this->imageResized, $savePath, $invertScaleQuality);
                        }
                        break;

                    // ... etc

                    default:
                        // *** No extension - No save.
                        break;
                }

                imagedestroy($this->imageResized);
            }


            ## --------------------------------------------------------

        }
?>
4 голосов
/ 14 ноября 2012

Это очень легко использовать здесь класс http://timthumb.googlecode.com/svn/trunk/timthumb.php здесь параметры http://viralpatel.net/blogs/resize-image-dynamically-php/ Я проверил выглядит отлично работает

пример измененное изображение

4 голосов
/ 16 марта 2012

Вы загружаете изображение, сначала изменяете его размер таким образом, чтобы его минимальная сторона составляла 150, а затем обрезаете до ширины / высоты 150 относительно центра.Затем вы просто выводите свое изображение:

WideImage::load('yourfile.png/jpg/...')
    ->resize(150, 150, 'outside', 'any')
    ->crop('center', 'center', 150, 150)
    ->output('png');

Вы найдете исходный код, документацию, онлайн-демонстрации и документацию API здесь: WideImage .

Дайте мне знать, если выУ меня все еще есть вопросы.

2 голосов
/ 14 марта 2012

Я бы сохранил миниатюры, чтобы вы могли сделать это только один раз, и они могут быть кэшированы.Если у вас фиксированное соотношение сторон, я бы уменьшил их до размера 200x200 (здесь есть некоторые ответы на php, поэтому я пропущу его).Если соотношение сторон изменяется, я бы использовал безопасное значение, чтобы оно всегда покрывало ваш блок 150x150 (например, 300x300).

Тогда я бы установил миниатюру в качестве фонового изображения для блока изображения в css, и выполучите именно тот эффект, который вам нужен:

.img_box {
  background-repeat: no-repeat;
  background-position: center center;
  background-image: url(/path/to/image);
}

Чтобы улучшить работу браузеров с поддержкой css3, вы можете установить:

background-size: cover;

для бокса, чтобы он точно подходил (поддерживая соотношение сторон).

2 голосов
/ 06 марта 2012

Почему бы просто не сделать это с помощью CSS и не использовать сервер для какой-либо обработки?Есть несколько способов сделать это с помощью CSS.Я использовал ранее метод Clip, и поиск в Google принесет вам несколько результатов. Здесь - это один сайт, который освещает эту скважину

1 голос
/ 14 марта 2012

Я не знаю этого полностью, но однажды я создал программу, которая просматривала бы нас миниатюрные изображения для наших изображений.И код выглядит так:

$src=imagecreatefromjpg("file.jpg");
$dest=imagecreatetruecolor($destwidth,$destheight);
$src1=imagecopyresized($dest,$src,0,0,0,0,$destwidth,$destheight,$widthresource,$heightresource);
echo imagejpeg($dest);

изменение параметров imagecopyresized, которые установлены на 0,0,0,0, здесь обрезает ваше изображение с x1, y1 до x2, y2. Надеюсь, это поможет

1 голос
/ 12 марта 2012

Вот мой класс изменения размера изображения.Класс может получить желаемый результат (обрезка / центрирование обрезки / и т.*

<?php
final class Img {
    /**
     * Usage:
     * Img::resizeImage( 'sample.png', null, array( 'x' => 150, 'y' => 150 ) )
     * Outputs a Image
     * 
     * Img::resizeImage( 'sample.png', 'crop.jpg', array( 'x' => 200, 'y' => 200 ) )
     * Saves a Image
     *
     * @static
     * @param string $source
     * @param null|string $destination
     * @param array $options
     * @return void
     * @throws Exception
     */
    public static function resizeImage( $source, $destination = null, $options = array() ) {
        if( !file_exists( $source ) || ( is_string( $destination ) && !is_writable( dirname( $destination ) ) ) ) {
            throw new Exception( 'Quelldatei existiert nicht oder Zielverzeichnis ist nicht beschreibbar.' );
        }

        #@ini_set ('memory_limit', '64M' );

        $defaultOptions = array(
            'x' => 100,
            'y' => 100,
            'maxX' => 1000,
            'maxY' => 1000,
            'zoom_crop' => 1,
            'quality' => 90,
            'align' => 'c', // [c]enter, [b]ottom, [t]op, [l]eft, [r]ight
            'filters' => '',
            'sharpen' => 0,
            'canvas' => 'ffffff',
        );
        $options = array_merge( $defaultOptions, $options );

        $sData = getimagesize( $source );
        $origType = $sData[2];
        $mimeType = $sData['mime'];

        if( !preg_match( '/^image\/(?:gif|jpg|jpeg|png)$/i', $mimeType ) ) {
            throw new Exception( 'The image being resized is not a valid gif, jpg or png.' );
        }

        if( !function_exists( 'imagecreatetruecolor' ) ) {
            throw new Exception( 'GD Library Error: imagecreatetruecolor does not exist' );
        }

        if( function_exists( 'imagefilter' ) && defined( 'IMG_FILTER_NEGATE' ) ) {
            $imageFilters = array (
                    1 => array (IMG_FILTER_NEGATE, 0),
                    2 => array (IMG_FILTER_GRAYSCALE, 0),
                    3 => array (IMG_FILTER_BRIGHTNESS, 1),
                    4 => array (IMG_FILTER_CONTRAST, 1),
                    5 => array (IMG_FILTER_COLORIZE, 4),
                    6 => array (IMG_FILTER_EDGEDETECT, 0),
                    7 => array (IMG_FILTER_EMBOSS, 0),
                    8 => array (IMG_FILTER_GAUSSIAN_BLUR, 0),
                    9 => array (IMG_FILTER_SELECTIVE_BLUR, 0),
                    10 => array (IMG_FILTER_MEAN_REMOVAL, 0),
                    11 => array (IMG_FILTER_SMOOTH, 0),
            );
        }

        $destX = min( $options['x'], $options['maxX'] );
        $destY = min( $options['y'], $options['maxY'] );

        switch( $mimeType ) {
            case 'image/jpg':
            case 'image/jpeg':
            case 'image/pjgpg':
                $image = imagecreatefromjpeg( $source );
                break;
            case 'image/png':
                $image = imagecreatefrompng( $source );
                break;
            case 'image/gif':
                $image = imagecreatefromgif( $source );
                break;
        }

        if( !isset( $image ) ) {
            throw new Exception( 'Could not open Image' );
        }

        $width = imagesx( $image );
        $height = imagesy( $image );
        $originX = $originY = 0;

        if( $destX > 0 && $destY == 0 ) {
            $destY = floor( $height * ( $destX / $width ) );
        } else if( $destY > 0 && $destX == 0 ) {
            $destX = floor( $width * ( $destY / $height ) );
        }

        // scale down and add borders
        if( $options['zoom_crop'] == 3 ) {
            $finalY = $height * ( $destX / $width );

            if( $finalY > $destY ) {
                $destX = $width * ( $destY / $height );
            } else {
                $destY = $finalY;
            }
        }

        $canvas = imagecreatetruecolor( $destX, $destY );
        imagealphablending( $canvas, false );

        if( strlen( $options['canvas'] ) < 6 ) {
            $options['canvas'] = 'ffffff';
        }

        $canvasColorR = hexdec( substr( $options['canvas'], 0, 2 ) );
        $canvasColorG = hexdec( substr( $options['canvas'], 2, 2 ) );
        $canvasColorB = hexdec( substr( $options['canvas'], 2, 2 ) );

        // transparentes bild erstellen
        $color = imagecolorallocatealpha( $canvas, $canvasColorR, $canvasColorG, $canvasColorB, 127 );
        imagefill( $canvas, 0, 0, $color );

        // scale down and add borders
        if( $options['zoom_crop'] == 2 ) {
            $finalY = $height * ( $destX / $width );

            if( $finalY > $destY ) {
                $originX = $destX / 2;
                $destX = $width * ( $destY / $height );
                $originX = round( $originX - ( $destX / 2 ) );
            } else {
                $originY = $destY / 2;
                $destY = $finalY;
                $originY = round( $originY - ( $destY / 2 ) );
            }
        }

        // restore transparency blending
        imagesavealpha( $canvas, true );

        if( $options['zoom_crop'] > 0 ) {

            $srcX = $srcY = 0;
            $srcW = $width;
            $srcH = $height;

            $cmpX = $width / $destX;
            $cmpY = $height / $destY;

            // calculate x or y coordinate and width or height of source
            if( $cmpX > $cmpY ) {
                // breitformat
                $srcW = round( $width / $cmpX * $cmpY );
                $srcX = round( ( $width - ( $width / $cmpX * $cmpY ) ) / 2 );
            } elseif( $cmpY > $cmpX ) {
                $srcH = round( $height / $cmpY * $cmpX );
                $srcY = round( ( $height - ( $height / $cmpY * $cmpX ) ) / 2 );
            }

            // pos cropping
            if( strlen( $options['align'] ) ) {
                if( strpos( $options['align'], 't') !== false) {
                    $srcY = 0;
                }
                if( strpos( $options['align'], 'b') !== false) {
                    $srcY = $height - $srcH;
                }
                if( strpos( $options['align'], 'l') !== false) {
                    $srcX = 0;
                }
                if( strpos( $options['align'], 'r') !== false) {
                    $srcX = $width - $srcW;
                }
            }

            imagecopyresampled( $canvas, $image, $originX, $originY, $srcX, $srcY, $destX, $destY, $srcW, $srcH );

        } else {
            imagecopyresampled( $canvas, $image, 0, 0, 0, 0, $destX, $destY, $width, $height );
        }

        // @todo filtermöglichkeit über optionen ausbessern
        if( strlen( $options['filters'] ) && function_exists( 'imagefilter' ) && defined( 'IMG_FILTER_NEGATE' ) ) {
            // apply filters to image
            $filterList = explode( '|', $options['filters'] );
            foreach( $filterList as $fl ) {
                $filterSettings = explode (',', $fl);
                if (isset ($imageFilters[$filterSettings[0]])) {

                    for ($i = 0; $i < 4; $i ++) {
                        if (!isset ($filterSettings[$i])) {
                            $filterSettings[$i] = null;
                        } else {
                            $filterSettings[$i] = (int) $filterSettings[$i];
                        }
                    }
                    switch ($imageFilters[$filterSettings[0]][1]) {
                        case 1:
                            imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1]);
                            break;
                        case 2:
                            imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1], $filterSettings[2]);
                            break;
                        case 3:
                            imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1], $filterSettings[2], $filterSettings[3]);
                            break;
                        case 4:
                            imagefilter ($canvas, $imageFilters[$filterSettings[0]][0], $filterSettings[1], $filterSettings[2], $filterSettings[3], $filterSettings[4]);
                            break;
                        default:
                            imagefilter ($canvas, $imageFilters[$filterSettings[0]][0]);
                            break;
                    }
                }
            }
        }

        if( $options['sharpen'] > 0 && function_exists( 'imageconvolution' ) ) {
            $sharpenMatrix = array (
                            array (-1,-1,-1),
                            array (-1,16,-1),
                            array (-1,-1,-1),
                            );

            $divisor = 8;
            $offset = 0;

            imageconvolution( $canvas, $sharpenMatrix, $divisor, $offset );
        }

        //Straight from Wordpress core code. Reduces filesize by up to 70% for PNG's
        if( ( IMAGETYPE_PNG == $origType || IMAGETYPE_GIF == $origType ) &&
            function_exists( 'imageistruecolor' ) && !imageistruecolor( $image ) &&
            imagecolortransparent( $image ) > 0 ) {
            imagetruecolortopalette( $canvas, false, imagecolorstotal( $image ) );
        }

        if( null === $destination ) {
            header( "Cache-Control: no-store, no-cache, must-revalidate" );
            header( "Cache-Control: post-check=0, pre-check=0", false);
            header( "Pragma: no-cache" );
            header( "Expires: Sat, 26 Jul 1997 05:00:00 GMT" );
            header( "Last-Modified: " . date( "D, d M Y H:i:s" ) . " GMT" );

        }

        switch( $mimeType ) {
            case 'image/jpg':
            case 'image/jpeg':
            case 'image/pjgpg':
                if( null === $destination ) {
                    header("Content-type: image/jpeg");
                }
                @imagejpeg( $canvas, $destination, $options['quality'] );
                break;
            case 'image/png':
                if( null === $destination ) {
                    header("Content-type: image/png");
                }
                @imagepng( $canvas, $destination, floor( $options['quality'] * 0.09 ) );
                break;
            case 'image/gif':
                if( null === $destination ) {
                    header("Content-type: image/gif");
                }
                @imagegif( $canvas, $destination );
                break;
            default:
                throw new Exception( 'Fehler beim schreiben' );
                break;
        }

        imagedestroy( $canvas );
        imagedestroy( $image );
    }
}
1 голос
/ 12 марта 2012
<?php
    $output_width =80;
    $output_height=80;

    if(isset($_GET['height'])){
       $output_height=$_GET['height'];
    }
     if(isset($_GET['width'])){
       $output_width=$_GET['width'];
    }

   $path = ( (isset($_REQUEST['path']))? $_REQUEST['path'] : "");
   //echo  $path;exit;
    $size_arr = getimagesize($path);
    if ($size_arr[2]==IMAGETYPE_GIF)
        $image = imagecreatefromgif($path);
    else if ($size_arr[2]==IMAGETYPE_JPEG)
        $image = imagecreatefromjpeg($path);
    else if ($size_arr[2]==IMAGETYPE_PNG)
        $image = imagecreatefrompng($path);
    else
        die_default_image();

    $tmpname = tempnam( sys_get_temp_dir() , "phptmp");

    resize_image($tmpname, $image, $size_arr, $output_width, $output_height);

    header('Content-Type: image/jpg');
    header('Content-Disposition: inline; filename="'.basename($path).'"');
    echo file_get_contents( $tmpname );
    unlink( $tmpname );
    die('');


function die_default_image()
{
    //43byte 1x1 transparent pixel gif
    header("content-type: image/gif");
    echo base64_decode("R0lGODlhAQABAIAAAAAAAAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==");
}

function resize_image($thumbname, $image, $size_arr, $max_width, $max_height)//maintain aspect ratio
{
    $width  = $max_width;
    $height = $max_height;
    list($width_orig, $height_orig, $img_type) = $size_arr;
    $ratio_orig = $width_orig/$height_orig;

    if ($width/$height > $ratio_orig) {
       $width = floor($height*$ratio_orig);
    } else {
       $height = floor($width/$ratio_orig);
    }

    // Resample
    $tempimg = imagecreatetruecolor($width, $height);
    imagecopyresampled($tempimg, $image, 0, 0, 0, 0, $width, $height, $width_orig, $height_orig);
    imagejpeg($tempimg, $thumbname, 80);
}

if (!function_exists('sys_get_temp_dir')) {
  function sys_get_temp_dir() {
    if (!empty($_ENV['TMP'])) { return realpath($_ENV['TMP']); }
    if (!empty($_ENV['TMPDIR'])) { return realpath( $_ENV['TMPDIR']); }
    if (!empty($_ENV['TEMP'])) { return realpath( $_ENV['TEMP']); }
    $tempfile=tempnam(uniqid(rand(),TRUE),'');
    if (file_exists($tempfile)) {
    unlink($tempfile);
    return realpath(dirname($tempfile));
    }
  }
}
?>

Сохраните файл как imageresize.php и поместите этот файл в папку с изображениями и просто используйте код, подобный этому, чтобы показать изображение

<img src="<?=base_url().'uploads/imageresize.php?path='.$image."&width=150 &height=150";?>" />

Вы можете использовать этот код для показа изображений в разных размерах.

0 голосов
/ 17 марта 2012

Я думаю, что простое решение без стресса и обработки было бы с помощью css:

1) Примените класс, который даст вам обрезанное изображение.Сделайте это с помощью отрицательной маржи.Я не использовал точный запас, используйте его так, как вам требуется.2) При наведении курсора переписать атрибут маркировки, чтобы получить реальное изображение.

css:
 <style>
   .crop:hover{
       margin:0;

    }
    .crop {
        margin:-100px -15px -40px -55px;
     }
</style>

html:

<img class="crop" src="image.jpg" />
0 голосов
/ 16 марта 2012

Это именно то, что вы ищете, и еще один шаг, кеширование больших пальцев:

Проверка http://phpthumb.gxdlabs.com/

Вы можете использовать этот скрипт как script.php? Img= image.jpg & size = 100, в этом случае они находятся в одной папке скрипта.

 <?php

    require_once '/path/to/ThumbLib.inc.php';  
    $filename = $_GET['img'];
    $path = "/upload/item/";
    $thumb = $_GET['size'];

    // Just let specific values 
    $sizeThumb = array('20','40','50','80','100','120','150');

    if(in_array($thumb,$sizeThumb)){
      $maxWidth = $thumb;
      $maxHeight = $thumb;
    } else { header('Status: 404 Not Found');   die; }   
    $pathUrl = _ROOT_FOLDER.'/thumbs/autothumb-'.$thumb.'-'.$filename;

    if(!file_exists(_ROOT_FOLDER.$path.$filename)) { header('Status: 404 Not Found');   die; } 

    if(!file_exists($pathUrl) ){

     $max = PhpThumbFactory::create(_ROOT_FOLDER.$path.$filename);
     $max->adaptiveResize($maxWidth,$maxHeight)->save($pathUrl);
     }

    header('Content-type: image/jpeg');    
    readfile($pathUrl);  

?> 
...