def blackboxTest(file,
number_of_chunks=800,
droprate=0.02,
seed=2,
overhead=0.05):
print("#### Starting Blackbox Test with " + str(number_of_chunks) +
" Chunks and a droprate of " + str(droprate) + " ####")
start = time.time()
dist = RobustSolitonDistribution(S=number_of_chunks, seed=seed)
# dist = IdealSolitonDistribution(S=number_of_chunks, seed=seed)
# pseudo = LTBPDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file, number_of_chunks,
dist) # , pseudo_decoder=pseudo)
decoder = LTDecoder.pseudo_decoder(number_of_chunks,
read_all_before_decode=True)
encoder.set_overhead_limit(overhead)
result, numberOfEncodedPackets, dropedCount, solvedCount = blackbox(
encoder, decoder, droprate=droprate)
end = time.time() - start
print("Blackbox-Decode " + ("successful" if result else "NOT successful") +
" after " + str(round(end, 4)) + " sec.")
return [
dist.get_config_string(),
result,
numberOfEncodedPackets,
dropedCount,
solvedCount,
round(end, 4),
number_of_chunks,
]
def blackboxTest(file, number_of_chunks=800, droprate=0.02, seed=2):
print(
"#### Starting Blackbox Test with "
+ str(number_of_chunks)
+ " Chunks and a droprate of "
+ str(droprate)
+ " ####"
)
start = time.time()
dist = IdealSolitonDistribution(number_of_chunks, seed)
pseudo = LTBPDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file, number_of_chunks, dist, pseudo_decoder=pseudo)
decoder = LTDecoder.pseudo_decoder(number_of_chunks)
result, numberOfEncodedPackets, dropedCount = blackbox(
encoder, decoder, droprate=droprate
)
end = time.time() - start
print(
"Blackbox-Decode "
+ ("successful" if result else "NOT successful")
+ " after "
+ str(round(end, 4))
+ " sec."
)
return ["LT", result, numberOfEncodedPackets, dropedCount, round(end, 4)]
def blackboxLTIdealTest(file,
number_of_chunks=800,
seed=2,
chunk_size=0,
overhead=0.20,
scale=1.0):
print(bcolors.OK + "Starting Blackbox Test with " + str(number_of_chunks) +
" Chunks" + bcolors.ENDC)
start = time.time()
dist = IdealSolitonDistribution(S=number_of_chunks, seed=seed)
algo_type.clear()
algo_type.append("LT_" + str(number_of_chunks) + "_" +
str(dist.get_config_string()))
encoder = LTEncoder(file, number_of_chunks, dist, chunk_size=chunk_size)
encoder.set_overhead_limit(overhead)
decoder = LTDecoder.pseudo_decoder(number_of_chunks)
decoder.set_read_all_before_decode(True)
result, dec_input, invalid_drop = blackbox(encoder, decoder, scale=scale)
end = time.time() - start
print(bcolors.BLUE + "Blackbox-Decode " +
(bcolors.OK + "successful" if result else bcolors.ERR +
"NOT successful") + bcolors.END + bcolors.BLUE + " after " +
str(round(end, 4)) + " sec." + bcolors.ENDC)
return [
dist.get_config_string(),
result,
number_of_chunks,
dec_input,
invalid_drop,
round(end, 4),
]
def init_dec(self):
"""
Gets the pseudodecoder based on the original class of the first packet in the packet list.
:return: Pseudodecoder
"""
packet = self.normal_packets[0]
if packet.get_org_class() == "RU10Packet":
return RU10Decoder.pseudo_decoder(packet.total_number_of_chunks)
elif packet.get_org_class() == "OnlinePacket":
return OnlineDecoder.pseudo_decoder(packet.total_number_of_chunks)
elif packet.get_org_class() == "Packet":
return LTDecoder.pseudo_decoder(packet.total_number_of_chunks)
def test_erlich_zielinski_dnarules():
dir_path = os.getcwd()
try:
os.remove(dir_path + "/DEC_" + out_dir2)
except:
print("Not deleting, File did not exists")
shutil.copyfile(dir_path + "/" + cmp_file2, dir_path + "/" + file2)
chunksize = 75
number_of_chunks = Encoder.get_number_of_chunks_for_file_with_chunk_size(
file2, chunksize)
pseudo_decoder = LTDecoder.pseudo_decoder(number_of_chunks)
dist = ErlichZielinskiRobustSolitonDistribution(k=number_of_chunks,
delta=0.2,
seed=2)
rules = DNARules_ErlichZielinski()
encoder = LTEncoder(file2,
number_of_chunks,
dist,
error_correction=reed_solomon_encode,
chunk_size=chunksize,
rules=rules,
insert_header=False,
number_of_chunks_len_format="H",
id_len_format="H",
used_packets_len_format="H",
pseudo_decoder=pseudo_decoder,
implicit_mode=True,
save_number_of_chunks_in_packet=False)
encoder.encode_to_packets()
encoder.save_packets(split_to_multiple_files=True, save_as_dna=True)
assert pseudo_decoder.is_decoded() and pseudo_decoder.getSolvedCount(
) == encoder.number_of_chunks
assert os.path.exists(out_dir2)
decoder = LTDecoder(out_dir2,
use_headerchunk=False,
dist=dist,
implicit_mode=True,
static_number_of_chunks=encoder.number_of_chunks,
error_correction=reed_solomon_decode)
decoder.decodeFolder(number_of_chunks_len_format="H",
seed_len_format="H",
degree_len_format="H")
assert decoder.is_decoded() and decoder.getSolvedCount(
) == encoder.number_of_chunks
decoder.saveDecodedFile(print_to_output=False, null_is_terminator=True)
out_file2 = "DEC_LT_" + file2
assert os.path.exists(out_file2) and filecmp.cmp(out_file2, cmp_file2)
os.remove(out_file2)
def blackboxLTTest(file, number_of_chunks=800, seed=2, chunk_size=0):
print("Starting Blackbox Test with " + str(number_of_chunks) + " Chunks")
start = time.time()
dist = RobustSolitonDistribution(S=number_of_chunks, seed=seed)
pseudo = LTBPDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file,
number_of_chunks,
dist,
pseudo_decoder=pseudo,
chunk_size=chunk_size)
decoder = LTDecoder.pseudo_decoder(number_of_chunks)
result, numberOfEncodedPackets, dropedCount = blackbox(encoder, decoder)
end = time.time() - start
print("Blackbox-Decode " + ("successful" if result else "NOT successful") +
" after " + str(round(end, 4)) + " sec.")
return [
dist.get_config_string(),
result,
numberOfEncodedPackets,
dropedCount,
round(end, 4),
number_of_chunks,
]
def main(file):
print("###### LT Codec number_of_chunks = 700 ######")
print("##### Ideal Soliton Distribution #####")
print("### LT without prioritized Packets ###")
start = time.time()
number_of_chunks = 700
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
encoder = LTEncoder(file, number_of_chunks, dist)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT without prioritized Packets with pseudo_decoder ###")
start = time.time()
number_of_chunks = 700
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
pseudo = LTBPDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file, number_of_chunks, dist, pseudo_decoder=pseudo)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT with prioritized Packets ###")
start = time.time()
number_of_chunks = 700
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
encoder = LTEncoder(file,
number_of_chunks,
dist,
prioritized_packets=[1, 3, 5])
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT with prioritized Packets AND pseudo_decoder ###")
start = time.time()
number_of_chunks = 700
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
pseudo = LTBPDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file,
number_of_chunks,
dist,
pseudo_decoder=pseudo,
prioritized_packets=[1, 3, 5])
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT with prioritized Packets AND Gauss-pseudo_decoder ###")
start = time.time()
number_of_chunks = 700
dist = IdealSolitonDistribution(number_of_chunks, seed=2)
pseudo = LTDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file,
number_of_chunks,
dist,
pseudo_decoder=pseudo,
prioritized_packets=[1, 3, 5])
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("##### Robust Soliton Distribution #####")
print("### LT without prioritized Packets ###")
start = time.time()
number_of_chunks = 700
dist = RobustSolitonDistribution(number_of_chunks, seed=2)
encoder = LTEncoder(file, number_of_chunks, dist)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT without prioritized Packets with Gauss-pseudo_decoder ###")
start = time.time()
number_of_chunks = 700
dist = RobustSolitonDistribution(number_of_chunks, seed=2)
pseudo = LTDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file, number_of_chunks, dist, pseudo_decoder=pseudo)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT with prioritized Packets ###")
start = time.time()
number_of_chunks = 700
dist = RobustSolitonDistribution(number_of_chunks, seed=2)
encoder = LTEncoder(file,
number_of_chunks,
dist,
prioritized_packets=[1, 3, 5])
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### LT with prioritized Packets AND Gauss-pseudo_decoder ###")
start = time.time()
number_of_chunks = 700
dist = RobustSolitonDistribution(number_of_chunks, seed=2)
pseudo = LTDecoder.pseudo_decoder(number_of_chunks)
encoder = LTEncoder(file,
number_of_chunks,
dist,
pseudo_decoder=pseudo,
prioritized_packets=[1, 3, 5])
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print(
"###### Online Codec - number_of_chunks = 2500, eps=0.01, quality=3 ######"
)
print("### Online without pseudo_decoder ###")
start = time.time()
number_of_chunks = 2500
epsilon = 0.01
quality = 3
dist = OnlineDistribution(epsilon)
# infer number_of_chunks form Distribution:
number_of_chunks = dist.get_size()
pseudo = OnlineBPDecoder.pseudo_decoder()
encoder = OnlineEncoder(file, number_of_chunks, dist, epsilon, quality)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")
print("### Online with pseudo_decoder ###")
start = time.time()
number_of_chunks = 2500
epsilon = 0.01
quality = 3
dist = OnlineDistribution(epsilon)
# infer number_of_chunks form Distribution:
number_of_chunks = dist.get_size()
pseudo = OnlineBPDecoder.pseudo_decoder()
encoder = OnlineEncoder(file,
number_of_chunks,
dist,
epsilon,
quality,
pseudo_decoder=pseudo)
encoder.encode_to_packets()
end = time.time() - start
print("Finished encoding after " + str(round(end, 4)) + " sec. " +
str(len(encoder.get_encoded_packets())) + " Packets encoded.\n")