Kapitel 16: Signalverarbeitung mit Python: · PDF file1 Kapitel 16: Signalverarbeitung mit...

1

Kapitel 16:

Signalverarbeitung mit Python: Bilder

Einführung in die InformatikWintersemester 2007/08

Prof. Bernhard Jung

Prof. B. Jung Grundlagen der Informatik, WS 2006/07

Übersicht

FarbräumeRepräsentation digitaler BilderBildverarbeitung mit der Python Imaging LibraryVektorgrafik

Hauptlernziele:- Grundzüge der computerbasierten Repräsentation und Verarbeitung von Bildern verstehen

- Verständnis geschachtelter for-Schleifen

2

Prof. B. Jung Einführung in die Informatik, WS 2007/08 TU Bergakademie Freiberg

Licht und Farbe

Licht (Photonen) als elektromagnetische Welle, als PartikelSichtbarer Bereich zwischen 400 nm (violett) und 750 nm (rot)

Weiße Lichtquelle strahlt alle Wellenlängen ausOberflächen absorbieren manche Wellenlängen, lassen andere durch, reflektieren weitereDominante reflektierte Wellenlänge ist Farbe einer Oberfläche


Farbwahrnehmung beim Menschen

Lichtrezeptoren in Retina (Netzhaut)Zapfen

Farbwahrnehmungca. 6 Millionenbesonders dicht im Zentrum

Stäbchenkeine Farbwahrnehmungca. 120 Millionenbesonders dicht in Peripheriewichtige bei Dämmerung, Nacht, peripherem Sehen

3 Arten von ZapfenMax. Sensitivät bei

430 nm (blau), 4%530 nm (grün), 32%560 nm (rot), 64%

3


RGB-Farbraum

Tri-chromatisches Farbmodell; Farbe hat

Rot-AnteilGrün-AnteilBlau-Anteil

Hardware-nahes Farbmodellz.B. Fernseher, Computer-Monitoreauch: Dateiformate für digitale Bilder

additive FarbmischungKomplementärfarben addieren sich zu weißz.B. rot (1,0,0) + cyan (0,1,1) = weiß (1,1,1)


CMY-Farbraum

Hardware-nahes Farbmodell (Drucker)

Primärfarben cyan (helles türkis), magenta, gelb

Konversion aus RGB:C = 1 - RM = 1 - GY = 1 - B

subtraktive Farbmischungz.B. Oberflächen in cyan, d.h. RGB (0,1,1), absorbieren alles rotes Licht („cyan subtrahiert rot aus weiß“)

z.B. um rot, RGB (1,0,0), d.h. CMY(0,1,1) zu drucken, werden magenta und gelb,aber kein cyan aufgetragen

4


HSV-Farbraum

an Farbpalette beim Malen orientiert:Auswahl einer Grundfarbe,dann vermischen mit weiß oder schwarzFarbmischung für Menschen besser nachvollziehbar als bei RGB, CMY

Hue - GrundfarbeSättigung (Saturation)z.B. bei Pastell-Farben geringValue

Konversion HSV <-> RGB siehe Literatur, z.B.http://en.wikipedia.org/wiki/HSV_color_spaceFarbrechner im Internet:http://web.forret.com/tools/color.asp

Lineare Interpolation zwischen zwei Farben im HSV-Raum besser als im RGB-Raum Seitenansicht Draufsicht


DigitaleBilder

Jede RGB Farbkomponente eines Bildpunktes (Pixel) wird durch ein Byte repräsentiert

Bereich von Farben: (0, 0, 0) bis (255, 255, 255)

wenn RGB-Werte für alle Komponenten gleich sind, dann ist der Bildpunkt grauschwarz: (0, 0, 0)dunkles grau: (50,50,50)helleres grau: (150,150,150)weiß: (255, 255, 255)

Bestimmte Farbmodelle repräsentieren Farben durch 4 Bytes = 32 Bits

z.B. RGBA, 'A' ist 'Alpha-Kanal'Alpha-Wert repräsentiert Transparenz eines Bildpunktes

255,0,0 0,255,0 0,0,255

100,10,5 50,50,50 255,255,0

5,10,100150,150,1500,255,255

5


0

1

2

3

0 21 3

Bildverarbeitung - Repräsentation von Bildern

Bild repräsentiert als Matrix von PixelnIndizierung der Matrix-Elemente als (x,y), oder (horizontal,vertikal)

Ursprung (0,0) links obenElement (2, 0) in der Matrix links hat Wert (255,1,1)Element ( 0, 3) hat Wert (12,11,11)

Bildpunkte (Pixel) sind typischerweise durch je ein Byte (0..255) pro RGB-Kanal repräsentiert

D.h. ein Pixel wird durch insgesamt 3 Byte = 24 Bit repräsentiert

Ingesamt können so 16.777.216 (224) verschiedene Farben dargestellt werden

Ausschnitt einer Matrixmit Werten von RGB-Tripel

(0,8,8) (255,1,1)(3,4,12) (22,1,4)

(1,123,0) (9,77,10)(7,4,111) (12,99,7)

(1,89,12) (111,1,1)(5,225,0) (9,7,10)

(12,11,11) (6,67,112)(77,7,0) (3,33,33)

x

y


Größe von Bildern (unkomprimiert)

25,165,824 bits3,145,728 bytes

18,874,368 bits2,359,296 bytes

1024 x 768Monitor, Bild

41,943,040 bits5,242,880 bytes

31,457,280 bits3,932,160 bytes

1,3 Mega-Pixel Kamera

1280 x 1024

Monitor, Bild

9,830,400 bits1,228,800 bytes

2,457,600 bits307,200 bytes

32 bit color

7,372,800 bits921,600 bytes

1,843,200 bits230,400 bytes

24 bit color

640 x 480Bild

320 x 240Bild

6


Dateiformate für Bilder (Auswahl)

.jpg (JPEG file interchange format)weitverbreitet für fotoähnliche Bilderverlustbehaftete Komprimierung ( Blockartefakte)ungeeignet für Text, Strichzeichnungen und harte Farbübergänge

.bmp (windows bit map) relativ schwache Komprimierung i.Vgl. zu PNG; daher im Internet wenig Verwendung

.png (portable network graphics)allgemein empfohlenes Format für verlustfreie Komprimierung von Bildern im Web weit verbreitet

.gif (graphics interchange format)Im Web weit verbreitetVorteile: gut geeignet für Text, unterstützt einfache Animationen („Animiertes GIF“)Nachteil: Nur 256 Farben, deshalb für Farbfotos schlecht geeignet

Blockartefakt bei JPEG-Komprimierung (Qualitätsstufen 90, 60, 20)


PIL – Python Imaging Library

Software-Bibliothek zur Bildverarbeitung in Pythonkostenfrei (kommerzieller Support verfügbar)plattformunabhängigUnterstützung gängiger Datei-Formate

jpg, png, gif, …

http://www.pythonware.com/products/pil/index.htm

Dokumentationonline: http://www.pythonware.com/library/pil/handbook/pdf: http://www.pythonware.com/media/data/pil-handbook.pdf

7


PIL – einfaches Beispiel

im = Image.open("Lena.png")öffnet Bilddatei, erzeugt BildobjektLena ist bekanntes Beispielbild in der digitalen Bildverarbeitung

im.show() Anzeige des Bilds auf Bildschirm (mittels systemspezifischen Anzeigeprogramm)

im.save("Lena.jpg")speichtert Bild (dabei Konversion zu JPEG)

>>> from PIL import Image>>> im = Image.open("Lena.png")>>> print im<PIL.PngImagePlugin.PngImageFile instance at 0x016CB1C0>>>> print im.format, im.size, im.modePNG (512, 512) RGB>>> im.show()>>> im.save("Lena.jpg")


PIL für die Bildverarbeitung- Operationen auf Pixeln

r,b,g = image.getpixel( (x,y) )r,g,b, sind RGB-Werte des Pixels (als Zahl 0..255)image ist Bild-Objekt (Instanz von Image)(x,y) ist Koordinate des Pixels (als Tupel)

image.putpixel( (x,y), (r,g,b) )setzen der RGB-Werte des Pixels (x,y)r,g,b sind Integer im Bereich 0..255

>>> from PIL import Image>>> image = Image.open("Lena.png")>>> r,g,b, = image.getpixel( (129,99) )>>> print r,g,b206 92 93>>> print image<PIL.PngImagePlugin.PngImageFile instance at 0x00C48698>

Weitere Funktionen: siehe PIL Dokumentation zu Klasse Image

8


Beispiel: Ändern von Pixel-Werten

>>> image = Image.open('tu-baf.jpg')>>> print image.size(200, 125)>>> yellow = (255,255,0)>>> image.putpixel( (10, 100), yellow)>>> image.putpixel( (11, 100), yellow)>>> image.putpixel( (12, 100), yellow)>>> image.putpixel( (13, 100), yellow)>>> image.putpixel( (14, 100), yellow)>>> image.putpixel( (15, 100), yellow)>>> image.putpixel( (16, 100), yellow)>>> image.putpixel( (17, 100), yellow)>>> image.putpixel( (18, 100), yellow)>>> image.putpixel( (19, 100), yellow)>>> image.show()

jetzt 10 gelbe Pixel hier

>>> for x in range(10,20): image.putpixel( (x,100), yellow)

Schneller wäre automatische Verarbeitung mit for-Schleife gewesen:


Indizierung von Pixeln

Bild: Matrix von PixelnBreite und Höhe von Bildern: w, h = image.size

Pixel können über ihren Index (x,y) referenziert werdenpixel = image.getpixel( (x, y) )

Bildverarbeitung mittels geschachtelten Schleifen …

9


Geschachtelte Schleifen

Schachtelung von Schleifen:Rumpf einer Schleife ist wiederum eine Schleife

hier: spaltenweise Bearbeitung der PixelVerarbeitungsreihenfolge der Indices

(0,0), (0,1), (0,2) ….(1,0), (1,1), (1,2) ….(2,0), (2,1), ….…

zeilenweise Verarbeitung genauso möglich

def increaseRed(image):width, height = image.sizefor x in range(width):

for y in range(height):r,g,b = image.getpixel((x,y))R,G,B = int(r*1.2), g, bimage.putpixel( (x,y), (R,G,B) )


Bildverarbeitung mit Schleifen

Verringerung des Rot-Anteils in jedem Pixel des Bilds

neuer Rot-Wert : int(r*0.5)Grün- und Blauanteile wie bisher

def decreaseRed(image):width, height = image.sizefor x in range(width):


10


Farbersetzung in Teilbereichen von Bildern

from PIL import Image

def increaseGreenInArea(image, (xmin,ymin), (xmax,ymax) ):for x in range(xmin,xmax):

for y in range(ymin,ymax):r,g,b = image.getpixel((x,y))R,G,B = r, int(g*1.4), bimage.putpixel( (x,y), (R,G,B) )

>>> im = Image.open('Bergzimmerlig.jpg')>>> increaseGreenInArea(im, (90,20), (160,80) )>>> image.show()

rechteckiger Bildbereich, in welchem Farbe verändert wird

Laufbereich von x und ywird entsprechend Funktionsparametern eingeschränkt


Beispiel Bildverarbeitung –Generierung von Sonnenuntergängen

Idee:nicht Rot-Anteil erhöhen (Bild würde dadurch heller) sondern Blau- und Grün-Anteile im Bild reduzieren

def makeSunset(image):width, height = image.sizefor x in range(width):

for y in range(height):r,g,b = image.getpixel((x,y))R,G,B = r, int(g*0.7), int(b*0.7)image.putpixel( (x,y), (R,G,B) )

11


Beispiel Bildverarbeitung –Generierung von Sonnenuntergängen

die zuvor definierte Funktion makeSunset() ist natürlich auf beliebige Bilder anwendbar

dazu muss nur die Funktion nur mit einem anderen Input-Parameter aufgerufen werden

def makeSunset(image):width, height = image.sizefor x in range(width):for y in range(height):r,g,b = image.getpixel((x,y))R,G,B = r, int(g*0.7), int(b*0.7)image.putpixel( (x,y), (R,G,B) )

tu-baf.jpg makeSunset('tu-baf.jpg')


Beispiel für bildgebende Verfahren im Bereich Geo / Engineering: Georadar

Alle Bilder: www.geosphereinc.com

Nachweis von Benzintanks im Boden

12


Analogie von Bild- und Soundverarbeitung

SoundverarbeitungSound = Sequenz von Sample-WertenSoundverarbeitung mittels for-Schleifehier: prozedurales APIobjektorientiertes API wäre auch möglich gewesen:

value = sound.getSample(index)sound.setSample(index,VALUE)

BildverarbeitungBild = Matrix von PixelnBildverarbeitung mittels geschachtelter for Schleifenobjektorientiertes API

def increaseRed(image):width, height = image.sizefor x in range(width):


def increaseVolume(sound):length = len(sound)for index in range(length):

value = getSample(sound, index)VALUE = value * 2setSample(sound, index, Value)


Beispiel Bildverarbeitung –Erzeugung von Negativen

R, G, B-Werte im Bereich 0 .. 255Negativ eines Pixels, z.B. (5,10,25):

(255-5, 255-10, 255-25) = (250, 245, 230)Negativ eines Bilds: Negativ aller Pixel

def negative(image):width, height = image.sizefor x in range(width):

for y in range(height):r,g,b = image.getpixel((x,y))R, G, B, = 255-r, 255-g, 255-bimage.putpixel( (x,y), (R,G,B) )

13


Grauwertbilder

Farbbilder: Drei Farbkanäle (RGB)8 Bit = 1 Byte (0…255) pro Kanal Darstellung von insgesamt 224 Farben

Grauwertbilder1 Farbkanal zu 8 Bit = 1 Byted.h. Darstellung von 28 = 256 Grauwerten

Konvertierung Farb- Grauwertbild

z.B. Luminanz =


Grauwertbilder

1 Bit / Pixel(Binärbild)

4 Bit / Pixel 8 Bit / Pixel

http://www.tasi.ac.uk/advice/creating/image.html

14


YCbCr-Farbmodell

Farbbild mit 3 KomponentenY – Grundhelligkeit (Luminanz)Cb - Maß für die Abweichung von Grau in Richtung Blau bzw. GelbCb - Maß für die Abweichung von Grau in Richtung Rot bzw. Türkis

Anwendungen: Digitales Fernsehen, DVDJPEG, MPEG

Farbkomponenten Cb u. Cr gut geeignet für Komprimierung

z.B. nur Farbe jedes zweiten Pixel speichern (downsampling)

Verwandte FormateYUV – analoges Fernsehen (Rückwärtskompatibilität zu SW-Fernsehen)YPbPr – analoge Farbmodell, z.B. S-Video

Y

Cb

Cr

http://de.wikipedia.org/wiki/YCbCr-Farbmodell


Konvertierung zu Grauwertbildern

Echte Grauwertbilder: Pro Pixel 1 Farbwerthier:

setze R,G,B auf denselben Farbwert, z.B.

def grayscale(image):width, height = image.sizefor x in range(width):

for y in range(height):r,g,b = image.getpixel((x,y))intensity = (r+g+b) / 3image.putpixel( (x,y), ( intensity,intensity,intensity) )

15


Konvertierung zu Grauwertbildern

Bisherige Methode zur Berechnung des Grauwerts von Pixeln ist nicht optimal

Psychologische Experimente legen nahe, dass Wahrnehmung von Farben bzgl. Luminanz unterschiedlich ist

z.B. wird blau als "dunkler" wahrgenommen als rotauch bei gleicher physikalischer Lichtintensität

Grauwert-Konvertierung mit wahrnehmungspsychologisch fundierter Gewichtung:

def grayscaleweighted(image):width, height = image.sizefor x in range(width):

for y in range(height):r,g,b = image.getpixel((x,y))R = r * 0.299G = g * 0.587B = b * 0.114luminance = int(R+G+B)image.putpixel( (x,y), (luminance,luminance,luminance) )


Grauwertkonvertierung

gewichtete Grauwertkonvertierung

einfache Grauwertkonvertierung

16


Beispiel: Farbauffrischung für Dächer- Bedingtes Verändern von Pixelwerten

Ziel: Intensivierung des Rot-Anteils von DächernIdee: Erhöhung des Rotanteils von Pixeln

aber nur wenn diese schon rötlich sindif-Anweisung

def intensifyRed(image):width, height = image.sizefor x in range(width):

for y in range(height):r,g,b = image.getpixel((x,y))if r > 180:

R,G,B = int(r*1.2), g, bimage.putpixel( (x,y), (R,G,B) )


Beispiel: if … elseZiel: Überprüfung, welche Pixel bei der beabsichtigten bedingten Pixeleinfärbung überhaupt eingefärbt werden wurdenZeichne ursprüngl. "rötliche" Pixel weiß, alle anderen schwarz

Resultierendes Bild hat nur noch zwei Farben (schwarz/weiß) ("Binärbild")

def detectRed(image):width, height = image.sizefor x in range(width):

for y in range(height):r,g,b = image.getpixel((x,y))if r > 180:

R,G,B = 255, 255, 255else:

R,G,B = 0,0,0image.putpixel( (x,y), (R,G,B) )

alle Dächer, aber nicht nur!bessere Bedingung für Dachpixel???

17


"Posterisation" – Reduktion der Anzahl der Farben in einem Bild

siehe auch: http://de.wikipedia.org/wiki/Posterisation


"Posterisation" - Methode

Ganze Bereiche von Farb-Anteilen werden auf einen bestimmten Farbanteil abgebildet

z.B. falls Rotanteil < 64 dann setze Rotanteil = 31z.B. falls Rotanteil zwischen 64 und 127 dann Rotanteil = 95z.B. falls Rotanteil zwischen 128 und 191 dann Rotanteil = 159z.B. falls Rotanteil zwischen 191 und 255 dann Rotanteil = 223und analog für Grün- und Blauanteile

Implementierung durch Reihe von if-Anweisungengenauer: if – elif – else

Resultierendes Bild hat deutlich weniger Farbengemäß obiger Posterisierungsvorschrift: nur noch 4 mögliche Werte pro Farbkanalinsgesamt also 4*4*4=64 mögliche Farben

18


"Posterisation" from PIL import Image

def posterize(image):width, height = image.sizefor x in range(width):

for y in range(height):r,g,b = image.getpixel((x,y))

if r < 64: R = 31elif r < 128: R = 95elif r < 192: R = 159else: R = 223

if g < 64: G = 31elif g < 128: G = 95elif g < 192: G = 159else: G = 223

if b < 64: B = 31elif b < 128: B = 95elif b < 192: B = 159else: B = 223

image.putpixel( (x,y), (R,G,B) )

"Posterisiertes" Bild mit nur noch 64 Farben


Transponieren von Bildern

def transpose(image):width, height = image.sizeimage2 = Image.new( 'RGB', (height,width) )for x in range(width):

for y in range(height):r,g,b = image.getpixel((x,y))image2.putpixel( (y,x), (r,g,b) )

return image2

Idee: Pixel (x,y) wird an Position (y,x) im neuen Bild kopiert

Rotation + Spiegelung

19


Vertikales "Spiegeln"

Berechne Mitte des Bildes in x-Richtung (mirrorpoint)Für jede Bildzeile:

kopiere Pixel an (mirrorpoint + offset, y) nach (mirrorpoint – offset, y)


Vertikales "Spiegeln"

def mirrorVertical(image):width, height = image.sizemirrorpoint = width / 2for y in range(height):

for xOffset in range(mirrorpoint):r,g,b = image.getpixel( (mirrorpoint + xOffset, y) )image.putpixel( (mirrorpoint - xOffset,y), (r,g,b))

return image

20


Horizontales "Spiegeln"

def mirrorHorizontal(image):width, height = image.sizemirrorpoint = height / 2for yOffset in range(mirrorpoint):

for x in range(width):r,g,b = image.getpixel( (x,mirrorpoint-yOffset))image.putpixel( (x,mirrorpoint+yOffset),(r,g,b))

return image

Analog zu vertikalem SpiegelnFür jede Bildspalte:

um Pixel von oberer Hälfte in unterer Hälfte zu spiegelnkopiere Pixel an (x, mirrorpoint - offset) nach (x, mirrorpoint + offset)


def bluescreen(image, background):width, height = image.sizefor x in range(width):

for y in range(height):r,g,b = image.getpixel( (x,y) )if b > r + g:

r2,g2,b2 = background.getpixel( (x,y) )image.putpixel( (x,y), (r2,g2,b2) )

Kombinieren von Bildern

z.B. alle bläulichen Pixel eines Bildes durch Hintergrund ersetzen (Bluescreening)"bläulich" bedeutet hier: b > r + g

21

Prof. B. Jung

Innovation

Akustische Kamera, http://www.acoustic-camera.com/

Nominierung Deutscher Zukunftspreis 2005

Sichtbarmachung von Geräuschen und deren SchallquellenBasierend auf Kombination von Digitalkamera + Mikrofon-Array Anwendungen: Schallreduktion, Geräuschanalyse, Fehlerkontrolle

Akustisches Bild einer Industrieanlage Mikrofon-Array

Geräuschbilder einer Nähmaschinerechts: Fehler in der Unterfadenmechanik


Bitmaps und Vektorgrafik

Bisher: Bitmap-Bilder (Rastergrafik)Bild ist Matrix von Pixeln.jpg, .bmp, .png, .gif, …Digitalkamera, Scanner

VektorgrafikAnweisungen zum Zeichnen verschiedener einfacher FormenLinien, Rechtecke, Text, …z.B. Freehand, Ilustrator, CorelDraw, …Postscript, TrueType Fonts, …Vorteil z.B. stufenlose Skalierung möglich

Bitmaps können um Vektorgrafik-Elemente angereichert werdenGrafikbibliotheken wandeln Vektorgrafik in Pixeldarstellung um

PIL: Modul ImageDraw, z.B.erzeugen einer Zeichenoberfläche

draw = ImageDraw.Draw(image)Linie zw. gegebenen Punkten zeichnen

draw.line( [(x1,y1), (x2,y2), …], fill=(r,g,b) )und viele Methoden mehr (Bögen, Rechtecke, Text, usw.)

22


Vektorgrafikelemente – Zeichnen von Linien

from PIL import Image

def verticalLines(image):width, height = image.sizefor x in range(0,width,5):

for y in range(height):image.putpixel( (x,y), (0,0,0) )

from PIL import Image, ImageDraw

def verticalLines(image):draw = ImageDraw.Draw(image)width, height = image.sizefor x in range(0,width,5):

draw.line( [(x,0), (x,height)], fill=(0,0,0) )

Pixel einzeln setzen:

oder Linien (Vektorgrafik) zeichnen mittels ImageDraw-Modul

Anfangs- und Endpunkt der Linie Farbe der Linie


Vektorgrafikelemente – Hinzufügen von Text

from PIL import Image, ImageDraw

def title(image,string): draw = ImageDraw.Draw(image)draw.text( (40,15), string, fill=(0,0,0) )

>>> im = Image.open('Bergzimmerlig.jpg')>>> title(im,'Willkommen in Freiberg')>>> im.show()

Methode ImageDraw.text ()Parameter:

Position des Textsder Text selberoptional z.B. Farbe

23


Vektorgrafikelemente

def coolpic():image = Image.new('RGB', (250,250))draw = ImageDraw.Draw(image)for i in range(25,1,-1):

color = (i*10,i*5,i)draw.rectangle( [(0,0), (i*10,i*10)], fill=color )

return image

Rechteck spezifiziert durch Koordinaten gegenüber liegender Eckpunkte

Bild generiert durch Überlagerung von 25 Quadrate unterschiedlicher Größe und Farbe.Alle Quadrate haben eine Eckeim Ursprung (0,0), d.h. links oben.

erzeugt Liste [25,24,23,…,1]


Vektorgrafikelemente

def coolpic2():white = (255,255,255)red = (255,0,0)green = (0,255,0)image = Image.new('RGB', (640,480), white)draw = ImageDraw.Draw(image)for i in range(25,1,-1):

x0, y0 = i, iw, h = i*3, i*4draw.rectangle( [(x0,y0),(x0+w,y0+h)], outline=red )x0, y0 = 100+i*4, 100+i*3w, h = i*8, i*10draw.rectangle( [(x0,y0),(x0+w,y0+h)], outline=green )

return image

Bild enthält je 25 rote und grüneRechtecke unterschiedlicher Größeund verschobenem Ursprung

erzeugt neues Bild derGröße (640,480), nur mitweißen Pixeln

Festlegung von Position, Breite und Höhedes aktuell zu zeichnenden Rechtecks

24


Chaos Game – Generierung von fraktaler Geometrie

Zufallspunkt-Algorithmus zur näherungsweisen Konstruktion des Sierpinski-Dreiecks:

1. Definiere ein gleichseitiges Dreieck mit Ecken A,B,C

2. Wähle einen beliebigen Punkt innerhalb des Dreiecks als ersten Punkt P = (x,y), z.B. A

3. Wähle zufällig einen der Eckpunkte A,B,C4. setzte P = Mittelpunkt der gedachten Linie

zwischen P und gewähltem Eckpunkt5. zeichne P6. Weiter mit Schritt 3 (bzw. Abbruch nach

max. Anzahl von Iterationen)

http://en.wikipedia.org/wiki/Sierpinski_triangleChaos Game nach 10000 Iterationen


Chaos Gamedef chaosgame(numIterations):

width, height = 512, 444A = (0, height-1)B = (width-1, height-1)C = (width/2, 0)x = y = 0im = Image.new('RGB',

(width,height), white ) for i in range(numIterations):

r = random.random()if r < 0.333:

x0, y0 = Acolor = red

elif r < 0.6667:x0, y0 = Bcolor = green

else:x0 , y0 = Ccolor = blue

x = ( x0 + x ) / 2y = ( y0 + y ) / 2im.putpixel( (x,y), color )

return im

from PIL import Imageimport random

white = (255,255,255)red = (255,0,0)green = (0,255,0)blue = (0,0,255)

chaosgame(100000)

neues leeres Bild mitweißem Hintergrund

nächster Pixel in Mitte zw. letztemPixel und zufälligemEckpunkt

Eckpunkte desDreiecks

Zufallszahl zw. 0 und 1

25


Fraktale Geometrie: Farn

Generierung mittels iteriertemFunktionensystem

Variante des Chaosspiels

Algorithmus rechts generiert und zeichnet Punkte im Bereich-5 ≤ x ≤ 50 ≤ y ≤ 10

In Python-Implementierung (nächste Folie) werden die Punkte statt auf 10*10 Bild auf 1000*1000 Bild gezeichnet; die Koordinaten der zu zeichnenden Punkte werden dementsprechend um Faktor 100 skaliert

1. Setze x = 0, y = 0; zeichne (x,y)2. In 1% der Fälle:

x = 0, y = 0.16 yin weiterem 7% der Fälle:

x = 0.2 x − 0.26 yy = 0.23 x + 0.22 y + 1.6

in 7% der Fälle:x = −0.15 x + 0.28 yy = 0.26 x + 0.24 y + 0.44

in restlichen 85% Fälle:x = 0.85 x + 0.04 yy = −0.04 xn + 0.85 yn + 1.6

3. zeichne Punkt (x,y)4. weiter mit Schritt 2 (bzw. Abbruch

nach max. Anzahl von Iterationen)

http://en.wikipedia.org/wiki/Iterated_function_system


Fraktale Bilder: Farn def fern(numIterations):scale = 100 # image scale factorimage = Image.new('RGB',

(10*scale,10*scale), white )

x = y = 0.0for i in range(numIterations):

r = random.random()if r < 0.01:

x = 0.0y = 0.16 * y

elif r < 0.08:x = 0.2 * x - 0.26 * yy = 0.23 * x + 0.22 * y + 1.6

elif r < 0.15:x = -0.15 * x + 0.28 * yy = 0.26 * x + 0.24 * y + 0.44

else:x = 0.85 * x + 0.04 * yy = -0.04 * x + 0.85 * y + 1.6

image.putpixel( (int((x+5)*scale), int((10-y)*scale)), green)

return image

from PIL import Imageimport random

white = (255,255,255)green = (0,255,0)

fern(100000)

Kapitel 16: Signalverarbeitung mit Python: · PDF file1 Kapitel 16: Signalverarbeitung mit...

Documents

Transcript of Kapitel 16: Signalverarbeitung mit Python: · PDF file1 Kapitel 16: Signalverarbeitung mit...