Changeset 115850 in spip-zone


Ignore:
Timestamp:
Jul 3, 2019, 12:11:45 PM (3 weeks ago)
Author:
cedric@…
Message:

mise a jour et optimisation de la lib

Location:
_plugins_/adaptive_images/trunk/lib/geometrize
Files:
1 added
5 deleted
24 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize.init.php

    r115817 r115850  
    22
    33/**
    4  * PHP geomtrize version compilee d'apres https://github.com/Tw1ddle/geometrize-haxe
     4 * PHP version of https://github.com/Tw1ddle/geometrize-haxe/commit/e6ed1ab8c3867ac0da5bfea25ee4e7204ad286be
     5 * Based on PHP code generated with Haxe on this base version
     6 * + manual optimization&refactoring
    57 *
    68 * boot PHP utils classes and start autoload for geometrize & al
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/AbstractEnumTools.class.php

    r115817 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize_AbstractEnumTools {
    5         public function __construct(){}
    6         function __toString() { return 'geometrize.AbstractEnumTools'; }
     5        public function __construct(){
     6        }
     7
     8        function __toString(){
     9                return 'geometrize.AbstractEnumTools';
     10        }
    711}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/Core.class.php

    r115842 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize_Core {
    5         public function __construct(){}
    6         static function computeColor($target, $current, $lines, $alpha) {
    7                 if(!($target !== null)) {
     5        public function __construct(){
     6        }
     7
     8        static function computeColor($target, $current, $lines, $alpha){
     9                if (!($target!==null)){
    810                        throw new HException("FAIL: target != null");
    911                }
    10                 if(!($current !== null)) {
     12                if (!($current!==null)){
    1113                        throw new HException("FAIL: current != null");
    1214                }
    13                 if(!($lines !== null)) {
     15                if (!($lines!==null)){
    1416                        throw new HException("FAIL: lines != null");
    1517                }
    16                 if(!($alpha >= 0)) {
     18                if (!($alpha>=0)){
    1719                        throw new HException("FAIL: alpha >= 0");
    1820                }
     
    2123                $totalBlue = 0;
    2224                $count = 0;
    23                 $f = 65535 / $alpha;
     25                $f = 65535/$alpha;
    2426                $a = intval($f);
    2527                {
    2628                        $_g = 0;
    27                         while($_g < $lines->length) {
     29                        while ($_g<$lines->length){
    2830                                $line = $lines[$_g];
    29                                 $_g = $_g + 1;
     31                                $_g = $_g+1;
    3032                                $y = $line->y;
    3133                                {
    3234                                        $_g2 = $line->x1;
    33                                         $_g1 = $line->x2 + 1;
    34                                         while($_g2 < $_g1) {
    35                                                 $_g2 = $_g2 + 1;
    36                                                 $x = $_g2 - 1;
    37                                                 $t = $target->data[$target->width * $y + $x];
    38                                                 $c = $current->data[$current->width * $y + $x];
    39                                                 $totalRed = $totalRed + ((($t >> 24 & 255) - ($c >> 24 & 255)) * $a + ($c >> 24 & 255) * 257);
    40                                                 $totalGreen = $totalGreen + ((($t >> 16 & 255) - ($c >> 16 & 255)) * $a + ($c >> 16 & 255) * 257);
    41                                                 $totalBlue = $totalBlue + ((($t >> 8 & 255) - ($c >> 8 & 255)) * $a + ($c >> 8 & 255) * 257);
    42                                                 $count = $count + 1;
    43                                                 unset($x,$t,$c);
    44                                         }
    45                                         unset($_g2,$_g1);
    46                                 }
    47                                 unset($y,$line);
    48                         }
    49                 }
    50                 if($count === 0) {
     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                }
     52                if ($count===0){
    5153                        return 0;
    5254                }
    53                 $value = intval($totalRed / $count) >> 8;
    54                 if(!true) {
     55                $value = intval($totalRed/$count) >> 8;
     56                if (!true){
    5557                        throw new HException("FAIL: min <= max");
    5658                }
    5759                $r = null;
    58                 if($value < 0) {
     60                if ($value<0){
    5961                        $r = 0;
    6062                } else {
    61                         if($value > 255) {
     63                        if ($value>255){
    6264                                $r = 255;
    6365                        } else {
     
    6567                        }
    6668                }
    67                 $value1 = intval($totalGreen / $count) >> 8;
    68                 if(!true) {
     69                $value1 = intval($totalGreen/$count) >> 8;
     70                if (!true){
    6971                        throw new HException("FAIL: min <= max");
    7072                }
    7173                $g = null;
    72                 if($value1 < 0) {
     74                if ($value1<0){
    7375                        $g = 0;
    7476                } else {
    75                         if($value1 > 255) {
     77                        if ($value1>255){
    7678                                $g = 255;
    7779                        } else {
     
    7981                        }
    8082                }
    81                 $value2 = intval($totalBlue / $count) >> 8;
    82                 if(!true) {
     83                $value2 = intval($totalBlue/$count) >> 8;
     84                if (!true){
    8385                        throw new HException("FAIL: min <= max");
    8486                }
    8587                $b = null;
    86                 if($value2 < 0) {
     88                if ($value2<0){
    8789                        $b = 0;
    8890                } else {
    89                         if($value2 > 255) {
     91                        if ($value2>255){
    9092                                $b = 255;
    9193                        } else {
     
    9395                        }
    9496                }
    95                 if(!true) {
     97                if (!true){
    9698                        throw new HException("FAIL: min <= max");
    9799                }
    98100                $tmp = null;
    99                 if($r < 0) {
     101                if ($r<0){
    100102                        $tmp = 0;
    101103                } else {
    102                         if($r > 255) {
     104                        if ($r>255){
    103105                                $tmp = 255;
    104106                        } else {
     
    106108                        }
    107109                }
    108                 if(!true) {
     110                if (!true){
    109111                        throw new HException("FAIL: min <= max");
    110112                }
    111113                $tmp1 = null;
    112                 if($g < 0) {
     114                if ($g<0){
    113115                        $tmp1 = 0;
    114116                } else {
    115                         if($g > 255) {
     117                        if ($g>255){
    116118                                $tmp1 = 255;
    117119                        } else {
     
    119121                        }
    120122                }
    121                 if(!true) {
     123                if (!true){
    122124                        throw new HException("FAIL: min <= max");
    123125                }
    124126                $tmp2 = null;
    125                 if($b < 0) {
     127                if ($b<0){
    126128                        $tmp2 = 0;
    127129                } else {
    128                         if($b > 255) {
     130                        if ($b>255){
    129131                                $tmp2 = 255;
    130132                        } else {
     
    132134                        }
    133135                }
    134                 if(!true) {
     136                if (!true){
    135137                        throw new HException("FAIL: min <= max");
    136138                }
    137139                $tmp3 = null;
    138                 if($alpha < 0) {
     140                if ($alpha<0){
    139141                        $tmp3 = 0;
    140142                } else {
    141                         if($alpha > 255) {
     143                        if ($alpha>255){
    142144                                $tmp3 = 255;
    143145                        } else {
     
    145147                        }
    146148                }
    147                 return ($tmp << 24) + ($tmp1 << 16) + ($tmp2 << 8) + $tmp3;
    148         }
    149         static function differenceFull($first, $second) {
    150                 /*
    151                 if(!($first !== null)) {
    152                         throw new HException("FAIL: first != null");
    153                 }
    154                 if(!($second !== null)) {
    155                         throw new HException("FAIL: second != null");
    156                 }
    157                 */
    158                 /*
    159                 {
    160                         $actual = $first->width;
    161                         $expected = $second->width;
    162                         if($actual !== $expected) {
    163                                 throw new HException("FAIL: values are not equal (expected: " . _hx_string_rec($expected, "") . ", actual: " . _hx_string_rec($actual, "") . ")");
    164                         }
    165                 }
    166                 {
    167                         $actual1 = $first->height;
    168                         $expected1 = $second->height;
    169                         if($actual1 !== $expected1) {
    170                                 throw new HException("FAIL: values are not equal (expected: " . _hx_string_rec($expected1, "") . ", actual: " . _hx_string_rec($actual1, "") . ")");
    171                         }
    172                 }
    173                 */
     149                return ($tmp << 24)+($tmp1 << 16)+($tmp2 << 8)+$tmp3;
     150        }
     151
     152        static function differenceFull($target, $current){
     153
     154                if (!isset($before->errorCache)){
     155                        $current->errorCache = [];
     156                }
     157
     158                $actual = $target->width;
     159                $expected = $current->width;
     160                if ($actual!==$expected){
     161                        throw new HException("FAIL: values are not equal (expected: " . _hx_string_rec($expected, "") . ", actual: " . _hx_string_rec($actual, "") . ")");
     162                }
     163                $actual1 = $target->height;
     164                $expected1 = $current->height;
     165                if ($actual1!==$expected1){
     166                        throw new HException("FAIL: values are not equal (expected: " . _hx_string_rec($expected1, "") . ", actual: " . _hx_string_rec($actual1, "") . ")");
     167                }
     168
    174169                $total = 0;
    175                 $width = $first->width;
    176                 $height = $first->height;
    177                 for($y=0;$y<$height;$y++) {
    178                         $o = $first->width * $y;
    179                         for ($x=0;$x<$width;$x++) {
    180                                 $f = $first->data[$o + $x];
    181                                 $s = $second->data[$o + $x];
    182                                 $dr = ($f >> 24 & 255) - ($s >> 24 & 255);
    183                                 if ($dr<0) $dr*=-1;
    184                                 $dg = ($f >> 16 & 255) - ($s >> 16 & 255);
    185                                 if ($dg<0) $dg*=-1;
    186                                 $db = ($f >> 8 & 255) - ($s >> 8 & 255);
    187                                 if ($db<0) $db*=-1;
    188                                 $da = ($f & 255) - ($s & 255);
    189                                 if ($da<0) $da*=-1;
    190                                 $total = $total + ($dr + $dg + $db + $da );
    191                         }
    192                 }
    193                 return $total / ($width * $height * 4.0) / 255;
    194         }
    195         static function differencePartial($target, $before, $after, $score, $lines) {
    196 
    197                 if (!isset($before->errorCache)) {
    198                         $before->errorCache = [];
    199                 }
    200 
    201                 /*
    202                 if(!($target !== null)) {
    203                         throw new HException("FAIL: target != null");
    204                 }
    205                 if(!($before !== null)) {
    206                         throw new HException("FAIL: before != null");
    207                 }
    208                 if(!($after !== null)) {
    209                         throw new HException("FAIL: after != null");
    210                 }
    211                 if(!($lines !== null)) {
    212                         throw new HException("FAIL: lines != null");
    213                 }*/
    214170                $width = $target->width;
    215171                $height = $target->height;
    216                 $rgbaCount = $width * $height * 4 * 255;
    217                 $total = $score * $rgbaCount;
    218                 $_g = 0;
    219                 while($_g < $lines->length) {
    220                         $line = &$lines[$_g];
    221                         $_g = $_g + 1;
    222                         $_g1 = $line->x2 + 1;
    223                         $o1 = $target->width * $line->y;
    224                         $o2 = $before->width * $line->y;
    225                         $o3 = $after->width * $line->y;
    226                         for($x=$line->x1;$x<$_g1;$x++) {
    227                                 $t = $target->data[$o1 + $x];
    228                                 $a = $after->data[$o3 + $x];
    229                                 if (!isset($before->errorCache[$o2 + $x])) {
    230                                         $b = $before->data[$o2 + $x];
    231                                         $dtbr = ($t >> 24 & 255) - ($b >> 24 & 255);
    232                                         if ($dtbr<0) $dtbr*=-1;
    233                                         $dtbg = ($t >> 16 & 255) - ($b >> 16 & 255);
    234                                         if ($dtbg<0) $dtbg*=-1;
    235                                         $dtbb = ($t >> 8 & 255) - ($b >> 8 & 255);
    236                                         if ($dtbb<0) $dtbb*=-1;
    237                                         $dtba = ($t & 255) - ($b & 255);
    238                                         if ($dtba<0) $dtba*=-1;
    239                                         $before->errorCache[$o2 + $x] = $dtbr + $dtbg + $dtbb + $dtba;
    240                                 }
    241 
    242                                 $dtar = ($t >> 24 & 255) - ($a >> 24 & 255);
    243                                 if ($dtar<0) $dtar*=-1;
    244                                 $dtag = ($t >> 16 & 255) - ($a >> 16 & 255);
    245                                 if ($dtag<0) $dtag*=-1;
    246                                 $dtab = ($t >> 8 & 255) - ($a >> 8 & 255);
    247                                 if ($dtab<0) $dtab*=-1;
    248                                 $dtaa = ($t & 255) - ($a & 255);
    249                                 if ($dtaa<0) $dtaa*=-1;
    250                                 $total = $total - $before->errorCache[$o2 + $x];
    251                                 $total = $total + ($dtar + $dtag + $dtab + $dtaa );
    252                         }
    253                 }
    254                 return $total / $rgbaCount;
    255         }
    256         static function bestRandomState($shapes, $alpha, $n, $target, $current, $buffer, $lastScore) {
    257                 $bestEnergy = 0;
     172                for ($y = 0; $y<$height; $y++){
     173                        $o = $target->width*$y;
     174                        for ($x = 0; $x<$width; $x++){
     175                                $f = $target->data[$o+$x];
     176                                $s = $current->data[$o+$x];
     177                                $dr = ($f >> 24 & 255)-($s >> 24 & 255);
     178                                if ($dr<0){
     179                                        $dr *= -1;
     180                                }
     181                                $dg = ($f >> 16 & 255)-($s >> 16 & 255);
     182                                if ($dg<0){
     183                                        $dg *= -1;
     184                                }
     185                                $db = ($f >> 8 & 255)-($s >> 8 & 255);
     186                                if ($db<0){
     187                                        $db *= -1;
     188                                }
     189                                $da = ($f & 255)-($s & 255);
     190                                if ($da<0){
     191                                        $da *= -1;
     192                                }
     193                                $total += ($current->errorCache[$o+$x] = $dr+$dg+$db+$da);
     194                        }
     195                }
     196                return $total;
     197        }
     198
     199        static function differencePartial($target, $before, $after, $score, $lines, $bestScore = null){
     200
     201                if (!isset($before->errorCache)){
     202                        $before->errorCache = [];
     203                }
     204
     205                $total = $score;
     206                for ($i = 0; $i<$lines->length; $i++){
     207                        $line = &$lines[$i];
     208                        $o1 = $target->width*$line->y;
     209                        $o2 = $before->width*$line->y;
     210                        for ($x = $line->x1; $x<=$line->x2; $x++){
     211                                $t = $target->data[$o1+$x];
     212                                if (!isset($before->errorCache[$o2+$x])){
     213                                        $b = $before->data[$o2+$x];
     214                                        $dtbr = ($t >> 24 & 255)-($b >> 24 & 255);
     215                                        if ($dtbr<0){
     216                                                $dtbr *= -1;
     217                                        }
     218                                        $dtbg = ($t >> 16 & 255)-($b >> 16 & 255);
     219                                        if ($dtbg<0){
     220                                                $dtbg *= -1;
     221                                        }
     222                                        $dtbb = ($t >> 8 & 255)-($b >> 8 & 255);
     223                                        if ($dtbb<0){
     224                                                $dtbb *= -1;
     225                                        }
     226                                        $dtba = ($t & 255)-($b & 255);
     227                                        if ($dtba<0){
     228                                                $dtba *= -1;
     229                                        }
     230                                        $before->errorCache[$o2+$x] = $dtbr+$dtbg+$dtbb+$dtba;
     231                                }
     232                                $total = $total-$before->errorCache[$o2+$x];
     233                        }
     234                }
     235                if (!is_null($bestScore) && $total>$bestScore){
     236                        return $total;
     237                }
     238
     239                for ($i = 0; $i<$lines->length; $i++){
     240                        $line = &$lines[$i];
     241                        $o1 = $target->width*$line->y;
     242                        $o3 = $after->width*$line->y;
     243                        for ($x = $line->x1; $x<=$line->x2; $x++){
     244                                $t = $target->data[$o1+$x];
     245                                $a = $after->data[$o3+$x];
     246
     247                                $dtar = ($t >> 24 & 255)-($a >> 24 & 255);
     248                                if ($dtar<0){
     249                                        $dtar *= -1;
     250                                }
     251                                $dtag = ($t >> 16 & 255)-($a >> 16 & 255);
     252                                if ($dtag<0){
     253                                        $dtag *= -1;
     254                                }
     255                                $dtab = ($t >> 8 & 255)-($a >> 8 & 255);
     256                                if ($dtab<0){
     257                                        $dtab *= -1;
     258                                }
     259                                $dtaa = ($t & 255)-($a & 255);
     260                                if ($dtaa<0){
     261                                        $dtaa *= -1;
     262                                }
     263                                $total = $total+($dtar+$dtag+$dtab+$dtaa);
     264                        }
     265                        if (!is_null($bestScore) && $total>$bestScore){
     266                                return $total;
     267                        }
     268                }
     269
     270                return $total;
     271        }
     272
     273        static function bestRandomState($shapes, $alpha, $n, $target, $current, $buffer, $lastScore){
     274                $bestEnergy = null;
    258275                $bestState = null;
    259                 {
    260                         $_g1 = 0;
    261                         $_g = $n;
    262                         while($_g1 < $_g) {
    263                                 $_g1 = $_g1 + 1;
    264                                 $i = $_g1 - 1;
    265                                 $state = new geometrize_State(geometrize_shape_ShapeFactory::randomShapeOf($shapes, $current->width, $current->height), $alpha, $target, $current, $buffer);
    266                                 $energy = $state->energy($lastScore);
    267                                 $tmp = null;
    268                                 if($i !== 0) {
    269                                         $tmp = $energy < $bestEnergy;
    270                                 } else {
    271                                         $tmp = true;
    272                                 }
    273                                 if($tmp) {
    274                                         $bestEnergy = $energy;
    275                                         $bestState = $state;
    276                                 }
    277                                 unset($tmp,$state,$i,$energy);
    278                         }
    279                 }
     276
     277                for ($i = 0; $i<$n; $i++){
     278                        $state = new geometrize_State(geometrize_shape_ShapeFactory::randomShapeOf($shapes, $current->width, $current->height), $alpha, $target, $current, $buffer);
     279                        $energy = $state->energy($lastScore, $bestEnergy);
     280                        if (is_null($bestEnergy) || $energy<$bestEnergy){
     281                                $bestEnergy = $energy;
     282                                $bestState = $state;
     283                        }
     284                }
     285
    280286                return $bestState;
    281287        }
    282         static function bestHillClimbState($shapes, $alpha, $n, $age, $target, $current, $buffer, $lastScore) {
     288
     289        static function bestHillClimbState($shapes, $alpha, $n, $age, $target, $current, $buffer, $lastScore){
    283290                $state = geometrize_Core::bestRandomState($shapes, $alpha, $n, $target, $current, $buffer, $lastScore);
    284291                $state = geometrize_Core::hillClimb($state, $age, $lastScore);
    285292                return $state;
    286293        }
    287         static function hillClimb($state, $maxAge, $lastScore) {
    288                 if(!($state !== null)) {
     294
     295        static function hillClimb($state, $maxAge, $lastScore){
     296                if (!($state!==null)){
    289297                        throw new HException("FAIL: state != null");
    290298                }
    291                 if(!($maxAge >= 0)) {
     299                if (!($maxAge>=0)){
    292300                        throw new HException("FAIL: maxAge >= 0");
    293301                }
     
    296304                $bestEnergy = $state1->energy($lastScore);
    297305                $age = 0;
    298                 while($age < $maxAge) {
     306                while ($age<$maxAge){
    299307                        $undo = $state1->mutate();
    300                         $energy = $state1->energy($lastScore);
    301                         if($energy >= $bestEnergy) {
     308                        $energy = $state1->energy($lastScore, $bestEnergy);
     309                        if ($energy>=$bestEnergy){
    302310                                $state1 = $undo;
    303311                        } else {
     
    306314                                $age = -1;
    307315                        }
    308                         $age = $age + 1;
    309                         unset($undo,$energy);
     316                        $age = $age+1;
     317                        unset($undo, $energy);
    310318                }
    311319                return $bestState;
    312320        }
    313         static function energy(&$shape, $alpha, $target, $current, $buffer, $score) {
    314                 if(!($shape !== null)) {
     321
     322        static function energy(&$shape, $alpha, $target, $current, $buffer, $score, $bestScore = null){
     323                if (!($shape!==null)){
    315324                        throw new HException("FAIL: shape != null");
    316325                }
    317                 if(!($target !== null)) {
     326                if (!($target!==null)){
    318327                        throw new HException("FAIL: target != null");
    319328                }
    320                 if(!($current !== null)) {
     329                if (!($current!==null)){
    321330                        throw new HException("FAIL: current != null");
    322331                }
    323                 if(!($buffer !== null)) {
     332                if (!($buffer!==null)){
    324333                        throw new HException("FAIL: buffer != null");
    325334                }
    326335                $lines = $shape->rasterize();
    327                 if (!isset($shape->color)) {
     336                if (!isset($shape->color)){
    328337                        $shape->color = geometrize_Core::computeColor($target, $current, $lines, $alpha);
    329338                }
    330                 $color = $shape->color;
    331                 // useful only if opacity!=1
    332                 if ($color && 255 !== 255) {
     339                // copyLines only if opacity!=1 (speed issue with no opacity in shapes)
     340                if ($shape->color & 255!==255){
    333341                        geometrize_rasterizer_Rasterizer::copyLines($buffer, $current, $lines);
    334342                }
    335                 geometrize_rasterizer_Rasterizer::drawLines($buffer, $color, $lines);
    336                 return geometrize_Core::differencePartial($target, $current, $buffer, $score, $lines);
    337         }
    338         function __toString() { return 'geometrize.Core'; }
     343                geometrize_rasterizer_Rasterizer::drawLines($buffer, $shape->color, $lines);
     344                return geometrize_Core::differencePartial($target, $current, $buffer, $score, $lines, $bestScore);
     345        }
     346
     347        function __toString(){
     348                return 'geometrize.Core';
     349        }
    339350}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/Model.class.php

    r115842 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize_Model {
    5         public function __construct($target, $backgroundColor) {
    6                 if(!php_Boot::$skip_constructor) {
    7                 if(!($target !== null)) {
    8                         throw new HException("FAIL: target != null");
    9                 }
    10                 $this->width = $target->width;
    11                 $this->height = $target->height;
    12                 $this->target = $target;
    13                 $w = $target->width;
    14                 $h = $target->height;
    15                 $bitmap = new geometrize_bitmap_Bitmap();
    16                 $bitmap->width = $w;
    17                 $bitmap->height = $h;
    18                 $this1 = (new _hx_array(array()));
    19                 $this1->length = $w * $h;
    20                 $bitmap->data = $this1;
    21                 $i = 0;
    22                 while($i < $bitmap->data->length) {
    23                         $bitmap->data[$i] = $backgroundColor;
    24                         $i = $i + 1;
    25                 }
    26                 $this->current = $bitmap;
    27                 $w1 = $target->width;
    28                 $h1 = $target->height;
    29                 $bitmap1 = new geometrize_bitmap_Bitmap();
    30                 $bitmap1->width = $w1;
    31                 $bitmap1->height = $h1;
    32                 $this2 = (new _hx_array(array()));
    33                 $this2->length = $w1 * $h1;
    34                 $bitmap1->data = $this2;
    35                 $i1 = 0;
    36                 while($i1 < $bitmap1->data->length) {
    37                         $bitmap1->data[$i1] = $backgroundColor;
    38                         $i1 = $i1 + 1;
    39                 }
    40                 $this->buffer = $bitmap1;
    41                 $this->score = geometrize_Core::differenceFull($target, $this->current);
    42         }}
    435        public $width;
    446        public $height;
     
    479        public $buffer;
    4810        public $score;
    49         public function step($shapeTypes, $alpha, $n, $age) {
     11
     12        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);
     49                }
     50        }
     51
     52        public function step($shapeTypes, $alpha, $n, $age){
    5053                $state = geometrize_Core::bestHillClimbState($shapeTypes, $alpha, $n, $age, $this->target, $this->current, $this->buffer, $this->score);
    5154                $results = (new _hx_array(array($this->addShape($state->shape, $state->alpha))));
    5255                return $results;
    5356        }
    54         public function addShape($shape, $alpha) {
    55                 if(!($shape !== null)) {
     57
     58        public function addShape($shape, $alpha){
     59                if (!($shape!==null)){
    5660                        throw new HException("FAIL: shape != null");
    5761                }
     
    6670                        $_g1 = 0;
    6771                        $_g = $_this->data->length;
    68                         while($_g1 < $_g) {
    69                                 $_g1 = $_g1 + 1;
    70                                 $i = $_g1 - 1;
     72                        while ($_g1<$_g){
     73                                $_g1 = $_g1+1;
     74                                $i = $_g1-1;
    7175                                $bitmap->data[$i] = $_this->data[$i];
    7276                                unset($i);
     
    7478                }
    7579                $before = $bitmap;
    76                 if (isset($this->current->errorCache)) {
     80                if (isset($this->current->errorCache)){
    7781                        $before->errorCache = $this->current->errorCache;
    78                         $this->current->errorCache = [];
    7982                }
    8083                $lines = $shape->rasterize();
    81                 if (!isset($shape->color)) {
     84                if (!isset($shape->color)){
    8285                        $shape->color = geometrize_Core::computeColor($this->target, $this->current, $lines, $alpha);
    8386                }
    84                 $color = $shape->color;
    85                 geometrize_rasterizer_Rasterizer::drawLines($this->current, $color, $lines);
     87                geometrize_rasterizer_Rasterizer::drawLines($this->current, $shape->color, $lines);
    8688                $this->score = geometrize_Core::differencePartial($this->target, $before, $this->current, $this->score, $lines);
    87                 $result = _hx_anonymous(array("score" => $this->score, "color" => $color, "shape" => $shape));
     89                $score_normalization = $_this->width*$_this->height*4*255;
     90                $result = _hx_anonymous(array("score" => $this->score/$score_normalization, "color" => $shape->color, "shape" => $shape));
    8891                return $result;
    8992        }
    90         public function __call($m, $a) {
    91                 if(isset($this->$m) && is_callable($this->$m))
     93
     94        public function __call($m, $a){
     95                if (isset($this->$m) && is_callable($this->$m)){
    9296                        return call_user_func_array($this->$m, $a);
    93                 else if(isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m]))
    94                         return call_user_func_array($this->__dynamics[$m], $a);
    95                 else if('toString' == $m)
    96                         return $this->__toString();
    97                 else
    98                         throw new HException('Unable to call <'.$m.'>');
     97                } else {
     98                        if (isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m])){
     99                                return call_user_func_array($this->__dynamics[$m], $a);
     100                        } else {
     101                                if ('toString'==$m){
     102                                        return $this->__toString();
     103                                } else {
     104                                        throw new HException('Unable to call <' . $m . '>');
     105                                }
     106                        }
     107                }
    99108        }
    100         function __toString() { return 'geometrize.Model'; }
     109
     110        function __toString(){
     111                return 'geometrize.Model';
     112        }
    101113}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/State.class.php

    r115817 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize_State {
    5         public function __construct($shape, $alpha, $target, $current, $buffer) {
    6                 if(!php_Boot::$skip_constructor) {
    7                 if(!($shape !== null)) {
    8                         throw new HException("FAIL: shape != null");
    9                 }
    10                 $this->shape = $shape;
    11                 $this->alpha = $alpha;
    12                 $this->score = -1;
    13                 $this->target = $target;
    14                 $this->current = $current;
    15                 $this->buffer = $buffer;
    16         }}
    175        public $shape;
    186        public $alpha;
     
    219        public $current;
    2210        public $buffer;
    23         public function energy($lastScore) {
    24                 if($this->score < 0) {
    25                         $this->score = geometrize_Core::energy($this->shape, $this->alpha, $this->target, $this->current, $this->buffer, $lastScore);
     11
     12        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;
     23                }
     24        }
     25
     26        public function energy($lastScore, $bestScore = null){
     27                if ($this->score<0){
     28                        $this->score = geometrize_Core::energy($this->shape, $this->alpha, $this->target, $this->current, $this->buffer, $lastScore, $bestScore);
    2629                }
    2730                return $this->score;
    2831        }
    29         public function mutate() {
     32
     33        public function mutate(){
    3034                $oldState = $this->hclone();
    3135                $this->shape->mutate();
     36                // force score recomputing as we mutated
     37                $this->score = -1;
    3238                return $oldState;
    3339        }
    34         public function hclone() {
     40
     41        public function hclone(){
    3542                $tmp = $this->shape->hclone();
    36                 return new geometrize_State($tmp, $this->alpha, $this->target, $this->current, $this->buffer);
     43                $newState = new geometrize_State($tmp, $this->alpha, $this->target, $this->current, $this->buffer);
     44                $newState->score = $this->score;
     45                return $newState;
    3746        }
    38         public function __call($m, $a) {
    39                 if(isset($this->$m) && is_callable($this->$m))
     47
     48        public function __call($m, $a){
     49                if (isset($this->$m) && is_callable($this->$m)){
    4050                        return call_user_func_array($this->$m, $a);
    41                 else if(isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m]))
    42                         return call_user_func_array($this->__dynamics[$m], $a);
    43                 else if('toString' == $m)
    44                         return $this->__toString();
    45                 else
    46                         throw new HException('Unable to call <'.$m.'>');
     51                } else {
     52                        if (isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m])){
     53                                return call_user_func_array($this->__dynamics[$m], $a);
     54                        } else {
     55                                if ('toString'==$m){
     56                                        return $this->__toString();
     57                                } else {
     58                                        throw new HException('Unable to call <' . $m . '>');
     59                                }
     60                        }
     61                }
    4762        }
    48         function __toString() { return 'geometrize.State'; }
     63
     64        function __toString(){
     65                return 'geometrize.State';
     66        }
    4967}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/_ArraySet/ArraySet_Impl_.class.php

    r115817 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize__ArraySet_ArraySet_Impl_ {
    5         public function __construct(){}
    6         static function create($array = null) {
    7                 if($array === null) {
     5        public function __construct(){
     6        }
     7
     8        static function create($array = null){
     9                if ($array===null){
    810                        $this1 = (new _hx_array(array()));
    911                        return $this1;
     
    1113                return geometrize__ArraySet_ArraySet_Impl_::toSet($array);
    1214        }
    13         static function intersection($this1, $set) {
     15
     16        static function intersection($this1, $set){
    1417                $result = (new _hx_array(array()));
    1518                {
    1619                        $_g = 0;
    17                         while($_g < $this1->length) {
     20                        while ($_g<$this1->length){
    1821                                $element = $this1[$_g];
    19                                 $_g = $_g + 1;
    20                                 if(geometrize__ArraySet_ArraySet_Impl_::contains($set, $element)) {
     22                                $_g = $_g+1;
     23                                if (geometrize__ArraySet_ArraySet_Impl_::contains($set, $element)){
    2124                                        $result->push($element);
    2225                                }
     
    2730                return $this2;
    2831        }
    29         static function union($this1, $set) {
     32
     33        static function union($this1, $set){
    3034                return geometrize__ArraySet_ArraySet_Impl_::toSet($this1->concat(geometrize__ArraySet_ArraySet_Impl_::toArray($set)));
    3135        }
    32         static function unionArray($this1, $array) {
     36
     37        static function unionArray($this1, $array){
    3338                return geometrize__ArraySet_ArraySet_Impl_::toSet($this1->concat($array));
    3439        }
    35         static function difference($this1, $set) {
     40
     41        static function difference($this1, $set){
    3642                $this2 = $this1->copy();
    3743                $result = $this2;
    3844                {
    3945                        $element = $set->iterator();
    40                         while($element->hasNext()) {
     46                        while ($element->hasNext()){
    4147                                $element1 = $element->next();
    4248                                $result->remove($element1);
     
    4753                return $this3;
    4854        }
    49         static function add($this1, $element) {
    50                 if(!($element !== null)) {
     55
     56        static function add($this1, $element){
     57                if (!($element!==null)){
    5158                        throw new HException("FAIL: element != null");
    5259                }
    53                 if(geometrize__ArraySet_ArraySet_Impl_::contains($this1, $element)) {
     60                if (geometrize__ArraySet_ArraySet_Impl_::contains($this1, $element)){
    5461                        return false;
    5562                }
     
    5764                return true;
    5865        }
    59         static function contains($this1, $element) {
     66
     67        static function contains($this1, $element){
    6068                {
    6169                        $_g = 0;
    62                         while($_g < $this1->length) {
     70                        while ($_g<$this1->length){
    6371                                $i = $this1[$_g];
    64                                 $_g = $_g + 1;
    65                                 if((is_object($_t = $i) && ($_t instanceof Enum) ? $_t == $element : _hx_equal($_t, $element))) {
     72                                $_g = $_g+1;
     73                                if ((is_object($_t = $i) && ($_t instanceof Enum) ? $_t==$element : _hx_equal($_t, $element))){
    6674                                        return true;
    6775                                }
    68                                 unset($i,$_t);
     76                                unset($i, $_t);
    6977                        }
    7078                }
    7179                return false;
    7280        }
    73         static function copy($this1) {
     81
     82        static function copy($this1){
    7483                $this2 = $this1->copy();
    7584                return $this2;
    7685        }
    77         static function slice($this1, $position, $end = null) {
     86
     87        static function slice($this1, $position, $end = null){
    7888                $this2 = $this1->slice($position, $end);
    7989                return $this2;
    8090        }
    81         static function splice($this1, $position, $length) {
     91
     92        static function splice($this1, $position, $length){
    8293                $this2 = $this1->splice($position, $length);
    8394                return $this2;
    8495        }
    85         static function toArray($this1) {
     96
     97        static function toArray($this1){
    8698                return $this1->copy();
    8799        }
    88         static function toSet($array) {
     100
     101        static function toSet($array){
    89102                $this1 = (new _hx_array(array()));
    90103                $set = $this1;
    91104                {
    92105                        $_g = 0;
    93                         while($_g < $array->length) {
     106                        while ($_g<$array->length){
    94107                                $v = $array[$_g];
    95                                 $_g = $_g + 1;
     108                                $_g = $_g+1;
    96109                                geometrize__ArraySet_ArraySet_Impl_::add($set, $v);
    97110                                unset($v);
     
    100113                return $set;
    101114        }
    102         static function _new($array) {
     115
     116        static function _new($array){
    103117                $this1 = $array;
    104118                return $this1;
    105119        }
    106         function __toString() { return 'geometrize._ArraySet.ArraySet_Impl_'; }
     120
     121        function __toString(){
     122                return 'geometrize._ArraySet.ArraySet_Impl_';
     123        }
    107124}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/bitmap/Bitmap.class.php

    r115842 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize_bitmap_Bitmap {
    5         public function __construct() {
    6                 ;
    7         }
    85        public $width;
    96        public $height;
    107        public $data;
    11         public function getPixel($x, $y) {
    12                 return $this->data[$this->width * $y + $x];
    13         }
    14         public function setPixel($x, $y, $color) {
    15                 $this->data[$this->width * $y + $x] = $color;
    16         }
    17         public function hclone() {
     8
     9        public function __construct(){
     10                ;
     11        }
     12
     13        public function getPixel($x, $y){
     14                return $this->data[$this->width*$y+$x];
     15        }
     16
     17        public function setPixel($x, $y, $color){
     18                $this->data[$this->width*$y+$x] = $color;
     19        }
     20
     21        public function hclone(){
    1822                $bitmap = new geometrize_bitmap_Bitmap();
    1923                $bitmap->width = $this->width;
     
    2529                        $_g1 = 0;
    2630                        $_g = $this->data->length;
    27                         while($_g1 < $_g) {
    28                                 $_g1 = $_g1 + 1;
    29                                 $i = $_g1 - 1;
     31                        while ($_g1<$_g){
     32                                $_g1 = $_g1+1;
     33                                $i = $_g1-1;
    3034                                $bitmap->data[$i] = $this->data[$i];
    3135                                unset($i);
     
    3438                return $bitmap;
    3539        }
    36         public function fill($color) {
     40
     41        public function fill($color){
    3742                $idx = 0;
    38                 while($idx < $this->data->length) {
     43                while ($idx<$this->data->length){
    3944                        $this->data[$idx] = $color >> 24 & 255;
    40                         $this->data[$idx + 1] = $color >> 16 & 255;
    41                         $this->data[$idx + 2] = $color >> 8 & 255;
    42                         $this->data[$idx + 3] = $color & 255;
    43                         $idx = $idx + 4;
    44                 }
    45         }
    46         public function getBytes() {
    47                 $bytes = haxe_io_Bytes::alloc($this->data->length * 4);
     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;
     49                }
     50        }
     51
     52        public function getBytes(){
     53                $bytes = haxe_io_Bytes::alloc($this->data->length*4);
    4854                $i = 0;
    49                 while($i < $this->data->length) {
    50                         $idx = $i * 4;
     55                while ($i<$this->data->length){
     56                        $idx = $i*4;
    5157                        {
    5258                                $v = $this->data[$i] >> 24 & 255;
     
    6268                                {
    6369                                        $this2 = $bytes->b;
    64                                         $this2->s[$idx + 1] = chr($v1);
     70                                        $this2->s[$idx+1] = chr($v1);
    6571                                        unset($this2);
    6672                                }
     
    7177                                {
    7278                                        $this3 = $bytes->b;
    73                                         $this3->s[$idx + 2] = chr($v2);
     79                                        $this3->s[$idx+2] = chr($v2);
    7480                                        unset($this3);
    7581                                }
     
    8086                                {
    8187                                        $this4 = $bytes->b;
    82                                         $this4->s[$idx + 3] = chr($v3);
     88                                        $this4->s[$idx+3] = chr($v3);
    8389                                        unset($this4);
    8490                                }
    8591                                unset($v3);
    8692                        }
    87                         $i = $i + 1;
     93                        $i = $i+1;
    8894                        unset($idx);
    8995                }
    9096                return $bytes;
    9197        }
    92         public function __call($m, $a) {
    93                 if(isset($this->$m) && is_callable($this->$m))
     98
     99        public function __call($m, $a){
     100                if (isset($this->$m) && is_callable($this->$m)){
    94101                        return call_user_func_array($this->$m, $a);
    95                 else if(isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m]))
    96                         return call_user_func_array($this->__dynamics[$m], $a);
    97                 else if('toString' == $m)
    98                         return $this->__toString();
    99                 else
    100                         throw new HException('Unable to call <'.$m.'>');
    101         }
    102         static function create($w, $h, $color) {
     102                } else {
     103                        if (isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m])){
     104                                return call_user_func_array($this->__dynamics[$m], $a);
     105                        } else {
     106                                if ('toString'==$m){
     107                                        return $this->__toString();
     108                                } else {
     109                                        throw new HException('Unable to call <' . $m . '>');
     110                                }
     111                        }
     112                }
     113        }
     114
     115        static function create($w, $h, $color){
    103116                $bitmap = new geometrize_bitmap_Bitmap();
    104117                $bitmap->width = $w;
    105118                $bitmap->height = $h;
    106119                $this1 = (new _hx_array(array()));
    107                 $this1->length = $w * $h;
     120                $this1->length = $w*$h;
    108121                $bitmap->data = $this1;
    109122                $i = 0;
    110                 while($i < $bitmap->data->length) {
     123                while ($i<$bitmap->data->length){
    111124                        $bitmap->data[$i] = $color;
    112                         $i = $i + 1;
     125                        $i = $i+1;
    113126                }
    114127                return $bitmap;
    115128        }
    116         static function createFromBytes($w, $h, $bytes) {
     129
     130        static function createFromBytes($w, $h, $bytes){
    117131                $bitmap = new geometrize_bitmap_Bitmap();
    118                 if(!($bytes !== null)) {
     132                if (!($bytes!==null)){
    119133                        throw new HException("FAIL: bytes != null");
    120134                }
    121135                {
    122136                        $actual = $bytes->length;
    123                         $expected = $w * $h * 4;
    124                         if($actual !== $expected) {
     137                        $expected = $w*$h*4;
     138                        if ($actual!==$expected){
    125139                                throw new HException("FAIL: values are not equal (expected: " . _hx_string_rec($expected, "") . ", actual: " . _hx_string_rec($actual, "") . ")");
    126140                        }
     
    129143                $bitmap->height = $h;
    130144                $this1 = (new _hx_array(array()));
    131                 $this1->length = intval($bytes->length / 4);
     145                $this1->length = intval($bytes->length/4);
    132146                $bitmap->data = $this1;
    133147                $i = 0;
    134148                $x = 0;
    135                 while($i < $bytes->length) {
     149                while ($i<$bytes->length){
    136150                        {
    137151                                $this2 = $bitmap->data;
     
    139153                                $red = ord($this3->s[$i]);
    140154                                $this4 = $bytes->b;
    141                                 $green = ord($this4->s[$i + 1]);
     155                                $green = ord($this4->s[$i+1]);
    142156                                $this5 = $bytes->b;
    143                                 $blue = ord($this5->s[$i + 2]);
     157                                $blue = ord($this5->s[$i+2]);
    144158                                $this6 = $bytes->b;
    145                                 $alpha = ord($this6->s[$i + 3]);
    146                                 if(!true) {
     159                                $alpha = ord($this6->s[$i+3]);
     160                                if (!true){
    147161                                        throw new HException("FAIL: min <= max");
    148162                                }
    149163                                $val = null;
    150                                 if($red < 0) {
     164                                if ($red<0){
    151165                                        $val = 0;
    152166                                } else {
    153                                         if($red > 255) {
     167                                        if ($red>255){
    154168                                                $val = 255;
    155169                                        } else {
     
    157171                                        }
    158172                                }
    159                                 if(!true) {
     173                                if (!true){
    160174                                        throw new HException("FAIL: min <= max");
    161175                                }
    162176                                $val1 = null;
    163                                 if($green < 0) {
     177                                if ($green<0){
    164178                                        $val1 = 0;
    165179                                } else {
    166                                         if($green > 255) {
     180                                        if ($green>255){
    167181                                                $val1 = 255;
    168182                                        } else {
     
    170184                                        }
    171185                                }
    172                                 if(!true) {
     186                                if (!true){
    173187                                        throw new HException("FAIL: min <= max");
    174188                                }
    175189                                $val2 = null;
    176                                 if($blue < 0) {
     190                                if ($blue<0){
    177191                                        $val2 = 0;
    178192                                } else {
    179                                         if($blue > 255) {
     193                                        if ($blue>255){
    180194                                                $val2 = 255;
    181195                                        } else {
     
    183197                                        }
    184198                                }
    185                                 if(!true) {
     199                                if (!true){
    186200                                        throw new HException("FAIL: min <= max");
    187201                                }
    188202                                $val3 = null;
    189                                 if($alpha < 0) {
     203                                if ($alpha<0){
    190204                                        $val3 = 0;
    191205                                } else {
    192                                         if($alpha > 255) {
     206                                        if ($alpha>255){
    193207                                                $val3 = 255;
    194208                                        } else {
     
    196210                                        }
    197211                                }
    198                                 $this2[$x] = ($val << 24) + ($val1 << 16) + ($val2 << 8) + $val3;
    199                                 unset($val3,$val2,$val1,$val,$this6,$this5,$this4,$this3,$this2,$red,$green,$blue,$alpha);
    200                         }
    201                         $i = $i + 4;
    202                         $x = $x + 1;
     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;
    203217                }
    204218                return $bitmap;
    205219        }
    206         static function createFromByteArray($w, $h, $bytes) {
     220
     221        static function createFromByteArray($w, $h, $bytes){
    207222                $data = haxe_io_Bytes::alloc($bytes->length);
    208223                $i = 0;
    209                 while($i < $bytes->length) {
     224                while ($i<$bytes->length){
    210225                        {
    211226                                $this1 = $data->b;
     
    213228                                unset($this1);
    214229                        }
    215                         $i = $i + 1;
     230                        $i = $i+1;
    216231                }
    217232                $bitmap = new geometrize_bitmap_Bitmap();
    218                 if(!($data !== null)) {
     233                if (!($data!==null)){
    219234                        throw new HException("FAIL: bytes != null");
    220235                }
    221236                {
    222237                        $actual = $data->length;
    223                         $expected = $w * $h * 4;
    224                         if($actual !== $expected) {
     238                        $expected = $w*$h*4;
     239                        if ($actual!==$expected){
    225240                                throw new HException("FAIL: values are not equal (expected: " . _hx_string_rec($expected, "") . ", actual: " . _hx_string_rec($actual, "") . ")");
    226241                        }
     
    229244                $bitmap->height = $h;
    230245                $this2 = (new _hx_array(array()));
    231                 $this2->length = intval($data->length / 4);
     246                $this2->length = intval($data->length/4);
    232247                $bitmap->data = $this2;
    233248                $i1 = 0;
    234249                $x = 0;
    235                 while($i1 < $data->length) {
     250                while ($i1<$data->length){
    236251                        {
    237252                                $this3 = $bitmap->data;
     
    239254                                $red = ord($this4->s[$i1]);
    240255                                $this5 = $data->b;
    241                                 $green = ord($this5->s[$i1 + 1]);
     256                                $green = ord($this5->s[$i1+1]);
    242257                                $this6 = $data->b;
    243                                 $blue = ord($this6->s[$i1 + 2]);
     258                                $blue = ord($this6->s[$i1+2]);
    244259                                $this7 = $data->b;
    245                                 $alpha = ord($this7->s[$i1 + 3]);
    246                                 if(!true) {
     260                                $alpha = ord($this7->s[$i1+3]);
     261                                if (!true){
    247262                                        throw new HException("FAIL: min <= max");
    248263                                }
    249264                                $val = null;
    250                                 if($red < 0) {
     265                                if ($red<0){
    251266                                        $val = 0;
    252267                                } else {
    253                                         if($red > 255) {
     268                                        if ($red>255){
    254269                                                $val = 255;
    255270                                        } else {
     
    257272                                        }
    258273                                }
    259                                 if(!true) {
     274                                if (!true){
    260275                                        throw new HException("FAIL: min <= max");
    261276                                }
    262277                                $val1 = null;
    263                                 if($green < 0) {
     278                                if ($green<0){
    264279                                        $val1 = 0;
    265280                                } else {
    266                                         if($green > 255) {
     281                                        if ($green>255){
    267282                                                $val1 = 255;
    268283                                        } else {
     
    270285                                        }
    271286                                }
    272                                 if(!true) {
     287                                if (!true){
    273288                                        throw new HException("FAIL: min <= max");
    274289                                }
    275290                                $val2 = null;
    276                                 if($blue < 0) {
     291                                if ($blue<0){
    277292                                        $val2 = 0;
    278293                                } else {
    279                                         if($blue > 255) {
     294                                        if ($blue>255){
    280295                                                $val2 = 255;
    281296                                        } else {
     
    283298                                        }
    284299                                }
    285                                 if(!true) {
     300                                if (!true){
    286301                                        throw new HException("FAIL: min <= max");
    287302                                }
    288303                                $val3 = null;
    289                                 if($alpha < 0) {
     304                                if ($alpha<0){
    290305                                        $val3 = 0;
    291306                                } else {
    292                                         if($alpha > 255) {
     307                                        if ($alpha>255){
    293308                                                $val3 = 255;
    294309                                        } else {
     
    296311                                        }
    297312                                }
    298                                 $this3[$x] = ($val << 24) + ($val1 << 16) + ($val2 << 8) + $val3;
    299                                 unset($val3,$val2,$val1,$val,$this7,$this6,$this5,$this4,$this3,$red,$green,$blue,$alpha);
    300                         }
    301                         $i1 = $i1 + 4;
    302                         $x = $x + 1;
     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;
    303318                }
    304319                return $bitmap;
    305320        }
    306         function __toString() { return 'geometrize.bitmap.Bitmap'; }
     321
     322        function __toString(){
     323                return 'geometrize.bitmap.Bitmap';
     324        }
    307325}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/exporter/SvgExporter.class.php

    r115817 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize_exporter_SvgExporter {
    5         public function __construct(){}
     5        public function __construct(){
     6        }
     7
    68        static $SVG_STYLE_HOOK = "::svg_style_hook::";
    7         static function export($shapes, $width, $height) {
     9
     10        static function export($shapes, $width, $height){
    811                $results = geometrize_exporter_SvgExporter::getSvgPrelude();
    912                $results = _hx_string_or_null($results) . _hx_string_or_null(geometrize_exporter_SvgExporter::getSvgNodeOpen($width, $height));
     
    1215                return $results;
    1316        }
    14         static function exportShapes($shapes) {
     17
     18        static function exportShapes($shapes){
    1519                $results = "";
    1620                {
    1721                        $_g1 = 0;
    1822                        $_g = $shapes->length;
    19                         while($_g1 < $_g) {
    20                                 $_g1 = $_g1 + 1;
    21                                 $i = $_g1 - 1;
     23                        while ($_g1<$_g){
     24                                $_g1 = $_g1+1;
     25                                $i = $_g1-1;
    2226                                $results = _hx_string_or_null($results) . _hx_string_or_null(geometrize_exporter_SvgExporter::exportShape($shapes[$i]));
    23                                 if($i !== $shapes->length - 1) {
     27                                if ($i!==$shapes->length-1){
    2428                                        $results = _hx_string_or_null($results) . "\x0A";
    2529                                }
     
    2933                return $results;
    3034        }
    31         static function exportShape($shape) {
     35
     36        static function exportShape($shape){
    3237                $s = $shape->shape->getSvgShapeData();
    3338                $sub = geometrize_exporter_SvgExporter::$SVG_STYLE_HOOK;
    3439                $by = geometrize_exporter_SvgExporter::stylesForShape($shape);
    35                 if($sub === "") {
    36                         return implode(str_split ($s), $by);
     40                if ($sub===""){
     41                        return implode(str_split($s), $by);
    3742                } else {
    3843                        return str_replace($sub, $by, $s);
    3944                }
    4045        }
    41         static function getSvgPrelude() {
     46
     47        static function getSvgPrelude(){
    4248                return "<?xml version=\"1.0\" standalone=\"no\"?>\x0A";
    4349        }
    44         static function getSvgNodeOpen($width, $height) {
     50
     51        static function getSvgNodeOpen($width, $height){
    4552                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";
    4653        }
    47         static function getSvgNodeClose() {
     54
     55        static function getSvgNodeClose(){
    4856                return "</svg>";
    4957        }
    50         static function stylesForShape($shape) {
     58
     59        static function stylesForShape($shape){
    5160                $_g = $shape->shape->getType();
    52                 switch($_g) {
    53                 case 6:case 7:{
    54                         $tmp = _hx_string_or_null(geometrize_exporter_SvgExporter::strokeForColor($shape->color)) . " stroke-width=\"1\" fill=\"none\" ";
    55                         return _hx_string_or_null($tmp) . _hx_string_or_null(geometrize_exporter_SvgExporter::strokeOpacityForAlpha($shape->color & 255));
    56                 }break;
    57                 default:{
    58                         $tmp1 = _hx_string_or_null(geometrize_exporter_SvgExporter::fillForColor($shape->color)) . " ";
    59                         return _hx_string_or_null($tmp1) . _hx_string_or_null(geometrize_exporter_SvgExporter::fillOpacityForAlpha($shape->color & 255));
    60                 }break;
     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                                }
     68                                break;
     69                        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                                }
     74                                break;
    6175                }
    6276        }
    63         static function rgbForColor($color) {
     77
     78        static function rgbForColor($color){
    6479                return "rgb(" . _hx_string_rec(($color >> 24 & 255), "") . "," . _hx_string_rec(($color >> 16 & 255), "") . "," . _hx_string_rec(($color >> 8 & 255), "") . ")";
    6580        }
    66         static function strokeForColor($color) {
     81
     82        static function strokeForColor($color){
    6783                return "stroke=\"" . _hx_string_or_null(geometrize_exporter_SvgExporter::rgbForColor($color)) . "\"";
    6884        }
    69         static function fillForColor($color) {
     85
     86        static function fillForColor($color){
    7087                return "fill=\"" . _hx_string_or_null(geometrize_exporter_SvgExporter::rgbForColor($color)) . "\"";
    7188        }
    72         static function fillOpacityForAlpha($alpha) {
    73                 return "fill-opacity=\"" . _hx_string_rec($alpha / 255.0, "") . "\"";
     89
     90        static function fillOpacityForAlpha($alpha){
     91                return "fill-opacity=\"" . _hx_string_rec($alpha/255.0, "") . "\"";
    7492        }
    75         static function strokeOpacityForAlpha($alpha) {
    76                 return "stroke-opacity=\"" . _hx_string_rec($alpha / 255.0, "") . "\"";
     93
     94        static function strokeOpacityForAlpha($alpha){
     95                return "stroke-opacity=\"" . _hx_string_rec($alpha/255.0, "") . "\"";
    7796        }
    78         function __toString() { return 'geometrize.exporter.SvgExporter'; }
     97
     98        function __toString(){
     99                return 'geometrize.exporter.SvgExporter';
     100        }
    79101}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/rasterizer/Rasterizer.class.php

    r115842 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize_rasterizer_Rasterizer {
    5         public function __construct(){}
    6         static function drawLines($image, $c, $lines) {
     5        public function __construct(){
     6        }
     7
     8        static function drawLines($image, $c, $lines){
    79
    810                // easy case: opacity=1, just a copy of the color $c, much faster
    9                 if ($c & 255 === 255) {
    10                         for($_g=0;$_g < $lines->length;$_g++) {
     11                if ($c & 255===255){
     12                        for ($_g = 0; $_g<$lines->length; $_g++){
    1113                                $line = &$lines[$_g];
    12                                 $_g1 = $line->x2 + 1;
    13                                 $o = $image->width * $line->y;
    14                                 for ($x = $line->x1;$x<$_g1;$x++) {
    15                                         $image->data[$o + $x] = $c;
    16                                 }
    17                         }
    18                 }
    19                 else {
     14                                $_g1 = $line->x2+1;
     15                                $o = $image->width*$line->y;
     16                                for ($x = $line->x1; $x<$_g1; $x++){
     17                                        $image->data[$o+$x] = $c;
     18                                        if (isset($image->errorCache) && isset($image->errorCache[$o+$x])){
     19                                                unset($image->errorCache[$o+$x]);
     20                                        }
     21                                }
     22                        }
     23                } else {
    2024                        $sr = $c >> 24 & 255;
    2125                        $sr = $sr | $sr << 8;
    22                         $sr = $sr * ($c & 255);
    23                         $sr = intval($sr / 255);
     26                        $sr = $sr*($c & 255);
     27                        $sr = intval($sr/255);
    2428                        $sg = $c >> 16 & 255;
    2529                        $sg = $sg | $sg << 8;
    26                         $sg = $sg * ($c & 255);
    27                         $sg = intval($sg / 255);
     30                        $sg = $sg*($c & 255);
     31                        $sg = intval($sg/255);
    2832                        $sb = $c >> 8 & 255;
    2933                        $sb = $sb | $sb << 8;
    30                         $sb = $sb * ($c & 255);
    31                         $sb = intval($sb / 255);
     34                        $sb = $sb*($c & 255);
     35                        $sb = intval($sb/255);
    3236                        $sa = $c & 255;
    3337                        $sa = $sa | $sa << 8;
    3438                        {
    3539                                $_g = 0;
    36                                 while($_g < $lines->length) {
     40                                while ($_g<$lines->length){
    3741                                        $line = $lines[$_g];
    38                                         $_g = $_g + 1;
     42                                        $_g = $_g+1;
    3943                                        $y = $line->y;
    4044                                        $ma = 65535;
    4145                                        $m = 65535;
    42                                         $as = ($m - $sa * ($ma / $m)) * 257;
     46                                        $as = ($m-$sa*($ma/$m))*257;
    4347                                        $a = intval($as);
    4448                                        {
    4549                                                $_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];
     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];
    5155                                                        $dr = $d >> 24 & 255;
    5256                                                        $dg = $d >> 16 & 255;
    5357                                                        $db = $d >> 8 & 255;
    5458                                                        $da = $d & 255;
    55                                                         $int = $dr * $a + $sr * $ma;
     59                                                        $int = $dr*$a+$sr*$ma;
    5660                                                        $r = null;
    57                                                         if($int < 0) {
    58                                                                 $r = 4294967296.0 + $int;
    59                                                         } else {
    60                                                                 $r = $int + 0.0;
     61                                                        if ($int<0){
     62                                                                $r = 4294967296.0+$int;
     63                                                        } else {
     64                                                                $r = $int+0.0;
    6165                                                        }
    6266                                                        $int1 = $m;
    6367                                                        $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;
     68                                                        if ($int1<0){
     69                                                                $r1 = 4294967296.0+$int1;
     70                                                        } else {
     71                                                                $r1 = $int1+0.0;
     72                                                        }
     73                                                        $r2 = intval($r/$r1) >> 8;
     74                                                        $int2 = $dg*$a+$sg*$ma;
    7175                                                        $g = null;
    72                                                         if($int2 < 0) {
    73                                                                 $g = 4294967296.0 + $int2;
    74                                                         } else {
    75                                                                 $g = $int2 + 0.0;
     76                                                        if ($int2<0){
     77                                                                $g = 4294967296.0+$int2;
     78                                                        } else {
     79                                                                $g = $int2+0.0;
    7680                                                        }
    7781                                                        $int3 = $m;
    7882                                                        $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;
     83                                                        if ($int3<0){
     84                                                                $g1 = 4294967296.0+$int3;
     85                                                        } else {
     86                                                                $g1 = $int3+0.0;
     87                                                        }
     88                                                        $g2 = intval($g/$g1) >> 8;
     89                                                        $int4 = $db*$a+$sb*$ma;
    8690                                                        $b = null;
    87                                                         if($int4 < 0) {
    88                                                                 $b = 4294967296.0 + $int4;
    89                                                         } else {
    90                                                                 $b = $int4 + 0.0;
     91                                                        if ($int4<0){
     92                                                                $b = 4294967296.0+$int4;
     93                                                        } else {
     94                                                                $b = $int4+0.0;
    9195                                                        }
    9296                                                        $int5 = $m;
    9397                                                        $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;
     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;
    101105                                                        $a1 = null;
    102                                                         if($int6 < 0) {
    103                                                                 $a1 = 4294967296.0 + $int6;
    104                                                         } else {
    105                                                                 $a1 = $int6 + 0.0;
     106                                                        if ($int6<0){
     107                                                                $a1 = 4294967296.0+$int6;
     108                                                        } else {
     109                                                                $a1 = $int6+0.0;
    106110                                                        }
    107111                                                        $int7 = $m;
    108112                                                        $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;
     113                                                        if ($int7<0){
     114                                                                $a2 = 4294967296.0+$int7;
     115                                                        } else {
     116                                                                $a2 = $int7+0.0;
     117                                                        }
     118                                                        $a3 = intval($a1/$a2) >> 8;
    115119                                                        {
    116                                                                 if(!true) {
     120                                                                if (!true){
    117121                                                                        throw new HException("FAIL: min <= max");
    118122                                                                }
    119123                                                                $color = null;
    120                                                                 if($r2 < 0) {
     124                                                                if ($r2<0){
    121125                                                                        $color = 0;
    122126                                                                } else {
    123                                                                         if($r2 > 255) {
     127                                                                        if ($r2>255){
    124128                                                                                $color = 255;
    125129                                                                        } else {
     
    127131                                                                        }
    128132                                                                }
    129                                                                 if(!true) {
     133                                                                if (!true){
    130134                                                                        throw new HException("FAIL: min <= max");
    131135                                                                }
    132136                                                                $color1 = null;
    133                                                                 if($g2 < 0) {
     137                                                                if ($g2<0){
    134138                                                                        $color1 = 0;
    135139                                                                } else {
    136                                                                         if($g2 > 255) {
     140                                                                        if ($g2>255){
    137141                                                                                $color1 = 255;
    138142                                                                        } else {
     
    140144                                                                        }
    141145                                                                }
    142                                                                 if(!true) {
     146                                                                if (!true){
    143147                                                                        throw new HException("FAIL: min <= max");
    144148                                                                }
    145149                                                                $color2 = null;
    146                                                                 if($b2 < 0) {
     150                                                                if ($b2<0){
    147151                                                                        $color2 = 0;
    148152                                                                } else {
    149                                                                         if($b2 > 255) {
     153                                                                        if ($b2>255){
    150154                                                                                $color2 = 255;
    151155                                                                        } else {
     
    153157                                                                        }
    154158                                                                }
    155                                                                 if(!true) {
     159                                                                if (!true){
    156160                                                                        throw new HException("FAIL: min <= max");
    157161                                                                }
    158162                                                                $color3 = null;
    159                                                                 if($a3 < 0) {
     163                                                                if ($a3<0){
    160164                                                                        $color3 = 0;
    161165                                                                } else {
    162                                                                         if($a3 > 255) {
     166                                                                        if ($a3>255){
    163167                                                                                $color3 = 255;
    164168                                                                        } else {
     
    166170                                                                        }
    167171                                                                }
    168                                                                 $image->data[$image->width * $y + $x] = ($color << 24) + ($color1 << 16) + ($color2 << 8) + $color3;
    169                                                                 unset($color3,$color2,$color1,$color);
    170                                                         }
    171                                                         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);
     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);
    172179                                                }
    173                                                 unset($_g2,$_g1);
     180                                                unset($_g2, $_g1);
    174181                                        }
    175                                         unset($y,$ma,$m,$line,$as,$a);
    176                                 }
    177                         }
    178                 }
    179         }
    180         static function copyLines($destination, $source, $lines) {
    181                 if(!($destination !== null)) {
     182                                        unset($y, $ma, $m, $line, $as, $a);
     183                                }
     184                        }
     185                }
     186        }
     187
     188        static function copyLines($destination, $source, $lines){
     189                if (!($destination!==null)){
    182190                        throw new HException("FAIL: destination != null");
    183191                }
    184                 if(!($source !== null)) {
     192                if (!($source!==null)){
    185193                        throw new HException("FAIL: source != null");
    186194                }
    187                 if(!($lines !== null)) {
     195                if (!($lines!==null)){
    188196                        throw new HException("FAIL: lines != null");
    189197                }
    190                 for($_g=0;$_g < $lines->length;$_g++) {
     198
     199                for ($_g = 0; $_g<$lines->length; $_g++){
    191200                        $line = &$lines[$_g];
    192                         $_g1 = $line->x2 + 1;
    193                         $o1 = $source->width * $line->y;
    194                         $o2 = $destination->width * $line->y;
    195                         for ($x = $line->x1;$x<$_g1;$x++) {
    196                                 $destination->data[$o2 + $x] = $source->data[$o1 + $x];
    197                         }
    198                 }
    199 /*
    200                 {
    201                         $_g = 0;
    202                         while($_g < $lines->length) {
    203                                 $line = $lines[$_g];
    204                                 $_g = $_g + 1;
    205                                 $y = $line->y;
    206                                 {
    207                                         $_g2 = $line->x1;
    208                                         $_g1 = $line->x2 + 1;
    209                                         while($_g2 < $_g1) {
    210                                                 $_g2 = $_g2 + 1;
    211                                                 $x = $_g2 - 1;
    212                                                 $destination->data[$destination->width * $y + $x] = $source->data[$source->width * $y + $x];
    213                                                 unset($x);
    214                                         }
    215                                         unset($_g2,$_g1);
    216                                 }
    217                                 unset($y,$line);
    218                         }
    219                 }*/
    220         }
    221         static function bresenham($x1, $y1, $x2, $y2) {
    222                 $dx = $x2 - $x1;
     201                        $_g1 = $line->x2+1;
     202                        $o1 = $source->width*$line->y;
     203                        $o2 = $destination->width*$line->y;
     204                        for ($x = $line->x1; $x<$_g1; $x++){
     205                                $destination->data[$o2+$x] = $source->data[$o1+$x];
     206                        }
     207                }
     208        }
     209
     210        static function bresenham($x1, $y1, $x2, $y2){
     211                $dx = $x2-$x1;
    223212                $ix = null;
    224                 if($dx > 0) {
     213                if ($dx>0){
    225214                        $ix = 1;
    226215                } else {
     
    228217                }
    229218                $ix1 = null;
    230                 if($dx < 0) {
     219                if ($dx<0){
    231220                        $ix1 = 1;
    232221                } else {
    233222                        $ix1 = 0;
    234223                }
    235                 $ix2 = $ix - $ix1;
     224                $ix2 = $ix-$ix1;
    236225                $dx1 = null;
    237                 if($dx < 0) {
     226                if ($dx<0){
    238227                        $dx1 = -$dx;
    239228                } else {
     
    241230                }
    242231                $dx = $dx1 << 1;
    243                 $dy = $y2 - $y1;
     232                $dy = $y2-$y1;
    244233                $iy = null;
    245                 if($dy > 0) {
     234                if ($dy>0){
    246235                        $iy = 1;
    247236                } else {
     
    249238                }
    250239                $iy1 = null;
    251                 if($dy < 0) {
     240                if ($dy<0){
    252241                        $iy1 = 1;
    253242                } else {
    254243                        $iy1 = 0;
    255244                }
    256                 $iy2 = $iy - $iy1;
     245                $iy2 = $iy-$iy1;
    257246                $dy1 = null;
    258                 if($dy < 0) {
     247                if ($dy<0){
    259248                        $dy1 = -$dy;
    260249                } else {
     
    264253                $points = (new _hx_array(array()));
    265254                $points->push(_hx_anonymous(array("x" => $x1, "y" => $y1)));
    266                 if($dx >= $dy) {
    267                         $error = $dy - ($dx >> 1);
    268                         while($x1 !== $x2) {
     255                if ($dx>=$dy){
     256                        $error = $dy-($dx >> 1);
     257                        while ($x1!==$x2){
    269258                                $tmp = null;
    270                                 if($error >= 0) {
    271                                         if($error === 0) {
    272                                                 $tmp = $ix2 > 0;
     259                                if ($error>=0){
     260                                        if ($error===0){
     261                                                $tmp = $ix2>0;
    273262                                        } else {
    274263                                                $tmp = true;
     
    277266                                        $tmp = false;
    278267                                }
    279                                 if($tmp) {
    280                                         $error = $error - $dx;
    281                                         $y1 = $y1 + $iy2;
    282                                 }
    283                                 $error = $error + $dy;
    284                                 $x1 = $x1 + $ix2;
     268                                if ($tmp){
     269                                        $error = $error-$dx;
     270                                        $y1 = $y1+$iy2;
     271                                }
     272                                $error = $error+$dy;
     273                                $x1 = $x1+$ix2;
    285274                                $points->push(_hx_anonymous(array("x" => $x1, "y" => $y1)));
    286275                                unset($tmp);
    287276                        }
    288277                } else {
    289                         $error1 = $dx - ($dy >> 1);
    290                         while($y1 !== $y2) {
     278                        $error1 = $dx-($dy >> 1);
     279                        while ($y1!==$y2){
    291280                                $tmp1 = null;
    292                                 if($error1 >= 0) {
    293                                         if($error1 === 0) {
    294                                                 $tmp1 = $iy2 > 0;
     281                                if ($error1>=0){
     282                                        if ($error1===0){
     283                                                $tmp1 = $iy2>0;
    295284                                        } else {
    296285                                                $tmp1 = true;
     
    299288                                        $tmp1 = false;
    300289                                }
    301                                 if($tmp1) {
    302                                         $error1 = $error1 - $dy;
    303                                         $x1 = $x1 + $ix2;
    304                                 }
    305                                 $error1 = $error1 + $dx;
    306                                 $y1 = $y1 + $iy2;
     290                                if ($tmp1){
     291                                        $error1 = $error1-$dy;
     292                                        $x1 = $x1+$ix2;
     293                                }
     294                                $error1 = $error1+$dx;
     295                                $y1 = $y1+$iy2;
    307296                                $points->push(_hx_anonymous(array("x" => $x1, "y" => $y1)));
    308297                                unset($tmp1);
     
    311300                return $points;
    312301        }
    313         static function scanlinesForPolygon($points) {
     302
     303        static function scanlinesForPolygon($points){
    314304                $lines = (new _hx_array(array()));
    315305                $edges = (new _hx_array(array()));
     
    317307                        $_g1 = 0;
    318308                        $_g = $points->length;
    319                         while($_g1 < $_g) {
    320                                 $_g1 = $_g1 + 1;
    321                                 $i = $_g1 - 1;
     309                        while ($_g1<$_g){
     310                                $_g1 = $_g1+1;
     311                                $i = $_g1-1;
    322312                                $p1 = $points[$i];
    323313                                $p2 = null;
    324                                 if($i === $points->length - 1) {
     314                                if ($i===$points->length-1){
    325315                                        $p2 = $points[0];
    326316                                } else {
    327                                         $p2 = $points[$i + 1];
     317                                        $p2 = $points[$i+1];
    328318                                }
    329319                                $p1p2 = geometrize_rasterizer_Rasterizer::bresenham($p1->x, $p1->y, $p2->x, $p2->y);
    330320                                $edges = $edges->concat($p1p2);
    331                                 unset($p2,$p1p2,$p1,$i);
     321                                unset($p2, $p1p2, $p1, $i);
    332322                        }
    333323                }
    334324                $yToXs = [];
    335                 for ($_g2 = 0;$_g2 < $edges->length;$_g2++) {
     325                for ($_g2 = 0; $_g2<$edges->length; $_g2++){
    336326                        $point = $edges[$_g2];
    337                         if (!isset($yToXs[$point->y])) {
     327                        if (!isset($yToXs[$point->y])){
    338328                                $yToXs[$point->y] = [];
    339329                        }
     
    341331                }
    342332                ksort($yToXs);
    343                 foreach ($yToXs as $y => $xs) {
     333                foreach ($yToXs as $y => $xs){
    344334                        $minx = min($xs);
    345335                        $maxx = max($xs);
    346336                        $lines->push(new geometrize_rasterizer_Scanline($y, $minx, $maxx));
    347337                }
    348 /*
    349 
    350                 $yToXs = new haxe_ds_IntMap();
    351                 {
    352                         $_g2 = 0;
    353                         while($_g2 < $edges->length) {
    354                                 $point = $edges[$_g2];
    355                                 $_g2 = $_g2 + 1;
    356                                 $s = $yToXs->get($point->y);
    357                                 if($s !== null) {
    358                                         geometrize__ArraySet_ArraySet_Impl_::add($s, $point->x);
    359                                 } else {
    360                                         $s = geometrize__ArraySet_ArraySet_Impl_::create(null);
    361                                         geometrize__ArraySet_ArraySet_Impl_::add($s, $point->x);
    362                                         $yToXs->set($point->y, $s);
    363                                 }
    364                                 unset($s,$point);
    365                         }
    366                 }
    367                 {
    368                         $key = $yToXs->keys();
    369                         while($key->hasNext()) {
    370                                 $key1 = $key->next();
    371                                 $a = geometrize__ArraySet_ArraySet_Impl_::toArray($yToXs->get($key1));
    372                                 $minMaxElements = null;
    373                                 $minMaxElements1 = null;
    374                                 if($a !== null) {
    375                                         $minMaxElements1 = $a->length === 0;
    376                                 } else {
    377                                         $minMaxElements1 = true;
    378                                 }
    379                                 if($minMaxElements1) {
    380                                         $minMaxElements = _hx_anonymous(array("x" => 0, "y" => 0));
    381                                 } else {
    382                                         $min = $a[0];
    383                                         $max = $a[0];
    384                                         {
    385                                                 $_g3 = 0;
    386                                                 while($_g3 < $a->length) {
    387                                                         $value = $a[$_g3];
    388                                                         $_g3 = $_g3 + 1;
    389                                                         if($min > $value) {
    390                                                                 $min = $value;
    391                                                         }
    392                                                         if($max < $value) {
    393                                                                 $max = $value;
    394                                                         }
    395                                                         unset($value);
    396                                                 }
    397                                                 unset($_g3);
    398                                         }
    399                                         $minMaxElements = _hx_anonymous(array("x" => $min, "y" => $max));
    400                                         unset($min,$max);
    401                                 }
    402                                 $lines->push(new geometrize_rasterizer_Scanline($key1, $minMaxElements->x, $minMaxElements->y));
    403                                 unset($minMaxElements1,$minMaxElements,$key1,$a);
    404                         }
    405                 }
    406 */
     338
    407339                return $lines;
    408340        }
    409         function __toString() { return 'geometrize.rasterizer.Rasterizer'; }
     341
     342        function __toString(){
     343                return 'geometrize.rasterizer.Rasterizer';
     344        }
    410345}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/rasterizer/Scanline.class.php

    r115817 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize_rasterizer_Scanline {
    5         public function __construct($y, $x1, $x2) {
    6                 if(!php_Boot::$skip_constructor) {
    7                 $this->y = $y;
    8                 $this->x1 = $x1;
    9                 $this->x2 = $x2;
    10         }}
    115        public $y;
    126        public $x1;
    137        public $x2;
    14         public function __call($m, $a) {
    15                 if(isset($this->$m) && is_callable($this->$m))
     8
     9        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                }
     15        }
     16
     17        public function __call($m, $a){
     18                if (isset($this->$m) && is_callable($this->$m)){
    1619                        return call_user_func_array($this->$m, $a);
    17                 else if(isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m]))
    18                         return call_user_func_array($this->__dynamics[$m], $a);
    19                 else if('toString' == $m)
    20                         return $this->__toString();
    21                 else
    22                         throw new HException('Unable to call <'.$m.'>');
     20                } else {
     21                        if (isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m])){
     22                                return call_user_func_array($this->__dynamics[$m], $a);
     23                        } else {
     24                                if ('toString'==$m){
     25                                        return $this->__toString();
     26                                } else {
     27                                        throw new HException('Unable to call <' . $m . '>');
     28                                }
     29                        }
     30                }
    2331        }
    24         static function trim($scanlines, $w, $h) {
    25                 if(!($scanlines !== null)) {
     32
     33        static function trim($scanlines, $w, $h){
     34                if (!($scanlines!==null)){
    2635                        throw new HException("FAIL: scanlines != null");
    2736                }
     
    3039                return $scanlines->filter(array(new _hx_lambda(array(&$h1, &$w1), "geometrize_rasterizer_Scanline_0"), 'execute'));
    3140        }
    32         static function trimHelper($line, $w, $h) {
     41
     42        static function trimHelper($line, $w, $h){
    3343                $tmp = null;
    3444                $tmp1 = null;
    3545                $tmp2 = null;
    36                 if($line->y >= 0) {
    37                         $tmp2 = $line->y >= $h;
     46                if ($line->y>=0){
     47                        $tmp2 = $line->y>=$h;
    3848                } else {
    3949                        $tmp2 = true;
    4050                }
    41                 if(!$tmp2) {
    42                         $tmp1 = $line->x1 >= $w;
     51                if (!$tmp2){
     52                        $tmp1 = $line->x1>=$w;
    4353                } else {
    4454                        $tmp1 = true;
    4555                }
    46                 if(!$tmp1) {
    47                         $tmp = $line->x2 < 0;
     56                if (!$tmp1){
     57                        $tmp = $line->x2<0;
    4858                } else {
    4959                        $tmp = true;
    5060                }
    51                 if($tmp) {
     61                if ($tmp){
    5262                        return false;
    5363                }
    5464                $value = $line->x1;
    55                 $max = $w - 1;
    56                 if(!(0 <= $max)) {
     65                $max = $w-1;
     66                if (!(0<=$max)){
    5767                        throw new HException("FAIL: min <= max");
    5868                }
    5969                $tmp3 = null;
    60                 if($value < 0) {
     70                if ($value<0){
    6171                        $tmp3 = 0;
    6272                } else {
    63                         if($value > $max) {
     73                        if ($value>$max){
    6474                                $tmp3 = $max;
    6575                        } else {
     
    6979                $line->x1 = $tmp3;
    7080                $value1 = $line->x2;
    71                 $max1 = $w - 1;
    72                 if(!(0 <= $max1)) {
     81                $max1 = $w-1;
     82                if (!(0<=$max1)){
    7383                        throw new HException("FAIL: min <= max");
    7484                }
    7585                $tmp4 = null;
    76                 if($value1 < 0) {
     86                if ($value1<0){
    7787                        $tmp4 = 0;
    7888                } else {
    79                         if($value1 > $max1) {
     89                        if ($value1>$max1){
    8090                                $tmp4 = $max1;
    8191                        } else {
     
    8494                }
    8595                $line->x2 = $tmp4;
    86                 return $line->x1 <= $line->x2;
     96                return $line->x1<=$line->x2;
    8797        }
    88         function __toString() { return 'geometrize.rasterizer.Scanline'; }
     98
     99        function __toString(){
     100                return 'geometrize.rasterizer.Scanline';
     101        }
    89102}
    90 function geometrize_rasterizer_Scanline_0(&$h1, &$w1, $a1) {
     103
     104function geometrize_rasterizer_Scanline_0(&$h1, &$w1, $a1){
    91105        {
    92106                return geometrize_rasterizer_Scanline::trimHelper($a1, $w1, $h1);
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/runner/ImageRunner.class.php

    r115817 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize_runner_ImageRunner {
    5         public function __construct($inputImage, $backgroundColor) {
    6                 if(!php_Boot::$skip_constructor) {
    7                 $this->model = null;
    8                 $this->model = new geometrize_Model($inputImage, $backgroundColor);
    9         }}
    105        public $model;
    11         public function step($options) {
     6
     7        public function __construct($inputImage, $backgroundColor){
     8                if (!php_Boot::$skip_constructor){
     9                        $this->model = null;
     10                        $this->model = new geometrize_Model($inputImage, $backgroundColor);
     11                }
     12        }
     13
     14        public function step($options){
    1215                return $this->model->step($options->shapeTypes, $options->alpha, $options->candidateShapesPerStep, $options->shapeMutationsPerStep);
    1316        }
    14         public function getImageData() {
    15                 if(!($this->model !== null)) {
     17
     18        public function getImageData(){
     19                if (!($this->model!==null)){
    1620                        throw new HException("FAIL: model != null");
    1721                }
    1822                return $this->model->current;
    1923        }
    20         public function __call($m, $a) {
    21                 if(isset($this->$m) && is_callable($this->$m))
     24
     25        public function __call($m, $a){
     26                if (isset($this->$m) && is_callable($this->$m)){
    2227                        return call_user_func_array($this->$m, $a);
    23                 else if(isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m]))
    24                         return call_user_func_array($this->__dynamics[$m], $a);
    25                 else if('toString' == $m)
    26                         return $this->__toString();
    27                 else
    28                         throw new HException('Unable to call <'.$m.'>');
     28                } else {
     29                        if (isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m])){
     30                                return call_user_func_array($this->__dynamics[$m], $a);
     31                        } else {
     32                                if ('toString'==$m){
     33                                        return $this->__toString();
     34                                } else {
     35                                        throw new HException('Unable to call <' . $m . '>');
     36                                }
     37                        }
     38                }
    2939        }
    30         function __toString() { return 'geometrize.runner.ImageRunner'; }
     40
     41        function __toString(){
     42                return 'geometrize.runner.ImageRunner';
     43        }
    3144}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Circle.class.php

    r115842 r115850  
    33// Generated by Haxe 3.4.7
    44class geometrize_shape_Circle extends geometrize_shape_Ellipse {
    5         public function __construct($xBound, $yBound) { if(!php_Boot::$skip_constructor) {
    6                 parent::__construct($xBound,$yBound);
    7                 $this->rx = Std::random(32) + 1;
    8                 $this->ry = $this->rx;
    9         }}
    10         public function mutate() {
    11                 $r = Std::random(2);
    12                 switch($r) {
    13                 case 0:{
    14                         $value = $this->x;
    15                         if(!true) {
    16                                 throw new HException("FAIL: lower <= upper");
    17                         }
    18                         $value1 = $value + (-16 + Math::floor(33 * Math::random()));
    19                         $max = $this->xBound - 1;
    20                         if(!(0 <= $max)) {
    21                                 throw new HException("FAIL: min <= max");
    22                         }
    23                         $tmp = null;
    24                         if($value1 < 0) {
    25                                 $tmp = 0;
    26                         } else {
    27                                 if($value1 > $max) {
    28                                         $tmp = $max;
    29                                 } else {
    30                                         $tmp = $value1;
    31                                 }
    32                         }
    33                         $this->x = $tmp;
    34                         $value2 = $this->y;
    35                         if(!true) {
    36                                 throw new HException("FAIL: lower <= upper");
    37                         }
    38                         $value3 = $value2 + (-16 + Math::floor(33 * Math::random()));
    39                         $max1 = $this->yBound - 1;
    40                         if(!(0 <= $max1)) {
    41                                 throw new HException("FAIL: min <= max");
    42                         }
    43                         $tmp1 = null;
    44                         if($value3 < 0) {
    45                                 $tmp1 = 0;
    46                         } else {
    47                                 if($value3 > $max1) {
    48                                         $tmp1 = $max1;
    49                                 } else {
    50                                         $tmp1 = $value3;
    51                                 }
    52                         }
    53                         $this->y = $tmp1;
    54                 }break;
    55                 case 1:{
    56                         $value4 = $this->rx;
    57                         if(!true) {
    58                                 throw new HException("FAIL: lower <= upper");
    59                         }
    60                         $value5 = $value4 + (-16 + Math::floor(33 * Math::random()));
    61                         $max2 = $this->xBound - 1;
    62                         if(!(1 <= $max2)) {
    63                                 throw new HException("FAIL: min <= max");
    64                         }
    65                         $r1 = null;
    66                         if($value5 < 1) {
    67                                 $r1 = 1;
    68                         } else {
    69                                 if($value5 > $max2) {
    70                                         $r1 = $max2;
    71                                 } else {
    72                                         $r1 = $value5;
    73                                 }
    74                         }
    75                         $this->rx = $r1;
    76                         $this->ry = $r1;
    77                 }break;
     5        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;
    7810                }
    7911        }
    80         public function hclone() {
     12
     13        public function mutate(){
     14                $r = mt_rand(0, 1);
     15                switch ($r) {
     16                        case 0:
     17                                {
     18                                        $value = $this->x;
     19                                        if (!true){
     20                                                throw new HException("FAIL: lower <= upper");
     21                                        }
     22                                        $value1 = $value+mt_rand(-16, +16);
     23                                        $max = $this->xBound-1;
     24                                        if (!(0<=$max)){
     25                                                throw new HException("FAIL: min <= max");
     26                                        }
     27                                        $tmp = null;
     28                                        if ($value1<0){
     29                                                $tmp = 0;
     30                                        } else {
     31                                                if ($value1>$max){
     32                                                        $tmp = $max;
     33                                                } else {
     34                                                        $tmp = $value1;
     35                                                }
     36                                        }
     37                                        $this->x = $tmp;
     38                                        $value2 = $this->y;
     39                                        if (!true){
     40                                                throw new HException("FAIL: lower <= upper");
     41                                        }
     42                                        $value3 = $value2+mt_rand(-16, +16);
     43                                        $max1 = $this->yBound-1;
     44                                        if (!(0<=$max1)){
     45                                                throw new HException("FAIL: min <= max");
     46                                        }
     47                                        $tmp1 = null;
     48                                        if ($value3<0){
     49                                                $tmp1 = 0;
     50                                        } else {
     51                                                if ($value3>$max1){
     52                                                        $tmp1 = $max1;
     53                                                } else {
     54                                                        $tmp1 = $value3;
     55                                                }
     56                                        }
     57                                        $this->y = $tmp1;
     58                                }
     59                                break;
     60                        case 1:
     61                                {
     62                                        $value4 = $this->rx;
     63                                        if (!true){
     64                                                throw new HException("FAIL: lower <= upper");
     65                                        }
     66                                        $value5 = $value4+mt_rand(-16, +16);
     67                                        $max2 = $this->xBound-1;
     68                                        if (!(1<=$max2)){
     69                                                throw new HException("FAIL: min <= max");
     70                                        }
     71                                        $r1 = null;
     72                                        if ($value5<1){
     73                                                $r1 = 1;
     74                                        } else {
     75                                                if ($value5>$max2){
     76                                                        $r1 = $max2;
     77                                                } else {
     78                                                        $r1 = $value5;
     79                                                }
     80                                        }
     81                                        $this->rx = $r1;
     82                                        $this->ry = $r1;
     83                                }
     84                                break;
     85                }
     86        }
     87
     88        public function hclone(){
    8189                $circle = new geometrize_shape_Circle($this->xBound, $this->yBound);
    8290                $circle->x = $this->x;
     
    8492                $circle->rx = $this->rx;
    8593                $circle->ry = $this->ry;
    86                 if (isset($this->color)) {
     94                if (isset($this->color)){
    8795                        $circle->color = $this->color;
    8896                }
    8997                return $circle;
    9098        }
    91         public function getType() {
     99
     100        public function getType(){
    92101                return 5;
    93102        }
    94         public function getRawShapeData() {
     103
     104        public function getRawShapeData(){
    95105                return (new _hx_array(array($this->x, $this->y, $this->rx)));
    96106        }
    97         public function getSvgShapeData() {
     107
     108        public function getSvgShapeData(){
    98109                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) . " />";
    99110        }
    100         function __toString() { return 'geometrize.shape.Circle'; }
     111
     112        function __toString(){
     113                return 'geometrize.shape.Circle';
     114        }
    101115}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Ellipse.class.php

    r115842 r115850  
    22
    33// Generated by Haxe 3.4.7
    4 class geometrize_shape_Ellipse implements geometrize_shape_Shape{
    5         public function __construct($xBound, $yBound) {
    6                 if(!php_Boot::$skip_constructor) {
    7                 $this->x = Std::random($xBound);
    8                 $this->y = Std::random($yBound);
    9                 $this->rx = Std::random(32) + 1;
    10                 $this->ry = Std::random(32) + 1;
    11                 $this->xBound = $xBound;
    12                 $this->yBound = $yBound;
    13         }}
     4class geometrize_shape_Ellipse implements geometrize_shape_Shape {
    145        public $x;
    156        public $y;
     
    189        public $xBound;
    1910        public $yBound;
    20         public function rasterize() {
     11
     12        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                }
     21        }
     22
     23        public function rasterize(){
    2124                $lines = (new _hx_array(array()));
    22                 $aspect = $this->rx / $this->ry;
     25                $aspect = $this->rx/$this->ry;
    2326                $w = $this->xBound;
    2427                $h = $this->yBound;
     
    2629                        $_g1 = 0;
    2730                        $_g = $this->ry;
    28                         while($_g1 < $_g) {
    29                                 $_g1 = $_g1 + 1;
    30                                 $dy = $_g1 - 1;
    31                                 $y1 = $this->y - $dy;
    32                                 $y2 = $this->y + $dy;
     31                        while ($_g1<$_g){
     32                                $_g1 = $_g1+1;
     33                                $dy = $_g1-1;
     34                                $y1 = $this->y-$dy;
     35                                $y2 = $this->y+$dy;
    3336                                $tmp = null;
    3437                                $tmp1 = null;
    35                                 if($y1 >= 0) {
    36                                         $tmp1 = $y1 >= $h;
     38                                if ($y1>=0){
     39                                        $tmp1 = $y1>=$h;
    3740                                } else {
    3841                                        $tmp1 = true;
    3942                                }
    40                                 if($tmp1) {
    41                                         if($y2 >= 0) {
    42                                                 $tmp = $y2 >= $h;
     43                                if ($tmp1){
     44                                        if ($y2>=0){
     45                                                $tmp = $y2>=$h;
    4346                                        } else {
    4447                                                $tmp = true;
     
    4750                                        $tmp = false;
    4851                                }
    49                                 if($tmp) {
     52                                if ($tmp){
    5053                                        continue;
    5154                                }
    52                                 $s = Std::int(Math::sqrt($this->ry * $this->ry - $dy * $dy) * $aspect);
    53                                 $x1 = $this->x - $s;
    54                                 $x2 = $this->x + $s;
    55                                 if($x1 < 0) {
     55                                $s = intval(sqrt($this->ry*$this->ry-$dy*$dy)*$aspect);
     56                                $x1 = $this->x-$s;
     57                                $x2 = $this->x+$s;
     58                                if ($x1<0){
    5659                                        $x1 = 0;
    5760                                }
    58                                 if($x2 >= $w) {
    59                                         $x2 = $w - 1;
     61                                if ($x2>=$w){
     62                                        $x2 = $w-1;
    6063                                }
    6164                                $tmp2 = null;
    62                                 if($y1 >= 0) {
    63                                         $tmp2 = $y1 < $h;
     65                                if ($y1>=0){
     66                                        $tmp2 = $y1<$h;
    6467                                } else {
    6568                                        $tmp2 = false;
    6669                                }
    67                                 if($tmp2) {
     70                                if ($tmp2){
    6871                                        $lines->push(new geometrize_rasterizer_Scanline($y1, $x1, $x2));
    6972                                }
    7073                                $tmp3 = null;
    7174                                $tmp4 = null;
    72                                 if($y2 >= 0) {
    73                                         $tmp4 = $y2 < $h;
     75                                if ($y2>=0){
     76                                        $tmp4 = $y2<$h;
    7477                                } else {
    7578                                        $tmp4 = false;
    7679                                }
    77                                 if($tmp4) {
    78                                         $tmp3 = $dy > 0;
     80                                if ($tmp4){
     81                                        $tmp3 = $dy>0;
    7982                                } else {
    8083                                        $tmp3 = false;
    8184                                }
    82                                 if($tmp3) {
     85                                if ($tmp3){
    8386                                        $lines->push(new geometrize_rasterizer_Scanline($y2, $x1, $x2));
    8487                                }
    85                                 unset($y2,$y1,$x2,$x1,$tmp4,$tmp3,$tmp2,$tmp1,$tmp,$s,$dy);
     88                                unset($y2, $y1, $x2, $x1, $tmp4, $tmp3, $tmp2, $tmp1, $tmp, $s, $dy);
    8689                        }
    8790                }
    8891                return $lines;
    8992        }
    90         public function mutate() {
    91                 $r = Std::random(3);
    92                 switch($r) {
    93                 case 0:{
    94                         $value = $this->x;
    95                         if(!true) {
    96                                 throw new HException("FAIL: lower <= upper");
    97                         }
    98                         $value1 = $value + (-16 + Math::floor(33 * Math::random()));
    99                         $max = $this->xBound - 1;
    100                         if(!(0 <= $max)) {
    101                                 throw new HException("FAIL: min <= max");
    102                         }
    103                         $tmp = null;
    104                         if($value1 < 0) {
    105                                 $tmp = 0;
    106                         } else {
    107                                 if($value1 > $max) {
    108                                         $tmp = $max;
    109                                 } else {
    110                                         $tmp = $value1;
    111                                 }
    112                         }
    113                         $this->x = $tmp;
    114                         $value2 = $this->y;
    115                         if(!true) {
    116                                 throw new HException("FAIL: lower <= upper");
    117                         }
    118                         $value3 = $value2 + (-16 + Math::floor(33 * Math::random()));
    119                         $max1 = $this->yBound - 1;
    120                         if(!(0 <= $max1)) {
    121                                 throw new HException("FAIL: min <= max");
    122                         }
    123                         $tmp1 = null;
    124                         if($value3 < 0) {
    125                                 $tmp1 = 0;
    126                         } else {
    127                                 if($value3 > $max1) {
    128                                         $tmp1 = $max1;
    129                                 } else {
    130                                         $tmp1 = $value3;
    131                                 }
    132                         }
    133                         $this->y = $tmp1;
    134                 }break;
    135                 case 1:{
    136                         $value4 = $this->rx;
    137                         if(!true) {
    138                                 throw new HException("FAIL: lower <= upper");
    139                         }
    140                         $value5 = $value4 + (-16 + Math::floor(33 * Math::random()));
    141                         $max2 = $this->xBound - 1;
    142                         if(!(1 <= $max2)) {
    143                                 throw new HException("FAIL: min <= max");
    144                         }
    145                         $tmp2 = null;
    146                         if($value5 < 1) {
    147                                 $tmp2 = 1;
    148                         } else {
    149                                 if($value5 > $max2) {
    150                                         $tmp2 = $max2;
    151                                 } else {
    152                                         $tmp2 = $value5;
    153                                 }
    154                         }
    155                         $this->rx = $tmp2;
    156                 }break;
    157                 case 2:{
    158                         $value6 = $this->ry;
    159                         if(!true) {
    160                                 throw new HException("FAIL: lower <= upper");
    161                         }
    162                         $value7 = $value6 + (-16 + Math::floor(33 * Math::random()));
    163                         $max3 = $this->xBound - 1;
    164                         if(!(1 <= $max3)) {
    165                                 throw new HException("FAIL: min <= max");
    166                         }
    167                         $tmp3 = null;
    168                         if($value7 < 1) {
    169                                 $tmp3 = 1;
    170                         } else {
    171                                 if($value7 > $max3) {
    172                                         $tmp3 = $max3;
    173                                 } else {
    174                                         $tmp3 = $value7;
    175                                 }
    176                         }
    177                         $this->ry = $tmp3;
    178                 }break;
    179                 }
    180         }
    181         public function hclone() {
     93
     94        public function mutate(){
     95                $r = mt_rand(0, 2);
     96                switch ($r) {
     97                        case 0:
     98                                {
     99                                        $value = $this->x;
     100                                        if (!true){
     101                                                throw new HException("FAIL: lower <= upper");
     102                                        }
     103                                        $value1 = $value+mt_rand(-16, +16);
     104                                        $max = $this->xBound-1;
     105                                        if (!(0<=$max)){
     106                                                throw new HException("FAIL: min <= max");
     107                                        }
     108                                        $tmp = null;
     109                                        if ($value1<0){
     110                                                $tmp = 0;
     111                                        } else {
     112                                                if ($value1>$max){
     113                                                        $tmp = $max;
     114                                                } else {
     115                                                        $tmp = $value1;
     116                                                }
     117                                        }
     118                                        $this->x = $tmp;
     119                                        $value2 = $this->y;
     120                                        if (!true){
     121                                                throw new HException("FAIL: lower <= upper");
     122                                        }
     123                                        $value3 = $value2+mt_rand(-16, +16);
     124                                        $max1 = $this->yBound-1;
     125                                        if (!(0<=$max1)){
     126                                                throw new HException("FAIL: min <= max");
     127                                        }
     128                                        $tmp1 = null;
     129                                        if ($value3<0){
     130                                                $tmp1 = 0;
     131                                        } else {
     132                                                if ($value3>$max1){
     133                                                        $tmp1 = $max1;
     134                                                } else {
     135                                                        $tmp1 = $value3;
     136                                                }
     137                                        }
     138                                        $this->y = $tmp1;
     139                                }
     140                                break;
     141                        case 1:
     142                                {
     143                                        $value4 = $this->rx;
     144                                        if (!true){
     145                                                throw new HException("FAIL: lower <= upper");
     146                                        }
     147                                        $value5 = $value4+mt_rand(-16, +16);
     148                                        $max2 = $this->xBound-1;
     149                                        if (!(1<=$max2)){
     150                                                throw new HException("FAIL: min <= max");
     151                                        }
     152                                        $tmp2 = null;
     153                                        if ($value5<1){
     154                                                $tmp2 = 1;
     155                                        } else {
     156                                                if ($value5>$max2){
     157                                                        $tmp2 = $max2;
     158                                                } else {
     159                                                        $tmp2 = $value5;
     160                                                }
     161                                        }
     162                                        $this->rx = $tmp2;
     163                                }
     164                                break;
     165                        case 2:
     166                                {
     167                                        $value6 = $this->ry;
     168                                        if (!true){
     169                                                throw new HException("FAIL: lower <= upper");
     170                                        }
     171                                        $value7 = $value6+mt_rand(-16, +16);
     172                                        $max3 = $this->xBound-1;
     173                                        if (!(1<=$max3)){
     174                                                throw new HException("FAIL: min <= max");
     175                                        }
     176                                        $tmp3 = null;
     177                                        if ($value7<1){
     178                                                $tmp3 = 1;
     179                                        } else {
     180                                                if ($value7>$max3){
     181                                                        $tmp3 = $max3;
     182                                                } else {
     183                                                        $tmp3 = $value7;
     184                                                }
     185                                        }
     186                                        $this->ry = $tmp3;
     187                                }
     188                                break;
     189                }
     190        }
     191
     192        public function rescale($scale){
     193                $this->x = intval(round($this->x*$scale));
     194                $this->y = intval(round($this->y*$scale));
     195                $this->rx = intval(round($this->rx*$scale));
     196                $this->ry = intval(round($this->ry*$scale));
     197                $this->xBound = intval(round($this->xBound*$scale));
     198                $this->yBound = intval(round($this->yBound*$scale));
     199        }
     200
     201        public function hclone(){
    182202                $ellipse = new geometrize_shape_Ellipse($this->xBound, $this->yBound);
    183203                $ellipse->x = $this->x;
     
    185205                $ellipse->rx = $this->rx;
    186206                $ellipse->ry = $this->ry;
    187                 if (isset($this->color)) {
     207                if (isset($this->color)){
    188208                        $ellipse->color = $this->color;
    189209                }
    190210                return $ellipse;
    191211        }
    192         public function getType() {
     212
     213        public function getType(){
    193214                return 3;
    194215        }
    195         public function getRawShapeData() {
     216
     217        public function getRawShapeData(){
    196218                return (new _hx_array(array($this->x, $this->y, $this->rx, $this->ry)));
    197219        }
    198         public function getSvgShapeData() {
     220
     221        public function getSvgShapeData(){
    199222                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) . " />";
    200223        }
    201         public function __call($m, $a) {
    202                 if(isset($this->$m) && is_callable($this->$m))
     224
     225        public function __call($m, $a){
     226                if (isset($this->$m) && is_callable($this->$m)){
    203227                        return call_user_func_array($this->$m, $a);
    204                 else if(isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m]))
    205                         return call_user_func_array($this->__dynamics[$m], $a);
    206                 else if('toString' == $m)
    207                         return $this->__toString();
    208                 else
    209                         throw new HException('Unable to call <'.$m.'>');
    210         }
    211         function __toString() { return 'geometrize.shape.Ellipse'; }
     228                } else {
     229                        if (isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m])){
     230                                return call_user_func_array($this->__dynamics[$m], $a);
     231                        } else {
     232                                if ('toString'==$m){
     233                                        return $this->__toString();
     234                                } else {
     235                                        throw new HException('Unable to call <' . $m . '>');
     236                                }
     237                        }
     238                }
     239        }
     240
     241        function __toString(){
     242                return 'geometrize.shape.Ellipse';
     243        }
    212244}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Line.class.php

    r115817 r115850  
    22
    33// Generated by Haxe 3.4.7
    4 class geometrize_shape_Line implements geometrize_shape_Shape{
    5         public function __construct($xBound, $yBound) {
    6                 if(!php_Boot::$skip_constructor) {
    7                 $this->x1 = Std::random($xBound);
    8                 $this->y1 = Std::random($yBound);
    9                 $value = $this->x1;
    10                 $value1 = $value + Std::random(32) + 1;
    11                 if(!(0 <= $xBound)) {
    12                         throw new HException("FAIL: min <= max");
    13                 }
    14                 $tmp = null;
    15                 if($value1 < 0) {
    16                         $tmp = 0;
    17                 } else {
    18                         if($value1 > $xBound) {
    19                                 $tmp = $xBound;
    20                         } else {
    21                                 $tmp = $value1;
    22                         }
    23                 }
    24                 $this->x2 = $tmp;
    25                 $value2 = $this->y1;
    26                 $value3 = $value2 + Std::random(32) + 1;
    27                 if(!(0 <= $yBound)) {
    28                         throw new HException("FAIL: min <= max");
    29                 }
    30                 $tmp1 = null;
    31                 if($value3 < 0) {
    32                         $tmp1 = 0;
    33                 } else {
    34                         if($value3 > $yBound) {
    35                                 $tmp1 = $yBound;
    36                         } else {
    37                                 $tmp1 = $value3;
    38                         }
    39                 }
    40                 $this->y2 = $tmp1;
    41                 $this->xBound = $xBound;
    42                 $this->yBound = $yBound;
    43         }}
     4class geometrize_shape_Line implements geometrize_shape_Shape {
    445        public $x1;
    456        public $y1;
     
    489        public $xBound;
    4910        public $yBound;
    50         public function rasterize() {
     11
     12        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");
     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;
     29                                }
     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;
     43                                } else {
     44                                        $tmp1 = $value3;
     45                                }
     46                        }
     47                        $this->y2 = $tmp1;
     48                        $this->xBound = $xBound;
     49                        $this->yBound = $yBound;
     50                }
     51        }
     52
     53        public function rasterize(){
    5154                $lines = (new _hx_array(array()));
    5255                $points = geometrize_rasterizer_Rasterizer::bresenham($this->x1, $this->y1, $this->x2, $this->y2);
    5356                {
    5457                        $_g = 0;
    55                         while($_g < $points->length) {
     58                        while ($_g<$points->length){
    5659                                $point = $points[$_g];
    57                                 $_g = $_g + 1;
     60                                $_g = $_g+1;
    5861                                $lines->push(new geometrize_rasterizer_Scanline($point->y, $point->x, $point->x));
    5962                                unset($point);
     
    6265                return geometrize_rasterizer_Scanline::trim($lines, $this->xBound, $this->yBound);
    6366        }
    64         public function mutate() {
    65                 $r = Std::random(4);
    66                 switch($r) {
    67                 case 0:{
    68                         $value = $this->x1;
    69                         if(!true) {
    70                                 throw new HException("FAIL: lower <= upper");
    71                         }
    72                         $value1 = $value + (-16 + Math::floor(33 * Math::random()));
    73                         $max = $this->xBound - 1;
    74                         if(!(0 <= $max)) {
    75                                 throw new HException("FAIL: min <= max");
    76                         }
    77                         $tmp = null;
    78                         if($value1 < 0) {
    79                                 $tmp = 0;
    80                         } else {
    81                                 if($value1 > $max) {
    82                                         $tmp = $max;
    83                                 } else {
    84                                         $tmp = $value1;
    85                                 }
    86                         }
    87                         $this->x1 = $tmp;
    88                         $value2 = $this->y1;
    89                         if(!true) {
    90                                 throw new HException("FAIL: lower <= upper");
    91                         }
    92                         $value3 = $value2 + (-16 + Math::floor(33 * Math::random()));
    93                         $max1 = $this->yBound - 1;
    94                         if(!(0 <= $max1)) {
    95                                 throw new HException("FAIL: min <= max");
    96                         }
    97                         $tmp1 = null;
    98                         if($value3 < 0) {
    99                                 $tmp1 = 0;
    100                         } else {
    101                                 if($value3 > $max1) {
    102                                         $tmp1 = $max1;
    103                                 } else {
    104                                         $tmp1 = $value3;
    105                                 }
    106                         }
    107                         $this->y1 = $tmp1;
    108                 }break;
    109                 case 1:{
    110                         $value4 = $this->x2;
    111                         if(!true) {
    112                                 throw new HException("FAIL: lower <= upper");
    113                         }
    114                         $value5 = $value4 + (-16 + Math::floor(33 * Math::random()));
    115                         $max2 = $this->xBound - 1;
    116                         if(!(0 <= $max2)) {
    117                                 throw new HException("FAIL: min <= max");
    118                         }
    119                         $tmp2 = null;
    120                         if($value5 < 0) {
    121                                 $tmp2 = 0;
    122                         } else {
    123                                 if($value5 > $max2) {
    124                                         $tmp2 = $max2;
    125                                 } else {
    126                                         $tmp2 = $value5;
    127                                 }
    128                         }
    129                         $this->x2 = $tmp2;
    130                         $value6 = $this->y2;
    131                         if(!true) {
    132                                 throw new HException("FAIL: lower <= upper");
    133                         }
    134                         $value7 = $value6 + (-16 + Math::floor(33 * Math::random()));
    135                         $max3 = $this->yBound - 1;
    136                         if(!(0 <= $max3)) {
    137                                 throw new HException("FAIL: min <= max");
    138                         }
    139                         $tmp3 = null;
    140                         if($value7 < 0) {
    141                                 $tmp3 = 0;
    142                         } else {
    143                                 if($value7 > $max3) {
    144                                         $tmp3 = $max3;
    145                                 } else {
    146                                         $tmp3 = $value7;
    147                                 }
    148                         }
    149                         $this->y2 = $tmp3;
    150                 }break;
    151                 }
    152         }
    153         public function hclone() {
     67
     68        public function mutate(){
     69                $r = mt_rand(0, 3); // TODO : fixme 0,1
     70                switch ($r) {
     71                        case 0:
     72                                {
     73                                        $value = $this->x1;
     74                                        if (!true){
     75                                                throw new HException("FAIL: lower <= upper");
     76                                        }
     77                                        $value1 = $value+mt_rand(-16, +16);
     78                                        $max = $this->xBound-1;
     79                                        if (!(0<=$max)){
     80                                                throw new HException("FAIL: min <= max");
     81                                        }
     82                                        $tmp = null;
     83                                        if ($value1<0){
     84                                                $tmp = 0;
     85                                        } else {
     86                                                if ($value1>$max){
     87                                                        $tmp = $max;
     88                                                } else {
     89                                                        $tmp = $value1;
     90                                                }
     91                                        }
     92                                        $this->x1 = $tmp;
     93                                        $value2 = $this->y1;
     94                                        if (!true){
     95                                                throw new HException("FAIL: lower <= upper");
     96                                        }
     97                                        $value3 = $value2+mt_rand(-16, +16);
     98                                        $max1 = $this->yBound-1;
     99                                        if (!(0<=$max1)){
     100                                                throw new HException("FAIL: min <= max");
     101                                        }
     102                                        $tmp1 = null;
     103                                        if ($value3<0){
     104                                                $tmp1 = 0;
     105                                        } else {
     106                                                if ($value3>$max1){
     107                                                        $tmp1 = $max1;
     108                                                } else {
     109                                                        $tmp1 = $value3;
     110                                                }
     111                                        }
     112                                        $this->y1 = $tmp1;
     113                                }
     114                                break;
     115                        case 1:
     116                                {
     117                                        $value4 = $this->x2;
     118                                        if (!true){
     119                                                throw new HException("FAIL: lower <= upper");
     120                                        }
     121                                        $value5 = $value4+mt_rand(-16, +16);
     122                                        $max2 = $this->xBound-1;
     123                                        if (!(0<=$max2)){
     124                                                throw new HException("FAIL: min <= max");
     125                                        }
     126                                        $tmp2 = null;
     127                                        if ($value5<0){
     128                                                $tmp2 = 0;
     129                                        } else {
     130                                                if ($value5>$max2){
     131                                                        $tmp2 = $max2;
     132                                                } else {
     133                                                        $tmp2 = $value5;
     134                                                }
     135                                        }
     136                                        $this->x2 = $tmp2;
     137                                        $value6 = $this->y2;
     138                                        if (!true){
     139                                                throw new HException("FAIL: lower <= upper");
     140                                        }
     141                                        $value7 = $value6+mt_rand(-16, +16);
     142                                        $max3 = $this->yBound-1;
     143                                        if (!(0<=$max3)){
     144                                                throw new HException("FAIL: min <= max");
     145                                        }
     146                                        $tmp3 = null;
     147                                        if ($value7<0){
     148                                                $tmp3 = 0;
     149                                        } else {
     150                                                if ($value7>$max3){
     151                                                        $tmp3 = $max3;
     152                                                } else {
     153                                                        $tmp3 = $value7;
     154                                                }
     155                                        }
     156                                        $this->y2 = $tmp3;
     157                                }
     158                                break;
     159                }
     160        }
     161
     162        public function rescale($scale){
     163                $this->x1 = intval(round($this->x1*$scale));
     164                $this->y1 = intval(round($this->y1*$scale));
     165                $this->x2 = intval(round($this->x2*$scale));
     166                $this->y2 = intval(round($this->y2*$scale));
     167                $this->xBound = intval(round($this->xBound*$scale));
     168                $this->yBound = intval(round($this->yBound*$scale));
     169        }
     170
     171        public function hclone(){
    154172                $line = new geometrize_shape_Line($this->xBound, $this->yBound);
    155173                $line->x1 = $this->x1;
     
    157175                $line->x2 = $this->x2;
    158176                $line->y2 = $this->y2;
     177                if (isset($this->color)){
     178                        $line->color = $this->color;
     179                }
    159180                return $line;
    160181        }
    161         public function getType() {
     182
     183        public function getType(){
    162184                return 6;
    163185        }
    164         public function getRawShapeData() {
     186
     187        public function getRawShapeData(){
    165188                return (new _hx_array(array($this->x1, $this->y1, $this->x2, $this->y2)));
    166189        }
    167         public function getSvgShapeData() {
     190
     191        public function getSvgShapeData(){
    168192                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) . " />";
    169193        }
    170         public function __call($m, $a) {
    171                 if(isset($this->$m) && is_callable($this->$m))
     194
     195        public function __call($m, $a){
     196                if (isset($this->$m) && is_callable($this->$m)){
    172197                        return call_user_func_array($this->$m, $a);
    173                 else if(isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m]))
    174                         return call_user_func_array($this->__dynamics[$m], $a);
    175                 else if('toString' == $m)
    176                         return $this->__toString();
    177                 else
    178                         throw new HException('Unable to call <'.$m.'>');
    179         }
    180         function __toString() { return 'geometrize.shape.Line'; }
     198                } else {
     199                        if (isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m])){
     200                                return call_user_func_array($this->__dynamics[$m], $a);
     201                        } else {
     202                                if ('toString'==$m){
     203                                        return $this->__toString();
     204                                } else {
     205                                        throw new HException('Unable to call <' . $m . '>');
     206                                }
     207                        }
     208                }
     209        }
     210
     211        function __toString(){
     212                return 'geometrize.shape.Line';
     213        }
    181214}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/QuadraticBezier.class.php

    r115817 r115850  
    22
    33// Generated by Haxe 3.4.7
    4 class geometrize_shape_QuadraticBezier implements geometrize_shape_Shape{
    5         public function __construct($xBound, $yBound) {
    6                 if(!php_Boot::$skip_constructor) {
    7                 $upper = $xBound - 1;
    8                 if(!(0 <= $upper)) {
    9                         throw new HException("FAIL: lower <= upper");
    10                 }
    11                 $this->x1 = Math::floor(($upper + 1) * Math::random());
    12                 $upper1 = $yBound - 1;
    13                 if(!(0 <= $upper1)) {
    14                         throw new HException("FAIL: lower <= upper");
    15                 }
    16                 $this->y1 = Math::floor(($upper1 + 1) * Math::random());
    17                 $upper2 = $xBound - 1;
    18                 if(!(0 <= $upper2)) {
    19                         throw new HException("FAIL: lower <= upper");
    20                 }
    21                 $this->cx = Math::floor(($upper2 + 1) * Math::random());
    22                 $upper3 = $yBound - 1;
    23                 if(!(0 <= $upper3)) {
    24                         throw new HException("FAIL: lower <= upper");
    25                 }
    26                 $this->cy = Math::floor(($upper3 + 1) * Math::random());
    27                 $upper4 = $xBound - 1;
    28                 if(!(0 <= $upper4)) {
    29                         throw new HException("FAIL: lower <= upper");
    30                 }
    31                 $this->x2 = Math::floor(($upper4 + 1) * Math::random());
    32                 $upper5 = $yBound - 1;
    33                 if(!(0 <= $upper5)) {
    34                         throw new HException("FAIL: lower <= upper");
    35                 }
    36                 $this->y2 = Math::floor(($upper5 + 1) * Math::random());
    37                 $this->xBound = $xBound;
    38                 $this->yBound = $yBound;
    39         }}
     4class geometrize_shape_QuadraticBezier implements geometrize_shape_Shape {
    405        public $cx;
    416        public $cy;
     
    4611        public $xBound;
    4712        public $yBound;
    48         public function rasterize() {
     13
     14        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                }
     49        }
     50
     51        public function rasterize(){
    4952                $lines = (new _hx_array(array()));
    5053                $points = (new _hx_array(array()));
     
    5255                {
    5356                        $_g1 = 0;
    54                         $_g = $pointCount - 1;
    55                         while($_g1 < $_g) {
    56                                 $_g1 = $_g1 + 1;
    57                                 $i = $_g1 - 1;
    58                                 $t = $i / $pointCount;
    59                                 $tp = 1 - $t;
    60                                 $x = Std::int($tp * ($tp * $this->x1 + $t * $this->cx) + $t * ($tp * $this->cx + $t * $this->x2));
    61                                 $y = Std::int($tp * ($tp * $this->y1 + $t * $this->cy) + $t * ($tp * $this->cy + $t * $this->y2));
     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));
    6265                                $points->push(_hx_anonymous(array("x" => $x, "y" => $y)));
    63                                 unset($y,$x,$tp,$t,$i);
     66                                unset($y, $x, $tp, $t, $i);
    6467                        }
    6568                }
    6669                {
    6770                        $_g11 = 0;
    68                         $_g2 = $points->length - 1;
    69                         while($_g11 < $_g2) {
    70                                 $_g11 = $_g11 + 1;
    71                                 $i1 = $_g11 - 1;
     71                        $_g2 = $points->length-1;
     72                        while ($_g11<$_g2){
     73                                $_g11 = $_g11+1;
     74                                $i1 = $_g11-1;
    7275                                $p0 = $points[$i1];
    73                                 $p1 = $points[$i1 + 1];
     76                                $p1 = $points[$i1+1];
    7477                                $pts = geometrize_rasterizer_Rasterizer::bresenham($p0->x, $p0->y, $p1->x, $p1->y);
    7578                                {
    7679                                        $_g21 = 0;
    77                                         while($_g21 < $pts->length) {
     80                                        while ($_g21<$pts->length){
    7881                                                $point = $pts[$_g21];
    79                                                 $_g21 = $_g21 + 1;
     82                                                $_g21 = $_g21+1;
    8083                                                $lines->push(new geometrize_rasterizer_Scanline($point->y, $point->x, $point->x));
    8184                                                unset($point);
     
    8386                                        unset($_g21);
    8487                                }
    85                                 unset($pts,$p1,$p0,$i1);
     88                                unset($pts, $p1, $p0, $i1);
    8689                        }
    8790                }
    8891                return geometrize_rasterizer_Scanline::trim($lines, $this->xBound, $this->yBound);
    8992        }
    90         public function mutate() {
    91                 if(!true) {
     93
     94        public function mutate(){
     95                if (!true){
    9296                        throw new HException("FAIL: lower <= upper");
    9397                }
    94                 $r = Math::floor(3 * Math::random());
    95                 switch($r) {
    96                 case 0:{
    97                         $value = $this->cx;
    98                         if(!true) {
    99                                 throw new HException("FAIL: lower <= upper");
    100                         }
    101                         $value1 = $value + (-8 + Math::floor(17 * Math::random()));
    102                         $max = $this->xBound - 1;
    103                         if(!(0 <= $max)) {
    104                                 throw new HException("FAIL: min <= max");
    105                         }
    106                         $tmp = null;
    107                         if($value1 < 0) {
    108                                 $tmp = 0;
    109                         } else {
    110                                 if($value1 > $max) {
    111                                         $tmp = $max;
    112                                 } else {
    113                                         $tmp = $value1;
    114                                 }
    115                         }
    116                         $this->cx = $tmp;
    117                         $value2 = $this->cy;
    118                         if(!true) {
    119                                 throw new HException("FAIL: lower <= upper");
    120                         }
    121                         $value3 = $value2 + (-8 + Math::floor(17 * Math::random()));
    122                         $max1 = $this->yBound - 1;
    123                         if(!(0 <= $max1)) {
    124                                 throw new HException("FAIL: min <= max");
    125                         }
    126                         $tmp1 = null;
    127                         if($value3 < 0) {
    128                                 $tmp1 = 0;
    129                         } else {
    130                                 if($value3 > $max1) {
    131                                         $tmp1 = $max1;
    132                                 } else {
    133                                         $tmp1 = $value3;
    134                                 }
    135                         }
    136                         $this->cy = $tmp1;
    137                 }break;
    138                 case 1:{
    139                         $value4 = $this->x1;
    140                         if(!true) {
    141                                 throw new HException("FAIL: lower <= upper");
    142                         }
    143                         $value5 = $value4 + (-8 + Math::floor(17 * Math::random()));
    144                         $max2 = $this->xBound - 1;
    145                         if(!(1 <= $max2)) {
    146                                 throw new HException("FAIL: min <= max");
    147                         }
    148                         $tmp2 = null;
    149                         if($value5 < 1) {
    150                                 $tmp2 = 1;
    151                         } else {
    152                                 if($value5 > $max2) {
    153                                         $tmp2 = $max2;
    154                                 } else {
    155                                         $tmp2 = $value5;
    156                                 }
    157                         }
    158                         $this->x1 = $tmp2;
    159                         $value6 = $this->y1;
    160                         if(!true) {
    161                                 throw new HException("FAIL: lower <= upper");
    162                         }
    163                         $value7 = $value6 + (-8 + Math::floor(17 * Math::random()));
    164                         $max3 = $this->yBound - 1;
    165                         if(!(1 <= $max3)) {
    166                                 throw new HException("FAIL: min <= max");
    167                         }
    168                         $tmp3 = null;
    169                         if($value7 < 1) {
    170                                 $tmp3 = 1;
    171                         } else {
    172                                 if($value7 > $max3) {
    173                                         $tmp3 = $max3;
    174                                 } else {
    175                                         $tmp3 = $value7;
    176                                 }
    177                         }
    178                         $this->y1 = $tmp3;
    179                 }break;
    180                 case 2:{
    181                         $value8 = $this->x2;
    182                         if(!true) {
    183                                 throw new HException("FAIL: lower <= upper");
    184                         }
    185                         $value9 = $value8 + (-8 + Math::floor(17 * Math::random()));
    186                         $max4 = $this->xBound - 1;
    187                         if(!(1 <= $max4)) {
    188                                 throw new HException("FAIL: min <= max");
    189                         }
    190                         $tmp4 = null;
    191                         if($value9 < 1) {
    192                                 $tmp4 = 1;
    193                         } else {
    194                                 if($value9 > $max4) {
    195                                         $tmp4 = $max4;
    196                                 } else {
    197                                         $tmp4 = $value9;
    198                                 }
    199                         }
    200                         $this->x2 = $tmp4;
    201                         $value10 = $this->y2;
    202                         if(!true) {
    203                                 throw new HException("FAIL: lower <= upper");
    204                         }
    205                         $value11 = $value10 + (-8 + Math::floor(17 * Math::random()));
    206                         $max5 = $this->yBound - 1;
    207                         if(!(1 <= $max5)) {
    208                                 throw new HException("FAIL: min <= max");
    209                         }
    210                         $tmp5 = null;
    211                         if($value11 < 1) {
    212                                 $tmp5 = 1;
    213                         } else {
    214                                 if($value11 > $max5) {
    215                                         $tmp5 = $max5;
    216                                 } else {
    217                                         $tmp5 = $value11;
    218                                 }
    219                         }
    220                         $this->y2 = $tmp5;
    221                 }break;
    222                 }
    223         }
    224         public function hclone() {
     98                $r = mt_rand(0, 2);
     99                switch ($r) {
     100                        case 0:
     101                                {
     102                                        $value = $this->cx;
     103                                        if (!true){
     104                                                throw new HException("FAIL: lower <= upper");
     105                                        }
     106                                        $value1 = $value+mt_rand(-8, +8);
     107                                        $max = $this->xBound-1;
     108                                        if (!(0<=$max)){
     109                                                throw new HException("FAIL: min <= max");
     110                                        }
     111                                        $tmp = null;
     112                                        if ($value1<0){
     113                                                $tmp = 0;
     114                                        } else {
     115                                                if ($value1>$max){
     116                                                        $tmp = $max;
     117                                                } else {
     118                                                        $tmp = $value1;
     119                                                }
     120                                        }
     121                                        $this->cx = $tmp;
     122                                        $value2 = $this->cy;
     123                                        if (!true){
     124                                                throw new HException("FAIL: lower <= upper");
     125                                        }
     126                                        $value3 = $value2+mt_rand(-8, +8);
     127                                        $max1 = $this->yBound-1;
     128                                        if (!(0<=$max1)){
     129                                                throw new HException("FAIL: min <= max");
     130                                        }
     131                                        $tmp1 = null;
     132                                        if ($value3<0){
     133                                                $tmp1 = 0;
     134                                        } else {
     135                                                if ($value3>$max1){
     136                                                        $tmp1 = $max1;
     137                                                } else {
     138                                                        $tmp1 = $value3;
     139                                                }
     140                                        }
     141                                        $this->cy = $tmp1;
     142                                }
     143                                break;
     144                        case 1:
     145                                {
     146                                        $value4 = $this->x1;
     147                                        if (!true){
     148                                                throw new HException("FAIL: lower <= upper");
     149                                        }
     150                                        $value5 = $value4+mt_rand(-8, +8);
     151                                        $max2 = $this->xBound-1;
     152                                        if (!(1<=$max2)){
     153                                                throw new HException("FAIL: min <= max");
     154                                        }
     155                                        $tmp2 = null;
     156                                        if ($value5<1){
     157                                                $tmp2 = 1;
     158                                        } else {
     159                                                if ($value5>$max2){
     160                                                        $tmp2 = $max2;
     161                                                } else {
     162                                                        $tmp2 = $value5;
     163                                                }
     164                                        }
     165                                        $this->x1 = $tmp2;
     166                                        $value6 = $this->y1;
     167                                        if (!true){
     168                                                throw new HException("FAIL: lower <= upper");
     169                                        }
     170                                        $value7 = $value6+mt_rand(-8, +8);
     171                                        $max3 = $this->yBound-1;
     172                                        if (!(1<=$max3)){
     173                                                throw new HException("FAIL: min <= max");
     174                                        }
     175                                        $tmp3 = null;
     176                                        if ($value7<1){
     177                                                $tmp3 = 1;
     178                                        } else {
     179                                                if ($value7>$max3){
     180                                                        $tmp3 = $max3;
     181                                                } else {
     182                                                        $tmp3 = $value7;
     183                                                }
     184                                        }
     185                                        $this->y1 = $tmp3;
     186                                }
     187                                break;
     188                        case 2:
     189                                {
     190                                        $value8 = $this->x2;
     191                                        if (!true){
     192                                                throw new HException("FAIL: lower <= upper");
     193                                        }
     194                                        $value9 = $value8+mt_rand(-8, +8);
     195                                        $max4 = $this->xBound-1;
     196                                        if (!(1<=$max4)){
     197                                                throw new HException("FAIL: min <= max");
     198                                        }
     199                                        $tmp4 = null;
     200                                        if ($value9<1){
     201                                                $tmp4 = 1;
     202                                        } else {
     203                                                if ($value9>$max4){
     204                                                        $tmp4 = $max4;
     205                                                } else {
     206                                                        $tmp4 = $value9;
     207                                                }
     208                                        }
     209                                        $this->x2 = $tmp4;
     210                                        $value10 = $this->y2;
     211                                        if (!true){
     212                                                throw new HException("FAIL: lower <= upper");
     213                                        }
     214                                        $value11 = $value10+mt_rand(-8, +8);
     215                                        $max5 = $this->yBound-1;
     216                                        if (!(1<=$max5)){
     217                                                throw new HException("FAIL: min <= max");
     218                                        }
     219                                        $tmp5 = null;
     220                                        if ($value11<1){
     221                                                $tmp5 = 1;
     222                                        } else {
     223                                                if ($value11>$max5){
     224                                                        $tmp5 = $max5;
     225                                                } else {
     226                                                        $tmp5 = $value11;
     227                                                }
     228                                        }
     229                                        $this->y2 = $tmp5;
     230                                }
     231                                break;
     232                }
     233        }
     234
     235        public function rescale($scale){
     236                $this->cx = intval(round($this->cx*$scale));
     237                $this->cy = intval(round($this->cy*$scale));
     238                $this->x1 = intval(round($this->x1*$scale));
     239                $this->y1 = intval(round($this->y1*$scale));
     240                $this->x2 = intval(round($this->x2*$scale));
     241                $this->y2 = intval(round($this->y2*$scale));
     242                $this->xBound = intval(round($this->xBound*$scale));
     243                $this->yBound = intval(round($this->yBound*$scale));
     244        }
     245
     246        public function hclone(){
    225247                $bezier = new geometrize_shape_QuadraticBezier($this->xBound, $this->yBound);
    226248                $bezier->cx = $this->cx;
     
    230252                $bezier->x2 = $this->x2;
    231253                $bezier->y2 = $this->y2;
     254                if (isset($this->color)){
     255                        $bezier->color = $this->color;
     256                }
    232257                return $bezier;
    233258        }
    234         public function getType() {
     259
     260        public function getType(){
    235261                return 7;
    236262        }
    237         public function getRawShapeData() {
     263
     264        public function getRawShapeData(){
    238265                return (new _hx_array(array($this->x1, $this->y1, $this->cx, $this->cy, $this->x2, $this->y2)));
    239266        }
    240         public function getSvgShapeData() {
     267
     268        public function getSvgShapeData(){
    241269                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) . " />";
    242270        }
    243         public function __call($m, $a) {
    244                 if(isset($this->$m) && is_callable($this->$m))
     271
     272        public function __call($m, $a){
     273                if (isset($this->$m) && is_callable($this->$m)){
    245274                        return call_user_func_array($this->$m, $a);
    246                 else if(isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m]))
    247                         return call_user_func_array($this->__dynamics[$m], $a);
    248                 else if('toString' == $m)
    249                         return $this->__toString();
    250                 else
    251                         throw new HException('Unable to call <'.$m.'>');
    252         }
    253         function __toString() { return 'geometrize.shape.QuadraticBezier'; }
     275                } else {
     276                        if (isset($this->__dynamics[$m]) && is_callable($this->__dynamics[$m])){
     277                                return call_user_func_array($this->__dynamics[$m], $a);
     278                        } else {
     279                                if ('toString'==$m){
     280                                        return $this->__toString();
     281                                } else {
     282                                        throw new HException('Unable to call <' . $m . '>');
     283                                }
     284                        }
     285                }
     286        }
     287
     288        function __toString(){
     289                return 'geometrize.shape.QuadraticBezier';
     290        }
    254291}
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Rectangle.class.php

    r115842 r115850  
    22
    33// Generated by Haxe 3.4.7
    4 class geometrize_shape_Rectangle implements geometrize_shape_Shape{
    5         public function __construct($xBound, $yBound) {
    6                 if(!php_Boot::$skip_constructor) {
    7                 $this->x1 = Std::random($xBound);
    8                 $this->y1 = Std::random($yBound);
    9                 $value = $this->x1;
    10                 $value1 = $value + Std::random(32) + 1;
    11                 $max = $xBound - 1;
    12                 if(!(0 <= $max)) {
    13                         throw new HException("FAIL: min <= max");
    14                 }
    15                 $tmp = null;
    16                 if($value1 < 0) {
    17                         $tmp = 0;
    18                 } else {
    19                         if($value1 > $max) {
    20                                 $tmp = $max;
    21                         } else {
    22                                 $tmp = $value1;
    23                         }
    24                 }
    25                 $this->x2 = $tmp;
    26                 $value2 = $this->y1;
    27                 $value3 = $value2 + Std::random(32) + 1;
    28                 $max1 = $yBound - 1;
    29                 if(!(0 <= $max1)) {
    30                         throw new HException("FAIL: min <= max");
    31                 }
    32                 $tmp1 = null;
    33                 if($value3 < 0) {
    34                         $tmp1 = 0;
    35                 } else {
    36                         if($value3 > $max1) {
    37                                 $tmp1 = $max1;
    38                         } else {
    39                                 $tmp1 = $value3;
    40                         }
    41                 }
    42                 $this->y2 = $tmp1;
    43                 $this->xBound = $xBound;
    44                 $this->yBound = $yBound;
    45         }}
     4class geometrize_shape_Rectangle implements geometrize_shape_Shape {
    465        public $x1;
    476        public $y1;
     
    509        public $xBound;
    5110        public $yBound;
    52         public function rasterize() {
     11
     12        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;
     25                        } 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;
     42                        } 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                }
     53        }
     54
     55        public function rasterize(){
    5356                $lines = (new _hx_array(array()));
    5457                {
    5558                        $_g1 = $this->y1;
    5659                        $_g = $this->y2;
    57                         while($_g1 < $_g) {
    58                                 $_g1 = $_g1 + 1;
    59                                 $y = $_g1 - 1;
    60                                 if($this->x1 !== $this->x2) {
     60                        while ($_g1<$_g){
     61                                $_g1 = $_g1+1;
     62                                $y = $_g1-1;
     63                                if ($this->x1!==$this->x2){
    6164                                        $first = $this->x1;
    6265                                        $second = $this->x2;
    6366                                        $tmp = null;
    64                                         if($first < $second) {
     67                                        if ($first<$second){
    6568                                                $tmp = $first;
    6669                                        } else {
     
    7073                                        $second1 = $this->x2;
    7174                                        $tmp1 = null;
    72                                         if($first1 > $second1) {
     75                                        if ($first1>$second1){
    7376                                                $tmp1 = $first1;
    7477                                        } else {
     
    7679                                        }
    7780                                        $lines->push(new geometrize_rasterizer_Scanline($y, $tmp, $tmp1));
    78                                         unset($tmp1,$tmp,$second1,$second,$first1,$first);
     81                                        unset($tmp1, $tmp, $second1, $second, $first1, $first);
    7982                                }
    8083                                unset($y);
     
    8386                return $lines;
    8487        }
    85         public function mutate() {
    86                 $r = Std::random(2);
    87                 switch($r) {
    88                 case 0:{
    89                         $value = $this->x1;
    90                         if(!true) {
    91                                 throw new HException("FAIL: lower <= upper");
    92                         }
    93                         $value1 = $value + (-16 + Math::floor(33 * Math::random()));
    94                         $max = $this->xBound - 1;
    95                         if(!(0 <= $max)) {
    96                                 throw new HException("FAIL: min <= max");
    97                         }
    98                         $tmp = null;
    99                         if($value1 < 0) {
    100                                 $tmp = 0;
    101                         } else {
    102                                 if($value1 > $max) {
    103                                         $tmp = $max;
    104                                 } else {
    105                                         $tmp = $value1;
    106                                 }
    107                         }
    108                         $this->x1 = $tmp;
    109                         $value2 = $this->y1;
    110                         if(!true) {
    111                                 throw new HException("FAIL: lower <= upper");
    112                         }
    113                         $value3 = $value2 + (-16 + Math::floor(33 * Math::random()));
    114                         $max1 = $this->yBound - 1;
    115                         if(!(0 <= $max1)) {
    116                                 throw new HException("FAIL: min <= max");
    117                         }
    118                         $tmp1 = null;
    119                         if($value3 < 0) {
    120                                 $tmp1 = 0;
    121                         } else {
    122                                 if($value3 > $max1) {
    123                                         $tmp1 = $max1;
    124                                 } else {
    125                                         $tmp1 = $value3;
    126                                 }
    127                         }
    128                         $this->y1 = $tmp1;
    129                 }break;
    130                 case 1:{
    131                         $value4 = $this->x2;
    132                         if(!true) {
    133                                 throw new HException("FAIL: lower <= upper");
    134                         }
    135                         $value5 = $value4 + (-16 + Math::floor(33 * Math::random()));
    136                         $max2 = $this->xBound - 1;
    137                         if(!(0 <= $max2)) {
    138                                 throw new HException("FAIL: min <= max");
    139                         }
    140                         $tmp2 = null;
    141                         if($value5 < 0) {
    142                                 $tmp2 = 0;
    143                         } else {
    144                                 if($value5 > $max2) {
    145                                         $tmp2 = $max2;
    146                                 } else {
    147                                         $tmp2 = $value5;
    148                                 }
    149                         }
    150                         $this->x2 = $tmp2;
    151                         $value6 = $this->y2;
    152                         if(!true) {
    153                                 throw new HException("FAIL: lower <= upper");
    154                         }
    155                         $value7 = $value6 + (-16 + Math::floor(33 * Math::random()));
    156                         $max3 = $this->yBound - 1;
    157                         if(!(0 <= $max3)) {
    158                                 throw new HException("FAIL: min <= max");
    159                         }
    160                         $tmp3 = null;
    161                         if($value7 < 0) {
    162                                 $tmp3 = 0;
    163                         } else {
    164                                 if($value7 > $max3) {
    165                                         $tmp3 = $max3;
    166                                 } else {
    167                                         $tmp3 = $value7;
    168                                 }
    169                         }
    170                         $this->y2 = $tmp3;
    171                 }break;
    172                 }
    173         }
    174         public function hclone() {
     88
     89        public function mutate(){
     90                $r = mt_rand(0, 1);
     91                switch ($r) {
     92                        case 0:
     93                                {
     94                                        $value = $this->x1;
     95                                        if (!true){
     96                                                throw new HException("FAIL: lower <= upper");
     97                                        }
     98                                        $value1 = $value+mt_rand(-16, +16);
     99                                        $max = $this->xBound-1;
     100                                        if (!(0<=$max)){
     101                                                throw new HException("FAIL: min <= max");
     102                                        }
     103                                        $tmp = null;
     104                                        if ($value1<0){
     105                                                $tmp = 0;
     106                                        } else {
     107                                                if ($value1>$max){
     108                                                        $tmp = $max;
     109                                                } else {
     110                                                        $tmp = $value1;
     111                                                }
     112                                        }
     113                                        $this->x1 = $tmp;
     114                                        $value2 = $this->y1;
     115                                        if (!true){
     116                                                throw new HException("FAIL: lower <= upper");
     117                                        }
     118                                        $value3 = $value2+mt_rand(-16, +16);
     119                                        $max1 = $this->yBound-1;
     120                                        if (!(0<=$max1)){
     121                                                throw new HException("FAIL: min <= max");
     122                                        }
     123                                        $tmp1 = null;
     124                                        if ($value3<0){
     125                                                $tmp1 = 0;
     126                                        } else {
     127                                                if ($value3>$max1){
     128                                                        $tmp1 = $max1;
     129                                                } else {
     130                                                        $tmp1 = $value3;
     131                                                }
     132                                        }
     133                                        $this->y1 = $tmp1;
     134                                }
     135                                break;
     136                        case 1:
     137                                {
     138                                        $value4 = $this->x2;
     139                                        if (!true){
     140                                                throw new HException("FAIL: lower <= upper");
     141                                        }
     142                                        $value5 = $value4+mt_rand(-16, +16);
     143                                        $max2 = $this->xBound-1;
     144                                        if (!(0<=$max2)){
     145                                                throw new HException("FAIL: min <= max");
     146                                        }
     147                                        $tmp2 = null;
     148                                        if ($value5<0){
     149                                                $tmp2 = 0;
     150                                        } else {
     151                                                if ($value5>$max2){
     152                                                        $tmp2 = $max2;
     153                                                } else {
     154                                                        $tmp2 = $value5;
     155                                                }
     156                                        }
     157                                        $this->x2 = $tmp2;
     158                                        $value6 = $this->y2;
     159                                        if (!true){
     160                                                throw new HException("FAIL: lower <= upper");
     161                                        }
     162                                        $value7 = $value6+mt_rand(-16, +16);
     163                                        $max3 = $this->yBound-1;
     164                                        if (!(0<=$max3)){
     165                                                throw new HException("FAIL: min <= max");
     166                                        }
     167                                        $tmp3 = null;
     168                                        if ($value7<0){
     169                                                $tmp3 = 0;
     170                                        } else {
     171                                                if ($value7>$max3){
     172                                                        $tmp3 = $max3;
     173                                                } else {
     174                                                        $tmp3 = $value7;
     175                                                }
     176                                        }
     177                                        $this->y2 = $tmp3;
     178                                }
     179                                break;
     180                }
     181        }
     182
     183        public function rescale($scale){
     184                $this->x1 = intval(round($this->x1*$scale));
     185                $this->y1 = intval(round($this->y1*$scale));
     186                $this->x2 = intval(round($this->x2*$scale));
     187                $this->y2 = intval(round($this->y2*$scale));
     188                $this->xBound = intval(round($this->xBound*$scale));
     189                $this->yBound = intval(round($this->yBound*$scale));
     190        }
     191
     192        public function hclone(){
    175193                $rectangle = new geometrize_shape_Rectangle($this->xBound, $this->yBound);
    176194                $rectangle->x1 = $this->x1;
     
    178196                $rectangle->x2 = $this->x2;
    179197                $rectangle->y2 = $this->y2;
    180                 if (isset($this->color)) {
     198                if (isset($this->color)){
    181199                        $rectangle->color = $this->color;
    182200                }
    183201                return $rectangle;
    184202        }
    185         public function getType() {
     203
     204        public function getType(){
    186205                return 0;
    187206        }
    188         public function getRawShapeData() {
     207
     208        public function getRawShapeData(){
    189209                $first = $this->x1;
    190210                $second = $this->x2;
    191211                $tmp = null;
    192                 if($first < $second) {
     212                if ($first<$second){
    193213                        $tmp = $first;
    194214                } else {
     
    198218                $second1 = $this->y2;
    199219                $tmp1 = null;
    200                 if($first1 < $second1) {
     220                if ($first1<$second1){
    201221                        $tmp1 = $first1;
    202222                } else {
     
    206226                $second2 = $this->x2;
    207227                $tmp2 = null;
    208                 if($first2 > $second2) {
     228                if ($first2>$second2){
    209229                        $tmp2 = $first2;
    210230                } else {
     
    214234                $second3 = $this->y2;
    215235                $tmp3 = null;
    216                 if($first3 > $second3) {
     236                if ($first3>$second3){
    217237                        $tmp3 = $first3;
    218238                } else {
     
    221241                return (new _hx_array(array($tmp, $tmp1, $tmp2, $tmp3)));
    222242        }
    223         public function getSvgShapeData() {
     243
     244        public function getSvgShapeData(){
    224245                $first = $this->x1;
    225246                $second = $this->x2;
    226247                $tmp = null;
    227                 if($first < $second) {
     248                if ($first<$second){
    228249                        $tmp = $first;
    229250                } else {
     
    233254                $second1 = $this->y2;
    234255                $tmp1 = null;
    235                 if($first1 < $second1) {
     256                if ($first1<$second1){
    236257                        $tmp1 = $first1;
    237258                } else {