Class WideImage\Image


					
	public

__construct(resource $handle)

The base class constructor

Parameters

$handle

Image handle (GD2 resource)

Overriden by

WideImage\TrueColorImage::__construct()

#


					
	public

__destruct()

Cleanup

Destroys the handle via \WideImage\Image::destroy() when called by the GC.

#


					
	public

destroy()

This method destroy the image handle, and releases the image resource.

After this is called, the object doesn't hold a valid image any more. No operation should be called after that.

#


					
	public

getHandle(): resource

Returns the GD image resource

Returns

GD image resource

#


					
	public

isValid(): bool

Returns

True, if the image object holds a valid GD image, false otherwise

#


					
	public

releaseHandle()

Releases the handle

#


					
	public

saveToFile(string $uri)

Saves an image to a file

The file type is recognized from the $uri. If you save to a GIF8, truecolor images are automatically converted to palette.

This method supports additional parameters: quality (for jpeg images) and compression quality and filters (for png images). See http://www.php.net/imagejpeg and http://www.php.net/imagepng for details.

Examples: // save to a GIF $image->saveToFile('image.gif');


// save to a PNG with compression=7 and no filters
$image->saveToFile('image.png', 7, PNG_NO_FILTER);
// save to a JPEG with quality=80
$image->saveToFile('image.jpg', 80);

// save to a JPEG with default quality=100 $image->saveToFile('image.jpg');

Parameters

$uri

File location

#


					
	public

asString(string $format): string

Returns binary string with image data in format specified by $format

Additional parameters may be passed to the function. See \WideImage\Image::saveToFile() for more details.

Parameters

$format

The format of the image

Returns

The binary image data in specified format

#


					
	protected

writeHeader($name, $data)

Output a header to browser.

#


					
	public

output(string $format)

Outputs the image to browser

Sets headers Content-length and Content-type, and echoes the image in the specified format. All other headers (such as Content-disposition) must be added manually.

Example: WideImage::load('image1.png')->resize(100, 100)->output('gif');

Parameters

$format

Image format

#


					
	public

getWidth(): int

Returns

Image width

#


					
	public

getHeight(): int

Returns

Image height

#


					
	public

allocateColor(mixed $R, int $G = null, int $B = null): int

Allocate a color by RGB values.

Parameters

`$R`	Red-component value or an RGB array (with red, green, blue keys)
`$G`	If $R is int, this is the green component
`$B`	If $R is int, this is the blue component

Returns

Image color index

#


					
	public

isTransparent(): bool

Returns

True if the image is transparent, false otherwise

#


					
	public

getTransparentColor(): int

Returns

Transparent color index

#


					
	public

setTransparentColor(int $color)

Sets the current transparent color index. Only makes sense for palette images (8-bit).

Parameters

$color

Transparent color index

#


					
	public

getTransparentColorRGB(): mixed

Returns a RGB array of the transparent color or null if none.

Returns

Transparent color RGBA array

#


					
	public

getRGBAt(int $x, int $y): array

Returns a RGBA array for pixel at $x, $y

Returns

RGB array

#


					
	public

setRGBAt(int $x, int $y, array $color)

Writes a pixel at the designated coordinates

Takes an associative array of colours and uses getExactColor() to retrieve the exact index color to write to the image with.

#


					
	public

getColorRGB(int $colorIndex): mixed

Returns a color's RGB

Parameters

$colorIndex

Color index

Returns

RGBA array for a color with index $colorIndex

#


					
	public

getColorAt(int $x, int $y): int

Returns an index of the color at $x, $y

Returns

Color index for a pixel at $x, $y

#


					
	public

setColorAt(int $x, int $y, int $color)

Set the color index $color to a pixel at $x, $y

Parameters

$color

Color index

#


					
	public

getClosestColor(mixed $R, int $G = null, int $B = null): int

Returns closest color index that matches the given RGB value. Uses PHP's imagecolorclosest()

Parameters

`$R`	Red or RGBA array
`$G`	Green component (or null if $R is an RGB array)
`$B`	Blue component (or null if $R is an RGB array)

Returns

Color index

#


					
	public

getExactColor(mixed $R, int $G = null, int $B = null): int

Returns the color index that exactly matches the given RGB value. Uses PHP's imagecolorexact()

Parameters

`$R`	Red or RGBA array
`$G`	Green component (or null if $R is an RGB array)
`$B`	Blue component (or null if $R is an RGB array)

Returns

Color index

#


					
	public

copyTransparencyFrom(object $sourceImage, bool $fill = true)

Copies transparency information from $sourceImage. Optionally fills the image with the transparent color at (0, 0).

Parameters

$fill

True if you want to fill the image with transparent color

#


					
	public

fill(int $x, int $y, int $color)

Fill the image at ($x, $y) with color index $color

#


					
	protected

getOperation(string $name): object

Used internally to create Operation objects

#


					
	public

getMask(): Image

Returns the image's mask

Mask is a greyscale image where the shade defines the alpha channel (black = transparent, white = opaque).

For opaque images (JPEG), the result will be white. For images with single-color transparency (GIF, 8-bit PNG), the areas with the transparent color will be black. For images with alpha channel transparenct, the result will be alpha channel.

Returns

An image mask

#


					
	public

resize(mixed $width = null, mixed $height = null, string $fit = 'inside', string $scale = 'any'): Image

Resize the image to given dimensions.

$width and $height are both smart coordinates. This means that you can pass any of these values in:

positive or negative integer (100, -20, ...)
positive or negative percent string (30%, -15%, ...)
complex coordinate (50% - 20, 15 + 30%, ...)
null: if one dimension is null, it's calculated proportionally from the other.

$fit parameter can be set to one of these three values:

'inside': resize proportionally and fit the resulting image tightly in the $width x $height box
'outside': resize proportionally and fit the resulting image tighly outside the box
'fill': resize the image to fill the $width x $height box exactly

$scale parameter can be:

'down': only resize the image if it's larger than the $width x $height box
'up': only resize the image if it's smaller than the $width x $height box
'any': resize the image

Example (resize to half-size): $smaller = $image->resize('50%');

$smaller = $image->resize('100', '100', 'inside', 'down'); is the same as $smaller = $image->resizeDown(100, 100, 'inside');

Parameters

`$width`	The new width (smart coordinate), or null.
`$height`	The new height (smart coordinate), or null.
`$fit`	'inside', 'outside', 'fill'
`$scale`	'down', 'up', 'any'

Returns

The resized image

#


					
	public

resizeDown(int $width = null, int $height = null, string $fit = 'inside'): Image

Same as \WideImage\Image::resize(), but the image is only applied if it is larger then the given dimensions. Otherwise,…

Same as \WideImage\Image::resize(), but the image is only applied if it is larger then the given dimensions. Otherwise, the resulting image retains the source's dimensions.

Parameters

`$width`	New width, smart coordinate
`$height`	New height, smart coordinate
`$fit`	'inside', 'outside', 'fill'

Returns

resized image

#


					
	public

resizeUp(int $width = null, int $height = null, string $fit = 'inside'): Image

Same as \WideImage\Image::resize(), but the image is only applied if it is smaller then the given dimensions. Otherwise…

Same as \WideImage\Image::resize(), but the image is only applied if it is smaller then the given dimensions. Otherwise, the resulting image retains the source's dimensions.

Parameters

`$width`	New width, smart coordinate
`$height`	New height, smart coordinate
`$fit`	'inside', 'outside', 'fill'

Returns

resized image

#


					
	public

rotate(int $angle, int $bgColor = null, bool $ignoreTransparent = true): Image

Rotate the image for angle $angle clockwise.

Preserves transparency. Has issues when saving to a BMP.

Parameters

`$angle`	Angle in degrees, clock-wise
`$bgColor`	color of the new background

Returns

The rotated image

#


					
	public

merge(Image $overlay, mixed $left = 0, mixed $top = 0, int $pct = 100): Image

This method lays the overlay (watermark) on the image.

Hint: if the overlay is a truecolor image with alpha channel, you should leave $pct at 100.

This operation supports alignment notation in coordinates: $watermark = WideImage::load('logo.gif'); $base = WideImage::load('picture.jpg'); $result = $base->merge($watermark, "right - 10", "bottom - 10", 50); // applies a logo aligned to bottom-right corner with a 10 pixel margin

Parameters

`$overlay`	The overlay image
`$left`	Left position of the overlay, smart coordinate
`$top`	Top position of the overlay, smart coordinate
`$pct`	The opacity of the overlay

Returns

The merged image

#


					
	public

resizeCanvas(
	mixed $width,
	mixed $height,
	mixed $pos_x,
	mixed $pos_y,
	int $bg_color = null,
	string $scale = 'any',
	bool $merge = false,
): Image

Resizes the canvas of the image, but doesn't scale the content of the image

This operation creates an empty canvas with dimensions $width x $height, filled with background color $bg_color and draws the original image onto it at position [$pos_x, $pos_y].

Arguments $width, $height, $pos_x and $pos_y are all smart coordinates. $width and $height are relative to the current image size, $pos_x and $pos_y are relative to the newly calculated canvas size. This can be confusing, but it makes sense. See the example below.

The example below loads a 100x150 image and then resizes its canvas to 200% x 100%+20 (which evaluates to 200x170). The image is placed at position [10, center+20], which evaluates to [10, 30]. $image = WideImage::load('someimage.jpg'); // 100x150 $white = $image->allocateColor(255, 255, 255); $image->resizeCanvas('200%', '100% + 20', 10, 'center+20', $white);

The parameter $merge defines whether the original image should be merged onto the new canvas. This means it blends transparent color and alpha colors into the background color. If set to false, the original image is just copied over, preserving the transparency/alpha information.

You can set the $scale parameter to limit when to resize the canvas. For example, if you want to resize the canvas only if the image is smaller than the new size, but leave the image intact if it's larger, set it to 'up'. Likewise, if you want to shrink the canvas, but don't want to change images that are already smaller, set it to 'down'.

Parameters

`$width`	Width of the new canvas (smart coordinate, relative to current image width)
`$height`	Height of the new canvas (smart coordinate, relative to current image height)
`$pos_x`	x-position of the image (smart coordinate, relative to the new width)
`$pos_y`	y-position of the image (smart coordinate, relative to the new height)
`$bg_color`	Background color (created with allocateColor or allocateColorAlpha), defaults to null (tries to use a transparent color)
`$scale`	Possible values: 'up' (enlarge only), 'down' (downsize only), 'any' (resize precisely to $width x $height). Defaults to 'any'.
`$merge`	Merge the original image (flatten alpha channel and transparency) or copy it over (preserve). Defaults to false.

Returns

The resulting image with resized canvas

#


					
	public

roundCorners(int $radius, int $color = null, int $smoothness = 2, int $corners = 255): Image

Returns an image with round corners

You can either set the corners' color or set them transparent.

Note on $smoothness: 1 means jagged edges, 2 is much better, more than 4 doesn't noticeably improve the quality. Rendering becomes increasingly slower if you increase smoothness.

Example: $nice = $ugly->roundCorners(20, $ugly->allocateColor(255, 0, 0), 2);

Use $corners parameter to specify which corners to draw rounded. Possible values are WideImage::SIDE_TOP_LEFT, WideImage::SIDE_TOP, WideImage::SIDE_TOP_RIGHT, WideImage::SIDE_RIGHT, WideImage::SIDE_BOTTOM_RIGHT, WideImage::SIDE_BOTTOM, WideImage::SIDE_BOTTOM_LEFT, WideImage::SIDE_LEFT, and WideImage::SIDE_ALL. You can specify any combination of corners with a + operation, see example below.

Example: $white = $image->allocateColor(255, 255, 255); $diagonal_corners = $image->roundCorners(15, $white, 2, WideImage::SIDE_TOP_LEFT + WideImage::SIDE_BOTTOM_RIGHT); $right_corners = $image->roundCorners(15, $white, 2, WideImage::SIDE_RIGHT);

Parameters

`$radius`	Radius of the corners
`$color`	The color of corners. If null, corners are rendered transparent (slower than using a solid color).
`$smoothness`	Specify the level of smoothness. Suggested values from 1 to 4.
`$corners`	Specify which corners to draw (defaults to WideImage::SIDE_ALL = all corners)

Returns

The resulting image with round corners

#


					
	public

applyMask(Image $mask, mixed $left = 0, mixed $top = 0): Image

Returns an image with applied mask

A mask is a grayscale image, where the shade determines the alpha channel. Black is fully transparent and white is fully opaque.

Parameters

`$mask`	The mask image, greyscale
`$left`	Left coordinate, smart coordinate
`$top`	Top coordinate, smart coordinate

Returns

The resulting image

#


					
	public

applyFilter(int $filter, int $arg1 = null, int $arg2 = null, int $arg3 = null, int $arg4 = null): Image

Applies a filter

Parameters

$filter

One of the IMG_FILTER_* constants

#


					
	public

applyConvolution(array $matrix, float $div, float $offset): Image

Applies convolution matrix with imageconvolution()

#


					
	public

crop(mixed $left = 0, mixed $top = 0, mixed $width = '100%', mixed $height = '100%'): Image

Returns a cropped rectangular portion of the image

If the rectangle specifies area that is out of bounds, it's limited to the current image bounds.

Examples: $cropped = $img->crop(10, 10, 150, 200); // crops a 150x200 rect at (10, 10) $cropped = $img->crop(-100, -50, 100, 50); // crops a 100x50 rect at the right-bottom of the image $cropped = $img->crop('25%', '25%', '50%', '50%'); // crops a 50%x50% rect from the center of the image

This operation supports alignment notation in left/top coordinates. Example: $cropped = $img->crop("right", "bottom", 100, 200); // crops a 100x200 rect from right bottom $cropped = $img->crop("center", "middle", 50, 30); // crops a 50x30 from the center of the image

Parameters

`$left`	Left-coordinate of the crop rect, smart coordinate
`$top`	Top-coordinate of the crop rect, smart coordinate
`$width`	Width of the crop rect, smart coordinate
`$height`	Height of the crop rect, smart coordinate

Returns

The cropped image

#


					
	public

autoCrop(int $margin = 0, int $rgb_threshold = 0, int $pixel_cutoff = 1, int $base_color = null): Image

Performs an auto-crop on the image

The image is auto-cropped from each of four sides. All sides are scanned for pixels that differ from $base_color for more than $rgb_threshold in absolute RGB difference. If more than $pixel_cutoff differentiating pixels are found, that line is considered to be the crop line for the side. If the line isn't different enough, the algorithm procedes to the next line towards the other edge of the image.

When the crop rectangle is found, it's enlarged by the $margin value on each of the four sides.

Parameters

`$margin`	Margin for the crop rectangle, can be negative.
`$rgb_threshold`	RGB difference which still counts as "same color".
`$pixel_cutoff`	How many pixels need to be different to mark a cut line.
`$base_color`	The base color index. If none specified (or null given), left-top pixel is used.

Returns

The cropped image

#


					
	public

asNegative(): Image

Returns a negative of the image

This operation differs from calling \WideImage\Image::applyFilter(IMG_FILTER_NEGATIVE), because it's 8-bit and transparency safe. This means it will return an 8-bit image, if the source image is 8-bit. If that 8-bit image has a palette transparency, the resulting image will keep transparency.

Returns

negative of the image

#


					
	public

asGrayscale(): Image

Returns a grayscale copy of the image

Returns

grayscale copy

#


					
	public

mirror(): Image

Returns a mirrored copy of the image

Returns

Mirrored copy

#


					
	public

unsharp(float $amount, float $radius, float $threshold): Image

Applies the unsharp filter

Returns

Unsharpened copy of the image

#


					
	public

flip(): Image

Returns a flipped (mirrored over horizontal line) copy of the image

Returns

Flipped copy

#


					
	public

correctGamma(float $inputGamma, float $outputGamma): Image

Corrects gamma on the image

Returns

Image with corrected gamma

#


					
	public

addNoise(int $amount, string $type): Image

Adds noise to the image

Parameters

`$amount`	Number of noise pixels to add
`$type`	Type of noise 'salt&pepper', 'color' or 'mono'

Returns

Image with noise added

#


					
	public

__call(string $name, array $args): Image

Used internally to execute operations

#


					
	public

__toString(): string

Returns an image in GIF or PNG format

#


					
	public

copy(): Image

Returns a copy of the image object

Returns

The copy

#


					
	public

copyTo(Image $dest, int $left = 0, int $top = 0)

Copies this image onto another image

#


					
	public

getCanvas(): Canvas

Returns the canvas object

The Canvas object can be used to draw text and shapes on the image

Examples: $img = WideImage::load('pic.jpg); $canvas = $img->getCanvas(); $canvas->useFont('arial.ttf', 15, $img->allocateColor(200, 220, 255)); $canvas->writeText(10, 50, "Hello world!");

$canvas->filledRectangle(10, 10, 80, 40, $img->allocateColor(255, 127, 255)); $canvas->line(60, 80, 30, 100, $img->allocateColor(255, 0, 0)); $img->saveToFile('new.png');

Returns

The Canvas object

#


					abstract
	public

isTrueColor(): bool

Returns true if the image is true-color, false otherwise

Implemented by

#


					abstract
	public

asTrueColor(): TrueColorImage

Returns a true-color copy of the image

Implemented by

#


					abstract
	public

asPalette(int $nColors = 255, bool $dither = null, bool $matchPalette = true): Image

Returns a palette copy (8bit) of the image

Parameters

`$nColors`	Number of colors in the resulting image, more than 0, less or equal to 255
`$dither`	Use dithering or not
`$matchPalette`	Set to true to use imagecolormatch() to match the resulting palette more closely to the original image

Implemented by

#


					abstract
	public

getChannels(): Image

Retrieve an image with selected channels

Examples: $channels = $img->getChannels('red', 'blue'); $channels = $img->getChannels('alpha', 'green'); $channels = $img->getChannels(array('green', 'blue'));

Implemented by

#


					abstract
	public

copyNoAlpha(): Image

Returns an image without an alpha channel

Implemented by

#


					
	public

__sleep(): array

Returns an array of serializable protected variables. Called automatically upon serialize().

#


					
	public

__wakeup()

Restores an image from serialization. Called automatically upon unserialize().

#

Properties
`protected`	`resource`	`$handle = null`	#
`protected`	`bool`	`$handleReleased = false`	#
`protected`	`Canvas`	`$canvas = null`	#
`protected`	`string`	`$sdata = null`	#

Namespaces

Classes

Class WideImage\Image

Parameters

Overriden by

Returns

Returns

Parameters

Parameters

Returns

Parameters

Returns

Returns

Parameters

Returns

Returns

Returns

Parameters

Returns

Returns

Parameters

Returns

Returns

Parameters

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Parameters

Returns

Parameters

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Parameters

Returns

Returns

Returns

Implemented by

Implemented by

Parameters

Implemented by

Implemented by

Implemented by