Seite 1 von 1
					
				Einfachste Möglichkeit ein pixelweise ein Bild zu erstellen?
				Verfasst: Mittwoch 16. Februar 2005, 16:58
				von sonium
				Hi, was ist die einfachste möglichkeit in Python pixelweise ein Bild (egal ob in Datei oder auf Bildschirm) zu erzeugen?
Code wäre nett 

 
			
					
				
				Verfasst: Mittwoch 16. Februar 2005, 17:11
				von Leonidas
				Nutzen der PIL?
Was anderes fällt mir jetzt nicht direkt ein, du kannst auch versuchen pygame oder gtk.DrawingArea zu nutzen, das sollte auch ok gehen nur wie es mit dem speichern aussieht..
			 
			
					
				
				Verfasst: Mittwoch 16. Februar 2005, 20:32
				von jens
				Hier gab es mal ein Mandelbrot Skript, welches mit TK pixelweise das Bild aufbaute... wobei es aber nicht wirklich Grafikpixel war, sondern Textpunkte, glaube ich...
			 
			
					
				
				Verfasst: Mittwoch 16. Februar 2005, 23:48
				von BlackJack
				Hi sonium,
Was möchtest Du denn mit dem Bild machen? Das am einfachsten zu erzeugende Format in irgendeiner beliebigen Programmiersprache, die Text in Dateien ausgeben kann, sind wohl die 
Netpbm Formate 
pbm (Schwarzweiss), 
pgm (Graustufen (auch mehr als 256)) und 
ppm (RGB).
Die Bilder lassen sich dann zum Beispiel mit den Netpbm Programmen, 
ImageMagick oder 
Gimp weiterverarbeiten.
 
			
					
				
				Verfasst: Donnerstag 17. Februar 2005, 13:41
				von Leonidas
				Also ich finde XBM (X11 Bitmap) und XPM (X11 Pixmap) besser, finde ich von der Struktur einfacher.
			 
			
					
				
				Verfasst: Donnerstag 17. Februar 2005, 15:33
				von BlackJack
				Dann hast Du Dir nicht angeschaut, wie die NetPBM Formate aussehen.  Was kann man denn an der Struktur noch einfacher machen?  Es wird das Format, Höhe und Breite, eventuell noch die Anzahl der Graustufen als Text in eine Datei geschrieben und dann folgen die Bilddaten, entweder als Höhe*Breite Bytes/Words bei den "Raw" Formaten oder als Zahlen als Text durch Whitespace getrennt.
			 
			
					
				
				Verfasst: Donnerstag 17. Februar 2005, 15:55
				von Leonidas
				BlackJack hat geschrieben:Dann hast Du Dir nicht angeschaut, wie die NetPBM Formate aussehen.  Was kann man denn an der Struktur noch einfacher machen?  Es wird das Format, Höhe und Breite, eventuell noch die Anzahl der Graustufen als Text in eine Datei geschrieben und dann folgen die Bilddaten, entweder als Höhe*Breite Bytes/Words bei den "Raw" Formaten oder als Zahlen als Text durch Whitespace getrennt.
Doch das habe ich:
PPM:
Code: Alles auswählen
P3
# feep.ppm
4 4
15
 0  0  0    0  0  0    0  0  0   15  0 15
 0  0  0    0 15  7    0  0  0    0  0  0
 0  0  0    0  0  0    0 15  7    0  0  0
15  0 15    0  0  0    0  0  0    0  0  0
gegen 
XPM. Da finde ich XPM irgendwie übersichtlicher. Also ein bild einfacher als das Bild mit buchstaben zu malen kann ich mir wirklich nicht einfacher vorstellen.
 
			
					
				
				Verfasst: Donnerstag 17. Februar 2005, 17:14
				von BlackJack
				Das malen mit Buchstaben ist doch gar nicht das Problem, es ging darum ein Bild von einem Programm erzeugen zu lassen.  Ich würde beides nicht per Hand erstellen wollen.  Mit mehr als 4-5 Farben wird's auch ziemlich unübersichtlich bei XPM.  Schau Dir mal das hier an: 
http://strony.ac-net.pl/magdah/jxpm/kod ... odim03.xpm
Die NetPBM Formate sind von der Struktur her einfacher aufgebaut und einfacher von einem Programm zu erzeugen. Vom einlesen mal ganz zu schweigen.  Man muss jedenfalls kein C-Programm scannen.
 
			
					
				
				Verfasst: Freitag 18. Februar 2005, 23:23
				von BlackJack
				Eine kleine Klasse mit der man ein PGM (Graustufen) erstellen und speichern kann:
Code: Alles auswählen
import struct
class PGM:
    def __init__(self, width, height, maxval=None, comment='producer: pnm.py'):
        if width <= 0 or height <= 0:
            raise ValueError("Dimensions must be > 0")
        
        self.width = width
        self.height = height
        self.maxval = maxval
        self.comment = comment
        
        #
        # Create empty image.
        #
        self.data = list()
        for dummy in xrange(self.height):
            self.data.append([0] * self.width)
    
    def __getitem__(self, coordinate_or_row):
        try:
            x, y = coordinate_or_row
            return self.data[y][x]
        except TypeError:
            return self.data[coordinate_or_row]
    
    def __setitem__(self, coordinate_or_row, pixel_or_row):
        try:
            x, y = coordinate_or_row
            self.data[y][x] = pixel_or_row
        except TypeError:
            self.data[coordinate_or_row] = pixel_or_row
    def write(self, fileobj):
        #
        # Write header.
        #
        fileobj.write('P5\n')
        if self.comment:
            fileobj.write('# %s\n' % self.comment)
        fileobj.write('%s %s\n' % (self.width, self.height))
        if self.maxval is None:
            self.maxval = max(map(max, self.data))
        fileobj.write('%s\n' % self.maxval)
        
        #
        # Write image data.
        #
        row_format = '>%d%s' % (self.width, 'BH'[int(self.maxval > 255)])
        for row in self.data:
            fileobj.write(struct.pack(row_format, *row))
    def save(self, filename):
        image_file = open(filename, 'wb')
        self.write(image_file)
        image_file.close()
So zu benutzen:
Code: Alles auswählen
from __future__ import division
import math
image = PGM(320, 240)
for y in xrange(image.height):
    for x in xrange(image.width):
        image[x, y] = int(abs((math.sin(x / 23)
                               + math.sin(y / 42)
                               + math.sin(x / 6.4)
                               + math.sin(y / 3.2))) * (255 / (2*math.pi)))
image.save('sin.pgm')
image = PGM(320, 240)
for row_nr in xrange(image.height):
    image[row_nr] = [row_nr] * image.width
image.save('gradient_h.pgm')
Die Klasse auf TrueColor Bilder (PPM) umzustellen sollte nicht weiter schwer sein.  Es fehlt natürlich auch ein wenig Dokumentation und ein paar Überprüfungen von Paramtern.
 
			
					
				
				Verfasst: Samstag 19. Februar 2005, 07:23
				von mawe
				Hi!
Sehr nett. Im Beispiel sollte man aber auch PGM importieren, sonst bleibts ziemlich finster 
 
Gruß, mawe
 
			
					
				
				Verfasst: Samstag 19. Februar 2005, 19:12
				von sonium
				mitlerweile hab bin ich auf pygame.surfarray gekommen. Hier eine Fläche pixelweise Blau anmalen:
Code: Alles auswählen
try:
    import pygame
    import Numeric as N
    from pygame.locals import *
    surfarray = pygame.surfarray
    if not surfarray: raise ImportError
except:
    raise ImportError, 'Error Importing Pygame/surfarray or Numeric'
    
pygame.init()
    
def show(img):
    screen = pygame.display.set_mode(img.shape[:2], 0, 32)
    surfarray.blit_array(screen, img)
    pygame.display.flip()
    pygame.display.set_caption("Simple GFX Output")
    while 1:
        e = pygame.event.wait()
        if e.type == QUIT: raise SystemExit
            
img = N.zeros((320, 240, 3))
for x in range(img.shape[0]):
    for y in range(img.shape[1]):
        img[x,y,:] = [100,155,255]
show(img)