def test_demarshalling(self):
original = (1, '1')
message = str(Framing.SimpleFrame(*original))
X = Framing.DeFramer()
X.activate()
X._deliver(message, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less!)
X.next()
result = X._collect("outbox")
self.assertEqual(original, result)
def test_marshalling_sequence(self):
X = Framing.Framer()
X.activate()
for i in xrange(100):
message = (i, str(i))
expect = str(Framing.SimpleFrame(*message))
X._deliver(message, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less!)
X.next()
result = X._collect("outbox")
self.assertEqual(expect, result)
def test_DeChunk_SingleChunk_ManyBlocks(self):
"The dechunker handles taking a chunk that's in many blocks and putting it back together"
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
message = "123\\S\4567\\890qwer\\\tyuiopasdfg\\\\hjklzxcvbnm\n" * 10
message += syncmessage
message += "1234567890q\\Swertyuiopasdfghjklzxcvbnm\n" * 10
chunk = self.makeBasicChunk(message, syncmessage)
X = Framing.DataDeChunker(syncmessage=syncmessage)
X.activate()
for block in self.blocks(chunk):
X._deliver(block, "inbox")
try:
for i in xrange(
200
): # More than sufficient cycles (should be lots less...)
X.next()
X._deliver("junk", "flush")
for i in xrange(
20
): # More than sufficient cycles (should be lots less...)
X.next()
result = X._collect("outbox")
except Framing.IncompleteChunk:
self.fail("IncompleteChunk exception should not propogate")
self.assertEqual(result, message)
def test_DeChunk_RandomChunk_ManyBlocks(self):
"The dechunker handles taking a chunk that's in many blocks and putting it back together"
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
message = ("".join([str(x) for x in xrange(10, 50)]) + "\n") * 10
chunk = self.makeBasicChunk(message, syncmessage)
X = Framing.DataDeChunker(syncmessage=syncmessage)
X.activate()
for block in self.blocks(chunk, blocksize=1):
X._deliver(block, "inbox")
try:
for i in xrange(
2000
): # More than sufficient cycles (should be lots less...)
X.next()
X._deliver("junk", "flush")
for i in xrange(
20
): # More than sufficient cycles (should be lots less...)
X.next()
result = X._collect("outbox")
except Framing.IncompleteChunk:
self.fail("IncompleteChunk exception should not propogate")
self.assertEqual(result, message)
def test_DeChunk_MultipleChunks_ManyBlocks(self):
"The dechunker handles taking many chunks that are in many blocks and putting it back together"
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
X = Framing.DataDeChunker(syncmessage=syncmessage)
X.activate()
for base in xrange(10, 1000, 50):
message = ("".join([str(x)
for x in xrange(base, base + 50)]) + "\n") * 10
chunk = self.makeBasicChunk(message, syncmessage)
for block in self.blocks(chunk, blocksize=1):
X._deliver(block, "inbox")
try:
for i in xrange(
2000
): # Run for a significant time period! (Chunk might be big)
X.next()
X._deliver("junk", "flush")
X.next()
result = X._collect("outbox")
except Framing.IncompleteChunk:
self.fail("IncompleteChunk exception should not propogate")
self.assertEqual(result, message)
def test_tuple2string_string2tuple_roundtrip_2(self):
"SimpleFrame.__str__, Framing.SimpleFrame.fromString - roundtrip for (50,'1111') succeeds"
original = (50, '1111')
Frame = Framing.SimpleFrame(*original)
FrameForWire = str(Frame)
result = Framing.SimpleFrame.fromString(FrameForWire)
self.assertEqual(original, result, "passed through unchanged")
def Framing_pcm(self):
self.pcm_framed=Framing.Framing(self.pcm, self.frame_size, self.interval)
self.frame_table=[]
for i in range(len(self.pcm_framed)):
temp=namedtuple('Status', ['Empty', 'UV'])
temp.Empty=False
temp.UV=0
self.frame_table.append(temp)
self.frame_LE=c.Log_Energy(self.pcm_framed)
def makeBasicChunk(self, message, syncmessage):
X = Framing.DataChunker(syncmessage=syncmessage)
X.activate()
X._deliver(message, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less!)
X.next()
result = X._collect("outbox")
return result
def test_tuple2string_6(self):
"SimpleFrame.__str__ - Random data of random length as the data part of the tuple succeeds"
import random
length = random.randrange(100, 200)
r = []
for x in xrange(length):
r.append(chr(random.randrange(0, 256)))
data = "".join(r)
Frame = Framing.SimpleFrame(50, data)
result = str(Frame)
self.assertEqual(result, "50 " + str(length) + "\n" + str(data))
def Separate(self):
Graph = c.GetDistance(self.Spec_g, th=5)
Graph_i = c.GetInclinations(Graph)
self.phonemes = []
### phonemes : list of namedtuple('phoneme', [point, UV, pcm_start, pcm_end])
for i in range(len(self.UV_list)):
if self.UV_list[i].UV == 'U':
# UV_list[i].start : end 에서 무조건 하나 가져옴
point = self.GetPointFromRange(Graph, self.UV_list[i].start, self.UV_list[i].end)
temp = namedtuple('phoneme', ['point', 'UV', 'pcm_start', 'pcm_end'])
temp.point = point
temp.UV = 'U'
self.phonemes.append(temp)
elif self.UV_list[i].UV == 'V':
# graph for문 돌면서 0인 구간 중 가운뎃값 가져옴
points = self.GetAllZeroPointFromRange(Graph, self.UV_list[i].start, self.UV_list[i].end)
if points==[]:
convexes = c.GetConvex_range(Graph_i, self.UV_list[i].start, self.UV_list[i].end)
if len(convexes)>0:
minindex = convexes[0]
minvalue = Graph[convexes[0]]
for j in range(len(convexes)):
if minvalue > Graph[convexes[j]]:
minvalue = Graph[convexes[j]]
minindex = convexes[j]
points.append(minindex)
for j in range(len(points)):
temp = namedtuple('phoneme', ['point', 'UV', 'pcm_start', 'pcm_end'])
temp.point = points[j]
temp.UV = 'V'
self.phonemes.append(temp)
### PostTreat : calculate p_start, p_end
for i in range(len(self.phonemes)):
f_start = Framing.Index_frame_to_origin(self.phonemes[i].point, self.frame_size, self.interval)
f_end = f_start + 2 * self.frame_size - self.interval
f_range = (f_start - f_end)
sectlen = int(0.05 * self.sample_rate)
p_start = f_start - int((sectlen - f_range) / 2) + 650
if p_start < 0:
p_start = 0
p_end = p_start + sectlen
if p_end >= len(self.pcmValue):
p_end = len(self.pcmValue) - 1
p_start = p_end - sectlen
self.phonemes[i].pcm_start = p_start
self.phonemes[i].pcm_end = p_end
def test_tuple2string_string2tuple_roundtrip_3(self):
"SimpleFrame.__str__, Framing.SimpleFrame.fromString - roundtrip for random data, frame id 50 succeeds"
import random
length = random.randrange(100, 200)
r = []
for x in xrange(length):
r.append(chr(random.randrange(0, 256)))
data = "".join(r)
original = (50, data)
Frame = Framing.SimpleFrame(*original)
FrameForWire = str(Frame)
result = Framing.SimpleFrame.fromString(FrameForWire)
self.assertEqual(original, result, "passed through unchanged")
def test_makeChunk(self):
message = "1234567890qwertyuiopasdfghjklzxcvbnm\n" * 20
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
X = Framing.DataChunker(syncmessage=syncmessage)
X.activate()
X._deliver(message, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less!)
X.next()
result = X._collect("outbox")
result_start = result[:len(syncmessage)]
result_message = result[len(syncmessage):]
self.assertEqual(message, result_message)
self.assertEqual(syncmessage, result_start)
def test_tuple2string_7(self):
"SimpleFrame.__str__ - Completely random frame"
import random
length = random.randrange(100, 200)
r = []
for x in xrange(length):
r.append(chr(random.randrange(0, 256)))
data = "".join(r)
stamp = random.randrange(0, 200)
Frame = Framing.SimpleFrame(stamp, data)
result = str(Frame)
self.assertEqual(result,
str(stamp) + " " + str(length) + "\n" + str(data))
def test_DeChunkFullChunk(self):
message = "1234567890qwertyuiopasdfghjklzxcvbnm\n" * 20
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
chunk = self.makeBasicChunk(message, syncmessage)
X = Framing.DataDeChunker(syncmessage=syncmessage)
X.activate()
X._deliver(chunk, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less...)
X.next()
X._deliver("junk", "flush")
for i in xrange(
20): # More than sufficient cycles (should be lots less...)
X.next()
result = X._collect("outbox")
self.assertEqual(result, message)
def test_makeChunk_oneSync(self):
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
message = "1234567890qwertyuiopasdfghjklzxcvbnm\n" * 10
message += syncmessage
message += "1234567890qwertyuiopasdfghjklzxcvbnm\n" * 10
X = Framing.DataChunker(syncmessage=syncmessage)
X.activate()
X._deliver(message, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less!)
X.next()
result = X._collect("outbox")
result_message = result[len(syncmessage):]
index = result_message.find(syncmessage)
self.assertEqual(
-1, index,
"Should not be able to find the syncmessage in the chunked version"
)
def Separate(self):
self.phonemes = []
### Case 1 : best case - UV detected successfully ###
if len(self.UV_list)==len(self.UV_txt):
for i in range(len(self.UV_list)):
points = self.Get_Points_from_Sector(self.UV_list[i].start, self.UV_list[i].end, len(self.UV_txt[i]), self.UV_list[i].UV)
for j in range(len(points)):
temp = namedtuple('phoneme',['point','label','pcm_start','pcm_end'])
temp.point = points[j]
temp.label = self.UV_txt[i][j]
if temp.label != 'S':
self.phonemes.append(temp)
### Case 2 : Number of Phonemes from whole sector is matched with Expected ###
### Case 3 : worst case - Timing matching
### PostTreat : calculate p_start, p_end
for i in range(len(self.phonemes)):
f_start = Framing.Index_frame_to_origin(self.phonemes[i].point,self.frame_size,self.interval)
f_end = f_start + 2 * self.frame_size - self.interval
f_range = (f_start-f_end)
sectlen = int(0.05*self.sample_rate)
#p_start = f_start - int((sectlen-f_range)/2)
#p_end = p_start + sectlen
p_start = f_start - int((sectlen-f_range)/2) + 650
if p_start < 0 :
p_start = 0
p_end = p_start + sectlen
if p_end >= len(self.pcm):
p_end = len(self.pcm)-1
p_start = p_end - sectlen
self.phonemes[i].pcm_start = p_start
self.phonemes[i].pcm_end = p_end
def test_non_aligned_chunk_blocks(self):
"The dechunker handles taking many chunks that are in many blocks and putting it back together"
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
X = Framing.DataDeChunker(syncmessage=syncmessage)
X.activate()
message = ("".join([str(x) for x in xrange(10, 60)]) + "\n") * 10
chunk = self.makeBasicChunk(message, syncmessage)
blockgen = self.blocks(chunk, blocksize=20)
for _ in xrange(5):
blockgen.next() # throw away first 5 blocks of a chunk
for block in blockgen: # This chunk, since it lacks a start should be ignored
X._deliver(block, "inbox")
# The next section assumes by the way the testing happens that the partial
# chunk above sent to the component is ignored - which is the desired
# behaviour we're testing
for base in xrange(10, 1000, 50):
message = ("".join([str(x)
for x in xrange(base, base + 50)]) + "\n") * 10
chunk = self.makeBasicChunk(message, syncmessage)
for block in self.blocks(chunk, blocksize=20):
X._deliver(block, "inbox")
try:
for i in xrange(
2000
): # Run for a significant time period! (Chunk might be big)
X.next()
X._deliver("junk", "flush")
X.next()
result = X._collect("outbox")
except Framing.IncompleteChunk:
self.fail("IncompleteChunk exception should not propogate")
self.assertEqual(result, message)
def test_marshalling(self):
X = Framing.Framer()
self.fail("Test Not Implemented")
def test_smokeTest(self):
X = Framing.DeFramer()
X.activate()
def test_smokeTest(self):
X = Framing.DataChunker()
X.activate()
def test_tuple2string_4(self):
"SimpleFrame.__str__ - (50,'1111') results in '50 4\\n1111'"
Frame = Framing.SimpleFrame(50, '1111')
result = str(Frame)
self.assertEqual(result, '50 4\n1111')
def Check_Empty_AVG(self):
self.frame_table[0].Empty = True
self.frame_table[0].UV = 0
self.frame_table[-1].Empty = True
self.frame_table[-1].UV = 0
self.sect_start = []
self.sect_end = []
for i in range(len(self.frame_table)-1):
if self.frame_table[i].Empty and not self.frame_table[i+1].Empty:
self.sect_start.append(i+1)
if not self.frame_table[i].Empty and self.frame_table[i+1].Empty:
self.sect_end.append(i+1)
i=0
while(i<len(self.sect_start)-1):
if (self.sect_start[i+1] - self.sect_end[i]) < 0.03*self.sample_rate/(self.frame_size-self.interval):
for j in range(self.sect_end[i], self.sect_start[i+1]):
self.frame_table[j].Empty = False
self.frame_table[j].UV = 2
del(self.sect_start[i+1])
del(self.sect_end[i])
else:
i+=1
selected_sect = 0
if not (len(self.sect_start)==1 and len(self.sect_end)==1):
self.avgSpec = []
for i in range(len(self.frame_table)):
sumSpec = 0
for j in range(len(self.Spec[i])):
sumSpec += self.Spec[i][j]
sumSpec /= len(self.Spec[0])
self.avgSpec.append(sumSpec)
selected_sect = 0
sect_value = -1
for i in range(len(self.sect_start)):
temp_sect = 0
for j in range(self.sect_start[i],self.sect_end[i]):
temp_sect += self.avgSpec[j]
if temp_sect > sect_value:
selected_sect = i
sect_value = temp_sect
for i in range(len(self.frame_table)):
if not i in range(self.sect_start[selected_sect], self.sect_end[selected_sect]):
self.frame_table[i].Empty = True
self.frame_table[i].UV = 0
###
for i in range(len(self.frame_table)-1):
if abs(self.frame_table[i].UV - self.frame_table[i+1].UV)==3:
self.frame_table[i].UV = 2
self.frame_table[i+1].UV = 2
#################################################3
allPoints = []
voicestart = Framing.Index_frame_to_origin(self.sect_start[selected_sect],self.frame_size,self.interval)
voiceend = Framing.Index_frame_to_origin(self.sect_end[selected_sect],self.frame_size,self.interval)
allPoints = Framing.Framing(self.pcmValue[voicestart:voiceend],800,0)
#allPoints = Framing.Framing(self.pcmValue[voicestart:voiceend],1600,800)
for i in range(len(allPoints)):
mfcclist = []
temp = psf.mfcc(np.array(allPoints[i]), samplerate=self.sample_rate, winlen=0.01, winstep=0.01, nfft=self.frame_size,numcep=12)
#temp = psf.mfcc(np.array(allPoints[i]), samplerate=self.sample_rate, winlen=0.02, winstep=0.02, nfft=self.frame_size,numcep=12)
for j in range(temp.shape[0]):
templist = []
for k in range(temp.shape[1]):
templist.append(temp[j][k])
mfcclist.append(templist)
self.allMFCC.append(mfcclist)
def test_tuple2string_2(self):
"SimpleFrame.__str__ - (1,'11') results in '1 2\\n11'"
Frame = Framing.SimpleFrame(1, '11')
result = str(Frame)
self.assertEqual(result, '1 2\n11')