Adds new python_rpnifs tests

python_rpnifs/__main__.py

@@ -14,20 +14,31 @@ from tqdm import tqdm
 
 from .ifs1 import IFS1
 from .ifs2 import IFS2
+from .ifs3 import IFS3
+from .ifs4 import IFS4
+from .ifs5 import IFS5
 
 
 #steps = 1024**2
-steps=512**2
+#steps=512**2
+steps=1024**2
 #steps*=4
 #steps*=10
-pool_sz = 32
-best_sz = 4
-n_mutation = 5
+pool_sz = 30
+best_sz = 6
+n_mutation = 10
 outfile='/tmp/rpnifs2_%02d.png'
-world = IFS1.get_world()
-pool = [IFS1(init_sz=3, world=world) for _ in range(pool_sz)]
+#world = IFS1.get_world()
+#pool = [IFS1(init_sz=3, world=world) for _ in range(pool_sz)]
 #world = IFS2.get_world()
 #pool = [IFS2(init_sz=3, world=world) for _ in range(pool_sz)]
+#world = IFS3.get_world()
+#pool = [IFS3(init_sz=3, world=world) for _ in range(pool_sz)]
+#world = IFS4.get_world()
+#pool = [IFS4(init_sz=3, world=world) for _ in range(pool_sz)]
+world = IFS5.get_world()
+#pool = [IFS5(init_sz=3, world=world) for _ in range(pool_sz)]
+pool = [IFS5(init_sz=6, world=world) for _ in range(pool_sz)]
 print('POOL ready')
 
 generation=0
@@ -49,7 +60,7 @@ while True:
 
         score = ifs.score()
         scores.append((ifs, score))
-        #print('%02d) %5.3f %s' % (i, score, ifs))
+        print('%02d) %5.3f %s' % (i, score, ifs))
         im = Image.fromarray(ifs.get_image())
         im.save(outfile % i)
 

python_rpnifs/ifs1.py

@@ -1,4 +1,5 @@
 import random
+import time
 import copy
 
 import numpy as np
@@ -93,6 +94,11 @@ class IFS1(object):
         self._world[self._position[0]][self._position[1]] = [r,g,b,a]
 
     def score(self):
+        start = time.time()
+        
+        colcount = len(np.unique(np.reshape(self._world[:,:,:3], (-1,3)),
+                       axis=0))
+
         #gray = rgb2gray(self._world)
         #sigma = estimate_sigma(self._world, multichannel=True, average_sigmas=True)
         sigmas = estimate_sigma(self._world, multichannel=True, average_sigmas=False)
@@ -111,9 +117,16 @@ class IFS1(object):
 
 
         score += mod 
-        if sigma and sigma > 5:
-            score /= sigma/5
-        print("SIGMAS : %r SIGMA  : %f " %  (sigmas, sigma))
-        print("SCORES : %r SCORE : %r" % (scores, score))
+        if sigma and sigma > 50:
+            score -= (sigma-50)/100
+        colscore = abs(colcount-1024) / 1e5
+        score -= colscore
+
+        printscore = lambda arr: '['+(', '.join(['%1.3f' % e for e in arr]))+']'
+        print("colscore %3.3f (%4d colors) scores time %5.2fs" % (colscore,
+                                                                 colcount,
+                                                                 time.time() - start))
+        print("SIGMAS : %s SIGMA  : %f " %  (printscore(sigmas), sigma))
+        print("SCORES : %s SCORE : %r" % (printscore(scores), score))
         return score
 

python_rpnifs/ifs3.py

@@ -0,0 +1,147 @@
+import random
+import time
+import copy
+
+import numpy as np
+from skimage.restoration import estimate_sigma
+
+from .expr import *
+from .fractdim import *
+
+
+class IFS3(object):
+    """ @brief 1 Variable IFS with R,G,B,A X,Y decomposition """
+
+    #height=width=1024
+    height=width=768
+    #height=width=512
+
+    def __init__(self, nexpr=4, init_sz=1, world=None):
+        self._nexpr = nexpr
+        self._expr = [RpnExpr(sz=init_sz, nvar=1)
+                      for _ in range(nexpr)]
+        self._world = world
+        if self._world is None:
+            self._world = self.get_world()
+        self._position = [random.randint(0, self.height-1),
+                          random.randint(0, self.width-1)]
+
+    @classmethod
+    def get_world(cls):
+        return np.zeros((cls.height,cls.width,4), dtype=np.uint8)
+
+    def raz_world(self):
+        for i in range(self.height):
+            for j in range(self.width):
+                self._world[i][j] = [0,0,0,0]
+    
+    def __str__(self):
+        return ";".join([str(e) for e in self._expr])
+
+    def __copy__(self):
+        ret = IFS3(nexpr=self._nexpr, world=self._world)
+        ret._expr = [copy.copy(e) for e in self._expr]
+        #ret._world = copy.deepcopy(self._world)
+        return ret
+
+    def get_image(self):
+    	return self._world
+ 
+    def mutation(self, n=1, rand=True):
+        n = 1 if n <= 1 else random.randint(1,n)
+        for _ in range(n):
+            random.choice(self._expr).mutation()
+
+    def step(self):
+        r,g,b,a = [int(e)
+                   for e in self._world[self._position[0]][self._position[1]]]
+        arg = r
+        arg <<= 8
+        arg += g
+        arg <<= 8
+        arg += b
+        arg <<= 8
+        arg += a
+        arg <<=16
+        arg += self._position[0]
+        arg <<=16
+        arg += self._position[1]
+
+        ret = int(random.choice(self._expr).eval(arg))
+        dr, dg, db, da = r,g,b,a
+
+        #self._position[1] = (ret & 0xFFFF)%self.width
+        self._position[1] = ((ret & 0xFFFF)*self.width)//0x10000
+        ret >>= 16
+        self._position[0] = ((ret & 0xFFFF)*self.height)//0x10000
+        ret >>= 16
+        a = ret & 0xFF
+        ret >>= 8
+        b = ret & 0xFF
+        ret >>= 8
+        g = ret & 0xFF
+        ret >>= 8
+        r = ret & 0xFF
+
+        sa = a/255
+        outa = (a + da*(1-sa))/255
+        if outa == 0:
+            ro,go,bo = 0,0,0
+        else:
+            ro, go, bo = [(c*(a/255)+dc*da*(1-sa))/outa
+                          for c, dc in ((r,dr), (g, dg), (b, db))]
+        r,g,b,a = [int(e) for e in (ro,go,bo,outa*255)]
+
+
+        self._world[self._position[0]][self._position[1]] = [r,g,b,a]
+
+    def score(self):
+        start = time.time()
+        
+        colcount = len(np.unique(np.reshape(self._world[:,:,:3], (-1,3)),
+                       axis=0))
+
+        #sigma = estimate_sigma(self._world, multichannel=True, average_sigmas=True)
+        sigmas = estimate_sigma(self._world[:,:,:3], multichannel=True,
+                                average_sigmas=False)
+
+        scores = [fractal_dimension(self._world[:,:,i]*self._world[:,:,3]/255)
+                  for i in range(3)]
+        #alpha score
+        #scores += [fractal_dimension(self._world[:,:,3])]
+
+        gray = rgb2gray(self._world)
+        graysigma = estimate_sigma(gray)
+        grayscore = fractal_dimension(gray)
+        del(gray)
+
+        sigmas += [graysigma]*3
+        sigmas = [0 if np.isnan(sigma) else sigma for sigma in sigmas]
+
+        scores += [grayscore]*3
+
+        sigma = sum(sigmas)/len(sigmas)
+
+        mod = abs(scores[0]-scores[1])
+        mod += abs(scores[0]-scores[2])
+        mod += abs(scores[0]-scores[3])
+        mod += abs(scores[1]-scores[2])
+        mod += abs(scores[1]-scores[3])
+        mod /= 5
+        score = sum(scores)/len(scores)
+
+
+        score += mod 
+        if sigma and sigma > 0:
+            score -= sigma/100
+        colscore = abs(colcount-1024) / 1e5
+        score -= colscore
+
+        printscore = lambda arr: '['+(', '.join(['%1.3f' % e for e in arr]))+']'
+        print("colscore %3.3f (%4d colors) scores time %5.2fs" % (colscore,
+                                                                 colcount,
+                                                                 time.time() - start))
+        print("SIGMAS : %s SIGMA  : %f " %  (printscore(sigmas), sigma))
+        print("SCORES : %s SCORE : %r" % (printscore(scores), score))
+        return score
+

python_rpnifs/ifs4.py

@@ -0,0 +1,143 @@
+import random
+import time
+import copy
+
+import numpy as np
+from skimage.restoration import estimate_sigma
+
+from .expr import *
+from .fractdim import *
+
+
+class IFS4(object):
+    """ @brief 1 Variable IFS with R,G,B,A X,Y decomposition """
+
+    #height=width=1024
+    height=width=768
+    #height=width=512
+
+    def __init__(self, nexpr=4, init_sz=1, world=None):
+        self._nexpr = nexpr
+        self._expr_pos = [[RpnExpr(sz=init_sz, nvar=6)
+                           for _ in range(nexpr)]
+			  for _ in range(2)]
+        self._expr_col = [[RpnExpr(sz=init_sz, nvar=6)
+                           for _ in range(nexpr)]
+			  for _ in range(4)]
+        self._world = world
+        if self._world is None:
+            self._world = self.get_world()
+        self._position = [random.randint(0, self.height-1),
+                          random.randint(0, self.width-1)]
+        self._col = [random.randint(0, 255) for _ in range(4)]
+
+    @classmethod
+    def get_world(cls):
+        return np.zeros((cls.height,cls.width,4), dtype=np.uint8)
+
+    def raz_world(self):
+        for i in range(self.height):
+            for j in range(self.width):
+                self._world[i][j] = [0,0,0,0]
+    
+    def __str__(self):
+        ret = 'X<%s>' % (';'.join([str(e) for e in self._expr_pos[0]]))
+        ret += 'Y<%s>' % (';'.join([str(e) for e in self._expr_pos[1]]))
+        ret += 'R<%s>' % (';'.join([str(e) for e in self._expr_col[0]]))
+        ret += 'G<%s>' % (';'.join([str(e) for e in self._expr_col[1]]))
+        ret += 'B<%s>' % (';'.join([str(e) for e in self._expr_col[2]]))
+        ret += 'A<%s>' % (';'.join([str(e) for e in self._expr_col[3]]))
+        return ret
+
+    def __copy__(self):
+        ret = IFS4(nexpr=self._nexpr, world=self._world)
+        ret._expr_pos = [[copy.copy(e) for e in el]
+                         for el in self._expr_pos]
+        ret._expr_col = [[copy.copy(e) for e in el]
+                         for el in self._expr_col]
+        #ret._world = copy.deepcopy(self._world)
+        return ret
+
+    def get_image(self):
+    	return self._world
+ 
+    def mutation(self, n=1, rand=True):
+        n = 1 if n <= 1 else random.randint(1,n)
+        for _ in range(n):
+            random.choice(self._expr_pos + self._expr_col).mutation()
+
+    def step(self):
+        dr,dg,db,da = [int(e)
+                   for e in self._world[self._position[0]][self._position[1]]]
+        cx = int((self._position[0] / self.width) * ((1<<64)-1))
+        cy = int((self._position[0] / self.height) * ((1<<64)-1))
+        args = (cx,cy,dr,dg,db,da)
+        rx,ry = [int(random.choice(expr).eval(*args))
+                 for expr in self._expr_pos]
+        rx = (rx * self.width) // ((1<<64)-1)
+        ry = (ry * self.height) // ((1<<64)-1)
+        r,g,b,a = [int(random.choice(expr).eval(*args) % 256)
+                   for expr in self._expr_col]
+
+        sa = a/255
+        outa = (a + da*(1-sa))/255
+        if outa == 0:
+            ro,go,bo = 0,0,0
+        else:
+            ro, go, bo = [(c*(a/255)+dc*da*(1-sa))/outa
+                          for c, dc in ((r,dr), (g, dg), (b, db))]
+        r,g,b,a = [int(e) for e in (ro,go,bo,outa*255)]
+
+
+        self._world[self._position[0]][self._position[1]] = [r,g,b,a]
+
+    def score(self):
+        start = time.time()
+        
+        colcount = len(np.unique(np.reshape(self._world[:,:,:3], (-1,3)),
+                       axis=0))
+
+        #sigma = estimate_sigma(self._world, multichannel=True, average_sigmas=True)
+        sigmas = estimate_sigma(self._world[:,:,:3], multichannel=True,
+                                average_sigmas=False)
+
+        scores = [fractal_dimension(self._world[:,:,i]*self._world[:,:,3]/255)
+                  for i in range(3)]
+        #alpha score
+        #scores += [fractal_dimension(self._world[:,:,3])]
+
+        gray = rgb2gray(self._world)
+        graysigma = estimate_sigma(gray)
+        grayscore = fractal_dimension(gray)
+        del(gray)
+
+        sigmas += [graysigma]*3
+        sigmas = [0 if np.isnan(sigma) else sigma for sigma in sigmas]
+
+        scores += [grayscore]*3
+
+        sigma = sum(sigmas)/len(sigmas)
+
+        mod = abs(scores[0]-scores[1])
+        mod += abs(scores[0]-scores[2])
+        mod += abs(scores[0]-scores[3])
+        mod += abs(scores[1]-scores[2])
+        mod += abs(scores[1]-scores[3])
+        mod /= 5
+        score = sum(scores)/len(scores)
+
+
+        score += mod 
+        if sigma and sigma > 0:
+            score -= sigma/100
+        colscore = abs(colcount-1024) / 1e5
+        score -= colscore
+
+        printscore = lambda arr: '['+(', '.join(['%1.3f' % e for e in arr]))+']'
+        print("colscore %3.3f (%4d colors) scores time %5.2fs" % (colscore,
+                                                                 colcount,
+                                                                 time.time() - start))
+        print("SIGMAS : %s SIGMA  : %f " %  (printscore(sigmas), sigma))
+        print("SCORES : %s SCORE : %r" % (printscore(scores), score))
+        return score
+

python_rpnifs/ifs5.py

@@ -0,0 +1,147 @@
+import random
+import time
+import copy
+
+import numpy as np
+from skimage.restoration import estimate_sigma
+
+from .expr import *
+from .fractdim import *
+
+
+class IFS5(object):
+    """ @brief 1 Variable IFS with R,G,B,A X,Y decomposition """
+
+    #height=width=1024
+    height=width=768
+    #height=width=512
+
+    def __init__(self, nexpr=4, init_sz=1, world=None):
+        self._nexpr = nexpr
+        self._expr = [[RpnExpr(sz=init_sz, nvar=6) for _ in range(6)]
+                      for _ in range(nexpr)]
+        self._world = world
+        if self._world is None:
+            self._world = self.get_world()
+        self._position = [random.randint(0, self.height-1),
+                          random.randint(0, self.width-1)]
+        self._col = [random.randint(0, 255) for _ in range(4)]
+
+    @classmethod
+    def get_world(cls):
+        return np.zeros((cls.height,cls.width,4), dtype=np.uint8)
+
+    def raz_world(self):
+        for i in range(self.height):
+            for j in range(self.width):
+                self._world[i][j] = [0,0,0,0]
+    
+    def __str__(self):
+        el_lbl = 'XYrgba'
+        fel = lambda el: ';'.join(['%s=(%s)' % (el_lbl[i], str(el[i]))
+                                   for i in range(len(el))])
+        ret = ';'.join(['<%s>' % fel(el) for el in self._expr])
+        return ret
+
+    def __copy__(self):
+        ret = IFS5(nexpr=self._nexpr, world=self._world)
+        ret._expr = [[copy.copy(e) for e in el]
+                      for el in self._expr]
+        #ret._world = copy.deepcopy(self._world)
+        return ret
+
+    def get_image(self):
+    	return self._world
+ 
+    def mutation(self, n=1, rand=True):
+        n = 1 if n <= 1 else random.randint(1,n)
+        for _ in range(n):
+            random.choice(random.choice(self._expr)).mutation()
+
+    def step(self):
+        dr,dg,db,da = [int(e)
+                       for e in self._world[self._position[0]][self._position[1]]]
+
+        cx = int((self._position[0] / self.width) * ((1<<64)-1))
+        cy = int((self._position[0] / self.height) * ((1<<64)-1))
+
+        args = (cx,cy,dr,dg,db,da)
+        rx,ry,r,g,b,a = (int(expr.eval(*args))
+                         for expr in random.choice(self._expr))
+        rx = (rx * (self.width-1)) // ((1<<64)-1)
+        ry = (ry * (self.height-1)) // ((1<<64)-1)
+        self._position[0], self._position[1] = rx, ry
+        r,g,b,a = (c%256 for c in (r,g,b,a))
+
+        sa = a/255
+        outa = (a + da*(1-sa))/255
+        if outa == 0:
+            ro,go,bo = 0,0,0
+        else:
+            ro, go, bo = [(c*(a/255)+dc*da*(1-sa))/outa
+                          for c, dc in ((r,dr), (g, dg), (b, db))]
+        r,g,b,a = [int(e) for e in (ro,go,bo,outa*255)]
+
+
+        self._world[self._position[0]][self._position[1]] = [r,g,b,a]
+
+    def score(self):
+        start = time.time()
+        
+        colcount = len(np.unique(np.reshape(self._world[:,:,:3], (-1,3)),
+                       axis=0))
+
+        #sigma = estimate_sigma(self._world, multichannel=True, average_sigmas=True)
+        sigmas = estimate_sigma(self._world[:,:,:3], multichannel=True,
+                                average_sigmas=False)
+
+        scores = [fractal_dimension(self._world[:,:,i]*self._world[:,:,3]/255)
+                  for i in range(3)]
+        #alpha score
+        #scores += [fractal_dimension(self._world[:,:,3])]
+
+        gray = rgb2gray(self._world)
+        graysigma = estimate_sigma(gray)
+        grayscore = fractal_dimension(gray)
+        del(gray)
+
+        sigmas += [graysigma]*3
+        sigmas = [0 if np.isnan(sigma) else sigma for sigma in sigmas]
+
+        scores += [grayscore]*3
+
+        sigma = sum(sigmas)/len(sigmas)
+
+        mod = abs(scores[0]-scores[1])
+        mod += abs(scores[0]-scores[2])
+        mod += abs(scores[0]-scores[3])
+        mod += abs(scores[1]-scores[2])
+        mod += abs(scores[1]-scores[3])
+        mod /= 5
+
+        null_comp = 0
+        for i in range(3):
+            null_comp += 1 if scores[i] == 0 else 0
+
+        if null_comp >= 2:
+            score = 0
+            mod *= 0.8
+        else:
+            score = sum(scores)/len(scores)
+
+        score += mod 
+
+        if sigma and sigma > 0:
+            score -= sigma/100
+        #colscore = abs(colcount-1024) / 1e5
+        colscore = abs(colcount-2048) / 1e5
+        score -= colscore
+
+        printscore = lambda arr: '['+(', '.join(['%1.3f' % e for e in arr]))+']'
+        print("colscore %3.3f (%4d colors) scores time %5.2fs" % (colscore,
+                                                                 colcount,
+                                                                 time.time() - start))
+        print("SIGMAS : %s SIGMA  : %f " %  (printscore(sigmas), sigma))
+        print("SCORES : %s SCORE : %r" % (printscore(scores), score))
+        return score
+