Create Stunning Images through Generative Python Programming

In this guide, we'll delve into the world of generative image manipulation using Python. We will break down a Python code implementation that allows you to create new images by flipping individual pixels while adhering to specific constraints. Whether you're a beginner looking to explore the fundamentals of generative image processing or an experienced programmer seeking to enhance your image manipulation skills, this article will provide valuable insights and practical examples to fuel your creative projects.

Building Stunning Images with Generative Python

Explore the fascinating world of generative image manipulation in Python with our comprehensive guide. Learn to create stunning images by flipping pixels while adhering to specific constraints, and unlock your creative potential. Whether you're interested in the art of image generation or need to help with your Python assignment, this resource provides valuable insights and practical examples to elevate your skills and inspire your projects. Dive into the world of generative image manipulation, and let your imagination run wild as you discover Python's limitless image transformation capabilities.

Block 1: Importing Modules and Defining Test Cases

```python import unittest import generative class GenerativeTest(unittest.TestCase): def test_flatten_image(self): test1 = [[1]] self.assertEqual([1], generative.flatten_image(test1)) test2 = [[1, 0], [1, 1]] self.assertEqual([1, 0, 1, 1], generative.flatten_image(test2)) test3 = [[1, 0, 1], [1, 0, 1], [1, 1, 0]] self.assertEqual([1, 0, 1, 1, 0, 1, 1, 1, 0], generative.flatten_image(test3)) def test_unflatten_image(self): test1 = [1] self.assertEqual([[1]], generative.unflatten_image(test1)) test2 = [1, 0, 1, 1] self.assertEqual([[1, 0], [1, 1]], generative.unflatten_image(test2)) test3 = [1, 0, 1, 1, 0, 1, 1, 1, 0] self.assertEqual([[1, 0, 1], [1, 0, 1], [1, 1, 0]], generative.unflatten_image(test3)) def test_check_adjacent_for_one(self): test = [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1] self.assertEqual(False, generative.check_adjacent_for_one(test, 0)) self.assertEqual(False, generative.check_adjacent_for_one(test, 1)) self.assertEqual(False, generative.check_adjacent_for_one(test, 2)) self.assertEqual(True, generative.check_adjacent_for_one(test, 3)) self.assertEqual(False, generative.check_adjacent_for_one(test, 4)) self.assertEqual(False, generative.check_adjacent_for_one(test, 5)) self.assertEqual(True, generative.check_adjacent_for_one(test, 6)) self.assertEqual(True, generative.check_adjacent_for_one(test, 8)) self.assertEqual(True, generative.check_adjacent_for_one(test, 9)) self.assertEqual(True, generative.check_adjacent_for_one(test, 10)) ```

This block imports the `unittest` module and a module named `generative`. It defines a test class `GenerativeTest` that contains several test cases for functions in the `generative` module. These test cases check the functionality of the generative image manipulation functions.

Block 2: Type Hinting and Function Definitions

```python from __future__ import annotations from typing import List # Function definitions for image manipulation def flatten_image(image: list[list[int]]) -> list[int]: """ Flattens a 2D list into a 1D list. :param image: 2D list of integers representing an image. :return: 1D list of integers representing a flattened image. """ return [pixel for row in image for pixel in row] def unflatten_image(flat_image: list[int]) -> list[list[int]]: """ Unflattens a 1D list into a 2D list. :param flat_image: 1D list of integers representing a flattened image. :return: 2D list of integers. """ image = [] row_length = int((len(flat_image))**0.5) for row in range(row_length): list_of_pixel = [] for i in range(row_length): list_of_pixel.append(flat_image[i + (row * row_length)]) image.append(list_of_pixel) return image def check_adjacent_for_one(flat_image: list[int], flat_pixel: int) -> bool: """ Checks if a pixel has an adjacent pixel with the value of 1 in a 1D list. :param flat_image: 1D list of integers representing a flattened image. :param flat_pixel: Integer representing the index of the pixel in question. :return: Boolean. """ image_size = int((len(flat_image))**0.5) row = flat_pixel // image_size column = flat_pixel % image_size # Pixels to check in the 1D list to_check = [] # Check above if row > 0: to_check.append(flat_pixel - image_size) # Check below if row < image_size - 1: to_check.append(flat_pixel + image_size) # Check left if column > 0: to_check.append(flat_pixel - 1) # Check right if column < image_size - 1: to_check.append(flat_pixel + 1) # Return True if any adjacent pixel has the value of 1 return any(flat_image[i] == 1 for i in to_check) def pixel_flip(lst: list[int], orig_lst: list[int], budget: int, results: list[list[int]], i:int =0) -> None: if budget == 0: return if i == len(orig_lst): return pixel_flip(lst, orig_lst, budget, results, i + 1) if orig_lst[i] == 0: if check_adjacent_for_one(orig_lst, i) > 0: copy = list(lst) copy[i] = 1 results.append(copy) pixel_flip(copy, orig_lst, budget-1, results, i+1) ```

In this block, the code first specifies type hinting using annotations. It then defines several functions used for image manipulation, including flattening and unflattening images, checking adjacent pixels for a specific value, and pixel flipping. These functions form the core of the image generation process.

Block 3: Writing Images to Files

```python def write_image(orig_image: list[list[int]], new_image: list[list[int]], file_name: str) -> None: f = open(file_name, 'w') height = len(orig_image) width = len(orig_image[0]) for i in range(height): for j in range(width): if orig_image[i][j] != new_image[i][j]: f.write('X') else: f.write(str(orig_image[i][j]) f.write('\n') f.close() def generate_new_images(image: list[list[int]], budget: int) -> list[list[list[int]]]: flattens = flatten_image(image) flippeds = [] pixel_flip(flattens, flattens, budget, flippeds) results = [] for flipped in flippeds: results.append(unflatten_image(flipped)) return results ```

This block contains two functions: `write_image` and `generate_new_images`. The `write_image` function is responsible for writing the differences between the original and new images to a file. The `generate_new_images` function generates new images by flipping pixels while adhering to a budget constraint.

Block 4: Main Function and Execution

```python def main(): lst = [[1,0,0],[1,0,0],[1,1,1]] results = [] pixel_flip(flatten_image(lst), flatten_image(lst), 3, results) for result in results: print(result) pref = 'file' for i in range(len(results)): write_image(lst, unflatten_image(results[i]), pref + str(i) + '.txt') if __name__ == '__main__': main() ```

The `main` function is responsible for executing the image generation process. It defines a sample image, calls the `pixel_flip` function to generate new images, and writes these images to files. This block also checks whether the script is executed as the main program and, if so, runs the `main` function.

Conclusion

Generative image manipulation is a fascinating field, and this Python code provides you with the tools to experiment with it. Whether you're interested in creating new images, exploring constraints, or understanding the basics of image manipulation, this code serves as an excellent starting point. Dive into the world of generative image manipulation, and let your creativity soar as you explore the endless possibilities of Python's image transformation capabilities. Unleash your imagination and start creating stunning, unique visuals today!