PHP imagesy函数代码示例

 private function createnewpicture()
 {
     $local = $this->path_two . $this->file['name'];
     move_uploaded_file($this->file['tmp_name'], $local);
     $filename = $this->file['tmp_name'] . "/" . $this->file['name'];
     $this->location = $this->path . "/" . $this->file['name'];
     switch ($this->file['type']) {
         case 'image/jpeg':
             $src = imagecreatefromjpeg($local);
             break;
         case 'image/png':
             $src = imagecreatefrompng($local);
             break;
         case 'image/gif':
             $src = imagecreatefromgif($local);
             break;
         default:
             break;
     }
     $sx = imagesx($src);
     $sy = imagesy($src);
     $new_image = imagecreatetruecolor($this->newwidth, $this->newheight);
     if (imagecopyresized($new_image, $src, 0, 0, 0, 0, $this->newwidth, $this->newheight, $sx, $sy)) {
         if (ImageJpeg($new_image, $this->location) || Imagegif($new_image, $this->location) || Imagepng($new_image, $this->location)) {
             //imagejpeg($this->location);
             return true;
         }
     } else {
         return false;
     }
 }

/**
 * Generate a cached thumbnail for object lists (eg. carrier, order states...etc)
 *
 * @param string $image Real image filename
 * @param string $cacheImage Cached filename
 * @param integer $size Desired size
 */
function cacheImage($image, $cacheImage, $size, $imageType = 'jpg')
{
    if (file_exists($image)) {
        if (!file_exists(_PS_TMP_IMG_DIR_ . $cacheImage)) {
            $imageGd = $imageType == 'gif' ? imagecreatefromgif($image) : imagecreatefromjpeg($image);
            $x = imagesx($imageGd);
            $y = imagesy($imageGd);
            /* Size is already ok */
            if ($y < $size) {
                copy($image, _PS_TMP_IMG_DIR_ . $cacheImage);
            } else {
                $ratioX = $x / ($y / $size);
                $newImage = $imageType == 'gif' ? imagecreate($ratioX, $size) : imagecreatetruecolor($ratioX, $size);
                /* Allow to keep nice look even if resized */
                $white = imagecolorallocate($newImage, 255, 255, 255);
                imagefill($newImage, 0, 0, $white);
                imagecopyresampled($newImage, $imageGd, 0, 0, 0, 0, $ratioX, $size, $x, $y);
                imagecolortransparent($newImage, $white);
                /* Quality alteration and image creation */
                if ($imageType == 'gif') {
                    imagegif($newImage, _PS_TMP_IMG_DIR_ . $cacheImage);
                } else {
                    imagejpeg($newImage, _PS_TMP_IMG_DIR_ . $cacheImage, 86);
                }
            }
        }
        return '<img src="../img/tmp/' . $cacheImage . '" alt="" class="imgm" />';
    }
    return '';
}

function hacknrollify($picfilename)
{
    $logofilename = "logo.png";
    $logoPicPath = "logopics/" . $logofilename;
    $originalPicPath = "originalpics/" . $picfilename;
    $editedfilename = "hnr_" . $picfilename;
    $editedPicPath = "editedpics/" . $editedfilename;
    // read the original image from file
    $profilepic = imagecreatefromjpeg($originalPicPath);
    $profilepicWidth = imagesx($profilepic);
    $profilepicHeight = imagesy($profilepic);
    // create the black image overlay
    $blackoverlay = imagecreate($profilepicWidth, $profilepicHeight);
    imagecolorallocate($blackoverlay, 0, 0, 0);
    // then merge the black and profilepic
    imagecopymerge($profilepic, $blackoverlay, 0, 0, 0, 0, $profilepicWidth, $profilepicHeight, 50);
    imagedestroy($blackoverlay);
    // merge the resized logo
    $logo = resizeImage($logoPicPath, $profilepicWidth - 80, 999999);
    imageAlphaBlending($logo, false);
    imageSaveAlpha($logo, true);
    $logoWidth = imagesx($logo);
    $logoHeight = imagesy($logo);
    $verticalOffset = $profilepicHeight / 2 - $logoHeight / 2;
    $horizontalOffset = 40;
    imagecopyresampled($profilepic, $logo, $horizontalOffset, $verticalOffset, 0, 0, $logoWidth, $logoHeight, $logoWidth, $logoHeight);
    $mergeSuccess = imagejpeg($profilepic, $editedPicPath);
    if (!$mergeSuccess) {
        echo "Image merge failed!";
    }
    imagedestroy($profilepic);
    imagedestroy($logo);
    return $editedPicPath;
}

 static function resizewidth($width, $imageold, $imagenew)
 {
     $image_info = getimagesize($imageold);
     $image_type = $image_info[2];
     if ($image_type == IMAGETYPE_JPEG) {
         $image = imagecreatefromjpeg($imageold);
     } elseif ($this->image_type == IMAGETYPE_GIF) {
         $image = imagecreatefromgif($imageold);
     } elseif ($this->image_type == IMAGETYPE_PNG) {
         $image = imagecreatefrompng($imageold);
     }
     $ratio = imagesy($image) / imagesx($image);
     $height = $width * $ratio;
     //$width = imagesx($image) * $width/100;
     // $height = imagesx($image) * $width/100;
     $new_image = imagecreatetruecolor($width, $height);
     imagecopyresampled($new_image, $image, 0, 0, 0, 0, $width, $height, $image_info[0], $image_info[1]);
     $image = $new_image;
     $compression = 75;
     $permissions = null;
     if ($image_type == IMAGETYPE_JPEG) {
         imagejpeg($image, $imagenew, $compression);
     } elseif ($image_type == IMAGETYPE_GIF) {
         imagegif($image, $imagenew);
     } elseif ($image_type == IMAGETYPE_PNG) {
         imagepng($image, $imagenew);
     }
     if ($permissions != null) {
         chmod($imagenew, $permissions);
     }
 }

 public function apply($resource)
 {
     // Extract arguments
     @(list(, $direction, $step, $thickness, $color) = func_get_args());
     $step = (int) $step;
     $thickness = (int) $thickness;
     if ($step < 2) {
         $step = 2;
     }
     // Get resolution
     $width = imagesx($resource);
     $height = imagesy($resource);
     if ($width === false || $height === false) {
         throw new Exception("An error was encountered while getting image resolution");
     }
     // Apply effect
     switch ($direction) {
         case self::VERTICAL:
             $x = 0;
             while (($x += $step) < $width) {
                 parent::apply($resource, $x, 0, $x, $height, $thickness, $color);
             }
             break;
         case self::HORIZONTAL:
         default:
             $y = 0;
             while (($y += $step) < $height) {
                 parent::apply($resource, 0, $y, $width, $y, $thickness, $color);
             }
     }
     return $resource;
 }

 /**
  * Contructor method. Will create a new image from the target file.
  * Accepts an image filename as a string. Method also works out how
  * big the image is and stores this in the $image array.
  *
  * @param string $imgFile The image filename.
  */
 public function ImageManipulation($imgfile)
 {
     //detect image format
     $this->image["format"] = preg_replace("/.*\\.(.*)\$/", "\\1", $imgfile);
     //$this->image["format"] = preg_replace(".*\.(.*)$", "\\1", $imgfile);
     $this->image["format"] = strtoupper($this->image["format"]);
     // convert image into usable format.
     if ($this->image["format"] == "JPG" || $this->image["format"] == "JPEG") {
         //JPEG
         $this->image["format"] = "JPEG";
         $this->image["src"] = ImageCreateFromJPEG($imgfile);
     } elseif ($this->image["format"] == "PNG") {
         //PNG
         $this->image["format"] = "PNG";
         $this->image["src"] = imagecreatefrompng($imgfile);
     } elseif ($this->image["format"] == "GIF") {
         //GIF
         $this->image["format"] = "GIF";
         $this->image["src"] = ImageCreateFromGif($imgfile);
     } elseif ($this->image["format"] == "WBMP") {
         //WBMP
         $this->image["format"] = "WBMP";
         $this->image["src"] = ImageCreateFromWBMP($imgfile);
     } else {
         //DEFAULT
         return false;
     }
     // Image is ok
     $this->imageok = true;
     // Work out image size
     $this->image["sizex"] = imagesx($this->image["src"]);
     $this->image["sizey"] = imagesy($this->image["src"]);
 }

 public function getHashValue($img)
 {
     $width = imagesx($img);
     $height = imagesy($img);
     $total = 0;
     $array = array();
     for ($y = 0; $y < $height; $y++) {
         for ($x = 0; $x < $width; $x++) {
             $gray = imagecolorat($img, $x, $y) >> 8 & 0xff;
             if (!is_array($array[$y])) {
                 $array[$y] = array();
             }
             $array[$y][$x] = $gray;
             $total += $gray;
         }
     }
     $average = intval($total / (64 * $this->rate * $this->rate));
     $result = '';
     for ($y = 0; $y < $height; $y++) {
         for ($x = 0; $x < $width; $x++) {
             if ($array[$y][$x] >= $average) {
                 $result .= '1';
             } else {
                 $result .= '0';
             }
         }
     }
     return $result;
 }

 public function resizeTo($width, $height)
 {
     if (osc_use_imagick()) {
         $bg = new Imagick();
         $bg->newImage($width, $height, 'white');
         $this->im->thumbnailImage($width, $height, true);
         $geometry = $this->im->getImageGeometry();
         $x = ($width - $geometry['width']) / 2;
         $y = ($height - $geometry['height']) / 2;
         $bg->compositeImage($this->im, imagick::COMPOSITE_OVER, $x, $y);
         $this->im = $bg;
     } else {
         $w = imagesx($this->im);
         $h = imagesy($this->im);
         if ($w / $h >= $width / $height) {
             //$newW = $width;
             $newW = $w > $width ? $width : $w;
             $newH = $h * ($newW / $w);
         } else {
             //$newH = $height;
             $newH = $h > $height ? $height : $h;
             $newW = $w * ($newH / $h);
         }
         $newIm = imagecreatetruecolor($width, $height);
         //$newW, $newH);
         imagealphablending($newIm, false);
         $colorTransparent = imagecolorallocatealpha($newIm, 255, 255, 255, 127);
         imagefill($newIm, 0, 0, $colorTransparent);
         imagesavealpha($newIm, true);
         imagecopyresampled($newIm, $this->im, ($width - $newW) / 2, ($height - $newH) / 2, 0, 0, $newW, $newH, $w, $h);
         imagedestroy($this->im);
         $this->im = $newIm;
     }
     return $this;
 }

 /**
  * method puts image onto map image
  * 
  * @param Map  $map
  * @param resources $imageToPut
  */
 public function putImage(Map $map, $imageToPut)
 {
     $mapImage = $map->getImage();
     $width = imagesx($imageToPut);
     $height = imagesy($imageToPut);
     imagecopy($mapImage, $imageToPut, imagesx($mapImage) - $width, 0, 0, 0, $width, $height);
 }

 public function filter($value)
 {
     if (!file_exists($value)) {
         throw new Zend_Filter_Exception('Image does not exist: ' . $value);
     }
     $image = imagecreatefromstring(file_get_contents($value));
     if (false === $image) {
         throw new Zend_Filter_Exception('Can\'t load image: ' . $value);
     }
     // find ratio to scale down to
     // TODO: pass 600 as parameter in the future
     $origWidth = imagesx($image);
     $origHeight = imagesy($image);
     $ratio = max($origWidth, $origHeight) / 600;
     if ($ratio > 1) {
         // img too big! create a scaled down image
         $newWidth = round($origWidth / $ratio);
         $newHeight = round($origHeight / $ratio);
         $resized = imagecreatetruecolor($newWidth, $newHeight);
         imagecopyresampled($resized, $image, 0, 0, 0, 0, $newWidth, $newHeight, $origWidth, $origHeight);
         // determine type and store to disk
         $explodeResult = explode(".", $value);
         $type = strtolower($explodeResult[count($explodeResult) - 1]);
         $writeFunc = 'image' . $type;
         if ($type == 'jpeg' || $type == 'jpg') {
             imagejpeg($resized, $value, 100);
         } else {
             $writeFunc($resized, $value);
         }
     }
     return $value;
 }

function create_pic($upfile, $new_path, $width)
{
    $quality = 100;
    $image_path = $upfile;
    $image_info = getimagesize($image_path);
    $exname = '';
    //1  =  GIF,  2  =  JPG,  3  =  PNG,  4  =  SWF,  5  =  PSD,  6  =  BMP,  7  =  TIFF(intel  byte  order),  8  =  TIFF(motorola  byte  order),  9  =  JPC,  10  =  JP2,  11  =  JPX,  12  =  JB2,  13  =  SWC,  14  =  IFF
    switch ($image_info[2]) {
        case 1:
            @($image = imagecreatefromgif($image_path));
            $exname = 'gif';
            break;
        case 2:
            @($image = imagecreatefromjpeg($image_path));
            $exname = 'jpg';
            break;
        case 3:
            @($image = imagecreatefrompng($image_path));
            $exname = 'png';
            break;
        case 6:
            @($image = imagecreatefromwbmp($image_path));
            $exname = 'wbmp';
            break;
    }
    $T_width = $image_info[0];
    $T_height = $image_info[1];
    if (!empty($image)) {
        $image_x = imagesx($image);
        $image_y = imagesy($image);
    } else {
        return FALSE;
    }
    @chmod($new_path, 0777);
    if ($image_x > $width) {
        $x = $width;
        $y = intval($x * $image_y / $image_x);
    } else {
        @copy($image_path, $new_path . '.' . $exname);
        return $exname;
    }
    $newimage = imagecreatetruecolor($x, $y);
    imagecopyresampled($newimage, $image, 0, 0, 0, 0, $x, $y, $image_x, $image_y);
    switch ($image_info[2]) {
        case 1:
            imagegif($newimage, $new_path . '.gif', $quality);
            break;
        case 2:
            imagejpeg($newimage, $new_path . '.jpg', $quality);
            break;
        case 3:
            imagepng($newimage, $new_path . '.png', $quality);
            break;
        case 6:
            imagewbmp($newimage, $new_path . '.wbmp', $quality);
            break;
    }
    imagedestroy($newimage);
    return $exname;
}

 /**
  * Set the image variable by using image create
  *
  * @param string $filename - The image filename
  */
 private function setImage($filename)
 {
     $size = getimagesize($filename);
     $this->ext = $size['mime'];
     switch ($this->ext) {
         // Image is a JPG
         case 'image/jpg':
         case 'image/jpeg':
             // create a jpeg extension
             $this->image = imagecreatefromjpeg($filename);
             break;
             // Image is a GIF
         // Image is a GIF
         case 'image/gif':
             $this->image = @imagecreatefromgif($filename);
             break;
             // Image is a PNG
         // Image is a PNG
         case 'image/png':
             $this->image = @imagecreatefrompng($filename);
             break;
             // Mime type not found
         // Mime type not found
         default:
             throw new Exception("File is not an image, please use another file type.", 1);
     }
     $this->origWidth = imagesx($this->image);
     $this->origHeight = imagesy($this->image);
 }

function resize_image($pathToImages, $pathToThumbs, $thumbWidth)
{
    // open the directory
    $dir = opendir($pathToImages);
    // loop through it, looking for any/all JPG files:
    while (false !== ($fname = readdir($dir))) {
        // parse path for the extension
        $info = pathinfo($pathToImages . $fname);
        // continue only if this is a JPEG image
        if (strtolower($info['extension']) == 'jpg' && $fname != "thumb.jpg") {
            // load image and get image size
            $img = imagecreatefromjpeg("{$pathToImages}" . "/" . "{$fname}");
            $width = imagesx($img);
            $height = imagesy($img);
            // calculate thumbnail size
            $new_width = $thumbWidth;
            $new_height = floor($height * ($thumbWidth / $width));
            // create a new temporary image
            $tmp_img = imagecreatetruecolor($new_width, $new_height);
            // copy and resize old image into new image
            imagecopyresized($tmp_img, $img, 0, 0, 0, 0, $new_width, $new_height, $width, $height);
            // save thumbnail into a file
            imagejpeg($tmp_img, "{$pathToThumbs}" . "/" . "{$fname}");
            echo "Se redujo la imagen  {$fname} <br />";
            //echo "$pathToThumbs" . "/" . "$fname<br/>";
        }
    }
    // close the directory
    closedir($dir);
}

 /**
  * {@inheritdoc}
  */
 public function apply(&$image)
 {
     $inputWidth = imagesx($image);
     $inputHeight = imagesy($image);
     $width = $inputWidth;
     $height = $inputHeight;
     // bigger
     if ($height < $this->outputHeight) {
         $width = $this->outputHeight / $height * $width;
         $height = $this->outputHeight;
     }
     if ($width < $this->outputWidth) {
         $height = $this->outputWidth / $width * $height;
         $width = $this->outputWidth;
     }
     // taller
     if ($height > $this->outputHeight) {
         $width = $this->outputHeight / $height * $width;
         $height = $this->outputHeight;
     }
     // wider
     if ($width > $this->outputWidth) {
         $height = $this->outputWidth / $width * $height;
         $width = $this->outputWidth;
     }
     $output = imagecreatetruecolor($width, $height);
     imagecopyresampled($output, $image, 0, 0, 0, 0, $width, $height, $inputWidth, $inputHeight);
     $image = $output;
 }

function upload($tmp, $name, $nome, $larguraP, $pasta)
{
    $ext = strtolower(end(explode('.', $name)));
    if ($ext == 'jpg') {
        $img = imagecreatefromjpeg($tmp);
    } elseif ($ext == 'gif') {
        $img = imagecreatefromgif($tmp);
    } else {
        $img = imagecreatefrompng($tmp);
    }
    $x = imagesx($img);
    $y = imagesy($img);
    $largura = $x > $larguraP ? $larguraP : $x;
    $altura = $largura * $y / $x;
    if ($altura > $larguraP) {
        $altura = $larguraP;
        $largura = $altura * $x / $y;
    }
    $nova = imagecreatetruecolor($largura, $altura);
    imagecopyresampled($nova, $img, 0, 0, 0, 0, $largura, $altura, $x, $y);
    imagejpeg($nova, "{$pasta}/{$nome}");
    imagedestroy($img);
    imagedestroy($nova);
    return $nome;
}