Remove useless classes and classmethod

Author: Belval

TextRecognitionDataGenerator/background_generator.py

@@ -6,87 +6,82 @@
 
 from PIL import Image, ImageDraw, ImageFilter
 
-class BackgroundGenerator(object):
-    @classmethod
-    def gaussian_noise(cls, height, width):
-        """
-            Create a background with Gaussian noise (to mimic paper)
-        """
-
-        # We create an all white image
-        image = np.ones((height, width)) * 255
-
-        # We add gaussian noise
-        cv2.randn(image, 235, 10)
-
-        return Image.fromarray(image).convert('RGBA')
-
-    @classmethod
-    def plain_white(cls, height, width):
-        """
-            Create a plain white background
-        """
-
-        return Image.new("L", (width, height), 255).convert('RGBA')
-
-    @classmethod
-    def quasicrystal(cls, height, width):
-        """
-            Create a background with quasicrystal (https://en.wikipedia.org/wiki/Quasicrystal)
-        """
-
-        image = Image.new("L", (width, height))
-        pixels = image.load()
-
-        frequency = random.random() * 30 + 20 # frequency
-        phase = random.random() * 2 * math.pi # phase
-        rotation_count = random.randint(10, 20) # of rotations
-
-        for kw in range(width):
-            y = float(kw) / (width - 1) * 4 * math.pi - 2 * math.pi
-            for kh in range(height):
-                x = float(kh) / (height - 1) * 4 * math.pi - 2 * math.pi
-                z = 0.0
-                for i in range(rotation_count):
-                    r = math.hypot(x, y)
-                    a = math.atan2(y, x) + i * math.pi * 2.0 / rotation_count
-                    z += math.cos(r * math.sin(a) * frequency + phase)
-                c = int(255 - round(255 * z / rotation_count))
-                pixels[kw, kh] = c # grayscale
-        return image.convert('RGBA')
-
-    @classmethod
-    def picture(cls, height, width):
-        """
-            Create a background with a picture
-        """
-
-        pictures = os.listdir('./pictures')
-
-        if len(pictures) > 0:
-            picture = Image.open('./pictures/' + pictures[random.randint(0, len(pictures) - 1)])
-
-            if picture.size[0] < width:
-                picture = picture.resize([width, int(picture.size[1] * (width / picture.size[0]))], Image.ANTIALIAS)
-            elif picture.size[1] < height:
-                picture.thumbnail([int(picture.size[0] * (height / picture.size[1])), height], Image.ANTIALIAS)
-
-            if (picture.size[0] == width):
-                x = 0
-            else:
-                x = random.randint(0, picture.size[0] - width)
-            if (picture.size[1] == height):
-                y = 0
-            else:
-                y = random.randint(0, picture.size[1] - height)
-                
-            return picture.crop(
-                (
-                    x,
-                    y,
-                    x + width,
-                    y + height,
-                )
-            )
+def gaussian_noise(height, width):
+    """
+        Create a background with Gaussian noise (to mimic paper)
+    """
+
+    # We create an all white image
+    image = np.ones((height, width)) * 255
+
+    # We add gaussian noise
+    cv2.randn(image, 235, 10)
+
+    return Image.fromarray(image).convert('RGBA')
+
+def plain_white(height, width):
+    """
+        Create a plain white background
+    """
+
+    return Image.new("L", (width, height), 255).convert('RGBA')
+
+def quasicrystal(height, width):
+    """
+        Create a background with quasicrystal (https://en.wikipedia.org/wiki/Quasicrystal)
+    """
+
+    image = Image.new("L", (width, height))
+    pixels = image.load()
+
+    frequency = random.random() * 30 + 20 # frequency
+    phase = random.random() * 2 * math.pi # phase
+    rotation_count = random.randint(10, 20) # of rotations
+
+    for kw in range(width):
+        y = float(kw) / (width - 1) * 4 * math.pi - 2 * math.pi
+        for kh in range(height):
+            x = float(kh) / (height - 1) * 4 * math.pi - 2 * math.pi
+            z = 0.0
+            for i in range(rotation_count):
+                r = math.hypot(x, y)
+                a = math.atan2(y, x) + i * math.pi * 2.0 / rotation_count
+                z += math.cos(r * math.sin(a) * frequency + phase)
+            c = int(255 - round(255 * z / rotation_count))
+            pixels[kw, kh] = c # grayscale
+    return image.convert('RGBA')
+
+def picture(height, width):
+    """
+        Create a background with a picture
+    """
+
+    pictures = os.listdir('./pictures')
+
+    if len(pictures) > 0:
+        picture = Image.open('./pictures/' + pictures[random.randint(0, len(pictures) - 1)])
+
+        if picture.size[0] < width:
+            picture = picture.resize([width, int(picture.size[1] * (width / picture.size[0]))], Image.ANTIALIAS)
+        elif picture.size[1] < height:
+            picture.thumbnail([int(picture.size[0] * (height / picture.size[1])), height], Image.ANTIALIAS)
+
+        if (picture.size[0] == width):
+            x = 0
+        else:
+            x = random.randint(0, picture.size[0] - width)
+        if (picture.size[1] == height):
+            y = 0
         else:
-            raise Exception('No images where found in the pictures folder!')
+            y = random.randint(0, picture.size[1] - height)
+            
+        return picture.crop(
+            (
+                x,
+                y,
+                x + width,
+                y + height,
+            )
+        )
+    else:
+        raise Exception('No images where found in the pictures folder!')

TextRecognitionDataGenerator/computer_text_generator.py

@@ -2,74 +2,70 @@
 
 from PIL import Image, ImageColor, ImageFont, ImageDraw, ImageFilter
 
-class ComputerTextGenerator(object):
-    @classmethod
-    def generate(cls, text, font, text_color, font_size, orientation, space_width, fit):
-        if orientation == 0:
-            return cls.__generate_horizontal_text(text, font, text_color, font_size, space_width, fit)
-        elif orientation == 1:
-            return cls.__generate_vertical_text(text, font, text_color, font_size, space_width, fit)
-        else:
-            raise ValueError("Unknown orientation " + str(orientation))
+def generate(text, font, text_color, font_size, orientation, space_width, fit):
+    if orientation == 0:
+        return _generate_horizontal_text(text, font, text_color, font_size, space_width, fit)
+    elif orientation == 1:
+        return _generate_vertical_text(text, font, text_color, font_size, space_width, fit)
+    else:
+        raise ValueError("Unknown orientation " + str(orientation))
+
+def _generate_horizontal_text(text, font, text_color, font_size, space_width, fit):
+    image_font = ImageFont.truetype(font=font, size=font_size)
+    words = text.split(' ')
+    space_width = image_font.getsize(' ')[0] * space_width
+
+    words_width = [image_font.getsize(w)[0] for w in words]
+    text_width =  sum(words_width) + int(space_width) * (len(words) - 1)
+    text_height = max([image_font.getsize(w)[1] for w in words])
+
+    txt_img = Image.new('RGBA', (text_width, text_height), (0, 0, 0, 0))
+
+    txt_draw = ImageDraw.Draw(txt_img)
+
+    colors = [ImageColor.getrgb(c) for c in text_color.split(',')]
+    c1, c2 = colors[0], colors[-1]
+
+    fill = (
+        random.randint(min(c1[0], c2[0]), max(c1[0], c2[0])),
+        random.randint(min(c1[1], c2[1]), max(c1[1], c2[1])),
+        random.randint(min(c1[2], c2[2]), max(c1[2], c2[2]))
+    )
+
+    for i, w in enumerate(words):
+        txt_draw.text((sum(words_width[0:i]) + i * int(space_width), 0), w, fill=fill, font=image_font)
+
+    if fit:
+        return txt_img.crop(txt_img.getbbox())
+    else:
+        return txt_img
+
+def _generate_vertical_text(text, font, text_color, font_size, space_width, fit):
+    image_font = ImageFont.truetype(font=font, size=font_size)
 
-    @classmethod
-    def __generate_horizontal_text(cls, text, font, text_color, font_size, space_width, fit):
-        image_font = ImageFont.truetype(font=font, size=font_size)
-        words = text.split(' ')
-        space_width = image_font.getsize(' ')[0] * space_width
+    space_height = int(image_font.getsize(' ')[1] * space_width)
 
-        words_width = [image_font.getsize(w)[0] for w in words]
-        text_width =  sum(words_width) + int(space_width) * (len(words) - 1)
-        text_height = max([image_font.getsize(w)[1] for w in words])
+    char_heights = [image_font.getsize(c)[1] if c != ' ' else space_height for c in text]
+    text_width = max([image_font.getsize(c)[0] for c in text])
+    text_height = sum(char_heights)
 
-        txt_img = Image.new('RGBA', (text_width, text_height), (0, 0, 0, 0))
+    txt_img = Image.new('RGBA', (text_width, text_height), (0, 0, 0, 0))
 
-        txt_draw = ImageDraw.Draw(txt_img)
+    txt_draw = ImageDraw.Draw(txt_img)
 
-        colors = [ImageColor.getrgb(c) for c in text_color.split(',')]
-        c1, c2 = colors[0], colors[-1]
+    colors = [ImageColor.getrgb(c) for c in text_color.split(',')]
+    c1, c2 = colors[0], colors[-1]
 
-        fill = (
-            random.randint(min(c1[0], c2[0]), max(c1[0], c2[0])),
-            random.randint(min(c1[1], c2[1]), max(c1[1], c2[1])),
-            random.randint(min(c1[2], c2[2]), max(c1[2], c2[2]))
-        )
+    fill = (
+        random.randint(c1[0], c2[0]),
+        random.randint(c1[1], c2[1]),
+        random.randint(c1[2], c2[2])
+    )
 
-        for i, w in enumerate(words):
-            txt_draw.text((sum(words_width[0:i]) + i * int(space_width), 0), w, fill=fill, font=image_font)
+    for i, c in enumerate(text):
+        txt_draw.text((0, sum(char_heights[0:i])), c, fill=fill, font=image_font)
 
-        if fit:
-            return txt_img.crop(txt_img.getbbox())
-        else:
-            return txt_img
-
-    @classmethod
-    def __generate_vertical_text(cls, text, font, text_color, font_size, space_width, fit):
-        image_font = ImageFont.truetype(font=font, size=font_size)
-        
-        space_height = int(image_font.getsize(' ')[1] * space_width)
-
-        char_heights = [image_font.getsize(c)[1] if c != ' ' else space_height for c in text]
-        text_width = max([image_font.getsize(c)[0] for c in text])
-        text_height = sum(char_heights)
-
-        txt_img = Image.new('RGBA', (text_width, text_height), (0, 0, 0, 0))
-
-        txt_draw = ImageDraw.Draw(txt_img)
-
-        colors = [ImageColor.getrgb(c) for c in text_color.split(',')]
-        c1, c2 = colors[0], colors[-1]
-
-        fill = (
-            random.randint(c1[0], c2[0]),
-            random.randint(c1[1], c2[1]),
-            random.randint(c1[2], c2[2])
-        )
-
-        for i, c in enumerate(text):
-            txt_draw.text((0, sum(char_heights[0:i])), c, fill=fill, font=image_font)
-
-        if fit:
-            return txt_img.crop(txt_img.getbbox())
-        else:
-            return txt_img
+    if fit:
+        return txt_img.crop(txt_img.getbbox())
+    else:
+        return txt_img

TextRecognitionDataGenerator/data_generator.py

@@ -3,13 +3,14 @@
 
 from PIL import Image, ImageFilter
 
-from computer_text_generator import ComputerTextGenerator
+import computer_text_generator
+import background_generator
+import distorsion_generator
 try:
-    from handwritten_text_generator import HandwrittenTextGenerator
+    import handwritten_text_generator
 except ImportError as e:
     print('Missing modules for handwritten text generation.')
-from background_generator import BackgroundGenerator
-from distorsion_generator import DistorsionGenerator
+
 
 class FakeTextDataGenerator(object):
     @classmethod
@@ -34,9 +35,9 @@ def generate(cls, index, text, font, out_dir, size, extension, skewing_angle, ra
         if is_handwritten:
             if orientation == 1:
                 raise ValueError("Vertical handwritten text is unavailable")
-            image = HandwrittenTextGenerator.generate(text, text_color, fit)
+            image = handwritten_text_generator.generate(text, text_color, fit)
         else:
-            image = ComputerTextGenerator.generate(text, font, text_color, size, orientation, space_width, fit)
+            image = computer_text_generator.generate(text, font, text_color, size, orientation, space_width, fit)
 
         random_angle = random.randint(0-skewing_angle, skewing_angle)
 
@@ -48,19 +49,19 @@ def generate(cls, index, text, font, out_dir, size, extension, skewing_angle, ra
         if distorsion_type == 0:
             distorted_img = rotated_img # Mind = blown
         elif distorsion_type == 1:
-            distorted_img = DistorsionGenerator.sin(
+            distorted_img = distorsion_generator.sin(
                 rotated_img,
                 vertical=(distorsion_orientation == 0 or distorsion_orientation == 2),
                 horizontal=(distorsion_orientation == 1 or distorsion_orientation == 2)
             )
         elif distorsion_type == 2:
-            distorted_img = DistorsionGenerator.cos(
+            distorted_img = distorsion_generator.cos(
                 rotated_img,
                 vertical=(distorsion_orientation == 0 or distorsion_orientation == 2),
                 horizontal=(distorsion_orientation == 1 or distorsion_orientation == 2)
             )
         else:
-            distorted_img = DistorsionGenerator.random(
+            distorted_img = distorsion_generator.random(
                 rotated_img,
                 vertical=(distorsion_orientation == 0 or distorsion_orientation == 2),
                 horizontal=(distorsion_orientation == 1 or distorsion_orientation == 2)
@@ -89,13 +90,13 @@ def generate(cls, index, text, font, out_dir, size, extension, skewing_angle, ra
         # Generate background image #
         #############################
         if background_type == 0:
-            background = BackgroundGenerator.gaussian_noise(background_height, background_width)
+            background = background_generator.gaussian_noise(background_height, background_width)
         elif background_type == 1:
-            background = BackgroundGenerator.plain_white(background_height, background_width)
+            background = background_generator.plain_white(background_height, background_width)
         elif background_type == 2:
-            background = BackgroundGenerator.quasicrystal(background_height, background_width)
+            background = background_generator.quasicrystal(background_height, background_width)
         else:
-            background = BackgroundGenerator.picture(background_height, background_width)
+            background = background_generator.picture(background_height, background_width)
 
         #############################
         # Place text with alignment #