RandomImageGenerator.php

Go to the documentation of this file.

<?php

class RandomImageGenerator {

        private $dictionaryFile;
        private $minWidth = 400;
        private $maxWidth = 800;
        private $minHeight = 400;
        private $maxHeight = 800;
        private $shapesToDraw = 5;

        private static $orientations = array(
                array(
                        '0thRow' => 'top',
                        '0thCol' => 'left',
                        'exifCode' => 1,
                        'counterRotation' => array( array( 1, 0 ), array( 0, 1 ) )
                ),
                array(
                        '0thRow' => 'bottom',
                        '0thCol' => 'right',
                        'exifCode' => 3,
                        'counterRotation' => array( array( -1, 0 ), array( 0, -1 ) )
                ),
                array(
                        '0thRow' => 'right',
                        '0thCol' => 'top',
                        'exifCode' => 6,
                        'counterRotation' => array( array( 0, 1 ), array( 1, 0 ) )
                ),
                array(
                        '0thRow' => 'left',
                        '0thCol' => 'bottom',
                        'exifCode' => 8,
                        'counterRotation' => array( array( 0, -1 ), array( -1, 0 ) )
                )
        );


        public function __construct( $options = array() ) {
                foreach ( array( '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 (
                                array(
                                        '/usr/share/dict/words',
                                        '/usr/dict/words',
                                        __DIR__ . '/words.txt'
                                ) as $dictionaryFile
                        ) {
                                if ( is_file( $dictionaryFile ) and 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 = array();
                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 = array();

                $spec['width'] = mt_rand( $this->minWidth, $this->maxWidth );
                $spec['height'] = mt_rand( $this->minHeight, $this->maxHeight );
                $spec['fill'] = $this->getRandomColor();

                $diagonalLength = sqrt( pow( $spec['width'], 2 ) + pow( $spec['height'], 2 ) );

                $draws = array();
                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 = array();
                        $draw['fill'] = $this->getRandomColor();
                        $draw['shape'] = array(
                                array( 'x' => $originX, 'y' => $originY - $radius ),
                                array( 'x' => $originX + $legDeltaX, 'y' => $originY + $legDeltaY ),
                                array( 'x' => $originX - $legDeltaX, 'y' => $originY + $legDeltaY ),
                                array( 'x' => $originX, 'y' => $originY - $radius )
                        );
                        $draws[] = $draw;

                }

                $spec['draws'] = $draws;

                return $spec;
        }

        static function shapePointsToString( $shape ) {
                $points = array();
                foreach ( $shape as $point ) {
                        $points[] = $point['x'] . ',' . $point['y'];
                }
                return join( " ", $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'] ) );
                }

                if ( !$fh = fopen( $filename, 'w' ) ) {
                        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 ) {
                        $cmd = wfEscapeShellArg( $wgExiv2Command )
                                . " -M "
                                . wfEscapeShellArg( "set Exif.Image.Orientation " . $orientation['exifCode'] )
                                . " "
                                . wfEscapeShellArg( $filename );

                        $retval = 0;
                        $err = wfShellExec( $cmd, $retval );
                        if ( $retval !== 0 ) {
                                print "Error with $cmd: $retval, $err\n";
                        }
                }
        }

        private static function rotateImageSpec( &$spec, $matrix ) {
                $tSpec = array();
                $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'] = array();
                foreach ( $spec['draws'] as $draw ) {
                        $tDraw = array(
                                'fill' => $draw['fill'],
                                'shape' => array()
                        );
                        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 array(
                        '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 = array();
                $args[] = "-size " . wfEscapeShellArg( $spec['width'] . 'x' . $spec['height'] );
                $args[] = wfEscapeShellArg( "xc:" . $spec['fill'] );
                foreach ( $spec['draws'] as $draw ) {
                        $fill = $draw['fill'];
                        $polygon = self::shapePointsToString( $draw['shape'] );
                        $drawCommand = "fill $fill  polygon $polygon";
                        $args[] = '-draw ' . wfEscapeShellArg( $drawCommand );
                }
                $args[] = wfEscapeShellArg( $filename );

                $command = wfEscapeShellArg( $wgImageMagickConvertCommand ) . " " . implode( " ", $args );
                $retval = null;
                wfShellExec( $command, $retval );
                return ( $retval === 0 );
        }

        public function getRandomColor() {
                $components = array();
                for ( $i = 0; $i <= 2; $i++ ) {
                        $components[] = mt_rand( 0, 255 );
                }
                return 'rgb(' . join( ', ', $components ) . ')';
        }

        private function getRandomWordPairs( $number ) {
                $lines = $this->getRandomLines( $number * 2 );
                // construct pairs of words
                $pairs = array();
                $count = count( $lines );
                for ( $i = 0; $i < $count; $i += 2 ) {
                        $pairs[] = array( $lines[$i], $lines[$i + 1] );
                }
                return $pairs;
        }

        private function getRandomLines( $number_desired ) {
                $filepath = $this->dictionaryFile;

                // initialize array of lines
                $lines = array();
                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;
        }

}