/**
  * Applies the sepia filter to an image resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     if ($this->offset === 0) {
         return;
     }
     $resource = $aResource->getResource();
     $imagex = imagesx($resource);
     $imagey = imagesy($resource);
     for ($x = 0; $x < $imagex; ++$x) {
         for ($y = 0; $y < $imagey; ++$y) {
             $distx = rand($this->offset * -1, $this->offset);
             $disty = rand($this->offset * -1, $this->offset);
             if ($x + $distx >= $imagex) {
                 continue;
             }
             if ($x + $distx < 0) {
                 continue;
             }
             if ($y + $disty >= $imagey) {
                 continue;
             }
             if ($y + $disty < 0) {
                 continue;
             }
             $oldcol = imagecolorat($resource, $x, $y);
             $newcol = imagecolorat($resource, $x + $distx, $y + $disty);
             imagesetpixel($resource, $x, $y, $newcol);
             imagesetpixel($resource, $x + $distx, $y + $disty, $oldcol);
         }
     }
 }
 /**
  * Applies the sepia filter to an image resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     $dstImg = $aResource->getResource();
     $imgX = $aResource->getX();
     $imgY = $aResource->getY();
     $previous = array("index" => -1, "result" => 0);
     for ($y = 0; $y < $imgY; $y++) {
         for ($x = 0; $x < $imgX; $x++) {
             $dstRGB = imagecolorat($dstImg, $x, $y);
             if ($previous["index"] === $dstRGB) {
                 $newRGB = $previous["result"];
             } else {
                 $dstR = $dstRGB >> 16 & 0xff;
                 $dstG = $dstRGB >> 8 & 0xff;
                 $dstB = $dstRGB & 0xff;
                 $newR = $dstR * 0.393 + $dstG * 0.769 + $dstB * 0.189 - $this->darken;
                 $newG = $dstR * 0.349 + $dstG * 0.6860000000000001 + $dstB * 0.168 - $this->darken;
                 $newB = $dstR * 0.272 + $dstG * 0.534 + $dstB * 0.131 - $this->darken;
                 $newR = $newR > 255 ? 255 : ($newR < 0 ? 0 : $newR);
                 $newG = $newG > 255 ? 255 : ($newG < 0 ? 0 : $newG);
                 $newB = $newB > 255 ? 255 : ($newB < 0 ? 0 : $newB);
                 $newRGB = imagecolorallocate($dstImg, $newR, $newG, $newB);
                 $previous["index"] = $dstRGB;
                 $previous["result"] = $newRGB;
             }
             imagesetpixel($dstImg, $x, $y, $newRGB);
         }
     }
 }
 /**
  * Write the resource back to it's owner 
  * @param ImageResource $resource
  * @param Segment $segment
  * @throws ImageResourceException when segment's dimensions do not match resource dimensions
  */
 public function writeSegment(ImageResource $resource, Segment $segment)
 {
     if ($resource->getWidth() !== $segment->getWidth() || $resource->getHeight() !== $segment->getHeight()) {
         throw new ImageResourceException("Dimensions of resource and segment differ");
     }
     imagecopy($this->resource->getResource(), $resource->getResource(), $segment->getCoordinate()->getX(), $segment->getCoordinate()->getY(), 0, 0, $segment->getWidth(), $segment->getHeight());
 }
 /**
  * Applies the sepia filter to an image resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     if ($this->degrees === 0) {
         return;
     }
     $width = $aResource->getX();
     $height = $aResource->getY();
     // cache calculated colors in a map...
     $colorMap = array();
     for ($x = 0; $x < $width; ++$x) {
         for ($y = 0; $y < $height; ++$y) {
             $color = ColorUtil::getColorAt($aResource, Coordinate::create($x, $y));
             if (!isset($colorMap[$color->getColorIndex()])) {
                 // calculate the new color
                 $hsl = ColorUtil::rgb2hsl($color->getRed(), $color->getGreen(), $color->getBlue());
                 $hsl[0] += $this->degrees;
                 $rgb = ColorUtil::hsl2rgb($hsl[0], $hsl[1], $hsl[2]);
                 $newcol = imagecolorallocate($aResource->getResource(), $rgb[0], $rgb[1], $rgb[2]);
                 $colorMap[$color->getColorIndex()] = $newcol;
             } else {
                 $newcol = $colorMap[$color->getColorIndex()];
             }
             imagesetpixel($aResource->getResource(), $x, $y, $newcol);
         }
     }
     $colorMap = null;
 }
 /**
  * (non-PHPdoc)
  * @see \imagemanipulation\filter\IImageFilter::applyFilter()
  */
 public function applyFilter(ImageResource $resource)
 {
     if ($this->radius === 0) {
         return;
     }
     $source_image = $resource->getResource();
     $source_width = $resource->getX();
     $source_height = $resource->getY();
     $corner_image = imagecreatetruecolor($this->radius, $this->radius);
     $clear_colour = imagecolorallocate($corner_image, 0, 0, 0);
     imagecolortransparent($corner_image, $clear_colour);
     $solid_colour = imagecolorallocate($corner_image, $this->color->getRed(), $this->color->getGreen(), $this->color->getBlue());
     imagefill($corner_image, 0, 0, $solid_colour);
     imagefilledellipse($corner_image, $this->radius, $this->radius, $this->radius * 2, $this->radius * 2, $clear_colour);
     /*
      * render the top-left, bottom-left, bottom-right, top-right corners by rotating and copying the mask
      */
     imagecopymerge($source_image, $corner_image, 0, 0, 0, 0, $this->radius, $this->radius, 100);
     $corner_image = imagerotate($corner_image, 90, 0);
     imagecopymerge($source_image, $corner_image, 0, $source_height - $this->radius, 0, 0, $this->radius, $this->radius, 100);
     $corner_image = imagerotate($corner_image, 90, 0);
     imagecopymerge($source_image, $corner_image, $source_width - $this->radius, $source_height - $this->radius, 0, 0, $this->radius, $this->radius, 100);
     $corner_image = imagerotate($corner_image, 90, 0);
     imagecopymerge($source_image, $corner_image, $source_width - $this->radius, 0, 0, 0, $this->radius, $this->radius, 100);
 }
 /**
  * (non-PHPdoc)
  * @see \imagemanipulation\filter\IImageFilter::applyFilter()
  */
 public function applyFilter(ImageResource $aResource)
 {
     $watermarkRes = new ImageImageResource($this->watermark);
     imagealphablending($aResource->getResource(), true);
     imagealphablending($watermarkRes->getResource(), true);
     if ($this->position == 'random') {
         $this->position = rand(1, 8);
     }
     if ($this->watermarkOpacity) {
         $opacityFilter = new ImageFilterOpacity($this->watermarkOpacity);
         $opacityFilter->applyFilter($watermarkRes);
     }
     $destWidth = $aResource->getX();
     $destHeight = $aResource->getY();
     $watermarkWidth = $watermarkRes->getX();
     $watermarkHeight = $watermarkRes->getY();
     switch ($this->position) {
         case 'top-right':
         case 'right-top':
         case 1:
             $result = imagecopy($aResource->getResource(), $watermarkRes->getResource(), $destWidth - $watermarkWidth, 0, 0, 0, $watermarkWidth, $watermarkHeight);
             break;
         case 'top-left':
         case 2:
             $result = imagecopy($aResource->getResource(), $watermarkRes->getResource(), 0, 0, 0, 0, $watermarkWidth, $watermarkHeight);
             break;
         case 'bottom-right':
         case 3:
             $result = imagecopy($aResource->getResource(), $watermarkRes->getResource(), $destWidth - $watermarkWidth, $destHeight - $watermarkHeight, 0, 0, $watermarkWidth, $watermarkHeight);
             break;
         case 'bottom-left':
         case 4:
             $result = imagecopy($aResource->getResource(), $watermarkRes->getResource(), 0, $destHeight - $watermarkHeight, 0, 0, $watermarkWidth, $watermarkHeight);
             break;
         case 'center':
         case 5:
             $result = imagecopy($aResource->getResource(), $watermarkRes->getResource(), $destWidth / 2 - $watermarkWidth / 2, $destHeight / 2 - $watermarkHeight / 2, 0, 0, $watermarkWidth, $watermarkHeight);
             break;
         case 'top':
         case 6:
             $result = imagecopy($aResource->getResource(), $watermarkRes->getResource(), $destWidth / 2 - $watermarkWidth / 2, 0, 0, 0, $watermarkWidth, $watermarkHeight);
             break;
         case 'bottom':
         case 7:
             $result = imagecopy($aResource->getResource(), $watermarkRes->getResource(), $destWidth / 2 - $watermarkWidth / 2, $destHeight - $watermarkHeight, 0, 0, $watermarkWidth, $watermarkHeight);
             break;
         case 'left':
         case 8:
             $result = imagecopy($aResource->getResource(), $watermarkRes->getResource(), 0, $destHeight / 2 - $watermarkHeight / 2, 0, 0, $watermarkWidth, $watermarkHeight);
             break;
         case 'right':
         case 9:
             $result = imagecopy($aResource->getResource(), $watermarkRes->getResource(), $destWidth - $watermarkWidth, $destHeight / 2 - $watermarkHeight / 2, 0, 0, $watermarkWidth, $watermarkHeight);
             break;
             imagedestroy($watermarkRes->getResource());
             if (!$result) {
                 throw new \Exception('Applying watermark failed');
             }
     }
 }
 /**
  * Applies the filter to the resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     $width = $aResource->getX();
     $height = $aResource->getY();
     $lineRes = imagecreatetruecolor($width, 1);
     $bgc = imagecolorallocatealpha($lineRes, $this->backgroundColor->getRed(), $this->backgroundColor->getGreen(), $this->backgroundColor->getBlue(), $this->backgroundColor->getAlpha());
     // Background color
     imagefilledrectangle($lineRes, 0, 0, $width, 1, $bgc);
     $rotateFilter = new ImageFilterRotate(180, $this->backgroundColor);
     $rotateFilter->applyFilter($aResource);
     $bg = imagecreatetruecolor($width, $this->height);
     imagecopyresampled($bg, $aResource->getResource(), 0, 0, 0, 0, $width, $height, $width, $height);
     $im = $bg;
     $bg = imagecreatetruecolor($width, $this->height);
     for ($x = 0; $x < $width; $x++) {
         imagecopy($bg, $im, $x, 0, $width - $x, 0, 1, $this->height);
     }
     $im = $bg;
     $in = 100 / $this->height;
     for ($i = 0; $i <= $this->height; $i++) {
         imagecopymerge($im, $lineRes, 0, $i, 0, 0, $width, 1, $this->startOpacity);
         if ($this->startOpacity < 100) {
             $this->startOpacity += $in;
         }
     }
     imagecopymerge($im, $lineRes, 0, 0, 0, 0, $width, $this->divLineHeight, 100);
     // Divider
     $aResource->setResource($im);
 }
 /**
  * Tests ImageResource->setResource()
  */
 public function testSetResourceFail()
 {
     try {
         $this->res->setResource(false);
         $this->fail('Expected an exception');
     } catch (ImageResourceException $ex) {
     }
 }
 /**
  * (non-PHPdoc)
  * @see \imagemanipulation\filter\IImageFilter::applyFilter()
  */
 public function applyFilter(ImageResource $aResource)
 {
     $resource = $aResource->getResource();
     $imagex = $aResource->getX();
     $imagey = $aResource->getY();
     for ($x = 0; $x < $imagex; $x += $this->blocksize) {
         for ($y = 0; $y < $imagey; $y += $this->blocksize) {
             // get the pixel colour at the top-left of the square
             $thiscol = imagecolorat($resource, $x, $y);
             // set the new red, green, and blue values to 0
             $newr = 0;
             $newg = 0;
             $newb = 0;
             // create an empty array for the colours
             $colours = array();
             // cycle through each pixel in the block
             for ($k = $x; $k < $x + $this->blocksize; ++$k) {
                 for ($l = $y; $l < $y + $this->blocksize; ++$l) {
                     // if we are outside the valid bounds of the image, use a safe colour
                     if ($k < 0) {
                         $colours[] = $thiscol;
                         continue;
                     }
                     if ($k >= $imagex) {
                         $colours[] = $thiscol;
                         continue;
                     }
                     if ($l < 0) {
                         $colours[] = $thiscol;
                         continue;
                     }
                     if ($l >= $imagey) {
                         $colours[] = $thiscol;
                         continue;
                     }
                     // if not outside the image bounds, get the colour at this pixel
                     $colours[] = imagecolorat($resource, $k, $l);
                 }
             }
             // cycle through all the colours we can use for sampling
             foreach ($colours as $colour) {
                 // add their red, green, and blue values to our master numbers
                 $newr += $colour >> 16 & 0xff;
                 $newg += $colour >> 8 & 0xff;
                 $newb += $colour & 0xff;
             }
             // now divide the master numbers by the number of valid samples to get an average
             $numelements = count($colours);
             $newr /= $numelements;
             $newg /= $numelements;
             $newb /= $numelements;
             // and use the new numbers as our colour
             $newcol = imagecolorallocate($resource, $newr, $newg, $newb);
             imagefilledrectangle($resource, $x, $y, $x + $this->blocksize - 1, $y + $this->blocksize - 1, $newcol);
         }
     }
 }
 /**
  * Create a new image with specified width, height and color
  * 
  * @param int $width The new image width in pixels
  * @param int $height The new image height in pixels
  * @param Color $color The new image color
  * 
  * @return \imagemanipulation\ImageResource
  */
 public static function create($width, $height, Color $color)
 {
     Args::int($width, 'width')->required()->min(1);
     Args::int($height, 'height')->required()->min(1);
     $res = new ImageResource(imagecreatetruecolor($width, $height));
     $color = ImageUtil::allocateColor($res->getResource(), $color);
     imagefill($res->getResource(), 0, 0, $color);
     $res->saveAlpha();
     return $res;
 }
 /**
  * Applies the filter to the resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     $width = $aResource->getX();
     $height = $aResource->getY();
     $blockImg = imagecreate(1, 1);
     imagecolorallocatealpha($blockImg, $this->blockColor->getRed(), $this->blockColor->getGreen(), $this->blockColor->getBlue(), $this->blockColor->getAlpha());
     for ($i = 0; $i <= $this->nrOfBlocks; $i++) {
         $xPos = rand(0, $width - $this->blockSize - 1);
         $yPos = rand(0, $height - $this->blockSize - 1);
         imagecopy($aResource->getResource(), $blockImg, $xPos, $yPos, $xPos, $yPos, $this->blockSize, $this->blockSize);
     }
 }
 /**
  * Applies the filter to the resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     //comic effect
     $width = $aResource->getX();
     $height = $aResource->getY();
     /* @var $imgK \imagemanipulation\ImageResource */
     $imgK = $aResource->cloneResource();
     $trueColorFilter = new ImageFilterTrueColor('ffffff', '000000');
     $trueColorFilter->applyFilter($imgK);
     imagecopymerge($aResource->getResource(), $imgK->getResource(), 0, 0, 0, 0, $width, $height, $this->opacity);
     imagedestroy($imgK->getResource());
 }
 /**
  * Applies the filter to the image resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     $function = 'imageflip';
     if (function_exists($function)) {
         $function($aResource->getResource(), $this->getMode());
     } else {
         $width = $aResource->getX();
         $height = $aResource->getY();
         $dest = imagecreatetruecolor($width, $height);
         imagealphablending($dest, false);
         imagesavealpha($dest, true);
         switch ($this->getMode()) {
             case self::FLIP_VERTICALLY:
                 $this->flipVertically($dest, $aResource->getResource(), $height, $width);
                 break;
             case self::FLIP_HORIZONTALLY:
                 $this->flipHorizontally($dest, $aResource->getResource(), $height, $width);
                 break;
             case self::FLIP_BOTH:
                 $this->flipVertically($dest, $aResource->getResource(), $height, $width);
                 $copy = imagecreatetruecolor($width, $height);
                 imagecopy($copy, $dest, 0, 0, 0, 0, $width, $height);
                 $this->flipHorizontally($dest, $copy, $height, $width);
                 break;
         }
         $aResource->setResource($dest);
     }
 }
 /**
  * Applies the filter to the resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     $this->width = $aResource->getX();
     $this->height = $aResource->getY();
     $im = $aResource->getResource();
     for ($x = 0; $x < $this->width; ++$x) {
         for ($y = 0; $y < $this->height; ++$y) {
             $index = imagecolorat($im, $x, $y);
             $rgb = imagecolorsforindex($im, $index);
             $this->vignetteToPixel($x, $y, $rgb);
             $color = imagecolorallocate($im, $rgb['red'], $rgb['green'], $rgb['blue']);
             imagesetpixel($im, $x, $y, $color);
         }
     }
 }
 /**
  * Applies the filter to the resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     $dest = $aResource->getResource();
     if (imageistruecolor($dest)) {
         imagetruecolortopalette($dest, false, 256);
     }
     foreach ($this->search as $search) {
         $searchRgb = new Color($search);
         $index = imagecolorclosest($aResource->getResource(), $searchRgb->getRed(), $searchRgb->getGreen(), $searchRgb->getBlue());
         // get White COlor
         imagecolorset($aResource->getResource(), $index, $this->replace->getRed(), $this->replace->getGreen(), $this->replace->getBlue());
         // SET NEW COLOR
     }
     $aResource->setResource($dest);
 }
 /**
  * Applies the filter to the image resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     if ($this->angle == 0 || $this->angle == 360) {
         return;
     }
     imageantialias($aResource->getResource(), true);
     $aResource->setResource(imagerotate($aResource->getResource(), $this->angle, $this->bgColor->getColorIndex(), $this->bgColor->getAlpha()));
     $new_imgres = imagecreatetruecolor($aResource->getX(), $aResource->getY());
     $success = imagecopy($new_imgres, $aResource->getResource(), 0, 0, 0, 0, $aResource->getX(), $aResource->getY());
     if (!$success) {
         throw new FilterException(self::$filterType);
     }
     imagedestroy($new_imgres);
 }
 /**
  * Applies the filter to the image resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     if ($this->percentage == 0) {
         return;
         // percentage = 0, do nothing !
     }
     $resource = $aResource->getResource();
     $rgb = 0;
     $d = array();
     $s = array();
     $dstx = 0;
     $dsty = 0;
     $dest = imagecreatetruecolor($aResource->getX(), $aResource->getY());
     for ($i = 0; $i < $aResource->getY(); $i++) {
         for ($j = 0; $j < $aResource->getX(); $j++) {
             $rgb = imagecolorat($dest, $dstx + $j, $dsty + $i);
             $d[0] = $rgb >> 16 & 0xff;
             $d[1] = $rgb >> 8 & 0xff;
             $d[2] = $rgb & 0xff;
             $rgb = imagecolorat($aResource->getResource(), $j, $i);
             $s[0] = $rgb >> 16 & 0xff;
             $s[1] = $rgb >> 8 & 0xff;
             $s[2] = $rgb & 0xff;
             $d[0] += min($s[0], 0xff - $d[0]) * $this->percentage / 100;
             $d[1] += min($s[1], 0xff - $d[1]) * $this->percentage / 100;
             $d[2] += min($s[2], 0xff - $d[2]) * $this->percentage / 100;
             imagesetpixel($resource, $dstx + $j, $dsty + $i, imagecolorallocate($resource, $d[0], $d[1], $d[2]));
         }
     }
 }
 /**
  * Tests ImageResource->setResource()
  */
 public function testSetResourceFail()
 {
     try {
         $this->res->setResource(false);
         $this->fail('Expected an exception');
     } catch (ImageResourceException $ex) {
         $this->assertNotNull($ex->getMessage());
     }
 }
 /**
  * (non-PHPdoc)
  * @see \imagemanipulation\filter\IImageFilter::applyFilter()
  */
 public function applyFilter(ImageResource $aResource)
 {
     if ($this->noise === 0) {
         return;
     }
     $resource = $aResource->getResource();
     $imagex = $aResource->getX();
     $imagey = $aResource->getY();
     for ($x = 0; $x < $imagex; ++$x) {
         for ($y = 0; $y < $imagey; ++$y) {
             if (rand(0, 1)) {
                 $rgb = imagecolorat($resource, $x, $y);
                 $red = $rgb >> 16 & 0xff;
                 $green = $rgb >> 8 & 0xff;
                 $blue = $rgb & 0xff;
                 $modifier = rand($this->noise * -1, $this->noise);
                 $red += $modifier;
                 $green += $modifier;
                 $blue += $modifier;
                 if ($red > 255) {
                     $red = 255;
                 }
                 if ($green > 255) {
                     $green = 255;
                 }
                 if ($blue > 255) {
                     $blue = 255;
                 }
                 if ($red < 0) {
                     $red = 0;
                 }
                 if ($green < 0) {
                     $green = 0;
                 }
                 if ($blue < 0) {
                     $blue = 0;
                 }
                 $newcol = imagecolorallocate($resource, $red, $green, $blue);
                 imagesetpixel($resource, $x, $y, $newcol);
             }
         }
     }
 }
 public function applyFilter(ImageResource $aResource)
 {
     $x = $aResource->getX();
     $y = $aResource->getY();
     $resource = $aResource->getResource();
     // Create a new image
     $ip = imagecreatetruecolor($x, $y);
     // Loop through the whole height of the image
     for ($i = 0; $i < $y; $i++) {
         // Loop through the whole width of the image
         for ($j = 0; $j < $x; $j++) {
             // Get the pixel color ( $this->img->x - 1 needs to be there because of the imagestart @ 0,0 ;) )
             $c = imagecolorat($resource, $x - 1 - $j, $i);
             // Get the rgb values from color $c
             $r = $c >> 16 & 0xff;
             $g = $c >> 8 & 0xff;
             $b = $c & 0xff;
             // Set the color
             $clr = imagecolorallocate($ip, $r, $g, $b);
             // Set the pixel color in the new image
             imagesetpixel($ip, $j, $i, $clr);
         }
     }
     $aResource->setResource(imagecreatetruecolor($x, $y));
     imagecopy($aResource->getResource(), $ip, 0, 0, 0, 0, $x, $y);
 }
 /**
  * Applies the filter to the resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     $width = $aResource->getWidth();
     $height = $aResource->getHeight();
     $lineRes = imagecreatetruecolor($width, 1);
     $bgc = imagecolorallocatealpha($lineRes, $this->backgroundColor->getRed(), $this->backgroundColor->getGreen(), $this->backgroundColor->getBlue(), $this->backgroundColor->getAlpha());
     // Background color
     imagefilledrectangle($lineRes, 0, 0, $width, 1, $bgc);
     $rotated = $aResource->cloneResource();
     $rotateFilter = new ImageFilterRotate(180, $this->backgroundColor);
     $rotateFilter->applyFilter($rotated);
     $bg = imagecreatetruecolor($width, $this->height);
     imagecopyresampled($bg, $rotated->getResource(), 0, 0, 0, 0, $width, $height, $width, $height);
     $im = $bg;
     $bg = imagecreatetruecolor($width, $this->height);
     for ($x = 0; $x < $width; $x++) {
         imagecopy($bg, $im, $x, 0, $width - $x, 0, 1, $this->height);
     }
     $im = $bg;
     $in = 100 / $this->height;
     for ($i = 0; $i <= $this->height; $i++) {
         imagecopymerge($im, $lineRes, 0, $i, 0, 0, $width, 1, $this->startOpacity);
         if ($this->startOpacity < 100) {
             $this->startOpacity += $in;
         }
     }
     imagecopymerge($im, $lineRes, 0, 0, 0, 0, $width, $this->divLineHeight, 100);
     // Divider
     if ($this->includeOriginal) {
         // we need to include the original
         $mergeWidth = imagesx($im) + $aResource->getWidth();
         $mergeHeight = imagesy($im) + $aResource->getHeight();
         $imMerge = imagecreatetruecolor($width, $mergeHeight);
         imagecopy($imMerge, $aResource->getResource(), 0, 0, 0, 0, $width, $height);
         imagecopy($imMerge, $im, 0, $aResource->getHeight(), 0, 0, $width, $height);
         $aResource->setResource($imMerge);
     } else {
         $aResource->setResource($im);
     }
 }
 /**
  * Applies the sepia filter to an image resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     $dstImg = $aResource->getResource();
     $imgX = $aResource->getX();
     $imgY = $aResource->getY();
     for ($y = 0; $y < $imgY; $y++) {
         for ($x = 0; $x < $imgX; $x++) {
             $dstRGB = imagecolorat($dstImg, $x, $y);
             //$dstA = ($dstRGB >> 24) << 1;
             $dstR = $dstRGB >> 16 & 0xff;
             $dstG = $dstRGB >> 8 & 0xff;
             $dstB = $dstRGB & 0xff;
             $newR = $dstR * 0.393 + $dstG * 0.769 + $dstB * 0.189 - $this->darken;
             $newG = $dstR * 0.349 + $dstG * 0.6860000000000001 + $dstB * 0.168 - $this->darken;
             $newB = $dstR * 0.272 + $dstG * 0.534 + $dstB * 0.131 - $this->darken;
             $newR = $newR > 255 ? 255 : ($newR < 0 ? 0 : $newR);
             $newG = $newG > 255 ? 255 : ($newG < 0 ? 0 : $newG);
             $newB = $newB > 255 ? 255 : ($newB < 0 ? 0 : $newB);
             $newRGB = imagecolorallocate($dstImg, $newR, $newG, $newB);
             imagesetpixel($dstImg, $x, $y, $newRGB);
         }
     }
 }
 /**
  * Applies the sepia filter to an image resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     if ($this->red === 0 && $this->green === 0 && $this->blue === 0) {
         return;
     }
     $res = $aResource->getResource();
     $width = $aResource->getX();
     $height = $aResource->getY();
     for ($y = 0; $y < $height; $y++) {
         for ($x = 0; $x < $width; $x++) {
             $colorIndex = imagecolorat($res, $x, $y);
             $dstA = $colorIndex >> 24 << 1;
             $dstR = $colorIndex >> 16 & 0xff;
             $dstG = $colorIndex >> 8 & 0xff;
             $dstB = $colorIndex & 0xff;
             $newR = min(255, $this->red + $dstR);
             $newG = min(255, $this->green + $dstG);
             $newB = min(255, $this->blue + $dstB);
             $newColor = imagecolorallocatealpha($res, $newR, $newG, $newB, $dstA);
             imagesetpixel($res, $x, $y, $newColor);
         }
     }
 }
 /**
  * Create the thumbnail
  *
  * @param $aResource ImageResource The image resource of the original image
  *       
  * @return ImageResource The image resource of the thumbnail
  */
 public function create(ImageResource $aResource)
 {
     // The original PHP image resource
     $origImgRes = $aResource->getResource();
     // Create a new image resource
     $newResource = clone $aResource;
     $this->strategy->init($aResource);
     $originalBegin = $this->strategy->getSourceBegin($newResource);
     $originalEnd = $this->strategy->getSourceEnd($newResource);
     $targetBegin = $this->strategy->getDestinationBegin($aResource);
     $targetEnd = $this->strategy->getDestinationEnd($newResource);
     // no change, return original
     if ($originalBegin == $targetBegin && $originalEnd == $targetEnd) {
         return $aResource;
     }
     $aResource->setResource(imagecreatetruecolor($targetEnd->getX(), $targetEnd->getY()));
     imagecolortransparent($aResource->getResource(), imagecolorallocate($newResource->getResource(), 0, 0, 0));
     imagealphablending($aResource->getResource(), false);
     imageantialias($aResource->getResource(), true);
     imagecopyresampled($aResource->getResource(), $newResource->getResource(), $targetBegin->getX(), $targetBegin->getY(), $originalBegin->getX(), $originalBegin->getY(), $targetEnd->getX(), $targetEnd->getY(), $originalEnd->getX(), $originalEnd->getY());
     $aResource->setResource($aResource->getResource());
     $newResource->destroy();
     return $aResource;
 }
 /**
  * Applies the filter to the resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     //comic effect
     $width = $aResource->getX();
     $height = $aResource->getY();
     $imgK = imagecreatetruecolor($width, $height);
     $lowR = $this->lowcolor->getRed();
     $lowG = $this->lowcolor->getGreen();
     $lowB = $this->lowcolor->getBlue();
     $highR = $this->highcolor->getRed();
     $highG = $this->highcolor->getGreen();
     $highB = $this->highcolor->getBlue();
     for ($y = 0; $y < $height; $y++) {
         for ($x = 0; $x < $width; $x++) {
             $rgb = imagecolorat($aResource->getResource(), $x, $y);
             $r = $rgb >> 16 & 0xff;
             $g = $rgb >> 8 & 0xff;
             $b = $rgb & 0xff;
             $bw = $r + $g + $b > 300 ? imagecolorallocate($imgK, $lowR, $lowG, $lowB) : imagecolorallocate($imgK, $highR, $highG, $highB);
             imagesetpixel($imgK, $x, $y, $bw);
         }
     }
     $aResource->setResource($imgK);
 }
 /**
  * (non-PHPdoc)
  * @see \imagemanipulation\filter\IImageFilter::applyFilter()
  */
 public function applyFilter(ImageResource $aResource)
 {
     $placeholder = imagecreatetruecolor($aResource->getX(), $aResource->getY());
     imagealphablending($placeholder, false);
     imagesavealpha($placeholder, true);
     $destWidth = $this->fill ? $aResource->getX() : $this->overlay->getX();
     $destHeight = $this->fill ? $aResource->getY() : $this->overlay->getY();
     imagecopyresized($placeholder, $this->overlay->getResource(), 0, 0, 0, 0, $destWidth, $destHeight, $this->overlay->getX(), $this->overlay->getY());
     imagecopymerge($aResource->getResource(), $placeholder, $this->startX, $this->startY, 0, 0, $destWidth, $destHeight, $this->opacity);
 }
 /**
  * (non-PHPdoc)
  * @see \imagemanipulation\filter\IImageFilter::applyFilter()
  */
 public function applyFilter(ImageResource $aResource)
 {
     $destWidth = $this->fill ? $aResource->getX() : $this->overlay->getX();
     $destHeight = $this->fill ? $aResource->getY() : $this->overlay->getY();
     imagealphablending($this->overlay->getResource(), false);
     imagesavealpha($this->overlay->getResource(), false);
     imagecopyresized($this->overlay->getResource(), $this->overlay->getResource(), 0, 0, 0, 0, $destWidth, $destHeight, $this->overlay->getX(), $this->overlay->getY());
     imagealphablending($aResource->getResource(), true);
     imagesavealpha($aResource->getResource(), true);
     imagecopyresampled($aResource->getResource(), $this->overlay->getResource(), $this->startX, $this->startY, 0, 0, $destWidth, $destHeight, $destWidth, $destHeight);
 }
 /**
  * Applies the filter to the resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     if (!isset($this->opacity)) {
         return;
     }
     $this->opacity /= 100;
     //get image width and height
     $w = $aResource->getX();
     $h = $aResource->getY();
     //turn alpha blending off
     imagealphablending($aResource->getResource(), false);
     //find the most opaque pixel in the image (the one with the smallest alpha value)
     $minalpha = 127;
     for ($x = 0; $x < $w; $x++) {
         for ($y = 0; $y < $h; $y++) {
             $alpha = imagecolorat($aResource->getResource(), $x, $y) >> 24 & 0xff;
             if ($alpha < $minalpha) {
                 $minalpha = $alpha;
             }
         }
     }
     //loop through image pixels and modify alpha for each
     for ($x = 0; $x < $w; $x++) {
         for ($y = 0; $y < $h; $y++) {
             //get current alpha value (represents the TANSPARENCY!)
             $colorxy = imagecolorat($aResource->getResource(), $x, $y);
             $alpha = $colorxy >> 24 & 0xff;
             //calculate new alpha
             if ($minalpha !== 127) {
                 $alpha = 127 + 127 * $this->opacity * ($alpha - 127) / (127 - $minalpha);
             } else {
                 $alpha += 127 * $this->opacity;
             }
             //get the color index with new alpha
             $alphacolorxy = imagecolorallocatealpha($aResource->getResource(), $colorxy >> 16 & 0xff, $colorxy >> 8 & 0xff, $colorxy & 0xff, $alpha);
             //set pixel with the new color + opacity
             if (!imagesetpixel($aResource->getResource(), $x, $y, $alphacolorxy)) {
                 return;
             }
         }
     }
 }
 /**
  * Applies the filter to the resource
  *
  * @param ImageResource $aResource
  */
 public function applyFilter(ImageResource $aResource)
 {
     $orig_time_limit = ini_get('max_execution_time');
     set_time_limit(180);
     // creating the image
     $starting_img = $aResource->getResource();
     // this will be the final image, same width and height of the original
     $final = imagecreatetruecolor($aResource->getX(), $aResource->getY());
     // looping through ALL pixels!!
     for ($x = 1; $x < $aResource->getX() - 1; $x++) {
         for ($y = 1; $y < $aResource->getY() - 1; $y++) {
             // getting gray value of all surrounding pixels
             $pixel_up = $this->getLuminance(imagecolorat($starting_img, $x, $y - 1));
             $pixel_down = $this->getLuminance(imagecolorat($starting_img, $x, $y + 1));
             $pixel_left = $this->getLuminance(imagecolorat($starting_img, $x - 1, $y));
             $pixel_right = $this->getLuminance(imagecolorat($starting_img, $x + 1, $y));
             $pixel_up_left = $this->getLuminance(imagecolorat($starting_img, $x - 1, $y - 1));
             $pixel_up_right = $this->getLuminance(imagecolorat($starting_img, $x + 1, $y - 1));
             $pixel_down_left = $this->getLuminance(imagecolorat($starting_img, $x - 1, $y + 1));
             $pixel_down_right = $this->getLuminance(imagecolorat($starting_img, $x + 1, $y + 1));
             // appliying convolution mask
             $conv_x = $pixel_up_right + $pixel_right * 2 + $pixel_down_right - ($pixel_up_left + $pixel_left * 2 + $pixel_down_left);
             $conv_y = $pixel_up_left + $pixel_up * 2 + $pixel_up_right - ($pixel_down_left + $pixel_down * 2 + $pixel_down_right);
             // calculating the distance
             $gray = (int) sqrt($conv_x * $conv_x + $conv_y + $conv_y);
             // inverting the distance not to get the negative image
             $gray = 255 - $gray;
             // adjusting distance if it's greater than 255 or less than zero (out of color range)
             if ($gray > 255) {
                 $gray = 255;
             }
             if ($gray < 0) {
                 $gray = 0;
             }
             // creation of the new gray
             $new_gray = imagecolorallocate($final, $gray, $gray, $gray);
             // adding the gray pixel to the new image
             imagesetpixel($final, $x, $y, $new_gray);
         }
     }
     imagedestroy($starting_img);
     $aResource->setResource($final);
     set_time_limit($orig_time_limit);
 }
 public function applyFilter(ImageResource $aResource)
 {
     imagefilter($aResource->getResource(), IMG_FILTER_MEAN_REMOVAL);
 }