BOOL write_in_fat_index(struct mfs_volume* volume, u32_t index, u64_t value) { struct mfs_sb_info sb; read_sb(volume, &sb); u32_t start_position = 0; u32_t end_position = 0; u128 write_position = 0; start_position = (sb.fat_sector * sb.bytes_per_sector); end_position = (sb.fat_sector + (sb.sectors_of_fat * sb.copies_of_fat)) * sb.bytes_per_sector; // Volume에 적을 위치를 계산한다. FAT Begin Address + FAT Index Address(Index - 2는 Index 0,1은 쓰이지 않기 때문이다. 시작이 2부터이다.) write_position = start_position + (sb.fat_index_size * (index - 2)); if(write_position > end_position) return FALSE; #ifdef __KERNEL__ seek_volume(volume, write_position); #else seek_volume(volume, write_position, SEEK_SET); #endif write_volume(volume, &value, sizeof(sb.fat_index_size), 1); return TRUE; }
static void make_fat_index(struct mfs_volume* volume, struct mfs_sb_info* sb, u32_t index, u64_t size) { u8_t first_sector[BYTES_PER_SECTOR] = {0, }; u32_t start_position = 0; u32_t end_position = 0; u128 index_position = 0; if(volume == NULL) { printf("ERROR: Volume is empty!\n"); exit(1); } seek_volume(volume, 0, SEEK_SET); read_volume(volume, first_sector, sizeof(u8_t), sizeof(first_sector)); start_position = (sb->fat_sector * sb->bytes_per_sector); end_position = (sb->fat_sector + (sb->sectors_of_fat * sb->copies_of_fat)) * sb->bytes_per_sector; // Volume에 적을 위치를 계산한다. FAT Begin Address + FAT Index Address(Index - 2는 Index 0,1은 쓰이지 않기 때문이다. 시작이 2부터이다.) index_position = start_position + (sb->fat_index_size * (index - 2)); if (index_position > end_position) { printf("ERROR: Can't create a file allocation table index!\n"); exit(1); } seek_volume(volume, index_position, SEEK_SET); write_volume(volume, &size, sizeof(u32_t), 1); }
void process_square( volume_ptr<uint32_t> gt_ptr, affinity_graph_ptr<float> aff, std::size_t atlow, std::size_t at1, const std::string& fname ) { volume_ptr<uint32_t> segg ; std::vector<std::size_t> counts; { std::tie(segg, counts) = watershed<uint32_t>(aff, 0.3, 0.99); auto rg = get_region_graph(aff, segg, counts.size()-1); merge_segments_with_function (segg, rg, counts, square_fn(0.3, atlow, at1), 100); write_volume(fname + ".dat", segg); } { std::tie(segg, counts) = watershed<uint32_t>(aff, 0.3, 0.99); auto rg = get_region_graph(aff, segg, counts.size()-1); auto r = reduce(merge_segments_with_function_err (segg, gt_ptr, rg, counts, square_fn(0.3, atlow, at1), 100)); write_to_file(fname + "_pr.dat", r.data(), r.size()); } }
void process_felzenszwalb( volume_ptr<uint32_t> gt_ptr, affinity_graph_ptr<float> aff, double k, const std::string& fname ) { auto seg = felzenszwalb<uint32_t>(aff, k); write_volume(fname + ".dat", seg); auto prc = reduce(felzenszwalb_err(gt_ptr, aff, k)); write_to_file(fname + "_pr.dat", prc.data(), prc.size()); }
static void make_data_cluster(struct mfs_volume* volume, u128 volume_size, u128 cluster_size) { pu8_t buf = (pu8_t) malloc(cluster_size); memset(buf, 0, cluster_size); for (u32_t i = 1; i <= (volume_size / cluster_size); i++) { write_volume(volume, buf, sizeof(u8_t), cluster_size); } free(buf); }
static void create_volume(struct mfs_volume* new_volume, ps8_t volume_name, u128 volume_size, u128 cluster_size) { u8_t first_sector[BYTES_PER_SECTOR] = {0, }; if (volume_name == NULL) { volume_name = ""; } if (new_volume == NULL) { printf("ERROR: Volume is empty!\n"); exit(1); } make_data_cluster(new_volume, volume_size, cluster_size); struct mfs_sb_info* sb = (struct mfs_sb_info *) first_sector; initialize_sb(sb, volume_name, volume_size); seek_volume(new_volume, 0, SEEK_SET); write_volume(new_volume, sb, sizeof(u8_t), sizeof(struct mfs_sb_info)); make_fat(new_volume, sb, sb->fat_index_size); // Read Dump SQLite FILE *fp; u32_t total_size; u32_t n_size; fp = fopen("./test.db", "r"); fseek(fp, 0, SEEK_END); total_size = ftell(fp); fseek(fp, 0, SEEK_SET); char* buff = (char *) malloc(total_size); while(1) { n_size = fread(buff, sizeof(u8_t), total_size, fp); if(n_size <= 0){ break; } } // File Content Write create_dummy(new_volume, "/", "test.db", buff, total_size, 0); // write_sqlite_file(new_volume, "/", "test2.db", buff, 0, total_size); // write_sqlite_file(new_volume, "/", "test3.db", buff, 0, total_size); // write_sqlite_file(new_volume, "/", "test4.db", buff, 0, total_size); // write_sqlite_file(new_volume, "/", "test5.db", buff, 0, total_size); // read_sqlite_file(new_volume, "/", "test1.db"); // SQLite Dummy Buffer Free free(buff); fclose(fp); printf("\n\n\n"); }
BOOL alloc_new_entry(struct mfs_volume* volume, u128 dir_cluster_number, ps16_t file_name, struct mfs_dirent* searched_dentry) { u8_t cluster[CLUSTER_SIZE] = {0, }; const u32_t entry_per_data_cluster = CLUSTER_SIZE / sizeof(struct mfs_dirent); s16_t composited_file_name[128] = {0, }; BOOL has_long_file_name_next_entry = FALSE; u128 read_position = 0; u128 current_cluster_number = dir_cluster_number; u32_t current_entry_number = 0; struct mfs_dirent* current_dentry = NULL; u128 end_cluster = get_end_cluster(volume); // 디렉토리의 모든 클러스터를 검사한다. while(current_cluster_number != end_cluster) { read_position = read_cluster(volume, current_cluster_number); #ifdef __KERNEL__ seek_volume(volume, read_position); #else seek_volume(volume, read_position, SEEK_SET); #endif read_volume(volume, cluster, sizeof(u8_t), CLUSTER_SIZE); current_dentry = get_first_entry(cluster, ¤t_entry_number, has_long_file_name_next_entry); printf("alloc_new_entry current_cluster_number: %d\n", current_cluster_number); while(current_entry_number != entry_per_data_cluster) { if(is_normal_file(current_dentry->attribute) == TRUE) { // 얻은 엔트리가 LongFileName인지 여부 검사 if(is_long_file_name(current_dentry->attribute) == TRUE) { // LongFileName일 경우 LongFileName을 조합한다. composite_long_file_name(volume, current_cluster_number, current_entry_number, composited_file_name); } else { // 일반 FileName일 경우 복사 strcpy(composited_file_name, current_dentry->name); } // Name 비교 if(!strcmp(file_name, composited_file_name)) { memcpy(current_dentry, searched_dentry, sizeof(struct mfs_dirent)); #ifdef __KERNEL__ seek_volume(volume, read_position); #else seek_volume(volume, read_position, SEEK_SET); #endif write_volume(volume, cluster, sizeof(u8_t), CLUSTER_SIZE); printf("mfs inner dentry update\n"); return TRUE; } } // 다음 엔트리를 얻는다. current_dentry = get_next_entry(cluster, ¤t_entry_number, &has_long_file_name_next_entry); } current_cluster_number = read_fat_index(volume, current_cluster_number); } return FALSE; }
/* 함수명 : writeDirEntryInDirCluster 하는일 : 디렉토리 클러스터안에 디렉토리 엔트리를 추가한다. 디렉토리의 모든 클러스터를 검사하여, 빈 엔트리를 찾고 그 위치에 디렉토리 엔트리를 추가한다. 인자 : fVolume : 루프백이미지/파일 볼륨의 포인터 nDirClusterNumber : 디렉토리 클러스터 번호 pDirectoryEntry : 디렉토리 엔트리의 포인터 pFileName : 파일 이름의 문자열 포인터 리턴 값 : BOOL */ BOOL alloc_new_dirent(struct mfs_volume* volume, u128 dir_cluster_number, struct mfs_dirent* dirent, ps16_t file_name) { u8_t cluster[CLUSTER_SIZE] = {0, }; const u32_t entry_per_data_cluster = CLUSTER_SIZE / sizeof(struct mfs_dirent); BOOL has_long_file_name_next_entry = FALSE; u128 read_position = 0; u128 wirte_position = 0; u128 current_cluster_number = dir_cluster_number; u128 before_cluster_number = 0; u32_t current_entry_number = 0; struct mfs_dirent* current_dirent = NULL; u128 end_cluster = get_end_cluster(volume); // 디렉토리의 모든 클러스터를 검사한다. while(current_cluster_number != end_cluster) { read_position = read_cluster(volume, current_cluster_number); #ifdef __KERNEL__ seek_volume(volume, read_position); #else seek_volume(volume, read_position, SEEK_SET); #endif read_volume(volume, cluster, sizeof(u8_t), CLUSTER_SIZE); current_dirent = get_first_entry(cluster, ¤t_entry_number, has_long_file_name_next_entry); while(current_entry_number != entry_per_data_cluster) { // if (current_dirent->size == 0) if( is_deleted_file(current_dirent->attribute) || is_deleted_dir(current_dirent->attribute) ) { wirte_position = read_position + (current_entry_number * sizeof(struct mfs_dirent)); #ifdef __KERNEL__ seek_volume(volume, wirte_position); #else seek_volume(volume, wirte_position, SEEK_SET); #endif write_volume(volume, dirent, sizeof(struct mfs_dirent), 1); printf("alloc_new_dirent %d %d\n", current_cluster_number, wirte_position); return TRUE; } // 다음 엔트리를 얻는다. current_dirent = get_next_entry(cluster, ¤t_entry_number, &has_long_file_name_next_entry); } before_cluster_number = current_cluster_number; current_cluster_number = read_fat_index(volume, current_cluster_number); } // 디렉토리 클러스터에 빈 공간이 없다, 클러스터 추가 current_cluster_number = find_empty_fat_index(volume); write_in_fat_index(volume, before_cluster_number, current_cluster_number); write_in_fat_index(volume, current_cluster_number, end_cluster); wirte_position = read_cluster(volume, current_cluster_number); #ifdef __KERNEL__ seek_volume(volume, wirte_position); #else seek_volume(volume, wirte_position, SEEK_SET); #endif write_volume(volume, dirent, sizeof(struct mfs_dirent), 1); printf("alloc_new_dirent %d %d\n", current_cluster_number, wirte_position); return TRUE; }
int main() { // load the ground truth and the affinity graph volume_ptr<uint32_t> gt_ptr = read_volume<uint32_t>("./data/gt.in", 256); affinity_graph_ptr<float> aff = read_affinity_graph<float>("./data/ws_test_256.raw", 256, 256, 256); if ( 1 ) { volume_ptr<uint32_t> seg ; std::vector<std::size_t> counts; std::tie(seg, counts) = watershed<uint32_t>(aff, -1, 2); write_volume("./experiments/watershed/basic.out", seg); std::tie(seg, counts) = watershed<uint32_t>(aff, 0.1, 0.99); write_volume("./experiments/watershed/minmax.out", seg); // { // std::tie(segg, counts) = watershed<uint32_t>(aff, 0.3, 0.99); // auto rg = get_region_graph(aff, segg, counts.size()-1); // merge_segments_with_function(segg, rg, // counts, limit_fn2, 100); // write_volume("./experiments/voutall.out", segg); // } //return 0; } // // Linear // if ( 1 ) { std::vector<double> r; for ( std::size_t thold = 200; thold <= 100000; thold += 100 ) { if ( thold > 1000 ) thold += 900; if ( thold > 10000 ) thold += 9000; //double k = static_cast<double>(thold) / 1000; std::cout << "THOLD: " << thold << "\n"; volume_ptr<uint32_t> seg ; std::vector<std::size_t> counts; { std::tie(seg , counts) = watershed<uint32_t>(aff, 0.3, 0.99); auto rg = get_region_graph(aff, seg , counts.size()-1); merge_segments_with_function (seg, rg, counts, linear(thold), 10); write_volume("experiments/linear/" + std::to_string(thold) + ".dat", seg); auto x = compare_volumes(*gt_ptr, *seg, 256); r.push_back(x.first); r.push_back(x.second); } write_to_file("experiments/linear.dat", r.data(), r.size()); } //return 0; } // // Square // if ( 1 ) { std::vector<double> r; for ( std::size_t thold = 200; thold <= 100000; thold += 100 ) { if ( thold > 1000 ) thold += 900; if ( thold > 10000 ) thold += 9000; std::cout << "THOLD: " << thold << "\n"; volume_ptr<uint32_t> seg ; std::vector<std::size_t> counts; { std::tie(seg , counts) = watershed<uint32_t>(aff, 0.3, 0.99); auto rg = get_region_graph(aff, seg , counts.size()-1); merge_segments_with_function (seg, rg, counts, square(thold), 10); write_volume("experiments/square/" + std::to_string(thold) + ".dat", seg); auto x = compare_volumes(*gt_ptr, *seg, 256); r.push_back(x.first); r.push_back(x.second); } write_to_file("experiments/square.dat", r.data(), r.size()); } // return 0; } // // Felzenszwalb implementation // if ( 1 ) { std::vector<double> r; for ( std::size_t thold = 100; thold <= 50000; thold += 100 ) { if ( thold > 1000 ) thold += 900; if ( thold > 10000 ) thold += 9000; double k = static_cast<double>(thold) / 1000; auto seg = felzenszwalb<uint32_t>(aff, k); write_volume("experiments/felzenszwalb/" + std::to_string(k) + ".dat", seg); auto x = compare_volumes(*gt_ptr, *seg, 256); r.push_back(x.first); r.push_back(x.second); } write_to_file("experiments/felzenszwalb.dat", r.data(), r.size()); } // // simple thold fn // if ( 1 ) { std::vector<double> r; for ( std::size_t thold = 100; thold <= 50000; thold += 100 ) { if ( thold > 1000 ) thold += 900; if ( thold > 10000 ) thold += 9000; std::cout << "THOLD: " << thold << "\n"; volume_ptr<uint32_t> seg ; std::vector<std::size_t> counts; { std::tie(seg , counts) = watershed<uint32_t>(aff, 0.3, 0.99); auto rg = get_region_graph(aff, seg , counts.size()-1); merge_segments_with_function (seg, rg, counts, const_above_threshold(0.3, thold), 100); write_volume("experiments/threshold/" + std::to_string(thold) + ".dat", seg); auto x = compare_volumes(*gt_ptr, *seg, 256); r.push_back(x.first); r.push_back(x.second); } } write_to_file("experiments/threshold.dat", r.data(), r.size()); } return 0; volume_ptr<uint32_t> segg ; std::vector<std::size_t> counts; std::tie(segg, counts) = watershed<uint32_t>(aff, -1, 2); write_volume("voutraw.out", segg); for ( float low = 0.01; low < 0.051; low += 0.01 ) { for ( float high = 0.998; high > 0.989; high -= 0.002 ) { // std::tie(segg, counts) = watershed<uint32_t>(aff, low, high); // write_volume("vout." + std::to_string(low) + "." + // std::to_string(high) + ".out", segg); } } std::tie(segg, counts) = watershed<uint32_t>(aff, 0.5, 2); write_volume("voutmax.out", segg); std::tie(segg, counts) = watershed<uint32_t>(aff, 0.3, 0.99); write_volume("voutminmax.out", segg); // return 0; // auto rg = get_region_graph(aff, segg, counts.size()-1); // //yet_another_watershed(segg, rg, counts, 0.3); // //write_volume("voutanouther.out", segg); // merge_segments_with_function(segg, rg, counts, limit_fn3, 100); // write_volume("voutdo.out", segg); auto rg = get_region_graph(aff, segg, counts.size()-1); //yet_another_watershed(segg, rg, counts, 0.3); //write_volume("voutanouther.out", segg); auto r = merge_segments_with_function_err(segg, gt_ptr, rg, counts, limit_fn2, 100); write_to_file("./experiments/custom/precision_recall.dat", r.data(), r.size()); write_volume("voutall4x.out", segg); return 0; write_region_graph("voutall.rg", *rg); auto mt = get_merge_tree(*rg, counts.size()-1); write_region_graph("voutall.mt", *mt); return 0; }