Ifs5 implementation enhancement

python_rpnifs/__main__.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 import copy
+import random
+import multiprocessing
 
 try:
     import pyrpn
@@ -19,16 +21,24 @@ from .ifs3 import IFS3
 from .ifs4 import IFS4
 from .ifs5 import IFS5
 
+from .shape_score import ShapeScore
+
 
 #steps = 1024**2
-#steps=512**2
-steps=1024**2
+steps=512**2
+#steps=1024**2
 #steps*=4
 #steps*=10
-pool_sz = 30
-best_sz = 6
+
+#pool_sz = 30
+#best_sz = 6
+
+pool_sz = 32
+best_sz = 8
+
 n_mutation = 10
 outfile='/tmp/rpnifs2_%02d.png'
+outfile_grp='/tmp/rpnifs2_%02d_grp.png'
 #world = IFS1.get_world()
 #pool = [IFS1(init_sz=3, world=world) for _ in range(pool_sz)]
 #world = IFS2.get_world()
@@ -42,7 +52,18 @@ world = IFS5.get_world()
 pool = [IFS5(init_sz=6, world=world) for _ in range(pool_sz)]
 print('POOL ready')
 
+def stepper(ifs):
+    for _ in range(steps):
+        ifs.step()
+    return ifs
+
+def get_score(world):
+    shapescore = ShapeScore(world, jobs=1)
+    score = shapescore.score()
+    return score, shapescore
+
 generation=0
+mp_pool = multiprocessing.Pool(2)
 while True:
     generation+=1
     print('='*78)
@@ -52,18 +73,27 @@ while True:
     scores = []
     i=0
     #for ifs in pool:
-    for ifs in tqdm(pool, unit='ifs'):
-        i+=1
-        ifs.raz_world()
-        #for _ in tqdm(range(steps), total=steps, unit_scale=True):
-        for _ in range(steps):
-            ifs.step()
-
-        score = ifs.score()
+    #for ifs in tqdm(pool, unit='ifs'):
+    #    ifs.raz_world()
+    #    #for _ in tqdm(range(steps), total=steps, unit_scale=True):
+    #    for _ in range(steps):
+    #        ifs.step()
+    pool = [ifs for ifs in tqdm(mp_pool.imap(stepper, pool),
+                                total=len(pool),
+                                unit='ifs')]
+    
+    for i, (score,shapescore) in tqdm(enumerate(mp_pool.imap(get_score,
+                                                             [ifs._world for ifs in pool])),
+                                      unit='ifs', total=len(pool)):
+        ifs = pool[i]
+
+        #score = ifs.score()
         scores.append((ifs, score))
-        print('%02d) %5.3f %s' % (i, score, ifs))
+        #print('%02d) %5.3f %s' % (i, score, ifs))
+        print('%02d) %5.3f' % (i, score))
         im = Image.fromarray(ifs.get_image())
         im.save(outfile % i)
+        shapescore.result_image(outfile_grp % i)
 
         im_png = PngImageFile(outfile % i)
         metadata = PngInfo()
@@ -81,20 +111,42 @@ while True:
     for i, (ifs, score) in enumerate(best):
         print('%02d) %5.3f %s' % (i, score, ifs))
 
+    # Saving best
+    im = Image.fromarray(best[0][0].get_image())
+    outfile_gen = '/tmp/gen_%03d.png'
+    im.save(outfile_gen % generation)
+
+    im_png = PngImageFile(outfile_gen % generation)
+    metadata = PngInfo()
+    metadata.add_text('Score', '%5.3f' % score)
+    metadata.add_text('Generation', '%04d' % generation)
+    metadata.add_text('Pool_position', '%02d' % 1)
+    for key, text in ifs.expr_dict().items():
+        metadata.add_text(key, text)
+    im_png.save(outfile_gen % generation, pnginfo=metadata)
+
     # Mutating best
     pool = [b for b, _ in best]
     for ifs, _ in best:
-        for _ in range((pool_sz//best_sz)-1):
+        nmut_max = (pool_sz//best_sz)-1
+        for nmut in range(nmut_max):
             # needs >= IFS5
+            again = 0
             while True:
-                new = copy.copy(ifs)
-                new.mutation(n_mutation)
+                # half random mutation and half mutation by adding two IFS
+                if again > 5 or nmut < nmut_max / 2:
+                    new = copy.copy(ifs)
+                    new.mutation(n_mutation)
+                else:
+                    new =  ifs + random.choice(best)[0]
+
                 for cur in pool:
                     if cur - new == 0:
                         break
                 else:
                     pool.append(new)
                     break 
+                again += 1
             ###
             #new = copy.copy(ifs)
             #new.mutation(n_mutation)

python_rpnifs/fractdim.py

@@ -11,10 +11,22 @@ def rgb2gray(rgb):
 
 def rgba2gray(rgba):
     """ @return a grayscale version of an RGBA "image" """
-    r, g, b, a = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2], rgb[:,:,3]
+    r, g, b, a = rgba[:,:,0], rgba[:,:,1], rgba[:,:,2], rgba[:,:,3]
     gray = (0.2989 * r + 0.5870 * g + 0.1140 * b) * (a/255)
     return gray
 
+def rgb2grayavg(rgb):
+    """ @return a grayscale version of an RGB "image" """
+    r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
+    gray = (r+g+b)/3
+    return gray
+
+def rgba2grayavg(rgba):
+    """ @return a grayscale version of an RGBA "image" """
+    r, g, b, a = rgba[:,:,0], rgba[:,:,1], rgba[:,:,2], rgba[:,:,3]
+    gray = ((r + g + b)/3) * (a/255)
+    return gray
+
 def fractal_dimension(Z, threshold=None):
     ''' @return Minkowski-Bouligand dimension (computed) '''
     # Only for 2d image

python_rpnifs/ifs5.py

@@ -7,14 +7,15 @@ from skimage.restoration import estimate_sigma
 
 from .expr import *
 from .fractdim import *
+from .shape_score import ShapeScore
 
 
 class IFS5(object):
     """ @brief 1 Variable IFS with R,G,B,A X,Y decomposition """
 
     #height=width=1024
-    height=width=768
-    #height=width=512
+    #height=width=768
+    height=width=512
 
     def __init__(self, nexpr=4, init_sz=1, world=None):
         self._nexpr = nexpr
@@ -44,8 +45,6 @@ class IFS5(object):
             for j, el in enumerate(expr):
                 res[k_fmt % (i, el_lbl[j])] = str(el)
         return res
-                
-        
 
     def _fel(self):
         el_lbl = 'XYrgba'
@@ -64,6 +63,9 @@ class IFS5(object):
         #ret._world = copy.deepcopy(self._world)
         return ret
 
+    def get_image(self):
+    	return self._world
+ 
     def __sub__(self, b):
         """ @return The sum of the levensthein distance between all expressions
                 of two ifs
@@ -72,9 +74,23 @@ class IFS5(object):
                          for j in range(len(b._expr[i]))])
                     for i in range(len(b._expr))])
 
-    def get_image(self):
-    	return self._world
- 
+    def __add__(self, b):
+        """ @return A new IFS generated from both IFS, randomly choosing
+            expression from both
+        """
+        if type(b) !=  type(self):
+            raise TypeError('Types are not IFS5 for add')
+
+        ret = IFS5(nexpr=self._nexpr, world=self._world)
+
+        rc = random.choice
+        rint = random.randint
+
+        ret._expr = [[copy.copy(rc([self, b])._expr[rc([i, len(self._expr)-1])][rc([j, len(ex)-1])])
+                      for j, e in enumerate(ex)]
+                     for i, ex in enumerate(self._expr)]
+        return ret
+
     def mutation(self, n=1, rand=True):
         """ @brief Apply mutation on expressions
             @param n the mutation count
@@ -134,7 +150,7 @@ class IFS5(object):
         #alpha score
         #scores += [fractal_dimension(self._world[:,:,3])]
 
-        gray = rgb2gray(self._world)
+        gray = rgba2gray(self._world)
         graysigma = estimate_sigma(gray)
         grayscore = fractal_dimension(gray)
         del(gray)
@@ -144,7 +160,14 @@ class IFS5(object):
 
         scores += [grayscore]*3
 
-        sigma = sum(sigmas)/len(sigmas)
+        sigma_zero = 0
+        for sig in sigmas:
+            if sig == 0:
+                sigma_zero += 1
+        if len(sigmas) > sigma_zero:
+            sigma = sum(sigmas)/(len(sigmas)-sigma_zero)
+        else:
+            sigma = 0
 
         mod = abs(scores[0]-scores[1])
         mod += abs(scores[0]-scores[2])
@@ -155,13 +178,20 @@ class IFS5(object):
 
         null_comp = 0
         for i in range(3):
-            null_comp += 1 if scores[i] == 0 else 0
+            null_comp += 1 if scores[i] <= 0 else 0
 
         if null_comp >= 2:
             score = 0
             mod *= 0.8
         else:
-            score = sum(scores)/len(scores)
+            zero_score=0
+            for score in scores:
+                if score == 0:
+                    zero_score += 1
+            if len(scores) < zero_score:
+                score = sum(scores)/(len(scores)-zero_score)
+            else:
+                score = 0
 
         score += mod