Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen gezeigt.

--- ws1415:projekte_im_wintersemester_2014_15:bildzutoncode [2015/02/28 15:40]
lschmittmann
+++ ws1415:projekte_im_wintersemester_2014_15:bildzutoncode [2016/05/10 14:46] (aktuell)
@@ Zeile 436: / Zeile 436: @@
             return plraster
 </code>
-==== Markovketten ====
+==== Farbräume ====
-Markovketten
 <code python>
-def normMatrix(matrix):
-    '''normiert die Spalten der Matrix, so dass die Summe aller elemente einer Spalte genau 1 ergibt, das Verhaeltnis zwischen den Spalten aber noch erhalten bleibt.'''
+    def farbraume (self, z=2): #z Anzahl der Teilbereiche pro Farbkomponente
-    matrixcopy = []
+        '''Wenn man sich den RGB-Farbraum als Würfel vorstellt, so kann man diesen in kleinere Würfel zerlegen. Diese Methode zerlegt den Würfel in z*z*z kleine Würfel und ordnet jedem Pixel den Würfel zu, in dem er liegt.'''
-    for col in matrix:
+        farbraume = []
-        colcopy = []
+        for i in range (z):
-        nenner = sum(col)
+            for j in range (z):
-        if nenner != 0:
+                for k in range (z):
-            for element in col:
+                    farbraume.append((i,j,k))
-                colcopy.append(element/nenner)
-            matrixcopy.append(colcopy)
+        konvpixel = []
-        else:
+        for pixel in self.pixels:
-            colcopy = [1/len(col) for x in range(len(col))]
+            r = pixel[0]
-            print colcopy
+            g = pixel[1]
-    return matrixcopy
+            b = pixel[2]
-def step(matrix, vec, step = 1):
+            for i in range(z):
-    '''berechnet den Vector der Notenwahrscheinlichkeit nach step Noten'''
+                if (256/z)*i <= r and r < (256*(i+1))/z:
-    for i in range(step):
+                    rl = i #rot
-        retvec = []
+                if (256/z)*i <= g and g < (256*(i+1))/z:
-        for y in range(len(matrix[0])):
+                    gl = i #grün
-            retvec.append(sum([matrix[x][y]*vec[x] for x in range(len(matrix))]))
+                if (256/z)*i <= b and b < (256*(i+1))/z:
-        vec = retvec[:]
+                    bl = i #blau
-    return vec
+            konvpixel.append((rl,gl,bl))
-def nextTune(matrix, vec, val):
+        return [farbraume.index(tupel) for tupel in konvpixel]
-    '''val muss zwischen 0 und 1 liegen. Dann berechnet diese Methode den naechsten Ton, der gespielt wird.'''
+</code>
-    element = 0
+==== Synthesizer ====
-    probvec = step(matrix, vec)
+<code python>
-    print sum(probvec), " >= ", val
+def tune(f, d, r=44100, mode='sinus'):
-    while sum(probvec[:element+1]) < val:
+	vol = 1
-        element += 1
+	waves = []
-        if (element == len(probvec)-1):
+	waves.append(sinewave(f, r, d))
-            return element
+	if mode == 'organ':
-    #print 'Tonhoehe berechnet.'
+		while vol >= 0.1:
-    return element
+			vol *= 0.7
-def generateMelodie(pic, nums, tunes = 24):
+			waves.append(sinewave(f*freq.getRatio('quinte'), r, d, vol=vol/2))
-    '''nums muss eine Liste mit zahlen zwischen 0 und 1 sein'''
+			f *= freq.getRatio('oktave')
-    matrix = pic.transformImage(tunes, tunes)
+			waves.append(sinewave(f, r, d, vol = vol))
-    matrix = normMatrix(matrix)
+	if '#' in mode: #bei #a-z1,b-z2,c-z3,d-z4,g-z5,t-z6,e-z7 wird der a-te, b-te, ..., e-te oberton hinzugefügt mit z1, z2,..., z7 % lautstärke
-    melodie = []
+		toene = mode[1:].split(',')
-    vec = genVector(9, tunes)
+		for ton in toene:
-    for num in nums:
+			waves.append(sinewave(f*2**int(ton[:ton.index('-')]), r, d, vol=int(ton[ton.index('-'):])/100))
-        melodie.append(nextTune(matrix, vec, num))
-        vec = genVector(melodie[-1])
+	return wave
-        print 'Ton wurde der Melodie hinzugefuegt.'
+</code>
-    #print 'Melodie erzeugt.'
+==== MARKOV ====
-    return melodie
+<code python>
-def generateTune(pic, notes = 240, tunes = 24, length = 1, mode = 'sinus'):
+    from __future__ import division
-    '''generiert ein Sound object, mit einer durch markov ketten erstellte melodie'''
+    from bild import Bild
-    nums = zahlen.zufallsZahl(pic, notes)
+    import matplotlib.pyplot as plt
-    print nums
+    import numpy as np
-    print 'Zufallszahlen generiert.'
+    from sound import *
-    melodie = generateMelodie(pic, nums, tunes)
+    import frequenzen as freq
-    print 'Melodie erzeugt.'
+    import zufallszahlen as zahlen
-    rhythmus = rhythm.generateRhythm(pic, len(nums), length, 4)
+    import rhythm
-    print 'Rhythmus erzeugt.'
-    tonlage = 1
-    s = Sound(np.array([]))
-    for i in range(len(melodie)):
-        ton = melodie[i]
-        laenge = rhythmus[i]
-        tune = createTune(freq.getFreq(freq.buchstaben[ton%8][0])*2**(tonlage-ton//8), laenge, mode = mode)
-        #print max(tune)
-        s.appendSound([tune], swz.GRENZE)
-    print 'Fertig.'
-    return s
-def genVector(eins, length = 24):
-    '''generiert einen Vector der Laenge length mit einer 1 an der stelle eins'''
-    vec = [0 for i in range(length)]
-    vec[eins] = 1
-    return vec
-def genRandList(length, maximum):
-    return [(np.random.random_integers(maximum+1)-1)/maximum for x in range(length)]
+    def normMatrix(matrix):
+            '''normiert die Spalten der Matrix, so dass die Summe aller elemente einer Spalte genau 1 ergibt, das Verhaeltnis zwischen den Spalten aber                                                   noch erhalten bleibt.'''
+        matrixcopy = []
+        for col in matrix:
+            colcopy = []
+            nenner = sum(col)
+            if nenner != 0:
+                for element in col:
+                    colcopy.append(element/nenner)
+                matrixcopy.append(colcopy)
+            else:
+                colcopy = [1/len(col) for x in range(len(col))]
+                print colcopy
+        return matrixcopy
+    def step(matrix, vec, step = 1):
+        '''berechnet den Vector der Notenwahrscheinlichkeit nach step Noten'''
+        for i in range(step):
+            retvec = []
+            for y in range(len(matrix[0])):
+                retvec.append(sum([matrix[x][y]*vec[x] for x in range(len(matrix))]))
+            vec = retvec[:]
+        return vec
+    def nextTune(matrix, vec, val):
+        '''val muss zwischen 0 und 1 liegen. Dann berechnet diese Methode den naechsten Ton, der gespielt wird.'''
+        element = 0
+        probvec = step(matrix, vec)
+        print sum(probvec), " >= ", val
+        while sum(probvec[:element+1]) < val:
+            element += 1
+            if (element == len(probvec)-1):
+                return element
+        #print 'Tonhoehe berechnet.'
+        return element
+    def generateMelodie(pic, nums, tunes = 24):
+        '''nums muss eine Liste mit zahlen zwischen 0 und 1 sein'''
+        matrix = pic.transformImage(tunes, tunes)
+        matrix = normMatrix(matrix)
+        melodie = []
+        vec = genVector(9, tunes)
+        for num in nums:
+            melodie.append(nextTune(matrix, vec, num))
+            vec = genVector(melodie[-1])
+            print 'Ton wurde der Melodie hinzugefuegt.'
+        #print 'Melodie erzeugt.'
+        return melodie
+    def generateTune(pic, notes = 240, tunes = 24, length = 1, mode = 'sinus'):
+        '''generiert ein Sound object, mit einer durch markov ketten erstellte melodie'''
+        nums = zahlen.zufallsZahl(pic, notes)
+        print nums
+        print 'Zufallszahlen generiert.'
+        melodie = generateMelodie(pic, nums, tunes)
+        print 'Melodie erzeugt.'
+        rhythmus = rhythm.generateRhythm(pic, len(nums), length, 4)
+        print 'Rhythmus erzeugt.'
+        tonlage = 1
+        s = Sound(np.array([]))
+        for i in range(len(melodie)):
+            ton = melodie[i]
+            laenge = rhythmus[i]
+            tune = createTune(freq.getFreq(freq.buchstaben[ton%8][0])*2**(tonlage-ton//8), laenge, mode = mode)
+            #print max(tune)
+            s.appendSound([tune], swz.GRENZE)
+        print 'Fertig.'
+        return s
+    def genVector(eins, length = 24):
+        '''generiert einen Vector der Laenge length mit einer 1 an der stelle eins'''
+        vec = [0 for i in range(length)]
+        vec[eins] = 1
+        return vec
+    def genRandList(length, maximum):
+        return [(np.random.random_integers(maximum+1)-1)/maximum for x in range(length)]
+</code>
+==== Zufallszahlen ====
+Zufallszahlen für Markov-ketten
+<code python>
+# -*- coding: cp1252 -*-
+#Zufallszahl für Markov-Kette
+#-*- coding: utf-8 -*-
+from __future__ import division
+from PIL import Image
+import random
+from bild import Bild
+import numpy as np
+def spaltenBreite(bild, spalten = 240):
+    '''Spaltenbreite der Pixel die zusammengefasst wird!'''
+    n = bild.bBreite()
+    b = int((n-(n%spalten))/spalten)
+    if b == 0:
+        return 1
+    return b
+def spalten(bild, spaltenum = 240):
+    spalten = []
+    pic = bild.rasterList(bild.farbraume(4))
+    sBreite = spaltenBreite(bild, spaltenum)
+    ende = bild.bBreite()-bild.bBreite()%sBreite
+    if ende == 0:
+        ende = bild.bBreite()
+    for i in range(0, ende, sBreite):
+        spalte = []
+        for x in range(sBreite):
+            if (i+x < len(pic)):
+                spalte += pic[i+x]
+        spalten.append(spalte)
+    return spalten
+def zufallsZahl(bild, spaltenum = 240):
+    n = bild.bBreite()
+    b = spaltenBreite(bild, spaltenum)
+    l = int(bild.bHohe())
+    r = b * l
+    spalter = []
+    spaltenliste = spalten(bild, spaltenum)
+    for spalte in spaltenliste:
+        spalter.append(sum(spalte)/len(spalte))
+    zZahl = []
+    for spalte in range(len(spalter)):
+        varianz = 0
+        for y in range(r):
+            x1 = spalter[spalte]
+            x2 = spaltenliste[spalte][y]
+            varianz += 1/r*(x1 - x2)**2
+        zZahl.append(varianz)
+    maximum = max(zZahl)
+    return [num/maximum for num in zZahl]
+</code>

Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Unterschiede

Seiten-Werkzeuge