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!