Changeset 115922 in spip-zone


Ignore:
Timestamp:
Jul 11, 2019, 11:08:20 AM (9 days ago)
Author:
cedric@…
Message:

Optimization de la rapidite de geometrize

Location:
_plugins_/adaptive_images/trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/adaptive_images/trunk/adaptive_images_options.php

    r115861 r115922  
    115115        //$AdaptiveImages->thumbnailGeneratorCallback = "adaptive_images_preview_potrace";
    116116        // Experimental : generer des thumbnails svg a base de Geometrize PHP
    117         //$AdaptiveImages->thumbnailGeneratorCallback = "adaptive_images_preview_geometrize";
     117        $AdaptiveImages->thumbnailGeneratorCallback = "adaptive_images_preview_geometrize";
    118118}
    119119
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/Core.class.php

    r115850 r115922  
    2525                $f = 65535/$alpha;
    2626                $a = intval($f);
    27                 {
    28                         $_g = 0;
    29                         while ($_g<$lines->length){
    30                                 $line = $lines[$_g];
    31                                 $_g = $_g+1;
    32                                 $y = $line->y;
    33                                 {
    34                                         $_g2 = $line->x1;
    35                                         $_g1 = $line->x2+1;
    36                                         while ($_g2<$_g1){
    37                                                 $_g2 = $_g2+1;
    38                                                 $x = $_g2-1;
    39                                                 $t = $target->data[$target->width*$y+$x];
    40                                                 $c = $current->data[$current->width*$y+$x];
    41                                                 $totalRed = $totalRed+((($t >> 24 & 255)-($c >> 24 & 255))*$a+($c >> 24 & 255)*257);
    42                                                 $totalGreen = $totalGreen+((($t >> 16 & 255)-($c >> 16 & 255))*$a+($c >> 16 & 255)*257);
    43                                                 $totalBlue = $totalBlue+((($t >> 8 & 255)-($c >> 8 & 255))*$a+($c >> 8 & 255)*257);
    44                                                 $count = $count+1;
    45                                                 unset($x, $t, $c);
    46                                         }
    47                                         unset($_g2, $_g1);
    48                                 }
    49                                 unset($y, $line);
    50                         }
    51                 }
     27
     28                foreach($lines as $line){
     29                        $y = $line->y;
     30                        for ($x=$line->x1; $x<=$line->x2; $x++) {
     31                                $t = $target->data[$target->width*$y+$x];
     32                                $c = $current->data[$current->width*$y+$x];
     33                                $totalRed = $totalRed+((($t >> 24 & 255)-($c >> 24 & 255))*$a+($c >> 24 & 255)*257);
     34                                $totalGreen = $totalGreen+((($t >> 16 & 255)-($c >> 16 & 255))*$a+($c >> 16 & 255)*257);
     35                                $totalBlue = $totalBlue+((($t >> 8 & 255)-($c >> 8 & 255))*$a+($c >> 8 & 255)*257);
     36                                $count++;
     37                        }
     38                }
     39
    5240                if ($count===0){
    5341                        return 0;
     
    204192
    205193                $total = $score;
    206                 for ($i = 0; $i<$lines->length; $i++){
    207                         $line = &$lines[$i];
     194                foreach ($lines as &$line) {
    208195                        $o1 = $target->width*$line->y;
    209196                        $o2 = $before->width*$line->y;
     
    237224                }
    238225
    239                 for ($i = 0; $i<$lines->length; $i++){
    240                         $line = &$lines[$i];
     226                foreach ($lines as &$line) {
    241227                        $o1 = $target->width*$line->y;
    242228                        $o3 = $after->width*$line->y;
     
    337323                        $shape->color = geometrize_Core::computeColor($target, $current, $lines, $alpha);
    338324                }
    339                 // copyLines only if opacity!=1 (speed issue with no opacity in shapes)
     325                // copyLines only if opacity!=1 (speed issue with no transparency in shapes)
    340326                if ($shape->color & 255!==255){
    341327                        geometrize_rasterizer_Rasterizer::copyLines($buffer, $current, $lines);
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/Model.class.php

    r115850 r115922  
    1111
    1212        public function __construct($target, $backgroundColor){
    13                 if (!php_Boot::$skip_constructor){
    14                         if (!($target!==null)){
    15                                 throw new HException("FAIL: target != null");
    16                         }
    17                         $this->width = $target->width;
    18                         $this->height = $target->height;
    19                         $this->target = $target;
    20                         $w = $target->width;
    21                         $h = $target->height;
    22                         $bitmap = new geometrize_bitmap_Bitmap();
    23                         $bitmap->width = $w;
    24                         $bitmap->height = $h;
    25                         $this1 = (new _hx_array(array()));
    26                         $this1->length = $w*$h;
    27                         $bitmap->data = $this1;
    28                         $i = 0;
    29                         while ($i<$bitmap->data->length){
    30                                 $bitmap->data[$i] = $backgroundColor;
    31                                 $i = $i+1;
    32                         }
    33                         $this->current = $bitmap;
    34                         $w1 = $target->width;
    35                         $h1 = $target->height;
    36                         $bitmap1 = new geometrize_bitmap_Bitmap();
    37                         $bitmap1->width = $w1;
    38                         $bitmap1->height = $h1;
    39                         $this2 = (new _hx_array(array()));
    40                         $this2->length = $w1*$h1;
    41                         $bitmap1->data = $this2;
    42                         $i1 = 0;
    43                         while ($i1<$bitmap1->data->length){
    44                                 $bitmap1->data[$i1] = $backgroundColor;
    45                                 $i1 = $i1+1;
    46                         }
    47                         $this->buffer = $bitmap1;
    48                         $this->score = geometrize_Core::differenceFull($target, $this->current);
     13                if (!($target!==null)){
     14                        throw new HException("FAIL: target != null");
    4915                }
     16                $this->width = $target->width;
     17                $this->height = $target->height;
     18                $this->target = $target;
     19                $this->current = geometrize_bitmap_Bitmap::create($this->width,$this->height,$backgroundColor);
     20                $this->score = geometrize_Core::differenceFull($target, $this->current);
     21
     22                $this->buffer = $this->current->hclone();
    5023        }
    5124
    5225        public function step($shapeTypes, $alpha, $n, $age){
    5326                $state = geometrize_Core::bestHillClimbState($shapeTypes, $alpha, $n, $age, $this->target, $this->current, $this->buffer, $this->score);
    54                 $results = (new _hx_array(array($this->addShape($state->shape, $state->alpha))));
     27                $results = [$this->addShape($state->shape, $state->alpha)];
    5528                return $results;
    5629        }
     
    6033                        throw new HException("FAIL: shape != null");
    6134                }
    62                 $_this = $this->current;
    63                 $bitmap = new geometrize_bitmap_Bitmap();
    64                 $bitmap->width = $_this->width;
    65                 $bitmap->height = $_this->height;
    66                 $this1 = (new _hx_array(array()));
    67                 $this1->length = $_this->data->length;
    68                 $bitmap->data = $this1;
    69                 {
    70                         $_g1 = 0;
    71                         $_g = $_this->data->length;
    72                         while ($_g1<$_g){
    73                                 $_g1 = $_g1+1;
    74                                 $i = $_g1-1;
    75                                 $bitmap->data[$i] = $_this->data[$i];
    76                                 unset($i);
    77                         }
    78                 }
    79                 $before = $bitmap;
    80                 if (isset($this->current->errorCache)){
    81                         $before->errorCache = $this->current->errorCache;
    82                 }
     35                $before = $this->current->hclone();
     36
    8337                $lines = $shape->rasterize();
    8438                if (!isset($shape->color)){
    8539                        $shape->color = geometrize_Core::computeColor($this->target, $this->current, $lines, $alpha);
    8640                }
     41
    8742                geometrize_rasterizer_Rasterizer::drawLines($this->current, $shape->color, $lines);
    8843                $this->score = geometrize_Core::differencePartial($this->target, $before, $this->current, $this->score, $lines);
    89                 $score_normalization = $_this->width*$_this->height*4*255;
    90                 $result = _hx_anonymous(array("score" => $this->score/$score_normalization, "color" => $shape->color, "shape" => $shape));
     44                $score_normalization = $before->width * $before->height * 4 * 255;
     45                $result = ["score" => $this->score/$score_normalization, "color" => $shape->color, "shape" => $shape];
    9146                return $result;
    9247        }
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/State.class.php

    r115850 r115922  
    1111
    1212        public function __construct($shape, $alpha, $target, $current, $buffer){
    13                 if (!php_Boot::$skip_constructor){
    14                         if (!($shape!==null)){
    15                                 throw new HException("FAIL: shape != null");
    16                         }
    17                         $this->shape = $shape;
    18                         $this->alpha = $alpha;
    19                         $this->score = -1;
    20                         $this->target = $target;
    21                         $this->current = $current;
    22                         $this->buffer = $buffer;
     13                if (!($shape!==null)){
     14                        throw new HException("FAIL: shape != null");
    2315                }
     16                $this->shape = $shape;
     17                $this->alpha = $alpha;
     18                $this->score = -1;
     19                $this->target = $target;
     20                $this->current = $current;
     21                $this->buffer = $buffer;
    2422        }
    2523
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/bitmap/Bitmap.class.php

    r115850 r115922  
    66        public $height;
    77        public $data;
     8        public $errorCache;
    89
    910        public function __construct(){
    10                 ;
     11                $this->data = [];
    1112        }
    1213
     
    1920        }
    2021
     22        public function length() {
     23                return $this->width * $this->height;
     24        }
     25
    2126        public function hclone(){
    2227                $bitmap = new geometrize_bitmap_Bitmap();
    2328                $bitmap->width = $this->width;
    2429                $bitmap->height = $this->height;
    25                 $this1 = (new _hx_array(array()));
    26                 $this1->length = $this->data->length;
    27                 $bitmap->data = $this1;
    28                 {
    29                         $_g1 = 0;
    30                         $_g = $this->data->length;
    31                         while ($_g1<$_g){
    32                                 $_g1 = $_g1+1;
    33                                 $i = $_g1-1;
    34                                 $bitmap->data[$i] = $this->data[$i];
    35                                 unset($i);
    36                         }
     30                $bitmap->data = $this->data;
     31                if (isset($this->errorCache)) {
     32                        $bitmap->errorCache = $this->errorCache;
    3733                }
    3834                return $bitmap;
     
    4137        public function fill($color){
    4238                $idx = 0;
    43                 while ($idx<$this->data->length){
    44                         $this->data[$idx] = $color >> 24 & 255;
    45                         $this->data[$idx+1] = $color >> 16 & 255;
    46                         $this->data[$idx+2] = $color >> 8 & 255;
    47                         $this->data[$idx+3] = $color & 255;
    48                         $idx = $idx+4;
     39                $n = $this->width * $this->height;
     40                while ($idx<$n){
     41                        $this->data[$idx] = $color;
     42                        $idx++;
    4943                }
    50         }
    51 
    52         public function getBytes(){
    53                 $bytes = haxe_io_Bytes::alloc($this->data->length*4);
    54                 $i = 0;
    55                 while ($i<$this->data->length){
    56                         $idx = $i*4;
    57                         {
    58                                 $v = $this->data[$i] >> 24 & 255;
    59                                 {
    60                                         $this1 = $bytes->b;
    61                                         $this1->s[$idx] = chr($v);
    62                                         unset($this1);
    63                                 }
    64                                 unset($v);
    65                         }
    66                         {
    67                                 $v1 = $this->data[$i] >> 16 & 255;
    68                                 {
    69                                         $this2 = $bytes->b;
    70                                         $this2->s[$idx+1] = chr($v1);
    71                                         unset($this2);
    72                                 }
    73                                 unset($v1);
    74                         }
    75                         {
    76                                 $v2 = $this->data[$i] >> 8 & 255;
    77                                 {
    78                                         $this3 = $bytes->b;
    79                                         $this3->s[$idx+2] = chr($v2);
    80                                         unset($this3);
    81                                 }
    82                                 unset($v2);
    83                         }
    84                         {
    85                                 $v3 = $this->data[$i] & 255;
    86                                 {
    87                                         $this4 = $bytes->b;
    88                                         $this4->s[$idx+3] = chr($v3);
    89                                         unset($this4);
    90                                 }
    91                                 unset($v3);
    92                         }
    93                         $i = $i+1;
    94                         unset($idx);
    95                 }
    96                 return $bytes;
    9744        }
    9845
     
    11360        }
    11461
    115         static function create($w, $h, $color){
     62
     63        public static function create($w, $h, $color){
    11664                $bitmap = new geometrize_bitmap_Bitmap();
    11765                $bitmap->width = $w;
    11866                $bitmap->height = $h;
    119                 $this1 = (new _hx_array(array()));
    120                 $this1->length = $w*$h;
    121                 $bitmap->data = $this1;
    122                 $i = 0;
    123                 while ($i<$bitmap->data->length){
    124                         $bitmap->data[$i] = $color;
    125                         $i = $i+1;
    126                 }
     67                $bitmap->fill($color);
    12768                return $bitmap;
    12869        }
    12970
    130         static function createFromBytes($w, $h, $bytes){
     71        public static function createFromImageFile($file){
     72                list($w, $h) = getimagesize($file);
     73                $image = imagecreatefromstring(file_get_contents($file));
     74
    13175                $bitmap = new geometrize_bitmap_Bitmap();
    132                 if (!($bytes!==null)){
    133                         throw new HException("FAIL: bytes != null");
    134                 }
    135                 {
    136                         $actual = $bytes->length;
    137                         $expected = $w*$h*4;
    138                         if ($actual!==$expected){
    139                                 throw new HException("FAIL: values are not equal (expected: " . _hx_string_rec($expected, "") . ", actual: " . _hx_string_rec($actual, "") . ")");
     76                $bitmap->width = $w;
     77                $bitmap->height = $h;
     78
     79                for ($y = 0; $y<$h; $y++){
     80                        $l = $w * $y;
     81                        for ($x = 0; $x<$w; $x++){
     82                                // get a color
     83                                $color_index = imagecolorat($image, $x, $y);
     84                                // make it human readable
     85                                $c = imagecolorsforindex($image, $color_index);
     86                                $bitmap->data[$l+$x] = geometrize_bitmap_Bitmap::colorFromRGBAArray($c);
    14087                        }
    14188                }
    142                 $bitmap->width = $w;
    143                 $bitmap->height = $h;
    144                 $this1 = (new _hx_array(array()));
    145                 $this1->length = intval($bytes->length/4);
    146                 $bitmap->data = $this1;
    147                 $i = 0;
    148                 $x = 0;
    149                 while ($i<$bytes->length){
    150                         {
    151                                 $this2 = $bitmap->data;
    152                                 $this3 = $bytes->b;
    153                                 $red = ord($this3->s[$i]);
    154                                 $this4 = $bytes->b;
    155                                 $green = ord($this4->s[$i+1]);
    156                                 $this5 = $bytes->b;
    157                                 $blue = ord($this5->s[$i+2]);
    158                                 $this6 = $bytes->b;
    159                                 $alpha = ord($this6->s[$i+3]);
    160                                 if (!true){
    161                                         throw new HException("FAIL: min <= max");
    162                                 }
    163                                 $val = null;
    164                                 if ($red<0){
    165                                         $val = 0;
    166                                 } else {
    167                                         if ($red>255){
    168                                                 $val = 255;
    169                                         } else {
    170                                                 $val = $red;
    171                                         }
    172                                 }
    173                                 if (!true){
    174                                         throw new HException("FAIL: min <= max");
    175                                 }
    176                                 $val1 = null;
    177                                 if ($green<0){
    178                                         $val1 = 0;
    179                                 } else {
    180                                         if ($green>255){
    181                                                 $val1 = 255;
    182                                         } else {
    183                                                 $val1 = $green;
    184                                         }
    185                                 }
    186                                 if (!true){
    187                                         throw new HException("FAIL: min <= max");
    188                                 }
    189                                 $val2 = null;
    190                                 if ($blue<0){
    191                                         $val2 = 0;
    192                                 } else {
    193                                         if ($blue>255){
    194                                                 $val2 = 255;
    195                                         } else {
    196                                                 $val2 = $blue;
    197                                         }
    198                                 }
    199                                 if (!true){
    200                                         throw new HException("FAIL: min <= max");
    201                                 }
    202                                 $val3 = null;
    203                                 if ($alpha<0){
    204                                         $val3 = 0;
    205                                 } else {
    206                                         if ($alpha>255){
    207                                                 $val3 = 255;
    208                                         } else {
    209                                                 $val3 = $alpha;
    210                                         }
    211                                 }
    212                                 $this2[$x] = ($val << 24)+($val1 << 16)+($val2 << 8)+$val3;
    213                                 unset($val3, $val2, $val1, $val, $this6, $this5, $this4, $this3, $this2, $red, $green, $blue, $alpha);
    214                         }
    215                         $i = $i+4;
    216                         $x = $x+1;
    217                 }
     89
    21890                return $bitmap;
    21991        }
    22092
    221         static function createFromByteArray($w, $h, $bytes){
    222                 $data = haxe_io_Bytes::alloc($bytes->length);
    223                 $i = 0;
    224                 while ($i<$bytes->length){
    225                         {
    226                                 $this1 = $data->b;
    227                                 $this1->s[$i] = chr($bytes[$i]);
    228                                 unset($this1);
    229                         }
    230                         $i = $i+1;
     93        public static function colorFromRGBAArray($c){
     94                if (isset($c['alpha'])){
     95                        // in RGBA 0 = opaque, 127 = transparent
     96                        // in geometrize 0 = transparent, 255 = opaque
     97                        $c['alpha'] = round((127-$c['alpha'])*255/127);
     98                } else {
     99                        $c['alpha'] = 255;
    231100                }
    232                 $bitmap = new geometrize_bitmap_Bitmap();
    233                 if (!($data!==null)){
    234                         throw new HException("FAIL: bytes != null");
    235                 }
    236                 {
    237                         $actual = $data->length;
    238                         $expected = $w*$h*4;
    239                         if ($actual!==$expected){
    240                                 throw new HException("FAIL: values are not equal (expected: " . _hx_string_rec($expected, "") . ", actual: " . _hx_string_rec($actual, "") . ")");
    241                         }
    242                 }
    243                 $bitmap->width = $w;
    244                 $bitmap->height = $h;
    245                 $this2 = (new _hx_array(array()));
    246                 $this2->length = intval($data->length/4);
    247                 $bitmap->data = $this2;
    248                 $i1 = 0;
    249                 $x = 0;
    250                 while ($i1<$data->length){
    251                         {
    252                                 $this3 = $bitmap->data;
    253                                 $this4 = $data->b;
    254                                 $red = ord($this4->s[$i1]);
    255                                 $this5 = $data->b;
    256                                 $green = ord($this5->s[$i1+1]);
    257                                 $this6 = $data->b;
    258                                 $blue = ord($this6->s[$i1+2]);
    259                                 $this7 = $data->b;
    260                                 $alpha = ord($this7->s[$i1+3]);
    261                                 if (!true){
    262                                         throw new HException("FAIL: min <= max");
    263                                 }
    264                                 $val = null;
    265                                 if ($red<0){
    266                                         $val = 0;
    267                                 } else {
    268                                         if ($red>255){
    269                                                 $val = 255;
    270                                         } else {
    271                                                 $val = $red;
    272                                         }
    273                                 }
    274                                 if (!true){
    275                                         throw new HException("FAIL: min <= max");
    276                                 }
    277                                 $val1 = null;
    278                                 if ($green<0){
    279                                         $val1 = 0;
    280                                 } else {
    281                                         if ($green>255){
    282                                                 $val1 = 255;
    283                                         } else {
    284                                                 $val1 = $green;
    285                                         }
    286                                 }
    287                                 if (!true){
    288                                         throw new HException("FAIL: min <= max");
    289                                 }
    290                                 $val2 = null;
    291                                 if ($blue<0){
    292                                         $val2 = 0;
    293                                 } else {
    294                                         if ($blue>255){
    295                                                 $val2 = 255;
    296                                         } else {
    297                                                 $val2 = $blue;
    298                                         }
    299                                 }
    300                                 if (!true){
    301                                         throw new HException("FAIL: min <= max");
    302                                 }
    303                                 $val3 = null;
    304                                 if ($alpha<0){
    305                                         $val3 = 0;
    306                                 } else {
    307                                         if ($alpha>255){
    308                                                 $val3 = 255;
    309                                         } else {
    310                                                 $val3 = $alpha;
    311                                         }
    312                                 }
    313                                 $this3[$x] = ($val << 24)+($val1 << 16)+($val2 << 8)+$val3;
    314                                 unset($val3, $val2, $val1, $val, $this7, $this6, $this5, $this4, $this3, $red, $green, $blue, $alpha);
    315                         }
    316                         $i1 = $i1+4;
    317                         $x = $x+1;
    318                 }
    319                 return $bitmap;
     101                $color = ($c['red'] << 24) + ($c['green'] << 16) + ($c['blue'] << 8) + $c['alpha'];
     102                return $color;
    320103        }
     104
    321105
    322106        function __toString(){
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/exporter/SvgExporter.class.php

    r115850 r115922  
    88        static $SVG_STYLE_HOOK = "::svg_style_hook::";
    99
    10         static function export($shapes, $width, $height){
    11                 $results = geometrize_exporter_SvgExporter::getSvgPrelude();
    12                 $results = _hx_string_or_null($results) . _hx_string_or_null(geometrize_exporter_SvgExporter::getSvgNodeOpen($width, $height));
    13                 $results = _hx_string_or_null($results) . _hx_string_or_null(geometrize_exporter_SvgExporter::exportShapes($shapes));
    14                 $results = _hx_string_or_null($results) . _hx_string_or_null(geometrize_exporter_SvgExporter::getSvgNodeClose());
    15                 return $results;
     10        /**
     11         * @param array $results
     12         * @param int $width
     13         * @param int $height
     14         * @return string
     15         */
     16        static function export($results, $width, $height){
     17                $out = geometrize_exporter_SvgExporter::getSvgPrelude();
     18                $out .= geometrize_exporter_SvgExporter::getSvgNodeOpen($width, $height);
     19                $shapes = array_column($results, 'shape');
     20                $out .= geometrize_exporter_SvgExporter::exportShapes($shapes);
     21                $out .= geometrize_exporter_SvgExporter::getSvgNodeClose();
     22                return $out;
    1623        }
    1724
     25        /**
     26         * @param array $shapes
     27         * @return string
     28         */
    1829        static function exportShapes($shapes){
    19                 $results = "";
    20                 {
    21                         $_g1 = 0;
    22                         $_g = $shapes->length;
    23                         while ($_g1<$_g){
    24                                 $_g1 = $_g1+1;
    25                                 $i = $_g1-1;
    26                                 $results = _hx_string_or_null($results) . _hx_string_or_null(geometrize_exporter_SvgExporter::exportShape($shapes[$i]));
    27                                 if ($i!==$shapes->length-1){
    28                                         $results = _hx_string_or_null($results) . "\x0A";
    29                                 }
    30                                 unset($i);
    31                         }
     30                $out = [];
     31                foreach ($shapes as $shape) {
     32                        $out[] = geometrize_exporter_SvgExporter::exportShape($shape);
    3233                }
    33                 return $results;
     34                $out = implode("\x0A", $out);
     35                return $out;
    3436        }
    3537
     38        /**
     39         * @param geometrize_shape_Shape $shape
     40         * @return string
     41         */
    3642        static function exportShape($shape){
    37                 $s = $shape->shape->getSvgShapeData();
     43                $s = $shape->getSvgShapeData();
    3844                $sub = geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK;
    3945                $by = geometrize_exporter_SvgExporter::stylesForShape($shape);
     
    4551        }
    4652
     53        /**
     54         * @param array $points
     55         *   each element is a ['x'=>int, 'y'=>int] array
     56         * @return string
     57         */
     58        static public function exportPolygon($points) {
     59                $s1 = "<polygon points=\"";
     60
     61                foreach ($points as $point) {
     62                        $s1 .= $point['x'] . " " . $point['y'] . " ";
     63                }
     64                $s1 = rtrim($s1);
     65                $s1 .= "\" " . geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK . "/>";
     66                return $s1;
     67        }
     68
     69        /**
     70         * @return string
     71         */
    4772        static function getSvgPrelude(){
    4873                return "<?xml version=\"1.0\" standalone=\"no\"?>\x0A";
    4974        }
    5075
     76        /**
     77         * @param int $width
     78         * @param int $height
     79         * @return string
     80         */
    5181        static function getSvgNodeOpen($width, $height){
    52                 return "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.2\" baseProfile=\"tiny\" width=\"" . _hx_string_rec($width, "") . "\" height=\"" . _hx_string_rec($height, "") . "\">\x0A";
     82                return "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.2\" baseProfile=\"tiny\" width=\"" . intval($width) . "\" height=\"" . intval($height) . "\">\x0A";
    5383        }
    5484
     85        /**
     86         * @return string
     87         */
    5588        static function getSvgNodeClose(){
    5689                return "</svg>";
    5790        }
    5891
     92        /**
     93         * @param geometrize_shape_Shape $shape
     94         * @return string
     95         */
    5996        static function stylesForShape($shape){
    60                 $_g = $shape->shape->getType();
    61                 switch ($_g) {
    62                         case 6:
    63                         case 7:
    64                                 {
    65                                         $tmp = _hx_string_or_null(geometrize_exporter_SvgExporter::strokeForColor($shape->color)) . " stroke-width=\"1\" fill=\"none\" ";
    66                                         return _hx_string_or_null($tmp) . _hx_string_or_null(geometrize_exporter_SvgExporter::strokeOpacityForAlpha($shape->color & 255));
    67                                 }
     97                $style = "";
     98                switch ($shape->getType()) {
     99                        case geometrize_shape_ShapeTypes::T_LINE:
     100                        case geometrize_shape_ShapeTypes::T_QUADRATIC_BEZIER:
     101                                $style = geometrize_exporter_SvgExporter::strokeForColor($shape->color) . " stroke-width=\"1\" fill=\"none\" ";
     102                                $style .= geometrize_exporter_SvgExporter::strokeOpacityForAlpha($shape->color & 255);
    68103                                break;
    69104                        default:
    70                                 {
    71                                         $tmp1 = _hx_string_or_null(geometrize_exporter_SvgExporter::fillForColor($shape->color)) . " ";
    72                                         return _hx_string_or_null($tmp1) . _hx_string_or_null(geometrize_exporter_SvgExporter::fillOpacityForAlpha($shape->color & 255));
    73                                 }
     105                                $style = geometrize_exporter_SvgExporter::fillForColor($shape->color) . " ";
     106                                $style .= geometrize_exporter_SvgExporter::fillOpacityForAlpha($shape->color & 255);
    74107                                break;
    75108                }
     109                return $style ;
    76110        }
    77111
     112        /**
     113         * @param int $color
     114         * @return string
     115         */
    78116        static function rgbForColor($color){
    79                 return "rgb(" . _hx_string_rec(($color >> 24 & 255), "") . "," . _hx_string_rec(($color >> 16 & 255), "") . "," . _hx_string_rec(($color >> 8 & 255), "") . ")";
     117                return "rgb(" . ($color >> 24 & 255) . "," . ($color >> 16 & 255) . "," . ($color >> 8 & 255) . ")";
    80118        }
    81119
     120        /**
     121         * @param int $color
     122         * @return string
     123         */
    82124        static function strokeForColor($color){
    83                 return "stroke=\"" . _hx_string_or_null(geometrize_exporter_SvgExporter::rgbForColor($color)) . "\"";
     125                return "stroke=\"" . geometrize_exporter_SvgExporter::rgbForColor($color) . "\"";
    84126        }
    85127
     128        /**
     129         * @param int $color
     130         * @return string
     131         */
    86132        static function fillForColor($color){
    87                 return "fill=\"" . _hx_string_or_null(geometrize_exporter_SvgExporter::rgbForColor($color)) . "\"";
     133                return "fill=\"" . geometrize_exporter_SvgExporter::rgbForColor($color) . "\"";
    88134        }
    89135
     136        /**
     137         * @param int $alpha
     138         * @return string
     139         */
    90140        static function fillOpacityForAlpha($alpha){
    91                 return "fill-opacity=\"" . _hx_string_rec($alpha/255.0, "") . "\"";
     141                if ($alpha === 255) {
     142                        return "";
     143                }
     144                return "fill-opacity=\"" . ($alpha/255.0) . "\"";
    92145        }
    93146
     147        /**
     148         * @param int $alpha
     149         * @return string
     150         */
    94151        static function strokeOpacityForAlpha($alpha){
    95                 return "stroke-opacity=\"" . _hx_string_rec($alpha/255.0, "") . "\"";
     152                if ($alpha === 255) {
     153                        return "";
     154                }
     155                return "stroke-opacity=\"" . ($alpha/255.0)  . "\"";
    96156        }
    97157
     158        /**
     159         * @return string
     160         */
    98161        function __toString(){
    99162                return 'geometrize.exporter.SvgExporter';
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/rasterizer/Rasterizer.class.php

    r115850 r115922  
    1010                // easy case: opacity=1, just a copy of the color $c, much faster
    1111                if ($c & 255===255){
    12                         for ($_g = 0; $_g<$lines->length; $_g++){
    13                                 $line = &$lines[$_g];
     12                        foreach ($lines as &$line) {
    1413                                $_g1 = $line->x2+1;
    1514                                $o = $image->width*$line->y;
     
    3635                        $sa = $c & 255;
    3736                        $sa = $sa | $sa << 8;
    38                         {
    39                                 $_g = 0;
    40                                 while ($_g<$lines->length){
    41                                         $line = $lines[$_g];
    42                                         $_g = $_g+1;
    43                                         $y = $line->y;
    44                                         $ma = 65535;
    45                                         $m = 65535;
    46                                         $as = ($m-$sa*($ma/$m))*257;
    47                                         $a = intval($as);
     37
     38                        foreach ($lines as &$line) {
     39                                $y = $line->y;
     40                                $ma = 65535;
     41                                $m = 65535;
     42                                $as = ($m-$sa*($ma/$m))*257;
     43                                $a = intval($as);
     44
     45                                $_g2 = $line->x1;
     46                                $_g1 = $line->x2+1;
     47                                while ($_g2<$_g1){
     48                                        $_g2 = $_g2+1;
     49                                        $x = $_g2-1;
     50                                        $d = $image->data[$image->width*$y+$x];
     51                                        $dr = $d >> 24 & 255;
     52                                        $dg = $d >> 16 & 255;
     53                                        $db = $d >> 8 & 255;
     54                                        $da = $d & 255;
     55                                        $int = $dr*$a+$sr*$ma;
     56                                        $r = null;
     57                                        if ($int<0){
     58                                                $r = 4294967296.0+$int;
     59                                        } else {
     60                                                $r = $int+0.0;
     61                                        }
     62                                        $int1 = $m;
     63                                        $r1 = null;
     64                                        if ($int1<0){
     65                                                $r1 = 4294967296.0+$int1;
     66                                        } else {
     67                                                $r1 = $int1+0.0;
     68                                        }
     69                                        $r2 = intval($r/$r1) >> 8;
     70                                        $int2 = $dg*$a+$sg*$ma;
     71                                        $g = null;
     72                                        if ($int2<0){
     73                                                $g = 4294967296.0+$int2;
     74                                        } else {
     75                                                $g = $int2+0.0;
     76                                        }
     77                                        $int3 = $m;
     78                                        $g1 = null;
     79                                        if ($int3<0){
     80                                                $g1 = 4294967296.0+$int3;
     81                                        } else {
     82                                                $g1 = $int3+0.0;
     83                                        }
     84                                        $g2 = intval($g/$g1) >> 8;
     85                                        $int4 = $db*$a+$sb*$ma;
     86                                        $b = null;
     87                                        if ($int4<0){
     88                                                $b = 4294967296.0+$int4;
     89                                        } else {
     90                                                $b = $int4+0.0;
     91                                        }
     92                                        $int5 = $m;
     93                                        $b1 = null;
     94                                        if ($int5<0){
     95                                                $b1 = 4294967296.0+$int5;
     96                                        } else {
     97                                                $b1 = $int5+0.0;
     98                                        }
     99                                        $b2 = intval($b/$b1) >> 8;
     100                                        $int6 = $da*$a+$sa*$ma;
     101                                        $a1 = null;
     102                                        if ($int6<0){
     103                                                $a1 = 4294967296.0+$int6;
     104                                        } else {
     105                                                $a1 = $int6+0.0;
     106                                        }
     107                                        $int7 = $m;
     108                                        $a2 = null;
     109                                        if ($int7<0){
     110                                                $a2 = 4294967296.0+$int7;
     111                                        } else {
     112                                                $a2 = $int7+0.0;
     113                                        }
     114                                        $a3 = intval($a1/$a2) >> 8;
    48115                                        {
    49                                                 $_g2 = $line->x1;
    50                                                 $_g1 = $line->x2+1;
    51                                                 while ($_g2<$_g1){
    52                                                         $_g2 = $_g2+1;
    53                                                         $x = $_g2-1;
    54                                                         $d = $image->data[$image->width*$y+$x];
    55                                                         $dr = $d >> 24 & 255;
    56                                                         $dg = $d >> 16 & 255;
    57                                                         $db = $d >> 8 & 255;
    58                                                         $da = $d & 255;
    59                                                         $int = $dr*$a+$sr*$ma;
    60                                                         $r = null;
    61                                                         if ($int<0){
    62                                                                 $r = 4294967296.0+$int;
     116                                                if (!true){
     117                                                        throw new HException("FAIL: min <= max");
     118                                                }
     119                                                $color = null;
     120                                                if ($r2<0){
     121                                                        $color = 0;
     122                                                } else {
     123                                                        if ($r2>255){
     124                                                                $color = 255;
    63125                                                        } else {
    64                                                                 $r = $int+0.0;
     126                                                                $color = $r2;
    65127                                                        }
    66                                                         $int1 = $m;
    67                                                         $r1 = null;
    68                                                         if ($int1<0){
    69                                                                 $r1 = 4294967296.0+$int1;
     128                                                }
     129                                                if (!true){
     130                                                        throw new HException("FAIL: min <= max");
     131                                                }
     132                                                $color1 = null;
     133                                                if ($g2<0){
     134                                                        $color1 = 0;
     135                                                } else {
     136                                                        if ($g2>255){
     137                                                                $color1 = 255;
    70138                                                        } else {
    71                                                                 $r1 = $int1+0.0;
     139                                                                $color1 = $g2;
    72140                                                        }
    73                                                         $r2 = intval($r/$r1) >> 8;
    74                                                         $int2 = $dg*$a+$sg*$ma;
    75                                                         $g = null;
    76                                                         if ($int2<0){
    77                                                                 $g = 4294967296.0+$int2;
     141                                                }
     142                                                if (!true){
     143                                                        throw new HException("FAIL: min <= max");
     144                                                }
     145                                                $color2 = null;
     146                                                if ($b2<0){
     147                                                        $color2 = 0;
     148                                                } else {
     149                                                        if ($b2>255){
     150                                                                $color2 = 255;
    78151                                                        } else {
    79                                                                 $g = $int2+0.0;
     152                                                                $color2 = $b2;
    80153                                                        }
    81                                                         $int3 = $m;
    82                                                         $g1 = null;
    83                                                         if ($int3<0){
    84                                                                 $g1 = 4294967296.0+$int3;
     154                                                }
     155                                                if (!true){
     156                                                        throw new HException("FAIL: min <= max");
     157                                                }
     158                                                $color3 = null;
     159                                                if ($a3<0){
     160                                                        $color3 = 0;
     161                                                } else {
     162                                                        if ($a3>255){
     163                                                                $color3 = 255;
    85164                                                        } else {
    86                                                                 $g1 = $int3+0.0;
     165                                                                $color3 = $a3;
    87166                                                        }
    88                                                         $g2 = intval($g/$g1) >> 8;
    89                                                         $int4 = $db*$a+$sb*$ma;
    90                                                         $b = null;
    91                                                         if ($int4<0){
    92                                                                 $b = 4294967296.0+$int4;
    93                                                         } else {
    94                                                                 $b = $int4+0.0;
    95                                                         }
    96                                                         $int5 = $m;
    97                                                         $b1 = null;
    98                                                         if ($int5<0){
    99                                                                 $b1 = 4294967296.0+$int5;
    100                                                         } else {
    101                                                                 $b1 = $int5+0.0;
    102                                                         }
    103                                                         $b2 = intval($b/$b1) >> 8;
    104                                                         $int6 = $da*$a+$sa*$ma;
    105                                                         $a1 = null;
    106                                                         if ($int6<0){
    107                                                                 $a1 = 4294967296.0+$int6;
    108                                                         } else {
    109                                                                 $a1 = $int6+0.0;
    110                                                         }
    111                                                         $int7 = $m;
    112                                                         $a2 = null;
    113                                                         if ($int7<0){
    114                                                                 $a2 = 4294967296.0+$int7;
    115                                                         } else {
    116                                                                 $a2 = $int7+0.0;
    117                                                         }
    118                                                         $a3 = intval($a1/$a2) >> 8;
    119                                                         {
    120                                                                 if (!true){
    121                                                                         throw new HException("FAIL: min <= max");
    122                                                                 }
    123                                                                 $color = null;
    124                                                                 if ($r2<0){
    125                                                                         $color = 0;
    126                                                                 } else {
    127                                                                         if ($r2>255){
    128                                                                                 $color = 255;
    129                                                                         } else {
    130                                                                                 $color = $r2;
    131                                                                         }
    132                                                                 }
    133                                                                 if (!true){
    134                                                                         throw new HException("FAIL: min <= max");
    135                                                                 }
    136                                                                 $color1 = null;
    137                                                                 if ($g2<0){
    138                                                                         $color1 = 0;
    139                                                                 } else {
    140                                                                         if ($g2>255){
    141                                                                                 $color1 = 255;
    142                                                                         } else {
    143                                                                                 $color1 = $g2;
    144                                                                         }
    145                                                                 }
    146                                                                 if (!true){
    147                                                                         throw new HException("FAIL: min <= max");
    148                                                                 }
    149                                                                 $color2 = null;
    150                                                                 if ($b2<0){
    151                                                                         $color2 = 0;
    152                                                                 } else {
    153                                                                         if ($b2>255){
    154                                                                                 $color2 = 255;
    155                                                                         } else {
    156                                                                                 $color2 = $b2;
    157                                                                         }
    158                                                                 }
    159                                                                 if (!true){
    160                                                                         throw new HException("FAIL: min <= max");
    161                                                                 }
    162                                                                 $color3 = null;
    163                                                                 if ($a3<0){
    164                                                                         $color3 = 0;
    165                                                                 } else {
    166                                                                         if ($a3>255){
    167                                                                                 $color3 = 255;
    168                                                                         } else {
    169                                                                                 $color3 = $a3;
    170                                                                         }
    171                                                                 }
    172                                                                 $image->data[$image->width*$y+$x] = ($color << 24)+($color1 << 16)+($color2 << 8)+$color3;
    173                                                                 if (isset($image->errorCache) && isset($image->errorCache[$image->width*$y+$x])){
    174                                                                         unset($image->errorCache[$image->width*$y+$x]);
    175                                                                 }
    176                                                                 unset($color3, $color2, $color1, $color);
    177                                                         }
    178                                                         unset($x, $r2, $r1, $r, $int7, $int6, $int5, $int4, $int3, $int2, $int1, $int, $g2, $g1, $g, $dr, $dg, $db, $da, $d, $b2, $b1, $b, $a3, $a2, $a1);
    179                                                 }
    180                                                 unset($_g2, $_g1);
    181                                         }
    182                                         unset($y, $ma, $m, $line, $as, $a);
     167                                                }
     168                                                $image->data[$image->width*$y+$x] = ($color << 24)+($color1 << 16)+($color2 << 8)+$color3;
     169                                                if (isset($image->errorCache) && isset($image->errorCache[$image->width*$y+$x])){
     170                                                        unset($image->errorCache[$image->width*$y+$x]);
     171                                                }
     172                                        }
    183173                                }
    184174                        }
     
    197187                }
    198188
    199                 for ($_g = 0; $_g<$lines->length; $_g++){
    200                         $line = &$lines[$_g];
     189                foreach ($lines as &$line) {
    201190                        $_g1 = $line->x2+1;
    202191                        $o1 = $source->width*$line->y;
     
    208197        }
    209198
     199        /**
     200         * @param int $x1
     201         * @param int $y1
     202         * @param int $x2
     203         * @param int $y2
     204         * @return array
     205         */
    210206        static function bresenham($x1, $y1, $x2, $y2){
    211207                $dx = $x2-$x1;
     
    251247                }
    252248                $dy = $dy1 << 1;
    253                 $points = (new _hx_array(array()));
    254                 $points->push(_hx_anonymous(array("x" => $x1, "y" => $y1)));
     249                $points = [];
     250                $points[] = ["x" => $x1, "y" => $y1];
    255251                if ($dx>=$dy){
    256252                        $error = $dy-($dx >> 1);
     
    272268                                $error = $error+$dy;
    273269                                $x1 = $x1+$ix2;
    274                                 $points->push(_hx_anonymous(array("x" => $x1, "y" => $y1)));
     270                                $points[] = ["x" => $x1, "y" => $y1];
    275271                                unset($tmp);
    276272                        }
     
    294290                                $error1 = $error1+$dx;
    295291                                $y1 = $y1+$iy2;
    296                                 $points->push(_hx_anonymous(array("x" => $x1, "y" => $y1)));
     292                                $points[] = ["x" => $x1, "y" => $y1];
    297293                                unset($tmp1);
    298294                        }
     
    301297        }
    302298
    303         static function scanlinesForPolygon($points){
    304                 $lines = (new _hx_array(array()));
    305                 $edges = (new _hx_array(array()));
    306                 {
    307                         $_g1 = 0;
    308                         $_g = $points->length;
    309                         while ($_g1<$_g){
    310                                 $_g1 = $_g1+1;
    311                                 $i = $_g1-1;
    312                                 $p1 = $points[$i];
    313                                 $p2 = null;
    314                                 if ($i===$points->length-1){
    315                                         $p2 = $points[0];
    316                                 } else {
    317                                         $p2 = $points[$i+1];
    318                                 }
    319                                 $p1p2 = geometrize_rasterizer_Rasterizer::bresenham($p1->x, $p1->y, $p2->x, $p2->y);
    320                                 $edges = $edges->concat($p1p2);
    321                                 unset($p2, $p1p2, $p1, $i);
    322                         }
    323                 }
     299        /**
     300         * @param array $points
     301         * @param int $xBound
     302         * @param int $yBound
     303         * @return array
     304         */
     305        static function scanlinesForPolygon($points, $xBound, $yBound){
     306                return geometrize_rasterizer_Rasterizer::scanlinesForPath($points, $xBound, $yBound, true);
     307        }
     308
     309        /**
     310         * @param array $points
     311         * @param int $xBound
     312         * @param int $yBound
     313         * @param bool $isClosed
     314         * @return array
     315         */
     316        static function scanlinesForPath($points, $xBound, $yBound, $isClosed = false){
     317                $lines = [];
     318                $edges = [];
     319
     320                if ($isClosed) {
     321                        $prevPoint = end($points);
     322                }
     323                else {
     324                        $prevPoint = array_shift($points);
     325                }
     326
    324327                $yToXs = [];
    325                 for ($_g2 = 0; $_g2<$edges->length; $_g2++){
    326                         $point = $edges[$_g2];
    327                         if (!isset($yToXs[$point->y])){
    328                                 $yToXs[$point->y] = [];
    329                         }
    330                         $yToXs[$point->y][] = $point->x;
    331                 }
    332                 ksort($yToXs);
     328
     329                foreach ($points as $point) {
     330                        $rasterizedLine = geometrize_rasterizer_Rasterizer::bresenham($prevPoint['x'], $prevPoint['y'], $point['x'], $point['y']);
     331
     332                        foreach ($rasterizedLine as $p) {
     333                                if (!isset($yToXs[$p['y']])){
     334                                        $yToXs[$p['y']] = [];
     335                                }
     336                                $yToXs[$p['y']][] = $p['x'];
     337                        }
     338
     339                        $prevPoint = $point;
     340                }
     341
     342                // not super useful
     343                // ksort($yToXs);
     344
    333345                foreach ($yToXs as $y => $xs){
    334                         $minx = min($xs);
    335                         $maxx = max($xs);
    336                         $lines->push(new geometrize_rasterizer_Scanline($y, $minx, $maxx));
     346                        if ($y>=0 and $y<$yBound){
     347                                $minx = min($xs);
     348                                $maxx = max($xs);
     349                                if ($minx<$xBound and $maxx>=0){
     350                                        $lines[] = new geometrize_rasterizer_Scanline($y, max($minx, 0), min($maxx, $xBound-1));
     351                                }
     352                        }
    337353                }
    338354
     
    340356        }
    341357
     358        /**
     359         * @return string
     360         */
    342361        function __toString(){
    343362                return 'geometrize.rasterizer.Rasterizer';
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/rasterizer/Scanline.class.php

    r115850 r115922  
    88
    99        public function __construct($y, $x1, $x2){
    10                 if (!php_Boot::$skip_constructor){
    11                         $this->y = $y;
    12                         $this->x1 = $x1;
    13                         $this->x2 = $x2;
    14                 }
     10                $this->y = $y;
     11                $this->x1 = $x1;
     12                $this->x2 = $x2;
    1513        }
    1614
     
    3129        }
    3230
    33         static function trim($scanlines, $w, $h){
    34                 if (!($scanlines!==null)){
    35                         throw new HException("FAIL: scanlines != null");
    36                 }
    37                 $w1 = $w;
    38                 $h1 = $h;
    39                 return $scanlines->filter(array(new _hx_lambda(array(&$h1, &$w1), "geometrize_rasterizer_Scanline_0"), 'execute'));
     31        /**
     32         * Rescale the scanline
     33         * @param float $xScale
     34         * @param float $yScale
     35         */
     36        public function rescale($xScale, $yScale) {
     37                $this->y = intval(round($this->y*$yScale));
     38                $this->x1 = intval(round($this->x1*$xScale));
     39                $this->x2 = intval(round($this->x2*$xScale));
    4040        }
    4141
    42         static function trimHelper($line, $w, $h){
    43                 $tmp = null;
    44                 $tmp1 = null;
    45                 $tmp2 = null;
    46                 if ($line->y>=0){
    47                         $tmp2 = $line->y>=$h;
    48                 } else {
    49                         $tmp2 = true;
     42        static function trim(&$scanlines, $w, $h){
     43                if (!is_array($scanlines)){
     44                        throw new HException("FAIL: scanlines != array");
    5045                }
    51                 if (!$tmp2){
    52                         $tmp1 = $line->x1>=$w;
    53                 } else {
    54                         $tmp1 = true;
    55                 }
    56                 if (!$tmp1){
    57                         $tmp = $line->x2<0;
    58                 } else {
    59                         $tmp = true;
    60                 }
    61                 if ($tmp){
    62                         return false;
    63                 }
    64                 $value = $line->x1;
    6546                $max = $w-1;
    6647                if (!(0<=$max)){
    6748                        throw new HException("FAIL: min <= max");
    6849                }
    69                 $tmp3 = null;
    70                 if ($value<0){
    71                         $tmp3 = 0;
    72                 } else {
    73                         if ($value>$max){
    74                                 $tmp3 = $max;
    75                         } else {
    76                                 $tmp3 = $value;
     50
     51                foreach ($scanlines as $k=>&$line) {
     52                        if (!geometrize_rasterizer_Scanline::trimHelper($line, $w, $h)) {
     53                                unset($scanlines[$k]);
    7754                        }
    7855                }
    79                 $line->x1 = $tmp3;
    80                 $value1 = $line->x2;
    81                 $max1 = $w-1;
    82                 if (!(0<=$max1)){
    83                         throw new HException("FAIL: min <= max");
     56                /*
     57                // trim each scanline with the bounds
     58                $scanlines = array_map(function (&$line) use ($w,$h) { return geometrize_rasterizer_Scanline::trimHelper($line, $w, $h); }, $scanlines);
     59                // remove empty scanlines
     60                $scanlines = array_filter($scanlines);
     61                */
     62
     63                return $scanlines;
     64        }
     65
     66        /**
     67         * Trim a ScanLine
     68         * @param geometrize_rasterizer_Scanline $line
     69         * @param int $w
     70         * @param int $h
     71         * @return bool
     72         * @throws HException
     73         */
     74        static function trimHelper(&$line, $w, $h){
     75                if ($line->y<0 or $line->y>=$h) {
     76                        return false;
    8477                }
    85                 $tmp4 = null;
    86                 if ($value1<0){
    87                         $tmp4 = 0;
    88                 } else {
    89                         if ($value1>$max1){
    90                                 $tmp4 = $max1;
    91                         } else {
    92                                 $tmp4 = $value1;
    93                         }
     78                if ($line->x1>=$w or $line->x2<0 or $line->x2<$line->x1) {
     79                        return false;
    9480                }
    95                 $line->x2 = $tmp4;
    96                 return $line->x1<=$line->x2;
     81
     82                $line->x1 = max($line->x1, 0);
     83                $line->x2 = min($line->x2, $w-1);
     84
     85                return true;
    9786        }
    9887
     
    10190        }
    10291}
    103 
    104 function geometrize_rasterizer_Scanline_0(&$h1, &$w1, $a1){
    105         {
    106                 return geometrize_rasterizer_Scanline::trimHelper($a1, $w1, $h1);
    107         }
    108 }
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/runner/ImageRunner.class.php

    r115850 r115922  
    66
    77        public function __construct($inputImage, $backgroundColor){
    8                 if (!php_Boot::$skip_constructor){
    9                         $this->model = null;
    10                         $this->model = new geometrize_Model($inputImage, $backgroundColor);
    11                 }
     8                $this->model = new geometrize_Model($inputImage, $backgroundColor);
    129        }
    1310
    1411        public function step($options){
    15                 return $this->model->step($options->shapeTypes, $options->alpha, $options->candidateShapesPerStep, $options->shapeMutationsPerStep);
     12                return $this->model->step($options['shapeTypes'], $options['alpha'], $options['candidateShapesPerStep'], $options['shapeMutationsPerStep']);
    1613        }
    1714
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Circle.class.php

    r115850 r115922  
    44class geometrize_shape_Circle extends geometrize_shape_Ellipse {
    55        public function __construct($xBound, $yBound){
    6                 if (!php_Boot::$skip_constructor){
    7                         parent::__construct($xBound, $yBound);
    8                         $this->rx = mt_rand(1, 32);
    9                         $this->ry = $this->rx;
    10                 }
     6                parent::__construct($xBound, $yBound);
     7                $this->rx = mt_rand(1, 32);
     8                $this->ry = $this->rx;
    119        }
    1210
     
    9290                $circle->rx = $this->rx;
    9391                $circle->ry = $this->ry;
    94                 if (isset($this->color)){
    95                         $circle->color = $this->color;
    96                 }
     92                $circle->color = $this->color;
     93
    9794                return $circle;
    9895        }
    9996
    10097        public function getType(){
    101                 return 5;
     98                return geometrize_shape_ShapeTypes::T_CIRCLE;
    10299        }
    103100
    104101        public function getRawShapeData(){
    105                 return (new _hx_array(array($this->x, $this->y, $this->rx)));
     102                return [
     103                        $this->x,
     104                        $this->y,
     105                        $this->rx
     106                ];
    106107        }
    107108
    108109        public function getSvgShapeData(){
    109                 return "<circle cx=\"" . _hx_string_rec($this->x, "") . "\" cy=\"" . _hx_string_rec($this->y, "") . "\" r=\"" . _hx_string_rec($this->rx, "") . "\" " . _hx_string_or_null(geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK) . " />";
     110                return "<circle cx=\"" . $this->x . "\" cy=\"" . $this->y . "\" r=\"" . $this->rx . "\" " . geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK . " />";
    110111        }
    111112
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Ellipse.class.php

    r115861 r115922  
    99        public $xBound;
    1010        public $yBound;
     11        public $color;
    1112
    1213        public function __construct($xBound, $yBound){
    13                 if (!php_Boot::$skip_constructor){
    14                         $this->x = mt_rand(0, $xBound-1);
    15                         $this->y = mt_rand(0, $yBound-1);
    16                         $this->rx = mt_rand(1, 32);
    17                         $this->ry = mt_rand(1, 32);
    18                         $this->xBound = $xBound;
    19                         $this->yBound = $yBound;
    20                 }
     14                $this->x = mt_rand(0, $xBound-1);
     15                $this->y = mt_rand(0, $yBound-1);
     16                $this->rx = mt_rand(1, 32);
     17                $this->ry = mt_rand(1, 32);
     18                $this->xBound = $xBound;
     19                $this->yBound = $yBound;
    2120        }
    2221
    2322        public function rasterize(){
    24                 $lines = (new _hx_array(array()));
     23                $lines = [];
    2524                $aspect = $this->rx/$this->ry;
    2625                $w = $this->xBound;
     
    6968                                }
    7069                                if ($tmp2){
    71                                         $lines->push(new geometrize_rasterizer_Scanline($y1, $x1, $x2));
     70                                        $lines[] = new geometrize_rasterizer_Scanline($y1, $x1, $x2);
    7271                                }
    7372                                $tmp3 = null;
     
    8483                                }
    8584                                if ($tmp3){
    86                                         $lines->push(new geometrize_rasterizer_Scanline($y2, $x1, $x2));
     85                                        $lines[] = (new geometrize_rasterizer_Scanline($y2, $x1, $x2));
    8786                                }
    8887                                unset($y2, $y1, $x2, $x1, $tmp4, $tmp3, $tmp2, $tmp1, $tmp, $s, $dy);
     
    207206                $ellipse->rx = $this->rx;
    208207                $ellipse->ry = $this->ry;
    209                 if (isset($this->color)){
    210                         $ellipse->color = $this->color;
    211                 }
     208                $ellipse->color = $this->color;
     209
    212210                return $ellipse;
    213211        }
    214212
    215213        public function getType(){
    216                 return 3;
    217         }
    218 
     214                return geometrize_shape_ShapeTypes::T_ELLIPSE;
     215        }
     216
     217        /**
     218         * @return array
     219         */
    219220        public function getRawShapeData(){
    220                 return (new _hx_array(array($this->x, $this->y, $this->rx, $this->ry)));
     221                return [
     222                        $this->x,
     223                        $this->y,
     224                        $this->rx,
     225                        $this->ry
     226                ];
    221227        }
    222228
    223229        public function getSvgShapeData(){
    224                 return "<ellipse cx=\"" . _hx_string_rec($this->x, "") . "\" cy=\"" . _hx_string_rec($this->y, "") . "\" rx=\"" . _hx_string_rec($this->rx, "") . "\" ry=\"" . _hx_string_rec($this->ry, "") . "\" " . _hx_string_or_null(geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK) . " />";
     230                return "<ellipse cx=\"" . $this->x . "\" cy=\"" . $this->y . "\" rx=\"" . $this->rx . "\" ry=\"" . $this->ry . "\" " . geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK . " />";
    225231        }
    226232
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Line.class.php

    r115861 r115922  
    99        public $xBound;
    1010        public $yBound;
     11        public $color;
    1112
    1213        public function __construct($xBound, $yBound){
    13                 if (!php_Boot::$skip_constructor){
    14                         $this->x1 = mt_rand(0, $xBound-1);
    15                         $this->y1 = mt_rand(0, $yBound-1);
    16                         $value = $this->x1;
    17                         $value1 = $value+mt_rand(1, 32);
    18                         if (!(0<=$xBound)){
    19                                 throw new HException("FAIL: min <= max");
     14                $this->x1 = mt_rand(0, $xBound-1);
     15                $this->y1 = mt_rand(0, $yBound-1);
     16                $value = $this->x1;
     17                $value1 = $value+mt_rand(1, 32);
     18                if (!(0<=$xBound)){
     19                        throw new HException("FAIL: min <= max");
     20                }
     21                $tmp = null;
     22                if ($value1<0){
     23                        $tmp = 0;
     24                } else {
     25                        if ($value1>$xBound){
     26                                $tmp = $xBound;
     27                        } else {
     28                                $tmp = $value1;
    2029                        }
    21                         $tmp = null;
    22                         if ($value1<0){
    23                                 $tmp = 0;
     30                }
     31                $this->x2 = $tmp;
     32                $value2 = $this->y1;
     33                $value3 = $value2+mt_rand(1, 32);
     34                if (!(0<=$yBound)){
     35                        throw new HException("FAIL: min <= max");
     36                }
     37                $tmp1 = null;
     38                if ($value3<0){
     39                        $tmp1 = 0;
     40                } else {
     41                        if ($value3>$yBound){
     42                                $tmp1 = $yBound;
    2443                        } else {
    25                                 if ($value1>$xBound){
    26                                         $tmp = $xBound;
    27                                 } else {
    28                                         $tmp = $value1;
    29                                 }
     44                                $tmp1 = $value3;
    3045                        }
    31                         $this->x2 = $tmp;
    32                         $value2 = $this->y1;
    33                         $value3 = $value2+mt_rand(1, 32);
    34                         if (!(0<=$yBound)){
    35                                 throw new HException("FAIL: min <= max");
    36                         }
    37                         $tmp1 = null;
    38                         if ($value3<0){
    39                                 $tmp1 = 0;
    40                         } else {
    41                                 if ($value3>$yBound){
    42                                         $tmp1 = $yBound;
    43                                 } else {
    44                                         $tmp1 = $value3;
    45                                 }
    46                         }
    47                         $this->y2 = $tmp1;
    48                         $this->xBound = $xBound;
    49                         $this->yBound = $yBound;
    50                 }
    51         }
    52 
     46                }
     47                $this->y2 = $tmp1;
     48                $this->xBound = $xBound;
     49                $this->yBound = $yBound;
     50        }
     51
     52        /**
     53         * @return array
     54         * @throws HException
     55         */
    5356        public function rasterize(){
    54                 $lines = (new _hx_array(array()));
    55                 $points = geometrize_rasterizer_Rasterizer::bresenham($this->x1, $this->y1, $this->x2, $this->y2);
    56                 {
    57                         $_g = 0;
    58                         while ($_g<$points->length){
    59                                 $point = $points[$_g];
    60                                 $_g = $_g+1;
    61                                 $lines->push(new geometrize_rasterizer_Scanline($point->y, $point->x, $point->x));
    62                                 unset($point);
    63                         }
    64                 }
    65                 return geometrize_rasterizer_Scanline::trim($lines, $this->xBound, $this->yBound);
     57                $points = [
     58                        ['x' => $this->x1, 'y' => $this->y1],
     59                        ['x' => $this->x2, 'y' => $this->y2]
     60                ];
     61
     62                return geometrize_rasterizer_Rasterizer::scanlinesForPath($points, $this->xBound, $this->yBound);
    6663        }
    6764
     
    177174                $line->x2 = $this->x2;
    178175                $line->y2 = $this->y2;
    179                 if (isset($this->color)){
    180                         $line->color = $this->color;
    181                 }
     176                $line->color = $this->color;
     177
    182178                return $line;
    183179        }
    184180
    185181        public function getType(){
    186                 return 6;
    187         }
    188 
     182                return geometrize_shape_ShapeTypes::T_LINE;
     183        }
     184
     185        /**
     186         * @return array
     187         */
    189188        public function getRawShapeData(){
    190                 return (new _hx_array(array($this->x1, $this->y1, $this->x2, $this->y2)));
    191         }
    192 
     189                return [
     190                        $this->x1,
     191                        $this->y1,
     192                        $this->x2,
     193                        $this->y2
     194                ];
     195        }
     196
     197        /**
     198         * @return string
     199         */
    193200        public function getSvgShapeData(){
    194                 return "<line x1=\"" . _hx_string_rec($this->x1, "") . "\" y1=\"" . _hx_string_rec($this->y1, "") . "\" x2=\"" . _hx_string_rec($this->x2, "") . "\" y2=\"" . _hx_string_rec($this->y2, "") . "\" " . _hx_string_or_null(geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK) . " />";
     201                return "<line x1=\"" . $this->x1 . "\" y1=\"" . $this->y1 . "\" x2=\"" . $this->x2 . "\" y2=\"" . $this->y2 . "\" " . geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK . " />";
    195202        }
    196203
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/QuadraticBezier.class.php

    r115861 r115922  
    1111        public $xBound;
    1212        public $yBound;
     13        public $color;
    1314
    1415        public function __construct($xBound, $yBound){
    15                 if (!php_Boot::$skip_constructor){
    16                         $upper = $xBound-1;
    17                         if (!(0<=$upper)){
    18                                 throw new HException("FAIL: lower <= upper");
    19                         }
    20                         $this->x1 = mt_rand(0, $upper);
    21                         $upper1 = $yBound-1;
    22                         if (!(0<=$upper1)){
    23                                 throw new HException("FAIL: lower <= upper");
    24                         }
    25                         $this->y1 = mt_rand(0, $upper1);
    26                         $upper2 = $xBound-1;
    27                         if (!(0<=$upper2)){
    28                                 throw new HException("FAIL: lower <= upper");
    29                         }
    30                         $this->cx = mt_rand(0, $upper2);
    31                         $upper3 = $yBound-1;
    32                         if (!(0<=$upper3)){
    33                                 throw new HException("FAIL: lower <= upper");
    34                         }
    35                         $this->cy = mt_rand(0, $upper3);
    36                         $upper4 = $xBound-1;
    37                         if (!(0<=$upper4)){
    38                                 throw new HException("FAIL: lower <= upper");
    39                         }
    40                         $this->x2 = mt_rand(0, $upper4);
    41                         $upper5 = $yBound-1;
    42                         if (!(0<=$upper5)){
    43                                 throw new HException("FAIL: lower <= upper");
    44                         }
    45                         $this->y2 = mt_rand(0, $upper5);
    46                         $this->xBound = $xBound;
    47                         $this->yBound = $yBound;
    48                 }
     16                $upper = $xBound-1;
     17                if (!(0<=$upper)){
     18                        throw new HException("FAIL: lower <= upper");
     19                }
     20                $this->x1 = mt_rand(0, $upper);
     21                $upper1 = $yBound-1;
     22                if (!(0<=$upper1)){
     23                        throw new HException("FAIL: lower <= upper");
     24                }
     25                $this->y1 = mt_rand(0, $upper1);
     26                $upper2 = $xBound-1;
     27                if (!(0<=$upper2)){
     28                        throw new HException("FAIL: lower <= upper");
     29                }
     30                $this->cx = mt_rand(0, $upper2);
     31                $upper3 = $yBound-1;
     32                if (!(0<=$upper3)){
     33                        throw new HException("FAIL: lower <= upper");
     34                }
     35                $this->cy = mt_rand(0, $upper3);
     36                $upper4 = $xBound-1;
     37                if (!(0<=$upper4)){
     38                        throw new HException("FAIL: lower <= upper");
     39                }
     40                $this->x2 = mt_rand(0, $upper4);
     41                $upper5 = $yBound-1;
     42                if (!(0<=$upper5)){
     43                        throw new HException("FAIL: lower <= upper");
     44                }
     45                $this->y2 = mt_rand(0, $upper5);
     46                $this->xBound = $xBound;
     47                $this->yBound = $yBound;
    4948        }
    5049
    5150        public function rasterize(){
    52                 $lines = (new _hx_array(array()));
    53                 $points = (new _hx_array(array()));
     51                $points = [];
    5452                $pointCount = 20;
    55                 {
    56                         $_g1 = 0;
    57                         $_g = $pointCount-1;
    58                         while ($_g1<$_g){
    59                                 $_g1 = $_g1+1;
    60                                 $i = $_g1-1;
    61                                 $t = $i/$pointCount;
    62                                 $tp = 1-$t;
    63                                 $x = intval($tp*($tp*$this->x1+$t*$this->cx)+$t*($tp*$this->cx+$t*$this->x2));
    64                                 $y = intval($tp*($tp*$this->y1+$t*$this->cy)+$t*($tp*$this->cy+$t*$this->y2));
    65                                 $points->push(_hx_anonymous(array("x" => $x, "y" => $y)));
    66                                 unset($y, $x, $tp, $t, $i);
    67                         }
    68                 }
    69                 {
    70                         $_g11 = 0;
    71                         $_g2 = $points->length-1;
    72                         while ($_g11<$_g2){
    73                                 $_g11 = $_g11+1;
    74                                 $i1 = $_g11-1;
    75                                 $p0 = $points[$i1];
    76                                 $p1 = $points[$i1+1];
    77                                 $pts = geometrize_rasterizer_Rasterizer::bresenham($p0->x, $p0->y, $p1->x, $p1->y);
    78                                 {
    79                                         $_g21 = 0;
    80                                         while ($_g21<$pts->length){
    81                                                 $point = $pts[$_g21];
    82                                                 $_g21 = $_g21+1;
    83                                                 $lines->push(new geometrize_rasterizer_Scanline($point->y, $point->x, $point->x));
    84                                                 unset($point);
    85                                         }
    86                                         unset($_g21);
    87                                 }
    88                                 unset($pts, $p1, $p0, $i1);
    89                         }
    90                 }
    91                 return geometrize_rasterizer_Scanline::trim($lines, $this->xBound, $this->yBound);
     53
     54                $_g1 = 0;
     55                $_g = $pointCount-1;
     56                while ($_g1<$_g){
     57                        $_g1 = $_g1+1;
     58                        $i = $_g1-1;
     59                        $t = $i/$pointCount;
     60                        $tp = 1-$t;
     61                        $x = intval($tp*($tp*$this->x1+$t*$this->cx)+$t*($tp*$this->cx+$t*$this->x2));
     62                        $y = intval($tp*($tp*$this->y1+$t*$this->cy)+$t*($tp*$this->cy+$t*$this->y2));
     63                        $points[] = ["x" => $x, "y" => $y];
     64                }
     65
     66                return geometrize_rasterizer_Rasterizer::scanlinesForPath($points, $this->xBound, $this->yBound);
    9267        }
    9368
     
    254229                $bezier->x2 = $this->x2;
    255230                $bezier->y2 = $this->y2;
    256                 if (isset($this->color)){
    257                         $bezier->color = $this->color;
    258                 }
     231                $bezier->color = $this->color;
     232
    259233                return $bezier;
    260234        }
    261235
    262236        public function getType(){
    263                 return 7;
    264         }
    265 
     237                return geometrize_shape_ShapeTypes::T_QUADRATIC_BEZIER;
     238        }
     239
     240        /**
     241         * @return array
     242         */
    266243        public function getRawShapeData(){
    267                 return (new _hx_array(array($this->x1, $this->y1, $this->cx, $this->cy, $this->x2, $this->y2)));
    268         }
    269 
     244                return [
     245                        $this->x1,
     246                        $this->y1,
     247                        $this->cx,
     248                        $this->cy,
     249                        $this->x2,
     250                        $this->y2
     251                ];
     252        }
     253
     254        /**
     255         * @return string
     256         */
    270257        public function getSvgShapeData(){
    271                 return "<path d=\"M" . _hx_string_rec($this->x1, "") . " " . _hx_string_rec($this->y1, "") . " Q " . _hx_string_rec($this->cx, "") . " " . _hx_string_rec($this->cy, "") . " " . _hx_string_rec($this->x2, "") . " " . _hx_string_rec($this->y2, "") . "\" " . _hx_string_or_null(geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK) . " />";
     258                return "<path d=\"M" . $this->x1 . " " . $this->y1 . " Q " . $this->cx . " " . $this->cy . " " . $this->x2 . " " . $this->y2 . "\" " . geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK . " />";
    272259        }
    273260
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Rectangle.class.php

    r115861 r115922  
    99        public $xBound;
    1010        public $yBound;
     11        public $color;
    1112
    1213        public function __construct($xBound, $yBound){
    13                 if (!php_Boot::$skip_constructor){
    14                         $this->x1 = mt_rand(0, $xBound-1);
    15                         $this->y1 = mt_rand(0, $yBound-1);
    16                         $value = $this->x1;
    17                         $value1 = $value+mt_rand(1, 32);
    18                         $max = $xBound-1;
    19                         if (!(0<=$max)){
    20                                 throw new HException("FAIL: min <= max");
    21                         }
    22                         $tmp = null;
    23                         if ($value1<0){
    24                                 $tmp = 0;
     14                $this->x1 = mt_rand(0, $xBound-1);
     15                $this->y1 = mt_rand(0, $yBound-1);
     16                $value = $this->x1;
     17                $value1 = $value+mt_rand(1, 32);
     18                $max = $xBound-1;
     19                if (!(0<=$max)){
     20                        throw new HException("FAIL: min <= max");
     21                }
     22                $tmp = null;
     23                if ($value1<0){
     24                        $tmp = 0;
     25                } else {
     26                        if ($value1>$max){
     27                                $tmp = $max;
    2528                        } else {
    26                                 if ($value1>$max){
    27                                         $tmp = $max;
    28                                 } else {
    29                                         $tmp = $value1;
    30                                 }
    31                         }
    32                         $this->x2 = $tmp;
    33                         $value2 = $this->y1;
    34                         $value3 = $value2+mt_rand(1, 32);
    35                         $max1 = $yBound-1;
    36                         if (!(0<=$max1)){
    37                                 throw new HException("FAIL: min <= max");
    38                         }
    39                         $tmp1 = null;
    40                         if ($value3<0){
    41                                 $tmp1 = 0;
     29                                $tmp = $value1;
     30                        }
     31                }
     32                $this->x2 = $tmp;
     33                $value2 = $this->y1;
     34                $value3 = $value2+mt_rand(1, 32);
     35                $max1 = $yBound-1;
     36                if (!(0<=$max1)){
     37                        throw new HException("FAIL: min <= max");
     38                }
     39                $tmp1 = null;
     40                if ($value3<0){
     41                        $tmp1 = 0;
     42                } else {
     43                        if ($value3>$max1){
     44                                $tmp1 = $max1;
    4245                        } else {
    43                                 if ($value3>$max1){
    44                                         $tmp1 = $max1;
    45                                 } else {
    46                                         $tmp1 = $value3;
    47                                 }
    48                         }
    49                         $this->y2 = $tmp1;
    50                         $this->xBound = $xBound;
    51                         $this->yBound = $yBound;
    52                 }
     46                                $tmp1 = $value3;
     47                        }
     48                }
     49                $this->y2 = $tmp1;
     50                $this->xBound = $xBound;
     51                $this->yBound = $yBound;
    5352        }
    5453
    5554        public function rasterize(){
    56                 $lines = (new _hx_array(array()));
    57                 {
    58                         $_g1 = $this->y1;
    59                         $_g = $this->y2;
    60                         while ($_g1<$_g){
    61                                 $_g1 = $_g1+1;
    62                                 $y = $_g1-1;
    63                                 if ($this->x1!==$this->x2){
    64                                         $first = $this->x1;
    65                                         $second = $this->x2;
    66                                         $tmp = null;
    67                                         if ($first<$second){
    68                                                 $tmp = $first;
    69                                         } else {
    70                                                 $tmp = $second;
    71                                         }
    72                                         $first1 = $this->x1;
    73                                         $second1 = $this->x2;
    74                                         $tmp1 = null;
    75                                         if ($first1>$second1){
    76                                                 $tmp1 = $first1;
    77                                         } else {
    78                                                 $tmp1 = $second1;
    79                                         }
    80                                         $lines->push(new geometrize_rasterizer_Scanline($y, $tmp, $tmp1));
    81                                         unset($tmp1, $tmp, $second1, $second, $first1, $first);
    82                                 }
    83                                 unset($y);
    84                         }
    85                 }
     55                list($xm1, $ym1, $xm2, $ym2) = $this->getRawShapeData();
     56
     57                $lines = [];
     58                if ($xm2>$xm1){
     59                        for ($y = $ym1; $y<=$ym2; $y++){
     60                                $lines[] = new geometrize_rasterizer_Scanline($y, $xm1, $xm2);
     61                        }
     62                }
     63
    8664                return $lines;
    8765        }
     
    198176                $rectangle->x2 = $this->x2;
    199177                $rectangle->y2 = $this->y2;
    200                 if (isset($this->color)){
    201                         $rectangle->color = $this->color;
    202                 }
     178                $rectangle->color = $this->color;
     179
    203180                return $rectangle;
    204181        }
    205182
    206183        public function getType(){
    207                 return 0;
    208         }
    209 
     184                return geometrize_shape_ShapeTypes::T_RECTANGLE;
     185        }
     186
     187        /**
     188         * @return array
     189         */
    210190        public function getRawShapeData(){
    211                 $first = $this->x1;
    212                 $second = $this->x2;
    213                 $tmp = null;
    214                 if ($first<$second){
    215                         $tmp = $first;
    216                 } else {
    217                         $tmp = $second;
    218                 }
    219                 $first1 = $this->y1;
    220                 $second1 = $this->y2;
    221                 $tmp1 = null;
    222                 if ($first1<$second1){
    223                         $tmp1 = $first1;
    224                 } else {
    225                         $tmp1 = $second1;
    226                 }
    227                 $first2 = $this->x1;
    228                 $second2 = $this->x2;
    229                 $tmp2 = null;
    230                 if ($first2>$second2){
    231                         $tmp2 = $first2;
    232                 } else {
    233                         $tmp2 = $second2;
    234                 }
    235                 $first3 = $this->y1;
    236                 $second3 = $this->y2;
    237                 $tmp3 = null;
    238                 if ($first3>$second3){
    239                         $tmp3 = $first3;
    240                 } else {
    241                         $tmp3 = $second3;
    242                 }
    243                 return (new _hx_array(array($tmp, $tmp1, $tmp2, $tmp3)));
    244         }
    245 
     191                if ($this->x1<$this->x2){
     192                        $xfirst = $this->x1;
     193                        $xsecond = $this->x2;
     194                } else {
     195                        $xfirst = $this->x2;
     196                        $xsecond = $this->x1;
     197                }
     198                if ($this->y1<$this->y2){
     199                        $yfirst = $this->y1;
     200                        $ysecond = $this->y2;
     201                } else {
     202                        $yfirst = $this->y2;
     203                        $ysecond = $this->y1;
     204                }
     205
     206                return [
     207                        $xfirst,
     208                        $yfirst,
     209                        $xsecond,
     210                        $ysecond,
     211                ];
     212        }
     213
     214        /**
     215         * @return string
     216         */
    246217        public function getSvgShapeData(){
    247                 $first = $this->x1;
    248                 $second = $this->x2;
    249                 $tmp = null;
    250                 if ($first<$second){
    251                         $tmp = $first;
    252                 } else {
    253                         $tmp = $second;
    254                 }
    255                 $first1 = $this->y1;
    256                 $second1 = $this->y2;
    257                 $tmp1 = null;
    258                 if ($first1<$second1){
    259                         $tmp1 = $first1;
    260                 } else {
    261                         $tmp1 = $second1;
    262                 }
    263                 $first2 = $this->x1;
    264                 $second2 = $this->x2;
    265                 $tmp2 = null;
    266                 if ($first2>$second2){
    267                         $tmp2 = $first2;
    268                 } else {
    269                         $tmp2 = $second2;
    270                 }
    271                 $first3 = $this->x1;
    272                 $second3 = $this->x2;
    273                 $tmp3 = null;
    274                 if ($first3<$second3){
    275                         $tmp3 = $first3;
    276                 } else {
    277                         $tmp3 = $second3;
    278                 }
    279                 $first4 = $this->y1;
    280                 $second4 = $this->y2;
    281                 $tmp4 = null;
    282                 if ($first4>$second4){
    283                         $tmp4 = $first4;
    284                 } else {
    285                         $tmp4 = $second4;
    286                 }
    287                 $first5 = $this->y1;
    288                 $second5 = $this->y2;
    289                 $tmp5 = null;
    290                 if ($first5<$second5){
    291                         $tmp5 = $first5;
    292                 } else {
    293                         $tmp5 = $second5;
    294                 }
    295                 return "<rect x=\"" . _hx_string_rec($tmp, "") . "\" y=\"" . _hx_string_rec($tmp1, "") . "\" width=\"" . _hx_string_rec(($tmp2-$tmp3), "") . "\" height=\"" . _hx_string_rec(($tmp4-$tmp5), "") . "\" " . _hx_string_or_null(geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK) . " />";
     218                list($xm1, $ym1, $xm2, $ym2) = $this->getRawShapeData();
     219                $width = $xm2 - $xm1;
     220                $height = $ym2 - $ym1;
     221                return "<rect x=\"$xm1\" y=\"$ym1\" width=\"$width\" height=\"$height\" " . geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK . " />";
    296222        }
    297223
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/RotatedEllipse.class.php

    r115861 r115922  
    1010        public $xBound;
    1111        public $yBound;
     12        public $color;
    1213
    1314        public function __construct($xBound, $yBound){
    14                 if (!php_Boot::$skip_constructor){
    15                         $this->x = mt_rand(0, $xBound-1);
    16                         $this->y = mt_rand(0, $yBound-1);
    17                         $this->rx = mt_rand(1, 32);
    18                         $this->ry = mt_rand(1, 32);
    19                         $this->angle = mt_rand(0, 359);
    20                         $this->xBound = $xBound;
    21                         $this->yBound = $yBound;
    22                 }
     15                $this->x = mt_rand(0, $xBound-1);
     16                $this->y = mt_rand(0, $yBound-1);
     17                $this->rx = mt_rand(1, 32);
     18                $this->ry = mt_rand(1, 32);
     19                $this->angle = mt_rand(0, 359);
     20                $this->xBound = $xBound;
     21                $this->yBound = $yBound;
    2322        }
    2423
    2524        public function rasterize(){
    2625                $pointCount = 20;
    27                 $points = (new _hx_array(array()));
     26                $points = [];
    2827                $rads = $this->angle*(M_PI/180.0);
    2928                $c = cos($rads);
    3029                $s = sin($rads);
    31                 {
    32                         $_g1 = 0;
    33                         $_g = $pointCount;
    34                         while ($_g1<$_g){
    35                                 $_g1 = $_g1+1;
    36                                 $i = $_g1-1;
    37                                 $rot = 360.0/$pointCount*$i*(M_PI/180.0);
    38                                 $crx = $this->rx;
    39                                 $crx1 = $crx*cos($rot);
    40                                 $cry = $this->ry;
    41                                 $cry1 = $cry*sin($rot);
    42                                 $tx = intval($crx1*$c-$cry1*$s+$this->x);
    43                                 $ty = intval($crx1*$s+$cry1*$c+$this->y);
    44                                 $points->push(_hx_anonymous(array("x" => $tx, "y" => $ty)));
    45                                 unset($ty, $tx, $rot, $i, $cry1, $cry, $crx1, $crx);
    46                         }
     30
     31                $_g1 = 0;
     32                $_g = $pointCount;
     33                while ($_g1<$_g){
     34                        $_g1 = $_g1+1;
     35                        $i = $_g1-1;
     36                        $rot = 360.0/$pointCount*$i*(M_PI/180.0);
     37                        $crx = $this->rx;
     38                        $crx1 = $crx*cos($rot);
     39                        $cry = $this->ry;
     40                        $cry1 = $cry*sin($rot);
     41                        $tx = intval($crx1*$c-$cry1*$s+$this->x);
     42                        $ty = intval($crx1*$s+$cry1*$c+$this->y);
     43                        $points[] = ["x" => $tx, "y" => $ty];
    4744                }
    48                 $tmp = geometrize_rasterizer_Rasterizer::scanlinesForPolygon($points);
    49                 return geometrize_rasterizer_Scanline::trim($tmp, $this->xBound, $this->yBound);
     45
     46                return geometrize_rasterizer_Rasterizer::scanlinesForPolygon($points, $this->xBound, $this->yBound);
    5047        }
    5148
     
    189186                $ellipse->ry = $this->ry;
    190187                $ellipse->angle = $this->angle;
    191                 if (isset($this->color)){
    192                         $ellipse->color = $this->color;
    193                 }
     188                $ellipse->color = $this->color;
     189
    194190                return $ellipse;
    195191        }
    196192
    197193        public function getType(){
    198                 return 4;
    199         }
    200 
     194                return geometrize_shape_ShapeTypes::T_ROTATED_ELLIPSE;
     195        }
     196
     197        /**
     198         * @return array
     199         */
    201200        public function getRawShapeData(){
    202                 return (new _hx_array(array($this->x, $this->y, $this->rx, $this->ry, $this->angle)));
    203         }
    204 
     201                return [
     202                        $this->x,
     203                        $this->y,
     204                        $this->rx,
     205                        $this->ry,
     206                        $this->angle
     207                ];
     208        }
     209
     210        /**
     211         * @return string
     212         */
    205213        public function getSvgShapeData(){
    206                 $s = "<g transform=\"translate(" . _hx_string_rec($this->x, "") . " " . _hx_string_rec($this->y, "") . ") rotate(" . _hx_string_rec($this->angle, "") . ") scale(" . _hx_string_rec($this->rx, "") . " " . _hx_string_rec($this->ry, "") . ")\">";
    207                 $s = _hx_string_or_null($s) . _hx_string_or_null(("<ellipse cx=\"" . _hx_string_rec(0, "") . "\" cy=\"" . _hx_string_rec(0, "") . "\" rx=\"" . _hx_string_rec(1, "") . "\" ry=\"" . _hx_string_rec(1, "") . "\" " . _hx_string_or_null(geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK) . " />"));
    208                 $s = _hx_string_or_null($s) . "</g>";
     214                $s = "<g transform=\"translate(" . $this->x . " " . $this->y . ") rotate(" . $this->angle . ") scale(" . $this->rx . " " . $this->ry . ")\">";
     215                $s .= "<ellipse cx=\"" . 0 . "\" cy=\"" . 0 . "\" rx=\"" . 1 . "\" ry=\"" . 1 . "\" " . geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK . " />";
     216                $s .= "</g>";
    209217                return $s;
    210218        }
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/RotatedRectangle.class.php

    r115861 r115922  
    1010        public $xBound;
    1111        public $yBound;
     12        public $color;
    1213
    1314        public function __construct($xBound, $yBound){
    14                 if (!php_Boot::$skip_constructor){
    15                         $this->x1 = mt_rand(0, $xBound-1);
    16                         $this->y1 = mt_rand(0, $yBound-1);
    17                         $value = $this->x1;
    18                         $value1 = $value+mt_rand(1, 32);
    19                         if (!(0<=$xBound)){
    20                                 throw new HException("FAIL: min <= max");
     15                $this->x1 = mt_rand(0, $xBound-1);
     16                $this->y1 = mt_rand(0, $yBound-1);
     17                $value = $this->x1;
     18                $value1 = $value+mt_rand(1, 32);
     19                if (!(0<=$xBound)){
     20                        throw new HException("FAIL: min <= max");
     21                }
     22                $tmp = null;
     23                if ($value1<0){
     24                        $tmp = 0;
     25                } else {
     26                        if ($value1>$xBound){
     27                                $tmp = $xBound;
     28                        } else {
     29                                $tmp = $value1;
    2130                        }
    22                         $tmp = null;
    23                         if ($value1<0){
    24                                 $tmp = 0;
     31                }
     32                $this->x2 = $tmp;
     33                $value2 = $this->y1;
     34                $value3 = $value2+mt_rand(1, 32);
     35                if (!(0<=$yBound)){
     36                        throw new HException("FAIL: min <= max");
     37                }
     38                $tmp1 = null;
     39                if ($value3<0){
     40                        $tmp1 = 0;
     41                } else {
     42                        if ($value3>$yBound){
     43                                $tmp1 = $yBound;
    2544                        } else {
    26                                 if ($value1>$xBound){
    27                                         $tmp = $xBound;
    28                                 } else {
    29                                         $tmp = $value1;
    30                                 }
     45                                $tmp1 = $value3;
    3146                        }
    32                         $this->x2 = $tmp;
    33                         $value2 = $this->y1;
    34                         $value3 = $value2+mt_rand(1, 32);
    35                         if (!(0<=$yBound)){
    36                                 throw new HException("FAIL: min <= max");
    37                         }
    38                         $tmp1 = null;
    39                         if ($value3<0){
    40                                 $tmp1 = 0;
    41                         } else {
    42                                 if ($value3>$yBound){
    43                                         $tmp1 = $yBound;
    44                                 } else {
    45                                         $tmp1 = $value3;
    46                                 }
    47                         }
    48                         $this->y2 = $tmp1;
    49                         if (!true){
    50                                 throw new HException("FAIL: lower <= upper");
    51                         }
    52                         $this->angle = mt_rand(0, 360);
    53                         $this->xBound = $xBound;
    54                         $this->yBound = $yBound;
    55                 }
     47                }
     48                $this->y2 = $tmp1;
     49                if (!true){
     50                        throw new HException("FAIL: lower <= upper");
     51                }
     52                $this->angle = mt_rand(0, 360);
     53                $this->xBound = $xBound;
     54                $this->yBound = $yBound;
    5655        }
    5756
    5857        public function rasterize(){
    59                 $first = $this->x1;
    60                 $second = $this->x2;
    61                 $xm1 = null;
    62                 if ($first<$second){
    63                         $xm1 = $first;
    64                 } else {
    65                         $xm1 = $second;
    66                 }
    67                 $first1 = $this->x1;
    68                 $second1 = $this->x2;
    69                 $xm2 = null;
    70                 if ($first1>$second1){
    71                         $xm2 = $first1;
    72                 } else {
    73                         $xm2 = $second1;
    74                 }
    75                 $first2 = $this->y1;
    76                 $second2 = $this->y2;
    77                 $ym1 = null;
    78                 if ($first2<$second2){
    79                         $ym1 = $first2;
    80                 } else {
    81                         $ym1 = $second2;
    82                 }
    83                 $first3 = $this->y1;
    84                 $second3 = $this->y2;
    85                 $ym2 = null;
    86                 if ($first3>$second3){
    87                         $ym2 = $first3;
    88                 } else {
    89                         $ym2 = $second3;
    90                 }
     58                $points = $this->getCornerPoints();
     59                return geometrize_rasterizer_Rasterizer::scanlinesForPolygon($points, $this->xBound, $this->yBound);
     60        }
     61
     62        public function mutate(){
     63                $r = mt_rand(0, 2);
     64                switch ($r) {
     65                        case 0:
     66                                {
     67                                        $value = $this->x1;
     68                                        if (!true){
     69                                                throw new HException("FAIL: lower <= upper");
     70                                        }
     71                                        $value1 = $value+mt_rand(-16, +16);
     72                                        $max = $this->xBound-1;
     73                                        if (!(0<=$max)){
     74                                                throw new HException("FAIL: min <= max");
     75                                        }
     76                                        $tmp = null;
     77                                        if ($value1<0){
     78                                                $tmp = 0;
     79                                        } else {
     80                                                if ($value1>$max){
     81                                                        $tmp = $max;
     82                                                } else {
     83                                                        $tmp = $value1;
     84                                                }
     85                                        }
     86                                        $this->x1 = $tmp;
     87                                        $value2 = $this->y1;
     88                                        if (!true){
     89                                                throw new HException("FAIL: lower <= upper");
     90                                        }
     91                                        $value3 = $value2+mt_rand(-16, +16);
     92                                        $max1 = $this->yBound-1;
     93                                        if (!(0<=$max1)){
     94                                                throw new HException("FAIL: min <= max");
     95                                        }
     96                                        $tmp1 = null;
     97                                        if ($value3<0){
     98                                                $tmp1 = 0;
     99                                        } else {
     100                                                if ($value3>$max1){
     101                                                        $tmp1 = $max1;
     102                                                } else {
     103                                                        $tmp1 = $value3;
     104                                                }
     105                                        }
     106                                        $this->y1 = $tmp1;
     107                                }
     108                                break;
     109                        case 1:
     110                                {
     111                                        $value4 = $this->x2;
     112                                        if (!true){
     113                                                throw new HException("FAIL: lower <= upper");
     114                                        }
     115                                        $value5 = $value4+mt_rand(-16, +16);
     116                                        $max2 = $this->xBound-1;
     117                                        if (!(0<=$max2)){
     118                                                throw new HException("FAIL: min <= max");
     119                                        }
     120                                        $tmp2 = null;
     121                                        if ($value5<0){
     122                                                $tmp2 = 0;
     123                                        } else {
     124                                                if ($value5>$max2){
     125                                                        $tmp2 = $max2;
     126                                                } else {
     127                                                        $tmp2 = $value5;
     128                                                }
     129                                        }
     130                                        $this->x2 = $tmp2;
     131                                        $value6 = $this->y2;
     132                                        if (!true){
     133                                                throw new HException("FAIL: lower <= upper");
     134                                        }
     135                                        $value7 = $value6+mt_rand(-16, +16);
     136                                        $max3 = $this->yBound-1;
     137                                        if (!(0<=$max3)){
     138                                                throw new HException("FAIL: min <= max");
     139                                        }
     140                                        $tmp3 = null;
     141                                        if ($value7<0){
     142                                                $tmp3 = 0;
     143                                        } else {
     144                                                if ($value7>$max3){
     145                                                        $tmp3 = $max3;
     146                                                } else {
     147                                                        $tmp3 = $value7;
     148                                                }
     149                                        }
     150                                        $this->y2 = $tmp3;
     151                                }
     152                                break;
     153                        case 2:
     154                                {
     155                                        $value8 = $this->angle;
     156                                        if (!true){
     157                                                throw new HException("FAIL: lower <= upper");
     158                                        }
     159                                        $value9 = $value8+mt_rand(-4, +4);
     160                                        if (!true){
     161                                                throw new HException("FAIL: min <= max");
     162                                        }
     163                                        $tmp4 = null;
     164                                        if ($value9<0){
     165                                                $tmp4 = 0;
     166                                        } else {
     167                                                if ($value9>360){
     168                                                        $tmp4 = 360;
     169                                                } else {
     170                                                        $tmp4 = $value9;
     171                                                }
     172                                        }
     173                                        $this->angle = $tmp4;
     174                                }
     175                                break;
     176                }
     177        }
     178
     179        public function rescale($xBound, $yBound){
     180                $xScale = ($xBound-1) / ($this->xBound-1);
     181                $yScale = ($yBound-1) / ($this->yBound-1);
     182                $this->xBound = $xBound;
     183                $this->yBound = $yBound;
     184                $this->x1 = intval(round($this->x1*$xScale));
     185                $this->y1 = intval(round($this->y1*$yScale));
     186                $this->x2 = intval(round($this->x2*$xScale));
     187                $this->y2 = intval(round($this->y2*$yScale));
     188        }
     189
     190        public function hclone(){
     191                $rectangle = new geometrize_shape_RotatedRectangle($this->xBound, $this->yBound);
     192                $rectangle->x1 = $this->x1;
     193                $rectangle->y1 = $this->y1;
     194                $rectangle->x2 = $this->x2;
     195                $rectangle->y2 = $this->y2;
     196                $rectangle->angle = $this->angle;
     197                $rectangle->color = $this->color;
     198
     199                return $rectangle;
     200        }
     201
     202        public function getType(){
     203                return geometrize_shape_ShapeTypes::T_ROTATED_RECTANGLE;
     204        }
     205
     206        /**
     207         * @return array
     208         */
     209        public function getRawShapeData(){
     210                if ($this->x1<$this->x2){
     211                        $xfirst = $this->x1;
     212                        $xsecond = $this->x2;
     213                } else {
     214                        $xfirst = $this->x2;
     215                        $xsecond = $this->x1;
     216                }
     217                if ($this->y1<$this->y2){
     218                        $yfirst = $this->y1;
     219                        $ysecond = $this->y2;
     220                } else {
     221                        $yfirst = $this->y2;
     222                        $ysecond = $this->y1;
     223                }
     224
     225                return [
     226                        $xfirst,
     227                        $yfirst,
     228                        $xsecond,
     229                        $ysecond,
     230                        $this->angle
     231                ];
     232        }
     233
     234        /**
     235         * @return string
     236         */
     237        public function getSvgShapeData(){
     238                $points = $this->getCornerPoints();
     239                return geometrize_exporter_SvgExporter::exportPolygon($points);
     240        }
     241
     242        /**
     243         * @return array
     244         */
     245        public function getCornerPoints(){
     246                list($xm1, $ym1, $xm2, $ym2, $angle) = $this->getRawShapeData();
     247
    91248                $cx = intval(($xm1+$xm2)/2);
    92249                $cy = intval(($ym1+$ym2)/2);
     
    106263                $brx = intval($ox2*$c-$oy2*$s+$cx);
    107264                $bry = intval($ox2*$s+$oy2*$c+$cy);
    108                 $tmp = geometrize_rasterizer_Rasterizer::scanlinesForPolygon((new _hx_array(array(_hx_anonymous(array("x" => $ulx, "y" => $uly)), _hx_anonymous(array("x" => $urx, "y" => $ury)), _hx_anonymous(array("x" => $brx, "y" => $bry)), _hx_anonymous(array("x" => $blx, "y" => $bly))))));
    109                 return geometrize_rasterizer_Scanline::trim($tmp, $this->xBound, $this->yBound);
    110         }
    111 
    112         public function mutate(){
    113                 $r = mt_rand(0, 2);
    114                 switch ($r) {
    115                         case 0:
    116                                 {
    117                                         $value = $this->x1;
    118                                         if (!true){
    119                                                 throw new HException("FAIL: lower <= upper");
    120                                         }
    121                                         $value1 = $value+mt_rand(-16, +16);
    122                                         $max = $this->xBound-1;
    123                                         if (!(0<=$max)){
    124                                                 throw new HException("FAIL: min <= max");
    125                                         }
    126                                         $tmp = null;
    127                                         if ($value1<0){
    128                                                 $tmp = 0;
    129                                         } else {
    130                                                 if ($value1>$max){
    131                                                         $tmp = $max;
    132                                                 } else {
    133                                                         $tmp = $value1;
    134                                                 }
    135                                         }
    136                                         $this->x1 = $tmp;
    137                                         $value2 = $this->y1;
    138                                         if (!true){
    139                                                 throw new HException("FAIL: lower <= upper");
    140                                         }
    141                                         $value3 = $value2+mt_rand(-16, +16);
    142                                         $max1 = $this->yBound-1;
    143                                         if (!(0<=$max1)){
    144                                                 throw new HException("FAIL: min <= max");
    145                                         }
    146                                         $tmp1 = null;
    147                                         if ($value3<0){
    148                                                 $tmp1 = 0;
    149                                         } else {
    150                                                 if ($value3>$max1){
    151                                                         $tmp1 = $max1;
    152                                                 } else {
    153                                                         $tmp1 = $value3;
    154                                                 }
    155                                         }
    156                                         $this->y1 = $tmp1;
    157                                 }
    158                                 break;
    159                         case 1:
    160                                 {
    161                                         $value4 = $this->x2;
    162                                         if (!true){
    163                                                 throw new HException("FAIL: lower <= upper");
    164                                         }
    165                                         $value5 = $value4+mt_rand(-16, +16);
    166                                         $max2 = $this->xBound-1;
    167                                         if (!(0<=$max2)){
    168                                                 throw new HException("FAIL: min <= max");
    169                                         }
    170                                         $tmp2 = null;
    171                                         if ($value5<0){
    172                                                 $tmp2 = 0;
    173                                         } else {
    174                                                 if ($value5>$max2){
    175                                                         $tmp2 = $max2;
    176                                                 } else {
    177                                                         $tmp2 = $value5;
    178                                                 }
    179                                         }
    180                                         $this->x2 = $tmp2;
    181                                         $value6 = $this->y2;
    182                                         if (!true){
    183                                                 throw new HException("FAIL: lower <= upper");
    184                                         }
    185                                         $value7 = $value6+mt_rand(-16, +16);
    186                                         $max3 = $this->yBound-1;
    187                                         if (!(0<=$max3)){
    188                                                 throw new HException("FAIL: min <= max");
    189                                         }
    190                                         $tmp3 = null;
    191                                         if ($value7<0){
    192                                                 $tmp3 = 0;
    193                                         } else {
    194                                                 if ($value7>$max3){
    195                                                         $tmp3 = $max3;
    196                                                 } else {
    197                                                         $tmp3 = $value7;
    198                                                 }
    199                                         }
    200                                         $this->y2 = $tmp3;
    201                                 }
    202                                 break;
    203                         case 2:
    204                                 {
    205                                         $value8 = $this->angle;
    206                                         if (!true){
    207                                                 throw new HException("FAIL: lower <= upper");
    208                                         }
    209                                         $value9 = $value8+mt_rand(-4, +4);
    210                                         if (!true){
    211                                                 throw new HException("FAIL: min <= max");
    212                                         }
    213                                         $tmp4 = null;
    214                                         if ($value9<0){
    215                                                 $tmp4 = 0;
    216                                         } else {
    217                                                 if ($value9>360){
    218                                                         $tmp4 = 360;
    219                                                 } else {
    220                                                         $tmp4 = $value9;
    221                                                 }
    222                                         }
    223                                         $this->angle = $tmp4;
    224                                 }
    225                                 break;
    226                 }
    227         }
    228 
    229         public function rescale($xBound, $yBound){
    230                 $xScale = ($xBound-1) / ($this->xBound-1);
    231                 $yScale = ($yBound-1) / ($this->yBound-1);
    232                 $this->xBound = $xBound;
    233                 $this->yBound = $yBound;
    234                 $this->x1 = intval(round($this->x1*$xScale));
    235                 $this->y1 = intval(round($this->y1*$yScale));
    236                 $this->x2 = intval(round($this->x2*$xScale));
    237                 $this->y2 = intval(round($this->y2*$yScale));
    238         }
    239 
    240         public function hclone(){
    241                 $rectangle = new geometrize_shape_RotatedRectangle($this->xBound, $this->yBound);
    242                 $rectangle->x1 = $this->x1;
    243                 $rectangle->y1 = $this->y1;
    244                 $rectangle->x2 = $this->x2;
    245                 $rectangle->y2 = $this->y2;
    246                 $rectangle->angle = $this->angle;
    247                 if (isset($this->color)){
    248                         $rectangle->color = $this->color;
    249                 }
    250                 return $rectangle;
    251         }
    252 
    253         public function getType(){
    254                 return 1;
    255         }
    256 
    257         public function getRawShapeData(){
    258                 $first = $this->x1;
    259                 $second = $this->x2;
    260                 $tmp = null;
    261                 if ($first<$second){
    262                         $tmp = $first;
    263                 } else {
    264                         $tmp = $second;
    265                 }
    266                 $first1 = $this->y1;
    267                 $second1 = $this->y2;
    268                 $tmp1 = null;
    269                 if ($first1<$second1){
    270                         $tmp1 = $first1;
    271                 } else {
    272                         $tmp1 = $second1;
    273                 }
    274                 $first2 = $this->x1;
    275                 $second2 = $this->x2;
    276                 $tmp2 = null;
    277                 if ($first2>$second2){
    278                         $tmp2 = $first2;
    279                 } else {
    280                         $tmp2 = $second2;
    281                 }
    282                 $first3 = $this->y1;
    283                 $second3 = $this->y2;
    284                 $tmp3 = null;
    285                 if ($first3>$second3){
    286                         $tmp3 = $first3;
    287                 } else {
    288                         $tmp3 = $second3;
    289                 }
    290                 return (new _hx_array(array($tmp, $tmp1, $tmp2, $tmp3, $this->angle)));
    291         }
    292 
    293         public function getSvgShapeData(){
    294                 $first = $this->x1;
    295                 $second = $this->x2;
    296                 $xm1 = null;
    297                 if ($first<$second){
    298                         $xm1 = $first;
    299                 } else {
    300                         $xm1 = $second;
    301                 }
    302                 $first1 = $this->x1;
    303                 $second1 = $this->x2;
    304                 $xm2 = null;
    305                 if ($first1>$second1){
    306                         $xm2 = $first1;
    307                 } else {
    308                         $xm2 = $second1;
    309                 }
    310                 $first2 = $this->y1;
    311                 $second2 = $this->y2;
    312                 $ym1 = null;
    313                 if ($first2<$second2){
    314                         $ym1 = $first2;
    315                 } else {
    316                         $ym1 = $second2;
    317                 }
    318                 $first3 = $this->y1;
    319                 $second3 = $this->y2;
    320                 $ym2 = null;
    321                 if ($first3>$second3){
    322                         $ym2 = $first3;
    323                 } else {
    324                         $ym2 = $second3;
    325                 }
    326                 $cx = intval(($xm1+$xm2)/2);
    327                 $cy = intval(($ym1+$ym2)/2);
    328                 $ox1 = $xm1-$cx;
    329                 $ox2 = $xm2-$cx;
    330                 $oy1 = $ym1-$cy;
    331                 $oy2 = $ym2-$cy;
    332                 $rads = $this->angle*M_PI/180.0;
    333                 $c = cos($rads);
    334                 $s = sin($rads);
    335                 $ulx = intval($ox1*$c-$oy1*$s+$cx);
    336                 $uly = intval($ox1*$s+$oy1*$c+$cy);
    337                 $blx = intval($ox1*$c-$oy2*$s+$cx);
    338                 $bly = intval($ox1*$s+$oy2*$c+$cy);
    339                 $urx = intval($ox2*$c-$oy1*$s+$cx);
    340                 $ury = intval($ox2*$s+$oy1*$c+$cy);
    341                 $brx = intval($ox2*$c-$oy2*$s+$cx);
    342                 $bry = intval($ox2*$s+$oy2*$c+$cy);
    343                 $points = (new _hx_array(array(_hx_anonymous(array("x" => $ulx, "y" => $uly)), _hx_anonymous(array("x" => $urx, "y" => $ury)), _hx_anonymous(array("x" => $brx, "y" => $bry)), _hx_anonymous(array("x" => $blx, "y" => $bly)))));
    344                 $s1 = "<polygon points=\"";
    345                 {
    346                         $_g1 = 0;
    347                         $_g = $points->length;
    348                         while ($_g1<$_g){
    349                                 $_g1 = $_g1+1;
    350                                 $i = $_g1-1;
    351                                 $s1 = _hx_string_or_null($s1) . _hx_string_or_null((_hx_string_rec(_hx_array_get($points, $i)->x, "") . " " . _hx_string_rec(_hx_array_get($points, $i)->y, "")));
    352                                 if ($i!==$points->length-1){
    353                                         $s1 = _hx_string_or_null($s1) . " ";
    354                                 }
    355                                 unset($i);
    356                         }
    357                 }
    358                 $s1 = _hx_string_or_null($s1) . _hx_string_or_null(("\" " . _hx_string_or_null(geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK) . "/>"));
    359                 return $s1;
    360         }
    361 
    362         public function getCornerPoints(){
    363                 $first = $this->x1;
    364                 $second = $this->x2;
    365                 $xm1 = null;
    366                 if ($first<$second){
    367                         $xm1 = $first;
    368                 } else {
    369                         $xm1 = $second;
    370                 }
    371                 $first1 = $this->x1;
    372                 $second1 = $this->x2;
    373                 $xm2 = null;
    374                 if ($first1>$second1){
    375                         $xm2 = $first1;
    376                 } else {
    377                         $xm2 = $second1;
    378                 }
    379                 $first2 = $this->y1;
    380                 $second2 = $this->y2;
    381                 $ym1 = null;
    382                 if ($first2<$second2){
    383                         $ym1 = $first2;
    384                 } else {
    385                         $ym1 = $second2;
    386                 }
    387                 $first3 = $this->y1;
    388                 $second3 = $this->y2;
    389                 $ym2 = null;
    390                 if ($first3>$second3){
    391                         $ym2 = $first3;
    392                 } else {
    393                         $ym2 = $second3;
    394                 }
    395                 $cx = intval(($xm1+$xm2)/2);
    396                 $cy = intval(($ym1+$ym2)/2);
    397                 $ox1 = $xm1-$cx;
    398                 $ox2 = $xm2-$cx;
    399                 $oy1 = $ym1-$cy;
    400                 $oy2 = $ym2-$cy;
    401                 $rads = $this->angle*M_PI/180.0;
    402                 $c = cos($rads);
    403                 $s = sin($rads);
    404                 $ulx = intval($ox1*$c-$oy1*$s+$cx);
    405                 $uly = intval($ox1*$s+$oy1*$c+$cy);
    406                 $blx = intval($ox1*$c-$oy2*$s+$cx);
    407                 $bly = intval($ox1*$s+$oy2*$c+$cy);
    408                 $urx = intval($ox2*$c-$oy1*$s+$cx);
    409                 $ury = intval($ox2*$s+$oy1*$c+$cy);
    410                 $brx = intval($ox2*$c-$oy2*$s+$cx);
    411                 $bry = intval($ox2*$s+$oy2*$c+$cy);
    412                 return (new _hx_array(array(_hx_anonymous(array("x" => $ulx, "y" => $uly)), _hx_anonymous(array("x" => $urx, "y" => $ury)), _hx_anonymous(array("x" => $brx, "y" => $bry)), _hx_anonymous(array("x" => $blx, "y" => $bly)))));
     265
     266                $corners = [
     267                        ["x" => $ulx, "y" => $uly],
     268                        ["x" => $urx, "y" => $ury],
     269                        ["x" => $brx, "y" => $bry],
     270                        ["x" => $blx, "y" => $bly]
     271                ];
     272                return $corners;
    413273        }
    414274
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/ShapeFactory.class.php

    r115850 r115922  
    88        static function create($type, $xBound, $yBound){
    99                switch ($type) {
    10                         case 0:
    11                                 {
    12                                         return new geometrize_shape_Rectangle($xBound, $yBound);
    13                                 }
     10                        case geometrize_shape_ShapeTypes::T_RECTANGLE:
     11                                return new geometrize_shape_Rectangle($xBound, $yBound);
    1412                                break;
    15                         case 1:
    16                                 {
    17                                         return new geometrize_shape_RotatedRectangle($xBound, $yBound);
    18                                 }
     13                        case geometrize_shape_ShapeTypes::T_ROTATED_RECTANGLE:
     14                                return new geometrize_shape_RotatedRectangle($xBound, $yBound);
    1915                                break;
    20                         case 2:
    21                                 {
    22                                         return new geometrize_shape_Triangle($xBound, $yBound);
    23                                 }
     16                        case geometrize_shape_ShapeTypes::T_TRIANGLE:
     17                                return new geometrize_shape_Triangle($xBound, $yBound);
    2418                                break;
    25                         case 3:
    26                                 {
    27                                         return new geometrize_shape_Ellipse($xBound, $yBound);
    28                                 }
     19                        case geometrize_shape_ShapeTypes::T_ELLIPSE:
     20                                return new geometrize_shape_Ellipse($xBound, $yBound);
    2921                                break;
    30                         case 4:
    31                                 {
    32                                         return new geometrize_shape_RotatedEllipse($xBound, $yBound);
    33                                 }
     22                        case geometrize_shape_ShapeTypes::T_ROTATED_ELLIPSE:
     23                                return new geometrize_shape_RotatedEllipse($xBound, $yBound);
    3424                                break;
    35                         case 5:
    36                                 {
    37                                         return new geometrize_shape_Circle($xBound, $yBound);
    38                                 }
     25                        case geometrize_shape_ShapeTypes::T_CIRCLE:
     26                                return new geometrize_shape_Circle($xBound, $yBound);
    3927                                break;
    40                         case 6:
    41                                 {
    42                                         return new geometrize_shape_Line($xBound, $yBound);
    43                                 }
     28                        case geometrize_shape_ShapeTypes::T_LINE:
     29                                return new geometrize_shape_Line($xBound, $yBound);
    4430                                break;
    45                         case 7:
    46                                 {
    47                                         return new geometrize_shape_QuadraticBezier($xBound, $yBound);
    48                                 }
     31                        case geometrize_shape_ShapeTypes::T_QUADRATIC_BEZIER:
     32                                return new geometrize_shape_QuadraticBezier($xBound, $yBound);
    4933                                break;
    5034                }
     
    5236
    5337        static function randomShape($xBound, $yBound){
    54                 $a = (new _hx_array(array(0, 1, 2, 3, 4, 5, 6, 7)));
    55                 $tmp = null;
    56                 if ($a!==null){
    57                         $tmp = $a->length>0;
    58                 } else {
    59                         $tmp = false;
    60                 }
    61                 if (!$tmp){
    62                         throw new HException("FAIL: a != null && a.length > 0");
    63                 }
    64                 $upper = $a->length-1;
    65                 if (!(0<=$upper)){
    66                         throw new HException("FAIL: lower <= upper");
    67                 }
    68                 return geometrize_shape_ShapeFactory::create($a[mt_rand(0, $upper)], $xBound, $yBound);
     38                $a = [
     39                        geometrize_shape_ShapeTypes::T_RECTANGLE,
     40                        geometrize_shape_ShapeTypes::T_ROTATED_RECTANGLE,
     41                        geometrize_shape_ShapeTypes::T_TRIANGLE,
     42                        geometrize_shape_ShapeTypes::T_ELLIPSE,
     43                        geometrize_shape_ShapeTypes::T_ROTATED_ELLIPSE,
     44                        geometrize_shape_ShapeTypes::T_CIRCLE,
     45                        geometrize_shape_ShapeTypes::T_LINE,
     46                        geometrize_shape_ShapeTypes::T_QUADRATIC_BEZIER,
     47                ];
     48                return geometrize_shape_ShapeFactory::randomShapeOf($a, $xBound, $yBound);
    6949        }
    7050
    7151        static function randomShapeOf($types, $xBound, $yBound){
    72                 $tmp = null;
    73                 if ($types!==null){
    74                         $tmp = $types->length>0;
    75                 } else {
    76                         $tmp = false;
     52                if (!is_array($types) || !count($types)){
     53                        throw new HException("FAIL: types != null && count(types) > 0");
    7754                }
    78                 if (!$tmp){
    79                         throw new HException("FAIL: a != null && a.length > 0");
    80                 }
    81                 $upper = $types->length-1;
    82                 if (!(0<=$upper)){
    83                         throw new HException("FAIL: lower <= upper");
    84                 }
    85                 return geometrize_shape_ShapeFactory::create($types[mt_rand(0, $upper)], $xBound, $yBound);
     55                return geometrize_shape_ShapeFactory::create($types[mt_rand(0, count($types)-1)], $xBound, $yBound);
    8656        }
    8757
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/ShapeTypes.class.php

    r115850 r115922  
    66        }
    77
    8         static $RECTANGLE;
    9         static $ROTATED_RECTANGLE;
    10         static $TRIANGLE;
    11         static $ELLIPSE;
    12         static $ROTATED_ELLIPSE;
    13         static $CIRCLE;
    14         static $LINE;
    15         static $QUADRATIC_BEZIER;
     8        const T_RECTANGLE = 0;
     9        const T_ROTATED_RECTANGLE = 1;
     10        const T_TRIANGLE = 2;
     11        const T_ELLIPSE = 3;
     12        const T_ROTATED_ELLIPSE = 4;
     13        const T_CIRCLE = 5;
     14        const T_LINE = 6;
     15        const T_QUADRATIC_BEZIER = 7;
    1616
    1717        function __toString(){
     
    1919        }
    2020}
    21 
    22 geometrize_shape_ShapeTypes::$RECTANGLE = 0;
    23 geometrize_shape_ShapeTypes::$ROTATED_RECTANGLE = 1;
    24 geometrize_shape_ShapeTypes::$TRIANGLE = 2;
    25 geometrize_shape_ShapeTypes::$ELLIPSE = 3;
    26 geometrize_shape_ShapeTypes::$ROTATED_ELLIPSE = 4;
    27 geometrize_shape_ShapeTypes::$CIRCLE = 5;
    28 geometrize_shape_ShapeTypes::$LINE = 6;
    29 geometrize_shape_ShapeTypes::$QUADRATIC_BEZIER = 7;
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Triangle.class.php

    r115861 r115922  
    33// Generated by Haxe 3.4.7
    44class geometrize_shape_Triangle implements geometrize_shape_Shape {
    5         public $x1;
    6         public $y1;
    7         public $x2;
    8         public $y2;
    9         public $x3;
    10         public $y3;
    11         public $xBound;
    12         public $yBound;
     5
     6        /**
     7         * @var int
     8         */
     9        protected $x1;
     10
     11        /**
     12         * @var int
     13         */
     14        protected $y1;
     15
     16        /**
     17         * @var int
     18         */
     19        protected $x2;
     20
     21        /**
     22         * @var int
     23         */
     24        protected $y2;
     25
     26        /**
     27         * @var int
     28         */
     29        protected $x3;
     30
     31        /**
     32         * @var int
     33         */
     34        protected $y3;
     35
     36        /**
     37         * @var int
     38         */
     39        protected $xBound;
     40
     41        /**
     42         * @var int
     43         */
     44        protected $yBound;
     45
     46        /**
     47         * @var int
     48         */
     49        public $color;
     50
     51        /**
     52         * Rasterized lines
     53         * @var null|array
     54         */
     55        protected $lines = null;
    1356
    1457        public function __construct($xBound, $yBound){
    15                 if (!php_Boot::$skip_constructor){
    16                         $this->x1 = mt_rand(0, $xBound-1);
    17                         $this->y1 = mt_rand(0, $yBound-1);
    18                         $tmp = $this->x1;
    19                         if (!true){
    20                                 throw new HException("FAIL: lower <= upper");
    21                         }
    22                         $this->x2 = $tmp+mt_rand(-16, +16);
    23                         $tmp1 = $this->y1;
    24                         if (!true){
    25                                 throw new HException("FAIL: lower <= upper");
    26                         }
    27                         $this->y2 = $tmp1+mt_rand(-16, +16);
    28                         $tmp2 = $this->x1;
    29                         if (!true){
    30                                 throw new HException("FAIL: lower <= upper");
    31                         }
    32                         $this->x3 = $tmp2+mt_rand(-16, +16);
    33                         $tmp3 = $this->y1;
    34                         if (!true){
    35                                 throw new HException("FAIL: lower <= upper");
    36                         }
    37                         $this->y3 = $tmp3+mt_rand(-16, +16);
    38                         $this->xBound = $xBound;
    39                         $this->yBound = $yBound;
    40                 }
    41         }
    42 
     58                $this->x1 = mt_rand(0, $xBound-1);
     59                $this->y1 = mt_rand(0, $yBound-1);
     60                $this->x2 = $this->x1 + mt_rand(-16, +16);
     61                $this->y2 = $this->y1 + mt_rand(-16, +16);
     62                $this->x3 = $this->x1 + mt_rand(-16, +16);
     63                $this->y3 = $this->y1 + mt_rand(-16, +16);
     64
     65                $this->xBound = $xBound;
     66                $this->yBound = $yBound;
     67        }
     68
     69        /**
     70         * Rasterize the shape
     71         * @return array
     72         * @throws HException
     73         */
    4374        public function rasterize(){
    44                 $tmp = geometrize_rasterizer_Rasterizer::scanlinesForPolygon((new _hx_array(array(_hx_anonymous(array("x" => $this->x1, "y" => $this->y1)), _hx_anonymous(array("x" => $this->x2, "y" => $this->y2)), _hx_anonymous(array("x" => $this->x3, "y" => $this->y3))))));
    45                 return geometrize_rasterizer_Scanline::trim($tmp, $this->xBound, $this->yBound);
    46         }
    47 
     75                if (!$this->lines) {
     76                        $points = [
     77                                ["x" => $this->x1, "y" => $this->y1],
     78                                ["x" => $this->x2, "y" => $this->y2],
     79                                ["x" => $this->x3, "y" => $this->y3],
     80                        ];
     81                        $this->lines = geometrize_rasterizer_Rasterizer::scanlinesForPolygon($points, $this->xBound, $this->yBound);
     82                }
     83
     84                return $this->lines;
     85        }
     86
     87        /**
     88         * Mutate the shape
     89         * @throws HException
     90         */
    4891        public function mutate(){
    4992                $r = mt_rand(0, 2);
     93
    5094                switch ($r) {
    5195                        case 0:
    52                                 {
    53                                         $value = $this->x1;
    54                                         if (!true){
    55                                                 throw new HException("FAIL: lower <= upper");
    56                                         }
    57                                         $value1 = $value+mt_rand(-16, +16);
    58                                         $max = $this->xBound-1;
    59                                         if (!(0<=$max)){
    60                                                 throw new HException("FAIL: min <= max");
    61                                         }
    62                                         $tmp = null;
    63                                         if ($value1<0){
    64                                                 $tmp = 0;
    65                                         } else {
    66                                                 if ($value1>$max){
    67                                                         $tmp = $max;
    68                                                 } else {
    69                                                         $tmp = $value1;
    70                                                 }
    71                                         }
    72                                         $this->x1 = $tmp;
    73                                         $value2 = $this->y1;
    74                                         if (!true){
    75                                                 throw new HException("FAIL: lower <= upper");
    76                                         }
    77                                         $value3 = $value2+mt_rand(-16, +16);
    78                                         $max1 = $this->yBound-1;
    79                                         if (!(0<=$max1)){
    80                                                 throw new HException("FAIL: min <= max");
    81                                         }
    82                                         $tmp1 = null;
    83                                         if ($value3<0){
    84                                                 $tmp1 = 0;
    85                                         } else {
    86                                                 if ($value3>$max1){
    87                                                         $tmp1 = $max1;
    88                                                 } else {
    89                                                         $tmp1 = $value3;
    90                                                 }
    91                                         }
    92                                         $this->y1 = $tmp1;
    93                                 }
     96                                $this->x1 += mt_rand(-16, +16);
     97                                #$this->x1 = max(min($this->x1, $this->xBound-1),0);
     98                                $this->y1 += mt_rand(-16, +16);
     99                                #$this->y1 = max(min($this->y1, $this->yBound-1),0);
    94100                                break;
     101
    95102                        case 1:
    96                                 {
    97                                         $value4 = $this->x2;
    98                                         if (!true){
    99                                                 throw new HException("FAIL: lower <= upper");
    100                                         }
    101                                         $value5 = $value4+mt_rand(-16, +16);
    102                                         $max2 = $this->xBound-1;
    103                                         if (!(0<=$max2)){
    104                                                 throw new HException("FAIL: min <= max");
    105                                         }
    106                                         $tmp2 = null;
    107                                         if ($value5<0){
    108                                                 $tmp2 = 0;
    109                                         } else {
    110                                                 if ($value5>$max2){
    111                                                         $tmp2 = $max2;
    112                                                 } else {
    113                                                         $tmp2 = $value5;
    114                                                 }
    115                                         }
    116                                         $this->x2 = $tmp2;
    117                                         $value6 = $this->y2;
    118                                         if (!true){
    119                                                 throw new HException("FAIL: lower <= upper");
    120                                         }
    121                                         $value7 = $value6+mt_rand(-16, +16);
    122                                         $max3 = $this->yBound-1;
    123                                         if (!(0<=$max3)){
    124                                                 throw new HException("FAIL: min <= max");
    125                                         }
    126                                         $tmp3 = null;
    127                                         if ($value7<0){
    128                                                 $tmp3 = 0;
    129                                         } else {
    130                                                 if ($value7>$max3){
    131                                                         $tmp3 = $max3;
    132                                                 } else {
    133                                                         $tmp3 = $value7;
    134                                                 }
    135                                         }
    136                                         $this->y2 = $tmp3;
    137                                 }
     103                                $this->x2 += mt_rand(-16, +16);
     104                                #$this->x2 = max(min($this->x2, $this->xBound-1),0);
     105                                $this->y2 +=  mt_rand(-16, +16);
     106                                #$this->y2 = max(min($this->y2, $this->yBound-1),0);
    138107                                break;
     108
    139109                        case 2:
    140                                 {
    141                                         $value8 = $this->x3;
    142                                         if (!true){
    143                                                 throw new HException("FAIL: lower <= upper");
    144                                         }
    145                                         $value9 = $value8+mt_rand(-16, +16);
    146                                         $max4 = $this->xBound-1;
    147                                         if (!(0<=$max4)){
    148                                                 throw new HException("FAIL: min <= max");
    149                                         }
    150                                         $tmp4 = null;
    151                                         if ($value9<0){
    152                                                 $tmp4 = 0;
    153                                         } else {
    154                                                 if ($value9>$max4){
    155                                                         $tmp4 = $max4;
    156                                                 } else {
    157                                                         $tmp4 = $value9;
    158                                                 }
    159                                         }
    160                                         $this->x3 = $tmp4;
    161                                         $value10 = $this->y3;
    162                                         if (!true){
    163                                                 throw new HException("FAIL: lower <= upper");
    164                                         }
    165                                         $value11 = $value10+mt_rand(-16, +16);
    166                                         $max5 = $this->yBound-1;
    167                                         if (!(0<=$max5)){
    168                                                 throw new HException("FAIL: min <= max");
    169                                         }
    170                                         $tmp5 = null;
    171                                         if ($value11<0){
    172                                                 $tmp5 = 0;
    173                                         } else {
    174                                                 if ($value11>$max5){
    175                                                         $tmp5 = $max5;
    176                                                 } else {
    177                                                         $tmp5 = $value11;
    178                                                 }
    179                                         }
    180                                         $this->y3 = $tmp5;
    181                                 }
     110                                $this->x3 +=  mt_rand(-16, +16);
     111                                #$this->x3 = max(min($this->x3, $this->xBound-1),0);
     112                                $this->y3 += mt_rand(-16, +16);
     113                                #$this->y3 = max(min($this->y3, $this->yBound-1),0);
    182114                                break;
    183115                }
    184         }
    185 
     116
     117                // force to rasterize the new shape
     118                $this->lines = null;
     119        }
     120
     121        /**
     122         * rescale the shape to new bound dimensions
     123         * @param $xBound
     124         * @param $yBound
     125         */
    186126        public function rescale($xBound, $yBound){
    187127                $xScale = ($xBound-1) / ($this->xBound-1);
     
    195135                $this->x3 = intval(round($this->x3*$xScale));
    196136                $this->y3 = intval(round($this->y3*$yScale));
     137
     138                if ($this->lines) {
     139                        foreach ($this->lines as &$line) {
     140                                $line->rescale($xScale, $yScale);
     141                        }
     142                }
    197143        }
    198144
    199145        public function hclone(){
    200                 $triangle = new geometrize_shape_Triangle($this->xBound, $this->yBound);
    201                 $triangle->x1 = $this->x1;
    202                 $triangle->y1 = $this->y1;
    203                 $triangle->x2 = $this->x2;
    204                 $triangle->y2 = $this->y2;
    205                 $triangle->x3 = $this->x3;
    206                 $triangle->y3 = $this->y3;
    207                 if (isset($this->color)){
    208                         $triangle->color = $this->color;
    209                 }
    210                 return $triangle;
    211         }
     146                return clone $this;
     147        }
     148
     149        public function __clone() {
     150                if ($this->lines) {
     151                        foreach ($this->lines as $k=>&$line) {
     152                                $this->lines[$k] = clone $line;
     153                        }
     154                }
     155  }
    212156
    213157        public function getType(){
    214                 return 2;
     158                return geometrize_shape_ShapeTypes::T_TRIANGLE;
    215159        }
    216160
    217161        public function getRawShapeData(){
    218                 return (new _hx_array(array($this->x1, $this->y1, $this->x2, $this->y2, $this->x3, $this->y3)));
     162                return [
     163                        $this->x1,
     164                        $this->y1,
     165                        $this->x2,
     166                        $this->y2,
     167                        $this->x3,
     168                        $this->y3
     169                ];
    219170        }
    220171
    221172        public function getSvgShapeData(){
    222                 return "<polygon points=\"" . _hx_string_rec($this->x1, "") . "," . _hx_string_rec($this->y1, "") . " " . _hx_string_rec($this->x2, "") . "," . _hx_string_rec($this->y2, "") . " " . _hx_string_rec($this->x3, "") . "," . _hx_string_rec($this->y3, "") . "\" " . _hx_string_or_null(geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK) . "/>";
     173                $points = [
     174                        ["x" => $this->x1, "y" => $this->y1],
     175                        ["x" => $this->x2, "y" => $this->y2],
     176                        ["x" => $this->x3, "y" => $this->y3],
     177                ];
     178                return geometrize_exporter_SvgExporter::exportPolygon($points);
    223179        }
    224180
  • _plugins_/adaptive_images/trunk/preview/image_geometrize.php

    r115861 r115922  
    3232        // dimension de la miniature a vectoriser
    3333        $geometrize_options = [
    34                 "shapeTypes" => [geometrize_shape_ShapeTypes::$TRIANGLE],
     34                "shapeTypes" => [geometrize_shape_ShapeTypes::T_TRIANGLE],
    3535                "alpha" => 255, // beaucoup plus rapide qu'avec une transparence
    3636                "candidateShapesPerStep" => 150,
     
    5858        $dest = $cache["fichier_dest"];
    5959
    60         if ($cache["creer"]){
     60        if (true or $cache["creer"]){
    6161                if (!@file_exists($fichier)){
    6262                        return false;
    6363                }
    6464
     65                $runnerVersion = 2;
    6566                $runner = false;
    66                 $results = new _hx_array();
     67                $results = [];
    6768                $couleur_bg = _image_couleur_moyenne($fichier);
    6869                //$couleur_bg = couleur_extraire($fichier);
     
    7273                if (file_exists("$dest.runner")){
    7374                        lire_fichier("$dest.runner", $r);
    74                         if ($r = unserialize($r)){
     75                        if ($r = unserialize($r)
     76                                and $version = array_shift($r)
     77                                and $version === $runnerVersion){
    7578                                list($runner, $results) = $r;
    7679                                $w = $runner->model->width;
     
    9295                }
    9396
    94                 $hx_options = new _hx_array();
    95                 $hx_options->shapeTypes = new _hx_array($geometrize_options['shapeTypes']);
    96                 $hx_options->alpha = $geometrize_options['alpha'];
    97                 $hx_options->candidateShapesPerStep = $geometrize_options['candidateShapesPerStep'];
    98                 $hx_options->shapeMutationsPerStep = $geometrize_options['shapeMutationsPerStep'];
    99                 $hx_options->steps = $geometrize_options['steps'];
    100 
    10197                //var_dump("WIDTHUMB $width_thumb");
    10298
    10399                $start_time = time();
    104100                spip_timer('runner');
    105                 for ($i = $results->length; $i<$geometrize_options['steps']; $i++){
     101                for ($i = count($results); $i<$geometrize_options['steps']; $i++){
    106102
    107103                        // faut-il passer a une taille de vignette superieure ?
     
    124120                        }
    125121
    126                         $r = $runner->step($hx_options);
    127                         $results->push($r->get(0));
     122                        $r = $runner->step($geometrize_options);
     123                        $results = array_merge($results,$r);
    128124                        if (time()>$start_time+$time_budget){
    129125                                break;
     
    133129
    134130                //var_dump($r,'<hr/>',$results);
    135 
    136131
    137132                $svg_image = trim(geometrize_exporter_SvgExporter::export($results, $w, $h));
     
    162157
    163158                ecrire_fichier($dest, $svg_image);
    164                 $nsteps = $results->length;
    165                 if ($results->length<$geometrize_options['steps']){
     159                $nsteps = count($results);
     160                if ($nsteps<$geometrize_options['steps']){
    166161                        @touch($dest, 1); // on antidate l'image pour revenir ici au prochain affichage
    167                         ecrire_fichier("$dest.runner", serialize([$runner, $results]));
     162                        ecrire_fichier("$dest.runner", serialize([$runnerVersion, $runner, $results]));
    168163                        spip_log("PROGRESS: $fichier t=$time_compute Steps:$nsteps length:" . strlen($svg_image), 'ai_geometrize');
    169164                        //var_dump("STEPS:" . $nsteps);
     
    185180        $thumb = image_reduire($img, $width_thumb);
    186181        $source = extraire_attribut($thumb, 'src');
    187         list($w, $h) = getimagesize($source);
    188         $image = imagecreatefromstring(file_get_contents($source));
    189         $bitmap = new geometrize_bitmap_Bitmap();
    190         $bitmap->width = $w;
    191         $bitmap->height = $h;
    192 
    193         for ($x = 0; $x<$w; $x++){
    194                 for ($y = 0; $y<$h; $y++){
    195                         // get a color
    196                         $color_index = imagecolorat($image, $x, $y);
    197                         // make it human readable
    198                         $c = imagecolorsforindex($image, $color_index);
    199                         $bitmap->setPixel($x, $y, _couleur_to_geometrize($c));
    200                 }
    201         }
     182        $bitmap = geometrize_bitmap_Bitmap::createFromImageFile($source);
    202183        $runner = new geometrize_runner_ImageRunner($bitmap, _couleur_to_geometrize($couleur_bg));
    203184
    204         $new_results = new _hx_array();
     185        $new_results = [];
    205186        if ($results){
    206                 for ($i = 0; $i<$results->length; $i++){
    207                         $alpha = $results[$i]->shape->color & 255;
    208                         $results[$i]->shape->rescale($w, $h); // rescale on new bounds
    209                         $new_results->push($runner->model->addShape($results[$i]->shape, $alpha));
     187                $w = $bitmap->width;
     188                $h = $bitmap->height;
     189                foreach ($results as $result) {
     190                        $alpha = $result['shape']->color & 255;
     191                        $result['shape']->rescale($w, $h); // rescale on new bounds
     192                        $new_results[] = $runner->model->addShape($result['shape'], $alpha);
    210193                }
    211194        }
Note: See TracChangeset for help on using the changeset viewer.