313 lines
No EOL
9 KiB
PHP
313 lines
No EOL
9 KiB
PHP
<?php
|
|
// +-----------------------------------------------------------------------+
|
|
// | Piwigo - a PHP based photo gallery |
|
|
// +-----------------------------------------------------------------------+
|
|
// | Copyright(C) 2008-2013 Piwigo Team http://piwigo.org |
|
|
// +-----------------------------------------------------------------------+
|
|
// | This program is free software; you can redistribute it and/or modify |
|
|
// | it under the terms of the GNU General Public License as published by |
|
|
// | the Free Software Foundation |
|
|
// | |
|
|
// | This program is distributed in the hope that it will be useful, but |
|
|
// | WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
|
// | General Public License for more details. |
|
|
// | |
|
|
// | You should have received a copy of the GNU General Public License |
|
|
// | along with this program; if not, write to the Free Software |
|
|
// | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, |
|
|
// | USA. |
|
|
// +-----------------------------------------------------------------------+
|
|
|
|
function derivative_to_url($t)
|
|
{
|
|
return substr($t, 0, 2);
|
|
}
|
|
|
|
function size_to_url($s)
|
|
{
|
|
if ($s[0]==$s[1])
|
|
{
|
|
return $s[0];
|
|
}
|
|
return $s[0].'x'.$s[1];
|
|
}
|
|
|
|
function size_equals($s1, $s2)
|
|
{
|
|
return ($s1[0]==$s2[0] && $s1[1]==$s2[1]);
|
|
}
|
|
|
|
function char_to_fraction($c)
|
|
{
|
|
return (ord($c) - ord('a'))/25;
|
|
}
|
|
|
|
function fraction_to_char($f)
|
|
{
|
|
return chr(ord('a') + round($f*25));
|
|
}
|
|
|
|
/** small utility to manipulate a 'rectangle'*/
|
|
final class ImageRect
|
|
{
|
|
public $l,$t,$r,$b;
|
|
|
|
function __construct($l)
|
|
{
|
|
$this->l = $this->t = 0;
|
|
$this->r = $l[0];
|
|
$this->b = $l[1];
|
|
}
|
|
|
|
function width()
|
|
{
|
|
return $this->r - $this->l;
|
|
}
|
|
|
|
function height()
|
|
{
|
|
return $this->b - $this->t;
|
|
}
|
|
|
|
/** crops horizontally this rectangle by increasing left side and/or reducing the right side.
|
|
@param pixels the amount to substract from the width
|
|
@param coi a 4 character string (or null) containing the center of interest*/
|
|
function crop_h($pixels, $coi)
|
|
{
|
|
if ($this->width() <= $pixels)
|
|
return;
|
|
$tlcrop = floor($pixels/2);
|
|
|
|
if (!empty($coi))
|
|
{
|
|
$coil = floor($this->r * char_to_fraction($coi[0]));
|
|
$coir = ceil($this->r * char_to_fraction($coi[2]));
|
|
$availableL = $coil > $this->l ? $coil - $this->l : 0;
|
|
$availableR = $coir < $this->r ? $this->r - $coir : 0;
|
|
if ($availableL + $availableR >= $pixels)
|
|
{
|
|
if ($availableL < $tlcrop)
|
|
{
|
|
$tlcrop = $availableL;
|
|
}
|
|
elseif ($availableR < $tlcrop)
|
|
{
|
|
$tlcrop = $pixels - $availableR;
|
|
}
|
|
}
|
|
}
|
|
$this->l += $tlcrop;
|
|
$this->r -= $pixels - $tlcrop;
|
|
}
|
|
|
|
/** crops vertically this rectangle by increasing top side and/or reducing the bottom side.
|
|
@param pixels the amount to substract from the height
|
|
@param coi a 4 character string (or null) containing the center of interest*/
|
|
function crop_v($pixels, $coi)
|
|
{
|
|
if ($this->height() <= $pixels)
|
|
return;
|
|
$tlcrop = floor($pixels/2);
|
|
|
|
if (!empty($coi))
|
|
{
|
|
$coit = floor($this->b * char_to_fraction($coi[1]));
|
|
$coib = ceil($this->b * char_to_fraction($coi[3]));
|
|
$availableT = $coit > $this->t ? $coit - $this->t : 0;
|
|
$availableB = $coib < $this->b ? $this->b - $coib : 0;
|
|
if ($availableT + $availableB >= $pixels)
|
|
{
|
|
if ($availableT < $tlcrop)
|
|
{
|
|
$tlcrop = $availableT;
|
|
}
|
|
elseif ($availableB < $tlcrop)
|
|
{
|
|
$tlcrop = $pixels - $availableB;
|
|
}
|
|
}
|
|
}
|
|
$this->t += $tlcrop;
|
|
$this->b -= $pixels - $tlcrop;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/** Paramaters for derivative scaling and cropping. Instance of this class contained by DerivativeParams class.*/
|
|
final class SizingParams
|
|
{
|
|
/**
|
|
@param ideal_size two element array of maximum output dimensions (width, height)
|
|
@param max_crop range 0=no cropping ... 1= max cropping (100% of width/height); expressed as a factor of the input width/height
|
|
@param min_size used only if max_crop != 0 - two element array of output dimensions (width, height)
|
|
*/
|
|
function __construct($ideal_size, $max_crop = 0, $min_size = null)
|
|
{
|
|
$this->ideal_size = $ideal_size;
|
|
$this->max_crop = $max_crop; // range 0=no cropping ... 1= max cropping (100% of width/height)
|
|
$this->min_size = $min_size;
|
|
}
|
|
|
|
static function classic($w, $h)
|
|
{
|
|
return new SizingParams( array($w,$h) );
|
|
}
|
|
|
|
static function square($w)
|
|
{
|
|
return new SizingParams( array($w,$w), 1, array($w,$w) );
|
|
}
|
|
|
|
function add_url_tokens(&$tokens)
|
|
{
|
|
if ($this->max_crop == 0)
|
|
{
|
|
$tokens[] = 's'.size_to_url($this->ideal_size);
|
|
}
|
|
elseif ($this->max_crop == 1 && size_equals($this->ideal_size, $this->min_size) )
|
|
{
|
|
$tokens[] = 'e'.size_to_url($this->ideal_size);
|
|
}
|
|
else
|
|
{
|
|
$tokens[] = size_to_url($this->ideal_size);
|
|
$tokens[] = fraction_to_char($this->max_crop);
|
|
$tokens[] = size_to_url($this->min_size);
|
|
}
|
|
}
|
|
|
|
/* calculate the cropping rectangle and the scaled size for an input image size
|
|
@param in_size two element array of input dimensions (width, height)
|
|
@param coi empty or a four character encoded string containing the center of interest (unused if max_crop=0)
|
|
@param crop_rect output ImageRect containing the cropping rectangle or null if cropping is not required
|
|
@param scale_size output two element array containing width and height of the scaled image
|
|
*/
|
|
function compute($in_size, $coi, &$crop_rect, &$scale_size)
|
|
{
|
|
$destCrop = new ImageRect($in_size);
|
|
|
|
if ($this->max_crop > 0)
|
|
{
|
|
$ratio_w = $destCrop->width() / $this->ideal_size[0];
|
|
$ratio_h = $destCrop->height() / $this->ideal_size[1];
|
|
if ($ratio_w>1 || $ratio_h>1)
|
|
{
|
|
if ($ratio_w > $ratio_h)
|
|
{
|
|
$h = $destCrop->height() / $ratio_w;
|
|
if ($h < $this->min_size[1])
|
|
{
|
|
$idealCropPx = $destCrop->width() - floor($destCrop->height() * $this->ideal_size[0] / $this->min_size[1]);
|
|
$maxCropPx = round($this->max_crop * $destCrop->width());
|
|
$destCrop->crop_h( min($idealCropPx, $maxCropPx), $coi);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$w = $destCrop->width() / $ratio_h;
|
|
if ($w < $this->min_size[0])
|
|
{
|
|
$idealCropPx = $destCrop->height() - floor($destCrop->width() * $this->ideal_size[1] / $this->min_size[0]);
|
|
$maxCropPx = round($this->max_crop * $destCrop->height());
|
|
$destCrop->crop_v( min($idealCropPx, $maxCropPx), $coi);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$scale_size = array($destCrop->width(), $destCrop->height());
|
|
|
|
$ratio_w = $destCrop->width() / $this->ideal_size[0];
|
|
$ratio_h = $destCrop->height() / $this->ideal_size[1];
|
|
if ($ratio_w>1 || $ratio_h>1)
|
|
{
|
|
if ($ratio_w > $ratio_h)
|
|
{
|
|
$scale_size[0] = $this->ideal_size[0];
|
|
$scale_size[1] = floor(1e-6 + $scale_size[1] / $ratio_w);
|
|
}
|
|
else
|
|
{
|
|
$scale_size[0] = floor(1e-6 + $scale_size[0] / $ratio_h);
|
|
$scale_size[1] = $this->ideal_size[1];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$scale_size = null;
|
|
}
|
|
|
|
$crop_rect = null;
|
|
if ($destCrop->width()!=$in_size[0] || $destCrop->height()!=$in_size[1] )
|
|
{
|
|
$crop_rect = $destCrop;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/** All needed parameters to generate a derivative image.*/
|
|
final class DerivativeParams
|
|
{
|
|
public $type = IMG_CUSTOM; // string IMG_xxx
|
|
public $last_mod_time = 0; // used for non-custom images to regenerate the cached files
|
|
public $use_watermark = false;
|
|
public $sizing; // of type SizingParams
|
|
public $sharpen = 0; // range 0= no sharpening ... 1= max sharpening
|
|
|
|
function __construct($sizing)
|
|
{
|
|
$this->sizing = $sizing;
|
|
}
|
|
|
|
public function __sleep()
|
|
{
|
|
return array('last_mod_time', 'sizing', 'sharpen');
|
|
}
|
|
|
|
function add_url_tokens(&$tokens)
|
|
{
|
|
$this->sizing->add_url_tokens($tokens);
|
|
}
|
|
|
|
function compute_final_size($in_size)
|
|
{
|
|
$this->sizing->compute( $in_size, null, $crop_rect, $scale_size );
|
|
return $scale_size != null ? $scale_size : $in_size;
|
|
}
|
|
|
|
function max_width()
|
|
{
|
|
return $this->sizing->ideal_size[0];
|
|
}
|
|
|
|
function max_height()
|
|
{
|
|
return $this->sizing->ideal_size[1];
|
|
}
|
|
|
|
function is_identity($in_size)
|
|
{
|
|
if ($in_size[0] > $this->sizing->ideal_size[0] or
|
|
$in_size[1] > $this->sizing->ideal_size[1] )
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function will_watermark($out_size)
|
|
{
|
|
if ($this->use_watermark)
|
|
{
|
|
$min_size = ImageStdParams::get_watermark()->min_size;
|
|
return $min_size[0]<=$out_size[0]
|
|
|| $min_size[1]<=$out_size[1];
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
?>
|