← Back to branch summary

~ubuntu-branches/ubuntu/quantal/python-pyo/quantal

« back to all changes in this revision

Viewing changes to pyolib/fourier.py

  • Committer: Package Import Robot
  • Author(s): Tiago Bortoletto Vaz
  • Date: 2012-07-03 23:45:41 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120703234541-jh5jg00lvljnwq8m
Tags: 0.6.2-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
pyolib/fourier.py
147
147
    def __len__(self):
148
148
        return len(self._real_objs)
149
149
 
150
 
    def __del__(self):
151
 
        if self._real_dummy:
152
 
            [obj.deleteStream() for obj in self._real_dummy]
153
 
        if self._imag_dummy:
154
 
            [obj.deleteStream() for obj in self._imag_dummy]
155
 
        if self._bin_dummy:
156
 
            [obj.deleteStream() for obj in self._bin_dummy]
157
 
        self._real_dummy = []
158
 
        self._imag_dummy = []
159
 
        self._bin_dummy = []
160
 
        for obj in self._real_objs:
161
 
            obj.deleteStream()
162
 
            del obj
163
 
        for obj in self._imag_objs:
164
 
            obj.deleteStream()
165
 
            del obj
166
 
        for obj in self._bin_objs:
167
 
            obj.deleteStream()
168
 
            del obj
169
 
        for obj in self._base_players:
170
 
            obj.deleteStream()
171
 
            del obj
172
 
 
173
150
    def __getitem__(self, str):
174
151
        if str == 'real':
175
152
            self._real_dummy.append(Dummy([obj for i, obj in enumerate(self._real_objs)]))
237
214
        [obj.stop() for obj in self._bin_objs]
238
215
        return self
239
216
 
 
217
    def out(self, chnl=0, inc=1, dur=0, delay=0):
 
218
        return self.play(dur, delay)
 
219
 
240
220
    def setSize(self, x):
241
221
        """
242
222
        Replace the `size` attribute.
574
554
    def __len__(self):
575
555
        return len(self._inreal)
576
556
 
577
 
    def __del__(self):
578
 
        if self._mag_dummy:
579
 
            [obj.deleteStream() for obj in self._mag_dummy]
580
 
        if self._ang_dummy:
581
 
            [obj.deleteStream() for obj in self._ang_dummy]
582
 
        self._mag_dummy = []
583
 
        self._ang_dummy = []
584
 
        for obj in self._base_objs:
585
 
            obj.deleteStream()
586
 
            del obj
587
 
 
588
557
    def __getitem__(self, str):
589
558
        if str == 'mag':
590
559
            self._mag_dummy.append(Dummy([obj for i, obj in enumerate(self._base_objs) if i%2 == 0]))
749
718
    def __len__(self):
750
719
        return len(self._inmag)
751
720
 
752
 
    def __del__(self):
753
 
        if self._real_dummy:
754
 
            [obj.deleteStream() for obj in self._real_dummy]
755
 
        if self._imag_dummy:
756
 
            [obj.deleteStream() for obj in self._imag_dummy]
757
 
        self._real_dummy = []
758
 
        self._imag_dummy = []
759
 
        for obj in self._base_objs:
760
 
            obj.deleteStream()
761
 
            del obj
762
 
 
763
721
    def __getitem__(self, str):
764
722
        if str == 'real':
765
723
            self._real_dummy.append(Dummy([obj for i, obj in enumerate(self._base_objs) if i%2 == 0]))
899
857
    >>> delta = FrameDelta(pol["ang"], framesize=size, overlaps=4)
900
858
    >>> m_mag_rec = MatrixRec(pol["mag"], m_mag, 0, [i*hop for i in range(4)]).play()
901
859
    >>> m_pha_rec = MatrixRec(delta, m_pha, 0, [i*hop for i in range(4)]).play()
902
 
    >>> m_mag_read = MatrixPointer(m_mag, fin["bin"]/size, Randi(freq=0.51))
903
 
    >>> m_pha_read = MatrixPointer(m_pha, fin["bin"]/size, Randi(freq=0.5))
 
860
    >>> m_mag_read = MatrixPointer(m_mag, fin["bin"]/size, Sine(freq=0.25, mul=.5, add=.5))
 
861
    >>> m_pha_read = MatrixPointer(m_pha, fin["bin"]/size, Sine(freq=0.25, mul=.5, add=.5))
904
862
    >>> accum = FrameAccum(m_pha_read, framesize=size, overlaps=4)
905
863
    >>> car = PolToCar(m_mag_read, accum)
906
864
    >>> fout = IFFT(car["real"], car["imag"], size=size, overlaps=4).mix(1).out()
917
875
        self._in_fader = InputFader(input)
918
876
        in_fader, framesize, overlaps, mul, add, lmax = convertArgsToLists(self._in_fader, framesize, overlaps, mul, add)
919
877
        num_of_mains = len(self._in_fader) / self._overlaps
920
 
        self._main_players = []
 
878
        self._base_players = []
921
879
        for j in range(num_of_mains):
922
880
            objs_list = []
923
881
            for i in range(len(self._in_fader)):
924
882
                if (i % num_of_mains) == j:
925
883
                    objs_list.append(self._in_fader[i])
926
 
            self._main_players.append(FrameDeltaMain_base(objs_list, wrap(framesize,j), wrap(overlaps,j)))
 
884
            self._base_players.append(FrameDeltaMain_base(objs_list, wrap(framesize,j), wrap(overlaps,j)))
927
885
        self._base_objs = []
928
886
        for i in range(lmax):
929
 
            main_player = i % num_of_mains
 
887
            base_player = i % num_of_mains
930
888
            overlap = i / num_of_mains
931
 
            self._base_objs.append(FrameDelta_base(self._main_players[main_player], overlap, wrap(mul,i), wrap(add,i)))
 
889
            self._base_objs.append(FrameDelta_base(self._base_players[base_player], overlap, wrap(mul,i), wrap(add,i)))
932
890
 
933
891
    def __dir__(self):
934
892
        return ['input', 'framesize', 'mul', 'add']
935
893
 
936
 
    def __del__(self):
937
 
        for obj in self._base_objs:
938
 
            obj.deleteStream()
939
 
            del obj
940
 
        for obj in self._main_players:
941
 
            obj.deleteStream()
942
 
            del obj
943
 
 
944
 
    def play(self, dur=0, delay=0):
945
 
        dur, delay, lmax = convertArgsToLists(dur, delay)
946
 
        self._main_players = [obj.play(wrap(dur,i), wrap(delay,i)) for i, obj in enumerate(self._main_players)]
947
 
        self._base_objs = [obj.play(wrap(dur,i), wrap(delay,i)) for i, obj in enumerate(self._base_objs)]
948
 
        return self
949
 
 
950
894
    def out(self, chnl=0, inc=1, dur=0, delay=0):
951
 
        return self
952
 
 
953
 
    def stop(self):
954
 
        [obj.stop() for obj in self._main_players]
955
 
        [obj.stop() for obj in self._base_objs]
956
 
        return self
 
895
        return self.play(dur, delay)
957
896
 
958
897
    def setInput(self, x, fadetime=0.05):
959
898
        """
982
921
        """
983
922
        self._framesize = x
984
923
        x, lmax = convertArgsToLists(x)
985
 
        [obj.setFrameSize(wrap(x,i)) for i, obj in enumerate(self._main_players)]
 
924
        [obj.setFrameSize(wrap(x,i)) for i, obj in enumerate(self._base_players)]
986
925
 
987
926
    def ctrl(self, map_list=None, title=None, wxnoserver=False):
988
927
        self._map_list = []
1059
998
    >>> delta = FrameDelta(pol["ang"], framesize=size, overlaps=4)
1060
999
    >>> m_mag_rec = MatrixRec(pol["mag"], m_mag, 0, [i*hop for i in range(4)]).play()
1061
1000
    >>> m_pha_rec = MatrixRec(delta, m_pha, 0, [i*hop for i in range(4)]).play()
1062
 
    >>> m_mag_read = MatrixPointer(m_mag, fin["bin"]/size, Randi(freq=0.51))
1063
 
    >>> m_pha_read = MatrixPointer(m_pha, fin["bin"]/size, Randi(freq=0.5))
 
1001
    >>> m_mag_read = MatrixPointer(m_mag, fin["bin"]/size, Sine(freq=0.25, mul=.5, add=.5))
 
1002
    >>> m_pha_read = MatrixPointer(m_pha, fin["bin"]/size, Sine(freq=0.25, mul=.5, add=.5))
1064
1003
    >>> accum = FrameAccum(m_pha_read, framesize=size, overlaps=4)
1065
1004
    >>> car = PolToCar(m_mag_read, accum)
1066
1005
    >>> fout = IFFT(car["real"], car["imag"], size=size, overlaps=4).mix(1).out()
1077
1016
        self._in_fader = InputFader(input)
1078
1017
        in_fader, framesize, overlaps, mul, add, lmax = convertArgsToLists(self._in_fader, framesize, overlaps, mul, add)
1079
1018
        num_of_mains = len(self._in_fader) / self._overlaps
1080
 
        self._main_players = []
 
1019
        self._base_players = []
1081
1020
        for j in range(num_of_mains):
1082
1021
            objs_list = []
1083
1022
            for i in range(len(self._in_fader)):
1084
1023
                if (i%num_of_mains) == j:
1085
1024
                    objs_list.append(self._in_fader[i])
1086
 
            self._main_players.append(FrameAccumMain_base(objs_list, wrap(framesize,j), wrap(overlaps,j)))
 
1025
            self._base_players.append(FrameAccumMain_base(objs_list, wrap(framesize,j), wrap(overlaps,j)))
1087
1026
        self._base_objs = []
1088
1027
        for i in range(lmax):
1089
 
            main_player = i % num_of_mains
 
1028
            base_player = i % num_of_mains
1090
1029
            overlap = i / num_of_mains
1091
 
            self._base_objs.append(FrameAccum_base(self._main_players[main_player], overlap, wrap(mul,i), wrap(add,i)))
 
1030
            self._base_objs.append(FrameAccum_base(self._base_players[base_player], overlap, wrap(mul,i), wrap(add,i)))
1092
1031
 
1093
1032
    def __dir__(self):
1094
1033
        return ['input', 'framesize', 'mul', 'add']
1095
1034
 
1096
 
    def __del__(self):
1097
 
        for obj in self._base_objs:
1098
 
            obj.deleteStream()
1099
 
            del obj
1100
 
        for obj in self._main_players:
1101
 
            obj.deleteStream()
1102
 
            del obj
1103
 
 
1104
 
    def play(self, dur=0, delay=0):
1105
 
        dur, delay, lmax = convertArgsToLists(dur, delay)
1106
 
        self._main_players = [obj.play(wrap(dur,i), wrap(delay,i)) for i, obj in enumerate(self._main_players)]
1107
 
        self._base_objs = [obj.play(wrap(dur,i), wrap(delay,i)) for i, obj in enumerate(self._base_objs)]
1108
 
        return self
1109
 
 
1110
1035
    def out(self, chnl=0, inc=1, dur=0, delay=0):
1111
 
        return self
1112
 
 
1113
 
    def stop(self):
1114
 
        [obj.stop() for obj in self._main_players]
1115
 
        [obj.stop() for obj in self._base_objs]
1116
 
        return self
 
1036
        return self.play(dur, delay)
1117
1037
 
1118
1038
    def setInput(self, x, fadetime=0.05):
1119
1039
        """
1142
1062
        """
1143
1063
        self._framesize = x
1144
1064
        x, lmax = convertArgsToLists(x)
1145
 
        [obj.setFrameSize(wrap(x,i)) for i, obj in enumerate(self._main_players)]
 
1065
        [obj.setFrameSize(wrap(x,i)) for i, obj in enumerate(self._base_players)]
1146
1066
 
1147
1067
    def ctrl(self, map_list=None, title=None, wxnoserver=False):
1148
1068
        self._map_list = []
1241
1161
        self._in_fader = InputFader(input)
1242
1162
        in_fader, framesize, overlaps, up, down, damp, mul, add, lmax = convertArgsToLists(self._in_fader, framesize, overlaps, up, down, damp, mul, add)
1243
1163
        num_of_mains = len(self._in_fader) / self._overlaps
1244
 
        self._main_players = []
 
1164
        self._base_players = []
1245
1165
        for j in range(num_of_mains):
1246
1166
            objs_list = []
1247
1167
            for i in range(len(self._in_fader)):
1248
1168
                if (i % num_of_mains) == j:
1249
1169
                    objs_list.append(self._in_fader[i])
1250
 
            self._main_players.append(VectralMain_base(objs_list, wrap(framesize,j), wrap(overlaps,j), wrap(up,j), wrap(down,j), wrap(damp,j)))
 
1170
            self._base_players.append(VectralMain_base(objs_list, wrap(framesize,j), wrap(overlaps,j), wrap(up,j), wrap(down,j), wrap(damp,j)))
1251
1171
        self._base_objs = []
1252
1172
        for i in range(lmax):
1253
 
            main_player = i % num_of_mains
 
1173
            base_player = i % num_of_mains
1254
1174
            overlap = i / num_of_mains
1255
 
            self._base_objs.append(Vectral_base(self._main_players[main_player], overlap, wrap(mul,i), wrap(add,i)))
 
1175
            self._base_objs.append(Vectral_base(self._base_players[base_player], overlap, wrap(mul,i), wrap(add,i)))
1256
1176
 
1257
1177
    def __dir__(self):
1258
1178
        return ['input', 'framesize', 'up', 'down', 'damp', 'mul', 'add']
1259
1179
 
1260
 
    def __del__(self):
1261
 
        for obj in self._base_objs:
1262
 
            obj.deleteStream()
1263
 
            del obj
1264
 
        for obj in self._main_players:
1265
 
            obj.deleteStream()
1266
 
            del obj
1267
 
 
1268
 
    def play(self, dur=0, delay=0):
1269
 
        dur, delay, lmax = convertArgsToLists(dur, delay)
1270
 
        self._main_players = [obj.play(wrap(dur,i), wrap(delay,i)) for i, obj in enumerate(self._main_players)]
1271
 
        self._base_objs = [obj.play(wrap(dur,i), wrap(delay,i)) for i, obj in enumerate(self._base_objs)]
1272
 
        return self
1273
 
 
1274
1180
    def out(self, chnl=0, inc=1, dur=0, delay=0):
1275
 
        return self
1276
 
 
1277
 
    def stop(self):
1278
 
        [obj.stop() for obj in self._main_players]
1279
 
        [obj.stop() for obj in self._base_objs]
1280
 
        return self
 
1181
        return self.play(dur, delay)
1281
1182
 
1282
1183
    def setInput(self, x, fadetime=0.05):
1283
1184
        """
1306
1207
        """
1307
1208
        self._framesize = x
1308
1209
        x, lmax = convertArgsToLists(x)
1309
 
        [obj.setFrameSize(wrap(x,i)) for i, obj in enumerate(self._main_players)]
 
1210
        [obj.setFrameSize(wrap(x,i)) for i, obj in enumerate(self._base_players)]
1310
1211
 
1311
1212
    def setUp(self, x):
1312
1213
        """
1320
1221
        """
1321
1222
        self._up = x
1322
1223
        x, lmax = convertArgsToLists(x)
1323
 
        [obj.setUp(wrap(x,i)) for i, obj in enumerate(self._main_players)]
 
1224
        [obj.setUp(wrap(x,i)) for i, obj in enumerate(self._base_players)]
1324
1225
 
1325
1226
    def setDown(self, x):
1326
1227
        """
1334
1235
        """
1335
1236
        self._down = x
1336
1237
        x, lmax = convertArgsToLists(x)
1337
 
        [obj.setDown(wrap(x,i)) for i, obj in enumerate(self._main_players)]
 
1238
        [obj.setDown(wrap(x,i)) for i, obj in enumerate(self._base_players)]
1338
1239
 
1339
1240
    def setDamp(self, x):
1340
1241
        """
1348
1249
        """
1349
1250
        self._damp = x
1350
1251
        x, lmax = convertArgsToLists(x)
1351
 
        [obj.setDamp(wrap(x,i)) for i, obj in enumerate(self._main_players)]
 
1252
        [obj.setDamp(wrap(x,i)) for i, obj in enumerate(self._base_players)]
1352
1253
 
1353
1254
    def ctrl(self, map_list=None, title=None, wxnoserver=False):
1354
1255
        self._map_list = [SLMap(0., 1., "lin", "up", self._up),