Changeset 115842 in spip-zone


Ignore:
Timestamp:
Jul 2, 2019, 10:03:21 AM (3 weeks ago)
Author:
cedric@…
Message:

Optimisation du temps de calcul, en particulier avec opacite=255

Location:
_plugins_/adaptive_images/trunk/lib/geometrize/geometrize
Files:
10 edited

Legend:

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

    r115817 r115842  
    2222                $count = 0;
    2323                $f = 65535 / $alpha;
    24                 $a = Std::int($f);
     24                $a = intval($f);
    2525                {
    2626                        $_g = 0;
     
    5151                        return 0;
    5252                }
    53                 $value = Std::int($totalRed / $count) >> 8;
     53                $value = intval($totalRed / $count) >> 8;
    5454                if(!true) {
    5555                        throw new HException("FAIL: min <= max");
     
    6565                        }
    6666                }
    67                 $value1 = Std::int($totalGreen / $count) >> 8;
     67                $value1 = intval($totalGreen / $count) >> 8;
    6868                if(!true) {
    6969                        throw new HException("FAIL: min <= max");
     
    7979                        }
    8080                }
    81                 $value2 = Std::int($totalBlue / $count) >> 8;
     81                $value2 = intval($totalBlue / $count) >> 8;
    8282                if(!true) {
    8383                        throw new HException("FAIL: min <= max");
     
    148148        }
    149149        static function differenceFull($first, $second) {
     150                /*
    150151                if(!($first !== null)) {
    151152                        throw new HException("FAIL: first != null");
     
    154155                        throw new HException("FAIL: second != null");
    155156                }
     157                */
     158                /*
    156159                {
    157160                        $actual = $first->width;
     
    168171                        }
    169172                }
     173                */
    170174                $total = 0;
    171175                $width = $first->width;
    172176                $height = $first->height;
    173                 {
    174                         $_g1 = 0;
    175                         $_g = $height;
    176                         while($_g1 < $_g) {
    177                                 $_g1 = $_g1 + 1;
    178                                 $y = $_g1 - 1;
    179                                 {
    180                                         $_g3 = 0;
    181                                         $_g2 = $width;
    182                                         while($_g3 < $_g2) {
    183                                                 $_g3 = $_g3 + 1;
    184                                                 $x = $_g3 - 1;
    185                                                 $f = $first->data[$first->width * $y + $x];
    186                                                 $s = $second->data[$second->width * $y + $x];
    187                                                 $dr = ($f >> 24 & 255) - ($s >> 24 & 255);
    188                                                 $dg = ($f >> 16 & 255) - ($s >> 16 & 255);
    189                                                 $db = ($f >> 8 & 255) - ($s >> 8 & 255);
    190                                                 $da = ($f & 255) - ($s & 255);
    191                                                 $total = $total + ($dr * $dr + $dg * $dg + $db * $db + $da * $da);
    192                                                 unset($x,$s,$f,$dr,$dg,$db,$da);
    193                                         }
    194                                         unset($_g3,$_g2);
    195                                 }
    196                                 unset($y);
    197                         }
    198                 }
    199                 return Math::sqrt($total / ($width * $height * 4.0)) / 255;
     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;
    200194        }
    201195        static function differencePartial($target, $before, $after, $score, $lines) {
     196
     197                if (!isset($before->errorCache)) {
     198                        $before->errorCache = [];
     199                }
     200
     201                /*
    202202                if(!($target !== null)) {
    203203                        throw new HException("FAIL: target != null");
     
    211211                if(!($lines !== null)) {
    212212                        throw new HException("FAIL: lines != null");
    213                 }
     213                }*/
    214214                $width = $target->width;
    215215                $height = $target->height;
    216                 $rgbaCount = $width * $height * 4;
    217                 $total = Math::pow($score * 255, 2) * $rgbaCount;
    218                 {
    219                         $_g = 0;
    220                         while($_g < $lines->length) {
    221                                 $line = $lines[$_g];
    222                                 $_g = $_g + 1;
    223                                 $y = $line->y;
    224                                 {
    225                                         $_g2 = $line->x1;
    226                                         $_g1 = $line->x2 + 1;
    227                                         while($_g2 < $_g1) {
    228                                                 $_g2 = $_g2 + 1;
    229                                                 $x = $_g2 - 1;
    230                                                 $t = $target->data[$target->width * $y + $x];
    231                                                 $b = $before->data[$before->width * $y + $x];
    232                                                 $a = $after->data[$after->width * $y + $x];
    233                                                 $dtbr = ($t >> 24 & 255) - ($b >> 24 & 255);
    234                                                 $dtbg = ($t >> 16 & 255) - ($b >> 16 & 255);
    235                                                 $dtbb = ($t >> 8 & 255) - ($b >> 8 & 255);
    236                                                 $dtba = ($t & 255) - ($b & 255);
    237                                                 $dtar = ($t >> 24 & 255) - ($a >> 24 & 255);
    238                                                 $dtag = ($t >> 16 & 255) - ($a >> 16 & 255);
    239                                                 $dtab = ($t >> 8 & 255) - ($a >> 8 & 255);
    240                                                 $dtaa = ($t & 255) - ($a & 255);
    241                                                 $total = $total - ($dtbr * $dtbr + $dtbg * $dtbg + $dtbb * $dtbb + $dtba * $dtba);
    242                                                 $total = $total + ($dtar * $dtar + $dtag * $dtag + $dtab * $dtab + $dtaa * $dtaa);
    243                                                 unset($x,$t,$dtbr,$dtbg,$dtbb,$dtba,$dtar,$dtag,$dtab,$dtaa,$b,$a);
    244                                         }
    245                                         unset($_g2,$_g1);
     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;
    246240                                }
    247                                 unset($y,$line);
    248                         }
    249                 }
    250                 return Math::sqrt($total / $rgbaCount) / 255;
     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;
    251255        }
    252256        static function bestRandomState($shapes, $alpha, $n, $target, $current, $buffer, $lastScore) {
     
    307311                return $bestState;
    308312        }
    309         static function energy($shape, $alpha, $target, $current, $buffer, $score) {
     313        static function energy(&$shape, $alpha, $target, $current, $buffer, $score) {
    310314                if(!($shape !== null)) {
    311315                        throw new HException("FAIL: shape != null");
     
    321325                }
    322326                $lines = $shape->rasterize();
    323                 $color = geometrize_Core::computeColor($target, $current, $lines, $alpha);
    324                 geometrize_rasterizer_Rasterizer::copyLines($buffer, $current, $lines);
     327                if (!isset($shape->color)) {
     328                        $shape->color = geometrize_Core::computeColor($target, $current, $lines, $alpha);
     329                }
     330                $color = $shape->color;
     331                // useful only if opacity!=1
     332                if ($color && 255 !== 255) {
     333                        geometrize_rasterizer_Rasterizer::copyLines($buffer, $current, $lines);
     334                }
    325335                geometrize_rasterizer_Rasterizer::drawLines($buffer, $color, $lines);
    326336                return geometrize_Core::differencePartial($target, $current, $buffer, $score, $lines);
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/Model.class.php

    r115817 r115842  
    7474                }
    7575                $before = $bitmap;
     76                if (isset($this->current->errorCache)) {
     77                        $before->errorCache = $this->current->errorCache;
     78                        $this->current->errorCache = [];
     79                }
    7680                $lines = $shape->rasterize();
    77                 $color = geometrize_Core::computeColor($this->target, $this->current, $lines, $alpha);
     81                if (!isset($shape->color)) {
     82                        $shape->color = geometrize_Core::computeColor($this->target, $this->current, $lines, $alpha);
     83                }
     84                $color = $shape->color;
    7885                geometrize_rasterizer_Rasterizer::drawLines($this->current, $color, $lines);
    7986                $this->score = geometrize_Core::differencePartial($this->target, $before, $this->current, $this->score, $lines);
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/Util.class.php

    r115817 r115842  
    3838                }
    3939                $size = $image->width * $image->height;
    40                 $red = Std::int($totalRed / $size);
    41                 $green = Std::int($totalGreen / $size);
    42                 $blue = Std::int($totalBlue / $size);
     40                $red = intval($totalRed / $size);
     41                $green = intval($totalGreen / $size);
     42                $blue = intval($totalBlue / $size);
    4343                if(!true) {
    4444                        throw new HException("FAIL: min <= max");
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/bitmap/Bitmap.class.php

    r115817 r115842  
    129129                $bitmap->height = $h;
    130130                $this1 = (new _hx_array(array()));
    131                 $this1->length = Std::int($bytes->length / 4);
     131                $this1->length = intval($bytes->length / 4);
    132132                $bitmap->data = $this1;
    133133                $i = 0;
     
    229229                $bitmap->height = $h;
    230230                $this2 = (new _hx_array(array()));
    231                 $this2->length = Std::int($data->length / 4);
     231                $this2->length = intval($data->length / 4);
    232232                $bitmap->data = $this2;
    233233                $i1 = 0;
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/rasterizer/Rasterizer.class.php

    r115817 r115842  
    55        public function __construct(){}
    66        static function drawLines($image, $c, $lines) {
    7                 if(!($image !== null)) {
    8                         throw new HException("FAIL: image != null");
    9                 }
    10                 if(!($lines !== null)) {
    11                         throw new HException("FAIL: lines != null");
    12                 }
    13                 $sr = $c >> 24 & 255;
    14                 $sr = $sr | $sr << 8;
    15                 $sr = $sr * ($c & 255);
    16                 $sr = Std::int($sr / 255);
    17                 $sg = $c >> 16 & 255;
    18                 $sg = $sg | $sg << 8;
    19                 $sg = $sg * ($c & 255);
    20                 $sg = Std::int($sg / 255);
    21                 $sb = $c >> 8 & 255;
    22                 $sb = $sb | $sb << 8;
    23                 $sb = $sb * ($c & 255);
    24                 $sb = Std::int($sb / 255);
    25                 $sa = $c & 255;
    26                 $sa = $sa | $sa << 8;
    27                 {
    28                         $_g = 0;
    29                         while($_g < $lines->length) {
    30                                 $line = $lines[$_g];
    31                                 $_g = $_g + 1;
    32                                 $y = $line->y;
    33                                 $ma = 65535;
    34                                 $m = 65535;
    35                                 $as = ($m - $sa * ($ma / $m)) * 257;
    36                                 $a = Std::int($as);
    37                                 {
    38                                         $_g2 = $line->x1;
    39                                         $_g1 = $line->x2 + 1;
    40                                         while($_g2 < $_g1) {
    41                                                 $_g2 = $_g2 + 1;
    42                                                 $x = $_g2 - 1;
    43                                                 $d = $image->data[$image->width * $y + $x];
    44                                                 $dr = $d >> 24 & 255;
    45                                                 $dg = $d >> 16 & 255;
    46                                                 $db = $d >> 8 & 255;
    47                                                 $da = $d & 255;
    48                                                 $int = $dr * $a + $sr * $ma;
    49                                                 $r = null;
    50                                                 if($int < 0) {
    51                                                         $r = 4294967296.0 + $int;
    52                                                 } else {
    53                                                         $r = $int + 0.0;
     7
     8                // 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                                $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 {
     20                        $sr = $c >> 24 & 255;
     21                        $sr = $sr | $sr << 8;
     22                        $sr = $sr * ($c & 255);
     23                        $sr = intval($sr / 255);
     24                        $sg = $c >> 16 & 255;
     25                        $sg = $sg | $sg << 8;
     26                        $sg = $sg * ($c & 255);
     27                        $sg = intval($sg / 255);
     28                        $sb = $c >> 8 & 255;
     29                        $sb = $sb | $sb << 8;
     30                        $sb = $sb * ($c & 255);
     31                        $sb = intval($sb / 255);
     32                        $sa = $c & 255;
     33                        $sa = $sa | $sa << 8;
     34                        {
     35                                $_g = 0;
     36                                while($_g < $lines->length) {
     37                                        $line = $lines[$_g];
     38                                        $_g = $_g + 1;
     39                                        $y = $line->y;
     40                                        $ma = 65535;
     41                                        $m = 65535;
     42                                        $as = ($m - $sa * ($ma / $m)) * 257;
     43                                        $a = intval($as);
     44                                        {
     45                                                $_g2 = $line->x1;
     46                                                $_g1 = $line->x2 + 1;
     47                                                while($_g2 < $_g1) {
     48                                                        $_g2 = $_g2 + 1;
     49                                                        $x = $_g2 - 1;
     50                                                        $d = $image->data[$image->width * $y + $x];
     51                                                        $dr = $d >> 24 & 255;
     52                                                        $dg = $d >> 16 & 255;
     53                                                        $db = $d >> 8 & 255;
     54                                                        $da = $d & 255;
     55                                                        $int = $dr * $a + $sr * $ma;
     56                                                        $r = null;
     57                                                        if($int < 0) {
     58                                                                $r = 4294967296.0 + $int;
     59                                                        } else {
     60                                                                $r = $int + 0.0;
     61                                                        }
     62                                                        $int1 = $m;
     63                                                        $r1 = null;
     64                                                        if($int1 < 0) {
     65                                                                $r1 = 4294967296.0 + $int1;
     66                                                        } else {
     67                                                                $r1 = $int1 + 0.0;
     68                                                        }
     69                                                        $r2 = intval($r / $r1) >> 8;
     70                                                        $int2 = $dg * $a + $sg * $ma;
     71                                                        $g = null;
     72                                                        if($int2 < 0) {
     73                                                                $g = 4294967296.0 + $int2;
     74                                                        } else {
     75                                                                $g = $int2 + 0.0;
     76                                                        }
     77                                                        $int3 = $m;
     78                                                        $g1 = null;
     79                                                        if($int3 < 0) {
     80                                                                $g1 = 4294967296.0 + $int3;
     81                                                        } else {
     82                                                                $g1 = $int3 + 0.0;
     83                                                        }
     84                                                        $g2 = intval($g / $g1) >> 8;
     85                                                        $int4 = $db * $a + $sb * $ma;
     86                                                        $b = null;
     87                                                        if($int4 < 0) {
     88                                                                $b = 4294967296.0 + $int4;
     89                                                        } else {
     90                                                                $b = $int4 + 0.0;
     91                                                        }
     92                                                        $int5 = $m;
     93                                                        $b1 = null;
     94                                                        if($int5 < 0) {
     95                                                                $b1 = 4294967296.0 + $int5;
     96                                                        } else {
     97                                                                $b1 = $int5 + 0.0;
     98                                                        }
     99                                                        $b2 = intval($b / $b1) >> 8;
     100                                                        $int6 = $da * $a + $sa * $ma;
     101                                                        $a1 = null;
     102                                                        if($int6 < 0) {
     103                                                                $a1 = 4294967296.0 + $int6;
     104                                                        } else {
     105                                                                $a1 = $int6 + 0.0;
     106                                                        }
     107                                                        $int7 = $m;
     108                                                        $a2 = null;
     109                                                        if($int7 < 0) {
     110                                                                $a2 = 4294967296.0 + $int7;
     111                                                        } else {
     112                                                                $a2 = $int7 + 0.0;
     113                                                        }
     114                                                        $a3 = intval($a1 / $a2) >> 8;
     115                                                        {
     116                                                                if(!true) {
     117                                                                        throw new HException("FAIL: min <= max");
     118                                                                }
     119                                                                $color = null;
     120                                                                if($r2 < 0) {
     121                                                                        $color = 0;
     122                                                                } else {
     123                                                                        if($r2 > 255) {
     124                                                                                $color = 255;
     125                                                                        } else {
     126                                                                                $color = $r2;
     127                                                                        }
     128                                                                }
     129                                                                if(!true) {
     130                                                                        throw new HException("FAIL: min <= max");
     131                                                                }
     132                                                                $color1 = null;
     133                                                                if($g2 < 0) {
     134                                                                        $color1 = 0;
     135                                                                } else {
     136                                                                        if($g2 > 255) {
     137                                                                                $color1 = 255;
     138                                                                        } else {
     139                                                                                $color1 = $g2;
     140                                                                        }
     141                                                                }
     142                                                                if(!true) {
     143                                                                        throw new HException("FAIL: min <= max");
     144                                                                }
     145                                                                $color2 = null;
     146                                                                if($b2 < 0) {
     147                                                                        $color2 = 0;
     148                                                                } else {
     149                                                                        if($b2 > 255) {
     150                                                                                $color2 = 255;
     151                                                                        } else {
     152                                                                                $color2 = $b2;
     153                                                                        }
     154                                                                }
     155                                                                if(!true) {
     156                                                                        throw new HException("FAIL: min <= max");
     157                                                                }
     158                                                                $color3 = null;
     159                                                                if($a3 < 0) {
     160                                                                        $color3 = 0;
     161                                                                } else {
     162                                                                        if($a3 > 255) {
     163                                                                                $color3 = 255;
     164                                                                        } else {
     165                                                                                $color3 = $a3;
     166                                                                        }
     167                                                                }
     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);
    54172                                                }
    55                                                 $int1 = $m;
    56                                                 $r1 = null;
    57                                                 if($int1 < 0) {
    58                                                         $r1 = 4294967296.0 + $int1;
    59                                                 } else {
    60                                                         $r1 = $int1 + 0.0;
    61                                                 }
    62                                                 $r2 = Std::int($r / $r1) >> 8;
    63                                                 $int2 = $dg * $a + $sg * $ma;
    64                                                 $g = null;
    65                                                 if($int2 < 0) {
    66                                                         $g = 4294967296.0 + $int2;
    67                                                 } else {
    68                                                         $g = $int2 + 0.0;
    69                                                 }
    70                                                 $int3 = $m;
    71                                                 $g1 = null;
    72                                                 if($int3 < 0) {
    73                                                         $g1 = 4294967296.0 + $int3;
    74                                                 } else {
    75                                                         $g1 = $int3 + 0.0;
    76                                                 }
    77                                                 $g2 = Std::int($g / $g1) >> 8;
    78                                                 $int4 = $db * $a + $sb * $ma;
    79                                                 $b = null;
    80                                                 if($int4 < 0) {
    81                                                         $b = 4294967296.0 + $int4;
    82                                                 } else {
    83                                                         $b = $int4 + 0.0;
    84                                                 }
    85                                                 $int5 = $m;
    86                                                 $b1 = null;
    87                                                 if($int5 < 0) {
    88                                                         $b1 = 4294967296.0 + $int5;
    89                                                 } else {
    90                                                         $b1 = $int5 + 0.0;
    91                                                 }
    92                                                 $b2 = Std::int($b / $b1) >> 8;
    93                                                 $int6 = $da * $a + $sa * $ma;
    94                                                 $a1 = null;
    95                                                 if($int6 < 0) {
    96                                                         $a1 = 4294967296.0 + $int6;
    97                                                 } else {
    98                                                         $a1 = $int6 + 0.0;
    99                                                 }
    100                                                 $int7 = $m;
    101                                                 $a2 = null;
    102                                                 if($int7 < 0) {
    103                                                         $a2 = 4294967296.0 + $int7;
    104                                                 } else {
    105                                                         $a2 = $int7 + 0.0;
    106                                                 }
    107                                                 $a3 = Std::int($a1 / $a2) >> 8;
    108                                                 {
    109                                                         if(!true) {
    110                                                                 throw new HException("FAIL: min <= max");
    111                                                         }
    112                                                         $color = null;
    113                                                         if($r2 < 0) {
    114                                                                 $color = 0;
    115                                                         } else {
    116                                                                 if($r2 > 255) {
    117                                                                         $color = 255;
    118                                                                 } else {
    119                                                                         $color = $r2;
    120                                                                 }
    121                                                         }
    122                                                         if(!true) {
    123                                                                 throw new HException("FAIL: min <= max");
    124                                                         }
    125                                                         $color1 = null;
    126                                                         if($g2 < 0) {
    127                                                                 $color1 = 0;
    128                                                         } else {
    129                                                                 if($g2 > 255) {
    130                                                                         $color1 = 255;
    131                                                                 } else {
    132                                                                         $color1 = $g2;
    133                                                                 }
    134                                                         }
    135                                                         if(!true) {
    136                                                                 throw new HException("FAIL: min <= max");
    137                                                         }
    138                                                         $color2 = null;
    139                                                         if($b2 < 0) {
    140                                                                 $color2 = 0;
    141                                                         } else {
    142                                                                 if($b2 > 255) {
    143                                                                         $color2 = 255;
    144                                                                 } else {
    145                                                                         $color2 = $b2;
    146                                                                 }
    147                                                         }
    148                                                         if(!true) {
    149                                                                 throw new HException("FAIL: min <= max");
    150                                                         }
    151                                                         $color3 = null;
    152                                                         if($a3 < 0) {
    153                                                                 $color3 = 0;
    154                                                         } else {
    155                                                                 if($a3 > 255) {
    156                                                                         $color3 = 255;
    157                                                                 } else {
    158                                                                         $color3 = $a3;
    159                                                                 }
    160                                                         }
    161                                                         $image->data[$image->width * $y + $x] = ($color << 24) + ($color1 << 16) + ($color2 << 8) + $color3;
    162                                                         unset($color3,$color2,$color1,$color);
    163                                                 }
    164                                                 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);
     173                                                unset($_g2,$_g1);
    165174                                        }
    166                                         unset($_g2,$_g1);
    167                                 }
    168                                 unset($y,$ma,$m,$line,$as,$a);
     175                                        unset($y,$ma,$m,$line,$as,$a);
     176                                }
    169177                        }
    170178                }
     
    180188                        throw new HException("FAIL: lines != null");
    181189                }
     190                for($_g=0;$_g < $lines->length;$_g++) {
     191                        $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/*
    182200                {
    183201                        $_g = 0;
     
    199217                                unset($y,$line);
    200218                        }
    201                 }
     219                }*/
    202220        }
    203221        static function bresenham($x1, $y1, $x2, $y2) {
     
    314332                        }
    315333                }
     334                $yToXs = [];
     335                for ($_g2 = 0;$_g2 < $edges->length;$_g2++) {
     336                        $point = $edges[$_g2];
     337                        if (!isset($yToXs[$point->y])) {
     338                                $yToXs[$point->y] = [];
     339                        }
     340                        $yToXs[$point->y][] = $point->x;
     341                }
     342                ksort($yToXs);
     343                foreach ($yToXs as $y => $xs) {
     344                        $minx = min($xs);
     345                        $maxx = max($xs);
     346                        $lines->push(new geometrize_rasterizer_Scanline($y, $minx, $maxx));
     347                }
     348/*
     349
    316350                $yToXs = new haxe_ds_IntMap();
    317351                {
     
    370404                        }
    371405                }
     406*/
    372407                return $lines;
    373408        }
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Circle.class.php

    r115817 r115842  
    8484                $circle->rx = $this->rx;
    8585                $circle->ry = $this->ry;
     86                if (isset($this->color)) {
     87                        $circle->color = $this->color;
     88                }
    8689                return $circle;
    8790        }
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Ellipse.class.php

    r115817 r115842  
    185185                $ellipse->rx = $this->rx;
    186186                $ellipse->ry = $this->ry;
     187                if (isset($this->color)) {
     188                        $ellipse->color = $this->color;
     189                }
    187190                return $ellipse;
    188191        }
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Rectangle.class.php

    r115817 r115842  
    178178                $rectangle->x2 = $this->x2;
    179179                $rectangle->y2 = $this->y2;
     180                if (isset($this->color)) {
     181                        $rectangle->color = $this->color;
     182                }
    180183                return $rectangle;
    181184        }
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/RotatedEllipse.class.php

    r115817 r115842  
    165165                $ellipse->ry = $this->ry;
    166166                $ellipse->angle = $this->angle;
     167                if (isset($this->color)) {
     168                        $ellipse->color = $this->color;
     169                }
    167170                return $ellipse;
    168171        }
  • _plugins_/adaptive_images/trunk/lib/geometrize/geometrize/shape/Triangle.class.php

    r115817 r115842  
    1111                        throw new HException("FAIL: lower <= upper");
    1212                }
    13                 $this->x2 = $tmp + (-16 + Math::floor(33 * Math::random()));
     13                $this->x2 = $tmp + mt_rand(-16,+16);
    1414                $tmp1 = $this->y1;
    1515                if(!true) {
    1616                        throw new HException("FAIL: lower <= upper");
    1717                }
    18                 $this->y2 = $tmp1 + (-16 + Math::floor(33 * Math::random()));
     18                $this->y2 = $tmp1 + mt_rand(-16,+16);
    1919                $tmp2 = $this->x1;
    2020                if(!true) {
    2121                        throw new HException("FAIL: lower <= upper");
    2222                }
    23                 $this->x3 = $tmp2 + (-16 + Math::floor(33 * Math::random()));
     23                $this->x3 = $tmp2  + mt_rand(-16,+16);
    2424                $tmp3 = $this->y1;
    2525                if(!true) {
    2626                        throw new HException("FAIL: lower <= upper");
    2727                }
    28                 $this->y3 = $tmp3 + (-16 + Math::floor(33 * Math::random()));
     28                $this->y3 = $tmp3  + mt_rand(-16,+16);
    2929                $this->xBound = $xBound;
    3030                $this->yBound = $yBound;
     
    4343        }
    4444        public function mutate() {
    45                 $r = Std::random(3);
     45                $r = mt_rand(0,2);
    4646                switch($r) {
    4747                case 0:{
     
    5050                                throw new HException("FAIL: lower <= upper");
    5151                        }
    52                         $value1 = $value + (-16 + Math::floor(33 * Math::random()));
     52                        $value1 = $value  + mt_rand(-16,+16);
    5353                        $max = $this->xBound - 1;
    5454                        if(!(0 <= $max)) {
     
    7070                                throw new HException("FAIL: lower <= upper");
    7171                        }
    72                         $value3 = $value2 + (-16 + Math::floor(33 * Math::random()));
     72                        $value3 = $value2  + mt_rand(-16,+16);
    7373                        $max1 = $this->yBound - 1;
    7474                        if(!(0 <= $max1)) {
     
    9292                                throw new HException("FAIL: lower <= upper");
    9393                        }
    94                         $value5 = $value4 + (-16 + Math::floor(33 * Math::random()));
     94                        $value5 = $value4  + mt_rand(-16,+16);
    9595                        $max2 = $this->xBound - 1;
    9696                        if(!(0 <= $max2)) {
     
    112112                                throw new HException("FAIL: lower <= upper");
    113113                        }
    114                         $value7 = $value6 + (-16 + Math::floor(33 * Math::random()));
     114                        $value7 = $value6  + mt_rand(-16,+16);
    115115                        $max3 = $this->yBound - 1;
    116116                        if(!(0 <= $max3)) {
     
    134134                                throw new HException("FAIL: lower <= upper");
    135135                        }
    136                         $value9 = $value8 + (-16 + Math::floor(33 * Math::random()));
     136                        $value9 = $value8  + mt_rand(-16,+16);
    137137                        $max4 = $this->xBound - 1;
    138138                        if(!(0 <= $max4)) {
     
    154154                                throw new HException("FAIL: lower <= upper");
    155155                        }
    156                         $value11 = $value10 + (-16 + Math::floor(33 * Math::random()));
     156                        $value11 = $value10  + mt_rand(-16,+16);
    157157                        $max5 = $this->yBound - 1;
    158158                        if(!(0 <= $max5)) {
     
    181181                $triangle->x3 = $this->x3;
    182182                $triangle->y3 = $this->y3;
     183                if (isset($this->color)) {
     184                        $triangle->color = $this->color;
     185                }
    183186                return $triangle;
    184187        }
Note: See TracChangeset for help on using the changeset viewer.