Das deutsche Python-Forum

Code: Alles auswählen

#!/usr/bin/env python

import time
import PIL.Image
import numpy
import copy
from Tkinter import *
import tkMessageBox as tkm


def img(img_name):
	#return from img_name a list with (0,1) for (white, black) and after every line "\n" (=> line-end) as 3D Array (x,y,element)
	img = PIL.Image.open(img_name)
	n_img = numpy.array(img.getdata())
	#a_img = array with image-list
	a_img = n_img.tolist()
	for i in range(len(a_img)):
		#black = 1, rest = 0
		if a_img[i] not in range(0, 15):
			a_img.pop(i)
			a_img.insert(i, 0)
		else:
			a_img.pop(i)
			a_img.insert(i, 1)
	list_length1 = int(len(a_img)**0.5)
	list_length2 = list_length1
	a_img.insert(list_length1, "\n")
	for i in range (1, list_length2):
		#insert "line-end" ("\n")
		list_length1 = list_length1+list_length2+1
		a_img.insert(list_length1, "\n")
	y=1
	# print ''.join(map(str, a_img))
	for i in range (len(a_img)):
		element = a_img[i]
		a_img.pop(i)
		if element == "\n":
			try:
				x = i%((y-1)*(list_length2+1))+1
				a_img.insert(i, [x, y, element])
				y += 1
			except ZeroDivisionError:
				x = i+1
				a_img.insert(i, [x, y, element])
				y += 1
		else:
			try:
				x = i%((y-1)*(list_length2+1))+1
				a_img.insert(i, [x, y, element])
			except ZeroDivisionError:
				x = i+1
				a_img.insert(i, [x, y, element])
	return a_img

def line(img_list):
	#return line-length and direction of each line in image as array
	line_list = [] #all lines of the image as [start, stop]-element
	# print "---------------------------"
	data = 1
	while data == 1:
		first_element = 0
		start_point = 0
		try:
			while first_element != 1: #looking for first "1" in image
				first_element = img_list[start_point][2]
				start_point += 1
			else: #founding first "1" in image: img_list[start_point] = 1
				#looking for next "1"
				list_length = int(len(img_list)**0.5)
				start_point = start_point-1 #start-point of line
				end_point = start_point #end-point of line
				it = img_list[start_point][1] -1 #iterator
				if img_list[start_point+1][2] == "\n" or img_list[start_point+1][2] == 0:
				#no right line
					if img_list[start_point+list_length*it+it][2] == 0:
					#no line down
						line_list.append([img_list[start_point], img_list[end_point]])
						# print "punkt bei " + str(img_list[end_point])
						x = img_list[start_point][0]
						y = img_list[start_point][1]
						img_list.pop(start_point)
						img_list.insert(start_point, [x, y, 0])
					else:
					#line down
						try:
							while img_list[end_point+list_length+1][2] == 1:
								end_point = end_point+list_length+1
								it += 1
							line_list.append([img_list[start_point], img_list[end_point]])
							ind = start_point
							out = end_point
							while ind <= out:
								x = img_list[ind][0]
								y = img_list[ind][1]
								img_list.pop(ind)
								img_list.insert(ind, [x, y, 0])
								ind += list_length+1
							# print "linie nach unten fuer " + str(img_list[end_point][1]-img_list[start_point][1] +1)							
						except:
						# end of paper
							line_list.append([img_list[start_point], img_list[end_point]])
							ind = start_point
							it2 = 1
							while ind <= end_point:
								x = img_list[ind][0]
								y = img_list[ind][1]
								img_list.pop(ind)
								img_list.insert(ind, [x, y, 0])
								ind += list_length+1
							# print "linie (endpaper) nach unten fuer " + str(img_list[end_point][1]-img_list[start_point][1] +1)
							
				elif img_list[end_point+1][2] == 1:
				#right line
					while img_list[end_point+1][2] == 1:
						end_point += 1
					line_list.append([img_list[start_point], img_list[end_point]])
					# print "linie nach rechts fuer " + str(img_list[end_point][0]-img_list[start_point][0] +1)
					ind = start_point
					while ind <= end_point:
						x = img_list[ind][0]
						y = img_list[ind][1]
						img_list.pop(ind)
						img_list.insert(ind, [x, y, 0])
						ind += 1
						
		except: #white Paper
			# print "no more Data found"
			data = 0
			
	# lst = deepcopy(img_list)
	# for i in range(len(img_list)):
		# element = img_list[i][2]
		# lst.pop(i)
		# lst.insert(i, element)
	# print ''.join(map(str, lst))
	return line_list



def open_file():
	path = insert_path.get()
	img_listing = img(path)
	line_listing = line(img_listing)
	lst = copy.deepcopy(img_listing)
	for i in range(len(lst)):
		element = lst[i][2]
		lst.pop(i)
		lst.insert(i, element)
	a = ''.join(map(str, lst))
	tkm.showinfo(title="Bild-Matrix", message=a)
	tkm.showinfo(title="Bild-Matrix", message=line_listing)


def open_window():
	caption = "Hello Stephan"
	insert_text ="Name of image-file"
	explanation1 = "Notice: Presently, image has to be stored \n in the same folder as program"

	path_window = Tk()

	path_window.title(caption)
	Label(path_window, text = insert_text).grid(row=0, column=0, sticky=W)
	global insert_path
	insert_path = Entry(path_window)
	insert_path.grid(row=0, column=1, padx=4)
	Label(path_window, text = explanation1).grid(row=1, column=0, sticky=W)

	Button(path_window, text='Quit', command=path_window.quit).grid(row=1, column=2, pady=4)
	Button(path_window, text='Open File', command=open_file).grid(row=0, column=2, pady=4)

	path_window.mainloop()


	
def main():
	open_window()

	
if __name__=='__main__':
    main()

Code: Alles auswählen

from distutils.core import setup
import py2exe
import numpy
import copy
from Tkinter import *
import tkMessageBox
import PIL.Image


a = "test.py"
setup(console=[a])

options={r"py2exe":{r"includes": r'Tkinter',
                    r"includes": r'random',
                    r"includes": r're',
                    r"includes": r'struct',
                    r"includes": r'PIL',
					r"includes": r'time',
					r"includes": r'copy',
					r"includes": r'numpy',
					r"includes": r'Image',
					r"includes": r'tkMessageBox',
					'bundle_files': 1, 'compressed': True,
                    }}

Code: Alles auswählen

P1
10 10
0 0 0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
1 0 0 0 1 0 0 0 0 0
0 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0

Code: Alles auswählen

0000000000
0000000000
0000000000
0000000000
0000000000
0000000000
1000000000
0111000000
0000000000
0000000000

Code: Alles auswählen

                    x = image[ind][0]
                    y = image[ind][1]
                    image.pop(ind)
                    image.insert(ind, [x, y, 0])

Code: Alles auswählen

                    image[ind][2] = 0

Code: Alles auswählen

#!/usr/bin/env python
import Tkinter as tk
import tkMessageBox

import numpy
import PIL.Image


def load_image(filename, threshold=15):
    """Load image into a list of pixel elements.

    Each pixel element is a list of the form *[x, y, pixel]*.

    The elements are ordered as they appear in the image data from first top
    to bottom and left to right with the top left pixel as the first element.
    *x* and *y* denote the position of the pixel and *pixel* its color as an
    integer: 0 for white and 1 for black.

    After the elements for a complete pixel row a special marker element is
    present with a coordinate next to the rightmost pixel in that row and a
    pixel value of '\\n' (line end character).

    The function works with any file which can be read and converted into a
    grayscale image with `PIL`.

    Any grayscale value (0..255) below the optional `threshold` argument
    is interpreted as black.
    """
    image = numpy.array(PIL.Image.open(filename).convert('L')) < threshold
    # 
    # TODO Change this into returning `image` and not converting the
    #   2D data into a 1D list with marker elements for the pixel row ends.
    # 
    result = list()
    for y, row in enumerate(image, 1):
        result.extend([x, y, int(pixel)] for x, pixel in enumerate(row, 1))
        result.append([len(row) + 1, y, '\n'])
    return result


def get_lines(image):
    """Extract the lines from the image.

    The given `image` must be of the form returned by :func:`load_image`
    and width and height must be the same or an :exc:`ValueError` will
    be raised.

    Returns a sequence of lines.  Each line is represented as a list with
    two pairs of coordinates for the end points of that line.

    .. note:: This function alters pixel values of the given `image`.
        So if you need that information unchanged be sure to make a copy
        of it before passing it to this function.

    .. seealso::
        :func:`load_image` for a description of how the argument structure
        looks like.

    """
    # 
    # TODO Don't restrict this to images with equal width and height without
    #   a good reason.
    # 
    # TODO This function seems to be too long and too complex (and broken).
    # 
    lines = []
    try:
        # Length of one pixel row *including* the end marker!
        image_row_length = int(len(image)**0.5) + 1

        if image[image_row_length - 1][2] != '\n':
            raise ValueError('unexpected image row length')

        first_one_index = 0
        while True:
            while True:  # Looking for first '1' in image.
                if image[first_one_index][2] == 1:
                    break
                first_one_index += 1
            start_index = first_one_index
            # Looking for next '1'.
            end_index = start_index
            y = image[start_index][1] - 1
            if image[start_index + 1][2] in ['\n', 0]:
                # No right line.
                if image[start_index + (image_row_length - 1) * y + y][2] == 0:
                    # No line, just a point.
                    lines.append([image[start_index], image[end_index]])
                    image[start_index][2] = 0
                else:
                    # Line down.
                    try:
                        while image[end_index + image_row_length][2] == 1:
                            end_index = end_index + image_row_length
                    except IndexError:
                        # Line ends at the very bottom pixel row.
                        pass
                    lines.append([image[start_index], image[end_index]])
                    for i in xrange(
                        start_index, end_index + 1, image_row_length
                    ):
                        image[i][2] = 0

            elif image[start_index + 1][2] == 1:
                # Right line.
                while image[end_index + 1][2] == 1:
                    end_index += 1
                lines.append([image[start_index], image[end_index]])
                for i in xrange(start_index, end_index + 1):
                    image[i][2] = 0
            else:
                # 
                # The pixel value at `start_index` is not 0, 1, or '\n'
                # which should never happen.
                # 
                assert False, str(image[start_index + 1][2])

    except IndexError:
        # This happens when a non-existant image element is accessed
        # which means we have finished.  (Does it really mean *that*?)
        pass

    return lines


def process_file(path):
    image = load_image(path)
    lines = get_lines(image)
    tkMessageBox.showinfo(
        title='Bild-Matrix', message=''.join(str(x[2]) for x in image)
    )
    tkMessageBox.showinfo(title='Linien', message=lines)


def main():
    root = tk.Tk()
    root.title('Hello Stephan')

    tk.Label(root, text='Name of image file:').grid(
        row=0, column=0, sticky=tk.E
    )
    filename_entry = tk.Entry(root)
    filename_entry.grid(row=0, column=1, padx=4)
    filename_entry.focus_set()

    tk.Label(
        root,
        text=(
            'Notice: Presently, image has to be stored\n'
            'in the same folder as program'
        )
    ).grid(row=1, column=0, columnspan=2)

    tk.Button(
        root,
        text='Open File',
        command=lambda: process_file(filename_entry.get())
    ).grid(row=0, column=2, pady=4)
    tk.Button(root, text='Quit', command=root.quit).grid(
        row=1, column=2, pady=4
    )

    root.mainloop()


if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/env python
# coding: utf8
import Tkinter as tk
import tkMessageBox

import numpy
import PIL.Image


def load_image(filename, threshold=15):
    """Load image into a 2D boolean numpy array.

    The function works with any file which can be read and converted into a
    grayscale image with `PIL`.

    Any grayscale value (0..255) below the optional `threshold` argument
    is interpreted as black, i.e. True elements of the array.
    """
    return numpy.array(PIL.Image.open(filename).convert('L')) < threshold


def get_lines(image):
    """Extract the lines from the image.

    The `image` is a boolean 2D array.
    
    Returns a sequence of lines.  Each line is represented as a pair of
    coordinates of the form (x, y) for the end points of that line.
    """
    image = image.copy()
    max_x = image.shape[1] - 1
    lines = []
    for y, row in enumerate(image):
        for x, pixel in enumerate(row):
            if pixel:
                check_downwards = x == max_x or not row[x + 1]
                pixels = image[:, x][y:] if check_downwards else row[x:]

                # After this loop `i` is the index *after* the last set pixel
                # and the pixels of the line are deleted.
                i = None
                for i, line_pixel in enumerate(pixels):
                    if not line_pixel:
                        break
                    pixels[i] = False
                else:
                    # Adjust index iff the last pixel in `pixels` was set.
                    i += 1
                assert i is not None, 'there should have been at least 1 pixel'

                # Adjust `i` to be the index of the last set pixel in the line.
                i -= 1
                lines.append(
                    ((x, y), (x, y + i) if check_downwards else (x + i, y))
                )

    assert not image.any(), 'there are pixels left'
    return lines


def process_file(path):
    image = load_image(path)
    lines = get_lines(image)
    tkMessageBox.showinfo(title='Bild-Matrix', message=str(image.astype(int)))
    tkMessageBox.showinfo(title='Linien', message=lines)


def main():
    root = tk.Tk()
    root.title('Hello Stephan')

    tk.Label(root, text='Name of image file:').grid(
        row=0, column=0, sticky=tk.E
    )
    filename_entry = tk.Entry(root)
    filename_entry.grid(row=0, column=1, padx=4)
    filename_entry.focus_set()

    tk.Label(
        root,
        text=(
            'Notice: Presently, image has to be stored\n'
            'in the same folder as program'
        )
    ).grid(row=1, column=0, columnspan=2)

    tk.Button(
        root,
        text='Open File',
        command=lambda: process_file(filename_entry.get())
    ).grid(row=0, column=2, pady=4)
    tk.Button(root, text='Quit', command=root.quit).grid(
        row=1, column=2, pady=4
    )

    root.mainloop()


if __name__ == '__main__':
    main()