Commenting++

python_rpnifs/__main__.py

@@ -9,6 +9,7 @@ except (ImportError, NameError) as e:
     raise e
 
 from PIL import Image
+from PIL.PngImagePlugin import PngImageFile, PngInfo
 import numpy as np
 from tqdm import tqdm
 
@@ -64,15 +65,38 @@ while True:
         im = Image.fromarray(ifs.get_image())
         im.save(outfile % i)
 
+        im_png = PngImageFile(outfile % i)
+        metadata = PngInfo()
+        metadata.add_text('Score', '%5.3f' % score)
+        metadata.add_text('Generation', '%04d' % generation)
+        metadata.add_text('Pool_position', '%02d' % i)
+        for key, text in ifs.expr_dict().items():
+            metadata.add_text(key, text)
+        im_png.save(outfile % i, pnginfo=metadata)
+
+    # Selecting best
     scores = sorted(scores, key=lambda v: 0 if v[1] == np.nan else v[1],
                     reverse=True)
     best = scores[:best_sz]
     for i, (ifs, score) in enumerate(best):
         print('%02d) %5.3f %s' % (i, score, ifs))
+
+    # Mutating best
     pool = [b for b, _ in best]
     for ifs, _ in best:
         for _ in range((pool_sz//best_sz)-1):
-            new = copy.copy(ifs)
-            new.mutation(n_mutation)
-            pool.append(new)
+            # needs >= IFS5
+            while True:
+                new = copy.copy(ifs)
+                new.mutation(n_mutation)
+                for cur in pool:
+                    if cur - new == 0:
+                        break
+                else:
+                    pool.append(new)
+                    break 
+            ###
+            #new = copy.copy(ifs)
+            #new.mutation(n_mutation)
+            #pool.append(new)
 

python_rpnifs/expr.py

@@ -8,10 +8,30 @@ import numpy
 
 import pyrpn
 
+class RpnSym(object):
+    """ @brief Abstract class representing RpnExpr symbols """
+    
+    def __init__(self):
+        raise NotImplementedError('Abstract class')
+
+    def __sub__(self, b):
+        """ @return the difference between two symbols : 2 if types differs,
+            1 if same type but different value
+        """
+        if type(b) != type(self):
+            return 2
+        elif str(b) !=  str(self):
+            return 1
+        return 0
 
-class RpnOp(object):
+class RpnOp(RpnSym):
+    """ @brief an RPN operation symbol """
     
     def __init__(self, op=None):
+        """ @brief instanciate an RPN symbol
+            @param op if None a random op is choosen else a value from
+                pyrpn.get_ops().values() is expected
+        """
         if op is None:
             op = self.random()
         elif op not in pyrpn.get_ops().values():
@@ -24,25 +44,25 @@ class RpnOp(object):
     def __copy__(self):
         return type(self)(self.__op)
 
-    def __sub__(self, b):
-        if type(b) != type(self):
-            return 2
-        elif str(b) != str(self):
-            return 1
-        return 0
-
     def to_bytes(self):
+        """ @return a 9 bytes representation of the symbol """
         brepr = self.__op.encode('utf8')
         return bytes([1] + ([0]*(8-len(brepr)))) + brepr
 
     @staticmethod
     def random():
+        """ @return a random RpnOp instance """
         return random.choice(list(pyrpn.get_ops().values()))
 
 
-class RpnConst(object):
+class RpnConst(RpnSym):
+    """ @brief an RPN numeric constant symbol """
     
     def __init__(self, value=None):
+        """ @brief instanciate an RPN numeric constant symbol
+            @param value a 64bit unsigned integer (a random one is choosen
+                if None given)
+        """
         if value is None:
             value = random.randint(0, (1<<64)-1)
         elif value < 0 or value > (1<<64)-1:
@@ -55,20 +75,23 @@ class RpnConst(object):
     def __str__(self):
         return '0x%X' % self.__val
 
-    def __sub__(self, b):
-        if type(b) != type(self):
-            return 2
-        elif str(b) != str(self):
-            return 1
-        return 0
-
     def to_bytes(self):
+        """ @return a 9 bytes representation of the symbol """
         return bytes([0]) + self.__val.to_bytes(8, 'little')
 
 
-class RpnVar(object):
+class RpnVar(RpnSym):
+    """ @brief an RPN variable symbol
+        
+        Variables are indexed with integer, string representation are : A0, A1
+        etc.
+    """
 
     def __init__(self, varnum=None, nvar=1):
+        """ @brief instanciate an RPN variable symbol
+            @param varnum the variable number (random one choose if None given)
+            @param nvar the maximum variable number
+        """
         if varnum is None:
             if nvar == 1:
                 varnum = 0
@@ -81,6 +104,7 @@ class RpnVar(object):
     
     @property
     def nvar(self):
+        """ @return the maximum variable number """
         return self.__nvar
 
     def __copy__(self):
@@ -89,21 +113,26 @@ class RpnVar(object):
     def __str__(self):
         return 'A%d' % self.__val
 
-    def __sub__(self, b):
-        if type(b) != type(self):
-            return 2
-        elif str(b) != str(self):
-            return 1
-        return 0
-
     def to_bytes(self):
+        """ @return a 9 bytes representation of the symbol """
         brepr = str(self).encode('utf8')
         return bytes([1] + ([0]*(8-len(brepr)))) + brepr
 
 
 class RpnExpr(object):
+    """ @brief Wrapper on pyrpnifs.RPNExpr
+        
+        Allow using pyrpnifs.RPNExpr while keeping a high level representation
+        of the expression (using @ref RpnSym child classes).
+    """
 
     def __init__(self, sz=0, w_op=4, w_const=1, w_var=2, nvar=1):
+        """ @param sz The expression size for random generation
+            @param w_op RpnOp weight on random generation
+            @param w_const RpnConst weight on random generation
+            @param w_var RpnVar weight on random generation
+            @param n_var the variable count
+        """
         self.sz = 0
         self._weight = (w_op, w_const, w_var)
         choices = (RpnOp, RpnConst, lambda: RpnVar(nvar=nvar))
@@ -114,6 +143,9 @@ class RpnExpr(object):
             self.refresh_expr()
 
     def refresh_expr(self):
+        """ @brief Refresh the internal pyrpn.RPNExpr using the
+                @ref RpnSym representation
+        """
         self.pyrpn = pyrpn.RPNExpr(str(self), self.__nvar)
 
     def __str__(self):
@@ -130,16 +162,33 @@ class RpnExpr(object):
         return ret
 
     def to_bytes(self):
+        """ @return a bytes representation with 9 bytes for each symbols """
         return b''.join([elt.to_bytes() for elt in self.expr])
 
     def __sub__(self, b):
         return self.levenshtein(b)
 
     def eval(self, *args):
+        """ @brief Evaluate the expression with given arguments
+            @param args* an array of argument (with len  = nvar)
+        """
         return self.pyrpn.eval(*args)
 
     def mutation(self, n=1, min_len=3, w_add=1.25, w_del=1, w_mut=2,
                  w_mut_soft=4, w_add_elt=(1,1,1), w_mut_elt=(1,1,1)):
+        """ @brief Expression mutation
+            @param n mutation count
+            @param min_len the minimum length for an expression
+            @param w_add weight of adding a symbol
+            @param w_del weight of deleting a symbol
+            @param w_mut weight of mutating a symbol
+            @param w_mut_soft weight of mutationg a symbol without type change
+            @param w_add_elt weights for each types (op, const, var) when
+                adding a symbol
+            @param w_mut_elt weight for each types (op, const, var) when
+                mutating a symbol
+            @note The internal pyrpn.RPNExpr is refreshed after mutations
+        """
         for _ in range(n):
             if len(self.expr) <= min_len:
                 self.add(*w_add_elt)
@@ -156,6 +205,7 @@ class RpnExpr(object):
         pass
 
     def add(self, w_op=1, w_const=1, w_var=1):
+        """ @brief Mutate by adding a symbol """
         idx = random.randint(0,len(self.expr))
         new = random.choices((RpnOp, RpnConst, RpnVar), self._weight)[0]
         new = new(nvar=self.__nvar) if new == RpnVar else new()
@@ -163,11 +213,13 @@ class RpnExpr(object):
         pass
     
     def delete(self, *args):
+        """ @brief Mutate by deleting a symbol """
         idx = random.randint(0, len(self.expr)-1)
         self.expr.pop(idx)
         pass
 
     def mutate(self, w_op=1, w_const=1, w_var=1):
+        """ @brief Mutate changing a symbol into another """
         idx =  random.randint(0, len(self.expr)-1)
         new = random.choices((RpnOp, RpnConst, RpnVar), self._weight)[0]
         new = new(nvar=self.__nvar) if new == RpnVar else new()
@@ -175,6 +227,7 @@ class RpnExpr(object):
         pass
     
     def mutate_soft(self):
+        """ @brief Mutate changing a symbol into another of the same type """
         idx =  random.randint(0, len(self.expr)-1)
         cur = self.expr[idx]
         cls = type(cur)
@@ -185,8 +238,16 @@ class RpnExpr(object):
         self.expr[idx] =  new
         pass
 
-    def levenshtein(self, b, custom_weight=True):
-        a = self
+    def levenshtein(a, b, custom_weight=True):
+        """ @brief Calculate a levenshtein distance between two expression
+            @param a expression A
+            @param b expression B
+            @param custom_weight If True a different symbol of same type weight
+                1 and a different symbol of different type weight 2. Else no
+                special weight is applied.
+            @return an integer
+        """
+
         len_a = len(a.expr)
         len_b = len(b.expr)
 
@@ -209,6 +270,11 @@ class RpnExpr(object):
 
     @classmethod
     def from_string(cls, expr, nvar=1):
+        """ @brief Return an RpnExpr instance given a string representing
+            an expression
+            @param epxr the string representation
+            @param nvar the variable count
+        """
         res = RpnExpr(sz=0)
 
         for spl in expr.split(' '):

python_rpnifs/fractdim.py

@@ -4,17 +4,19 @@ import scipy
 import scipy.misc
 
 def rgb2gray(rgb):
+    """ @return a grayscale version of an RGB "image" """
     r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
     gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
     return gray
 
 def rgba2gray(rgba):
+    """ @return a grayscale version of an RGBA "image" """
     r, g, b, a = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2], rgb[:,:,3]
     gray = (0.2989 * r + 0.5870 * g + 0.1140 * b) * (a/255)
     return gray
 
 def fractal_dimension(Z, threshold=None):
-    ''' @return Minkowski–Bouligand dimension (computed) '''
+    ''' @return Minkowski-Bouligand dimension (computed) '''
     # Only for 2d image
     assert(len(Z.shape) == 2)
 

python_rpnifs/ifs5.py

@@ -36,11 +36,25 @@ class IFS5(object):
             for j in range(self.width):
                 self._world[i][j] = [0,0,0,0]
     
-    def __str__(self):
+    def expr_dict(self):
+        el_lbl = 'XYrgba'
+        res = dict()
+        k_fmt = 'IFS:%02d:%c'
+        for i, expr in enumerate(self._expr):
+            for j, el in enumerate(expr):
+                res[k_fmt % (i, el_lbl[j])] = str(el)
+        return res
+                
+        
+
+    def _fel(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 [fel(el) for el in self._expr]
+
+    def __str__(self):
+        ret = ';'.join(['<%s>' % el for el in self._fel()])
         return ret
 
     def __copy__(self):
@@ -50,15 +64,32 @@ class IFS5(object):
         #ret._world = copy.deepcopy(self._world)
         return ret
 
+    def __sub__(self, b):
+        """ @return The sum of the levensthein distance between all expressions
+                of two ifs
+        """
+        return sum([sum([self._expr[i][j] - b._expr[i][j]
+                         for j in range(len(b._expr[i]))])
+                    for i in range(len(b._expr))])
+
     def get_image(self):
     	return self._world
  
     def mutation(self, n=1, rand=True):
+        """ @brief Apply mutation on expressions
+            @param n the mutation count
+            @param rand unused ?!
+        """
         n = 1 if n <= 1 else random.randint(1,n)
         for _ in range(n):
             random.choice(random.choice(self._expr)).mutation()
 
     def step(self):
+        """ @brief Calculate a step of IFS
+            
+            Choose randomly an expression and evaluate it, giving values for
+            each argument and storing values in "world"
+        """
         dr,dg,db,da = [int(e)
                        for e in self._world[self._position[0]][self._position[1]]]
 
@@ -86,6 +117,9 @@ class IFS5(object):
         self._world[self._position[0]][self._position[1]] = [r,g,b,a]
 
     def score(self):
+        """ @brief Calculate the world's score
+            @return a float, higher the better
+        """
         start = time.time()
         
         colcount = len(np.unique(np.reshape(self._world[:,:,:3], (-1,3)),
@@ -135,6 +169,8 @@ class IFS5(object):
             score -= sigma/100
         #colscore = abs(colcount-1024) / 1e5
         colscore = abs(colcount-2048) / 1e5
+        if colcount < 2048:
+            colscore *= 10
         score -= colscore
 
         printscore = lambda arr: '['+(', '.join(['%1.3f' % e for e in arr]))+']'