cuongpv/faveo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Applied fixes from StyleCI

Browse Source
This commit is contained in:
Sujit Prasad
2016-02-19 02:20:12 -05:00
committed by StyleCI Bot
parent be5df5334f
commit d637c2b23f
439 changed files with 19063 additions and 19210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

319
public/filemanager/connectors/php/inc/wideimage/lib/Canvas.php
View File

@@ -1,167 +1,156 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* @package WideImage
**/
/**
* @package Exceptions
*/
class WideImage_NoFontException extends WideImage_Exception {}
/**
* @package Exceptions
*/
class WideImage_InvalidFontFileException extends WideImage_Exception {}
/**
* @package Exceptions
*/
class WideImage_InvalidCanvasMethodException extends WideImage_Exception {}
/**
* @package WideImage
*/
class WideImage_Canvas
{
protected $handle = 0;
protected $image = null;
protected $font = null;
/**
* Creates a canvas object that writes to the image passed as a parameter
*
* Shouldn't be used directly, use WideImage_Image::getCanvas() instead.
*
* @param WideImage_Image $img Image object
*/
function __construct($img)
{
$this->handle = $img->getHandle();
$this->image = $img;
}
/**
* Sets the active font. Can be an instance of
* WideImage_Font_TTF, WideImage_Font_PS, or WideImage_Font_GDF.
*
*
*
*
* @param object $font Font object to set for writeText()
*/
function setFont($font)
{
$this->font = $font;
}
/**
* Creates and sets the current font
*
* The supported font types are: TTF/OTF, PS, and GDF.
* Font type is detected from the extension. If the $file parameter doesn't have an extension, TTF font is presumed.
*
* Note: not all parameters are supported by all fonts.
*
* @param string $file Font file name (string)
* @param int $size Font size (supported for TTF/OTF and PS fonts, ignored for GDF)
* @param int $color Text color
* @param int $bgcolor Background color (supported only for PS font, ignored for TTF and PS)
* @return mixed One of the WideImage_Font_* objects
*/
function useFont($file, $size = 12, $color = 0, $bgcolor = null)
{
$p = strrpos($file, '.');
if ($p === false || $p < strlen($file) - 4)
$ext = 'ttf';
else
$ext = strtolower(substr($file, $p + 1));
if ($ext == 'ttf' || $ext == 'otf')
$font = new WideImage_Font_TTF($file, $size, $color);
elseif ($ext == 'ps')
$font = new WideImage_Font_PS($file, $size, $color, $bgcolor);
elseif ($ext == 'gdf')
$font = new WideImage_Font_GDF($file, $color);
else
throw new WideImage_InvalidFontFileException("'$file' appears to be an invalid font file.");
$this->setFont($font);
return $font;
}
/**
* Write text on the image at specified position
*
* You must set a font with a call to WideImage_Canvas::setFont() prior to writing text to the image.
*
* Smart coordinates are supported for $x and $y arguments, but currently only for TTF/OTF fonts.
*
* Example:
* <code>
* $img = WideImage::load('pic.jpg');
* $canvas = $img->getCanvas();
* $canvas->useFont('Verdana.ttf', 16, $img->allocateColor(255, 0, 0));
* $canvas->writeText('right', 'bottom', 'www.website.com');
* </code>
*
* @param int $x Left
* @param int $y Top
* @param string $text Text to write
* @param int $angle The angle, defaults to 0
*/
function writeText($x, $y, $text, $angle = 0)
{
if ($this->font === null)
throw new WideImage_NoFontException("Can't write text without a font.");
$angle = - floatval($angle);
if ($angle < 0)
$angle = 360 + $angle;
$angle = $angle % 360;
$this->font->writeText($this->image, $x, $y, $text, $angle);
}
/**
* A magic method that allows you to call any PHP function that starts with "image".
*
* This is a shortcut to call custom functions on the image handle.
*
* Example:
* <code>
* $img = WideImage::load('pic.jpg');
* $canvas = $img->getCanvas();
* $canvas->filledRect(10, 10, 20, 30, $img->allocateColor(0, 0, 0));
* $canvas->line(60, 80, 30, 100, $img->allocateColor(255, 0, 0));
* </code>
*/
function __call($method, $params)
{
if (function_exists('image' . $method))
{
array_unshift($params, $this->handle);
call_user_func_array('image' . $method, $params);
}
else
throw new WideImage_InvalidCanvasMethodException("Function doesn't exist: image{$method}.");
}
}
/**
*/
class WideImage_NoFontException extends WideImage_Exception
{
}
/**
*/
class WideImage_InvalidFontFileException extends WideImage_Exception
{
}
/**
*/
class WideImage_InvalidCanvasMethodException extends WideImage_Exception
{
}
/**
*/
class WideImage_Canvas
{
protected $handle = 0;
protected $image = null;
protected $font = null;
/**
* Creates a canvas object that writes to the image passed as a parameter.
*
* Shouldn't be used directly, use WideImage_Image::getCanvas() instead.
*
* @param WideImage_Image $img Image object
*/
public function __construct($img)
{
$this->handle = $img->getHandle();
$this->image = $img;
}
/**
* Sets the active font. Can be an instance of
* WideImage_Font_TTF, WideImage_Font_PS, or WideImage_Font_GDF.
*
*
*
*
* @param object $font Font object to set for writeText()
*/
public function setFont($font)
{
$this->font = $font;
}
/**
* Creates and sets the current font.
*
* The supported font types are: TTF/OTF, PS, and GDF.
* Font type is detected from the extension. If the $file parameter doesn't have an extension, TTF font is presumed.
*
* Note: not all parameters are supported by all fonts.
*
* @param string $file Font file name (string)
* @param int $size Font size (supported for TTF/OTF and PS fonts, ignored for GDF)
* @param int $color Text color
* @param int $bgcolor Background color (supported only for PS font, ignored for TTF and PS)
*
* @return mixed One of the WideImage_Font_* objects
*/
public function useFont($file, $size = 12, $color = 0, $bgcolor = null)
{
$p = strrpos($file, '.');
if ($p === false || $p < strlen($file) - 4) {
$ext = 'ttf';
} else {
$ext = strtolower(substr($file, $p + 1));
}
if ($ext == 'ttf' || $ext == 'otf') {
$font = new WideImage_Font_TTF($file, $size, $color);
} elseif ($ext == 'ps') {
$font = new WideImage_Font_PS($file, $size, $color, $bgcolor);
} elseif ($ext == 'gdf') {
$font = new WideImage_Font_GDF($file, $color);
} else {
throw new WideImage_InvalidFontFileException("'$file' appears to be an invalid font file.");
}
$this->setFont($font);
return $font;
}
/**
* Write text on the image at specified position.
*
* You must set a font with a call to WideImage_Canvas::setFont() prior to writing text to the image.
*
* Smart coordinates are supported for $x and $y arguments, but currently only for TTF/OTF fonts.
*
* Example:
* <code>
* $img = WideImage::load('pic.jpg');
* $canvas = $img->getCanvas();
* $canvas->useFont('Verdana.ttf', 16, $img->allocateColor(255, 0, 0));
* $canvas->writeText('right', 'bottom', 'www.website.com');
* </code>
*
* @param int $x Left
* @param int $y Top
* @param string $text Text to write
* @param int $angle The angle, defaults to 0
*/
public function writeText($x, $y, $text, $angle = 0)
{
if ($this->font === null) {
throw new WideImage_NoFontException("Can't write text without a font.");
}
$angle = -floatval($angle);
if ($angle < 0) {
$angle = 360 + $angle;
}
$angle = $angle % 360;
$this->font->writeText($this->image, $x, $y, $text, $angle);
}
/**
* A magic method that allows you to call any PHP function that starts with "image".
*
* This is a shortcut to call custom functions on the image handle.
*
* Example:
* <code>
* $img = WideImage::load('pic.jpg');
* $canvas = $img->getCanvas();
* $canvas->filledRect(10, 10, 20, 30, $img->allocateColor(0, 0, 0));
* $canvas->line(60, 80, 30, 100, $img->allocateColor(255, 0, 0));
* </code>
*/
public function __call($method, $params)
{
if (function_exists('image'.$method)) {
array_unshift($params, $this->handle);
call_user_func_array('image'.$method, $params);
} else {
throw new WideImage_InvalidCanvasMethodException("Function doesn't exist: image{$method}.");
}
}
}

381
public/filemanager/connectors/php/inc/wideimage/lib/Coordinate.php
View File

@@ -1,208 +1,179 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
*/
class WideImage_InvalidCoordinateException extends WideImage_Exception
{
}
* @package Internals
**/
/**
* @package Exceptions
*/
class WideImage_InvalidCoordinateException extends WideImage_Exception {}
/**
* A utility class for smart coordinates
*
* @package Internals
**/
class WideImage_Coordinate
{
static protected $coord_align = array("left", "center", "right", "top", "middle", "bottom");
static protected $coord_numeric = array("[0-9]+", "[0-9]+\.[0-9]+", "[0-9]+%", "[0-9]+\.[0-9]+%");
/**
* Parses a numeric or string representation of a corrdinate into a structure
*
* @param string $coord Smart coordinate
* @return array Parsed smart coordinate
*/
static function parse($c)
{
$tokens = array();
$operators = array('+', '-');
$flush_operand = false;
$flush_operator = false;
$current_operand = '';
$current_operator = '';
$coordinate = strval($c);
$expr_len = strlen($coordinate);
for ($i = 0; $i < $expr_len; $i++)
{
$char = $coordinate[$i];
if (in_array($char, $operators))
{
$flush_operand = true;
$flush_operator = true;
$current_operator = $char;
}
else
{
$current_operand .= $char;
if ($i == $expr_len - 1)
$flush_operand = true;
}
if ($flush_operand)
{
if (trim($current_operand) != '')
$tokens[] = array('type' => 'operand', 'value' => trim($current_operand));
$current_operand = '';
$flush_operand = false;
}
if ($flush_operator)
{
$tokens[] = array('type' => 'operator', 'value' => $char);
$flush_operator = false;
}
}
return $tokens;
}
/**
* Evaluates the $coord relatively to $dim
*
* @param string $coord A numeric value or percent string
* @param int $dim Dimension
* @param int $sec_dim Secondary dimension (for align)
* @return int Calculated value
*/
static function evaluate($coord, $dim, $sec_dim = null)
{
$comp_regex = implode('|', self::$coord_align) . '|' . implode('|', self::$coord_numeric);
if (preg_match("/^([+-])?({$comp_regex})$/", $coord, $matches))
{
$sign = intval($matches[1] . "1");
$val = $matches[2];
if (in_array($val, self::$coord_align))
{
if ($sec_dim === null)
{
switch ($val)
{
case 'left':
case 'top':
return 0;
break;
case 'center':
case 'middle':
return $sign * intval($dim / 2);
break;
case 'right':
case 'bottom':
return $sign * $dim;
break;
default:
return null;
}
}
else
{
switch ($val)
{
case 'left':
case 'top':
return 0;
break;
case 'center':
case 'middle':
return $sign * intval($dim / 2 - $sec_dim / 2);
break;
case 'right':
case 'bottom':
return $sign * ($dim - $sec_dim);
break;
default:
return null;
}
}
}
elseif (substr($val, -1) === '%')
return intval(round($sign * $dim * floatval(str_replace('%', '', $val)) / 100));
else
return $sign * intval(round($val));
}
}
/**
* Calculates and fixes a smart coordinate into a numeric value
*
* @param mixed $value Smart coordinate, relative to $dim
* @param int $dim Coordinate to which $value is relative
* @param int $sec_dim Secondary dimension (for align)
* @return int Calculated value
*/
static function fix($value, $dim, $sec_dim = null)
{
$coord_tokens = self::parse($value);
if (count($coord_tokens) == 0 || $coord_tokens[count($coord_tokens) - 1]['type'] != 'operand')
throw new WideImage_InvalidCoordinateException("Couldn't parse coordinate '$value' properly.");
$value = 0;
$operation = 1;
foreach ($coord_tokens as $token)
{
if ($token['type'] == 'operand')
{
$operand_value = self::evaluate($token['value'], $dim, $sec_dim);
if ($operation == 1)
$value = $value + $operand_value;
elseif ($operation == -1)
$value = $value - $operand_value;
else
throw new WideImage_InvalidCoordinateException("Invalid coordinate syntax.");
$operation = 0;
}
elseif ($token['type'] == 'operator')
{
if ($token['value'] == '-')
{
if ($operation == 0)
$operation = -1;
else
$operation = $operation * -1;
}
elseif ($token['value'] == '+')
{
if ($operation == 0)
$operation = '1';
}
}
}
return $value;
}
}
/**
* A utility class for smart coordinates.
**/
class WideImage_Coordinate
{
protected static $coord_align = ['left', 'center', 'right', 'top', 'middle', 'bottom'];
protected static $coord_numeric = ['[0-9]+', "[0-9]+\.[0-9]+", '[0-9]+%', "[0-9]+\.[0-9]+%"];
/**
* Parses a numeric or string representation of a corrdinate into a structure.
*
* @param string $coord Smart coordinate
*
* @return array Parsed smart coordinate
*/
public static function parse($c)
{
$tokens = [];
$operators = ['+', '-'];
$flush_operand = false;
$flush_operator = false;
$current_operand = '';
$current_operator = '';
$coordinate = strval($c);
$expr_len = strlen($coordinate);
for ($i = 0; $i < $expr_len; $i++) {
$char = $coordinate[$i];
if (in_array($char, $operators)) {
$flush_operand = true;
$flush_operator = true;
$current_operator = $char;
} else {
$current_operand .= $char;
if ($i == $expr_len - 1) {
$flush_operand = true;
}
}
if ($flush_operand) {
if (trim($current_operand) != '') {
$tokens[] = ['type' => 'operand', 'value' => trim($current_operand)];
}
$current_operand = '';
$flush_operand = false;
}
if ($flush_operator) {
$tokens[] = ['type' => 'operator', 'value' => $char];
$flush_operator = false;
}
}
return $tokens;
}
/**
* Evaluates the $coord relatively to $dim.
*
* @param string $coord A numeric value or percent string
* @param int $dim Dimension
* @param int $sec_dim Secondary dimension (for align)
*
* @return int Calculated value
*/
public static function evaluate($coord, $dim, $sec_dim = null)
{
$comp_regex = implode('|', self::$coord_align).'|'.implode('|', self::$coord_numeric);
if (preg_match("/^([+-])?({$comp_regex})$/", $coord, $matches)) {
$sign = intval($matches[1].'1');
$val = $matches[2];
if (in_array($val, self::$coord_align)) {
if ($sec_dim === null) {
switch ($val) {
case 'left':
case 'top':
return 0;
break;
case 'center':
case 'middle':
return $sign * intval($dim / 2);
break;
case 'right':
case 'bottom':
return $sign * $dim;
break;
default:
return;
}
} else {
switch ($val) {
case 'left':
case 'top':
return 0;
break;
case 'center':
case 'middle':
return $sign * intval($dim / 2 - $sec_dim / 2);
break;
case 'right':
case 'bottom':
return $sign * ($dim - $sec_dim);
break;
default:
return;
}
}
} elseif (substr($val, -1) === '%') {
return intval(round($sign * $dim * floatval(str_replace('%', '', $val)) / 100));
} else {
return $sign * intval(round($val));
}
}
}
/**
* Calculates and fixes a smart coordinate into a numeric value.
*
* @param mixed $value Smart coordinate, relative to $dim
* @param int $dim Coordinate to which $value is relative
* @param int $sec_dim Secondary dimension (for align)
*
* @return int Calculated value
*/
public static function fix($value, $dim, $sec_dim = null)
{
$coord_tokens = self::parse($value);
if (count($coord_tokens) == 0 || $coord_tokens[count($coord_tokens) - 1]['type'] != 'operand') {
throw new WideImage_InvalidCoordinateException("Couldn't parse coordinate '$value' properly.");
}
$value = 0;
$operation = 1;
foreach ($coord_tokens as $token) {
if ($token['type'] == 'operand') {
$operand_value = self::evaluate($token['value'], $dim, $sec_dim);
if ($operation == 1) {
$value = $value + $operand_value;
} elseif ($operation == -1) {
$value = $value - $operand_value;
} else {
throw new WideImage_InvalidCoordinateException('Invalid coordinate syntax.');
}
$operation = 0;
} elseif ($token['type'] == 'operator') {
if ($token['value'] == '-') {
if ($operation == 0) {
$operation = -1;
} else {
$operation = $operation * -1;
}
} elseif ($token['value'] == '+') {
if ($operation == 0) {
$operation = '1';
}
}
}
}
return $value;
}
}

39
public/filemanager/connectors/php/inc/wideimage/lib/Exception.php
View File

@@ -1,31 +1,12 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* @package WideImage
**/
/**
* Base Exception class
*
* @package Exceptions
**/
class WideImage_Exception extends RuntimeException {}
/**
* Base Exception class.
**/
class WideImage_Exception extends RuntimeException
{
}

73
public/filemanager/connectors/php/inc/wideimage/lib/Font/GDF.php
View File

@@ -1,48 +1,29 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* @package WideImage
**/
/**
* GDF font support class
*
* @package WideImage
*/
class WideImage_Font_GDF
{
protected $font;
protected $color;
function __construct($face, $color)
{
if (is_int($face) && $face >= 1 && $face <= 5)
$this->font = $face;
else
$this->font = imageloadfont($face);
$this->color = $color;
}
function writeText($image, $x, $y, $text)
{
imagestring($image->getHandle(), $this->font, $x, $y, $text, $this->color);
}
}
/**
* GDF font support class.
*/
class WideImage_Font_GDF
{
protected $font;
protected $color;
public function __construct($face, $color)
{
if (is_int($face) && $face >= 1 && $face <= 5) {
$this->font = $face;
} else {
$this->font = imageloadfont($face);
}
$this->color = $color;
}
public function writeText($image, $x, $y, $text)
{
imagestring($image->getHandle(), $this->font, $x, $y, $text, $this->color);
}
}

96
public/filemanager/connectors/php/inc/wideimage/lib/Font/PS.php
View File

@@ -1,60 +1,42 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* PS font support class.
*/
class WideImage_Font_PS
{
public $size;
public $color;
public $handle;
* @package WideImage
**/
/**
* PS font support class
*
* @package WideImage
*/
class WideImage_Font_PS
{
public $size;
public $color;
public $handle;
function __construct($file, $size, $color, $bgcolor = null)
{
$this->handle = imagepsloadfont($file);
$this->size = $size;
$this->color = $color;
if ($bgcolor === null)
$this->bgcolor = $color;
else
$this->color = $color;
}
function writeText($image, $x, $y, $text, $angle = 0)
{
if ($image->isTrueColor())
$image->alphaBlending(true);
imagepstext($image->getHandle(), $text, $this->handle, $this->size, $this->color, $this->bgcolor, $x, $y, 0, 0, $angle, 4);
}
function __destruct()
{
imagepsfreefont($this->handle);
$this->handle = null;
}
}
public function __construct($file, $size, $color, $bgcolor = null)
{
$this->handle = imagepsloadfont($file);
$this->size = $size;
$this->color = $color;
if ($bgcolor === null) {
$this->bgcolor = $color;
} else {
$this->color = $color;
}
}
public function writeText($image, $x, $y, $text, $angle = 0)
{
if ($image->isTrueColor()) {
$image->alphaBlending(true);
}
imagepstext($image->getHandle(), $text, $this->handle, $this->size, $this->color, $this->bgcolor, $x, $y, 0, 0, $angle, 4);
}
public function __destruct()
{
imagepsfreefont($this->handle);
$this->handle = null;
}
}

125
public/filemanager/connectors/php/inc/wideimage/lib/Font/TTF.php
View File

@@ -1,75 +1,56 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* TTF font support class.
*/
class WideImage_Font_TTF
{
public $face;
public $size;
public $color;
* @package WideImage
**/
/**
* TTF font support class
*
* @package WideImage
*/
class WideImage_Font_TTF
{
public $face;
public $size;
public $color;
function __construct($face, $size, $color)
{
$this->face = $face;
$this->size = $size;
$this->color = $color;
}
/**
* Writes text onto an image
*
* @param WideImage_Image $image
* @param mixed $x smart coordinate
* @param mixed $y smart coordinate
* @param string $text
* @param int $angle Angle in degrees clockwise
*/
function writeText($image, $x, $y, $text, $angle = 0)
{
if ($image->isTrueColor())
$image->alphaBlending(true);
$box = imageftbbox($this->size, $angle, $this->face, $text);
$obox = array(
'left' => min($box[0], $box[2], $box[4], $box[6]),
'top' => min($box[1], $box[3], $box[5], $box[7]),
'right' => max($box[0], $box[2], $box[4], $box[6]) - 1,
'bottom' => max($box[1], $box[3], $box[5], $box[7]) - 1
);
$obox['width'] = abs($obox['left']) + abs($obox['right']);
$obox['height'] = abs($obox['top']) + abs($obox['bottom']);
$x = WideImage_Coordinate::fix($x, $image->getWidth(), $obox['width']);
$y = WideImage_Coordinate::fix($y, $image->getHeight(), $obox['height']);
$fixed_x = $x - $obox['left'];
$fixed_y = $y - $obox['top'];
imagettftext($image->getHandle(), $this->size, $angle, $fixed_x, $fixed_y, $this->color, $this->face, $text);
}
}
public function __construct($face, $size, $color)
{
$this->face = $face;
$this->size = $size;
$this->color = $color;
}
/**
* Writes text onto an image.
*
* @param WideImage_Image $image
* @param mixed $x smart coordinate
* @param mixed $y smart coordinate
* @param string $text
* @param int $angle Angle in degrees clockwise
*/
public function writeText($image, $x, $y, $text, $angle = 0)
{
if ($image->isTrueColor()) {
$image->alphaBlending(true);
}
$box = imageftbbox($this->size, $angle, $this->face, $text);
$obox = [
'left' => min($box[0], $box[2], $box[4], $box[6]),
'top' => min($box[1], $box[3], $box[5], $box[7]),
'right' => max($box[0], $box[2], $box[4], $box[6]) - 1,
'bottom' => max($box[1], $box[3], $box[5], $box[7]) - 1,
];
$obox['width'] = abs($obox['left']) + abs($obox['right']);
$obox['height'] = abs($obox['top']) + abs($obox['bottom']);
$x = WideImage_Coordinate::fix($x, $image->getWidth(), $obox['width']);
$y = WideImage_Coordinate::fix($y, $image->getHeight(), $obox['height']);
$fixed_x = $x - $obox['left'];
$fixed_y = $y - $obox['top'];
imagettftext($image->getHandle(), $this->size, $angle, $fixed_x, $fixed_y, $this->color, $this->face, $text);
}
}

1944
public/filemanager/connectors/php/inc/wideimage/lib/Image.php
View File

File diff suppressed because it is too large Load Diff

76
public/filemanager/connectors/php/inc/wideimage/lib/Mapper/BMP.php
View File

@@ -1,51 +1,31 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
include_once WideImage::path().'/vendor/de77/BMP.php';
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Mapper support for BMP.
*/
class WideImage_Mapper_BMP
{
public function load($uri)
{
return WideImage_vendor_de77_BMP::imagecreatefrombmp($uri);
}
* @package Internal/Mappers
**/
include_once WideImage::path() . '/vendor/de77/BMP.php';
/**
* Mapper support for BMP
*
* @package Internal/Mappers
*/
class WideImage_Mapper_BMP
{
function load($uri)
{
return WideImage_vendor_de77_BMP::imagecreatefrombmp($uri);
}
function loadFromString($data)
{
return WideImage_vendor_de77_BMP::imagecreatefromstring($data);
}
function save($handle, $uri = null)
{
if ($uri == null)
return WideImage_vendor_de77_BMP::imagebmp($handle);
else
return WideImage_vendor_de77_BMP::imagebmp($handle, $uri);
}
}
public function loadFromString($data)
{
return WideImage_vendor_de77_BMP::imagecreatefromstring($data);
}
public function save($handle, $uri = null)
{
if ($uri == null) {
return WideImage_vendor_de77_BMP::imagebmp($handle);
} else {
return WideImage_vendor_de77_BMP::imagebmp($handle, $uri);
}
}
}

63
public/filemanager/connectors/php/inc/wideimage/lib/Mapper/GD.php
View File

@@ -1,44 +1,25 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Mapper class for GD files.
*/
class WideImage_Mapper_GD
{
public function load($uri)
{
return @imagecreatefromgd($uri);
}
* @package Internal/Mappers
**/
/**
* Mapper class for GD files
*
* @package Internal/Mappers
*/
class WideImage_Mapper_GD
{
function load($uri)
{
return @imagecreatefromgd($uri);
}
function save($handle, $uri = null)
{
if ($uri == null)
return imagegd($handle);
else
return imagegd($handle, $uri);
}
}
public function save($handle, $uri = null)
{
if ($uri == null) {
return imagegd($handle);
} else {
return imagegd($handle, $uri);
}
}
}

56
public/filemanager/connectors/php/inc/wideimage/lib/Mapper/GD2.php
View File

@@ -1,41 +1,21 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Mapper class for GD2 files.
*/
class WideImage_Mapper_GD2
{
public function load($uri)
{
return @imagecreatefromgd2($uri);
}
* @package Internal/Mappers
**/
/**
* Mapper class for GD2 files
*
* @package Internal/Mappers
*/
class WideImage_Mapper_GD2
{
function load($uri)
{
return @imagecreatefromgd2($uri);
}
function save($handle, $uri = null, $chunk_size = null, $type = null)
{
return imagegd2($handle, $uri, $chunk_size, $type);
}
}
public function save($handle, $uri = null, $chunk_size = null, $type = null)
{
return imagegd2($handle, $uri, $chunk_size, $type);
}
}

75
public/filemanager/connectors/php/inc/wideimage/lib/Mapper/GIF.php
View File

@@ -1,50 +1,31 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Mapper class for GIF files.
*/
class WideImage_Mapper_GIF
{
public function load($uri)
{
return @imagecreatefromgif($uri);
}
* @package Internal/Mappers
**/
/**
* Mapper class for GIF files
*
* @package Internal/Mappers
*/
class WideImage_Mapper_GIF
{
function load($uri)
{
return @imagecreatefromgif($uri);
}
function save($handle, $uri = null)
{
// This is a workaround for a bug, for which PHP devs claim it's not
// really a bug. Well, it IS.
// You can't pass null as the second parameter, because php is
// then trying to save an image to a '' location (which results in an
// error, of course). And the same thing works fine for imagepng() and
// imagejpeg(). It's a bug! ;)
if ($uri)
return imagegif($handle, $uri);
else
return imagegif($handle);
}
}
public function save($handle, $uri = null)
{
// This is a workaround for a bug, for which PHP devs claim it's not
// really a bug. Well, it IS.
// You can't pass null as the second parameter, because php is
// then trying to save an image to a '' location (which results in an
// error, of course). And the same thing works fine for imagepng() and
// imagejpeg(). It's a bug! ;)
if ($uri) {
return imagegif($handle, $uri);
} else {
return imagegif($handle);
}
}
}

56
public/filemanager/connectors/php/inc/wideimage/lib/Mapper/JPEG.php
View File

@@ -1,41 +1,21 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Mapper class for JPEG files.
*/
class WideImage_Mapper_JPEG
{
public function load($uri)
{
return @imagecreatefromjpeg($uri);
}
* @package Internal/Mappers
**/
/**
* Mapper class for JPEG files
*
* @package Internal/Mappers
*/
class WideImage_Mapper_JPEG
{
function load($uri)
{
return @imagecreatefromjpeg($uri);
}
function save($handle, $uri = null, $quality = 100)
{
return imagejpeg($handle, $uri, $quality);
}
}
public function save($handle, $uri = null, $quality = 100)
{
return imagejpeg($handle, $uri, $quality);
}
}

56
public/filemanager/connectors/php/inc/wideimage/lib/Mapper/PNG.php
View File

@@ -1,41 +1,21 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Mapper class for PNG files.
*/
class WideImage_Mapper_PNG
{
public function load($uri)
{
return @imagecreatefrompng($uri);
}
* @package Internal/Mappers
**/
/**
* Mapper class for PNG files
*
* @package Internal/Mappers
*/
class WideImage_Mapper_PNG
{
function load($uri)
{
return @imagecreatefrompng($uri);
}
function save($handle, $uri = null, $compression = 9, $filters = PNG_ALL_FILTERS)
{
return imagepng($handle, $uri, $compression, $filters);
}
}
public function save($handle, $uri = null, $compression = 9, $filters = PNG_ALL_FILTERS)
{
return imagepng($handle, $uri, $compression, $filters);
}
}

69
public/filemanager/connectors/php/inc/wideimage/lib/Mapper/TGA.php
View File

@@ -1,48 +1,27 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
include_once WideImage::path().'/vendor/de77/TGA.php';
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Mapper support for TGA.
*/
class WideImage_Mapper_TGA
{
public function load($uri)
{
return WideImage_vendor_de77_TGA::imagecreatefromtga($uri);
}
* @package Internal/Mappers
**/
include_once WideImage::path() . '/vendor/de77/TGA.php';
/**
* Mapper support for TGA
*
* @package Internal/Mappers
*/
class WideImage_Mapper_TGA
{
function load($uri)
{
return WideImage_vendor_de77_TGA::imagecreatefromtga($uri);
}
function loadFromString($data)
{
return WideImage_vendor_de77_TGA::imagecreatefromstring($data);
}
function save($handle, $uri = null)
{
throw new WideImage_Exception("Saving to TGA isn't supported.");
}
}
public function loadFromString($data)
{
return WideImage_vendor_de77_TGA::imagecreatefromstring($data);
}
public function save($handle, $uri = null)
{
throw new WideImage_Exception("Saving to TGA isn't supported.");
}
}

233
public/filemanager/connectors/php/inc/wideimage/lib/MapperFactory.php
View File

@@ -1,126 +1,111 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* @package WideImage
**/
/**
* Thrown when image format isn't supported
*
* @package Exceptions
*/
class WideImage_UnsupportedFormatException extends WideImage_Exception {}
/**
* Mapper factory
*
* @package Internals
**/
abstract class WideImage_MapperFactory
{
static protected $mappers = array();
static protected $customMappers = array();
static protected $mimeTable = array(
'image/jpg' => 'JPEG',
'image/jpeg' => 'JPEG',
'image/pjpeg' => 'JPEG',
'image/gif' => 'GIF',
'image/png' => 'PNG'
);
/**
* Returns a mapper, based on the $uri and $format
*
* @param string $uri File URI
* @param string $format File format (extension or mime-type) or null
* @return WideImage_Mapper
**/
static function selectMapper($uri, $format = null)
{
$format = self::determineFormat($uri, $format);
if (array_key_exists($format, self::$mappers))
return self::$mappers[$format];
$mapperClassName = 'WideImage_Mapper_' . $format;
if (!class_exists($mapperClassName, false))
{
$mapperFileName = WideImage::path() . 'Mapper/' . $format . '.php';
if (file_exists($mapperFileName))
require_once $mapperFileName;
}
if (class_exists($mapperClassName))
{
self::$mappers[$format] = new $mapperClassName();
return self::$mappers[$format];
}
throw new WideImage_UnsupportedFormatException("Format '{$format}' is not supported.");
}
static function registerMapper($mapper_class_name, $mime_type, $extension)
{
self::$customMappers[$mime_type] = $mapper_class_name;
self::$mimeTable[$mime_type] = $extension;
}
static function getCustomMappers()
{
return self::$customMappers;
}
static function determineFormat($uri, $format = null)
{
if ($format == null)
$format = self::extractExtension($uri);
// mime-type match
if (preg_match('~[a-z]*/[a-z-]*~i', $format))
if (isset(self::$mimeTable[strtolower($format)]))
{
return self::$mimeTable[strtolower($format)];
}
// clean the string
$format = strtoupper(preg_replace('/[^a-z0-9_-]/i', '', $format));
if ($format == 'JPG')
$format = 'JPEG';
return $format;
}
static function mimeType($format)
{
return array_search(strtoupper($format), self::$mimeTable);
}
static function extractExtension($uri)
{
$p = strrpos($uri, '.');
if ($p === false)
return '';
else
return substr($uri, $p + 1);
}
}
/**
* Thrown when image format isn't supported.
*/
class WideImage_UnsupportedFormatException extends WideImage_Exception
{
}
/**
* Mapper factory.
**/
abstract class WideImage_MapperFactory
{
protected static $mappers = [];
protected static $customMappers = [];
protected static $mimeTable = [
'image/jpg' => 'JPEG',
'image/jpeg' => 'JPEG',
'image/pjpeg' => 'JPEG',
'image/gif' => 'GIF',
'image/png' => 'PNG',
];
/**
* Returns a mapper, based on the $uri and $format.
*
* @param string $uri File URI
* @param string $format File format (extension or mime-type) or null
*
* @return WideImage_Mapper
**/
public static function selectMapper($uri, $format = null)
{
$format = self::determineFormat($uri, $format);
if (array_key_exists($format, self::$mappers)) {
return self::$mappers[$format];
}
$mapperClassName = 'WideImage_Mapper_'.$format;
if (!class_exists($mapperClassName, false)) {
$mapperFileName = WideImage::path().'Mapper/'.$format.'.php';
if (file_exists($mapperFileName)) {
require_once $mapperFileName;
}
}
if (class_exists($mapperClassName)) {
self::$mappers[$format] = new $mapperClassName();
return self::$mappers[$format];
}
throw new WideImage_UnsupportedFormatException("Format '{$format}' is not supported.");
}
public static function registerMapper($mapper_class_name, $mime_type, $extension)
{
self::$customMappers[$mime_type] = $mapper_class_name;
self::$mimeTable[$mime_type] = $extension;
}
public static function getCustomMappers()
{
return self::$customMappers;
}
public static function determineFormat($uri, $format = null)
{
if ($format == null) {
$format = self::extractExtension($uri);
}
// mime-type match
if (preg_match('~[a-z]*/[a-z-]*~i', $format)) {
if (isset(self::$mimeTable[strtolower($format)])) {
return self::$mimeTable[strtolower($format)];
}
}
// clean the string
$format = strtoupper(preg_replace('/[^a-z0-9_-]/i', '', $format));
if ($format == 'JPG') {
$format = 'JPEG';
}
return $format;
}
public static function mimeType($format)
{
return array_search(strtoupper($format), self::$mimeTable);
}
public static function extractExtension($uri)
{
$p = strrpos($uri, '.');
if ($p === false) {
return '';
} else {
return substr($uri, $p + 1);
}
}
}

296
public/filemanager/connectors/php/inc/wideimage/lib/Operation/AddNoise.php
View File

@@ -1,153 +1,145 @@
<?php
/**
* @author Tomasz Kapusta
* @copyright 2010
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* @package Internal/Operations
**/
/**
* Noise filter
*
* @package Internal/Operations
*/
class WideImage_Operation_AddNoise {
/**
* Returns image with noise added
*
* @param WideImage_Image $image
* @param float $amount
* @param const $type
* @param float $threshold
* @return WideImage_Image
*/
function execute($image, $amount, $type) {
switch ($type)
{
case 'salt&pepper' : $fun = 'saltPepperNoise_fun';
break;
case 'color' : $fun = 'colorNoise_fun';
break;
default : $fun = 'monoNoise_fun';
break;
}
return self::filter($image->asTrueColor(), $fun, $amount);
}
/**
* Returns image with every pixel changed by specififed function
*
* @param WideImage_Image $image
* @param str $function
* @param int $value
* @return WideImage_Image
*/
function filter($image, $function, $value)
{
for ($y = 0; $y < $image->getHeight(); $y++)
{
for ($x = 0; $x< $image->getWidth(); $x++)
{
$rgb = imagecolorat($image->getHandle(), $x, $y);
$a = ($rgb >> 24) & 0xFF;
$r = ($rgb >> 16) & 0xFF;
$g = ($rgb >> 8) & 0xFF;
$b = $rgb & 0xFF;
self::$function($r, $g, $b, $value);
$color = imagecolorallocatealpha($image->getHandle(), $r, $g, $b, $a);
imagesetpixel($image->getHandle(), $x, $y, $color);
}
}
return $image;
}
/**
* Adds color noise by altering given R,G,B values using specififed amount
*
* @param int $r
* @param int $g
* @param int $b
* @param int $value
* @return void
*/
function colorNoise_fun(&$r, &$g, &$b, $amount)
{
$r = self::byte($r + mt_rand(0, $amount) - ($amount >> 1) );
$g = self::byte($g + mt_rand(0, $amount) - ($amount >> 1) );
$b = self::byte($b + mt_rand(0, $amount) - ($amount >> 1) );
}
/**
* Adds mono noise by altering given R,G,B values using specififed amount
*
* @param int $r
* @param int $g
* @param int $b
* @param int $value
* @return void
*/
function monoNoise_fun(&$r, &$g, &$b, $amount)
{
$rand = mt_rand(0, $amount) - ($amount >> 1);
$r = self::byte($r + $rand);
$g = self::byte($g + $rand);
$b = self::byte($b + $rand);
}
/**
* Adds salt&pepper noise by altering given R,G,B values using specififed amount
*
* @param int $r
* @param int $g
* @param int $b
* @param int $value
* @return void
*/
function saltPepperNoise_fun(&$r, &$g, &$b, $amount)
{
if (mt_rand(0, 255 - $amount) != 0) return;
$rand = mt_rand(0, 1);
switch ($rand)
{
case 0 : $r = $g = $b = 0;
break;
case 1 : $r = $g = $b = 255;
break;
}
}
/**
* Returns value within (0,255)
*
* @param int $b
* @return int
*/
function byte($b)
{
if ($b > 255) return 255;
if ($b < 0) return 0;
return (int) $b;
}
}
/**
* @author Tomasz Kapusta
* @copyright 2010
**/
/**
* Noise filter.
*/
class WideImage_Operation_AddNoise
{
/**
* Returns image with noise added.
*
* @param WideImage_Image $image
* @param float $amount
* @param const $type
* @param float $threshold
*
* @return WideImage_Image
*/
public function execute($image, $amount, $type)
{
switch ($type) {
case 'salt&pepper': $fun = 'saltPepperNoise_fun';
break;
case 'color': $fun = 'colorNoise_fun';
break;
default: $fun = 'monoNoise_fun';
break;
}
return self::filter($image->asTrueColor(), $fun, $amount);
}
/**
* Returns image with every pixel changed by specififed function.
*
* @param WideImage_Image $image
* @param str $function
* @param int $value
*
* @return WideImage_Image
*/
public function filter($image, $function, $value)
{
for ($y = 0; $y < $image->getHeight(); $y++) {
for ($x = 0; $x < $image->getWidth(); $x++) {
$rgb = imagecolorat($image->getHandle(), $x, $y);
$a = ($rgb >> 24) & 0xFF;
$r = ($rgb >> 16) & 0xFF;
$g = ($rgb >> 8) & 0xFF;
$b = $rgb & 0xFF;
self::$function($r, $g, $b, $value);
$color = imagecolorallocatealpha($image->getHandle(), $r, $g, $b, $a);
imagesetpixel($image->getHandle(), $x, $y, $color);
}
}
return $image;
}
/**
* Adds color noise by altering given R,G,B values using specififed amount.
*
* @param int $r
* @param int $g
* @param int $b
* @param int $value
*
* @return void
*/
public function colorNoise_fun(&$r, &$g, &$b, $amount)
{
$r = self::byte($r + mt_rand(0, $amount) - ($amount >> 1));
$g = self::byte($g + mt_rand(0, $amount) - ($amount >> 1));
$b = self::byte($b + mt_rand(0, $amount) - ($amount >> 1));
}
/**
* Adds mono noise by altering given R,G,B values using specififed amount.
*
* @param int $r
* @param int $g
* @param int $b
* @param int $value
*
* @return void
*/
public function monoNoise_fun(&$r, &$g, &$b, $amount)
{
$rand = mt_rand(0, $amount) - ($amount >> 1);
$r = self::byte($r + $rand);
$g = self::byte($g + $rand);
$b = self::byte($b + $rand);
}
/**
* Adds salt&pepper noise by altering given R,G,B values using specififed amount.
*
* @param int $r
* @param int $g
* @param int $b
* @param int $value
*
* @return void
*/
public function saltPepperNoise_fun(&$r, &$g, &$b, $amount)
{
if (mt_rand(0, 255 - $amount) != 0) {
return;
}
$rand = mt_rand(0, 1);
switch ($rand) {
case 0: $r = $g = $b = 0;
break;
case 1: $r = $g = $b = 255;
break;
}
}
/**
* Returns value within (0,255).
*
* @param int $b
*
* @return int
*/
public function byte($b)
{
if ($b > 255) {
return 255;
}
if ($b < 0) {
return 0;
}
return (int) $b;
}
}

73
public/filemanager/connectors/php/inc/wideimage/lib/Operation/ApplyConvolution.php
View File

@@ -1,48 +1,31 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* ApplyConvolution operation class.
*/
class WideImage_Operation_ApplyConvolution
{
/**
* Executes imageconvolution() filter.
*
* @param WideImage_Image $image
* @param array $matrix
* @param numeric $div
* @param numeric $offset
*
* @return WideImage_Image
*/
public function execute($image, $matrix, $div, $offset)
{
$new = $image->asTrueColor();
if (!imageconvolution($new->getHandle(), $matrix, $div, $offset)) {
throw new WideImage_GDFunctionResultException('imageconvolution() returned false');
}
* @package Internal/Operations
**/
/**
* ApplyConvolution operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_ApplyConvolution
{
/**
* Executes imageconvolution() filter
*
* @param WideImage_Image $image
* @param array $matrix
* @param numeric $div
* @param numeric $offset
* @return WideImage_Image
*/
function execute($image, $matrix, $div, $offset)
{
$new = $image->asTrueColor();
if (!imageconvolution($new->getHandle(), $matrix, $div, $offset))
throw new WideImage_GDFunctionResultException("imageconvolution() returned false");
return $new;
}
}
return $new;
}
}

111
public/filemanager/connectors/php/inc/wideimage/lib/Operation/ApplyFilter.php
View File

@@ -1,67 +1,50 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* ApplyFilter operation class.
*/
class WideImage_Operation_ApplyFilter
{
/**
* A list of filters that only accept one arguments for imagefilter().
*
* @var array
*/
protected static $one_arg_filters = [IMG_FILTER_SMOOTH, IMG_FILTER_CONTRAST, IMG_FILTER_BRIGHTNESS];
* @package Internal/Operations
**/
/**
* ApplyFilter operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_ApplyFilter
{
/**
* A list of filters that only accept one arguments for imagefilter()
*
* @var array
*/
static protected $one_arg_filters = array(IMG_FILTER_SMOOTH, IMG_FILTER_CONTRAST, IMG_FILTER_BRIGHTNESS);
/**
* Executes imagefilter
*
* @param WideImage_Image $image
* @param int $filter
* @param numeric $arg1
* @param numeric $arg2
* @param numeric $arg3
* @return WideImage_TrueColorImage
*/
function execute($image, $filter, $arg1 = null, $arg2 = null, $arg3 = null, $arg4 = null)
{
$new = $image->asTrueColor();
if (in_array($filter, self::$one_arg_filters))
$res = imagefilter($new->getHandle(), $filter, $arg1);
elseif (defined('IMG_FILTER_PIXELATE') && $filter == IMG_FILTER_PIXELATE)
$res = imagefilter($new->getHandle(), $filter, $arg1, $arg2);
elseif ($filter == IMG_FILTER_COLORIZE)
$res = imagefilter($new->getHandle(), $filter, $arg1, $arg2, $arg3, $arg4);
else
$res = imagefilter($new->getHandle(), $filter);
if (!$res)
throw new WideImage_GDFunctionResultException("imagefilter() returned false");
return $new;
}
}
/**
* Executes imagefilter.
*
* @param WideImage_Image $image
* @param int $filter
* @param numeric $arg1
* @param numeric $arg2
* @param numeric $arg3
*
* @return WideImage_TrueColorImage
*/
public function execute($image, $filter, $arg1 = null, $arg2 = null, $arg3 = null, $arg4 = null)
{
$new = $image->asTrueColor();
if (in_array($filter, self::$one_arg_filters)) {
$res = imagefilter($new->getHandle(), $filter, $arg1);
} elseif (defined('IMG_FILTER_PIXELATE') && $filter == IMG_FILTER_PIXELATE) {
$res = imagefilter($new->getHandle(), $filter, $arg1, $arg2);
} elseif ($filter == IMG_FILTER_COLORIZE) {
$res = imagefilter($new->getHandle(), $filter, $arg1, $arg2, $arg3, $arg4);
} else {
$res = imagefilter($new->getHandle(), $filter);
}
if (!$res) {
throw new WideImage_GDFunctionResultException('imagefilter() returned false');
}
return $new;
}
}

181
public/filemanager/connectors/php/inc/wideimage/lib/Operation/ApplyMask.php
View File

@@ -1,105 +1,82 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* ApplyMask operation class.
*/
class WideImage_Operation_ApplyMask
{
/**
* Applies a mask on the copy of source image.
*
* @param WideImage_Image $image
* @param WideImage_Image $mask
* @param smart_coordinate $left
* @param smart_coordinate $top
*
* @return WideImage_Image
*/
public function execute($image, $mask, $left = 0, $top = 0)
{
$left = WideImage_Coordinate::fix($left, $image->getWidth(), $mask->getWidth());
$top = WideImage_Coordinate::fix($top, $image->getHeight(), $mask->getHeight());
* @package Internal/Operations
**/
/**
* ApplyMask operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_ApplyMask
{
/**
* Applies a mask on the copy of source image
*
* @param WideImage_Image $image
* @param WideImage_Image $mask
* @param smart_coordinate $left
* @param smart_coordinate $top
* @return WideImage_Image
*/
function execute($image, $mask, $left = 0, $top = 0)
{
$left = WideImage_Coordinate::fix($left, $image->getWidth(), $mask->getWidth());
$top = WideImage_Coordinate::fix($top, $image->getHeight(), $mask->getHeight());
$width = $image->getWidth();
$mask_width = $mask->getWidth();
$height = $image->getHeight();
$mask_height = $mask->getHeight();
$result = $image->asTrueColor();
$result->alphaBlending(false);
$result->saveAlpha(true);
$srcTransparentColor = $result->getTransparentColor();
if ($srcTransparentColor >= 0)
{
# this was here. works without.
#$trgb = $image->getColorRGB($srcTransparentColor);
#$trgb['alpha'] = 127;
#$destTransparentColor = $result->allocateColorAlpha($trgb);
#$result->setTransparentColor($destTransparentColor);
$destTransparentColor = $srcTransparentColor;
}
else
{
$destTransparentColor = $result->allocateColorAlpha(255, 255, 255, 127);
}
for ($x = 0; $x < $width; $x++)
for ($y = 0; $y < $height; $y++)
{
$mx = $x - $left;
$my = $y - $top;
if ($mx >= 0 && $mx < $mask_width && $my >= 0 && $my < $mask_height)
{
$srcColor = $image->getColorAt($x, $y);
if ($srcColor == $srcTransparentColor)
$destColor = $destTransparentColor;
else
{
$maskRGB = $mask->getRGBAt($mx, $my);
if ($maskRGB['red'] == 0)
$destColor = $destTransparentColor;
elseif ($srcColor >= 0)
{
$imageRGB = $image->getRGBAt($x, $y);
$level = ($maskRGB['red'] / 255) * (1 - $imageRGB['alpha'] / 127);
$imageRGB['alpha'] = 127 - round($level * 127);
if ($imageRGB['alpha'] == 127)
$destColor = $destTransparentColor;
else
$destColor = $result->allocateColorAlpha($imageRGB);
}
else
$destColor = $destTransparentColor;
}
$result->setColorAt($x, $y, $destColor);
}
}
return $result;
}
}
$width = $image->getWidth();
$mask_width = $mask->getWidth();
$height = $image->getHeight();
$mask_height = $mask->getHeight();
$result = $image->asTrueColor();
$result->alphaBlending(false);
$result->saveAlpha(true);
$srcTransparentColor = $result->getTransparentColor();
if ($srcTransparentColor >= 0) {
// this was here. works without.
//$trgb = $image->getColorRGB($srcTransparentColor);
//$trgb['alpha'] = 127;
//$destTransparentColor = $result->allocateColorAlpha($trgb);
//$result->setTransparentColor($destTransparentColor);
$destTransparentColor = $srcTransparentColor;
} else {
$destTransparentColor = $result->allocateColorAlpha(255, 255, 255, 127);
}
for ($x = 0; $x < $width; $x++) {
for ($y = 0; $y < $height; $y++) {
$mx = $x - $left;
$my = $y - $top;
if ($mx >= 0 && $mx < $mask_width && $my >= 0 && $my < $mask_height) {
$srcColor = $image->getColorAt($x, $y);
if ($srcColor == $srcTransparentColor) {
$destColor = $destTransparentColor;
} else {
$maskRGB = $mask->getRGBAt($mx, $my);
if ($maskRGB['red'] == 0) {
$destColor = $destTransparentColor;
} elseif ($srcColor >= 0) {
$imageRGB = $image->getRGBAt($x, $y);
$level = ($maskRGB['red'] / 255) * (1 - $imageRGB['alpha'] / 127);
$imageRGB['alpha'] = 127 - round($level * 127);
if ($imageRGB['alpha'] == 127) {
$destColor = $destTransparentColor;
} else {
$destColor = $result->allocateColorAlpha($imageRGB);
}
} else {
$destColor = $destTransparentColor;
}
}
$result->setColorAt($x, $y, $destColor);
}
}
}
return $result;
}
}

75
public/filemanager/connectors/php/inc/wideimage/lib/Operation/AsGrayscale.php
View File

@@ -1,49 +1,32 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* AsGrayscale operation class.
*/
class WideImage_Operation_AsGrayscale
{
/**
* Returns a greyscale copy of an image.
*
* @param WideImage_Image $image
*
* @return WideImage_Image
*/
public function execute($image)
{
$new = $image->asTrueColor();
if (!imagefilter($new->getHandle(), IMG_FILTER_GRAYSCALE)) {
throw new WideImage_GDFunctionResultException('imagefilter() returned false');
}
* @package Internal/Operations
**/
/**
* AsGrayscale operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_AsGrayscale
{
/**
* Returns a greyscale copy of an image
*
* @param WideImage_Image $image
* @return WideImage_Image
*/
function execute($image)
{
$new = $image->asTrueColor();
if (!imagefilter($new->getHandle(), IMG_FILTER_GRAYSCALE))
throw new WideImage_GDFunctionResultException("imagefilter() returned false");
if (!$image->isTrueColor())
$new = $new->asPalette();
return $new;
}
}
if (!$image->isTrueColor()) {
$new = $new->asPalette();
}
return $new;
}
}

102
public/filemanager/connectors/php/inc/wideimage/lib/Operation/AsNegative.php
View File

@@ -1,63 +1,45 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* AsNegative operation class.
*/
class WideImage_Operation_AsNegative
{
/**
* Returns a greyscale copy of an image.
*
* @param WideImage_Image $image
*
* @return WideImage_Image
*/
public function execute($image)
{
$palette = !$image->isTrueColor();
$transparent = $image->isTransparent();
* @package Internal/Operations
**/
/**
* AsNegative operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_AsNegative
{
/**
* Returns a greyscale copy of an image
*
* @param WideImage_Image $image
* @return WideImage_Image
*/
function execute($image)
{
$palette = !$image->isTrueColor();
$transparent = $image->isTransparent();
if ($palette && $transparent)
$tcrgb = $image->getTransparentColorRGB();
$new = $image->asTrueColor();
if (!imagefilter($new->getHandle(), IMG_FILTER_NEGATE))
throw new WideImage_GDFunctionResultException("imagefilter() returned false");
if ($palette)
{
$new = $new->asPalette();
if ($transparent)
{
$irgb = array('red' => 255 - $tcrgb['red'], 'green' => 255 - $tcrgb['green'], 'blue' => 255 - $tcrgb['blue'], 'alpha' => 127);
// needs imagecolorexactalpha instead of imagecolorexact, otherwise doesn't work on some transparent GIF images
$new_tci = imagecolorexactalpha($new->getHandle(), $irgb['red'], $irgb['green'], $irgb['blue'], 127);
$new->setTransparentColor($new_tci);
}
}
return $new;
}
}
if ($palette && $transparent) {
$tcrgb = $image->getTransparentColorRGB();
}
$new = $image->asTrueColor();
if (!imagefilter($new->getHandle(), IMG_FILTER_NEGATE)) {
throw new WideImage_GDFunctionResultException('imagefilter() returned false');
}
if ($palette) {
$new = $new->asPalette();
if ($transparent) {
$irgb = ['red' => 255 - $tcrgb['red'], 'green' => 255 - $tcrgb['green'], 'blue' => 255 - $tcrgb['blue'], 'alpha' => 127];
// needs imagecolorexactalpha instead of imagecolorexact, otherwise doesn't work on some transparent GIF images
$new_tci = imagecolorexactalpha($new->getHandle(), $irgb['red'], $irgb['green'], $irgb['blue'], 127);
$new->setTransparentColor($new_tci);
}
}
return $new;
}
}

289
public/filemanager/connectors/php/inc/wideimage/lib/Operation/AutoCrop.php
View File

@@ -1,162 +1,133 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* AutoCrop operation.
*/
class WideImage_Operation_AutoCrop
{
/**
* Executes the auto-crop operation on the $img.
*
* @param WideImage_Image $img
* @param int $rgb_threshold The difference in RGB from $base_color
* @param int $pixel_cutoff The number of pixels on each border that must be over $rgb_threshold
* @param int $base_color The color that will get cropped
*
* @return WideImage_Image resulting auto-cropped image
*/
public function execute($img, $margin, $rgb_threshold, $pixel_cutoff, $base_color)
{
$margin = intval($margin);
* @package Internal/Operations
**/
/**
* AutoCrop operation
*
* @package Internal/Operations
*/
class WideImage_Operation_AutoCrop
{
/**
* Executes the auto-crop operation on the $img
*
* @param WideImage_Image $img
* @param int $rgb_threshold The difference in RGB from $base_color
* @param int $pixel_cutoff The number of pixels on each border that must be over $rgb_threshold
* @param int $base_color The color that will get cropped
* @return WideImage_Image resulting auto-cropped image
*/
function execute($img, $margin, $rgb_threshold, $pixel_cutoff, $base_color)
{
$margin = intval($margin);
$rgb_threshold = intval($rgb_threshold);
if ($rgb_threshold < 0)
$rgb_threshold = 0;
$pixel_cutoff = intval($pixel_cutoff);
if ($pixel_cutoff <= 1)
$pixel_cutoff = 1;
if ($base_color === null)
$rgb_base = $img->getRGBAt(0, 0);
else
{
if ($base_color < 0)
return $img->copy();
$rgb_base = $img->getColorRGB($base_color);
}
$cut_rect = array('left' => 0, 'top' => 0, 'right' => $img->getWidth() - 1, 'bottom' => $img->getHeight() - 1);
for ($y = 0; $y <= $cut_rect['bottom']; $y++)
{
$count = 0;
for ($x = 0; $x <= $cut_rect['right']; $x++)
{
$rgb = $img->getRGBAt($x, $y);
$diff = abs($rgb['red'] - $rgb_base['red']) + abs($rgb['green'] - $rgb_base['green']) + abs($rgb['blue'] - $rgb_base['blue']);
if ($diff > $rgb_threshold)
{
$count++;
if ($count >= $pixel_cutoff)
{
$cut_rect['top'] = $y;
break 2;
}
}
}
}
for ($y = $img->getHeight() - 1; $y >= $cut_rect['top']; $y--)
{
$count = 0;
for ($x = 0; $x <= $cut_rect['right']; $x++)
{
$rgb = $img->getRGBAt($x, $y);
$diff = abs($rgb['red'] - $rgb_base['red']) + abs($rgb['green'] - $rgb_base['green']) + abs($rgb['blue'] - $rgb_base['blue']);
if ($diff > $rgb_threshold)
{
$count++;
if ($count >= $pixel_cutoff)
{
$cut_rect['bottom'] = $y;
break 2;
}
}
}
}
for ($x = 0; $x <= $cut_rect['right']; $x++)
{
$count = 0;
for ($y = $cut_rect['top']; $y <= $cut_rect['bottom']; $y++)
{
$rgb = $img->getRGBAt($x, $y);
$diff = abs($rgb['red'] - $rgb_base['red']) + abs($rgb['green'] - $rgb_base['green']) + abs($rgb['blue'] - $rgb_base['blue']);
if ($diff > $rgb_threshold)
{
$count++;
if ($count >= $pixel_cutoff)
{
$cut_rect['left'] = $x;
break 2;
}
}
}
}
for ($x = $cut_rect['right']; $x >= $cut_rect['left']; $x--)
{
$count = 0;
for ($y = $cut_rect['top']; $y <= $cut_rect['bottom']; $y++)
{
$rgb = $img->getRGBAt($x, $y);
$diff = abs($rgb['red'] - $rgb_base['red']) + abs($rgb['green'] - $rgb_base['green']) + abs($rgb['blue'] - $rgb_base['blue']);
if ($diff > $rgb_threshold)
{
$count++;
if ($count >= $pixel_cutoff)
{
$cut_rect['right'] = $x;
break 2;
}
}
}
}
$cut_rect = array(
'left' => $cut_rect['left'] - $margin,
'top' => $cut_rect['top'] - $margin,
'right' => $cut_rect['right'] + $margin,
'bottom' => $cut_rect['bottom'] + $margin
);
if ($cut_rect['left'] < 0)
$cut_rect['left'] = 0;
if ($cut_rect['top'] < 0)
$cut_rect['top'] = 0;
if ($cut_rect['right'] >= $img->getWidth())
$cut_rect['right'] = $img->getWidth() - 1;
if ($cut_rect['bottom'] >= $img->getHeight())
$cut_rect['bottom'] = $img->getHeight() - 1;
return $img->crop($cut_rect['left'], $cut_rect['top'], $cut_rect['right'] - $cut_rect['left'] + 1, $cut_rect['bottom'] - $cut_rect['top'] + 1);
}
}
$rgb_threshold = intval($rgb_threshold);
if ($rgb_threshold < 0) {
$rgb_threshold = 0;
}
$pixel_cutoff = intval($pixel_cutoff);
if ($pixel_cutoff <= 1) {
$pixel_cutoff = 1;
}
if ($base_color === null) {
$rgb_base = $img->getRGBAt(0, 0);
} else {
if ($base_color < 0) {
return $img->copy();
}
$rgb_base = $img->getColorRGB($base_color);
}
$cut_rect = ['left' => 0, 'top' => 0, 'right' => $img->getWidth() - 1, 'bottom' => $img->getHeight() - 1];
for ($y = 0; $y <= $cut_rect['bottom']; $y++) {
$count = 0;
for ($x = 0; $x <= $cut_rect['right']; $x++) {
$rgb = $img->getRGBAt($x, $y);
$diff = abs($rgb['red'] - $rgb_base['red']) + abs($rgb['green'] - $rgb_base['green']) + abs($rgb['blue'] - $rgb_base['blue']);
if ($diff > $rgb_threshold) {
$count++;
if ($count >= $pixel_cutoff) {
$cut_rect['top'] = $y;
break 2;
}
}
}
}
for ($y = $img->getHeight() - 1; $y >= $cut_rect['top']; $y--) {
$count = 0;
for ($x = 0; $x <= $cut_rect['right']; $x++) {
$rgb = $img->getRGBAt($x, $y);
$diff = abs($rgb['red'] - $rgb_base['red']) + abs($rgb['green'] - $rgb_base['green']) + abs($rgb['blue'] - $rgb_base['blue']);
if ($diff > $rgb_threshold) {
$count++;
if ($count >= $pixel_cutoff) {
$cut_rect['bottom'] = $y;
break 2;
}
}
}
}
for ($x = 0; $x <= $cut_rect['right']; $x++) {
$count = 0;
for ($y = $cut_rect['top']; $y <= $cut_rect['bottom']; $y++) {
$rgb = $img->getRGBAt($x, $y);
$diff = abs($rgb['red'] - $rgb_base['red']) + abs($rgb['green'] - $rgb_base['green']) + abs($rgb['blue'] - $rgb_base['blue']);
if ($diff > $rgb_threshold) {
$count++;
if ($count >= $pixel_cutoff) {
$cut_rect['left'] = $x;
break 2;
}
}
}
}
for ($x = $cut_rect['right']; $x >= $cut_rect['left']; $x--) {
$count = 0;
for ($y = $cut_rect['top']; $y <= $cut_rect['bottom']; $y++) {
$rgb = $img->getRGBAt($x, $y);
$diff = abs($rgb['red'] - $rgb_base['red']) + abs($rgb['green'] - $rgb_base['green']) + abs($rgb['blue'] - $rgb_base['blue']);
if ($diff > $rgb_threshold) {
$count++;
if ($count >= $pixel_cutoff) {
$cut_rect['right'] = $x;
break 2;
}
}
}
}
$cut_rect = [
'left' => $cut_rect['left'] - $margin,
'top' => $cut_rect['top'] - $margin,
'right' => $cut_rect['right'] + $margin,
'bottom' => $cut_rect['bottom'] + $margin,
];
if ($cut_rect['left'] < 0) {
$cut_rect['left'] = 0;
}
if ($cut_rect['top'] < 0) {
$cut_rect['top'] = 0;
}
if ($cut_rect['right'] >= $img->getWidth()) {
$cut_rect['right'] = $img->getWidth() - 1;
}
if ($cut_rect['bottom'] >= $img->getHeight()) {
$cut_rect['bottom'] = $img->getHeight() - 1;
}
return $img->crop($cut_rect['left'], $cut_rect['top'], $cut_rect['right'] - $cut_rect['left'] + 1, $cut_rect['bottom'] - $cut_rect['top'] + 1);
}
}

155
public/filemanager/connectors/php/inc/wideimage/lib/Operation/CopyChannelsPalette.php
View File

@@ -1,90 +1,71 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* CopyChannelsPalette operation class.
*
* This operation is intended to be used on palette images
*/
class WideImage_Operation_CopyChannelsPalette
{
/**
* Returns an image with only specified channels copied.
*
* @param WideImage_PaletteImage $img
* @param array $channels
*
* @return WideImage_PaletteImage
*/
public function execute($img, $channels)
{
$blank = ['red' => 0, 'green' => 0, 'blue' => 0];
if (isset($channels['alpha'])) {
unset($channels['alpha']);
}
* @package Internal/Operations
**/
/**
* CopyChannelsPalette operation class
*
* This operation is intended to be used on palette images
*
* @package Internal/Operations
*/
class WideImage_Operation_CopyChannelsPalette
{
/**
* Returns an image with only specified channels copied
*
* @param WideImage_PaletteImage $img
* @param array $channels
* @return WideImage_PaletteImage
*/
function execute($img, $channels)
{
$blank = array('red' => 0, 'green' => 0, 'blue' => 0);
if (isset($channels['alpha']))
unset($channels['alpha']);
$width = $img->getWidth();
$height = $img->getHeight();
$copy = WideImage_PaletteImage::create($width, $height);
if ($img->isTransparent())
{
$otci = $img->getTransparentColor();
$TRGB = $img->getColorRGB($otci);
$tci = $copy->allocateColor($TRGB);
}
else
{
$otci = null;
$tci = null;
}
for ($x = 0; $x < $width; $x++)
for ($y = 0; $y < $height; $y++)
{
$ci = $img->getColorAt($x, $y);
if ($ci === $otci)
{
$copy->setColorAt($x, $y, $tci);
continue;
}
$RGB = $img->getColorRGB($ci);
$newRGB = $blank;
foreach ($channels as $channel)
$newRGB[$channel] = $RGB[$channel];
$color = $copy->getExactColor($newRGB);
if ($color == -1)
$color = $copy->allocateColor($newRGB);
$copy->setColorAt($x, $y, $color);
}
if ($img->isTransparent())
$copy->setTransparentColor($tci);
return $copy;
}
}
$width = $img->getWidth();
$height = $img->getHeight();
$copy = WideImage_PaletteImage::create($width, $height);
if ($img->isTransparent()) {
$otci = $img->getTransparentColor();
$TRGB = $img->getColorRGB($otci);
$tci = $copy->allocateColor($TRGB);
} else {
$otci = null;
$tci = null;
}
for ($x = 0; $x < $width; $x++) {
for ($y = 0; $y < $height; $y++) {
$ci = $img->getColorAt($x, $y);
if ($ci === $otci) {
$copy->setColorAt($x, $y, $tci);
continue;
}
$RGB = $img->getColorRGB($ci);
$newRGB = $blank;
foreach ($channels as $channel) {
$newRGB[$channel] = $RGB[$channel];
}
$color = $copy->getExactColor($newRGB);
if ($color == -1) {
$color = $copy->allocateColor($newRGB);
}
$copy->setColorAt($x, $y, $color);
}
}
if ($img->isTransparent()) {
$copy->setTransparentColor($tci);
}
return $copy;
}
}

112
public/filemanager/connectors/php/inc/wideimage/lib/Operation/CopyChannelsTrueColor.php
View File

@@ -1,67 +1,51 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* CopyChannelsTrueColor operation class.
*
* Used to perform CopyChannels operation on truecolor images
*/
class WideImage_Operation_CopyChannelsTrueColor
{
/**
* Returns an image with only specified channels copied.
*
* @param WideImage_Image $img
* @param array $channels
*
* @return WideImage_Image
*/
public function execute($img, $channels)
{
$blank = ['red' => 0, 'green' => 0, 'blue' => 0, 'alpha' => 0];
* @package Internal/Operations
**/
/**
* CopyChannelsTrueColor operation class
*
* Used to perform CopyChannels operation on truecolor images
*
* @package Internal/Operations
*/
class WideImage_Operation_CopyChannelsTrueColor
{
/**
* Returns an image with only specified channels copied
*
* @param WideImage_Image $img
* @param array $channels
* @return WideImage_Image
*/
function execute($img, $channels)
{
$blank = array('red' => 0, 'green' => 0, 'blue' => 0, 'alpha' => 0);
$width = $img->getWidth();
$height = $img->getHeight();
$copy = WideImage_TrueColorImage::create($width, $height);
if (count($channels) > 0)
for ($x = 0; $x < $width; $x++)
for ($y = 0; $y < $height; $y++)
{
$RGBA = $img->getRGBAt($x, $y);
$newRGBA = $blank;
foreach ($channels as $channel)
$newRGBA[$channel] = $RGBA[$channel];
$color = $copy->getExactColorAlpha($newRGBA);
if ($color == -1)
$color = $copy->allocateColorAlpha($newRGBA);
$copy->setColorAt($x, $y, $color);
}
return $copy;
}
}
$width = $img->getWidth();
$height = $img->getHeight();
$copy = WideImage_TrueColorImage::create($width, $height);
if (count($channels) > 0) {
for ($x = 0; $x < $width; $x++) {
for ($y = 0; $y < $height; $y++) {
$RGBA = $img->getRGBAt($x, $y);
$newRGBA = $blank;
foreach ($channels as $channel) {
$newRGBA[$channel] = $RGBA[$channel];
}
$color = $copy->getExactColorAlpha($newRGBA);
if ($color == -1) {
$color = $copy->allocateColorAlpha($newRGBA);
}
$copy->setColorAt($x, $y, $color);
}
}
}
return $copy;
}
}

72
public/filemanager/connectors/php/inc/wideimage/lib/Operation/CorrectGamma.php
View File

@@ -1,48 +1,30 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* CorrectGamma operation class.
*/
class WideImage_Operation_CorrectGamma
{
/**
* Executes imagegammacorrect().
*
* @param WideImage_Image $image
* @param numeric $input_gamma
* @param numeric $output_gamma
*
* @return WideImage_TrueColorImage
*/
public function execute($image, $input_gamma, $output_gamma)
{
$new = $image->copy();
if (!imagegammacorrect($new->getHandle(), $input_gamma, $output_gamma)) {
throw new WideImage_GDFunctionResultException('imagegammacorrect() returned false');
}
* @package Internal/Operations
**/
/**
* CorrectGamma operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_CorrectGamma
{
/**
* Executes imagegammacorrect()
*
* @param WideImage_Image $image
* @param numeric $input_gamma
* @param numeric $output_gamma
* @return WideImage_TrueColorImage
*/
function execute($image, $input_gamma, $output_gamma)
{
$new = $image->copy();
if (!imagegammacorrect($new->getHandle(), $input_gamma, $output_gamma))
throw new WideImage_GDFunctionResultException("imagegammacorrect() returned false");
return $new;
}
}
return $new;
}
}

148
public/filemanager/connectors/php/inc/wideimage/lib/Operation/Crop.php
View File

@@ -1,86 +1,68 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Crop operation class.
*/
class WideImage_Operation_Crop
{
/**
* Returns a cropped image.
*
* @param WideImage_Image $img
* @param smart_coordinate $left
* @param smart_coordinate $top
* @param smart_coordinate $width
* @param smart_coordinate $height
*
* @return WideImage_Image
*/
public function execute($img, $left, $top, $width, $height)
{
$width = WideImage_Coordinate::fix($width, $img->getWidth(), $width);
$height = WideImage_Coordinate::fix($height, $img->getHeight(), $height);
$left = WideImage_Coordinate::fix($left, $img->getWidth(), $width);
$top = WideImage_Coordinate::fix($top, $img->getHeight(), $height);
if ($left < 0) {
$width = $left + $width;
$left = 0;
}
* @package Internal/Operations
**/
/**
* Crop operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_Crop
{
/**
* Returns a cropped image
*
* @param WideImage_Image $img
* @param smart_coordinate $left
* @param smart_coordinate $top
* @param smart_coordinate $width
* @param smart_coordinate $height
* @return WideImage_Image
*/
function execute($img, $left, $top, $width, $height)
{
$width = WideImage_Coordinate::fix($width, $img->getWidth(), $width);
$height = WideImage_Coordinate::fix($height, $img->getHeight(), $height);
$left = WideImage_Coordinate::fix($left, $img->getWidth(), $width);
$top = WideImage_Coordinate::fix($top, $img->getHeight(), $height);
if ($left < 0)
{
$width = $left + $width;
$left = 0;
}
if ($width > $img->getWidth() - $left)
$width = $img->getWidth() - $left;
if ($top < 0)
{
$height = $top + $height;
$top = 0;
}
if ($height > $img->getHeight() - $top)
$height = $img->getHeight() - $top;
if ($width <= 0 || $height <= 0)
throw new WideImage_Exception("Can't crop outside of an image.");
$new = $img->doCreate($width, $height);
if ($img->isTransparent() || $img instanceof WideImage_PaletteImage)
{
$new->copyTransparencyFrom($img);
if (!imagecopyresized($new->getHandle(), $img->getHandle(), 0, 0, $left, $top, $width, $height, $width, $height))
throw new WideImage_GDFunctionResultException("imagecopyresized() returned false");
}
else
{
$new->alphaBlending(false);
$new->saveAlpha(true);
if (!imagecopyresampled($new->getHandle(), $img->getHandle(), 0, 0, $left, $top, $width, $height, $width, $height))
throw new WideImage_GDFunctionResultException("imagecopyresampled() returned false");
}
return $new;
}
}
if ($width > $img->getWidth() - $left) {
$width = $img->getWidth() - $left;
}
if ($top < 0) {
$height = $top + $height;
$top = 0;
}
if ($height > $img->getHeight() - $top) {
$height = $img->getHeight() - $top;
}
if ($width <= 0 || $height <= 0) {
throw new WideImage_Exception("Can't crop outside of an image.");
}
$new = $img->doCreate($width, $height);
if ($img->isTransparent() || $img instanceof WideImage_PaletteImage) {
$new->copyTransparencyFrom($img);
if (!imagecopyresized($new->getHandle(), $img->getHandle(), 0, 0, $left, $top, $width, $height, $width, $height)) {
throw new WideImage_GDFunctionResultException('imagecopyresized() returned false');
}
} else {
$new->alphaBlending(false);
$new->saveAlpha(true);
if (!imagecopyresampled($new->getHandle(), $img->getHandle(), 0, 0, $left, $top, $width, $height, $width, $height)) {
throw new WideImage_GDFunctionResultException('imagecopyresampled() returned false');
}
}
return $new;
}
}

86
public/filemanager/connectors/php/inc/wideimage/lib/Operation/Flip.php
View File

@@ -1,54 +1,38 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Flip operation class.
*/
class WideImage_Operation_Flip
{
/**
* Returns a flipped image.
*
* @param WideImage_Image $image
*
* @return WideImage_Image
*/
public function execute($image)
{
$new = $image->copy();
* @package Internal/Operations
**/
/**
* Flip operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_Flip
{
/**
* Returns a flipped image
*
* @param WideImage_Image $image
* @return WideImage_Image
*/
function execute($image)
{
$new = $image->copy();
$width = $image->getWidth();
$height = $image->getHeight();
if ($new->isTransparent())
imagefilledrectangle($new->getHandle(), 0, 0, $width, $height, $new->getTransparentColor());
for ($y = 0; $y < $height; $y++)
if (!imagecopy($new->getHandle(), $image->getHandle(), 0, $y, 0, $height - $y - 1, $width, 1))
throw new WideImage_GDFunctionResultException("imagecopy() returned false");
return $new;
}
}
$width = $image->getWidth();
$height = $image->getHeight();
if ($new->isTransparent()) {
imagefilledrectangle($new->getHandle(), 0, 0, $width, $height, $new->getTransparentColor());
}
for ($y = 0; $y < $height; $y++) {
if (!imagecopy($new->getHandle(), $image->getHandle(), 0, $y, 0, $height - $y - 1, $width, 1)) {
throw new WideImage_GDFunctionResultException('imagecopy() returned false');
}
}
return $new;
}
}

114
public/filemanager/connectors/php/inc/wideimage/lib/Operation/GetMask.php
View File

@@ -1,67 +1,51 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* @package Internal/Operations
**/
/**
* GetMask operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_GetMask
{
/**
* Returns a mask
*
* @param WideImage_Image $image
* @return WideImage_Image
*/
function execute($image)
{
$width = $image->getWidth();
$height = $image->getHeight();
$mask = WideImage_TrueColorImage::create($width, $height);
$mask->setTransparentColor(-1);
$mask->alphaBlending(false);
$mask->saveAlpha(false);
for ($i = 0; $i <= 255; $i++)
$greyscale[$i] = ImageColorAllocate($mask->getHandle(), $i, $i, $i);
imagefilledrectangle($mask->getHandle(), 0, 0, $width, $height, $greyscale[255]);
$transparentColor = $image->getTransparentColor();
$alphaToGreyRatio = 255 / 127;
for ($x = 0; $x < $width; $x++)
for ($y = 0; $y < $height; $y++)
{
$color = $image->getColorAt($x, $y);
if ($color == $transparentColor)
$rgba['alpha'] = 127;
else
$rgba = $image->getColorRGB($color);
imagesetpixel($mask->getHandle(), $x, $y, $greyscale[255 - round($rgba['alpha'] * $alphaToGreyRatio)]);
}
return $mask;
}
}
/**
* GetMask operation class.
*/
class WideImage_Operation_GetMask
{
/**
* Returns a mask.
*
* @param WideImage_Image $image
*
* @return WideImage_Image
*/
public function execute($image)
{
$width = $image->getWidth();
$height = $image->getHeight();
$mask = WideImage_TrueColorImage::create($width, $height);
$mask->setTransparentColor(-1);
$mask->alphaBlending(false);
$mask->saveAlpha(false);
for ($i = 0; $i <= 255; $i++) {
$greyscale[$i] = imagecolorallocate($mask->getHandle(), $i, $i, $i);
}
imagefilledrectangle($mask->getHandle(), 0, 0, $width, $height, $greyscale[255]);
$transparentColor = $image->getTransparentColor();
$alphaToGreyRatio = 255 / 127;
for ($x = 0; $x < $width; $x++) {
for ($y = 0; $y < $height; $y++) {
$color = $image->getColorAt($x, $y);
if ($color == $transparentColor) {
$rgba['alpha'] = 127;
} else {
$rgba = $image->getColorRGB($color);
}
imagesetpixel($mask->getHandle(), $x, $y, $greyscale[255 - round($rgba['alpha'] * $alphaToGreyRatio)]);
}
}
return $mask;
}
}

131
public/filemanager/connectors/php/inc/wideimage/lib/Operation/Merge.php
View File

@@ -1,78 +1,59 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Merge operation class.
*/
class WideImage_Operation_Merge
{
/**
* Returns a merged image.
*
* @param WideImage_Image $base
* @param WideImage_Image $overlay
* @param smart_coordinate $left
* @param smart_coordinate $top
* @param numeric $pct
*
* @return WideImage_Image
*/
public function execute($base, $overlay, $left, $top, $pct)
{
$x = WideImage_Coordinate::fix($left, $base->getWidth(), $overlay->getWidth());
$y = WideImage_Coordinate::fix($top, $base->getHeight(), $overlay->getHeight());
* @package Internal/Operations
**/
/**
* Merge operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_Merge
{
/**
* Returns a merged image
*
* @param WideImage_Image $base
* @param WideImage_Image $overlay
* @param smart_coordinate $left
* @param smart_coordinate $top
* @param numeric $pct
* @return WideImage_Image
*/
function execute($base, $overlay, $left, $top, $pct)
{
$x = WideImage_Coordinate::fix($left, $base->getWidth(), $overlay->getWidth());
$y = WideImage_Coordinate::fix($top, $base->getHeight(), $overlay->getHeight());
$result = $base->asTrueColor();
$result->alphaBlending(true);
$result->saveAlpha(true);
if ($pct <= 0)
return $result;
if ($pct < 100)
{
if (!imagecopymerge(
$result->getHandle(),
$overlay->getHandle(),
$x, $y, 0, 0,
$overlay->getWidth(),
$overlay->getHeight(),
$pct))
throw new WideImage_GDFunctionResultException("imagecopymerge() returned false");
}
else
{
if (!imagecopy(
$result->getHandle(),
$overlay->getHandle(),
$x, $y, 0, 0,
$overlay->getWidth(),
$overlay->getHeight()))
throw new WideImage_GDFunctionResultException("imagecopy() returned false");
}
return $result;
}
}
$result = $base->asTrueColor();
$result->alphaBlending(true);
$result->saveAlpha(true);
if ($pct <= 0) {
return $result;
}
if ($pct < 100) {
if (!imagecopymerge(
$result->getHandle(),
$overlay->getHandle(),
$x, $y, 0, 0,
$overlay->getWidth(),
$overlay->getHeight(),
$pct)) {
throw new WideImage_GDFunctionResultException('imagecopymerge() returned false');
}
} else {
if (!imagecopy(
$result->getHandle(),
$overlay->getHandle(),
$x, $y, 0, 0,
$overlay->getWidth(),
$overlay->getHeight())) {
throw new WideImage_GDFunctionResultException('imagecopy() returned false');
}
}
return $result;
}
}

87
public/filemanager/connectors/php/inc/wideimage/lib/Operation/Mirror.php
View File

@@ -1,55 +1,38 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Mirror operation class.
*/
class WideImage_Operation_Mirror
{
/**
* Returns a mirrored image.
*
* @param WideImage_Image $image
*
* @return WideImage_Image
*/
public function execute($image)
{
$new = $image->copy();
* @package Internal/Operations
**/
/**
* Mirror operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_Mirror
{
/**
* Returns a mirrored image
*
* @param WideImage_Image $image
* @return WideImage_Image
*/
function execute($image)
{
$new = $image->copy();
$width = $image->getWidth();
$height = $image->getHeight();
if ($new->isTransparent())
imagefilledrectangle($new->getHandle(), 0, 0, $width, $height, $new->getTransparentColor());
for ($x = 0; $x < $width; $x++)
{
if (!imagecopy($new->getHandle(), $image->getHandle(), $x, 0, $width - $x - 1, 0, 1, $height))
throw new WideImage_GDFunctionResultException("imagecopy() returned false");
}
return $new;
}
}
$width = $image->getWidth();
$height = $image->getHeight();
if ($new->isTransparent()) {
imagefilledrectangle($new->getHandle(), 0, 0, $width, $height, $new->getTransparentColor());
}
for ($x = 0; $x < $width; $x++) {
if (!imagecopy($new->getHandle(), $image->getHandle(), $x, 0, $width - $x - 1, 0, 1, $height)) {
throw new WideImage_GDFunctionResultException('imagecopy() returned false');
}
}
return $new;
}
}

295
public/filemanager/connectors/php/inc/wideimage/lib/Operation/Resize.php
View File

@@ -1,157 +1,144 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* An Exception for when an invalid fit method is passed.
*/
class WideImage_Operation_InvalidFitMethodException extends WideImage_Exception
{
}
/**
* An Exception for when an invalid resize dimensions are passed.
*/
class WideImage_Operation_InvalidResizeDimensionException extends WideImage_Exception
{
}
* @package Internal/Operations
**/
/**
* An Exception for when an invalid fit method is passed
*
* @package Internal/Operations
*/
class WideImage_Operation_InvalidFitMethodException extends WideImage_Exception {}
/**
* An Exception for when an invalid resize dimensions are passed
*
* @package Internal/Operations
*/
class WideImage_Operation_InvalidResizeDimensionException extends WideImage_Exception {}
/**
* Resize operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_Resize
{
/**
* Prepares and corrects smart coordinates
*
* @param WideImage_Image $img
* @param smart_coordinate $width
* @param smart_coordinate $height
* @param string $fit
* @return array
*/
protected function prepareDimensions($img, $width, $height, $fit)
{
if ($width === null && $height === null)
{
$width = $img->getWidth();
$height = $img->getHeight();
}
if ($width !== null)
$width = WideImage_Coordinate::fix($width, $img->getWidth());
if ($height !== null)
$height = WideImage_Coordinate::fix($height, $img->getHeight());
if ($width === null)
$width = floor($img->getWidth() * $height / $img->getHeight());
if ($height === null)
$height = floor($img->getHeight() * $width / $img->getWidth());
if ($width === 0 || $height === 0)
return array('width' => 0, 'height' => 0);
if ($fit == null)
$fit = 'inside';
$dim = array();
if ($fit == 'fill')
{
$dim['width'] = $width;
$dim['height'] = $height;
}
elseif ($fit == 'inside' || $fit == 'outside')
{
$rx = $img->getWidth() / $width;
$ry = $img->getHeight() / $height;
if ($fit == 'inside')
$ratio = ($rx > $ry) ? $rx : $ry;
else
$ratio = ($rx < $ry) ? $rx : $ry;
$dim['width'] = round($img->getWidth() / $ratio);
$dim['height'] = round($img->getHeight() / $ratio);
}
else
throw new WideImage_Operation_InvalidFitMethodException("{$fit} is not a valid resize-fit method.");
return $dim;
}
/**
* Returns a resized image
*
* @param WideImage_Image $img
* @param smart_coordinate $width
* @param smart_coordinate $height
* @param string $fit
* @param string $scale
* @return WideImage_Image
*/
function execute($img, $width, $height, $fit, $scale)
{
$dim = $this->prepareDimensions($img, $width, $height, $fit);
if (($scale === 'down' && ($dim['width'] >= $img->getWidth() && $dim['height'] >= $img->getHeight())) ||
($scale === 'up' && ($dim['width'] <= $img->getWidth() && $dim['height'] <= $img->getHeight())))
$dim = array('width' => $img->getWidth(), 'height' => $img->getHeight());
if ($dim['width'] <= 0 || $dim['height'] <= 0)
throw new WideImage_Operation_InvalidResizeDimensionException("Both dimensions must be larger than 0.");
if ($img->isTransparent() || $img instanceof WideImage_PaletteImage)
{
$new = WideImage_PaletteImage::create($dim['width'], $dim['height']);
$new->copyTransparencyFrom($img);
if (!imagecopyresized(
$new->getHandle(),
$img->getHandle(),
0, 0, 0, 0,
$new->getWidth(),
$new->getHeight(),
$img->getWidth(),
$img->getHeight()))
throw new WideImage_GDFunctionResultException("imagecopyresized() returned false");
}
else
{
$new = WideImage_TrueColorImage::create($dim['width'], $dim['height']);
$new->alphaBlending(false);
$new->saveAlpha(true);
if (!imagecopyresampled(
$new->getHandle(),
$img->getHandle(),
0, 0, 0, 0,
$new->getWidth(),
$new->getHeight(),
$img->getWidth(),
$img->getHeight()))
throw new WideImage_GDFunctionResultException("imagecopyresampled() returned false");
$new->alphaBlending(true);
}
return $new;
}
}
/**
* Resize operation class.
*/
class WideImage_Operation_Resize
{
/**
* Prepares and corrects smart coordinates.
*
* @param WideImage_Image $img
* @param smart_coordinate $width
* @param smart_coordinate $height
* @param string $fit
*
* @return array
*/
protected function prepareDimensions($img, $width, $height, $fit)
{
if ($width === null && $height === null) {
$width = $img->getWidth();
$height = $img->getHeight();
}
if ($width !== null) {
$width = WideImage_Coordinate::fix($width, $img->getWidth());
}
if ($height !== null) {
$height = WideImage_Coordinate::fix($height, $img->getHeight());
}
if ($width === null) {
$width = floor($img->getWidth() * $height / $img->getHeight());
}
if ($height === null) {
$height = floor($img->getHeight() * $width / $img->getWidth());
}
if ($width === 0 || $height === 0) {
return ['width' => 0, 'height' => 0];
}
if ($fit == null) {
$fit = 'inside';
}
$dim = [];
if ($fit == 'fill') {
$dim['width'] = $width;
$dim['height'] = $height;
} elseif ($fit == 'inside' || $fit == 'outside') {
$rx = $img->getWidth() / $width;
$ry = $img->getHeight() / $height;
if ($fit == 'inside') {
$ratio = ($rx > $ry) ? $rx : $ry;
} else {
$ratio = ($rx < $ry) ? $rx : $ry;
}
$dim['width'] = round($img->getWidth() / $ratio);
$dim['height'] = round($img->getHeight() / $ratio);
} else {
throw new WideImage_Operation_InvalidFitMethodException("{$fit} is not a valid resize-fit method.");
}
return $dim;
}
/**
* Returns a resized image.
*
* @param WideImage_Image $img
* @param smart_coordinate $width
* @param smart_coordinate $height
* @param string $fit
* @param string $scale
*
* @return WideImage_Image
*/
public function execute($img, $width, $height, $fit, $scale)
{
$dim = $this->prepareDimensions($img, $width, $height, $fit);
if (($scale === 'down' && ($dim['width'] >= $img->getWidth() && $dim['height'] >= $img->getHeight())) ||
($scale === 'up' && ($dim['width'] <= $img->getWidth() && $dim['height'] <= $img->getHeight()))) {
$dim = ['width' => $img->getWidth(), 'height' => $img->getHeight()];
}
if ($dim['width'] <= 0 || $dim['height'] <= 0) {
throw new WideImage_Operation_InvalidResizeDimensionException('Both dimensions must be larger than 0.');
}
if ($img->isTransparent() || $img instanceof WideImage_PaletteImage) {
$new = WideImage_PaletteImage::create($dim['width'], $dim['height']);
$new->copyTransparencyFrom($img);
if (!imagecopyresized(
$new->getHandle(),
$img->getHandle(),
0, 0, 0, 0,
$new->getWidth(),
$new->getHeight(),
$img->getWidth(),
$img->getHeight())) {
throw new WideImage_GDFunctionResultException('imagecopyresized() returned false');
}
} else {
$new = WideImage_TrueColorImage::create($dim['width'], $dim['height']);
$new->alphaBlending(false);
$new->saveAlpha(true);
if (!imagecopyresampled(
$new->getHandle(),
$img->getHandle(),
0, 0, 0, 0,
$new->getWidth(),
$new->getHeight(),
$img->getWidth(),
$img->getHeight())) {
throw new WideImage_GDFunctionResultException('imagecopyresampled() returned false');
}
$new->alphaBlending(true);
}
return $new;
}
}

185
public/filemanager/connectors/php/inc/wideimage/lib/Operation/ResizeCanvas.php
View File

@@ -1,107 +1,84 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* ResizeCanvas operation class.
*/
class WideImage_Operation_ResizeCanvas
{
/**
* Returns an image with a resized canvas.
*
* The image is filled with $color. Use $scale to determine, when to resize.
*
* @param WideImage_Image $img
* @param smart_coordinate $width
* @param smart_coordinate $height
* @param smart_coordinate $left
* @param smart_coordinate $top
* @param int $color
* @param string $scale 'up', 'down', 'any'
* @param bool $merge
*
* @return WideImage_Image
*/
public function execute($img, $width, $height, $left, $top, $color, $scale, $merge)
{
$new_width = WideImage_Coordinate::fix($width, $img->getWidth());
$new_height = WideImage_Coordinate::fix($height, $img->getHeight());
* @package Internal/Operations
**/
/**
* ResizeCanvas operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_ResizeCanvas
{
/**
* Returns an image with a resized canvas
*
* The image is filled with $color. Use $scale to determine, when to resize.
*
* @param WideImage_Image $img
* @param smart_coordinate $width
* @param smart_coordinate $height
* @param smart_coordinate $left
* @param smart_coordinate $top
* @param int $color
* @param string $scale 'up', 'down', 'any'
* @param boolean $merge
* @return WideImage_Image
*/
function execute($img, $width, $height, $left, $top, $color, $scale, $merge)
{
$new_width = WideImage_Coordinate::fix($width, $img->getWidth());
$new_height = WideImage_Coordinate::fix($height, $img->getHeight());
if ($scale == 'down')
{
$new_width = min($new_width, $img->getWidth());
$new_height = min($new_height, $img->getHeight());
}
elseif ($scale == 'up')
{
$new_width = max($new_width, $img->getWidth());
$new_height = max($new_height, $img->getHeight());
}
$new = WideImage::createTrueColorImage($new_width, $new_height);
if ($img->isTrueColor())
{
if ($color === null)
$color = $new->allocateColorAlpha(0, 0, 0, 127);
}
else
{
imagepalettecopy($new->getHandle(), $img->getHandle());
if ($img->isTransparent())
{
$new->copyTransparencyFrom($img);
$tc_rgb = $img->getTransparentColorRGB();
$t_color = $new->allocateColorAlpha($tc_rgb);
}
if ($color === null)
{
if ($img->isTransparent())
$color = $t_color;
else
$color = $new->allocateColorAlpha(255, 0, 127, 127);
imagecolortransparent($new->getHandle(), $color);
}
}
$new->fill(0, 0, $color);
$x = WideImage_Coordinate::fix($left, $new->getWidth(), $img->getWidth());
$y = WideImage_Coordinate::fix($top, $new->getHeight(), $img->getHeight());
// blending for truecolor images
if ($img->isTrueColor())
$new->alphaBlending($merge);
// not-blending for palette images
if (!$merge && !$img->isTrueColor() && isset($t_color))
$new->getCanvas()->filledRectangle($x, $y, $x + $img->getWidth(), $y + $img->getHeight(), $t_color);
$img->copyTo($new, $x, $y);
return $new;
}
}
if ($scale == 'down') {
$new_width = min($new_width, $img->getWidth());
$new_height = min($new_height, $img->getHeight());
} elseif ($scale == 'up') {
$new_width = max($new_width, $img->getWidth());
$new_height = max($new_height, $img->getHeight());
}
$new = WideImage::createTrueColorImage($new_width, $new_height);
if ($img->isTrueColor()) {
if ($color === null) {
$color = $new->allocateColorAlpha(0, 0, 0, 127);
}
} else {
imagepalettecopy($new->getHandle(), $img->getHandle());
if ($img->isTransparent()) {
$new->copyTransparencyFrom($img);
$tc_rgb = $img->getTransparentColorRGB();
$t_color = $new->allocateColorAlpha($tc_rgb);
}
if ($color === null) {
if ($img->isTransparent()) {
$color = $t_color;
} else {
$color = $new->allocateColorAlpha(255, 0, 127, 127);
}
imagecolortransparent($new->getHandle(), $color);
}
}
$new->fill(0, 0, $color);
$x = WideImage_Coordinate::fix($left, $new->getWidth(), $img->getWidth());
$y = WideImage_Coordinate::fix($top, $new->getHeight(), $img->getHeight());
// blending for truecolor images
if ($img->isTrueColor()) {
$new->alphaBlending($merge);
}
// not-blending for palette images
if (!$merge && !$img->isTrueColor() && isset($t_color)) {
$new->getCanvas()->filledRectangle($x, $y, $x + $img->getWidth(), $y + $img->getHeight(), $t_color);
}
$img->copyTo($new, $x, $y);
return $new;
}
}

104
public/filemanager/connectors/php/inc/wideimage/lib/Operation/Rotate.php
View File

@@ -1,64 +1,46 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Rotate operation class.
*/
class WideImage_Operation_Rotate
{
/**
* Returns rotated image.
*
* @param WideImage_Image $image
* @param numeric $angle
* @param int $bgColor
* @param bool $ignoreTransparent
*
* @return WideImage_Image
*/
public function execute($image, $angle, $bgColor, $ignoreTransparent)
{
$angle = -floatval($angle);
if ($angle < 0) {
$angle = 360 + $angle;
}
$angle = $angle % 360;
* @package Internal/Operations
**/
/**
* Rotate operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_Rotate
{
/**
* Returns rotated image
*
* @param WideImage_Image $image
* @param numeric $angle
* @param int $bgColor
* @param bool $ignoreTransparent
* @return WideImage_Image
*/
function execute($image, $angle, $bgColor, $ignoreTransparent)
{
$angle = -floatval($angle);
if ($angle < 0)
$angle = 360 + $angle;
$angle = $angle % 360;
if ($angle == 0)
return $image->copy();
$image = $image->asTrueColor();
if ($bgColor === null)
{
$bgColor = $image->getTransparentColor();
if ($bgColor == -1)
{
$bgColor = $image->allocateColorAlpha(255, 255, 255, 127);
imagecolortransparent($image->getHandle(), $bgColor);
}
}
return new WideImage_TrueColorImage(imagerotate($image->getHandle(), $angle, $bgColor, $ignoreTransparent));
}
}
if ($angle == 0) {
return $image->copy();
}
$image = $image->asTrueColor();
if ($bgColor === null) {
$bgColor = $image->getTransparentColor();
if ($bgColor == -1) {
$bgColor = $image->allocateColorAlpha(255, 255, 255, 127);
imagecolortransparent($image->getHandle(), $bgColor);
}
}
return new WideImage_TrueColorImage(imagerotate($image->getHandle(), $angle, $bgColor, $ignoreTransparent));
}
}

208
public/filemanager/connectors/php/inc/wideimage/lib/Operation/RoundCorners.php
View File

@@ -1,114 +1,100 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* ApplyMask operation class.
*/
class WideImage_Operation_RoundCorners
{
/**
* @param WideImage_Image $image
* @param int $radius
* @param int $color
* @param int $smoothness
*
* @return WideImage_Image
*/
public function execute($image, $radius, $color, $smoothness, $corners)
{
if ($smoothness < 1) {
$sample_ratio = 1;
} elseif ($smoothness > 16) {
$sample_ratio = 16;
} else {
$sample_ratio = $smoothness;
}
* @package Internal/Operations
**/
/**
* ApplyMask operation class
*
* @package Internal/Operations
*/
class WideImage_Operation_RoundCorners
{
/**
* @param WideImage_Image $image
* @param int $radius
* @param int $color
* @param int $smoothness
* @return WideImage_Image
*/
function execute($image, $radius, $color, $smoothness, $corners)
{
if ($smoothness < 1)
$sample_ratio = 1;
elseif ($smoothness > 16)
$sample_ratio = 16;
else
$sample_ratio = $smoothness;
$corner = WideImage::createTrueColorImage($radius * $sample_ratio, $radius * $sample_ratio);
if ($color === null)
{
imagepalettecopy($corner->getHandle(), $image->getHandle());
$bg_color = $corner->allocateColor(0, 0, 0);
$corner->fill(0, 0, $bg_color);
$fg_color = $corner->allocateColor(255, 255, 255);
$corner->getCanvas()->filledEllipse($radius * $sample_ratio, $radius * $sample_ratio, $radius * 2 * $sample_ratio, $radius * 2 * $sample_ratio, $fg_color);
$corner = $corner->resize($radius, $radius);
$result = $image->asTrueColor();
$tc = $result->getTransparentColor();
if ($tc == -1)
{
$tc = $result->allocateColorAlpha(255, 255, 255, 127);
imagecolortransparent($result->getHandle(), $tc);
$result->setTransparentColor($tc);
}
if ($corners & WideImage::SIDE_TOP_LEFT || $corners & WideImage::SIDE_LEFT || $corners & WideImage::SIDE_TOP)
$result = $result->applyMask($corner, -1, -1);
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_TOP_RIGHT || $corners & WideImage::SIDE_TOP || $corners & WideImage::SIDE_RIGHT)
$result = $result->applyMask($corner, $result->getWidth() - $corner->getWidth() + 1, -1, 100);
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_BOTTOM_RIGHT || $corners & WideImage::SIDE_RIGHT || $corners & WideImage::SIDE_BOTTOM)
$result = $result->applyMask($corner, $result->getWidth() - $corner->getWidth() + 1, $result->getHeight() - $corner->getHeight() + 1, 100);
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_BOTTOM_LEFT || $corners & WideImage::SIDE_LEFT || $corners & WideImage::SIDE_BOTTOM)
$result = $result->applyMask($corner, -1, $result->getHeight() - $corner->getHeight() + 1, 100);
return $result;
}
else
{
$bg_color = $color;
$corner->fill(0, 0, $bg_color);
$fg_color = $corner->allocateColorAlpha(127, 127, 127, 127);
$corner->getCanvas()->filledEllipse($radius * $sample_ratio, $radius * $sample_ratio, $radius * 2 * $sample_ratio, $radius * 2 * $sample_ratio, $fg_color);
$corner = $corner->resize($radius, $radius);
$result = $image->copy();
if ($corners & WideImage::SIDE_TOP_LEFT || $corners & WideImage::SIDE_LEFT || $corners & WideImage::SIDE_TOP)
$result = $result->merge($corner, -1, -1, 100);
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_TOP_RIGHT || $corners & WideImage::SIDE_TOP || $corners & WideImage::SIDE_RIGHT)
$result = $result->merge($corner, $result->getWidth() - $corner->getWidth() + 1, -1, 100);
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_BOTTOM_RIGHT || $corners & WideImage::SIDE_RIGHT || $corners & WideImage::SIDE_BOTTOM)
$result = $result->merge($corner, $result->getWidth() - $corner->getWidth() + 1, $result->getHeight() - $corner->getHeight() + 1, 100);
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_BOTTOM_LEFT || $corners & WideImage::SIDE_LEFT || $corners & WideImage::SIDE_BOTTOM)
$result = $result->merge($corner, -1, $result->getHeight() - $corner->getHeight() + 1, 100);
return $result;
}
}
}
$corner = WideImage::createTrueColorImage($radius * $sample_ratio, $radius * $sample_ratio);
if ($color === null) {
imagepalettecopy($corner->getHandle(), $image->getHandle());
$bg_color = $corner->allocateColor(0, 0, 0);
$corner->fill(0, 0, $bg_color);
$fg_color = $corner->allocateColor(255, 255, 255);
$corner->getCanvas()->filledEllipse($radius * $sample_ratio, $radius * $sample_ratio, $radius * 2 * $sample_ratio, $radius * 2 * $sample_ratio, $fg_color);
$corner = $corner->resize($radius, $radius);
$result = $image->asTrueColor();
$tc = $result->getTransparentColor();
if ($tc == -1) {
$tc = $result->allocateColorAlpha(255, 255, 255, 127);
imagecolortransparent($result->getHandle(), $tc);
$result->setTransparentColor($tc);
}
if ($corners & WideImage::SIDE_TOP_LEFT || $corners & WideImage::SIDE_LEFT || $corners & WideImage::SIDE_TOP) {
$result = $result->applyMask($corner, -1, -1);
}
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_TOP_RIGHT || $corners & WideImage::SIDE_TOP || $corners & WideImage::SIDE_RIGHT) {
$result = $result->applyMask($corner, $result->getWidth() - $corner->getWidth() + 1, -1, 100);
}
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_BOTTOM_RIGHT || $corners & WideImage::SIDE_RIGHT || $corners & WideImage::SIDE_BOTTOM) {
$result = $result->applyMask($corner, $result->getWidth() - $corner->getWidth() + 1, $result->getHeight() - $corner->getHeight() + 1, 100);
}
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_BOTTOM_LEFT || $corners & WideImage::SIDE_LEFT || $corners & WideImage::SIDE_BOTTOM) {
$result = $result->applyMask($corner, -1, $result->getHeight() - $corner->getHeight() + 1, 100);
}
return $result;
} else {
$bg_color = $color;
$corner->fill(0, 0, $bg_color);
$fg_color = $corner->allocateColorAlpha(127, 127, 127, 127);
$corner->getCanvas()->filledEllipse($radius * $sample_ratio, $radius * $sample_ratio, $radius * 2 * $sample_ratio, $radius * 2 * $sample_ratio, $fg_color);
$corner = $corner->resize($radius, $radius);
$result = $image->copy();
if ($corners & WideImage::SIDE_TOP_LEFT || $corners & WideImage::SIDE_LEFT || $corners & WideImage::SIDE_TOP) {
$result = $result->merge($corner, -1, -1, 100);
}
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_TOP_RIGHT || $corners & WideImage::SIDE_TOP || $corners & WideImage::SIDE_RIGHT) {
$result = $result->merge($corner, $result->getWidth() - $corner->getWidth() + 1, -1, 100);
}
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_BOTTOM_RIGHT || $corners & WideImage::SIDE_RIGHT || $corners & WideImage::SIDE_BOTTOM) {
$result = $result->merge($corner, $result->getWidth() - $corner->getWidth() + 1, $result->getHeight() - $corner->getHeight() + 1, 100);
}
$corner = $corner->rotate(90);
if ($corners & WideImage::SIDE_BOTTOM_LEFT || $corners & WideImage::SIDE_LEFT || $corners & WideImage::SIDE_BOTTOM) {
$result = $result->merge($corner, -1, $result->getHeight() - $corner->getHeight() + 1, 100);
}
return $result;
}
}
}

261
public/filemanager/connectors/php/inc/wideimage/lib/Operation/Unsharp.php
View File

@@ -1,135 +1,132 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
* Unsharp filter.
*
* This filter was taken from http://vikjavev.no/computing/ump.php,
* the original author Torstein Hønsi. Adapted to fit better within
* the Wideimage package.
*/
class WideImage_Operation_Unsharp
{
/**
* Returns sharpened image.
*
* @param WideImage_Image $image
* @param float $amount
* @param int $radius
* @param float $threshold
*
* @return WideImage_Image
*/
public function execute($image, $amount, $radius, $threshold)
{
* @package Internal/Operations
**/
/**
* Unsharp filter
*
* This filter was taken from http://vikjavev.no/computing/ump.php,
* the original author Torstein Hønsi. Adapted to fit better within
* the Wideimage package.
*
* @package Internal/Operations
*/
class WideImage_Operation_Unsharp {
/**
* Returns sharpened image
*
* @param WideImage_Image $image
* @param float $amount
* @param int $radius
* @param float $threshold
* @return WideImage_Image
*/
function execute($image, $amount, $radius, $threshold) {
// Attempt to calibrate the parameters to Photoshop:
if ($amount > 500) $amount = 500;
$amount = $amount * 0.016;
if ($radius > 50) $radius = 50;
$radius = $radius * 2;
if ($threshold > 255) $threshold = 255;
$radius = abs(round($radius)); // Only integers make sense.
if ($radius == 0) {
return $image;
}
// Gaussian blur matrix
$matrix = array(
array(1, 2, 1),
array(2, 4, 2),
array(1, 2, 1)
);
$blurred = $image->applyConvolution($matrix, 16, 0);
if($threshold > 0) {
// Calculate the difference between the blurred pixels and the original
// and set the pixels
for ($x = 0; $x < $image->getWidth(); $x++) {
for ($y = 0; $y < $image->getHeight(); $y++) {
$rgbOrig = $image->getRGBAt($x, $y);
$rOrig = $rgbOrig["red"];
$gOrig = $rgbOrig["green"];
$bOrig = $rgbOrig["blue"];
$rgbBlur = $blurred->getRGBAt($x, $y);
$rBlur = $rgbBlur["red"];
$gBlur = $rgbBlur["green"];
$bBlur = $rgbBlur["blue"];
// When the masked pixels differ less from the original
// than the threshold specifies, they are set to their original value.
$rNew = (abs($rOrig - $rBlur) >= $threshold)
? max(0, min(255, ($amount * ($rOrig - $rBlur)) + $rOrig))
: $rOrig;
$gNew = (abs($gOrig - $gBlur) >= $threshold)
? max(0, min(255, ($amount * ($gOrig - $gBlur)) + $gOrig))
: $gOrig;
$bNew = (abs($bOrig - $bBlur) >= $threshold)
? max(0, min(255, ($amount * ($bOrig - $bBlur)) + $bOrig))
: $bOrig;
$rgbNew = array("red" => $rNew, "green" => $gNew, "blue" => $bNew, "alpha" => 0);
if (($rOrig != $rNew) || ($gOrig != $gNew) || ($bOrig != $bNew)) {
$image->setRGBAt($x, $y, $rgbNew);
}
}
}
}
else {
$w = $image->getWidth();
$h = $image->getHeight();
for ($x = 0; $x < $w; $x++) {
for ($y = 0; $y < $h; $y++) {
$rgbOrig = $image->getRGBAt($x, $y);
$rOrig = $rgbOrig["red"];
$gOrig = $rgbOrig["green"];
$bOrig = $rgbOrig["blue"];
$rgbBlur = $blurred->getRGBAt($x, $y);
$rBlur = $rgbBlur["red"];
$gBlur = $rgbBlur["green"];
$bBlur = $rgbBlur["blue"];
$rNew = ($amount * ($rOrig - $rBlur)) + $rOrig;
if($rNew>255){$rNew=255;}
elseif($rNew<0){$rNew=0;}
$gNew = ($amount * ($gOrig - $gBlur)) + $gOrig;
if($gNew>255){$gNew=255;}
elseif($gNew<0){$gNew=0;}
$bNew = ($amount * ($bOrig - $bBlur)) + $bOrig;
if($bNew>255){$bNew=255;}
elseif($bNew<0){$bNew=0;}
$rgbNew = array("red" => $rNew, "green" => $gNew, "blue" => $bNew, "alpha" => 0);
$image->setRGBAt($x, $y, $rgbNew);
}
}
}
return $image;
}
}
// Attempt to calibrate the parameters to Photoshop:
if ($amount > 500) {
$amount = 500;
}
$amount = $amount * 0.016;
if ($radius > 50) {
$radius = 50;
}
$radius = $radius * 2;
if ($threshold > 255) {
$threshold = 255;
}
$radius = abs(round($radius)); // Only integers make sense.
if ($radius == 0) {
return $image;
}
// Gaussian blur matrix
$matrix = [
[1, 2, 1],
[2, 4, 2],
[1, 2, 1],
];
$blurred = $image->applyConvolution($matrix, 16, 0);
if ($threshold > 0) {
// Calculate the difference between the blurred pixels and the original
// and set the pixels
for ($x = 0; $x < $image->getWidth(); $x++) {
for ($y = 0; $y < $image->getHeight(); $y++) {
$rgbOrig = $image->getRGBAt($x, $y);
$rOrig = $rgbOrig['red'];
$gOrig = $rgbOrig['green'];
$bOrig = $rgbOrig['blue'];
$rgbBlur = $blurred->getRGBAt($x, $y);
$rBlur = $rgbBlur['red'];
$gBlur = $rgbBlur['green'];
$bBlur = $rgbBlur['blue'];
// When the masked pixels differ less from the original
// than the threshold specifies, they are set to their original value.
$rNew = (abs($rOrig - $rBlur) >= $threshold)
? max(0, min(255, ($amount * ($rOrig - $rBlur)) + $rOrig))
: $rOrig;
$gNew = (abs($gOrig - $gBlur) >= $threshold)
? max(0, min(255, ($amount * ($gOrig - $gBlur)) + $gOrig))
: $gOrig;
$bNew = (abs($bOrig - $bBlur) >= $threshold)
? max(0, min(255, ($amount * ($bOrig - $bBlur)) + $bOrig))
: $bOrig;
$rgbNew = ['red' => $rNew, 'green' => $gNew, 'blue' => $bNew, 'alpha' => 0];
if (($rOrig != $rNew) || ($gOrig != $gNew) || ($bOrig != $bNew)) {
$image->setRGBAt($x, $y, $rgbNew);
}
}
}
} else {
$w = $image->getWidth();
$h = $image->getHeight();
for ($x = 0; $x < $w; $x++) {
for ($y = 0; $y < $h; $y++) {
$rgbOrig = $image->getRGBAt($x, $y);
$rOrig = $rgbOrig['red'];
$gOrig = $rgbOrig['green'];
$bOrig = $rgbOrig['blue'];
$rgbBlur = $blurred->getRGBAt($x, $y);
$rBlur = $rgbBlur['red'];
$gBlur = $rgbBlur['green'];
$bBlur = $rgbBlur['blue'];
$rNew = ($amount * ($rOrig - $rBlur)) + $rOrig;
if ($rNew > 255) {
$rNew = 255;
} elseif ($rNew < 0) {
$rNew = 0;
}
$gNew = ($amount * ($gOrig - $gBlur)) + $gOrig;
if ($gNew > 255) {
$gNew = 255;
} elseif ($gNew < 0) {
$gNew = 0;
}
$bNew = ($amount * ($bOrig - $bBlur)) + $bOrig;
if ($bNew > 255) {
$bNew = 255;
} elseif ($bNew < 0) {
$bNew = 0;
}
$rgbNew = ['red' => $rNew, 'green' => $gNew, 'blue' => $bNew, 'alpha' => 0];
$image->setRGBAt($x, $y, $rgbNew);
}
}
}
return $image;
}
}

89
public/filemanager/connectors/php/inc/wideimage/lib/OperationFactory.php
View File

@@ -1,57 +1,38 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/**
*/
class WideImage_UnknownImageOperationException extends WideImage_Exception
{
}
* @package Internals
**/
/**
* @package Exceptions
*/
class WideImage_UnknownImageOperationException extends WideImage_Exception {}
/**
* Operation factory
*
* @package Internals
**/
class WideImage_OperationFactory
{
static protected $cache = array();
static function get($operationName)
{
$lcname = strtolower($operationName);
if (!isset(self::$cache[$lcname]))
{
$opClassName = "WideImage_Operation_" . ucfirst($operationName);
if (!class_exists($opClassName, false))
{
$fileName = WideImage::path() . 'Operation/' . ucfirst($operationName) . '.php';
if (file_exists($fileName))
require_once $fileName;
elseif (!class_exists($opClassName))
throw new WideImage_UnknownImageOperationException("Can't load '{$operationName}' operation.");
}
self::$cache[$lcname] = new $opClassName();
}
return self::$cache[$lcname];
}
}
/**
* Operation factory.
**/
class WideImage_OperationFactory
{
protected static $cache = [];
public static function get($operationName)
{
$lcname = strtolower($operationName);
if (!isset(self::$cache[$lcname])) {
$opClassName = 'WideImage_Operation_'.ucfirst($operationName);
if (!class_exists($opClassName, false)) {
$fileName = WideImage::path().'Operation/'.ucfirst($operationName).'.php';
if (file_exists($fileName)) {
require_once $fileName;
} elseif (!class_exists($opClassName)) {
throw new WideImage_UnknownImageOperationException("Can't load '{$operationName}' operation.");
}
}
self::$cache[$lcname] = new $opClassName();
}
return self::$cache[$lcname];
}
}

262
public/filemanager/connectors/php/inc/wideimage/lib/PaletteImage.php
View File

@@ -1,136 +1,130 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* @package WideImage
**/
/**
* @package WideImage
*/
class WideImage_PaletteImage extends WideImage_Image
{
/**
* Create a palette image
*
* @param int $width
* @param int $height
* @return WideImage_PaletteImage
*/
static function create($width, $height)
{
if ($width * $height <= 0 || $width < 0)
throw new WideImage_InvalidImageDimensionException("Can't create an image with dimensions [$width, $height].");
return new WideImage_PaletteImage(imagecreate($width, $height));
}
function doCreate($width, $height)
{
return self::create($width, $height);
}
/**
* (non-PHPdoc)
* @see WideImage_Image#isTrueColor()
*/
function isTrueColor()
{
return false;
}
/**
* (non-PHPdoc)
* @see WideImage_Image#asPalette($nColors, $dither, $matchPalette)
*/
function asPalette($nColors = 255, $dither = null, $matchPalette = true)
{
return $this->copy();
}
/**
* Returns a copy of the image
*
* @param $trueColor True if the new image should be truecolor
* @return WideImage_Image
*/
protected function copyAsNew($trueColor = false)
{
$width = $this->getWidth();
$height = $this->getHeight();
if ($trueColor)
$new = WideImage_TrueColorImage::create($width, $height);
else
$new = WideImage_PaletteImage::create($width, $height);
// copy transparency of source to target
if ($this->isTransparent())
{
$rgb = $this->getTransparentColorRGB();
if (is_array($rgb))
{
$tci = $new->allocateColor($rgb['red'], $rgb['green'], $rgb['blue']);
$new->fill(0, 0, $tci);
$new->setTransparentColor($tci);
}
}
imageCopy($new->getHandle(), $this->handle, 0, 0, 0, 0, $width, $height);
return $new;
}
/**
* (non-PHPdoc)
* @see WideImage_Image#asTrueColor()
*/
function asTrueColor()
{
$width = $this->getWidth();
$height = $this->getHeight();
$new = WideImage::createTrueColorImage($width, $height);
if ($this->isTransparent())
$new->copyTransparencyFrom($this);
if (!imageCopy($new->getHandle(), $this->handle, 0, 0, 0, 0, $width, $height))
throw new WideImage_GDFunctionResultException("imagecopy() returned false");
return $new;
}
/**
* (non-PHPdoc)
* @see WideImage_Image#getChannels()
*/
function getChannels()
{
$args = func_get_args();
if (count($args) == 1 && is_array($args[0]))
$args = $args[0];
return WideImage_OperationFactory::get('CopyChannelsPalette')->execute($this, $args);
}
/**
* (non-PHPdoc)
* @see WideImage_Image#copyNoAlpha()
*/
function copyNoAlpha()
{
return WideImage_Image::loadFromString($this->asString('png'));
}
}
/**
*/
class WideImage_PaletteImage extends WideImage_Image
{
/**
* Create a palette image.
*
* @param int $width
* @param int $height
*
* @return WideImage_PaletteImage
*/
public static function create($width, $height)
{
if ($width * $height <= 0 || $width < 0) {
throw new WideImage_InvalidImageDimensionException("Can't create an image with dimensions [$width, $height].");
}
return new self(imagecreate($width, $height));
}
public function doCreate($width, $height)
{
return self::create($width, $height);
}
/**
* (non-PHPdoc).
*
* @see WideImage_Image#isTrueColor()
*/
public function isTrueColor()
{
return false;
}
/**
* (non-PHPdoc).
*
* @see WideImage_Image#asPalette($nColors, $dither, $matchPalette)
*/
public function asPalette($nColors = 255, $dither = null, $matchPalette = true)
{
return $this->copy();
}
/**
* Returns a copy of the image.
*
* @param $trueColor True if the new image should be truecolor
*
* @return WideImage_Image
*/
protected function copyAsNew($trueColor = false)
{
$width = $this->getWidth();
$height = $this->getHeight();
if ($trueColor) {
$new = WideImage_TrueColorImage::create($width, $height);
} else {
$new = self::create($width, $height);
}
// copy transparency of source to target
if ($this->isTransparent()) {
$rgb = $this->getTransparentColorRGB();
if (is_array($rgb)) {
$tci = $new->allocateColor($rgb['red'], $rgb['green'], $rgb['blue']);
$new->fill(0, 0, $tci);
$new->setTransparentColor($tci);
}
}
imagecopy($new->getHandle(), $this->handle, 0, 0, 0, 0, $width, $height);
return $new;
}
/**
* (non-PHPdoc).
*
* @see WideImage_Image#asTrueColor()
*/
public function asTrueColor()
{
$width = $this->getWidth();
$height = $this->getHeight();
$new = WideImage::createTrueColorImage($width, $height);
if ($this->isTransparent()) {
$new->copyTransparencyFrom($this);
}
if (!imagecopy($new->getHandle(), $this->handle, 0, 0, 0, 0, $width, $height)) {
throw new WideImage_GDFunctionResultException('imagecopy() returned false');
}
return $new;
}
/**
* (non-PHPdoc).
*
* @see WideImage_Image#getChannels()
*/
public function getChannels()
{
$args = func_get_args();
if (count($args) == 1 && is_array($args[0])) {
$args = $args[0];
}
return WideImage_OperationFactory::get('CopyChannelsPalette')->execute($this, $args);
}
/**
* (non-PHPdoc).
*
* @see WideImage_Image#copyNoAlpha()
*/
public function copyNoAlpha()
{
return WideImage_Image::loadFromString($this->asString('png'));
}
}

432
public/filemanager/connectors/php/inc/wideimage/lib/TrueColorImage.php
View File

@@ -1,218 +1,218 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
**/
/**
* A class for truecolor image objects
*
* @package WideImage
*/
class WideImage_TrueColorImage extends WideImage_Image
{
/**
* Creates the object
*
* @param resource $handle
*/
function __construct($handle)
{
parent::__construct($handle);
$this->alphaBlending(false);
$this->saveAlpha(true);
}
/**
* Factory method that creates a true-color image object
*
* @param int $width
* @param int $height
* @return WideImage_TrueColorImage
*/
static function create($width, $height)
{
if ($width * $height <= 0 || $width < 0)
throw new WideImage_InvalidImageDimensionException("Can't create an image with dimensions [$width, $height].");
return new WideImage_TrueColorImage(imagecreatetruecolor($width, $height));
}
function doCreate($width, $height)
{
return self::create($width, $height);
}
function isTrueColor()
{
return true;
}
/**
* Sets alpha blending mode via imagealphablending()
*
* @param bool $mode
* @return bool
*/
function alphaBlending($mode)
{
return imagealphablending($this->handle, $mode);
}
/**
* Toggle if alpha channel should be saved with the image via imagesavealpha()
*
* @param bool $on
* @return bool
*/
function saveAlpha($on)
{
return imagesavealpha($this->handle, $on);
}
/**
* Allocates a color and returns its index
*
* This method accepts either each component as an integer value,
* or an associative array that holds the color's components in keys
* 'red', 'green', 'blue', 'alpha'.
*
* @param mixed $R
* @param int $G
* @param int $B
* @param int $A
* @return int
*/
function allocateColorAlpha($R, $G = null, $B = null, $A = null)
{
if (is_array($R))
return imageColorAllocateAlpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
else
return imageColorAllocateAlpha($this->handle, $R, $G, $B, $A);
}
/**
* @see WideImage_Image#asPalette($nColors, $dither, $matchPalette)
*/
function asPalette($nColors = 255, $dither = null, $matchPalette = true)
{
$nColors = intval($nColors);
if ($nColors < 1)
$nColors = 1;
elseif ($nColors > 255)
$nColors = 255;
if ($dither === null)
$dither = $this->isTransparent();
$temp = $this->copy();
imagetruecolortopalette($temp->handle, $dither, $nColors);
if ($matchPalette == true && function_exists('imagecolormatch'))
imagecolormatch($this->handle, $temp->handle);
// The code below isn't working properly; it corrupts transparency on some palette->tc->palette conversions.
// Why is this code here?
/*
if ($this->isTransparent())
{
$trgb = $this->getTransparentColorRGB();
$tci = $temp->getClosestColor($trgb);
$temp->setTransparentColor($tci);
}
/**/
$temp->releaseHandle();
return new WideImage_PaletteImage($temp->handle);
}
/**
* Returns the index of the color that best match the given color components
*
* This method accepts either each component as an integer value,
* or an associative array that holds the color's components in keys
* 'red', 'green', 'blue', 'alpha'.
*
* @param mixed $R Red component value or an associative array
* @param int $G Green component
* @param int $B Blue component
* @param int $A Alpha component
* @return int The color index
*/
function getClosestColorAlpha($R, $G = null, $B = null, $A = null)
{
if (is_array($R))
return imagecolorclosestalpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
else
return imagecolorclosestalpha($this->handle, $R, $G, $B, $A);
}
/**
* Returns the index of the color that exactly match the given color components
*
* This method accepts either each component as an integer value,
* or an associative array that holds the color's components in keys
* 'red', 'green', 'blue', 'alpha'.
*
* @param mixed $R Red component value or an associative array
* @param int $G Green component
* @param int $B Blue component
* @param int $A Alpha component
* @return int The color index
*/
function getExactColorAlpha($R, $G = null, $B = null, $A = null)
{
if (is_array($R))
return imagecolorexactalpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
else
return imagecolorexactalpha($this->handle, $R, $G, $B, $A);
}
/**
* @see WideImage_Image#getChannels()
*/
function getChannels()
{
$args = func_get_args();
if (count($args) == 1 && is_array($args[0]))
$args = $args[0];
return WideImage_OperationFactory::get('CopyChannelsTrueColor')->execute($this, $args);
}
/**
* (non-PHPdoc)
* @see WideImage_Image#copyNoAlpha()
*/
function copyNoAlpha()
{
$prev = $this->saveAlpha(false);
$result = WideImage_Image::loadFromString($this->asString('png'));
$this->saveAlpha($prev);
//$result->releaseHandle();
return $result;
}
/**
* (non-PHPdoc)
* @see WideImage_Image#asTrueColor()
*/
function asTrueColor()
{
return $this->copy();
}
}
/**
* A class for truecolor image objects.
*/
class WideImage_TrueColorImage extends WideImage_Image
{
/**
* Creates the object.
*
* @param resource $handle
*/
public function __construct($handle)
{
parent::__construct($handle);
$this->alphaBlending(false);
$this->saveAlpha(true);
}
/**
* Factory method that creates a true-color image object.
*
* @param int $width
* @param int $height
*
* @return WideImage_TrueColorImage
*/
public static function create($width, $height)
{
if ($width * $height <= 0 || $width < 0) {
throw new WideImage_InvalidImageDimensionException("Can't create an image with dimensions [$width, $height].");
}
return new self(imagecreatetruecolor($width, $height));
}
public function doCreate($width, $height)
{
return self::create($width, $height);
}
public function isTrueColor()
{
return true;
}
/**
* Sets alpha blending mode via imagealphablending().
*
* @param bool $mode
*
* @return bool
*/
public function alphaBlending($mode)
{
return imagealphablending($this->handle, $mode);
}
/**
* Toggle if alpha channel should be saved with the image via imagesavealpha().
*
* @param bool $on
*
* @return bool
*/
public function saveAlpha($on)
{
return imagesavealpha($this->handle, $on);
}
/**
* Allocates a color and returns its index.
*
* This method accepts either each component as an integer value,
* or an associative array that holds the color's components in keys
* 'red', 'green', 'blue', 'alpha'.
*
* @param mixed $R
* @param int $G
* @param int $B
* @param int $A
*
* @return int
*/
public function allocateColorAlpha($R, $G = null, $B = null, $A = null)
{
if (is_array($R)) {
return imagecolorallocatealpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
} else {
return imagecolorallocatealpha($this->handle, $R, $G, $B, $A);
}
}
/**
* @see WideImage_Image#asPalette($nColors, $dither, $matchPalette)
*/
public function asPalette($nColors = 255, $dither = null, $matchPalette = true)
{
$nColors = intval($nColors);
if ($nColors < 1) {
$nColors = 1;
} elseif ($nColors > 255) {
$nColors = 255;
}
if ($dither === null) {
$dither = $this->isTransparent();
}
$temp = $this->copy();
imagetruecolortopalette($temp->handle, $dither, $nColors);
if ($matchPalette == true && function_exists('imagecolormatch')) {
imagecolormatch($this->handle, $temp->handle);
}
// The code below isn't working properly; it corrupts transparency on some palette->tc->palette conversions.
// Why is this code here?
/*
if ($this->isTransparent())
{
$trgb = $this->getTransparentColorRGB();
$tci = $temp->getClosestColor($trgb);
$temp->setTransparentColor($tci);
}
/**/
$temp->releaseHandle();
return new WideImage_PaletteImage($temp->handle);
}
/**
* Returns the index of the color that best match the given color components.
*
* This method accepts either each component as an integer value,
* or an associative array that holds the color's components in keys
* 'red', 'green', 'blue', 'alpha'.
*
* @param mixed $R Red component value or an associative array
* @param int $G Green component
* @param int $B Blue component
* @param int $A Alpha component
*
* @return int The color index
*/
public function getClosestColorAlpha($R, $G = null, $B = null, $A = null)
{
if (is_array($R)) {
return imagecolorclosestalpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
} else {
return imagecolorclosestalpha($this->handle, $R, $G, $B, $A);
}
}
/**
* Returns the index of the color that exactly match the given color components.
*
* This method accepts either each component as an integer value,
* or an associative array that holds the color's components in keys
* 'red', 'green', 'blue', 'alpha'.
*
* @param mixed $R Red component value or an associative array
* @param int $G Green component
* @param int $B Blue component
* @param int $A Alpha component
*
* @return int The color index
*/
public function getExactColorAlpha($R, $G = null, $B = null, $A = null)
{
if (is_array($R)) {
return imagecolorexactalpha($this->handle, $R['red'], $R['green'], $R['blue'], $R['alpha']);
} else {
return imagecolorexactalpha($this->handle, $R, $G, $B, $A);
}
}
/**
* @see WideImage_Image#getChannels()
*/
public function getChannels()
{
$args = func_get_args();
if (count($args) == 1 && is_array($args[0])) {
$args = $args[0];
}
return WideImage_OperationFactory::get('CopyChannelsTrueColor')->execute($this, $args);
}
/**
* (non-PHPdoc).
*
* @see WideImage_Image#copyNoAlpha()
*/
public function copyNoAlpha()
{
$prev = $this->saveAlpha(false);
$result = WideImage_Image::loadFromString($this->asString('png'));
$this->saveAlpha($prev);
//$result->releaseHandle();
return $result;
}
/**
* (non-PHPdoc).
*
* @see WideImage_Image#asTrueColor()
*/
public function asTrueColor()
{
return $this->copy();
}
}

749
public/filemanager/connectors/php/inc/wideimage/lib/WideImage.php
View File

@@ -1,377 +1,376 @@
<?php
/**
* @author Gasper Kozak
* @copyright 2007-2011
/**
* @author Gasper Kozak
* @copyright 2007-2011
**/
require_once WideImage::path().'Exception.php';
This file is part of WideImage.
WideImage is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
WideImage 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with WideImage; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* @package WideImage
**/
require_once WideImage::path() . 'Exception.php';
require_once WideImage::path() . 'Image.php';
require_once WideImage::path() . 'TrueColorImage.php';
require_once WideImage::path() . 'PaletteImage.php';
require_once WideImage::path() . 'Coordinate.php';
require_once WideImage::path() . 'Canvas.php';
require_once WideImage::path() . 'MapperFactory.php';
require_once WideImage::path() . 'OperationFactory.php';
require_once WideImage::path() . 'Font/TTF.php';
require_once WideImage::path() . 'Font/GDF.php';
require_once WideImage::path() . 'Font/PS.php';
/**
* @package Exceptions
*/
class WideImage_InvalidImageHandleException extends WideImage_Exception {}
/**
* @package Exceptions
*/
class WideImage_InvalidImageSourceException extends WideImage_Exception {}
/**
* @package Exceptions
*
* Class for invalid GD function calls result (for example those that return bool)
*/
class WideImage_GDFunctionResultException extends WideImage_Exception {}
/**
* The gateway class for loading images and core library functions
*
* @package WideImage
*/
class WideImage
{
const SIDE_TOP_LEFT = 1;
const SIDE_TOP = 2;
const SIDE_TOP_RIGHT = 4;
const SIDE_RIGHT = 8;
const SIDE_BOTTOM_RIGHT = 16;
const SIDE_BOTTOM = 32;
const SIDE_BOTTOM_LEFT = 64;
const SIDE_LEFT = 128;
const SIDE_ALL = 255;
/**
* @var string Path to the library base directory
*/
protected static $path = null;
/**
* Returns the library version
* @return string The library version
*/
static function version()
{
return '11.02.19';
}
/**
* Returns the path to the library
* @return string
*/
static function path()
{
if (self::$path === null)
self::$path = dirname(__FILE__) . DIRECTORY_SEPARATOR;
return self::$path;
}
/**
* Checks whether the gd library is loaded, and throws an exception otherwise
*/
static function checkGD()
{
if (!extension_loaded('gd'))
throw new WideImage_Exception("WideImage requires the GD extension, but it's apparently not loaded.");
}
/**
* Registers a custom mapper for image loading and saving
*
* Example:
* <code>
* WideImage::registerCustomMapper('WideImage_Mapper_TGA', 'image/tga', 'tga');
* </code>
*
* @param string $mapper_class_name
* @param string $mime_type
* @param string $extension
*/
static function registerCustomMapper($mapper_class_name, $mime_type, $extension)
{
WideImage_MapperFactory::registerMapper($mapper_class_name, $mime_type, strtoupper($extension));
}
/**
* Loads an image from a file, URL, HTML input file field, binary string, or a valid image handle.
* The image format is auto-detected.
*
* Currently supported formats: PNG, GIF, JPG, BMP, TGA, GD, GD2.
*
* This function analyzes the input and decides whether to use WideImage::loadFromHandle(),
* WideImage::loadFromFile(), WideImage::loadFromUpload() or WideImage::loadFromString(),
* all of which you can also call directly to spare WideImage some guessing.
*
* Arrays are supported for upload fields; it returns an array of loaded images.
* To load only a single image from an array field, use WideImage::loadFromUpload('img', $i),
* where $i is the index of the image you want to load.
*
* <code>
* $img = WideImage::load('http://url/image.png'); // image URL
* $img = WideImage::load('/path/to/image.png'); // local file path
* $img = WideImage::load('img'); // upload field name
* $img = WideImage::load(imagecreatetruecolor(10, 10)); // a GD resource
* $img = WideImage::load($image_data); // binary string containing image data
* </code>
*
* @param mixed $source File name, url, HTML file input field name, binary string, or a GD image resource
* @return WideImage_Image WideImage_PaletteImage or WideImage_TrueColorImage instance
*/
static function load($source)
{
$predictedSourceType = '';
if ($source == '')
$predictedSourceType = 'String';
// Creating image via a valid resource
if (!$predictedSourceType && self::isValidImageHandle($source))
$predictedSourceType = 'Handle';
// Check for binary string
if (!$predictedSourceType)
{
// search first $binLength bytes (at a maximum) for ord<32 characters (binary image data)
$binLength = 64;
$sourceLength = strlen($source);
$maxlen = ($sourceLength > $binLength) ? $binLength : $sourceLength;
for ($i = 0; $i < $maxlen; $i++)
if (ord($source[$i]) < 32)
{
$predictedSourceType = 'String';
break;
}
}
// Uploaded image (array uploads not supported)
if (isset($_FILES[$source]) && isset($_FILES[$source]['tmp_name']))
$predictedSourceType = 'Upload';
// Otherwise, must be a file or an URL
if (!$predictedSourceType)
$predictedSourceType = 'File';
return call_user_func(array('WideImage', 'loadFrom' . $predictedSourceType), $source);
}
/**
* Create and load an image from a file or URL. The image format is auto-detected.
*
* @param string $uri File or url
* @return WideImage_Image WideImage_PaletteImage or WideImage_TrueColorImage instance
*/
static function loadFromFile($uri)
{
$data = file_get_contents($uri);
$handle = @imagecreatefromstring($data);
if (!self::isValidImageHandle($handle))
{
try
{
// try to find a mapper first
$mapper = WideImage_MapperFactory::selectMapper($uri);
if ($mapper)
$handle = $mapper->load($uri);
}
catch (WideImage_UnsupportedFormatException $e)
{
// mapper not found
}
// try all custom mappers
if (!self::isValidImageHandle($handle))
{
$custom_mappers = WideImage_MapperFactory::getCustomMappers();
foreach ($custom_mappers as $mime_type => $mapper_class)
{
$mapper = WideImage_MapperFactory::selectMapper(null, $mime_type);
$handle = $mapper->loadFromString($data);
if (self::isValidImageHandle($handle))
break;
}
}
}
if (!self::isValidImageHandle($handle))
throw new WideImage_InvalidImageSourceException("File '{$uri}' appears to be an invalid image source.");
return self::loadFromHandle($handle);
}
/**
* Create and load an image from a string. Format is auto-detected.
*
* @param string $string Binary data, i.e. from BLOB field in the database
* @return WideImage_Image WideImage_PaletteImage or WideImage_TrueColorImage instance
*/
static function loadFromString($string)
{
if (strlen($string) < 128)
throw new WideImage_InvalidImageSourceException("String doesn't contain image data.");
$handle = @imagecreatefromstring($string);
if (!self::isValidImageHandle($handle))
{
$custom_mappers = WideImage_MapperFactory::getCustomMappers();
foreach ($custom_mappers as $mime_type => $mapper_class)
{
$mapper = WideImage_MapperFactory::selectMapper(null, $mime_type);
$handle = $mapper->loadFromString($string);
if (self::isValidImageHandle($handle))
break;
}
}
if (!self::isValidImageHandle($handle))
throw new WideImage_InvalidImageSourceException("String doesn't contain valid image data.");
return self::loadFromHandle($handle);
}
/**
* Create and load an image from an image handle.
*
* <b>Note:</b> the resulting image object takes ownership of the passed
* handle. When the newly-created image object is destroyed, the handle is
* destroyed too, so it's not a valid image handle anymore. In order to
* preserve the handle for use after object destruction, you have to call
* WideImage_Image::releaseHandle() on the created image instance prior to its
* destruction.
*
* <code>
* $handle = imagecreatefrompng('file.png');
* $image = WideImage::loadFromHandle($handle);
* </code>
*
* @param resource $handle A valid GD image resource
* @return WideImage_Image WideImage_PaletteImage or WideImage_TrueColorImage instance
*/
static function loadFromHandle($handle)
{
if (!self::isValidImageHandle($handle))
throw new WideImage_InvalidImageSourceException("Handle is not a valid GD image resource.");
if (imageistruecolor($handle))
return new WideImage_TrueColorImage($handle);
else
return new WideImage_PaletteImage($handle);
}
/**
* This method loads a file from the $_FILES array. The image format is auto-detected.
*
* You only have to pass the field name as the parameter. For array fields, this function will
* return an array of image objects, unless you specify the $index parameter, which will
* load the desired image.
*
* @param $field_name Name of the key in $_FILES array
* @param int $index The index of the file to load (if the input field is an array)
* @return WideImage_Image The loaded image
*/
static function loadFromUpload($field_name, $index = null)
{
if (!array_key_exists($field_name, $_FILES))
throw new WideImage_InvalidImageSourceException("Upload field '{$field_name}' doesn't exist.");
if (is_array($_FILES[$field_name]['tmp_name']))
{
if (isset($_FILES[$field_name]['tmp_name'][$index]))
$filename = $_FILES[$field_name]['tmp_name'][$index];
else
{
$result = array();
foreach ($_FILES[$field_name]['tmp_name'] as $idx => $tmp_name)
$result[$idx] = self::loadFromFile($tmp_name);
return $result;
}
}
else
$filename = $_FILES[$field_name]['tmp_name'];
if (!file_exists($filename))
throw new WideImage_InvalidImageSourceException("Uploaded file doesn't exist.");
return self::loadFromFile($filename);
}
/**
* Factory method for creating a palette image
*
* @param int $width
* @param int $height
* @return WideImage_PaletteImage
*/
static function createPaletteImage($width, $height)
{
return WideImage_PaletteImage::create($width, $height);
}
/**
* Factory method for creating a true-color image
*
* @param int $width
* @param int $height
* @return WideImage_TrueColorImage
*/
static function createTrueColorImage($width, $height)
{
return WideImage_TrueColorImage::create($width, $height);
}
/**
* Check whether the given handle is a valid GD resource
*
* @param mixed $handle The variable to check
* @return bool
*/
static function isValidImageHandle($handle)
{
return (is_resource($handle) && get_resource_type($handle) == 'gd');
}
/**
* Throws exception if the handle isn't a valid GD resource
*
* @param mixed $handle The variable to check
*/
static function assertValidImageHandle($handle)
{
if (!self::isValidImageHandle($handle))
throw new WideImage_InvalidImageHandleException("{$handle} is not a valid image handle.");
}
}
WideImage::checkGD();
WideImage::registerCustomMapper('WideImage_Mapper_BMP', 'image/bmp', 'bmp');
WideImage::registerCustomMapper('WideImage_Mapper_TGA', 'image/tga', 'tga');
require_once WideImage::path().'Image.php';
require_once WideImage::path().'TrueColorImage.php';
require_once WideImage::path().'PaletteImage.php';
require_once WideImage::path().'Coordinate.php';
require_once WideImage::path().'Canvas.php';
require_once WideImage::path().'MapperFactory.php';
require_once WideImage::path().'OperationFactory.php';
require_once WideImage::path().'Font/TTF.php';
require_once WideImage::path().'Font/GDF.php';
require_once WideImage::path().'Font/PS.php';
/**
*/
class WideImage_InvalidImageHandleException extends WideImage_Exception
{
}
/**
*/
class WideImage_InvalidImageSourceException extends WideImage_Exception
{
}
/**
*/
class WideImage_GDFunctionResultException extends WideImage_Exception
{
}
/**
* The gateway class for loading images and core library functions.
*/
class WideImage
{
const SIDE_TOP_LEFT = 1;
const SIDE_TOP = 2;
const SIDE_TOP_RIGHT = 4;
const SIDE_RIGHT = 8;
const SIDE_BOTTOM_RIGHT = 16;
const SIDE_BOTTOM = 32;
const SIDE_BOTTOM_LEFT = 64;
const SIDE_LEFT = 128;
const SIDE_ALL = 255;
/**
* @var string Path to the library base directory
*/
protected static $path = null;
/**
* Returns the library version.
*
* @return string The library version
*/
public static function version()
{
return '11.02.19';
}
/**
* Returns the path to the library.
*
* @return string
*/
public static function path()
{
if (self::$path === null) {
self::$path = dirname(__FILE__).DIRECTORY_SEPARATOR;
}
return self::$path;
}
/**
* Checks whether the gd library is loaded, and throws an exception otherwise.
*/
public static function checkGD()
{
if (!extension_loaded('gd')) {
throw new WideImage_Exception("WideImage requires the GD extension, but it's apparently not loaded.");
}
}
/**
* Registers a custom mapper for image loading and saving.
*
* Example:
* <code>
* WideImage::registerCustomMapper('WideImage_Mapper_TGA', 'image/tga', 'tga');
* </code>
*
* @param string $mapper_class_name
* @param string $mime_type
* @param string $extension
*/
public static function registerCustomMapper($mapper_class_name, $mime_type, $extension)
{
WideImage_MapperFactory::registerMapper($mapper_class_name, $mime_type, strtoupper($extension));
}
/**
* Loads an image from a file, URL, HTML input file field, binary string, or a valid image handle.
* The image format is auto-detected.
*
* Currently supported formats: PNG, GIF, JPG, BMP, TGA, GD, GD2.
*
* This function analyzes the input and decides whether to use WideImage::loadFromHandle(),
* WideImage::loadFromFile(), WideImage::loadFromUpload() or WideImage::loadFromString(),
* all of which you can also call directly to spare WideImage some guessing.
*
* Arrays are supported for upload fields; it returns an array of loaded images.
* To load only a single image from an array field, use WideImage::loadFromUpload('img', $i),
* where $i is the index of the image you want to load.
*
* <code>
* $img = WideImage::load('http://url/image.png'); // image URL
* $img = WideImage::load('/path/to/image.png'); // local file path
* $img = WideImage::load('img'); // upload field name
* $img = WideImage::load(imagecreatetruecolor(10, 10)); // a GD resource
* $img = WideImage::load($image_data); // binary string containing image data
* </code>
*
* @param mixed $source File name, url, HTML file input field name, binary string, or a GD image resource
*
* @return WideImage_Image WideImage_PaletteImage or WideImage_TrueColorImage instance
*/
public static function load($source)
{
$predictedSourceType = '';
if ($source == '') {
$predictedSourceType = 'String';
}
// Creating image via a valid resource
if (!$predictedSourceType && self::isValidImageHandle($source)) {
$predictedSourceType = 'Handle';
}
// Check for binary string
if (!$predictedSourceType) {
// search first $binLength bytes (at a maximum) for ord<32 characters (binary image data)
$binLength = 64;
$sourceLength = strlen($source);
$maxlen = ($sourceLength > $binLength) ? $binLength : $sourceLength;
for ($i = 0; $i < $maxlen; $i++) {
if (ord($source[$i]) < 32) {
$predictedSourceType = 'String';
break;
}
}
}
// Uploaded image (array uploads not supported)
if (isset($_FILES[$source]) && isset($_FILES[$source]['tmp_name'])) {
$predictedSourceType = 'Upload';
}
// Otherwise, must be a file or an URL
if (!$predictedSourceType) {
$predictedSourceType = 'File';
}
return call_user_func(['WideImage', 'loadFrom'.$predictedSourceType], $source);
}
/**
* Create and load an image from a file or URL. The image format is auto-detected.
*
* @param string $uri File or url
*
* @return WideImage_Image WideImage_PaletteImage or WideImage_TrueColorImage instance
*/
public static function loadFromFile($uri)
{
$data = file_get_contents($uri);
$handle = @imagecreatefromstring($data);
if (!self::isValidImageHandle($handle)) {
try {
// try to find a mapper first
$mapper = WideImage_MapperFactory::selectMapper($uri);
if ($mapper) {
$handle = $mapper->load($uri);
}
} catch (WideImage_UnsupportedFormatException $e) {
// mapper not found
}
// try all custom mappers
if (!self::isValidImageHandle($handle)) {
$custom_mappers = WideImage_MapperFactory::getCustomMappers();
foreach ($custom_mappers as $mime_type => $mapper_class) {
$mapper = WideImage_MapperFactory::selectMapper(null, $mime_type);
$handle = $mapper->loadFromString($data);
if (self::isValidImageHandle($handle)) {
break;
}
}
}
}
if (!self::isValidImageHandle($handle)) {
throw new WideImage_InvalidImageSourceException("File '{$uri}' appears to be an invalid image source.");
}
return self::loadFromHandle($handle);
}
/**
* Create and load an image from a string. Format is auto-detected.
*
* @param string $string Binary data, i.e. from BLOB field in the database
*
* @return WideImage_Image WideImage_PaletteImage or WideImage_TrueColorImage instance
*/
public static function loadFromString($string)
{
if (strlen($string) < 128) {
throw new WideImage_InvalidImageSourceException("String doesn't contain image data.");
}
$handle = @imagecreatefromstring($string);
if (!self::isValidImageHandle($handle)) {
$custom_mappers = WideImage_MapperFactory::getCustomMappers();
foreach ($custom_mappers as $mime_type => $mapper_class) {
$mapper = WideImage_MapperFactory::selectMapper(null, $mime_type);
$handle = $mapper->loadFromString($string);
if (self::isValidImageHandle($handle)) {
break;
}
}
}
if (!self::isValidImageHandle($handle)) {
throw new WideImage_InvalidImageSourceException("String doesn't contain valid image data.");
}
return self::loadFromHandle($handle);
}
/**
* Create and load an image from an image handle.
*
* <b>Note:</b> the resulting image object takes ownership of the passed
* handle. When the newly-created image object is destroyed, the handle is
* destroyed too, so it's not a valid image handle anymore. In order to
* preserve the handle for use after object destruction, you have to call
* WideImage_Image::releaseHandle() on the created image instance prior to its
* destruction.
*
* <code>
* $handle = imagecreatefrompng('file.png');
* $image = WideImage::loadFromHandle($handle);
* </code>
*
* @param resource $handle A valid GD image resource
*
* @return WideImage_Image WideImage_PaletteImage or WideImage_TrueColorImage instance
*/
public static function loadFromHandle($handle)
{
if (!self::isValidImageHandle($handle)) {
throw new WideImage_InvalidImageSourceException('Handle is not a valid GD image resource.');
}
if (imageistruecolor($handle)) {
return new WideImage_TrueColorImage($handle);
} else {
return new WideImage_PaletteImage($handle);
}
}
/**
* This method loads a file from the $_FILES array. The image format is auto-detected.
*
* You only have to pass the field name as the parameter. For array fields, this function will
* return an array of image objects, unless you specify the $index parameter, which will
* load the desired image.
*
* @param $field_name Name of the key in $_FILES array
* @param int $index The index of the file to load (if the input field is an array)
*
* @return WideImage_Image The loaded image
*/
public static function loadFromUpload($field_name, $index = null)
{
if (!array_key_exists($field_name, $_FILES)) {
throw new WideImage_InvalidImageSourceException("Upload field '{$field_name}' doesn't exist.");
}
if (is_array($_FILES[$field_name]['tmp_name'])) {
if (isset($_FILES[$field_name]['tmp_name'][$index])) {
$filename = $_FILES[$field_name]['tmp_name'][$index];
} else {
$result = [];
foreach ($_FILES[$field_name]['tmp_name'] as $idx => $tmp_name) {
$result[$idx] = self::loadFromFile($tmp_name);
}
return $result;
}
} else {
$filename = $_FILES[$field_name]['tmp_name'];
}
if (!file_exists($filename)) {
throw new WideImage_InvalidImageSourceException("Uploaded file doesn't exist.");
}
return self::loadFromFile($filename);
}
/**
* Factory method for creating a palette image.
*
* @param int $width
* @param int $height
*
* @return WideImage_PaletteImage
*/
public static function createPaletteImage($width, $height)
{
return WideImage_PaletteImage::create($width, $height);
}
/**
* Factory method for creating a true-color image.
*
* @param int $width
* @param int $height
*
* @return WideImage_TrueColorImage
*/
public static function createTrueColorImage($width, $height)
{
return WideImage_TrueColorImage::create($width, $height);
}
/**
* Check whether the given handle is a valid GD resource.
*
* @param mixed $handle The variable to check
*
* @return bool
*/
public static function isValidImageHandle($handle)
{
return is_resource($handle) && get_resource_type($handle) == 'gd';
}
/**
* Throws exception if the handle isn't a valid GD resource.
*
* @param mixed $handle The variable to check
*/
public static function assertValidImageHandle($handle)
{
if (!self::isValidImageHandle($handle)) {
throw new WideImage_InvalidImageHandleException("{$handle} is not a valid image handle.");
}
}
}
WideImage::checkGD();
WideImage::registerCustomMapper('WideImage_Mapper_BMP', 'image/bmp', 'bmp');
WideImage::registerCustomMapper('WideImage_Mapper_TGA', 'image/tga', 'tga');