webshell

Ghost Exploiter Team Official

Directory >> /home/softsuitetech/public_html/DEMO/dasphene/vendor/mike42/gfx-php/src/Mike42/GfxPhp/

File / Folder	Size	Action
.	-
Codec	--	ren
Util	--	ren
.htaccess	0.27KB	edt ren
AbstractRasterImage.php	3.304KB	edt ren
BlackAndWhiteRasterImag...	4.74KB	edt ren
GrayscaleRasterImage.php	3.96KB	edt ren
Image.php	2.252KB	edt ren
IndexedRasterImage.php	9.313KB	edt ren
PaletteGenerator.php	1.13KB	edt ren
RasterImage.php	2.994KB	edt ren
RgbRasterImage.php	5.296KB	edt ren

<?php
namespace Mike42\GfxPhp;

class RgbRasterImage extends AbstractRasterImage
{
    protected $width;

protected $height;

protected $data;

protected $maxVal;

public function getWidth() : int
    {
        return $this -> width;
    }

public function getHeight() : int
    {
        return $this -> height;
    }

public function getRasterData(): string
    {
        if ($this -> maxVal > 255) {
            return pack("n*", ... $this -> data);
        }
        return pack("C*", ... $this -> data);
    }

public function getMaxVal()
    {
        return $this -> maxVal;
    }

public function getPixel(int $x, int $y) : int
    {
        if ($x < 0 || $x >= $this -> width) {
            return 0;
        }
        if ($y < 0 || $y >= $this -> height) {
            return 0;
        }
        $byte = ($y * $this -> width + $x) * 3;
        return self::rgbToInt($this -> data[$byte], $this -> data[$byte + 1], $this -> data[$byte + 2], $this -> maxVal);
    }

public function indexToRgb(int $val)
    {
        return self::intToRgb($val);
    }
    
    public function rgbToIndex(array $val)
    {
        return self::rgbToInt($val[0], $val[1], $val[2]);
    }
    
    public static function rgbToInt(int $r, int $g, int $b)
    {
        return ($r << 16) | ($g << 8) | $b;
    }

public static function intToRgb($in)
    {
        return [
            ($in >> 16) & 0xFF,
            ($in >> 8) & 0xFF,
            ($in) & 0xFF
        ];
    }

public function setPixel(int $x, int $y, int $value)
    {
        if ($x < 0 || $x >= $this -> width) {
            return;
        }
        if ($y < 0 || $y >= $this -> height) {
            return;
        }
        $rgb = self::intToRgb($value);
        for ($i = 0; $i < 3; $i++) {
            $value = $rgb[$i] & 0xFF;
            $byte = ($y * $this -> width + $x) * 3;
            $this -> data[$byte + $i] = $value;
        }
    }

public function mapColor(int $srcColor, RasterImage $destImage)
    {
        if ($destImage instanceof RgbRasterImage) {
            return $srcColor;
        }
        throw new \Exception("Cannot map colors");
    }

protected function __construct($width, $height, array $data, int $maxVal)
    {
        $this -> width = $width;
        $this -> height = $height;
        $this -> data = $data;
        $this -> maxVal = $maxVal;
    }

public static function create($width, $height, array $data = null, $maxVal = 255) : RgbRasterImage
    {
        $expectedBytes = $width * $height * 3;
        if ($data === null) {
            $data = array_values(array_fill(0, $expectedBytes, $maxVal));
        }
        if ($maxVal > 255) {
            array_walk($data, array('self', 'convertDepth'), [$maxVal, 255]);
            $maxVal = 255;
        }
        return new RgbRasterImage($width, $height, $data, $maxVal);
    }

public static function convertDepth(&$item, $key, array $data)
    {
        $maxVal = $data[0];
        $newMaxVal = $data[1];
        $item = intdiv($item * $newMaxVal, $maxVal);
    }

public function toRgb() : RgbRasterImage
    {
        return clone $this;
    }

public function toGrayscale() : GrayscaleRasterImage
    {
        $img = GrayscaleRasterImage::create($this -> width, $this -> height);
        for ($y = 0; $y < $this -> height; $y++) {
            for ($x = 0; $x < $this -> width; $x++) {
                $original = $this -> intToRgb($this -> getPixel($x, $y));
                $lightness = intdiv($original[0] + $original[1] + $original[2], 3);
                $img -> setPixel($x, $y, $lightness);
            }
        }
        return $img;
    }

public function toBlackAndWhite() : BlackAndWhiteRasterImage
    {
        $img = BlackAndWhiteRasterImage::create($this -> width, $this -> height);
        for ($y = 0; $y < $this -> height; $y++) {
            for ($x = 0; $x < $this -> width; $x++) {
                $original = $this -> intToRgb($this -> getPixel($x, $y));
                $lightness = intdiv($original[0] + $original[1] + $original[2], 3);
                $img -> setPixel($x, $y, $lightness > 128 ? 0 : 1);
            }
        }
        return $img;
    }

public function toIndexed(): IndexedRasterImage
    {
        // NB: It might be possible to speed this up with array_fill_keys and array_replace.
        // Each pixel as a numeric value
        $pixels = array_map([$this, "rgbToIndex"], array_chunk($this -> data, 3, false));
        // List of unique colors
        $colorValues = array_values(array_unique($pixels, SORT_NUMERIC));
        $paletteSize = count($colorValues);
        // Use 24-bit color number as key, palette index as value
        $lookup = array_flip($colorValues);
        // Replace palette values w/ expanded [r, g, b] values for use in IndexedRasterImage
        for ($i = 0; $i < $paletteSize; $i++) {
            $colorValues[$i] = $this -> intToRgb($colorValues[$i]);
        }
        // Replace pixel values with color ID's
        $imageSize = count($pixels);
        for ($i = 0; $i < $imageSize; $i++) {
            $pixels[$i] = $lookup[$pixels[$i]];
        }
        // Max value round-off to 256 colors if possible, otherwise leave unlimited
        $maxVal = $paletteSize > 256 ? 16777215 : 255;
        return IndexedRasterImage::create($this -> width, $this -> height, $pixels, $colorValues, $maxVal);
    }
}

<=Back