File Source for LImage.php

<?php
/**
* Class file.
*
* @license http://opensource.org/licenses/mozilla1.1.php Mozilla Public License
* @copyright 2005, diemeisterei GmbH. All rights reserved.
* @author $Author: schmunk $
* @version $Revision: 625 $ $Date: 2007-02-25 02:05:09 +0100 (Sun, 25 Feb 2007) $
* @package Phundament.Components
* @subpackage WebControls
*/
/**
* This is a combination of an extended TImage and a wrapper for ImageMagick functions
*
* @package System.Web.UI.WebControls
* @subpackage Graphics
* @todo define max dimensions for image rendering!!! PERFORMANCE & MEMORY
*/
class LImage extends TImage
{
private $SrcUrl;
private $SrcRealpath;
private $DestUrl;
private $DestRealpath;
private $OutputDir;
private $SrcExt;
private $BinPath;
private $Info;
// TODO (PRADO hotfix?)
/**
* @return string the URL of the image file
*/
public function getImageUrl()
{
return TPropertyValue :: ensureString($this->getViewState('ImageUrl', ''));
}
/**
* @param string the URL of the image file
*/
public function setImageUrl($value)
{
$this->setViewState('ImageUrl', $value, '');
}
public function setResize($value)
{
$this->setViewState('Resize', TPropertyValue :: ensureBoolean($value), '');
}
public function getResize()
{
return $this->getViewState('Resize', true);
}
public function setDestWidth($value)
{
$this->setViewState('DestWidth', TPropertyValue :: ensureInteger($value), '');
}
public function getDestWidth()
{
return $this->getViewState('DestWidth');
}
public function setDestHeight($value)
{
$this->setViewState('DestHeight', TPropertyValue :: ensureInteger($value), '');
}
public function getDestHeight()
{
return $this->getViewState('DestHeight');
}
public function setDestQuality($value)
{
$this->setViewState('DestQuality', TPropertyValue :: ensureInteger($value), '');
}
public function getDestQuality()
{
return $this->getViewState('DestQuality', "50");
}
public function setDestType($value)
{
$this->setViewState('DestType', TPropertyValue :: ensureString(strtoupper($value)), '');
}
public function getDestType()
{
return $this->getViewState('DestType', 'jpg');
}
public function setDestColorSpace($value)
{
$this->setViewState('DestColorSpace', TPropertyValue :: ensureString($value), '');
}
public function getDestColorSpace()
{
return $this->getViewState('DestColorSpace', "rgb");
}
public function setShowMimeTypeImage($value)
{
$this->setViewState('ShowMimeTypeImage', TPropertyValue :: ensureBoolean($value), '');
}
public function getShowMimeTypeImage()
{
return $this->getViewState('ShowMimeTypeImage', false);
}
public function setDestBackgroundColor($value)
{
$this->setViewState('BackgroundColor', TPropertyValue :: ensureString($value), '');
}
public function getDestBackgroundColor()
{
return $this->getViewState('BackgroundColor', null);
}
public function setPageNumber($value)
{
$this->setViewState('PageNumber', TPropertyValue :: ensureInteger($value), 0);
}
public function getPageNumber()
{
return $this->getViewState('PageNumber', 0);
}
public function setIsRendered($value)
{
$this->setViewState('IsRendered', TPropertyValue :: ensureBoolean($value), false);
}
public function getIsRendered()
{
return $this->getViewState('IsRendered', false);
}
public function setPxEmFactor($value)
{
$this->setViewState('PxEmFactor', $value);
}
public function getPxEmFactor()
{
return $this->getViewState('PxEmFactor', false);
}
public function getAbortRemainingExecutionTime()
{
if ($t= $this->Application->Parameters['AbortRemainingExecutionTime'])
return $t;
else
return 5;
}
/**
* @ignore
*/
public function onInit($param)
{
#Prado :: trace("LImage onInit starting ... ", "Lithron.LImage");
$param= $this->Application->getParameters();
$this->OutputDir= $param->itemAt("OutputDir");
parent :: onInit($param);
#Prado :: trace("LImage onInit complete", "Lithron.LImage");
}
function __construct()
{
$this->findImageMagick();
if (empty ($this->BinPath))
{
Prado :: log("ImageMagick not found", 32, "Lithron.LImage");
return;
}
}
/**
* @todo double
*/
public function onLoad($param)
{
parent :: onLoad($param);
#$this->work();
}
/**
* @todo double
*/
public function onPreRender($param)
{
parent :: onPreRender($param);
// check if we should abort rendering
$settings= $this->Application->getModule("php_settings");
if ($settings instanceof TModule)
{
$t= $settings->getRemainingExecutionTime();
$at= $this->getAbortRemainingExecutionTime();
if ($t < $at)
{
$this->Controls[]= "image not yet rendered";
$this->ImageUrl= "_IMAGE_NOT_YET_RENDERED_";
Prado :: log("Rendering aborted, only $t sec(s) time left", TLogger :: INFO, "Lithron.LImage");
return;
}
}
// assume rendered image when url points to tmp path, otherwise postback problems
if (!strstr($this->ImageUrl, $this->OutputDir))
{
$this->work();
// TODO
try
{
# $this->ImageUrl;
$info= getimagesize($this->Application->BasePath . "/../" . $this->ImageUrl);
#$this->PxEmFactor = 12;
if ($this->PxEmFactor)
{
$this->Width= ($info[0] / 10) . "em";
$this->Height= ($info[1] / 10) . "em";
}
else
{
$this->Width= $info[0];
$this->Height= $info[1];
}
}
catch (Exception $e)
{
Prado :: log($e->getMessage(), 2, "Lithron.LImage");
}
}
else
{
}
}
private function work()
{
if (empty ($this->BinPath))
{
return;
}
if ($this->getResize() == true && $this->getImageUrl())
{
$this->generateImage();
}
else
if ($this->getImageUrl())
{
// todo;
try
{
$publishedUrl= $this->publishFilePath($this->getImageUrl());
$this->setImageUrl($publishedUrl);
$this->IsRendered= true;
}
catch (Exception $e)
{
Prado :: log($e->getMessage(), 8);
}
}
}
public function doIdentify($file)
{
return $this->identify($file);
}
/**
* Searches ImageMagick in file system
*/
private function findImageMagick()
{
if ($this->BinPath= $this->Application->getGlobalState("LImage:BinPath"))
{
putenv("PATH=" . $this->BinPath);
return;
}
$param= $this->Application->getParameters();
$paths= explode(";", $param->itemAt("ImagickSearchPaths"));
foreach ($paths AS $path)
{
if (!is_dir($path))
continue;
#echo $path;exit;
exec($path . "/identify -version", $output);
if (isset ($output[0]) && strstr($output[0], "ImageMagick"))
{
$this->BinPath= $path . "/";
$this->Application->setGlobalState("LImage:BinPath", $this->BinPath);
return;
#break;
}
#$this->BinPath;
}
}
/**
* Invokes image generation
*/
private function generateImage()
{
#Prado :: trace("Generating image ... ", "Lithron.LImage");
$this->SrcUrl= $this->getImageUrl();
$this->SrcRealpath= realpath($this->getImageUrl());
$this->SrcExt= substr(strrchr($this->SrcUrl, "."), 1);
// check if missing
if (!is_file($this->SrcUrl))
{
Prado :: log("File '" . $this->SrcUrl . "' missing", 8, "Lithron.LImage");
$this->setImageUrl($this->publishAsset("LImage/mimetypes/missing.png"));
return;
}
// output folder
$outputDir= realpath($this->OutputDir);
// check cache
#$file= $this->generateHash(); #.".".$outputType;
$file= $this->generateHash() . "." . strtolower($this->getDestType());
if (is_file($outputDir . "/" . $file))
{
#Prado :: trace("Using cached file: {$file} <= '{$this->SrcUrl}' ", "Lithron.LImage");
$this->setImageUrl($this->OutputDir . "/" . $file);
return;
}
// get file info
$this->Info= $this->identify($this->SrcRealpath);
if (is_writable($outputDir))
{
$outputRealpath= $outputDir . "/" . $file;
$clientUrl= $this->OutputDir . "/" . $file;
// generate image
if ($this->getShowMimeTypeImage() === true)
{
$this->generateAlternativeImage($this->SrcRealpath, $outputRealpath);
}
else
{
$this->convert($this->SrcRealpath, $outputRealpath);
if (!is_file($outputRealpath))
{
$this->generateAlternativeImage($this->SrcRealpath, $outputRealpath);
}
}
$this->setImageUrl($clientUrl);
}
else
{
Prado :: log("OutputDir '" . $outputDir . "' is not writable", 3, "Lithron.LImage");
}
}
/**
* Creates a unique fingerprint of the destination file
*/
private function generateHash()
{
if ($cache= $this->Application->Cache)
{
#$idString= $cache->get("LImage:" . $this->SrcUrl);
}
if (empty ($idString))
{
Prado :: trace("Creating new md5 for {$this->SrcUrl} ...", "Lithron.LImage");
// useless performance debug ? wrong microtimes !?
if ($this->ShowMimeTypeImage === false)
{
$file_contents= file_get_contents($this->SrcUrl);
#$file_contents = $this->SrcUrl;
#sleep(0.1);
$idString= md5($file_contents);
}
else
{
$idString= strrchr($this->SrcUrl, ".");
}
#Prado :: trace("Md5 for {$this->SrcUrl} created", "Lithron.LImage");
if ($cache)
{
$cache->set("LImage:" . $this->SrcUrl, $idString, 360);
}
}
$_props= array (
"DestWidth",
"DestHeight",
"DestType",
"DestQuality",
"DestColorSpace",
"DestBackgroundColor",
"ShowMimeTypeImage",
"PageNumber"
);
foreach ($_props AS $prop)
{
$_eval= "return(\$this->get" . $prop . "());";
$value= eval ($_eval);
$idString .= "|" . $value;
}
$hash= md5($idString);
#Prado :: trace("$idString: $hash", "Lithron.LImage");
return $hash;
}
/**
* Returns file information
*/
private function identify($file)
{
$f= "size_short:%b;width:%w;height:%h;type:%m;colorspace:%r;transparent:;resolution_x:%x;resolution_y:%y;colors:%k;quantum:%q;image_depth:%z;";
$cmd= $this->BinPath . "identify -format \"" . $f . "\" '$file'[0]";
#Prado :: log("Executing $cmd", TLogger :: INFO, "Lithron.Limage");
exec($cmd, $data);
if (isset ($data[0]))
{
$dataArray= explode(";", $data[0]);
foreach ($dataArray AS $pair)
{
$array= split(":", $pair);
$return[$array[0]]= @ $array[1];
}
return $return;
}
else
{
Prado :: log("Could not identify '" . $file . "'", 4, "Lithron.LImage");
}
}
/**
* Converts image
*/
private function convert($src, $dest)
{
if (isset ($this->Info['Error']))
{
Prado :: log("ImageMagick error: " . $this->Info['Error'], 16, "Lithron.LImage");
return;
}
$page= (string)$this->getPageNumber();
$cmd= $this->BinPath . "convert ";
switch ($this->Info["type"])
{
// change output type for special image formats
case "PSD" :
case "PDF" :
case "PS" :
$this->setDestType("PNG");
$cmd .= " -density 144x144 \"{$src}[{$page}]\" ";
#$cmd .= " -resample 72x72 ";
break;
default :
$cmd .= " \"{$src}[{$page}]\" ";
}
if ($this->Info['transparent'])
$cmd .= " -colorspace transparent ";
if (strstr($this->Info["colorspace"], "CMYK") && $this->DestColorspace != "CMYK")
{
#echo "COLORSPACE CONVERSION<br>";
$cmd .= "-profile \"" . dirname(__FILE__) . "/EuroscaleUncoated.icc\" ";
$cmd .= "-profile \"" . dirname(__FILE__) . "/sRGB.icm\" ";
$cmd .= "-colorspace RGB";
}
if ($this->getDestWidth() || $this->getDestHeight())
{
$cmd .= " -geometry {$this->getDestWidth()}x{$this->getDestHeight()} ";
}
if ($this->getDestBackgroundColor() !== null)
{
$cmd .= " -background {$this->getDestBackgroundColor()} ";
}
$cmd .= " +profile \"*\" -quality {$this->getDestQuality()} ";
if ($this->getDestType())
{
$cmd .= " {$this->getDestType()}:";
}
$cmd .= "\"{$dest}\" ";
Prado :: log("Executing $cmd", TLogger :: INFO, "Lithron.Limage");
exec($cmd, $output);
#var_dump($output);
}
/**
* Tries to create an image from file extension and mimetype images
*/
private function generateAlternativeImage($src, $dest)
{
$mimeIcon= "LImage/mimetypes/" . $this->SrcExt . ".png";
if (is_file(dirname(__FILE__) . "/" . $mimeIcon))
{
$altImg= $this->publishAsset($mimeIcon);
}
else
{
$altImg= $this->publishAsset("LImage/mimetypes/mime-empty.png");
}
$this->convert(realpath($altImg), $dest);
$this->setImageUrl($dest);
return;
$cmd= $this->BinPath . "convert ";
$cmd .= "-background white -fill gray ";
#$cmd .= "-font Arial ";
$cmd .= "-pointsize 24 label:{$this->SrcExt} ";
$cmd .= "{$dest} ";
Prado :: trace("executing $cmd", "Lithron.Limage");
exec($cmd, $output);
}
}

Source for file LImage.php