Added imager module. Updating s0urce.js script.

dataLoad.py

@@ -12,9 +12,12 @@ import json
 import argparse
 import subprocess
 
+import imager
+
 parser = argparse.ArgumentParser(description="S0urce.io utility program.")
 parser.add_argument("--download", help="Download Images", action="store_true")
 parser.add_argument("--train", help="Convert Images to Text", action="store_true")
+parser.add_argument("--update", help="Update s0urce.js script", action="store_true")
 parser.add_argument(
     "JSON", type=str, nargs="?", help="Filename to save results", default="test.js"
 )
@@ -220,6 +223,9 @@ def image_filename(difficulty, index):
 def cleaned_filename(difficulty, index):
     return f"images/{difficulty}_{index}_clean.png"       
 
+def cleaner_filename(difficulty, index):
+    return f"images/{difficulty}_{index}_cleaner.png"       
+
 
 def image_cleaner(source, destination):
     image = Image.open(source)
@@ -235,7 +241,7 @@ def image_cleaner(source, destination):
             if b > high:
                 high = b
             diff = g - high
-            is_green = diff > GREEN_DIFF
+            is_green = diff > 0 # GREEN_DIFF
 
             if is_green:
                 image.putpixel( (x,y), (255,255,255,255) )
@@ -320,9 +326,9 @@ def autotrain(difficult):
 
         cleaned = cleaned_filename(difficult, x)
         if not os.path.exists(cleaned):
-            image_cleaner(fname, cleaned)
+            imager.image_cleaner(fname, cleaned)
 
-        print(f"Loading: {cleaned}")
+        print(f"Loading: {cleaned} ", end='')
         fileout = "data/{0}_{1}".format(difficult, x)
 
         output = subprocess.run(
@@ -367,6 +373,33 @@ if args.train:
     with open(args.JSON, 'w') as fp:
         json.dump(key_word, fp, sort_keys=True, indent=2)
 
+if args.update:
+    with open(args.JSON, 'r') as fp:
+        key_word = json.load(fp)
+
+    # update the s0urce.js script
+    filename = 's0urce.js'
+    with open(filename, 'r') as fp:
+        lines = fp.readlines()
+    # Lines are now in memory.  Time to update!    
+
+    for i in range(0, len(lines)):
+        if 'http://s0urce.io/client/img/word/' in lines[i]:
+            # This is a target line, so:
+            l = lines[i].strip().strip(':').strip('"')
+            parts = l.split('/')
+            dif = parts[-2]
+            index = parts[-1]
+            key = f'{dif}_{index}'
+            pprint(parts)
+            pprint(key)
+            word = key_word[key]
+            lines[i+1] = f'    form.value = "{word}";' + "\nbreak;\n"
+
+    with open(filename, 'w') as fp:
+        for line in lines:
+            fp.write(line)
+
 # ----------------------------------------------------------------------------------------
 # All below was in a seperate dataJS.py file... but now I have fixed it so it's 1 script!
 # Do we really need to worry about all this right now? (I think we have enough bugs to begin with.)

imager.py

@@ -0,0 +1,181 @@
+
+from PIL import Image
+import os
+import subprocess
+
+ON = "X"  # Dark pixel in an image
+OFF = "."  # Light pixel in an image
+
+INTENSITY = 75
+# How bright does something have to be to trigger it being a dark or light pixel?
+# Looks like around 75 removes the extra stuff that s0urce.io does to prevent it from being just matching images.
+
+GREEN_DIFF = 10
+# How much brighter the green channel must be (compared to the others),
+# to be called green.
+
+
+
+def img_point(pix, x, y):
+    """
+    img_point, returns a pixel of an image,
+    given the x and y on the image.
+    """
+    return pix[x, y]
+
+
+def img_avg(pix, x, y):
+    """
+    img_avg, returns the average brightness 0-255,
+    given pixel, and the x and y on the image calls img_point,
+    to get the individual rgb values to calculate,
+    brightness. (Grey scale)
+    """
+    rgb = img_point(pix, x, y)
+    # if(im.mode == 'P'):
+    #    rgb = pal[rgb*3:(rgb+1)*3]
+
+    # if(im.mode == 'I'):
+    #    return rgb >> 8
+
+    return int((rgb[0] + rgb[1] + rgb[2]) / 3)
+
+
+def is_set(pix, x, y):
+    global INTENSITY
+    """
+    is_set, returns True or False of calculating,
+    the brightness of the given point on a image,
+    compared to given intensity.
+    
+    True means the brightness at the given x and y,
+    is Less Than which means its dark.
+    
+    False means the brightness at the given x and y,
+    is Greater Than which means its bright. (Grey Scale)
+    """
+    avg = img_avg(pix, x, y)
+    return avg < INTENSITY
+
+
+def is_green(image, x, y):
+    """
+    Is this pixel Green?
+    """
+    (red, green, blue, _) = image.getpixel((x, y))
+    # Find the difference between green and the other values.
+    other = red
+    if blue > other:
+        other = blue
+    diff = green - other
+    return diff > GREEN_DIFF
+
+
+def scan_img(image):
+    """
+    Given an image, look at a image and find dark pixels,
+
+    also find the bounding box size.
+    (Where's the top,left,right,bottom-most pixels at?)
+
+    returns start x, y and end x, y and total number of dark pixels.
+    """
+    total = 0
+    size = image.size    
+    sx = size[0]
+    ex = 0
+    sy = size[1]
+    ey = 0
+
+    for y in range(0, size[1]):
+        for x in range(0, size[0]):
+            pnt_is = is_set(pix, x, y)
+            if pnt_is:
+                total += 1
+                if x < sx:
+                    sx = x
+                if x > ex:
+                    ex = x
+                if y < sy:
+                    sy = y
+                if y > ey:
+                    ey = y
+
+    # print (sx,ex,sy,ey)
+    # give us a little border to work with
+    if sx > 0:
+        sx -= 1
+    if ex < size[0]:
+        ex += 1
+
+    if sy > 0:
+        sy -= 1
+    if ey < size[1]:
+        ey += 1
+
+    return (sx, sy, ex, ey, total)
+
+
+def output_image(image):
+    """
+    For the size of the area we have reduced down to where the majority of dark pixels,
+    are located, store all that into a list and return the list.
+    
+    given pixel for function passing.
+    returns multiple strings in a list that are edited to use characters to represent,
+    the dark and light pixels of the image. (Grey Scale)
+    """
+    size = image.size
+    result = []
+
+    for y in range(0, size[1]):
+        s = ""
+        for x in range(0, size[0]):
+            # if is_set(pix, x, y):
+            if not is_green(image, x, y):
+                s += ON
+            else:
+                s += OFF
+        result.append(s)
+
+    return result
+
+
+def image_cleaner(source, destination, padfile=True):
+    """ Given a source image, clean it and save to destination
+
+    If padfile is set, we use imagemagik to add additional padding
+    around the image, which helps with the conversion process.
+    """
+    image = Image.open(source)
+    size = image.size
+
+    for y in range(0, size[1]):
+        for x in range(0, size[0]):
+            (r, g, b, _) = image.getpixel( (x,y) )
+            high = r
+            if b > high:
+                high = b
+            diff = g - high
+            is_green = diff > 0 # GREEN_DIFF
+
+            if is_green:
+                image.putpixel( (x,y), (255,255,255,255) )
+            else:
+                image.putpixel( (x,y), (0, 0, 0, 255) )
+
+    if padfile:
+        tmpfile = "temp.png"
+        image.save(tmpfile)
+        output = subprocess.run(
+            ["convert", tmpfile, "-bordercolor", "White",
+            "-border", "10x10", "-alpha", "off", destination],
+            stderr=subprocess.DEVNULL,
+            # capture_output=False,
+            shell=False,
+        )
+        os.unlink(tmpfile)
+
+    else:            
+        image.save(destination)
+