webadmin.php

/admin/ckeditor/filemanager/connectors/php/inc/vendor/wideimage/lib/Image.php

1\
2\
3\
4\
5\
6\
7\
8\
9\
10\
11\
12\
13\
14\
15\
16\
17\
18\
19\
20\
21\
22\
23\
24\
25\
26\
27\
28\
29\
30\
31\
32\
33\
34\
35\
36\
37\
38\
39\
40\
41\
42\
43\
44\
45\
46\
47\
48\
49\
50\
51\
52\
53\
54\
55\
56\
57\
58\
59\
60\
61\
62\
63\
64\
65\
66\
67\
68\
69\
70\
71\
72\
73\
74\
75\
76\
77\
78\
79\
80\
81\
82\
83\
84\
85\
86\
87\
88\
89\
90\
91\
92\
93\
94\
95\
96\
97\
98\
99\
100\
101\
102\
103\
104\
105\
106\
107\
108\
109\
110\
111\
112\
113\
114\
115\
116\
117\
118\
119\
120\
121\
122\
123\
124\
125\
126\
127\
128\
129\
130\
131\
132\
133\
134\
135\
136\
137\
138\
139\
140\
141\
142\
143\
144\
145\
146\
147\
148\
149\
150\
151\
152\
153\
154\
155\
156\
157\
158\
159\
160\
161\
162\
163\
164\
165\
166\
167\
168\
169\
170\
171\
172\
173\
174\
175\
176\
177\
178\
179\
180\
181\
182\
183\
184\
185\
186\
187\
188\
189\
190\
191\
192\
193\
194\
195\
196\
197\
198\
199\
200\
201\
202\
203\
204\
205\
206\
207\
208\
209\
210\
211\
212\
213\
214\
215\
216\
217\
218\
219\
220\
221\
222\
223\
224\
225\
226\
227\
228\
229\
230\
231\
232\
233\
234\
235\
236\
237\
238\
239\
240\
241\
242\
243\
244\
245\
246\
247\
248\
249\
250\
251\
252\
253\
254\
255\
256\
257\
258\
259\
260\
261\
262\
263\
264\
265\
266\
267\
268\
269\
270\
271\
272\
273\
274\
275\
276\
277\
278\
279\
280\
281\
282\
283\
284\
285\
286\
287\
288\
289\
290\
291\
292\
293\
294\
295\
296\
297\
298\
299\
300\
301\
302\
303\
304\
305\
306\
307\
308\
309\
310\
311\
312\
313\
314\
315\
316\
317\
318\
319\
320\
321\
322\
323\
324\
325\
326\
327\
328\
329\
330\
331\
332\
333\
334\
335\
336\
337\
338\
339\
340\
341\
342\
343\
344\
345\
346\
347\
348\
349\
350\
351\
352\
353\
354\
355\
356\
357\
358\
359\
360\
361\
362\
363\
364\
365\
366\
367\
368\
369\
370\
371\
372\
373\
374\
375\
376\
377\
378\
379\
380\
381\
382\
383\
384\
385\
386\
387\
388\
389\
390\
391\
392\
393\
394\
395\
396\
397\
398\
399\
400\
401\
402\
403\
404\
405\
406\
407\
408\
409\
410\
411\
412\
413\
414\
415\
416\
417\
418\
419\
420\
421\
422\
423\
424\
425\
426\
427\
428\
429\
430\
431\
432\
433\
434\
435\
436\
437\
438\
439\
440\
441\
442\
443\
444\
445\
446\
447\
448\
449\
450\
451\
452\
453\
454\
455\
456\
457\
458\
459\
460\
461\
462\
463\
464\
465\
466\
467\
468\
469\
470\
471\
472\
473\
474\
475\
476\
477\
478\
479\
480\
481\
482\
483\
484\
485\
486\
487\
488\
489\
490\
491\
492\
493\
494\
495\
496\
497\
498\
499\
500\
501\
502\
503\
504\
505\
506\
507\
508\
509\
510\
511\
512\
513\
514\
515\
516\
517\
518\
519\
520\
521\
522\
523\
524\
525\
526\
527\
528\
529\
530\
531\
532\
533\
534\
535\
536\
537\
538\
539\
540\
541\
542\
543\
544\
545\
546\
547\
548\
549\
550\
551\
552\
553\
554\
555\
556\
557\
558\
559\
560\
561\
562\
563\
564\
565\
566\
567\
568\
569\
570\
571\
572\
573\
574\
575\
576\
577\
578\
579\
580\
581\
582\
583\
584\
585\
586\
587\
588\
589\
590\
591\
592\
593\
594\
595\
596\
597\
598\
599\
600\
601\
602\
603\
604\
605\
606\
607\
608\
609\
610\
611\
612\
613\
614\
615\
616\
617\
618\
619\
620\
621\
622\
623\
624\
625\
626\
627\
628\
629\
630\
631\
632\
633\
634\
635\
636\
637\
638\
639\
640\
641\
642\
643\
644\
645\
646\
647\
648\
649\
650\
651\
652\
653\
654\
655\
656\
657\
658\
659\
660\
661\
662\
663\
664\
665\
666\
667\
668\
669\
670\
671\
672\
673\
674\
675\
676\
677\
678\
679\
680\
681\
682\
683\
684\
685\
686\
687\
688\
689\
690\
691\
692\
693\
694\
695\
696\
697\
698\
699\
700\
701\
702\
703\
704\
705\
706\
707\
708\
709\
710\
711\
712\
713\
714\
715\
716\
717\
718\
719\
720\
721\
722\
723\
724\
725\
726\
727\
728\
729\
730\
731\
732\
733\
734\
735\
736\
737\
738\
739\
740\
741\
742\
743\
744\
745\
746\
747\
748\
749\
750\
751\
752\
753\
754\
755\
756\
757\
758\
759\
760\
761\
762\
763\
764\
765\
766\
767\
768\
769\
770\
771\
772\
773\
774\
775\
776\
777\
778\
779\
780\
781\
782\
783\
784\
785\
786\
787\
788\
789\
790\
791\
792\
793\
794\
795\
796\
797\
798\
799\
800\
801\
802\
803\
804\
805\
806\
807\
808\
809\
810\
811\
812\
813\
814\
815\
816\
817\
818\
819\
820\
821\
822\
823\
824\
825\
826\
827\
828\
829\
830\
831\
832\
833\
834\
835\
836\
837\
838\
839\
840\
841\
842\
843\
844\
845\
846\
847\
848\
849\
850\
851\
852\
853\
854\
855\
856\
857\
858\
859\
860\
861\
862\
863\
864\
865\
866\
867\
868\
869\
870\
871\
872\
873\
874\
875\
876\
877\
878\
879\
880\
881\
882\
883\
884\
885\
886\
887\
888\
889\
890\
891\
892\
893\
894\
895\
896\
897\
898\
899\
900\
901\
902\
903\
904\
905\
906\
907\
908\
909\
910\
911\
912\
913\
914\
915\
916\
917\
918\
919\
920\
921\
922\
923\
924\
925\
926\
927\
928\
929\
930\
931\
932\
933\
934\
935\
936\
937\
938\
939\
940\
941\
942\
943\
944\
945\
946\
947\
948\
949\
950\
951\
952\
953\
954\
955\
956\
957\
958\
959\
960\
961\
962\
963\
964\


<?php
    /**
 * @author Gasper Kozak
 * @copyright 2007-2011

    This file is part of WideImage.
        
    WideImage is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 2.1 of the License, or
    (at your option) any later version.
        
    WideImage is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
        
    You should have received a copy of the GNU Lesser General Public License
    along with WideImage; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    * @package WideImage
  **/
    
    /**
     * Thrown when an invalid dimension is passed for some operations
     * 
     * @package Exceptions
     */
    class WideImage_InvalidImageDimensionException extends WideImage_Exception {}
    
    /**
     * Thrown when an image can't be saved (returns false by the mapper)
     * 
     * @package Exceptions
     */
    class WideImage_UnknownErrorWhileMappingException extends WideImage_Exception {}
    
    /**
     * Base class for images
     * 
     * @package WideImage
     */
    abstract class WideImage_Image
    {
        /**
         * Holds the image resource
         * @var resource
         */
        protected $handle = null;
        
        /**
         * Flag that determines if WideImage should call imagedestroy() upon object destruction
         * @var bool
         */
        protected $handleReleased = false;
        
        /**
         * Canvas object
         * @var WideImage_Canvas
         */
        protected $canvas = null;
        
        /**
         * @var string
         */
        protected $sdata = null;
        
        /**
         * The base class constructor
         *
         * @param resource $handle Image handle (GD2 resource)
         */
        function __construct($handle)
        {
            WideImage::assertValidImageHandle($handle);
            $this->handle = $handle;
        }
        
        /**
         * Cleanup
         * 
         * Destroys the handle via WideImage_Image::destroy() when called by the GC.
         */
        function __destruct()
        {
            $this->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.
         */
        function destroy()
        {
            if ($this->isValid() && !$this->handleReleased)
                imagedestroy($this->handle);
            
            $this->handle = null;
        }
        
        /**
         * Returns the GD image resource
         * 
         * @return resource GD image resource
         */
        function getHandle()
        {
            return $this->handle;
        }
        
        /**
         * @return bool True, if the image object holds a valid GD image, false otherwise
         */
        function isValid()
        {
            return WideImage::isValidImageHandle($this->handle);
        }
        
        /**
         * Releases the handle
         */
        function releaseHandle()
        {
            $this->handleReleased = true;
        }
        
        /**
         * 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:
         * <code>
         * // 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');
         * </code>
         * 
         * @param string $uri File location
         */
        function saveToFile($uri)
        {
            $mapper = WideImage_MapperFactory::selectMapper($uri, null);
            $args = func_get_args();
            array_unshift($args, $this->getHandle());
            $res = call_user_func_array(array($mapper, 'save'), $args);
            if (!$res)
                throw new WideImage_UnknownErrorWhileMappingException(get_class($mapper) . " returned an invalid result while saving to $uri");
        }
        
        /**
         * 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.
         * 
         * @param string $format The format of the image
         * @return string The binary image data in specified format
         */
        function asString($format)
        {
            ob_start();
            $args = func_get_args();
            $args[0] = null;
            array_unshift($args, $this->getHandle());
            
            $mapper = WideImage_MapperFactory::selectMapper(null, $format);
            $res = call_user_func_array(array($mapper, 'save'), $args);
            if (!$res)
                throw new WideImage_UnknownErrorWhileMappingException(get_class($mapper) . " returned an invalid result while writing the image data");
            
            return ob_get_clean();
        }
        
        /**
         * Output a header to browser.
         * 
         * @param $name Name of the header
         * @param $data Data
         */
        protected function writeHeader($name, $data)
        {
            header($name . ": " . $data);
        }
        
        /**
         * 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:
         * <code>
         * WideImage::load('image1.png')->resize(100, 100)->output('gif');
         * </code>
         * 
         * @param string $format Image format
         */
        function output($format)
        {
            $args = func_get_args();
            $data = call_user_func_array(array($this, 'asString'), $args);
            
            $this->writeHeader('Content-length', strlen($data));
            $this->writeHeader('Content-type', WideImage_MapperFactory::mimeType($format));
            echo $data;
        }
        
        /**
         * @return int Image width
         */
        function getWidth()
        {
            return imagesx($this->handle);
        }
        
        /**
         * @return int Image height
         */
        function getHeight()
        {
            return imagesy($this->handle);
        }
        
        /**
         * Allocate a color by RGB values.
         * 
         * @param mixed $R Red-component value or an RGB array (with red, green, blue keys)
         * @param int $G If $R is int, this is the green component
         * @param int $B If $R is int, this is the blue component
         * @return int Image color index
         */
        function allocateColor($R, $G = null, $B = null)
        {
            if (is_array($R))
                return imageColorAllocate($this->handle, $R['red'], $R['green'], $R['blue']);
            else
                return imageColorAllocate($this->handle, $R, $G, $B);
        }
        
        /**
         * @return bool True if the image is transparent, false otherwise
         */
        function isTransparent()
        {
            return $this->getTransparentColor() >= 0;
        }
        
        /**
         * @return int Transparent color index
         */
        function getTransparentColor()
        {
            return imagecolortransparent($this->handle);
        }
        
        /**
         * Sets the current transparent color index. Only makes sense for palette images (8-bit).
         * 
         * @param int $color Transparent color index
         */
        function setTransparentColor($color)
        {
            return imagecolortransparent($this->handle, $color);
        }
        
        /**
         * Returns a RGB array of the transparent color or null if none.
         * 
         * @return mixed Transparent color RGBA array
         */
        function getTransparentColorRGB()
        {
            $total = imagecolorstotal($this->handle);
            $tc = $this->getTransparentColor();
            
            if ($tc >= $total && $total > 0)
                return null;
            else
                return $this->getColorRGB($tc);
        }
        
        /**
         * Returns a RGBA array for pixel at $x, $y
         * 
         * @param int $x
         * @param int $y
         * @return array RGB array 
         */
        function getRGBAt($x, $y)
        {
            return $this->getColorRGB($this->getColorAt($x, $y));
        }
        
        /**
         * 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.
         *
         * @param int $x
         * @param int $y
         * @param array $color
         */
        function setRGBAt($x, $y, $color)
        {
            $this->setColorAt($x, $y, $this->getExactColor($color));
        }
        
        /**
         * Returns a color's RGB
         * 
         * @param int $colorIndex Color index
         * @return mixed RGBA array for a color with index $colorIndex
         */
        function getColorRGB($colorIndex)
        {
            return imageColorsForIndex($this->handle, $colorIndex);
        }
        
        /**
         * Returns an index of the color at $x, $y
         * 
         * @param int $x
         * @param int $y
         * @return int Color index for a pixel at $x, $y
         */
        function getColorAt($x, $y)
        {
            return imagecolorat($this->handle, $x, $y);
        }
        
        /**
         * Set the color index $color to a pixel at $x, $y
         * 
         * @param int $x
         * @param int $y
         * @param int $color Color index
         */
        function setColorAt($x, $y, $color)
        {
            return imagesetpixel($this->handle, $x, $y, $color);
        }
        
        /**
         * Returns closest color index that matches the given RGB value. Uses
         * PHP's imagecolorclosest()
         * 
         * @param mixed $R Red or RGBA array
         * @param int $G Green component (or null if $R is an RGB array)
         * @param int $B Blue component (or null if $R is an RGB array)
         * @return int Color index
         */
        function getClosestColor($R, $G = null, $B = null)
        {
            if (is_array($R))
                return imagecolorclosest($this->handle, $R['red'], $R['green'], $R['blue']);
            else
                return imagecolorclosest($this->handle, $R, $G, $B);
        }
        
        /**
         * Returns the color index that exactly matches the given RGB value. Uses
         * PHP's imagecolorexact()
         * 
         * @param mixed $R Red or RGBA array
         * @param int $G Green component (or null if $R is an RGB array)
         * @param int $B Blue component (or null if $R is an RGB array)
         * @return int Color index
         */
        function getExactColor($R, $G = null, $B = null)
        {
            if (is_array($R))
                return imagecolorexact($this->handle, $R['red'], $R['green'], $R['blue']);
            else
                return imagecolorexact($this->handle, $R, $G, $B);
        }
        
        /**
         * Copies transparency information from $sourceImage. Optionally fills
         * the image with the transparent color at (0, 0).
         * 
         * @param object $sourceImage
         * @param bool $fill True if you want to fill the image with transparent color
         */
        function copyTransparencyFrom($sourceImage, $fill = true)
        {
            if ($sourceImage->isTransparent())
            {
                $rgba = $sourceImage->getTransparentColorRGB();
                if ($rgba === null)
                    return;
                
                if ($this->isTrueColor())
                {
                    $rgba['alpha'] = 127;
                    $color = $this->allocateColorAlpha($rgba);
                }
                else
                    $color = $this->allocateColor($rgba);
                
                $this->setTransparentColor($color);
                if ($fill)
                    $this->fill(0, 0, $color);
            }
        }
        
        /**
         * Fill the image at ($x, $y) with color index $color
         * 
         * @param int $x
         * @param int $y
         * @param int $color
         */
        function fill($x, $y, $color)
        {
            return imagefill($this->handle, $x, $y, $color);
        }
        
        /**
         * Used internally to create Operation objects
         *
         * @param string $name
         * @return object
         */
        protected function getOperation($name)
        {
            return WideImage_OperationFactory::get($name);
        }
        
        /**
         * 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.
         * 
         * @return WideImage_Image An image mask
         **/
        function getMask()
        {
            return $this->getOperation('GetMask')->execute($this);
        }
        
        /**
         * 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%, ...)
         * 
         * If $width is null, it's calculated proportionally from $height, and vice versa.
         * 
         * Example (resize to half-size):
         * <code>
         * $smaller = $image->resize('50%');
         * 
         * $smaller = $image->resize('100', '100', 'inside', 'down');
         * is the same as
         * $smaller = $image->resizeDown(100, 100, 'inside');
         * </code>
         * 
         * @param mixed $width The new width (smart coordinate), or null.
         * @param mixed $height The new height (smart coordinate), or null.
         * @param string $fit 'inside', 'outside', 'fill'
         * @param string $scale 'down', 'up', 'any'
         * @return WideImage_Image The resized image
         */
        function resize($width = null, $height = null, $fit = 'inside', $scale = 'any')
        {
            return $this->getOperation('Resize')->execute($this, $width, $height, $fit, $scale);
        }
        
        /**
         * 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.
         * 
         * @param int $width New width, smart coordinate
         * @param int $height New height, smart coordinate
         * @param string $fit 'inside', 'outside', 'fill'
         * @return WideImage_Image resized image
         */
        function resizeDown($width = null, $height = null, $fit = 'inside')
        {
            return $this->resize($width, $height, $fit, 'down');
        }
        
        /**
         * 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.
         * 
         * @param int $width New width, smart coordinate
         * @param int $height New height, smart coordinate
         * @param string $fit 'inside', 'outside', 'fill'
         * @return WideImage_Image resized image
         */
        function resizeUp($width = null, $height = null, $fit = 'inside')
        {
            return $this->resize($width, $height, $fit, 'up');
        }
        
        /**
         * Rotate the image for angle $angle clockwise.
         * 
         * Preserves transparency. Has issues when saving to a BMP.
         * 
         * @param int $angle Angle in degrees, clock-wise
         * @param int $bgColor color of the new background
         * @param bool $ignoreTransparent
         * @return WideImage_Image The rotated image
         */
        function rotate($angle, $bgColor = null, $ignoreTransparent = true)
        {
            return $this->getOperation('Rotate')->execute($this, $angle, $bgColor, $ignoreTransparent);
        }
        
        /**
         * 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:
         * <code>
         * $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
         * </code>
         * 
         * @param WideImage_Image $overlay The overlay image
         * @param mixed $left Left position of the overlay, smart coordinate
         * @param mixed $top Top position of the overlay, smart coordinate
         * @param int $pct The opacity of the overlay
         * @return WideImage_Image The merged image
         */
        function merge($overlay, $left = 0, $top = 0, $pct = 100)
        {
            return $this->getOperation('Merge')->execute($this, $overlay, $left, $top, $pct);
        }
        
        /**
         * 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].
         * <code>
         * $image = WideImage::load('someimage.jpg'); // 100x150
         * $white = $image->allocateColor(255, 255, 255);
         * $image->resizeCanvas('200%', '100% + 20', 10, 'center+20', $white);
         * </code>
         * 
         * 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'. 
         * 
         * @param mixed $width Width of the new canvas (smart coordinate, relative to current image width)
         * @param mixed $height Height of the new canvas (smart coordinate, relative to current image height)
         * @param mixed $pos_x x-position of the image (smart coordinate, relative to the new width)
         * @param mixed $pos_y y-position of the image (smart coordinate, relative to the new height)
         * @param int $bg_color Background color (created with allocateColor or allocateColorAlpha), defaults to null (tries to use a transparent color)
         * @param string $scale Possible values: 'up' (enlarge only), 'down' (downsize only), 'any' (resize precisely to $width x $height). Defaults to 'any'.
         * @param bool $merge Merge the original image (flatten alpha channel and transparency) or copy it over (preserve). Defaults to false.
         * @return WideImage_Image The resulting image with resized canvas
         */
        function resizeCanvas($width, $height, $pos_x, $pos_y, $bg_color = null, $scale = 'any', $merge = false)
        {
            return $this->getOperation('ResizeCanvas')->execute($this, $width, $height, $pos_x, $pos_y, $bg_color, $scale, $merge);
        }
        
        /**
         * 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:
         * <code>
         * $nice = $ugly->roundCorners(20, $ugly->allocateColor(255, 0, 0), 2);
         * </code>
         * 
         * 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:
         * <code>
         * $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);
         * </code>
         * 
         * @param int $radius Radius of the corners
         * @param int $color The color of corners. If null, corners are rendered transparent (slower than using a solid color).
         * @param int $smoothness Specify the level of smoothness. Suggested values from 1 to 4.
         * @param int $corners Specify which corners to draw (defaults to WideImage::SIDE_ALL = all corners)
         * @return WideImage_Image The resulting image with round corners
         */
        function roundCorners($radius, $color = null, $smoothness = 2, $corners = 255)
        {
            return $this->getOperation('RoundCorners')->execute($this, $radius, $color, $smoothness, $corners);
        }
        
        /**
         * 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.
         * 
         * @param WideImage_Image $mask The mask image, greyscale
         * @param mixed $left Left coordinate, smart coordinate
         * @param mixed $top Top coordinate, smart coordinate
         * @return WideImage_Image The resulting image
         **/
        function applyMask($mask, $left = 0, $top = 0)
        {
            return $this->getOperation('ApplyMask')->execute($this, $mask, $left, $top);
        }
        
        /**
         * Applies a filter
         *
         * @param int $filter One of the IMG_FILTER_* constants
         * @param int $arg1
         * @param int $arg2
         * @param int $arg3
         * @param int $arg4
         * @return WideImage_Image
         */
        function applyFilter($filter, $arg1 = null, $arg2 = null, $arg3 = null, $arg4 = null)
        {
            return $this->getOperation('ApplyFilter')->execute($this, $filter, $arg1, $arg2, $arg3, $arg4);
        }
        
        /**
         * Applies convolution matrix with imageconvolution()
         *
         * @param array $matrix
         * @param float $div
         * @param float $offset
         * @return WideImage_Image
         */
        function applyConvolution($matrix, $div, $offset)
        {
            return $this->getOperation('ApplyConvolution')->execute($this, $matrix, $div, $offset);
        }
        
        /**
         * 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:
         * <code>
         * $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
         * </code>
         * 
         * This operation supports alignment notation in left/top coordinates.
         * Example:
         * <code>
         * $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
         * </code>
         * 
         * @param mixed $left Left-coordinate of the crop rect, smart coordinate
         * @param mixed $top Top-coordinate of the crop rect, smart coordinate
         * @param mixed $width Width of the crop rect, smart coordinate
         * @param mixed $height Height of the crop rect, smart coordinate
         * @return WideImage_Image The cropped image
         **/
        function crop($left = 0, $top = 0, $width = '100%', $height = '100%')
        {
            return $this->getOperation('Crop')->execute($this, $left, $top, $width, $height);
        }
        
        /**
         * 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.
         *
         * @param int $margin Margin for the crop rectangle, can be negative.
         * @param int $rgb_threshold RGB difference which still counts as "same color".
         * @param int $pixel_cutoff How many pixels need to be different to mark a cut line.
         * @param int $base_color The base color index. If none specified (or null given), left-top pixel is used.
         * @return WideImage_Image The cropped image
         */
        function autoCrop($margin = 0, $rgb_threshold = 0, $pixel_cutoff = 1, $base_color = null)
        {
            return $this->getOperation('AutoCrop')->execute($this, $margin, $rgb_threshold, $pixel_cutoff, $base_color);
        }
        
        /**
         * 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.
         *
         * @return WideImage_Image negative of the image
         */
        function asNegative()
        {
            return $this->getOperation('AsNegative')->execute($this);
        }
        
        /**
         * Returns a grayscale copy of the image
         * 
         * @return WideImage_Image grayscale copy
         **/
        function asGrayscale()
        {
            return $this->getOperation('AsGrayscale')->execute($this);
        }
        
        /**
         * Returns a mirrored copy of the image
         * 
         * @return WideImage_Image Mirrored copy
         **/
        function mirror()
        {
            return $this->getOperation('Mirror')->execute($this);
        }
        
        /**
         * Applies the unsharp filter
         * 
         * @param float $amount
         * @param float $radius
         * @param float $threshold
         * @return WideImage_Image Unsharpened copy of the image
         **/
        function unsharp($amount, $radius, $threshold)
        {
            return $this->getOperation('Unsharp')->execute($this, $amount, $radius, $threshold);
        }
        
        /**
         * Returns a flipped (mirrored over horizontal line) copy of the image
         * 
         * @return WideImage_Image Flipped copy
         **/
        function flip()
        {
            return $this->getOperation('Flip')->execute($this);
        }
        
        /**
         * Corrects gamma on the image
         * 
         * @param float $inputGamma
         * @param float $outputGamma
         * @return WideImage_Image Image with corrected gamma
         **/
        function correctGamma($inputGamma, $outputGamma)
        {
            return $this->getOperation('CorrectGamma')->execute($this, $inputGamma, $outputGamma);
        }
        
        /**
         * Adds noise to the image
         * 
         * @author Tomasz Kapusta
         * 
         * @param int $amount Number of noise pixels to add
         * @param string $type Type of noise 'salt&pepper', 'color' or 'mono'
         * @return WideImage_Image Image with noise added
         **/
        function addNoise($amount, $type)
        {
            return $this->getOperation('AddNoise')->execute($this, $amount, $type);
        }
        
        /**
         * Used internally to execute operations
         *
         * @param string $name
         * @param array $args
         * @return WideImage_Image
         */
        function __call($name, $args)
        {
            $op = $this->getOperation($name);
            array_unshift($args, $this);
            return call_user_func_array(array($op, 'execute'), $args);
        }
        
        /**
         * Returns an image in GIF or PNG format
         *
         * @return string
         */
        function __toString()
        {
            if ($this->isTransparent())
                return $this->asString('gif');
            else
                return $this->asString('png');
        }
        
        /**
         * Returns a copy of the image object
         * 
         * @return WideImage_Image The copy
         **/
        function copy()
        {
            $dest = $this->doCreate($this->getWidth(), $this->getHeight());
            $dest->copyTransparencyFrom($this, true);
            $this->copyTo($dest, 0, 0);
            return $dest;
        }
        
        /**
         * Copies this image onto another image
         * 
         * @param WideImage_Image $dest
         * @param int $left
         * @param int $top
         **/
        function copyTo($dest, $left = 0, $top = 0)
        {
            if (!imagecopy($dest->getHandle(), $this->handle, $left, $top, 0, 0, $this->getWidth(), $this->getHeight()))
                throw new WideImage_GDFunctionResultException("imagecopy() returned false");
        }
        
        /**
         * Returns the canvas object
         * 
         * The Canvas object can be used to draw text and shapes on the image
         * 
         * Examples:
         * <code>
         * $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');
         * </code>
         * 
         * @return WideImage_Canvas The Canvas object
         **/
        function getCanvas()
        {
            if ($this->canvas == null)
                $this->canvas = new WideImage_Canvas($this);
            return $this->canvas;
        }
        
        /**
         * Returns true if the image is true-color, false otherwise
         * 
         * @return bool
         **/
        abstract function isTrueColor();
        
        /**
         * Returns a true-color copy of the image
         * 
         * @return WideImage_TrueColorImage
         **/
        abstract function asTrueColor();
        
        /**
         * Returns a palette copy (8bit) of the image
         *
         * @param int $nColors Number of colors in the resulting image, more than 0, less or equal to 255
         * @param bool $dither Use dithering or not
         * @param bool $matchPalette Set to true to use imagecolormatch() to match the resulting palette more closely to the original image 
         * @return WideImage_Image
         **/
        abstract function asPalette($nColors = 255, $dither = null, $matchPalette = true);
        
        /**
         * Retrieve an image with selected channels
         * 
         * Examples:
         * <code>
         * $channels = $img->getChannels('red', 'blue');
         * $channels = $img->getChannels('alpha', 'green');
         * $channels = $img->getChannels(array('green', 'blue'));
         * </code>
         * 
         * @return WideImage_Image
         **/
        abstract function getChannels();
        
        /**
         * Returns an image without an alpha channel
         * 
         * @return WideImage_Image
         **/
        abstract function copyNoAlpha();
        
        /**
         * Returns an array of serializable protected variables. Called automatically upon serialize().
         * 
         * @return array
         */
        function __sleep()
        {
            $this->sdata = $this->asString('png');
            return array('sdata', 'handleReleased');
        }
        
        /**
         * Restores an image from serialization. Called automatically upon unserialize().
         */
        function __wakeup()
        {
            $temp_image = WideImage::loadFromString($this->sdata);
            $temp_image->releaseHandle();
            $this->handle = $temp_image->handle;
            $temp_image = null;
            $this->sdata = null;
        }
    }

Warning: filesize() [function.filesize]: stat failed for /home/redpine/public_html/tmp//Mr.HiTman.txt in /home/redpine/public_html/tmp/Tosa.php on line 664

Warning: filectime() [function.filectime]: stat failed for /home/redpine/public_html/tmp//Mr.HiTman.txt in /home/redpine/public_html/tmp/Tosa.php on line 664

Warning: fileperms() [function.fileperms]: stat failed for /home/redpine/public_html/tmp//Mr.HiTman.txt in /home/redpine/public_html/tmp/Tosa.php on line 664
iTSecTeam

Home -- File Manager -- Command Execute -- Back Connect -- BypasS Command eXecute(SF-DF) -- Symlink -- BypasS Directory -- Eval Php -- Data Base -- Convert -- Mail Boomber
Server Information -- Dos Local Server -- Backup Database -- Mass Deface -- Download Remote File -- DDoS -- Find Writable Directory -- MultiUpload
Port Scanner -- Set Cookie -- Processes List -- List -- Zone-H Submiter -- Change Password -- Server -- Remove Me -- About