virtual void SetUp() {
read_data_file("140712_003331.txt", m_X);
read_data_file("140712_064332.txt", m_Y);
read_data_file("140712_064332_rigid.txt", m_Y_rigid);
read_data_file("140712_064332_nonrigid_lowrank.txt",
m_Y_nonrigid_lowrank);
}
void
verify_results(vector_t x[], vector_t v[], const char lang[])
{
char fname[256], qx[256], qv[256], verif[256];
vector_t xT[N], vT[N];
data_t m[N], ex, ev;
if (pid != 0) return;
sprintf(fname, "%s/%d/%s/result%d.dat", data_dir, N, lang, prob_no);
if ((!random_flag || fixed_flag) && read_data_file(fname, m, xT, vT)) {
ex = quality_index(xT, x);
ev = quality_index(vT, v);
sprintf(qx, "%.1e", ex);
sprintf(qv, "%.1e", ev);
strcpy(verif,
finite_func(ex) && ex < epsilon &&
finite_func(ev) && ev < epsilon ? "Successful" : "FAILED");
}
else {
strcpy(qx, "N/A");
strcpy(qv, "N/A");
strcpy(verif, "not performed");
}
printf("\n*** Overall results ***\n"
"# of processes: %d\n"
"Quality index (2-norm) of x: %s\n"
"Quality index (2-norm) of v: %s\n"
"Verification: %s\n",
nprocs, qx, qv, verif);
}
static void
read_autodetect_file(const char * filename)
{
int binary = 0, c;
FILE *file;
file = fopen (filename, "r");
if (file == NULL) {
fprintf (stderr, "Failed to open %s: %s\n",
filename, strerror (errno));
exit (1);
}
while ((c = fgetc(file)) != EOF) {
/* totally lazy binary detector */
if (c < 10) {
binary = 1;
break;
}
}
fclose(file);
if (binary == 1)
read_bin_file(filename);
else
read_data_file(filename);
}
int main(int argc,char *argv[]) {
double value;
int i_start,n_points;
if (argc != 3) {
fprintf(stderr,"%s <input file> <value>\n",argv[0]);
exit(1);
}
n_points = read_data_file(argv[1],&data);
fprintf(stderr,"Read %d points from data file %s\n",n_points,argv[1]);
value = atof(argv[2]);
i_start = 0;
while (i_start < n_points - 3) {
if ((data[i_start + 1].y - value) * (data[i_start + 2].y - value) < 0.0) {
#ifdef NEWTON
find_newton_inverse_coeffs(4,data + i_start);
#endif
#ifdef LAGRANGE
printf("%.8g %.8g\n",lagrange_inverse(4,data + i_start,value),value);
#endif
#ifdef NEWTON
printf("%.8g %.8g\n",newton_inverse(4,data + i_start,value),value);
#endif
}
i_start++;
}
exit(0);
}
/**
* 주어진 argv를 이용해서 config파일을 오픈하는 함수입니다.
*/
void file_open(char **argv)
{
char* file_name;
file_name = strdup(argv[1]);
argv_file = fopen(file_name,"r");
if (argv_file == NULL)
{
fprintf(stderr,"failed to load data file ‘%s’\n",file_name);
return;
}
//먼저 data파일의 줄 갯수를 셉니다.
read_new_line_letter(argv_file);
//data파일의 내용을 읽고 적절하게 파싱해서 실행하고 스케쥴링할 프로그램의 데이터를 구합니다.
read_data_file();
//이제 각 알고리즘마다 한번씩 검사합니다.
printf("\n[SJF]\n");
process_run(SJF);
printf("\n[SRT]\n");
process_run(SRT);
printf("\n[RR]\n");
process_run(RR);
printf("\n[PR]\n");
process_run(PR);
}
int main(int argc, char** argv)
{
vector<string> feats;
vector<string> data;
size_t min_samples;
read_feature_file(argv[1], feats);
read_data_file(argv[2], data);
min_samples = atoi(argv[2]);
cart dc(feats, data, min_samples);
tree_node* root = dc.gen_subtree();
traverse(root, feats);
return 0;
}
int main(){
int menu=0;
List* user_list = (List*)malloc(sizeof(List));
tweetList* word_list = (tweetList*)malloc(sizeof(tweetList));
//list_init(user_list);
while(menu!=99){
puts("\t***************\t Menu \t*****************");
puts("\t0. Read data files");
puts("\t1. display statistics");
puts("\t2. Top 5 most tweeted words");
puts("\t3. Top 5 most tweeted users");
puts("\t4. Find users who tweeted a word (e.g., ’연세대’)");
puts("\t5. Find all people who are friends of the above users");
puts("\t6. Delete all mentions of a word");
puts("\t7. Delete all users who mentioned a word");
puts("\t8. Find strongly connected components");
puts("\t9. Find shortest path from a given user");
printf("\t99. Quit\n");
puts("\t********************************************");
printf("Select menu : ");
scanf("%d", &menu);
switch(menu){
case 0:
read_data_file(user_list, word_list);
break;
case 1:
display_stats(user_list, word_list);
break;
case 99:
printf("Quit this program.\n");
return;
default:
puts("Wrong Input!\n. Select menu again.");
}
}
return 0;
}
void
load_data(data_t m[], vector_t x[], vector_t v[])
{
char fname[256], pname[256];
#ifdef USE_RANDOM_DATA
random_flag = 1;
#endif
#ifdef USE_FIXED_DATA
fixed_flag = 1;
#endif
set_seed();
if (!random_flag) {
if (!fixed_flag) prob_no = rand_func()%nprobs;
sprintf(fname, "%s/%d/prob%d.dat", data_dir, N, prob_no);
if (!read_data_file(fname, m, x, v)) random_flag = 1;
}
if (random_flag) {
if (fixed_flag) prob_no = nprobs;
generate_mass_array(m);
generate_vector_array(x);
generate_vector_array(v);
}
if (pid == 0) {
if (!random_flag || fixed_flag)
sprintf(pname, "%d", prob_no);
else
strcpy(pname, "random");
printf("\n*** Simulation parameters ***\n"
"Number of particles: %d\n"
"Number of time steps: %d\n"
"Interval of time steps: %.1g\n"
"Data set No.: %s\n",
N, T, DT, pname);
}
}
int
main (int argc, char *argv[])
{
uint32_t devid = 0xa011;
char *devid_str = NULL;
int i, c;
int option_index = 0;
int binary = -1;
static struct option long_options[] = {
{"devid", 1, 0, 'd'},
{"ascii", 0, 0, 'a'},
{"binary", 0, 0, 'b'},
{ 0 }
};
devid_str = getenv("INTEL_DEVID_OVERRIDE");
while((c = getopt_long(argc, argv, "ad:b",
long_options, &option_index)) != -1) {
switch(c) {
case 'd':
devid_str = optarg;
break;
case 'b':
binary = 1;
break;
case 'a':
binary = 0;
break;
default:
printf("unkown command options\n");
break;
}
}
if (devid_str)
devid = strtoul(devid_str, NULL, 0);
ctx = drm_intel_decode_context_alloc(devid);
if (optind == argc) {
fprintf(stderr, "no input file given\n");
exit(-1);
}
for (i = optind; i < argc; i++) {
/* For stdin input, let's read as data file */
if (!strcmp(argv[i], "-")) {
read_data_file(argv[i]);
continue;
}
if (binary == 1)
read_bin_file(argv[i]);
else if (binary == 0)
read_data_file(argv[i]);
else
read_autodetect_file(argv[i]);
}
return 0;
}
int main(int argc, char *argv[]) {
int c;
static struct option long_options[] = {
{ "help", no_argument, 0, 'h'},
{ "file", required_argument, 0, 'f'},
{ "layout", required_argument, 0, 'l'},
{ "bsize", required_argument, 0, 'b'},
{ "chunk", required_argument, 0, 'c'},
{ "blockNumber", required_argument, 0, 'n'},
{ 0, 0, 0, 0}
};
// Get utility name
utility_name = basename(argv[0]);
rozofs_layout_initialize();
while (1) {
int option_index = 0;
c = getopt_long(argc, argv, "hH:f:l:b:c:n:", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'h':
usage();
exit(EXIT_SUCCESS);
break;
break;
case 'f':
filename[nb_file++] = optarg;
break;
case 'l':
{
int ret;
ret = sscanf(optarg,"%d", &layout);
if (ret <= 0) {
fprintf(stderr, "dataReader failed. Bad layout: %s %s\n", optarg,
strerror(errno));
exit(EXIT_FAILURE);
}
}
break;
case 'c':
{
int ret;
ret = sscanf(optarg,"%d", &firstBlock);
if (ret <= 0) {
fprintf(stderr, "dataReader failed. Bad chunk number: %s %s\n", optarg,
strerror(errno));
exit(EXIT_FAILURE);
}
}
break;
case 'n':
{
int ret;
ret = sscanf(optarg,"%d", &block_number);
if (ret < 0) {
fprintf(stderr, "dataReader failed. Bad block number: %s %s\n", optarg,
strerror(errno));
exit(EXIT_FAILURE);
}
}
break;
case 'b':
{
int ret;
ret = sscanf(optarg,"%d", &bsize);
if (ret < 0) {
fprintf(stderr, "dataReader failed. Bad block size: %s %s\n", optarg,
strerror(errno));
exit(EXIT_FAILURE);
}
}
break;
case '?':
usage();
exit(EXIT_SUCCESS);
break;
default:
usage();
exit(EXIT_FAILURE);
break;
}
}
openlog("dataReader", LOG_PID, LOG_DAEMON);
/*
** Check parameter consistency
*/
if (nb_file == 0){
fprintf(stderr, "dataReader failed. Missing --file option.\n");
exit(EXIT_FAILURE);
}
bbytes = ROZOFS_BSIZE_BYTES(bsize);
if (bbytes < 0) {
fprintf(stderr, "bad block size: %d\n", bsize);
exit(EXIT_FAILURE);
}
firstBlock *= ROZOFS_STORAGE_NB_BLOCK_PER_CHUNK(bsize);
// Start rebuild storage
if (read_data_file() != 0) goto error;
exit(EXIT_SUCCESS);
error:
exit(EXIT_FAILURE);
}
int main(void)
{
FILE *config,*data;
if(!(config = fopen(CONFIG_FILE,"r")))
{
printf("error while reading config file\n");
exit(-1);
}
//todo:create init function
MAC* mac_p = (MAC*)malloc(sizeof(*mac_p));
MAC* mac_head = mac_p; //head(the first) node does not store data
mac_head->next = NULL;
mac_p = mac_head;
if(!read_config(config,&mac_p))
{
printf("error while reading config\n");
exit(-1);
}
fclose(config);
//here you should sort mac address!!!
//this is the mac_address link test
printf("%s\n",mac_head->next->next->next->mac_address );
//mac_p = mac_head->next->next;
//sort_mac_address(&mac_p);
//print_config_to_file(mac_head);
//test end
if(!(data = fopen(DATA_FILE,"r+")))
{
printf("error while reading data file\n");
exit(-1);
}
STUDENT_INFO* info_p = (STUDENT_INFO*)malloc(sizeof(*info_p));
STUDENT_INFO* info_head = info_p;
info_head->next = NULL;
info_p = info_head;
read_data_file(data, &info_p);
//this is the stu_info link test
/*STUDENT_INFO* test2 = info_head->next;
printf("link test2!\n");
while(test2!=NULL)
{
printf("student info faculty is %s\n",test2->faculty);
printf("student info id is %s\n",test2->id);
printf("student info name is %s\n",test2->name);
test2 = test2->next;
}*/
//test end
//begin handle data(struct slice):
//todo:init func
SESSION* session_head = (SESSION*)malloc(sizeof(*session_head));
session_head->next = NULL;
SESSION* session_p = session_head;
return 0;
}
int main(int argc, char **argv){
size_t num_resampled_elements = PFA_NOUT_AZIMUTH * PFA_NOUT_RANGE;
complex **resampled = new complex*[PFA_NOUT_AZIMUTH];
complex **data = new complex*[N_PULSES];
double **input_coords = new double*[PFA_NOUT_RANGE];
for(int p=0;p<N_PULSES;p++){
*(data+p) = new complex[PFA_NOUT_RANGE];
}
for(int p=0;p<PFA_NOUT_AZIMUTH;p++){
*(resampled+p) = new complex[PFA_NOUT_RANGE];
}
for(int p=0;p<PFA_NOUT_RANGE;p++){
*(input_coords+p) = new double[N_PULSES];
}
float *window = new float[T_PFA];
double *output_coords = new double[PFA_NOUT_AZIMUTH];
complex *gold_resampled = new complex[num_resampled_elements];
size_t num_sw = PFA_NOUT_AZIMUTH/WIN_SIZE;
read_kern2_data_file(
data,
input_coords,
output_coords,
window);
fprintf(stderr,"end read in input data\n");
read_data_file(
(char *) gold_resampled,
sizeof(complex)*num_resampled_elements);
struct timeval tim1,tim2;
#ifdef serial
fprintf(stderr,"serial version start\n");
gettimeofday(&tim1, NULL);
for(size_t col=0;col<PFA_NOUT_RANGE;col++){
sar_interp2_col(
col,
num_sw,
resampled,
data,
window,
input_coords,
output_coords);
}
gettimeofday(&tim2, NULL);
fprintf(stderr,"serial version end\n");
#endif
#ifdef parallel
fprintf(stderr,"parallel version start\n");
gettimeofday(&tim1, NULL);
ar::simt_tau::par_for(PFA_NOUT_RANGE, [&](size_t col) {
sar_interp2_col(col,num_sw,resampled,data,window,input_coords,output_coords);
});
gettimeofday(&tim2, NULL);
fprintf(stderr,"parallel version end\n");
#endif
double t1=tim1.tv_sec+(tim1.tv_usec/1000000.0);
double t2=tim2.tv_sec+(tim2.tv_usec/1000000.0);
fprintf(stderr,"interp1@@@ %f seconds elapsed\n", t2-t1);
#ifdef WRITEtoFILE
FILE *wbfp=fopen("interp2.wb","wb");
for(size_t p=0;p<PFA_NOUT_AZIMUTH;p++)
fwrite(*(resampled+p), sizeof(complex), PFA_NOUT_RANGE, wbfp);
fclose(wbfp);
#endif
double snr = calculate_snr((complex *) gold_resampled,resampled);
fprintf(stderr,"snr=%f\n",snr);
for(int p=0;p<N_PULSES;p++){
delete[] *(data+p);
}
for(int p=0;p<PFA_NOUT_AZIMUTH;p++){
delete[] *(resampled+p);
}
for(int p=0;p<PFA_NOUT_RANGE;p++){
delete[] *(input_coords+p);
}
delete[] data;
delete[] resampled;
delete[] window;
delete[] input_coords;
delete[] output_coords;
delete[] gold_resampled;
}
/*read the data contain in the file
*/
int32_t macsim_read(GenericReader_T* genreader,glu_item_t* item)
{
char data_var[LG_MAX_STRING_MACSIM];
uint32_t indice_data=0,
rep=EOF,
dimension=0;
uint8_t continuer=1;
TSP_sample_symbol_info_list_t ssi_list;
ssi_list=*genreader->ssi_list;
if(NULL!=genreader->handler->file)
{
/*TYPE_CHAR or TYPE_UCHAR is a string of LG_MAX_STRING_MACSIM length */
if( (TSP_TYPE_CHAR==ssi_list.TSP_sample_symbol_info_list_t_val[item->provider_global_index].type)
|| (TSP_TYPE_UCHAR==ssi_list.TSP_sample_symbol_info_list_t_val[item->provider_global_index].type) )
{
item->size=ssi_list.TSP_sample_symbol_info_list_t_val[item->provider_global_index].dimension;
/*calculate the real dimension for the string symbol*/
dimension=ssi_list.TSP_sample_symbol_info_list_t_val[item->provider_global_index].dimension/LG_MAX_STRING_MACSIM;
}
else
{
item->size=ssi_list.TSP_sample_symbol_info_list_t_val[item->provider_global_index].dimension;
dimension=ssi_list.TSP_sample_symbol_info_list_t_val[item->provider_global_index].dimension;
}
item->size*=tsp_type_size[ssi_list.TSP_sample_symbol_info_list_t_val[item->provider_global_index].type];
while( continuer &&
(indice_data<dimension))
{
memset(data_var,'\0',LG_MAX_STRING_MACSIM);
/*read one data of the file*/
rep=read_data_file(genreader->handler->file,data_var);
if(EOF!=rep)
{
/*end of line*/
if(END_SAMPLE_SET==rep)
{
continuer=0;
}
/*load retrieve data in the raw value*/
switch(ssi_list.TSP_sample_symbol_info_list_t_val[item->provider_global_index].type)
{
case TSP_TYPE_DOUBLE :
load_double(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_FLOAT :
load_float(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_INT8 :
load_int8(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_INT16:
load_int16(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_INT32 :
load_int32(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_INT64 :
load_int64(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_UINT8:
load_uint8(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_UINT16:
load_uint16(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_UINT32:
load_uint32(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_UINT64:
load_uint64(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_CHAR:
load_char(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_UCHAR:
load_uchar(data_var,item->raw_value,indice_data);
break;
case TSP_TYPE_RAW:
load_type_raw(data_var,item->raw_value,indice_data);
break;
default:
break;
}
++indice_data;
}
else
{
continuer=0;
}
}
}
return(rep);
}
int main(int argc, char **argv)
{
float (*mu)[WAMI_GMM_IMG_NUM_COLS][WAMI_GMM_NUM_MODELS] = NULL;
float (*sigma)[WAMI_GMM_IMG_NUM_COLS][WAMI_GMM_NUM_MODELS] = NULL;
float (*weights)[WAMI_GMM_IMG_NUM_COLS][WAMI_GMM_NUM_MODELS] = NULL;
u8 (*foreground)[WAMI_GMM_IMG_NUM_ROWS][WAMI_GMM_IMG_NUM_COLS] = NULL;
#ifdef ENABLE_CORRECTNESS_CHECKING
u8 (*golden_foreground)[WAMI_GMM_IMG_NUM_ROWS][WAMI_GMM_IMG_NUM_COLS] = NULL;
u8 (*golden_eroded)[WAMI_GMM_IMG_NUM_COLS] = NULL;
u8 (*eroded)[WAMI_GMM_IMG_NUM_COLS] = NULL;
#endif
u8 (*morph)[WAMI_GMM_IMG_NUM_COLS] = NULL;
u16 (*frames)[WAMI_GMM_IMG_NUM_ROWS][WAMI_GMM_IMG_NUM_COLS] = NULL;
int i;
char *input_directory = NULL;
const size_t num_pixels = WAMI_GMM_IMG_NUM_ROWS * WAMI_GMM_IMG_NUM_COLS;
if (argc != 2)
{
fprintf(stderr, "%s <directory-containing-input-files>\n", argv[0]);
exit(EXIT_FAILURE);
}
input_directory = argv[1];
mu = XMALLOC(sizeof(float) * num_pixels * WAMI_GMM_NUM_MODELS);
sigma = XMALLOC(sizeof(float) * num_pixels * WAMI_GMM_NUM_MODELS);
weights = XMALLOC(sizeof(float) * num_pixels * WAMI_GMM_NUM_MODELS);
foreground = XMALLOC(sizeof(u8) * num_pixels * WAMI_GMM_NUM_FRAMES);
#ifdef ENABLE_CORRECTNESS_CHECKING
golden_foreground = XMALLOC(sizeof(u8) * num_pixels * WAMI_GMM_NUM_FRAMES);
eroded = XMALLOC(sizeof(u8) * num_pixels);
golden_eroded = XMALLOC(sizeof(u8) * num_pixels);
#endif
morph = XMALLOC(sizeof(u8) * num_pixels);
frames = XMALLOC(sizeof(u16) * num_pixels * WAMI_GMM_NUM_FRAMES);
memset(mu, 0, sizeof(float) * num_pixels * WAMI_GMM_NUM_MODELS);
memset(sigma, 0, sizeof(float) * num_pixels * WAMI_GMM_NUM_MODELS);
memset(weights, 0, sizeof(float) * num_pixels * WAMI_GMM_NUM_MODELS);
memset(foreground, 0, sizeof(u8) * num_pixels * WAMI_GMM_NUM_FRAMES);
memset(morph, 0, sizeof(u8) * num_pixels);
memset(frames, 0, sizeof(u16) * num_pixels * WAMI_GMM_NUM_FRAMES);
read_gmm_input_data(
mu, sigma, weights, frames, input_filename, input_directory);
#ifdef ENABLE_CORRECTNESS_CHECKING
read_data_file(
(char *) golden_foreground,
golden_output_filename,
input_directory,
sizeof(u8) * num_pixels * WAMI_GMM_NUM_FRAMES);
#endif
printf("WAMI kernel 2 parameters:\n\n");
printf("Image width = %d pixels\n", WAMI_DEBAYER_IMG_NUM_COLS);
printf("Image height = %d pixels\n", WAMI_DEBAYER_IMG_NUM_ROWS);
printf("Number of input frames = %d\n", WAMI_GMM_NUM_FRAMES);
printf("\nStarting WAMI kernel 3 (Gaussian Mixture Model / Change Detection).\n\n");
tic();
accept_roi_begin();
for (i = 0; i < WAMI_GMM_NUM_FRAMES; ++i)
{
wami_gmm(
(u8 (*)[WAMI_GMM_IMG_NUM_COLS]) &foreground[i][0][0],
mu,
sigma,
weights,
(u16 (*)[WAMI_GMM_IMG_NUM_COLS]) &frames[i][0][0]);
}
accept_roi_end();
PRINT_STAT_DOUBLE("CPU time using func toc - ", toc());
printf ("\n");
#ifdef ENABLE_CORRECTNESS_CHECKING
{
int j, k, validation_warning = 0;
double err;
for (i = 0; i < WAMI_GMM_NUM_FRAMES; ++i)
{
int num_misclassified = 0, num_foreground = 0;
double misclassification_rate = 0;
wami_morpho_erode(
eroded, (u8 (*)[WAMI_GMM_IMG_NUM_COLS]) &foreground[i][0][0]);
wami_morpho_erode(
golden_eroded, (u8 (*)[WAMI_GMM_IMG_NUM_COLS]) &golden_foreground[i][0][0]);
printf("\nValidating frame %d output...\n", i);
for (j = 0; j < WAMI_GMM_IMG_NUM_ROWS; ++j)
{
for (k = 0; k < WAMI_GMM_IMG_NUM_COLS; ++k)
{
if (eroded[j][k] != golden_eroded[j][k])
{
++num_misclassified;
}
if (golden_eroded[j][k] != 0)
{
++num_foreground;
}
}
}
misclassification_rate = (100.0*num_misclassified)/num_foreground;
err += (((double) num_misclassified) / ((double) num_foreground)) / ((double) WAMI_GMM_NUM_FRAMES);
printf("\tMisclassified pixels: %d\n", num_misclassified);
printf("\tGolden foreground pixels (after erosion): %d\n", num_foreground);
printf("\tMisclassification rate relative to foreground: %f%%\n",
misclassification_rate);
if (misclassification_rate > 0.1)
{
validation_warning = 1;
}
}
FILE *fp = fopen("err.txt", "wb");
assert(fp != NULL);
fprintf(fp, "%.2f\n", err);
fclose(fp);
if (validation_warning)
{
printf("\nValidation warning: Misclassification rate appears high; check images.\n\n");
}
else
{
printf("\nValidation checks passed.\n\n");
}
}
#endif
#ifdef WRITE_OUTPUT_TO_DISK
printf("Writing output to %s.\n", output_filename);
{
FILE *fp = fopen(output_filename, "wb");
assert(fp != NULL);
assert(fwrite(foreground, sizeof(u8), num_pixels * WAMI_GMM_NUM_FRAMES, fp) ==
num_pixels * WAMI_GMM_NUM_FRAMES);
fclose(fp);
}
#endif
FREE_AND_NULL(mu);
FREE_AND_NULL(sigma);
FREE_AND_NULL(weights);
FREE_AND_NULL(foreground);
#ifdef ENABLE_CORRECTNESS_CHECKING
FREE_AND_NULL(golden_foreground);
FREE_AND_NULL(eroded);
FREE_AND_NULL(golden_eroded);
#endif
FREE_AND_NULL(morph);
FREE_AND_NULL(frames);
return 0;
}