def decode(file, error_correction=nocode, null_is_terminator=False, mode_1_bmp=False, number_of_chunks=STATIC_NUM_CHUNKS, use_header_chunk=False, id_len_format=ID_LEN_FORMAT, number_of_chunks_len_format=NUMBER_OF_CHUNKS_LEN_FORMAT, packet_len_format=PACKET_LEN_FORMAT, crc_len_format=CRC_LEN_FORMAT, read_all=READ_ALL_BEFORE_DECODER, distribution_cfg_str=""): dist = ErlichZielinskiRobustSolitonDistribution(number_of_chunks, seed=2) if distribution_cfg_str != "": # parse distribution_cfg_str and create distribution with the defined settings... splt = distribution_cfg_str.split("_") mode = splt[1] if mode == "ErlichZielinskiRobustSoliton": k = int(splt[2].split("=")[1]) delta = float(splt[3].split("=")[1]) c = float(splt[4].split("=")[1]) dist = ErlichZielinskiRobustSolitonDistribution(k, delta, c, seed=2) elif mode == "RobustSoliton": k = int(splt[2].split("=")[1]) delta = float(splt[3].split("=")[1]) dist = RobustSolitonDistribution(number_of_chunks, k, delta, seed=2) elif mode == "IdealSoliton": dist = IdealSolitonDistribution(number_of_chunks, seed=2) """try: decoder = LTBPDecoder(file, error_correction=error_correction, use_headerchunk=HEADER_CHUNK, static_number_of_chunks=STATIC_NUM_CHUNKS, implicit_mode=IMPLICIT_MODE, dist=dist) print("[1/2] Approximation Decode") _internal(decoder) if not decoder.is_decoded(): print("[2/2] Approximation Decode") _internal(decoder) decoder.saveDecodedFile(null_is_terminator=NULL_IS_TERMINATOR) except Exception as e:""" print("[X/2] Falling back to Gauss-Mode") print("Falling back to Gauss-Mode") decoder = LTDecoder(file, error_correction=error_correction, use_headerchunk=use_header_chunk, static_number_of_chunks=number_of_chunks, implicit_mode=IMPLICIT_MODE, dist=dist) decoder.read_all_before_decode = read_all decoder.decode(number_of_chunks_len_format=number_of_chunks_len_format, seed_len_format=id_len_format, degree_len_format="H") decoder.solve() decoder.saveDecodedFile(null_is_terminator=null_is_terminator, print_to_output=PRINT_TO_OUTPUT)
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 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 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 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 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 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")
def test_suite(as_dna, decoder_instance, distribution, use_header, implicit_mode): dir_path = os.getcwd() try: os.remove(dir_path + "/" + file) except: print("Not deleting, File did not exists") shutil.copyfile(dir_path + "/" + cmp_file, dir_path + "/" + file) chunksize = 200 number_of_chunks = Encoder.get_number_of_chunks_for_file_with_chunk_size( file, chunksize) pseudo_decoder = decoder_instance.pseudo_decoder(number_of_chunks) if distribution == "robust": dist = RobustSolitonDistribution(S=number_of_chunks, delta=0.2, seed=2) elif distribution == "ideal": dist = IdealSolitonDistribution(S=number_of_chunks, seed=2) else: dist = ErlichZielinskiRobustSolitonDistribution(k=number_of_chunks, delta=0.2, seed=2) rules = FastDNARules() if as_dna else None encoder = LTEncoder(file, number_of_chunks, dist, chunk_size=chunksize, pseudo_decoder=pseudo_decoder, rules=rules, insert_header=use_header, number_of_chunks_len_format="H", id_len_format="H", used_packets_len_format="H", implicit_mode=implicit_mode) encoder.encode_to_packets() encoder.save_packets(split_to_multiple_files=True, save_as_dna=as_dna) assert pseudo_decoder.is_decoded() and pseudo_decoder.getSolvedCount( ) == encoder.number_of_chunks assert os.path.exists(out_dir) decoder = decoder_instance(out_dir, use_headerchunk=use_header, dist=dist, implicit_mode=implicit_mode) 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 os.remove(file) decoder.saveDecodedFile(print_to_output=False) if not use_header: out_file = "DEC_LT_" + file else: out_file = file assert os.path.exists(out_file) and filecmp.cmp(out_file, cmp_file) if decoder_instance == LTBPDecoder: # since ApproxDecoder defines an upper bound Gauss-Decoder MUST be able to decode! decoder = LTDecoder(out_dir, use_headerchunk=use_header, dist=dist, implicit_mode=implicit_mode) 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) os.remove(out_file) decoder.saveDecodedFile(print_to_output=False) assert os.path.exists(out_file) and filecmp.cmp(out_file, cmp_file) shutil.rmtree(out_dir)