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;
}
