418 lines
15 KiB
PHP
418 lines
15 KiB
PHP
<?php
|
|
|
|
namespace dynamicimages\traits;
|
|
|
|
use dynamicimages\classes\dynamicimages_asset;
|
|
use dynamicimages\helpers\dynamicimages_tool;
|
|
use dynamicimages\interfaces\dynamicimages_image_i;
|
|
|
|
trait dynamicimages_image_t
|
|
{
|
|
|
|
/**
|
|
* Internal Imagick canvas (temporary, changeable image object)
|
|
*/
|
|
private ?\Imagick $image = null;
|
|
private ?int $canvasWidth = null;
|
|
private ?int $canvasHeight = null;
|
|
|
|
/**
|
|
* @var dynamicimages_tool[]
|
|
*/
|
|
private array $tools = [];
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
public function setAssets(array $assets): dynamicimages_image_i
|
|
{
|
|
$this->assets = $assets;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
public function getAssets(): array
|
|
{
|
|
return $this->assets;
|
|
}
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
public function addAsset(dynamicimages_asset $asset): dynamicimages_image_i
|
|
{
|
|
$this->assets[] = $asset;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
public function setTools(array $tools): dynamicimages_image_i
|
|
{
|
|
$this->tools = $tools;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
public function addTool(dynamicimages_tool $tool): dynamicimages_image_i
|
|
{
|
|
$this->tools[] = $tool;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
public function getTools(): array
|
|
{
|
|
return $this->tools;
|
|
}
|
|
|
|
/**
|
|
* Debug
|
|
*/
|
|
public function debugAssets(): void
|
|
{
|
|
echo 'Assets count: ' . count($this->assets) . PHP_EOL;
|
|
foreach ($this->assets as $asset) {
|
|
echo 'Asset path: ' . $asset->getPath() . ' - (Width: ' . $asset->getWidth() . ', Height: ' . $asset->getHeight() . ')' . PHP_EOL;
|
|
}
|
|
}
|
|
|
|
public function getAssetPath(string $asset_name): string
|
|
{
|
|
return $this->module_asset_path . $asset_name;
|
|
}
|
|
|
|
/**
|
|
* Resolve an absolute filesystem path to a font file located under the shared dynamicimages assets/fonts directory.
|
|
*
|
|
* Example result: WD . '/modules/dynamicimages/assets/fonts/YourFont.ttf'
|
|
*
|
|
* @param string $fontFile
|
|
* @return string absolute path
|
|
*/
|
|
public function getFontPath(string $fontFile): string
|
|
{
|
|
$fontFile = ltrim($fontFile, '/\\');
|
|
$path = WD . '/' . self::asset_path . 'fonts/' . $fontFile;
|
|
if (!is_readable($path)) {
|
|
throw new \RuntimeException('Font not found or not readable: ' . $path);
|
|
}
|
|
return $path;
|
|
}
|
|
|
|
public function setAssetPath(string $asset_path): dynamicimages_image_i
|
|
{
|
|
$this->module_asset_path = $asset_path;
|
|
return $this;
|
|
}
|
|
|
|
// ===== Canvas lifecycle =====
|
|
public function initImageCanvas(int $width, int $height, string $background = 'transparent'): dynamicimages_image_i
|
|
{
|
|
if (!extension_loaded('imagick')) {
|
|
throw new \RuntimeException('Imagick extension is required to initialize image canvas.');
|
|
}
|
|
if ($width <= 0 || $height <= 0) {
|
|
throw new \InvalidArgumentException('Canvas width and height must be positive integers.');
|
|
}
|
|
$bg = new \ImagickPixel($background === 'transparent' ? 'transparent' : $background);
|
|
$this->image = new \Imagick();
|
|
$this->image->newImage($width, $height, $bg, 'png'); // ensure alpha channel
|
|
$this->image->setImageFormat('png');
|
|
$this->canvasWidth = $width;
|
|
$this->canvasHeight = $height;
|
|
return $this;
|
|
}
|
|
|
|
public function clearImage(): dynamicimages_image_i
|
|
{
|
|
if ($this->image instanceof \Imagick) {
|
|
$this->image->clear();
|
|
$this->image->destroy();
|
|
}
|
|
$this->image = null;
|
|
$this->canvasWidth = null;
|
|
$this->canvasHeight = null;
|
|
return $this;
|
|
}
|
|
|
|
public function getCanvasSize(): array
|
|
{
|
|
$this->assertCanvasInitialized();
|
|
return ['width' => $this->canvasWidth, 'height' => $this->canvasHeight];
|
|
}
|
|
|
|
// ===== Explicit asset compositing =====
|
|
public function drawAsset(dynamicimages_asset $asset, int $x, int $y, float $opacity = 1.0): dynamicimages_image_i
|
|
{
|
|
$this->assertCanvasInitialized();
|
|
if ($opacity < 0.0 || $opacity > 1.0) {
|
|
throw new \InvalidArgumentException('Opacity must be between 0.0 and 1.0');
|
|
}
|
|
// If the asset has an in-memory image (e.g., rotated), use it; otherwise load from path
|
|
$memoryImage = method_exists($asset, 'getMemoryImage') ? $asset->getMemoryImage() : null;
|
|
if ($memoryImage instanceof \Imagick) {
|
|
$layer = $memoryImage; // already a clone from asset
|
|
} else {
|
|
if (!is_readable($asset->getPath())) {
|
|
throw new \RuntimeException('Asset is not readable: ' . $asset->getPath());
|
|
}
|
|
$layer = new \Imagick();
|
|
$layer->readImage($asset->getPath());
|
|
}
|
|
// Normalize to support alpha
|
|
$layer->setImageAlphaChannel(\Imagick::ALPHACHANNEL_SET);
|
|
if ($opacity < 1.0) {
|
|
$layer->evaluateImage(\Imagick::EVALUATE_MULTIPLY, $opacity, \Imagick::CHANNEL_ALPHA);
|
|
}
|
|
$this->image->compositeImage($layer, \Imagick::COMPOSITE_DEFAULT, $x, $y);
|
|
$layer->clear();
|
|
$layer->destroy();
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Draw an asset centered around the given coordinates.
|
|
* This is useful for rotated layers whose bounding box changes per angle,
|
|
* but should visually share the same pivot point.
|
|
*/
|
|
public function drawAssetCentered(dynamicimages_asset $asset, int $centerX, int $centerY, float $opacity = 1.0): dynamicimages_image_i
|
|
{
|
|
$this->assertCanvasInitialized();
|
|
if ($opacity < 0.0 || $opacity > 1.0) {
|
|
throw new \InvalidArgumentException('Opacity must be between 0.0 and 1.0');
|
|
}
|
|
$memoryImage = method_exists($asset, 'getMemoryImage') ? $asset->getMemoryImage() : null;
|
|
if ($memoryImage instanceof \Imagick) {
|
|
$layer = $memoryImage; // already a clone from asset
|
|
} else {
|
|
if (!is_readable($asset->getPath())) {
|
|
throw new \RuntimeException('Asset is not readable: ' . $asset->getPath());
|
|
}
|
|
$layer = new \Imagick();
|
|
$layer->readImage($asset->getPath());
|
|
}
|
|
$layer->setImageAlphaChannel(\Imagick::ALPHACHANNEL_SET);
|
|
if ($opacity < 1.0) {
|
|
$layer->evaluateImage(\Imagick::EVALUATE_MULTIPLY, $opacity, \Imagick::CHANNEL_ALPHA);
|
|
}
|
|
$w = (int)$layer->getImageWidth();
|
|
$h = (int)$layer->getImageHeight();
|
|
$x = (int)floor($centerX - $w / 2);
|
|
$y = (int)floor($centerY - $h / 2);
|
|
$this->image->compositeImage($layer, \Imagick::COMPOSITE_DEFAULT, $x, $y);
|
|
$layer->clear();
|
|
$layer->destroy();
|
|
return $this;
|
|
}
|
|
|
|
// ===== Transformations on the temporary image object =====
|
|
public function resize(int $width, int $height): dynamicimages_image_i
|
|
{
|
|
$this->assertCanvasInitialized();
|
|
if ($width <= 0 || $height <= 0) {
|
|
throw new \InvalidArgumentException('Resize width and height must be positive integers.');
|
|
}
|
|
$this->image->resizeImage($width, $height, \Imagick::FILTER_LANCZOS, 1.0);
|
|
$this->canvasWidth = $width;
|
|
$this->canvasHeight = $height;
|
|
return $this;
|
|
}
|
|
|
|
public function resizeToMaxWidth(int $maxWidth): dynamicimages_image_i
|
|
{
|
|
$this->assertCanvasInitialized();
|
|
if ($maxWidth <= 0) {
|
|
throw new \InvalidArgumentException('Resize max width must be a positive integer.');
|
|
}
|
|
if ($this->canvasWidth === null || $this->canvasHeight === null || $this->canvasWidth <= $maxWidth) {
|
|
return $this;
|
|
}
|
|
|
|
$height = (int)round($this->canvasHeight * ($maxWidth / $this->canvasWidth));
|
|
return $this->resize($maxWidth, max(1, $height));
|
|
}
|
|
|
|
public function crop(int $width, int $height, int $x, int $y): dynamicimages_image_i
|
|
{
|
|
$this->assertCanvasInitialized();
|
|
if ($width <= 0 || $height <= 0) {
|
|
throw new \InvalidArgumentException('Crop width and height must be positive integers.');
|
|
}
|
|
$this->image->cropImage($width, $height, $x, $y);
|
|
// Reset canvas virtual page to avoid offsets
|
|
$this->image->setImagePage(0, 0, 0, 0);
|
|
$this->canvasWidth = $width;
|
|
$this->canvasHeight = $height;
|
|
return $this;
|
|
}
|
|
|
|
public function rotate(float $degrees, string $background = 'transparent'): dynamicimages_image_i
|
|
{
|
|
$this->assertCanvasInitialized();
|
|
$bg = new \ImagickPixel($background === 'transparent' ? 'transparent' : $background);
|
|
$this->image->rotateImage($bg, $degrees);
|
|
// Reset virtual page so top-left is (0,0) after rotation; rotation occurs around center
|
|
$this->image->setImagePage(0, 0, 0, 0);
|
|
// Update stored dimensions
|
|
$this->canvasWidth = (int)$this->image->getImageWidth();
|
|
$this->canvasHeight = (int)$this->image->getImageHeight();
|
|
return $this;
|
|
}
|
|
|
|
public function setOpacity(float $opacity): dynamicimages_image_i
|
|
{
|
|
$this->assertCanvasInitialized();
|
|
if ($opacity < 0.0 || $opacity > 1.0) {
|
|
throw new \InvalidArgumentException('Opacity must be between 0.0 and 1.0');
|
|
}
|
|
$this->image->setImageAlphaChannel(\Imagick::ALPHACHANNEL_SET);
|
|
$this->image->evaluateImage(\Imagick::EVALUATE_MULTIPLY, $opacity, \Imagick::CHANNEL_ALPHA);
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Draw a straight line on the current canvas.
|
|
*
|
|
* @param int $x1 Starting X coordinate
|
|
* @param int $y1 Starting Y coordinate
|
|
* @param int $x2 Ending X coordinate
|
|
* @param int $y2 Ending Y coordinate
|
|
* @param string $color Any Imagick-compatible color string (e.g., 'red', '#FF0000', 'rgba(255,0,0,0.7)')
|
|
* @param int $thickness Stroke width in pixels
|
|
* @param array<int,float>|null $dash Optional dash pattern (e.g., [10,5] for dashed line)
|
|
* @return dynamicimages_image_i
|
|
*/
|
|
public function drawLine(int $x1, int $y1, int $x2, int $y2, string $color = 'rgba(255,0,0,1.0)', int $thickness = 1, ?array $dash = null): dynamicimages_image_i
|
|
{
|
|
$this->assertCanvasInitialized();
|
|
$draw = new \ImagickDraw();
|
|
$draw->setStrokeColor(new \ImagickPixel($color));
|
|
$draw->setStrokeWidth(max(1, $thickness));
|
|
$draw->setFillOpacity(0.0);
|
|
if ($dash !== null && count($dash) > 0) {
|
|
// Imagick expects an array of floats for dash and a dash offset
|
|
$draw->setStrokeDashArray(array_map('floatval', $dash));
|
|
$draw->setStrokeDashOffset(0);
|
|
}
|
|
$draw->line($x1, $y1, $x2, $y2);
|
|
$this->image->drawImage($draw);
|
|
$draw->clear();
|
|
$draw->destroy();
|
|
return $this;
|
|
}
|
|
|
|
private function assertCanvasInitialized(): void
|
|
{
|
|
if (!$this->image instanceof \Imagick) {
|
|
throw new \RuntimeException('Canvas is not initialized. Call initImageCanvas() first.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Export the first asset as a base64 data URI. If no assets exist, throws an exception.
|
|
*/
|
|
public function exportAsBase64(?string $format = null, int $quality = 90): string
|
|
{
|
|
if ($this->image instanceof \Imagick) {
|
|
return 'data:image/png;base64,' . base64_encode($this->exportBinary($format, $quality));
|
|
}
|
|
|
|
// Fallback: export first asset as-is
|
|
if (empty($this->assets)) {
|
|
throw new \RuntimeException('No assets available to export.');
|
|
}
|
|
$asset = $this->assets[0];
|
|
$path = $asset->getPath();
|
|
if (!is_readable($path)) {
|
|
throw new \RuntimeException('Asset is not readable: ' . $path);
|
|
}
|
|
$imgInfo = @getimagesize($path);
|
|
$mime = is_array($imgInfo) && isset($imgInfo['mime']) ? $imgInfo['mime'] : 'application/octet-stream';
|
|
$data = file_get_contents($path);
|
|
if ($data === false) {
|
|
throw new \RuntimeException('Failed to read asset: ' . $path);
|
|
}
|
|
return 'data:' . $mime . ';base64,' . base64_encode($data);
|
|
}
|
|
|
|
public function exportBinary(?string $format = null, int $quality = 90): string
|
|
{
|
|
// If a canvas is initialized, export that as PNG by default
|
|
if ($this->image instanceof \Imagick) {
|
|
$img = clone $this->image;
|
|
$img->setImageFormat('png');
|
|
// Quality influences compression for PNG differently; keep as hint
|
|
if ($format !== null && strtolower($format) !== 'png') {
|
|
// For now we only support PNG for composed images as requested
|
|
}
|
|
// Strip metadata to reduce size
|
|
$img->stripImage();
|
|
$blob = $img->getImageBlob();
|
|
$img->clear();
|
|
$img->destroy();
|
|
return $blob;
|
|
}
|
|
|
|
// Fallback: export first asset as-is
|
|
if (empty($this->assets)) {
|
|
throw new \RuntimeException('No assets available to export.');
|
|
}
|
|
$asset = $this->assets[0];
|
|
$path = $asset->getPath();
|
|
if (!is_readable($path)) {
|
|
throw new \RuntimeException('Asset is not readable: ' . $path);
|
|
}
|
|
$data = file_get_contents($path);
|
|
if ($data === false) {
|
|
throw new \RuntimeException('Failed to read asset: ' . $path);
|
|
}
|
|
return $data;
|
|
}
|
|
|
|
public function getAsset(string $asset_name): ?dynamicimages_asset
|
|
{
|
|
foreach ($this->assets as $asset) {
|
|
if (basename($asset->getPath()) === $asset_name) {
|
|
return $asset;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Return the image file as a response directly to the browser
|
|
*
|
|
*/
|
|
public function outputImage(?string $format = null, int $quality = 90): void
|
|
{
|
|
$mimeType = 'image/png';
|
|
if (!$this->image instanceof \Imagick && !empty($this->assets)) {
|
|
$asset = $this->assets[0];
|
|
$path = $asset->getPath();
|
|
$imgInfo = is_readable($path) ? @getimagesize($path) : false;
|
|
$mimeType = is_array($imgInfo) && isset($imgInfo['mime']) ? $imgInfo['mime'] : 'application/octet-stream';
|
|
}
|
|
$imageData = $this->exportBinary($format, $quality);
|
|
header('Content-Type: ' . $mimeType);
|
|
header('Content-Length: ' . strlen($imageData));
|
|
echo $imageData;
|
|
exit;
|
|
}
|
|
|
|
/**
|
|
* Serve the composed picture directly to the client. Wrapper for outputImage.
|
|
*/
|
|
public function servePicture(?string $format = null, int $quality = 90): void
|
|
{
|
|
$this->outputImage($format, $quality);
|
|
}
|
|
}
|