function IMAGEN_tipo_normal()
{
$escalado = 'IMG/i/m/' . $_GET['ancho'] . '_' . $_GET['alto'] . '_' . $_GET['sha1'];
$origen = 'IMG/i/' . $_GET['sha1'];
$ancho = $_GET['ancho'];
$alto = $_GET['alto'];
if (@($ancho * $alto) > 562500) {
die('La imagen solicitada excede el límite de este servicio');
}
if (!file_exists($escalado)) {
$im = new Imagick($origen);
$im->setCompression(Imagick::COMPRESSION_JPEG);
$im->setCompressionQuality(85);
$im->setImageFormat('jpeg');
$im->stripImage();
$im->despeckleImage();
$im->sharpenImage(0.5, 1);
//$im->reduceNoiseImage(0);
$im->setInterlaceScheme(Imagick::INTERLACE_PLANE);
$im->resizeImage($ancho, $alto, imagick::FILTER_LANCZOS, 1);
$im->writeImage($escalado);
$im->destroy();
}
$im = new Imagick($escalado);
$output = $im->getimageblob();
$outputtype = $im->getFormat();
$im->destroy();
header("Content-type: {$outputtype}");
header("Content-length: " . filesize($escalado));
echo $output;
}
/**
* Get image data from image object
* @param \Imagick $img
* @param string $type
* @return string mixed
*/
private static function image2data($img, $type = 'png')
{
$img->setImageFormat($type);
if ($img->getImageWidth() * $img->getImageHeight() > 40000) {
switch ($type) {
case 'png':
$img->setInterlaceScheme(\imagick::INTERLACE_PNG);
break;
case 'jpeg':
$img->setInterlaceScheme(\imagick::INTERLACE_JPEG);
break;
}
}
return $img->getImageBlob();
}
/**
* {@inheritdoc}
*/
public function interlace($scheme)
{
static $supportedInterlaceSchemes = array(ImageInterface::INTERLACE_NONE => \Imagick::INTERLACE_NO, ImageInterface::INTERLACE_LINE => \Imagick::INTERLACE_LINE, ImageInterface::INTERLACE_PLANE => \Imagick::INTERLACE_PLANE, ImageInterface::INTERLACE_PARTITION => \Imagick::INTERLACE_PARTITION);
if (!array_key_exists($scheme, $supportedInterlaceSchemes)) {
throw new InvalidArgumentException('Unsupported interlace type');
}
$this->imagick->setInterlaceScheme($supportedInterlaceSchemes[$scheme]);
return $this;
}
function createThumbnail($filename, $thname, $width = 100, $height = 100, $cdn = null)
{
$filePath = 'pdfslice';
try {
$extension = substr($filename, strrpos($filename, '.') + 1 - strlen($filename));
$fallback_save_path = $filePath;
if ($extension == "svg") {
$im = new Imagick();
$svgdata = file_get_contents($filename);
$svgdata = svgScaleHack($svgdata, $width, $height);
//$im->setBackgroundColor(new ImagickPixel('transparent'));
$im->readImageBlob($svgdata);
$im->setImageFormat("jpg");
$im->resizeImage($width, $height, imagick::FILTER_LANCZOS, 1);
$raw_data = $im->getImageBlob();
is_null($cdn) ? file_put_contents($fallback_save_path . '/' . $thname, $im->getImageBlob()) : '';
} else {
if ($extension == "jpg") {
$im = new Imagick($filename);
$im->stripImage();
// Save as progressive JPEG
$im->setInterlaceScheme(Imagick::INTERLACE_PLANE);
$raw_data = $im->resizeImage($width, $height, imagick::FILTER_LANCZOS, 1);
// Set quality
// $im->setImageCompressionQuality(85);
is_null($cdn) ? $im->writeImage($fallback_save_path . '/' . $thname) : '';
}
}
if (!is_null($cdn)) {
$imageObject = $cdn->DataObject();
$imageObject->SetData($raw_data);
$imageObject->name = $thname;
$imageObject->content_type = 'image/jpg';
$imageObject->Create();
}
$im->clear();
$im->destroy();
return true;
} catch (Exception $e) {
return false;
}
}
/**
* Transform an image using the Imagick PHP extension
*
* @param File $image File associated with this thumbnail
* @param array $params Array with scaler params
*
* @return MediaTransformError Error object if error occurred, false (=no error) otherwise
*/
protected function transformImageMagickExt($image, $params)
{
global $wgSharpenReductionThreshold, $wgSharpenParameter, $wgMaxAnimatedGifArea, $wgJpegPixelFormat;
try {
$im = new Imagick();
$im->readImage($params['srcPath']);
if ($params['mimeType'] == 'image/jpeg') {
// Sharpening, see bug 6193
if (($params['physicalWidth'] + $params['physicalHeight']) / ($params['srcWidth'] + $params['srcHeight']) < $wgSharpenReductionThreshold) {
// Hack, since $wgSharpenParameter is written specifically for the command line convert
list($radius, $sigma) = explode('x', $wgSharpenParameter);
$im->sharpenImage($radius, $sigma);
}
$qualityVal = isset($params['quality']) ? (string) $params['quality'] : null;
$im->setCompressionQuality($qualityVal ?: 80);
if ($params['interlace']) {
$im->setInterlaceScheme(Imagick::INTERLACE_JPEG);
}
if ($wgJpegPixelFormat) {
$factors = $this->imageMagickSubsampling($wgJpegPixelFormat);
$im->setSamplingFactors($factors);
}
} elseif ($params['mimeType'] == 'image/png') {
$im->setCompressionQuality(95);
if ($params['interlace']) {
$im->setInterlaceScheme(Imagick::INTERLACE_PNG);
}
} elseif ($params['mimeType'] == 'image/gif') {
if ($this->getImageArea($image) > $wgMaxAnimatedGifArea) {
// Extract initial frame only; we're so big it'll
// be a total drag. :P
$im->setImageScene(0);
} elseif ($this->isAnimatedImage($image)) {
// Coalesce is needed to scale animated GIFs properly (bug 1017).
$im = $im->coalesceImages();
}
// GIF interlacing is only available since 6.3.4
$v = Imagick::getVersion();
preg_match('/ImageMagick ([0-9]+\\.[0-9]+\\.[0-9]+)/', $v['versionString'], $v);
if ($params['interlace'] && version_compare($v[1], '6.3.4') >= 0) {
$im->setInterlaceScheme(Imagick::INTERLACE_GIF);
}
}
$rotation = isset($params['disableRotation']) ? 0 : $this->getRotation($image);
list($width, $height) = $this->extractPreRotationDimensions($params, $rotation);
$im->setImageBackgroundColor(new ImagickPixel('white'));
// Call Imagick::thumbnailImage on each frame
foreach ($im as $i => $frame) {
if (!$frame->thumbnailImage($width, $height, false)) {
return $this->getMediaTransformError($params, "Error scaling frame {$i}");
}
}
$im->setImageDepth(8);
if ($rotation) {
if (!$im->rotateImage(new ImagickPixel('white'), 360 - $rotation)) {
return $this->getMediaTransformError($params, "Error rotating {$rotation} degrees");
}
}
if ($this->isAnimatedImage($image)) {
wfDebug(__METHOD__ . ": Writing animated thumbnail\n");
// This is broken somehow... can't find out how to fix it
$result = $im->writeImages($params['dstPath'], true);
} else {
$result = $im->writeImage($params['dstPath']);
}
if (!$result) {
return $this->getMediaTransformError($params, "Unable to write thumbnail to {$params['dstPath']}");
}
} catch (ImagickException $e) {
return $this->getMediaTransformError($params, $e->getMessage());
}
return false;
}
private function thumbnail_file_with_imagick($file_path, $save_as, $w = 0, $h = 0)
{
try {
$real_save_as = $save_as;
$save_as = tempnam(PERCH_RESFILEPATH, '_im_tmp_');
$Image = new Imagick($file_path . '[0]');
$Image->setImageFormat('jpg');
if ($Image->getImageHeight() <= $Image->getImageWidth()) {
$Image->thumbnailImage($w * $this->density, 0);
} else {
$Image->thumbnailImage(0, $w * $this->density);
}
// progressive jpg?
if ($this->progressive_jpeg) {
$Image->setInterlaceScheme(Imagick::INTERLACE_PLANE);
}
$Image->writeImage($save_as);
copy($save_as, $real_save_as);
unlink($save_as);
$save_as = $real_save_as;
$out = array();
$out['w'] = (int) $Image->getImageWidth() / $this->density;
$out['h'] = (int) $Image->getImageHeight() / $this->density;
$out['file_path'] = $save_as;
$parts = explode(DIRECTORY_SEPARATOR, $save_as);
$out['file_name'] = array_pop($parts);
$out['web_path'] = str_replace(PERCH_RESFILEPATH . DIRECTORY_SEPARATOR, PERCH_RESPATH . '/', $save_as);
$out['density'] = $this->density;
$out['mime'] = 'image/' . $Image->getImageFormat();
$Image->destroy();
return $out;
} catch (Exception $e) {
PerchUtil::debug('Unable to create thumbnail', 'error');
PerchUtil::debug($e, 'error');
}
return false;
}
/**
* Efficiently resize the current image
*
* This is a WordPress specific implementation of Imagick::thumbnailImage(),
* which resizes an image to given dimensions and removes any associated profiles.
*
* @since 4.5.0
* @access protected
*
* @param int $dst_w The destination width.
* @param int $dst_h The destination height.
* @param string $filter_name Optional. The Imagick filter to use when resizing. Default 'FILTER_TRIANGLE'.
* @param bool $strip_meta Optional. Strip all profiles, excluding color profiles, from the image. Default true.
* @return bool|WP_Error
*/
protected function thumbnail_image($dst_w, $dst_h, $filter_name = 'FILTER_TRIANGLE', $strip_meta = true)
{
$allowed_filters = array('FILTER_POINT', 'FILTER_BOX', 'FILTER_TRIANGLE', 'FILTER_HERMITE', 'FILTER_HANNING', 'FILTER_HAMMING', 'FILTER_BLACKMAN', 'FILTER_GAUSSIAN', 'FILTER_QUADRATIC', 'FILTER_CUBIC', 'FILTER_CATROM', 'FILTER_MITCHELL', 'FILTER_LANCZOS', 'FILTER_BESSEL', 'FILTER_SINC');
/**
* Set the filter value if '$filter_name' name is in our whitelist and the related
* Imagick constant is defined or fall back to our default filter.
*/
if (in_array($filter_name, $allowed_filters) && defined('Imagick::' . $filter_name)) {
$filter = constant('Imagick::' . $filter_name);
} else {
$filter = defined('Imagick::FILTER_TRIANGLE') ? Imagick::FILTER_TRIANGLE : false;
}
/**
* Filters whether to strip metadata from images when they're resized.
*
* This filter only applies when resizing using the Imagick editor since GD
* always strips profiles by default.
*
* @since 4.5.0
*
* @param bool $strip_meta Whether to strip image metadata during resizing. Default true.
*/
if (apply_filters('image_strip_meta', $strip_meta)) {
$this->strip_meta();
// Fail silently if not supported.
}
try {
/*
* To be more efficient, resample large images to 5x the destination size before resizing
* whenever the output size is less that 1/3 of the original image size (1/3^2 ~= .111),
* unless we would be resampling to a scale smaller than 128x128.
*/
if (is_callable(array($this->image, 'sampleImage'))) {
$resize_ratio = $dst_w / $this->size['width'] * ($dst_h / $this->size['height']);
$sample_factor = 5;
if ($resize_ratio < 0.111 && ($dst_w * $sample_factor > 128 && $dst_h * $sample_factor > 128)) {
$this->image->sampleImage($dst_w * $sample_factor, $dst_h * $sample_factor);
}
}
/*
* Use resizeImage() when it's available and a valid filter value is set.
* Otherwise, fall back to the scaleImage() method for resizing, which
* results in better image quality over resizeImage() with default filter
* settings and retains backward compatibility with pre 4.5 functionality.
*/
if (is_callable(array($this->image, 'resizeImage')) && $filter) {
$this->image->setOption('filter:support', '2.0');
$this->image->resizeImage($dst_w, $dst_h, $filter, 1);
} else {
$this->image->scaleImage($dst_w, $dst_h);
}
// Set appropriate quality settings after resizing.
if ('image/jpeg' == $this->mime_type) {
if (is_callable(array($this->image, 'unsharpMaskImage'))) {
$this->image->unsharpMaskImage(0.25, 0.25, 8, 0.065);
}
$this->image->setOption('jpeg:fancy-upsampling', 'off');
}
if ('image/png' === $this->mime_type) {
$this->image->setOption('png:compression-filter', '5');
$this->image->setOption('png:compression-level', '9');
$this->image->setOption('png:compression-strategy', '1');
$this->image->setOption('png:exclude-chunk', 'all');
}
/*
* If alpha channel is not defined, set it opaque.
*
* Note that Imagick::getImageAlphaChannel() is only available if Imagick
* has been compiled against ImageMagick version 6.4.0 or newer.
*/
if (is_callable(array($this->image, 'getImageAlphaChannel')) && is_callable(array($this->image, 'setImageAlphaChannel')) && defined('Imagick::ALPHACHANNEL_UNDEFINED') && defined('Imagick::ALPHACHANNEL_OPAQUE')) {
if ($this->image->getImageAlphaChannel() === Imagick::ALPHACHANNEL_UNDEFINED) {
$this->image->setImageAlphaChannel(Imagick::ALPHACHANNEL_OPAQUE);
}
}
// Limit the bit depth of resized images to 8 bits per channel.
if (is_callable(array($this->image, 'getImageDepth')) && is_callable(array($this->image, 'setImageDepth'))) {
if (8 < $this->image->getImageDepth()) {
$this->image->setImageDepth(8);
}
}
if (is_callable(array($this->image, 'setInterlaceScheme')) && defined('Imagick::INTERLACE_NO')) {
$this->image->setInterlaceScheme(Imagick::INTERLACE_NO);
}
} catch (Exception $e) {
return new WP_Error('image_resize_error', $e->getMessage());
}
}
/**
* Set image file progressive settings
*/
protected function processFile()
{
$this->imagickObject->setInterlaceScheme($this->getInterlaceScheme());
}
/**
* Outputs an image resource as a given type
*
* @param Imagick $im
* @param string $type
* @param string $filename
* @param int $qual
* @return bool
*/
function zp_imageOutput($im, $type, $filename = NULL, $qual = 75)
{
$interlace = getOption('image_interlace');
$qual = max(min($qual, 100), 0);
$im->setImageFormat($type);
switch ($type) {
case 'gif':
$im->setImageCompression(Imagick::COMPRESSION_LZW);
$im->setImageCompressionQuality($qual);
if ($interlace) {
$im->setInterlaceScheme(Imagick::INTERLACE_GIF);
}
break;
case 'jpeg':
case 'jpg':
$im->setImageCompression(Imagick::COMPRESSION_JPEG);
$im->setImageCompressionQuality($qual);
if ($interlace) {
$im->setInterlaceScheme(Imagick::INTERLACE_JPEG);
}
break;
case 'png':
$im->setImageCompression(Imagick::COMPRESSION_ZIP);
$im->setImageCompressionQuality($qual);
if ($interlace) {
$im->setInterlaceScheme(Imagick::INTERLACE_PNG);
}
break;
}
$im->optimizeImageLayers();
if ($filename == NULL) {
header('Content-Type: image/' . $type);
return print $im->getImagesBlob();
}
return $im->writeImages(imgSrcURI($filename), true);
}
/**
* Guess image mimetype from filename or from Content-Type header
*
* @arg $filename string Image filename
* @arg $fromcurl boolean Check Content-Type header from curl request
*/
function guess_image_type($filename, $fromcurl = false)
{
logger('Photo: guess_image_type: ' . $filename . ($fromcurl ? ' from curl headers' : ''), LOGGER_DEBUG);
$type = null;
if ($fromcurl) {
$a = get_app();
$headers = array();
$h = explode("\n", $a->get_curl_headers());
foreach ($h as $l) {
list($k, $v) = array_map("trim", explode(":", trim($l), 2));
$headers[$k] = $v;
}
if (array_key_exists('Content-Type', $headers)) {
$type = $headers['Content-Type'];
}
}
if (is_null($type)) {
// Guessing from extension? Isn't that... dangerous?
if (class_exists('Imagick') && file_exists($filename) && is_readable($filename)) {
/**
* Well, this not much better,
* but at least it comes from the data inside the image,
* we won't be tricked by a manipulated extension
*/
$image = new Imagick($filename);
$type = $image->getImageMimeType();
$image->setInterlaceScheme(Imagick::INTERLACE_PLANE);
} else {
$ext = pathinfo($filename, PATHINFO_EXTENSION);
$types = Photo::supportedTypes();
$type = "image/jpeg";
foreach ($types as $m => $e) {
if ($ext == $e) {
$type = $m;
}
}
}
}
logger('Photo: guess_image_type: type=' . $type, LOGGER_DEBUG);
return $type;
}
/**
* Resize
*
* @return bool
*/
public function resize()
{
try {
$resultMessage = array();
// Set filename
//@todo: check source
if (empty($this->filename)) {
$source = \explode('/', $this->source);
$this->setFileName($source[\count($source) - 1]);
}
// Define filename and extension
//@todo: check filename
$fileNameExtension = \substr($this->filename, \strrpos($this->filename, '.') + 1);
$fileName = \str_replace('.' . $fileNameExtension, '', $this->filename);
// Define retina size images
if ($this->retina === true) {
foreach ($this->type as $key => $imageType) {
$this->setType($key . self::RETINA_POSTFIX, $imageType['sizeWidth'] * 2, $imageType['sizeHeight'] * 2);
}
}
// Resize and save images
//@todo: check type
foreach ($this->type as $key => $imageType) {
$img = new \Imagick($this->source);
// Get exif and rotate the image
$exif = \exif_read_data($this->source, 'IFD0');
if (!empty($exif) && !empty($exif['Orientation'])) {
switch ($exif['Orientation']) {
case 8:
$img->rotateImage(new \ImagickPixel(), -90);
break;
case 3:
$img->rotateImage(new \ImagickPixel(), -180);
break;
case 6:
$img->rotateImage(new \ImagickPixel(), -270);
break;
default:
break;
}
}
// Get original size of the image
$imageWidth = $img->getImageWidth();
$imageHeight = $img->getImageHeight();
// Resize the image
if ($imageWidth > $imageHeight) {
$imageRotation = 'landscape';
} elseif ($imageWidth < $imageHeight) {
$imageRotation = 'portrait';
} else {
$imageRotation = 'square';
}
switch ($imageRotation) {
case 'landscape':
$img->resizeImage(\round($imageWidth / ($imageHeight / $imageType['sizeHeight'])), $imageType['sizeHeight'], \Imagick::FILTER_LANCZOS, 0.9, true);
break;
case 'portrait':
$img->resizeImage($imageType['sizeWidth'], \round($imageHeight / ($imageWidth / $imageType['sizeWidth'])), \Imagick::FILTER_LANCZOS, 0.9, true);
break;
case 'square':
$img->resizeImage($imageType['sizeWidth'], \round($imageHeight / ($imageWidth / $imageType['sizeWidth'])), \Imagick::FILTER_LANCZOS, 0.9, true);
break;
default:
break;
}
// Crop the image
$img->cropImage($imageType['sizeWidth'], $imageType['sizeHeight'], 0, 0);
// Sharpen image
$img->adaptiveSharpenImage(2, 1);
// Set progressive
if ($this->progressive === true) {
$img->setInterlaceScheme(\Imagick::INTERLACE_PLANE);
}
// Save
$outFileName = (empty($this->prefix) ? '' : $this->prefix . self::SEPARATOR) . $fileName . self::SEPARATOR . $key . '.' . $fileNameExtension;
@\unlink($this->target . '/' . $outFileName);
$img->writeImage($this->target . '/' . $outFileName);
$resultMessage[$key] = $outFileName;
}
// Save original image
if ($this->saveOriginal === true) {
// Save
$outFileName = (empty($this->prefix) ? '' : $this->prefix . self::SEPARATOR) . $fileName . '.' . $fileNameExtension;
@\unlink($this->target . '/' . $outFileName);
\copy($this->source, $this->target . '/' . $outFileName);
$resultMessage['original'] = $outFileName;
}
// Set status
$this->setStatus(self::STATUS_SUCCESS);
$this->setMessage(array('files' => $resultMessage));
return true;
} catch (\Exception $e) {
// Set status
$this->setStatus(self::STATUS_ERROR);
$this->setMessage($e->getMessage());
return false;
}
}
/**
*
*/
function sharpen($path)
{
if (!class_exists('\\Imagick')) {
return;
}
$dimensions = @getimagesize($path);
if (!isset($dimensions[2]) || IMAGETYPE_JPEG != $dimensions[2]) {
return;
}
debug("sharpening {$path}", 6);
try {
$imagick = new \Imagick($path);
$imagick->unsharpMaskImage(0, 0.5, 1, 0);
$imagick->setImageFormat("jpg");
$imagick->setImageCompression(\Imagick::COMPRESSION_JPEG);
$imagick->setImageCompressionQuality(jpeg_quality());
$imagick->setInterlaceScheme(\Imagick::INTERLACE_PLANE);
// this is for watermarking
$imagick = \apply_filters("wp_resized2cache_imagick", $imagick, $path);
$imagick->writeImage($path);
$imagick->destroy();
} catch (Exception $e) {
debug('something went wrong with imagemagick: ', $e->getMessage(), 4);
return;
}
}
/**
* @desc Create a thumbnail of the picture and save it
* @param $size The size requested
*/
private function createThumbnail($width, $height = false)
{
if (!$height) {
$height = $width;
}
$path = $this->_path . md5($this->_key) . '_' . $width . '.jpg';
$im = new Imagick();
$im->readImageBlob($this->_bin);
$geo = $im->getImageGeometry();
$im->cropThumbnailImage($width, $height);
if ($width > $geo['width']) {
$factor = floor($width / $geo['width']);
$im->blurImage($factor, 10);
}
$im->setImageCompressionQuality(85);
$im->setInterlaceScheme(Imagick::INTERLACE_PLANE);
$im->writeImage($path);
}
/**
* Outputs an image resource as a given type
*
* @internal Imagick::INTERLACE_[GIF|JPEG|PNG] require Imagick compiled against ImageMagick 6.3.4+
*
* @param Imagick $im
* @param string $type
* @param string $filename
* @param int $qual
* @throws ImagickException
* @return bool
*/
function zp_imageOutput($im, $type, $filename = NULL, $qual = 75)
{
global $_imagemagick_version, $_imagick_newer_interlace;
if (!isset($_imagick_newer_interlace)) {
$_imagick_newer_interlace = version_compare($_imagemagick_version['versionNumber'], '6.3.4', '>=');
}
$interlace = getOption('image_interlace');
$qual = max(min($qual, 100), 0);
$im->setImageFormat($type);
switch ($type) {
case 'gif':
$im->setCompression(Imagick::COMPRESSION_LZW);
$im->setCompressionQuality($qual);
if ($interlace) {
if ($_imagick_newer_interlace) {
$im->setInterlaceScheme(Imagick::INTERLACE_GIF);
} else {
$im->setInterlaceScheme(Imagick::INTERLACE_LINE);
}
}
break;
case 'jpeg':
case 'jpg':
$im->setCompression(Imagick::COMPRESSION_JPEG);
$im->setCompressionQuality($qual);
if ($interlace) {
if ($_imagick_newer_interlace) {
$im->setInterlaceScheme(Imagick::INTERLACE_JPEG);
} else {
$im->setInterlaceScheme(Imagick::INTERLACE_LINE);
}
}
break;
case 'png':
$im->setCompression(Imagick::COMPRESSION_ZIP);
$im->setCompressionQuality($qual);
if ($interlace) {
if ($_imagick_newer_interlace) {
$im->setInterlaceScheme(Imagick::INTERLACE_PNG);
} else {
$im->setInterlaceScheme(Imagick::INTERLACE_LINE);
}
}
break;
}
try {
$im->optimizeImageLayers();
} catch (ImagickException $e) {
if (DEBUG_IMAGE) {
debugLog('Caught ImagickException in zp_imageOutput(): ' . $e->getMessage());
}
}
if ($filename == NULL) {
header('Content-Type: image/' . $type);
return print $im->getImagesBlob();
}
return $im->writeImages($filename, true);
}
/**
*
*
* @param
*
* @return void
*/
private function drawPolygon($event, $au_scalar, &$polyOffsetX, &$polyOffsetY, &$polygonURL, &$polyWidth, &$polyHeight)
{
$originX = null;
$originY = null;
$polygonURL = null;
$maxPixelScale = 0.60511022;
// arcseconds per pixel
$polyString = $event['hpc_boundcc'];
$polyString = str_replace(array('POLYGON', '(', ')'), '', $polyString);
foreach (explode(',', $polyString) as $xy) {
list($x_coord, $y_coord) = explode(' ', $xy);
$x[] = $x_coord * $au_scalar;
$y[] = -$y_coord * $au_scalar;
}
$originX = min($x);
$originY = min($y);
$polyOffsetX = $originX;
$polyOffsetY = $originY;
$width = 0;
$height = 0;
for ($i = 0; $i < count($x); $i++) {
$xCoord = ($x[$i] - $originX) / $maxPixelScale;
$yCoord = ($y[$i] - $originY) / $maxPixelScale;
$polyArray[] = array('x' => $xCoord, 'y' => $yCoord);
if ($xCoord > $width) {
$width = $xCoord;
}
if ($yCoord > $height) {
$height = $yCoord;
}
}
/* Create a new imagick object */
$im = new Imagick();
/* Create ImagickDraw object */
$draw = new ImagickDraw();
$strokeWidth = 4;
$draw->setStrokeLineJoin(Imagick::LINEJOIN_ROUND);
$draw->setStrokeColor('#00000088');
$draw->setStrokeWidth($strokeWidth);
$draw->setStrokeAntialias(true);
$draw->setFillColor('#' . $GLOBALS['HEK_COLORS'][$event['event_type']] . '66');
$draw->polygon($polyArray);
$polyWidth = $width + $strokeWidth;
$polyHeight = $height + $strokeWidth;
/* Create a new canvas object and a transparent image */
$canvas = new Imagick();
$canvas->newImage($polyWidth, $polyHeight, 'none');
/* Draw the ImagickDraw on to the canvas */
$canvas->drawImage($draw);
/* Set the format to PNG */
$canvas->setImageFormat('png');
$canvas->setInterlaceScheme(Imagick::INTERLACE_PNG);
/* Output the image */
$dateArray = date_parse($event['event_starttime']);
$cache_base_dir = HV_CACHE_DIR . '/events/' . $dateArray['year'] . '/' . str_pad($dateArray['month'], 2, '0', STR_PAD_LEFT) . '/' . str_pad($dateArray['day'], 2, '0', STR_PAD_LEFT);
// Check for existence of cache sub-directory
if (!@file_exists($cache_base_dir)) {
@mkdir($cache_base_dir, 0777, true);
}
$cache_file = rawurlencode($event['kb_archivid']) . '.png';
$cache_file_path = $cache_base_dir . '/' . $cache_file;
$polygonURL = str_replace(HV_CACHE_DIR, 'cache', $cache_base_dir) . '/' . rawurlencode($cache_file);
$fp = @fopen($cache_file_path, 'wb');
if ($fp !== false) {
@fwrite($fp, $canvas);
@fclose($fp);
}
}
echo "创建文件目录失败！";
}
}
foreach ($data as $k => $v) {
if ($v['diy_picture_path']) {
if (!file_exists($path_pre . '/Uploads' . $v['diy_picture_path'])) {
$size_arr = $size_data[$v['cate_id']][$v['attri_name']];
if (!file_exists($path_pre . '/Uploads/Uploads/' . $YMD . '/' . $v['cate_id'] . '/' . $v['attri_name'])) {
mkdir($path_pre . '/Uploads/Uploads/' . $YMD . '/' . $v['cate_id']);
mkdir($path_pre . '/Uploads/Uploads/' . $YMD . '/' . $v['cate_id'] . '/' . $v['attri_name']);
echo "创建文件目录成功！";
}
$im = new Imagick($path_pre . $v['diy_picture_path']);
$im->thumbnailImage($size_arr['width'], $size_arr['height'], true);
/* 改变大小 */
$im->setInterlaceScheme(4);
$lspath = basename($v['diy_picture_path']);
$lspatharr = explode(".", $lspath);
$am = $im->writeImage($path_pre . '/Uploads/Uploads/' . $YMD . '/' . $v['cate_id'] . '/' . $v['attri_name'] . '/' . $lspatharr[0] . '-' . $v['updateid'] . '.' . $lspatharr[1]);
if (!$am) {
echo "图片压缩失败！";
} else {
$im_get = new \Imagick($path_pre . '/Uploads/Uploads/' . $YMD . '/' . $v['cate_id'] . '/' . $v['attri_name'] . '/' . $lspatharr[0] . '-' . $v['updateid'] . '.' . $lspatharr[1]);
$im_sta = $im_get->getImageColorspace();
if (2 == $im_sta) {
list($bg_width, $bg_height) = getimagesize($path_pre . '/Uploads/Uploads/' . $YMD . '/' . $v['cate_id'] . '/' . $v['attri_name'] . '/' . $lspatharr[0] . '-' . $v['updateid'] . '.' . $lspatharr[1]);
$bg_width -= 2;
$bg_height -= 2;
$imm = new \Imagick();
$imm->newImage(2, 2, new \ImagickPixel('#FFFFFE'));
$im_get->setImageColorSpace(1);
