RandomImageGenerator.php

Go to the documentation of this file.

<?php
use MediaWiki\Shell\Shell;
 
class RandomImageGenerator {
    private $dictionaryFile;
    private $minWidth = 400;
    private $maxWidth = 800;
    private $minHeight = 400;
    private $maxHeight = 800;
    private $shapesToDraw = 5;
 
    private static $orientations = [
        [
            '0thRow' => 'top',
            '0thCol' => 'left',
            'exifCode' => 1,
            'counterRotation' => [ [ 1, 0 ], [ 0, 1 ] ]
        ],
        [
            '0thRow' => 'bottom',
            '0thCol' => 'right',
            'exifCode' => 3,
            'counterRotation' => [ [ -1, 0 ], [ 0, -1 ] ]
        ],
        [
            '0thRow' => 'right',
            '0thCol' => 'top',
            'exifCode' => 6,
            'counterRotation' => [ [ 0, 1 ], [ 1, 0 ] ]
        ],
        [
            '0thRow' => 'left',
            '0thCol' => 'bottom',
            'exifCode' => 8,
            'counterRotation' => [ [ 0, -1 ], [ -1, 0 ] ]
        ]
    ];
 
    public function __construct( $options = [] ) {
        foreach ( [ 'dictionaryFile', 'minWidth', 'minHeight',
            'maxWidth', 'maxHeight', 'shapesToDraw' ] as $property
        ) {
            if ( isset( $options[$property] ) ) {
                $this->$property = $options[$property];
            }
        }
 
        // find the dictionary file, to generate random names
        if ( !isset( $this->dictionaryFile ) ) {
            foreach (
                [
                    '/usr/share/dict/words',
                    '/usr/dict/words',
                    __DIR__ . '/words.txt'
                ] as $dictionaryFile
            ) {
                if ( is_file( $dictionaryFile ) && is_readable( $dictionaryFile ) ) {
                    $this->dictionaryFile = $dictionaryFile;
                    break;
                }
            }
        }
        if ( !isset( $this->dictionaryFile ) ) {
            throw new Exception( "RandomImageGenerator: dictionary file not "
                . "found or not specified properly" );
        }
    }
 
    function writeImages( $number, $format = 'jpg', $dir = null ) {
        $filenames = $this->getRandomFilenames( $number, $format, $dir );
        $imageWriteMethod = $this->getImageWriteMethod( $format );
        foreach ( $filenames as $filename ) {
            $this->{$imageWriteMethod}( $this->getImageSpec(), $format, $filename );
        }
 
        return $filenames;
    }
 
    function getImageWriteMethod( $format ) {
        global $wgUseImageMagick, $wgImageMagickConvertCommand;
        if ( $format === 'svg' ) {
            return 'writeSvg';
        } else {
            // figure out how to write images
            global $wgExiv2Command;
            if ( class_exists( 'Imagick' ) && $wgExiv2Command && is_executable( $wgExiv2Command ) ) {
                return 'writeImageWithApi';
            } elseif ( $wgUseImageMagick
                && $wgImageMagickConvertCommand
                && is_executable( $wgImageMagickConvertCommand )
            ) {
                return 'writeImageWithCommandLine';
            }
        }
        throw new Exception( "RandomImageGenerator: could not find a suitable "
            . "method to write images in '$format' format" );
    }
 
    private function getRandomFilenames( $number, $extension = 'jpg', $dir = null ) {
        if ( is_null( $dir ) ) {
            $dir = getcwd();
        }
        $filenames = [];
        foreach ( $this->getRandomWordPairs( $number ) as $pair ) {
            $basename = $pair[0] . '_' . $pair[1];
            if ( !is_null( $extension ) ) {
                $basename .= '.' . $extension;
            }
            $basename = preg_replace( '/\s+/', '', $basename );
            $filenames[] = "$dir/$basename";
        }
 
        return $filenames;
    }
 
    public function getImageSpec() {
        $spec = [];
 
        $spec['width'] = mt_rand( $this->minWidth, $this->maxWidth );
        $spec['height'] = mt_rand( $this->minHeight, $this->maxHeight );
        $spec['fill'] = $this->getRandomColor();
 
        $diagonalLength = sqrt( $spec['width'] ** 2 + $spec['height'] ** 2 );
 
        $draws = [];
        for ( $i = 0; $i <= $this->shapesToDraw; $i++ ) {
            $radius = mt_rand( 0, $diagonalLength / 4 );
            if ( $radius == 0 ) {
                continue;
            }
            $originX = mt_rand( -1 * $radius, $spec['width'] + $radius );
            $originY = mt_rand( -1 * $radius, $spec['height'] + $radius );
            $angle = mt_rand( 0, ( 3.141592 / 2 ) * $radius ) / $radius;
            $legDeltaX = round( $radius * sin( $angle ) );
            $legDeltaY = round( $radius * cos( $angle ) );
 
            $draw = [];
            $draw['fill'] = $this->getRandomColor();
            $draw['shape'] = [
                [ 'x' => $originX, 'y' => $originY - $radius ],
                [ 'x' => $originX + $legDeltaX, 'y' => $originY + $legDeltaY ],
                [ 'x' => $originX - $legDeltaX, 'y' => $originY + $legDeltaY ],
                [ 'x' => $originX, 'y' => $originY - $radius ]
            ];
            $draws[] = $draw;
        }
 
        $spec['draws'] = $draws;
 
        return $spec;
    }
 
    static function shapePointsToString( $shape ) {
        $points = [];
        foreach ( $shape as $point ) {
            $points[] = $point['x'] . ',' . $point['y'];
        }
 
        return implode( " ", $points );
    }
 
    public function writeSvg( $spec, $format, $filename ) {
        $svg = new SimpleXmlElement( '<svg/>' );
        $svg->addAttribute( 'xmlns', 'http://www.w3.org/2000/svg' );
        $svg->addAttribute( 'version', '1.1' );
        $svg->addAttribute( 'width', $spec['width'] );
        $svg->addAttribute( 'height', $spec['height'] );
        $g = $svg->addChild( 'g' );
        foreach ( $spec['draws'] as $drawSpec ) {
            $shape = $g->addChild( 'polygon' );
            $shape->addAttribute( 'fill', $drawSpec['fill'] );
            $shape->addAttribute( 'points', self::shapePointsToString( $drawSpec['shape'] ) );
        }
 
        $fh = fopen( $filename, 'w' );
        if ( !$fh ) {
            throw new Exception( "couldn't open $filename for writing" );
        }
        fwrite( $fh, $svg->asXML() );
        if ( !fclose( $fh ) ) {
            throw new Exception( "couldn't close $filename" );
        }
    }
 
    public function writeImageWithApi( $spec, $format, $filename ) {
        // this is a hack because I can't get setImageOrientation() to work. See below.
        global $wgExiv2Command;
 
        $image = new Imagick();
        $orientation = self::$orientations[0]; // default is normal orientation
        if ( $format == 'jpg' ) {
            $orientation = self::$orientations[array_rand( self::$orientations )];
            $spec = self::rotateImageSpec( $spec, $orientation['counterRotation'] );
        }
 
        $image->newImage( $spec['width'], $spec['height'], new ImagickPixel( $spec['fill'] ) );
 
        foreach ( $spec['draws'] as $drawSpec ) {
            $draw = new ImagickDraw();
            $draw->setFillColor( $drawSpec['fill'] );
            $draw->polygon( $drawSpec['shape'] );
            $image->drawImage( $draw );
        }
 
        $image->setImageFormat( $format );
 
        // this doesn't work, even though it's documented to do so...
        // $image->setImageOrientation( $orientation['exifCode'] );
 
        $image->writeImage( $filename );
 
        // because the above setImageOrientation call doesn't work... nor can I
        // get an external imagemagick binary to do this either... Hacking this
        // for now (only works if you have exiv2 installed, a program to read
        // and manipulate exif).
        if ( $wgExiv2Command ) {
            $command = Shell::command( $wgExiv2Command,
                '-M',
                "set Exif.Image.Orientation {$orientation['exifCode']}",
                $filename
            )->includeStderr();
 
            $result = $command->execute();
            $retval = $result->getExitCode();
            if ( $retval !== 0 ) {
                print "Error with $command: $retval, {$result->getStdout()}\n";
            }
        }
    }
 
    private static function rotateImageSpec( &$spec, $matrix ) {
        $tSpec = [];
        $dims = self::matrixMultiply2x2( $matrix, $spec['width'], $spec['height'] );
        $correctionX = 0;
        $correctionY = 0;
        if ( $dims['x'] < 0 ) {
            $correctionX = abs( $dims['x'] );
        }
        if ( $dims['y'] < 0 ) {
            $correctionY = abs( $dims['y'] );
        }
        $tSpec['width'] = abs( $dims['x'] );
        $tSpec['height'] = abs( $dims['y'] );
        $tSpec['fill'] = $spec['fill'];
        $tSpec['draws'] = [];
        foreach ( $spec['draws'] as $draw ) {
            $tDraw = [
                'fill' => $draw['fill'],
                'shape' => []
            ];
            foreach ( $draw['shape'] as $point ) {
                $tPoint = self::matrixMultiply2x2( $matrix, $point['x'], $point['y'] );
                $tPoint['x'] += $correctionX;
                $tPoint['y'] += $correctionY;
                $tDraw['shape'][] = $tPoint;
            }
            $tSpec['draws'][] = $tDraw;
        }
 
        return $tSpec;
    }
 
    private static function matrixMultiply2x2( $matrix, $x, $y ) {
        return [
            'x' => $x * $matrix[0][0] + $y * $matrix[0][1],
            'y' => $x * $matrix[1][0] + $y * $matrix[1][1]
        ];
    }
 
    public function writeImageWithCommandLine( $spec, $format, $filename ) {
        global $wgImageMagickConvertCommand;
 
        $args = [
            $wgImageMagickConvertCommand,
            '-size',
            $spec['width'] . 'x' . $spec['height'],
            "xc:{$spec['fill']}",
        ];
        foreach ( $spec['draws'] as $draw ) {
            $fill = $draw['fill'];
            $polygon = self::shapePointsToString( $draw['shape'] );
            $drawCommand = "fill $fill  polygon $polygon";
            $args[] = '-draw';
            $args[] = $drawCommand;
        }
        $args[] = $filename;
 
        $result = Shell::command( $args )->execute();
 
        return ( $result->getExitCode() === 0 );
    }
 
    public function getRandomColor() {
        $components = [];
        for ( $i = 0; $i <= 2; $i++ ) {
            $components[] = mt_rand( 0, 255 );
        }
 
        return 'rgb(' . implode( ', ', $components ) . ')';
    }
 
    private function getRandomWordPairs( $number ) {
        $lines = $this->getRandomLines( $number * 2 );
        // construct pairs of words
        $pairs = [];
        $count = count( $lines );
        for ( $i = 0; $i < $count; $i += 2 ) {
            $pairs[] = [ $lines[$i], $lines[$i + 1] ];
        }
 
        return $pairs;
    }
 
    private function getRandomLines( $number_desired ) {
        $filepath = $this->dictionaryFile;
 
        // initialize array of lines
        $lines = [];
        for ( $i = 0; $i < $number_desired; $i++ ) {
            $lines[] = null;
        }
 
        /*
         * This algorithm obtains N random lines from a file in one single pass.
         * It does this by replacing elements of a fixed-size array of lines,
         * less and less frequently as it reads the file.
         */
        $fh = fopen( $filepath, "r" );
        if ( !$fh ) {
            throw new Exception( "couldn't open $filepath" );
        }
        $line_number = 0;
        $max_index = $number_desired - 1;
        while ( !feof( $fh ) ) {
            $line = fgets( $fh );
            if ( $line !== false ) {
                $line_number++;
                $line = trim( $line );
                if ( mt_rand( 0, $line_number ) <= $max_index ) {
                    $lines[mt_rand( 0, $max_index )] = $line;
                }
            }
        }
        fclose( $fh );
        if ( $line_number < $number_desired ) {
            throw new Exception( "not enough lines in $filepath" );
        }
 
        return $lines;
    }
}