ILIAS\Filesystem\Util\ImageConversionTest Class Reference

Inheritance diagram for ILIAS\Filesystem\Util\ImageConversionTest:

Collaboration diagram for ILIAS\Filesystem\Util\ImageConversionTest:

Public Member Functions
	testImageThumbnailActualImage ()
	testImageSquareActualImage ()
	testResizeToFitWidth (int $width, int $height, int $final_width, int $final_height)
	testResizeToFitHeight (int $width, int $height, int $final_height, int $final_width)
	testResizeByFixedSize (int $width, int $height, int $final_width, int $final_height, bool $crop)
	testImageOutputOptions (ImageOutputOptions $options, string $expected_mime_type, int $expected_quality)
	testImageOutputOptionSanity ()
	testWrongFormats (string $format)
	testWrongQualities (int $quality)
	testFormatConvert ()
	testFailed ()
	testBackgroundColor (?string $color)
	testAnimatedImageUsesFirstFrame (string $format)
	testAnimatedTransparentImageUsesFirstFrameOnBackground (string $format)
	testAnimatedImageWithSmallerFirstFrameUsesBackground (string $format)
	testWriteImage ()
	testHighDensityPixel ()

Static Public Member Functions
static	getImageSizesByWidth ()
static	getImageSizesByHeight ()
static	getImageSizesByFixed ()
static	getImageOptions ()
static	getWrongFormats ()
static	getWrongQualites ()
static	getColors ()
static	getOutputFormats ()

Protected Member Functions
	setUp ()
	checkImagick ()
	getImageSizeFromStream (FileStream $stream)
	getImageTypeFromStream (FileStream $stream)
	getImageQualityFromStream (FileStream $stream)
	createTestImageStream (int $width, int $height)

Protected Attributes
const	BY_WIDTH_FINAL = 256
const	BY_HEIGHT_FINAL = 756
const	W = 'width'
const	H = 'height'
const	IMAGE_JPEG = 'image/jpeg'
const	IMAGE_PNG = 'image/png'
const	IMAGE_WEBP = 'image/webp'
Images	$images

Private Member Functions
	colorDiff (string $hex_color_one, string $hex_color_two)
	convertAnimatedImage (string $img, string $format)
	assertPixels (\Imagick $image, array $expected)

Detailed Description

Author

Fabian Schmid fabia.nosp@m.n@sr.nosp@m..solu.nosp@m.tion.nosp@m.s

Definition at line 33 of file ImageConversionTest.php.

Member Function Documentation

assertPixels()

ILIAS\Filesystem\Util\ImageConversionTest::assertPixels ( \Imagick  $image, array  $expected  )

private

Parameters

array<string,array<array{0

int|float, 1: int|float}>> $expected colors with positions, a float is relative to the image size, a negative int is counted from the end

Definition at line 509 of file ImageConversionTest.php.

                                                                   : void
    {
        $width = $image->getImageWidth();
        $height = $image->getImageHeight();
        $position = static fn(int|float $p, int $size): int => is_float($p)
            ? (int) ($size * $p)
            : ($p < 0 ? $size + $p : $p);
 
        foreach ($expected as $expected_color => $positions) {
            foreach ($positions as [$x, $y]) {
                $x = $position($x, $width);
                $y = $position($y, $height);
                $pixel = $image->getImagePixelColor($x, $y)->getColor();
                $color = sprintf('#%02x%02x%02x', $pixel['r'], $pixel['g'], $pixel['b']);
                $this->assertLessThan(10, $this->colorDiff($expected_color, $color), "pixel $x/$y is $color");
                $this->assertSame(1, $pixel['a'], "pixel $x/$y is not opaque");
            }
        }
    }

References ILIAS\Repository\int().

Here is the call graph for this function:

checkImagick()

ILIAS\Filesystem\Util\ImageConversionTest::checkImagick ( )

protected

Definition at line 583 of file ImageConversionTest.php.

                                     : void
    {
        if (!class_exists('Imagick')) {
            $this->markTestSkipped('Imagick not installed');
        }
    }

Referenced by ILIAS\Filesystem\Util\ImageConversionTest\setUp().

Here is the caller graph for this function:

colorDiff()

ILIAS\Filesystem\Util\ImageConversionTest::colorDiff ( string  $hex_color_one, string  $hex_color_two  )

private

Definition at line 385 of file ImageConversionTest.php.

                                                                            : int
    {
        preg_match('/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i', $hex_color_one, $rgb_one);
        preg_match('/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i', $hex_color_two, $rgb_two);
 
        return abs(hexdec($rgb_one[1]) - hexdec($rgb_two[1]))
            + abs(hexdec($rgb_one[2]) - hexdec($rgb_two[2]))
            + abs(hexdec($rgb_one[3]) - hexdec($rgb_two[3]));
    }

convertAnimatedImage()

ILIAS\Filesystem\Util\ImageConversionTest::convertAnimatedImage ( string  $img, string  $format  )

private

Definition at line 474 of file ImageConversionTest.php.

                                                                      : \Imagick
    {
        $this->assertFileExists($img);
        $gif = Streams::ofResource(fopen($img, 'rb'));
 
        $converter_options = (new ImageConversionOptions())
            ->withThrowOnError(true)
            ->withFixedDimensions(20, 20)
            ->withCrop(true)
            ->withKeepAspectRatio(true)
            ->withBackgroundColor('#FFFFFF');
 
        $output_options = (new ImageOutputOptions())
            ->withQuality(100)
            ->withFormat($format);
 
        $converter = new ImageConverter($converter_options, $output_options, $gif);
        $this->assertTrue($converter->isOK());
 
        $converted = new \Imagick();
        $converted->readImageBlob((string) $converter->getStream());
        $this->assertSame(1, $converted->getNumberImages());
        $this->assertSame(
            $format === ImageOutputOptions::FORMAT_JPG ? 'JPEG' : strtoupper($format),
            $converted->getImageFormat()
        );
        $this->assertSame($converted->getImageWidth(), $converted->getImageHeight());
 
        return $converted;
    }

createTestImageStream()

ILIAS\Filesystem\Util\ImageConversionTest::createTestImageStream ( int  $width, int  $height  )

protected

Definition at line 613 of file ImageConversionTest.php.

                                                                     : FileStream
    {
        $img = new \Imagick();
        $img->newImage($width, $height, new \ImagickPixel('black'));
        $img->setImageFormat('jpg');
 
        $stream = Streams::ofString($img->getImageBlob());
        $stream->rewind();
        return $stream;
    }

getColors()

static ILIAS\Filesystem\Util\ImageConversionTest::getColors ( )

static

Definition at line 369 of file ImageConversionTest.php.

                                      : \Iterator
    {
        yield [null];
        yield ['#000000'];
        yield ['#ff0000'];
        yield ['#00ff00'];
        yield ['#0000ff'];
        yield ['#ffffff'];
        yield ['#A3BF5A'];
        yield ['#E9745A'];
        yield ['#5A5AE9'];
        yield ['#5AE9E9'];
        yield ['#E95AE9'];
        yield ['#E9E95A'];
    }

getImageOptions()

static ILIAS\Filesystem\Util\ImageConversionTest::getImageOptions ( )

static

Definition at line 233 of file ImageConversionTest.php.

                                            : \Iterator
    {
        $options = new ImageOutputOptions();
        yield [$options, self::IMAGE_JPEG, 75];
        yield [$options->withPngOutput()->withQuality(22), self::IMAGE_PNG, 0];
        yield [$options->withJpgOutput()->withQuality(100), self::IMAGE_JPEG, 100];
        yield [$options->withFormat('png')->withQuality(50), self::IMAGE_PNG, 0];
        yield [$options->withFormat('jpg')->withQuality(87), self::IMAGE_JPEG, 87];
        yield [$options->withQuality(5)->withJpgOutput(), self::IMAGE_JPEG, 5];
        yield [$options->withQuality(10)->withJpgOutput(), self::IMAGE_JPEG, 10];
        yield [$options->withQuality(35)->withJpgOutput(), self::IMAGE_JPEG, 35];
        yield [$options->withQuality(0)->withWebPOutput(), self::IMAGE_WEBP, 0];
        yield [$options->withQuality(100)->withWebPOutput(), self::IMAGE_WEBP, 100];
    }

References ILIAS\UI\Implementation\Component\Input\Field\$options.

getImageQualityFromStream()

ILIAS\Filesystem\Util\ImageConversionTest::getImageQualityFromStream ( FileStream  $stream )

protected

Definition at line 604 of file ImageConversionTest.php.

                                                                    : int
    {
        $stream->rewind();
        $img = new \Imagick();
        $img->readImageBlob((string) $stream);
 
        return $img->getImageCompressionQuality();
    }

getImageSizeFromStream()

ILIAS\Filesystem\Util\ImageConversionTest::getImageSizeFromStream ( FileStream  $stream )

protected

Definition at line 590 of file ImageConversionTest.php.

                                                                 : array
    {
        $getimagesizefromstring = getimagesizefromstring((string) $stream);
        return [
            self::W => (int) round($getimagesizefromstring[0]),
            self::H => (int) round($getimagesizefromstring[1])
        ];
    }

References ILIAS\Repository\int().

Referenced by ILIAS\Filesystem\Util\ImageConversionTest\testImageSquareActualImage().

Here is the call graph for this function:

Here is the caller graph for this function:

getImageSizesByFixed()

static ILIAS\Filesystem\Util\ImageConversionTest::getImageSizesByFixed ( )

static

Definition at line 202 of file ImageConversionTest.php.

                                                 : \Iterator
    {
        yield [1024, 768, 300, 100, true];
        yield [1024, 768, 300, 100, false];
        yield [1024, 768, 100, 300, true];
        yield [1024, 768, 100, 300, false];
        yield [400, 300, 500, 400, true];
        yield [400, 300, 500, 400, false];
    }

getImageSizesByHeight()

static ILIAS\Filesystem\Util\ImageConversionTest::getImageSizesByHeight ( )

static

Definition at line 154 of file ImageConversionTest.php.

                                                  : \Iterator
    {
        yield [400, 300, self::BY_HEIGHT_FINAL, 1008];
        yield [300, 400, self::BY_HEIGHT_FINAL, 567];
        yield [200, 200, self::BY_HEIGHT_FINAL, 756];
        yield [248, 845, self::BY_HEIGHT_FINAL, 221];
    }

getImageSizesByWidth()

static ILIAS\Filesystem\Util\ImageConversionTest::getImageSizesByWidth ( )

static

Definition at line 107 of file ImageConversionTest.php.

                                                 : \Iterator
    {
        yield [400, 300, self::BY_WIDTH_FINAL, 192];
        yield [300, 400, self::BY_WIDTH_FINAL, 341];
        yield [543, 431, self::BY_WIDTH_FINAL, 203];
        yield [200, 200, self::BY_WIDTH_FINAL, 256];
    }

References ILIAS\Filesystem\Util\ImageConversionTest\BY_WIDTH_FINAL.

getImageTypeFromStream()

ILIAS\Filesystem\Util\ImageConversionTest::getImageTypeFromStream ( FileStream  $stream )

protected

Definition at line 599 of file ImageConversionTest.php.

                                                                 : string
    {
        return finfo_buffer(finfo_open(FILEINFO_MIME_TYPE), $stream->read(255));
    }

getOutputFormats()

static ILIAS\Filesystem\Util\ImageConversionTest::getOutputFormats ( )

static

Definition at line 428 of file ImageConversionTest.php.

                                             : \Iterator
    {
        yield [ImageOutputOptions::FORMAT_PNG];
        yield [ImageOutputOptions::FORMAT_JPG];
        yield [ImageOutputOptions::FORMAT_WEBP];
    }

getWrongFormats()

static ILIAS\Filesystem\Util\ImageConversionTest::getWrongFormats ( )

static

Definition at line 294 of file ImageConversionTest.php.

                                            : \Iterator
    {
        yield ['gif'];
        yield ['bmp'];
        yield ['jpg2000'];
    }

getWrongQualites()

static ILIAS\Filesystem\Util\ImageConversionTest::getWrongQualites ( )

static

Definition at line 309 of file ImageConversionTest.php.

                                             : \Iterator
    {
        yield [-1];
        yield [101];
        yield [102];
    }

setUp()

ILIAS\Filesystem\Util\ImageConversionTest::setUp ( )

protected

Definition at line 46 of file ImageConversionTest.php.

                              : void
    {
        $this->checkImagick();
        $this->images = new Images(
            true,
        );
    }

References ILIAS\Filesystem\Util\ImageConversionTest\checkImagick().

Here is the call graph for this function:

testAnimatedImageUsesFirstFrame()

ILIAS\Filesystem\Util\ImageConversionTest::testAnimatedImageUsesFirstFrame

(

string

$format

)

Definition at line 436 of file ImageConversionTest.php.

                                                                   : void
    {
        // three frames of 40x40, optimized: the second and third frame only contain
        // a 10x10 green resp. blue square, the first frame is completely red
        $converted = $this->convertAnimatedImage(__DIR__ . '/img/animated.gif', $format);
 
        $this->assertPixels($converted, [
            '#ff0000' => [[1, 1], [0.5, 0.5], [-2, -2]],
        ]);
    }

testAnimatedImageWithSmallerFirstFrameUsesBackground()

ILIAS\Filesystem\Util\ImageConversionTest::testAnimatedImageWithSmallerFirstFrameUsesBackground

(

string

$format

)

Definition at line 462 of file ImageConversionTest.php.

                                                                                        : void
    {
        // two frames of 40x40: the first one is an opaque red 20x20 square at 10/10, the
        // second one is completely blue. The area not covered by the first frame is empty.
        $converted = $this->convertAnimatedImage(__DIR__ . '/img/animated_offset.gif', $format);
 
        $this->assertPixels($converted, [
            '#ffffff' => [[1, 1], [-2, -2]],
            '#ff0000' => [[0.5, 0.5]],
        ]);
    }

testAnimatedTransparentImageUsesFirstFrameOnBackground()

ILIAS\Filesystem\Util\ImageConversionTest::testAnimatedTransparentImageUsesFirstFrameOnBackground

(

string

$format

)

Definition at line 448 of file ImageConversionTest.php.

                                                                                          : void
    {
        // three frames of 40x40: the first one is transparent with a red square in the
        // center, the second and third one only contain a 10x10 green resp. blue square
        // in the upper left and lower right corner
        $converted = $this->convertAnimatedImage(__DIR__ . '/img/animated_transparent.gif', $format);
 
        $this->assertPixels($converted, [
            '#ffffff' => [[1, 1], [-2, -2]],
            '#ff0000' => [[0.5, 0.5]],
        ]);
    }

testBackgroundColor()

ILIAS\Filesystem\Util\ImageConversionTest::testBackgroundColor

(

?string

$color

)

Definition at line 396 of file ImageConversionTest.php.

                                                       : void
    {
        $transparent_png = __DIR__ . '/img/transparent.png';
        $this->assertFileExists($transparent_png);
        $png = Streams::ofResource(fopen($transparent_png, 'rb'));
 
        $converter_options = (new ImageConversionOptions())
            ->withThrowOnError(true)
            ->withFixedDimensions(100, 100);
 
        if ($color !== null) {
            $converter_options = $converter_options->withBackgroundColor($color);
        } else {
            $color = '#ffffff';
        }
 
        $output_options = (new ImageOutputOptions())
            ->withQuality(100)
            ->withJpgOutput();
 
        $converter = new ImageConverter($converter_options, $output_options, $png);
        $this->assertTrue($converter->isOK());
        $converted_stream = $converter->getStream();
        $gd_image = imagecreatefromstring((string) $converted_stream);
        $colors = imagecolorsforindex($gd_image, imagecolorat($gd_image, 1, 1));
 
        $color_in_converted_picture = sprintf("#%02x%02x%02x", $colors['red'], $colors['green'], $colors['blue']);
        $color_diff = $this->colorDiff($color, $color_in_converted_picture);
 
        $this->assertLessThan(3, $color_diff);
    }

testFailed()

ILIAS\Filesystem\Util\ImageConversionTest::testFailed

(

)

Definition at line 352 of file ImageConversionTest.php.

                                : void
    {
        $false_stream = Streams::ofString('false');
        $images = new Images(
            false,
            false
        );
 
        $resized = $images->resizeToFixedSize(
            $false_stream,
            5,
            5
        );
        $this->assertFalse($resized->isOK());
        $this->assertInstanceOf(\Throwable::class, $resized->getThrowableIfAny());
    }

References ILIAS\Filesystem\Util\Convert\Images\resizeToFixedSize().

Here is the call graph for this function:

testFormatConvert()

ILIAS\Filesystem\Util\ImageConversionTest::testFormatConvert

(

)

Definition at line 324 of file ImageConversionTest.php.

                                       : void
    {
        $jpg = $this->createTestImageStream(10, 10);
        $png = $this->images->convertToFormat(
            $jpg,
            'png'
        );
 
        $this->assertSame(self::IMAGE_PNG, $this->getImageTypeFromStream($png->getStream()));
        $size = $this->getImageSizeFromStream($png->getStream());
        $this->assertEquals(10, $size[self::W]);
        $this->assertEquals(10, $size[self::H]);
 
        // With Dimensions
        $jpg = $this->createTestImageStream(10, 10);
        $png = $this->images->convertToFormat(
            $jpg,
            'png',
            20,
            20
        );
 
        $this->assertSame(self::IMAGE_PNG, $this->getImageTypeFromStream($png->getStream()));
        $size = $this->getImageSizeFromStream($png->getStream());
        $this->assertEquals(20, $size[self::W]);
        $this->assertEquals(20, $size[self::H]);
    }

testHighDensityPixel()

ILIAS\Filesystem\Util\ImageConversionTest::testHighDensityPixel

(

)

Definition at line 554 of file ImageConversionTest.php.

                                          : void
    {
        $file = 'https://upload.wikimedia.org/wikipedia/commons/5/5e/Jan_Vermeer_-_The_Art_of_Painting_-_Google_Art_Project.jpg';
        $curl = curl_init();
        curl_setopt($curl, CURLOPT_URL, $file);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curl, CURLOPT_USERAGENT, 'PHPUnit/1.0');
        $string = curl_exec($curl);
        $curl = null;
 
        $img = Streams::ofString($string);
        $this->assertInstanceOf(FileStream::class, $img);
 
        $converter_options = (new ImageConversionOptions())
            ->withWidth(80)
            ->withHeight(80)
            ->withKeepAspectRatio(true)
            ->withCrop(true)
            ->withThrowOnError(true);
 
        $output_options = (new ImageOutputOptions())
            ->withQuality(60)
            ->withFormat(ImageOutputOptions::FORMAT_PNG);
 
        $converter = new ImageConverter($converter_options, $output_options, $img);
        $this->assertTrue($converter->isOK());
    }

testImageOutputOptions()

ILIAS\Filesystem\Util\ImageConversionTest::testImageOutputOptions	(	ImageOutputOptions	$options,
		string	$expected_mime_type,
		int	$expected_quality
	)

Definition at line 250 of file ImageConversionTest.php.

     : void {
        $resized = $this->images->resizeToFixedSize(
            $this->createTestImageStream(10, 10),
            5,
            5,
            true,
            $options
        );
 
        $this->assertSame($expected_mime_type, $this->getImageTypeFromStream($resized->getStream()));
        $this->assertSame($expected_quality, $this->getImageQualityFromStream($resized->getStream()));
    }

testImageOutputOptionSanity()

ILIAS\Filesystem\Util\ImageConversionTest::testImageOutputOptionSanity

(

)

Definition at line 267 of file ImageConversionTest.php.

                                                 : void
    {
        $options = new ImageOutputOptions();
 
        // Defaults
        $this->assertSame('jpg', $options->getFormat());
        $this->assertSame(75, $options->getQuality());
 
        $png = $options->withPngOutput();
        $this->assertSame('png', $png->getFormat());
        $this->assertSame('jpg', $options->getFormat()); // original options should not change
        $png_explicit = $options->withFormat('png');
        $this->assertSame('png', $png_explicit->getFormat());
 
        $jpg = $options->withJpgOutput();
        $this->assertSame('jpg', $jpg->getFormat());
        $jpg_explicit = $options->withFormat('jpg');
        $this->assertSame('jpg', $jpg_explicit->getFormat());
        $jpeg = $options->withFormat('jpeg');
        $this->assertSame('jpg', $jpeg->getFormat());
 
        // Quality
        $low = $options->withQuality(5);
        $this->assertSame(5, $low->getQuality());
        $this->assertSame(75, $options->getQuality()); // original options should not change
    }

References ILIAS\UI\Implementation\Component\Input\Field\$options.

testImageSquareActualImage()

ILIAS\Filesystem\Util\ImageConversionTest::testImageSquareActualImage

(

)

Definition at line 81 of file ImageConversionTest.php.

                                                : void
    {
        $img = __DIR__ . '/img/robot.jpg';
        $this->assertFileExists($img);
        $getimagesize = getimagesize($img);
        $original_width = $getimagesize[0]; // should be 600
        $original_height = $getimagesize[1]; // should be 800
        $this->assertSame(600, $original_width);
        $this->assertSame(800, $original_height);
 
        // make tumbnail
        $original_stream = Streams::ofResource(fopen($img, 'rb'));
 
        $thumbnail_converter = $this->images->croppedSquare(
            $original_stream,
            200
        );
        $this->assertTrue($thumbnail_converter->isOK());
        $this->assertNotInstanceOf(\Throwable::class, $thumbnail_converter->getThrowableIfAny());
 
        $getimagesizefromstring = $this->getImageSizeFromStream($thumbnail_converter->getStream());
 
        $this->assertEquals(200, $getimagesizefromstring[self::W]);
        $this->assertEquals(200, $getimagesizefromstring[self::H]);
    }

References ILIAS\Filesystem\Util\ImageConversionTest\getImageSizeFromStream(), and ILIAS\Filesystem\Stream\Streams\ofResource().

Here is the call graph for this function:

testImageThumbnailActualImage()

ILIAS\Filesystem\Util\ImageConversionTest::testImageThumbnailActualImage

(

)

Definition at line 54 of file ImageConversionTest.php.

                                                   : void
    {
        $img = __DIR__ . '/img/robot.jpg';
        $this->assertFileExists($img);
        $getimagesize = getimagesize($img);
        $original_width = $getimagesize[0]; // should be 600
        $original_height = $getimagesize[1]; // should be 800
        $this->assertSame(600, $original_width);
        $this->assertSame(800, $original_height);
 
        // make tumbnail
        $original_stream = Streams::ofResource(fopen($img, 'rb'));
 
        $thumbnail_converter = $this->images->thumbnail(
            $original_stream,
            100
        );
        $this->assertTrue($thumbnail_converter->isOK());
        $this->assertNotInstanceOf(\Throwable::class, $thumbnail_converter->getThrowableIfAny());
        $converted_stream = $thumbnail_converter->getStream();
 
        $getimagesizefromstring = getimagesizefromstring((string) $converted_stream);
 
        $this->assertSame(75, $getimagesizefromstring[0]); // width
        $this->assertSame(100, $getimagesizefromstring[1]); // height
    }

References ILIAS\Filesystem\Stream\Streams\ofResource().

Here is the call graph for this function:

testResizeByFixedSize()

ILIAS\Filesystem\Util\ImageConversionTest::testResizeByFixedSize	(	int	$width,
		int	$height,
		int	$final_width,
		int	$final_height,
		bool	$crop
	)

Definition at line 213 of file ImageConversionTest.php.

     : void {
        $stream = $this->createTestImageStream($width, $height);
        $dimensions = $this->getImageSizeFromStream($stream);
        $this->assertEquals($width, $dimensions[self::W]);
        $this->assertEquals($height, $dimensions[self::H]);
 
        $by_fixed = $this->images->resizeToFixedSize($stream, $final_width, $final_height, $crop);
        $this->assertTrue($by_fixed->isOK());
        $new_dimensions = $this->getImageSizeFromStream($by_fixed->getStream());
 
        $this->assertEquals($final_width, $new_dimensions[self::W]);
        $this->assertEquals($final_height, $new_dimensions[self::H]);
    }

testResizeToFitHeight()

ILIAS\Filesystem\Util\ImageConversionTest::testResizeToFitHeight	(	int	$width,
		int	$height,
		int	$final_height,
		int	$final_width
	)

Definition at line 164 of file ImageConversionTest.php.

     : void {
        $stream = $this->createTestImageStream($width, $height);
        $dimensions = $this->getImageSizeFromStream($stream);
        $this->assertEquals($width, $dimensions[self::W]);
        $this->assertEquals($height, $dimensions[self::H]);
 
        // resize to fit
        $resized = $this->images->resizeByHeight($stream, self::BY_HEIGHT_FINAL);
        $this->assertTrue($resized->isOK());
        $new_dimensions = $this->getImageSizeFromStream($resized->getStream());
 
        $this->assertEquals($final_width, $new_dimensions[self::W]);
        $this->assertEquals($final_height, $new_dimensions[self::H]);
 
        // check aspect ratio
        $this->assertSame(
            round($width > $height),
            round($final_width > $final_height)
        );
        $this->assertSame(
            round($width / $height),
            round($new_dimensions[self::W] / $new_dimensions[self::H])
        );
        $this->assertSame(
            $width > $height,
            $width > $height
        );
        $this->assertSame(
            $width > $height,
            $new_dimensions[self::W] > $new_dimensions[self::H]
        );
    }

testResizeToFitWidth()

ILIAS\Filesystem\Util\ImageConversionTest::testResizeToFitWidth	(	int	$width,
		int	$height,
		int	$final_width,
		int	$final_height
	)

Definition at line 116 of file ImageConversionTest.php.

     : void {
        $stream = $this->createTestImageStream($width, $height);
        $dimensions = $this->getImageSizeFromStream($stream);
        $this->assertEquals($width, $dimensions[self::W]);
        $this->assertEquals($height, $dimensions[self::H]);
 
        // resize to fit width
        $resized = $this->images->resizeByWidth($stream, self::BY_WIDTH_FINAL);
        $this->assertTrue($resized->isOK());
        $new_dimensions = $this->getImageSizeFromStream($resized->getStream());
 
        $this->assertEquals($final_width, $new_dimensions[self::W]);
        $this->assertEquals($final_height, $new_dimensions[self::H]);
 
        // check aspect ratio
        $this->assertSame(
            round($width > $height),
            round($final_width > $final_height)
        );
        $this->assertSame(
            round($width / $height),
            round($new_dimensions[self::W] / $new_dimensions[self::H])
        );
        $this->assertSame(
            $width > $height,
            $width > $height
        );
        $this->assertSame(
            $width > $height,
            $new_dimensions[self::W] > $new_dimensions[self::H]
        );
    }

testWriteImage()

ILIAS\Filesystem\Util\ImageConversionTest::testWriteImage

(

)

Definition at line 529 of file ImageConversionTest.php.

                                    : void
    {
        $img = $this->createTestImageStream(10, 10);
 
        $output_path = __DIR__ . '/img/output.jpg';
        $converter_options = (new ImageConversionOptions())
            ->withThrowOnError(true)
            ->withMakeTemporaryFiles(false)
            ->withFixedDimensions(100, 100)
            ->withOutputPath($output_path);
 
        $output_options = (new ImageOutputOptions())
            ->withQuality(10)
            ->withJpgOutput();
 
        $converter = new ImageConverter($converter_options, $output_options, $img);
        $this->assertTrue($converter->isOK());
 
        $this->assertFileExists($output_path);
        $stream = $converter->getStream();
        $this->assertEquals($output_path, $stream->getMetadata('uri'));
 
        unlink($output_path);
    }

testWrongFormats()

ILIAS\Filesystem\Util\ImageConversionTest::testWrongFormats

(

string

$format

)

Definition at line 302 of file ImageConversionTest.php.

                                                    : void
    {
        $options = new ImageOutputOptions();
        $this->expectException(\InvalidArgumentException::class);
        $wrong = $options->withFormat($format);
    }

References ILIAS\UI\Implementation\Component\Input\Field\$options.

testWrongQualities()

ILIAS\Filesystem\Util\ImageConversionTest::testWrongQualities

(

int

$quality

)

Definition at line 317 of file ImageConversionTest.php.

                                                    : void
    {
        $options = new ImageOutputOptions();
        $this->expectException(\InvalidArgumentException::class);
        $wrong = $options->withQuality($quality);
    }

References ILIAS\UI\Implementation\Component\Input\Field\$options.

Field Documentation

$images

Images ILIAS\Filesystem\Util\ImageConversionTest::$images

protected

Definition at line 44 of file ImageConversionTest.php.

BY_HEIGHT_FINAL

const ILIAS\Filesystem\Util\ImageConversionTest::BY_HEIGHT_FINAL = 756

protected

Definition at line 38 of file ImageConversionTest.php.

BY_WIDTH_FINAL

const ILIAS\Filesystem\Util\ImageConversionTest::BY_WIDTH_FINAL = 256

protected

Definition at line 37 of file ImageConversionTest.php.

Referenced by ILIAS\Filesystem\Util\ImageConversionTest\getImageSizesByWidth().

H

const ILIAS\Filesystem\Util\ImageConversionTest::H = 'height'

protected

Definition at line 40 of file ImageConversionTest.php.

IMAGE_JPEG

const ILIAS\Filesystem\Util\ImageConversionTest::IMAGE_JPEG = 'image/jpeg'

protected

Definition at line 41 of file ImageConversionTest.php.

IMAGE_PNG

const ILIAS\Filesystem\Util\ImageConversionTest::IMAGE_PNG = 'image/png'

protected

Definition at line 42 of file ImageConversionTest.php.

IMAGE_WEBP

const ILIAS\Filesystem\Util\ImageConversionTest::IMAGE_WEBP = 'image/webp'

protected

Definition at line 43 of file ImageConversionTest.php.

W

const ILIAS\Filesystem\Util\ImageConversionTest::W = 'width'

protected

Definition at line 39 of file ImageConversionTest.php.

---

The documentation for this class was generated from the following file:

• components/ILIAS/Filesystem/tests/Util/Convert/ImageConversionTest.php