Enhance color handling + add gray option

gte/__main__.py

                            default=False, const=True)
 
 
-
 parser_gen = subparsers.add_parser('generate', help='evolving help')
 
 parser_gen.add_argument('--prog', '-P', type=str, default=None)
                         default=3)
 parser_gen.add_argument('--steps', '-s', type=int, metavar='N',
                         default=30000)
+parser_gen.add_argument('--gray', '-G', action='store_const',
+                        default=False, const=True)
 
 
 args = parser.parse_args()
 if 'pool_size' in args:
     # Evolver
     if args.prog is None:
-        progs = [rpnlib.RpnExpr.random(args.prog_size)
-                for _ in range(args.pool_size)]
+        prog = rpnlib.RpnExpr.random(args.prog_size)
+        progs = [mutate(prog, force=True) for _ in range(args.pool_size-1)]
+        #progs = [rpnlib.RpnExpr.random(args.prog_size)
+        #        for _ in range(args.pool_size)]
     else:
         prog = rpnlib.RpnExpr.from_string(args.prog)
         progs = [mutate(prog, force=True) for _ in range(args.pool_size-1)]
     exit(0)
 else:
     # Generate
-    w = World(args.world_height, args.world_width)
+    w = World(args.world_height, args.world_width, gray=args.gray)
     prog = rpnlib.RpnExpr.from_string(args.prog)
     turmits = [LivingTurmit(world=w, prog=prog)
                for _ in range(args.turmit_count)]

gte/world.py

         @param args : dirty argparser returned arguments
     '''
     generation, progid, prog, trynum, args = args
-    w = World(args.world_height, args.world_width)
+    w = World(args.world_height, args.world_width, gray=True)
     logger.debug('Running P%d run#%d %s' % (progid, trynum, prog))
     w.raz()
     turmits = [LivingTurmit(world=w, prog=prog)
 class World(object):
     ''' @brief A Turmit world. An array of dim == 2 with tuple(R,G,B) '''
     
-    def __init__(self, x, y):
+    def __init__(self, x, y, gray=False):
         if x < 1:
             raise ValueError('Invalid value %d for x size')
         if y < 1:
         self._x = x
         self._y = y
         self._val = None
+        self._gray = gray
         self.raz()
 
     @property
 
     def raz(self, color=None):
         ''' @brief Set all value to color
-            @param color tuple : tuple(R,G,B)
+            @param color tuple | float : tuple(R,G,B) or greylevel
         '''
         if color is None:
-            self._val = np.zeros([self._y, self._x, 3])
+            if self._gray:
+                self._val = np.zeros([self._y, self._x])
+            else:
+                self._val = np.zeros([self._y, self._x, 3])
         else:
             self._val = [[color for _ in range(self._x)] for _ in range(self._y)]
             self._val = np.array(self._val)
     
     def fractdim(self, threshold=None):
         ''' @return Minkowski–Bouligand dimension (computed) '''
-        Z = self.rgb2gray(self._val)
+        if not self._gray:
+            Z = self.rgb2gray(self._val)
+        else:
+            Z = self._val
 
         # Only for 2d image
         assert(len(Z.shape) == 2)
         gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
         return gray
 
+    @staticmethod
+    def single_rgb2gray(rgb):
+        r,g,b = rgb
+        gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
+        return gray
+
     def __getitem__(self, a):
         return self._val[a]
 
             raise TypeError(msg % color)
         ## @brief Stores Turmit color
         rand_hue = randint(0,255) / 255
+        rand_lvl = randint(127,255) / 255
+        rand_val = randint(127,255) / 255
         self._col = tuple(round(i * 255)
-                          for i in colorsys.hsv_to_rgb(rand_hue,1,1))
+                          for i in colorsys.hsv_to_rgb(rand_hue,
+                                                       rand_lvl,
+                                                       rand_val))
+        if world._gray:
+            #self._col = 255.0
+            self._col = tuple(round(i * 255)
+                              for i in colorsys.hsv_to_rgb(rand_hue,1,1))
+            self._col = World.single_rgb2gray(self._col)
         #self._col = (randint(0,255), randint(0, 255), randint(0,255))
         if color is not None:
             self._col = color
 
     def __call__(self):
         ''' @brief Exec a turmit and move it '''
-        r,g,b = self._world[self._y][self._x]
+        if self._world._gray:
+            r = g = b = self._world[self._y][self._x]
+        else:
+            r,g,b = self._world[self._y][self._x]
         tdir = super().__call__(x=self._x, y=self._y, r=r, g=g, b=b)
         self.move(tdir)