Esempio n. 1
0
int main(void) {
  const char *signal_file   = "../data/input.csv";
  double *signals;
  int signal_length;

  const char *filter_file  = "../data/filter.csv";
  double *filter;
  int filter_length;

  double *products;
  int i;

  // ファイルから読み込む
  get_double_data(filter_file, filter,  &filter_length);
  get_double_data(signal_file, signals, &signal_length);

  // 畳み込みの実行
  convolute(filter, filter_length, signals, signal_length, products);

  // 出力する
  printf("\nSIGNALS:\n");
  for(i = 0; i < signal_length; i++) {
    printf("%d:\t%f\n", i, signals[i]);
  }
  printf("\nFILTER:\n");
  for(i = 0; i < signal_length; i++) {
    printf("%d:\t%f\n", i, filter[i]);
  }
  printf("\nOUTPUT:\n");
  for(i = 0; i < signal_length - filter_length; i++) {
    printf("%d:\t%f\n", i, products[i]);
  }
}
template<class Out, class T> Out Convolution<Out, T>::operator()(T t, void* args) {
	if(m_product_function == NULL)
		return 0;

	((Affine_function<Out, T>*)m_product_function->get_f2()->get_f2())->set_t_shift(-t);
	return convolute(m_integrator, m_product_function, t, args, m_t_inf, m_t_sup, m_fixed_interval);
}
Esempio n. 3
0
int main(int argc, char* argv[] ) {
	
	init();
	
	convolute();

	return 0;
}
PNM* BlurGaussian::transform()
{
    emit message("Blurring...");

    int size = getParameter("size").toInt();
    radius = (size/2)+1;
    sigma = getParameter("sigma").toDouble();

    return convolute(getMask(size, Normalize), RepeatEdge);
}
Esempio n. 5
0
File: main.c Progetto: mjftw/CubeSat
//uses is_correctible instead of the actual reed_solomon codec to make it faster
float message_pass_rate_sim(int num_errors_min, int tries_max, float BER, int t)
{
  int successes = 0;
  int errors = 0;
  int tries = 0;

  while(errors < num_errors_min)
  {

    raw_data rd;
    rd.length = 128 + 2*t;
    rd.data = (uint8_t*)alloc_named(rd.length, "message_pass_rate_sim rd");
    unsigned int i;
    for(i = 0; i < rd.length; i++)
      rd.data[i] = rand();

    raw_data ep = convolute(rd);

    //interleaving not needed as errror insertion is AWGN- faster to not do it
    //interleave(ep);  //interleaves data in place

    insert_errors2(ep.data, ep.length, BER);

    //deinterleave(ep);

    raw_data deconvoluted = deconvolute(ep, NULL);

    if(is_correctible(rd, deconvoluted, t, 0))
    {
      successes++;
    }
    else
    {
      errors++;
    }

    dealloc(ep.data);
    dealloc(deconvoluted.data);
    dealloc(rd.data);
    if(tries >= tries_max)
      break;

    tries++;
  }
  return (float)successes / ((float)successes + (float)errors);
}
/** Returns a convoluted form of the image */
PNM* Convolution::transform()
{
    return convolute(getMask(3, Normalize), RepeatEdge);
}
Esempio n. 7
0
 T operator()(const T * py) const {  return convolute(py);  }
template<class Out, class T> Out Convolution<Out, T>::convolute(Integration<Out, T>* integrator, 
		Function_class<Out, T>* f1, Function_class<Out, T>* f2, T t, void* args, T t_inf, T t_sup, bool fixed_interval) {
	return convolute(integrator, (*f1) * ((*f2)(Affine_function<Out, T>(1, -t))), t, args, t_inf, t_sup, fixed_interval);
}
template<class Out, class T> Out Convolution<Out, T>::operator()(Function_class<Out, T>* f1, Function_class<Out, T>* f2, T t, void* args) {
	return convolute(m_integrator, f1, f2, t, args, m_t_inf, m_t_sup, m_fixed_interval);
}
Esempio n. 10
0
void Tilemap::generateLevel() {
	int* ceiling = new int[GRID_SIZE_X];
	int* floor = new int[GRID_SIZE_X];

	for(int x=0; x<GRID_SIZE_X; x++) {
		if(x < 16) {
			ceiling[x] = 4;
			floor[x] = 4;
			continue;
		}
		ceiling[x] = rand() % int(GRID_SIZE_Y*0.4f);
		floor[x] = 1 + rand() % int(GRID_SIZE_Y*0.4f);
		if(rand() % 10 == 1) ceiling[x] += 5;
		else if(rand() % 10 == 1) floor[x] += 5;
	}

	float* tent = generateTentKernel(1.f);
	ceiling = convolute(ceiling, GRID_SIZE_X, tent, 8);
	
	tent = generateTentKernel(1.f);
	floor = convolute(floor, GRID_SIZE_X, tent, 8);

	float* box = generateBoxKernel();
	ceiling = convolute(ceiling, GRID_SIZE_X, box, 4);

	box = generateBoxKernel();
	floor = convolute(floor, GRID_SIZE_X, box, 4);

	for(int x=0; x<GRID_SIZE_X; x++) {
		for(int y=0; y<ceiling[x]; y++) {
			if(rand() % 10 == 1)
				grid[x][y] = 1 + rand() % 3;
			else grid[x][y] = 1;
		}

	}
	for(int x=0; x<GRID_SIZE_X; x++) {
		for(int y=0; y<floor[x]; y++) {
			if(rand() % 10 == 1)
				grid[x][GRID_SIZE_Y-y] = 1 + rand() % 3;
			else grid[x][GRID_SIZE_Y-y] = 1;
		}
	}
	

	// edge detection

	for(int y=0; y<GRID_SIZE_Y; y++)
	for(int x=0; x<GRID_SIZE_X; x++) {
		int ri = rand() % 3;
		if(grid[x][y] > 0) {
			int neighborA = 0, neighborB = 0, neighborC = 0, neighborD = 0;
			if(y-1 < 0) neighborA = 1;
			else neighborA = grid[x][y-1];
			if(x+1 >= GRID_SIZE_X) neighborB = 1;
			else neighborB = grid[x+1][y];
			if(y+1 >= GRID_SIZE_Y) neighborC = 1;
			else neighborC = grid[x][y+1];
			if(x-1 < 0) neighborD = 1;
			else neighborD = grid[x-1][y];
			if(neighborA && neighborB && !neighborC && !neighborD) {
				if(ri == 0) {
					grid[x][y] = 4;
				} else if(ri == 1) {
					grid[x][y] = 8;
				} else {
					grid[x][y] = 12;
				}
			} else if(neighborA && !neighborB && !neighborC && neighborD) {
				if(ri == 0) {
					grid[x][y] = 5;
				} else if(ri == 1) {
					grid[x][y] = 9;
				} else {
					grid[x][y] = 13;
				}
			} else if(!neighborA && neighborB && neighborC && !neighborD) {
				if(ri == 0) {
					grid[x][y] = 6;
				} else if(ri == 1) {
					grid[x][y] = 10;
				} else {
					grid[x][y] = 14;
				}
			} else if(!neighborA && !neighborB && neighborC && neighborD) {
				if(ri == 0) {
					grid[x][y] = 7;
				} else if(ri == 1) {
					grid[x][y] = 11;
				} else {
					grid[x][y] = 15;
				}
			} else if(!neighborA) {
				if(rand() % 10 == 1)
					grid[x][y] = 17;
				else grid[x][y] = 16;
			} else if(!neighborC) {
				if(rand() % 10 == 1)
					grid[x][y] = 19;
				else grid[x][y] = 18;
			}
		}
	}
}
Esempio n. 11
0
int main(int argc, char** argv) {
	int thread_count = 4;
	int fd, i, j, k, width, height, loops, t, row_div, col_div, rows, cols;
	double timer, remote_time;
	char *image;
	color_t imageType;
	/* MPI world topology */
    int process_id, num_processes;
	/* Find current task id */
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &num_processes);
    MPI_Comm_rank(MPI_COMM_WORLD, &process_id);
	/* MPI status */
    MPI_Status status;
	/* MPI data types */
    MPI_Datatype grey_col_type;
    MPI_Datatype rgb_col_type;
    MPI_Datatype grey_row_type;
    MPI_Datatype rgb_row_type;
	/* MPI requests */
    MPI_Request send_north_req;
    MPI_Request send_south_req;
    MPI_Request send_west_req;
    MPI_Request send_east_req;
    MPI_Request recv_north_req;
    MPI_Request recv_south_req;
    MPI_Request recv_west_req;
    MPI_Request recv_east_req;
	
	/* Neighbours */
	int north = -1;
	int south = -1;
    int west = -1;
    int east = -1;

    /* Check arguments */
    if (process_id == 0) {
		Usage(argc, argv, &image, &width, &height, &loops, &imageType);
		/* Division of data in each process */
		row_div = divide_rows(height, width, num_processes);
		if (row_div <= 0 || height % row_div || num_processes % row_div || width % (col_div = num_processes / row_div)) {
				fprintf(stderr, "%s: Cannot divide to processes\n", argv[0]);
				MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
				return EXIT_FAILURE;
		}
	}
	if (process_id != 0) {
		image = malloc((strlen(argv[1])+1) * sizeof(char));
		strcpy(image, argv[1]);
	}
	/* Broadcast parameters */
    MPI_Bcast(&width, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&height, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&loops, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&imageType, 1, MPI_INT, 0, MPI_COMM_WORLD);
	MPI_Bcast(&row_div, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&col_div, 1, MPI_INT, 0, MPI_COMM_WORLD);
	
	/* Compute number of rows per process */
	rows = height / row_div;
	cols = width / col_div;

	/* Create column data type for grey & rgb */
	MPI_Type_vector(rows, 1, cols+2, MPI_BYTE, &grey_col_type);
	MPI_Type_commit(&grey_col_type);
	MPI_Type_vector(rows, 3, 3*cols+6, MPI_BYTE, &rgb_col_type);
	MPI_Type_commit(&rgb_col_type);
	/* Create row data type */
	MPI_Type_contiguous(cols, MPI_BYTE, &grey_row_type);
	MPI_Type_commit(&grey_row_type);
	MPI_Type_contiguous(3*cols, MPI_BYTE, &rgb_row_type);
	MPI_Type_commit(&rgb_row_type);

	 /* Compute starting row and column */
    int start_row = (process_id / col_div) * rows;
    int start_col = (process_id % col_div) * cols;
	
	/* Init filters */
	int box_blur[3][3] = {{1, 1, 1}, {1, 1, 1}, {1, 1, 1}};
	int gaussian_blur[3][3] = {{1, 2, 1}, {2, 4, 2}, {1, 2, 1}};
	int edge_detection[3][3] = {{1, 4, 1}, {4, 8, 4}, {1, 4, 1}};
	float **h = malloc(3 * sizeof(float *));
	for (i = 0 ; i < 3 ; i++)
		h[i] = malloc(3 * sizeof(float));
	for (i = 0 ; i < 3 ; i++) {
		for (j = 0 ; j < 3 ; j++){
			// h[i][j] = box_blur[i][j] / 9.0;
			h[i][j] = gaussian_blur[i][j] / 16.0;
			// h[i][j] = edge_detection[i][j] / 28.0;
		}
	}

	/* Init arrays */
	uint8_t *src = NULL, *dst = NULL, *tmpbuf = NULL, *tmp = NULL;
	MPI_File fh;
	int filesize, bufsize, nbytes;
	if (imageType == GREY) {
		filesize = width * height;
		bufsize = filesize / num_processes;
		nbytes = bufsize / sizeof(uint8_t);
		src = calloc((rows+2) * (cols+2), sizeof(uint8_t));
		dst = calloc((rows+2) * (cols+2), sizeof(uint8_t));
	} else if (imageType == RGB) {
		filesize = width*3 * height;
		bufsize = filesize / num_processes;
		nbytes = bufsize / sizeof(uint8_t);
		src = calloc((rows+2) * (cols*3+6), sizeof(uint8_t));
		dst = calloc((rows+2) * (cols*3+6), sizeof(uint8_t));
	}
	if (src == NULL || dst == NULL) {
        fprintf(stderr, "%s: Not enough memory\n", argv[0]);
        MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
        return EXIT_FAILURE;
	}

	/* Parallel read */
	MPI_File_open(MPI_COMM_WORLD, image, MPI_MODE_RDONLY, MPI_INFO_NULL, &fh);
	if (imageType == GREY) {
		for (i = 1 ; i <= rows ; i++) {
			MPI_File_seek(fh, (start_row + i-1) * width + start_col, MPI_SEEK_SET);
			tmpbuf = offset(src, i, 1, cols+2);
			MPI_File_read(fh, tmpbuf, cols, MPI_BYTE, &status);
		}
	} else if (imageType == RGB) {
		for (i = 1 ; i <= rows ; i++) {
			MPI_File_seek(fh, 3*(start_row + i-1) * width + 3*start_col, MPI_SEEK_SET);
			tmpbuf = offset(src, i, 3, cols*3+6);
			MPI_File_read(fh, tmpbuf, cols*3, MPI_BYTE, &status);
		}
	}
	MPI_File_close(&fh);

	/* Compute neighbours */
    if (start_row != 0)
        north = process_id - col_div;
    if (start_row + rows != height)
        south = process_id + col_div;
    if (start_col != 0)
        west = process_id - 1;
    if (start_col + cols != width)
        east = process_id + 1;
	
	/* Get time before */
    timer = MPI_Wtime();
	/* Convolute "loops" times */
	for (t = 0 ; t < loops ; t++) {
        /* Send and request borders */
		if (imageType == GREY) {
			if (north != -1) {
				MPI_Isend(offset(src, 1, 1, cols+2), 1, grey_row_type, north, 0, MPI_COMM_WORLD, &send_north_req);
				MPI_Irecv(offset(src, 0, 1, cols+2), 1, grey_row_type, north, 0, MPI_COMM_WORLD, &recv_north_req);
			}
			if (west != -1) {
				MPI_Isend(offset(src, 1, 1, cols+2), 1, grey_col_type,  west, 0, MPI_COMM_WORLD, &send_west_req);
				MPI_Irecv(offset(src, 1, 0, cols+2), 1, grey_col_type,  west, 0, MPI_COMM_WORLD, &recv_west_req);
			}
			if (south != -1) {
				MPI_Isend(offset(src, rows, 1, cols+2), 1, grey_row_type, south, 0, MPI_COMM_WORLD, &send_south_req);
				MPI_Irecv(offset(src, rows+1, 1, cols+2), 1, grey_row_type, south, 0, MPI_COMM_WORLD, &recv_south_req);
			}
			if (east != -1) {
				MPI_Isend(offset(src, 1, cols, cols+2), 1, grey_col_type,  east, 0, MPI_COMM_WORLD, &send_east_req);
				MPI_Irecv(offset(src, 1, cols+1, cols+2), 1, grey_col_type,  east, 0, MPI_COMM_WORLD, &recv_east_req);
			}
		} else if (imageType == RGB) {
			if (north != -1) {
				MPI_Isend(offset(src, 1, 3, 3*cols+6), 1, rgb_row_type, north, 0, MPI_COMM_WORLD, &send_north_req);
				MPI_Irecv(offset(src, 0, 3, 3*cols+6), 1, rgb_row_type, north, 0, MPI_COMM_WORLD, &recv_north_req);
			}
			if (west != -1) {
				MPI_Isend(offset(src, 1, 3, 3*cols+6), 1, rgb_col_type,  west, 0, MPI_COMM_WORLD, &send_west_req);
				MPI_Irecv(offset(src, 1, 0, 3*cols+6), 1, rgb_col_type,  west, 0, MPI_COMM_WORLD, &recv_west_req);
			}
			if (south != -1) {
				MPI_Isend(offset(src, rows, 3, 3*cols+6), 1, rgb_row_type, south, 0, MPI_COMM_WORLD, &send_south_req);
				MPI_Irecv(offset(src, rows+1, 3, 3*cols+6), 1, rgb_row_type, south, 0, MPI_COMM_WORLD, &recv_south_req);
			}
			if (east != -1) {
				MPI_Isend(offset(src, 1, 3*cols, 3*cols+6), 1, rgb_col_type,  east, 0, MPI_COMM_WORLD, &send_east_req);
				MPI_Irecv(offset(src, 1, 3*cols+3, 3*cols+6), 1, rgb_col_type,  east, 0, MPI_COMM_WORLD, &recv_east_req);
			}
		}

		/* Inner Data Convolute */
		convolute(src, dst, 1, rows, 1, cols, cols, rows, h, imageType);

	    /* Request and compute */
		if (north != -1) {
			MPI_Wait(&recv_north_req, &status);
			
			convolute(src, dst, 1, 1, 2, cols-1, cols, rows, h, imageType);
		}
		if (west != -1) {
			MPI_Wait(&recv_west_req, &status);
			convolute(src, dst, 2, rows-1, 1, 1, cols, rows, h, imageType);
		}
		if (south != -1) {
			MPI_Wait(&recv_south_req, &status);
			convolute(src, dst, rows, rows, 2, cols-1, cols, rows, h, imageType);
		}
		if (east != -1) {
			MPI_Wait(&recv_east_req, &status);
			convolute(src, dst, 2, rows-1, cols, cols, cols, rows, h, imageType);
		}

		/* Corner data */
		if (north != -1 && west != -1)
			convolute(src, dst, 1, 1, 1, 1, cols, rows, h, imageType);
		if (west != -1 && south != -1)
			convolute(src, dst, rows, rows, 1, 1, cols, rows, h, imageType);
		if (south != -1 && east != -1)
			convolute(src, dst, rows, rows, cols, cols, cols, rows, h, imageType);
		if (east != -1 && north != -1)
			convolute(src, dst, 1, 1, cols, cols, cols, rows, h, imageType);

		/* Wait to have sent all borders */
		if (north != -1)
			MPI_Wait(&send_north_req, &status);
		if (west != -1)
			MPI_Wait(&send_west_req, &status);
		if (south != -1)
			MPI_Wait(&send_south_req, &status);
		if (east != -1)
			MPI_Wait(&send_east_req, &status);

		/* swap arrays */
		tmp = src;
	    src = dst;
	    dst = tmp;
	}
	/* Get time elapsed */
    timer = MPI_Wtime() - timer;

	/* Parallel write */
	char *outImage = malloc((strlen(image) + 9) * sizeof(char));
	strcpy(outImage, "blur_");
	strcat(outImage, image);
	MPI_File outFile;
	MPI_File_open(MPI_COMM_WORLD, outImage, MPI_MODE_CREATE | MPI_MODE_WRONLY, MPI_INFO_NULL, &outFile);
	if (imageType == GREY) {
		for (i = 1 ; i <= rows ; i++) {
			MPI_File_seek(outFile, (start_row + i-1) * width + start_col, MPI_SEEK_SET);
			tmpbuf = offset(src, i, 1, cols+2);
			MPI_File_write(outFile, tmpbuf, cols, MPI_BYTE, MPI_STATUS_IGNORE);
		}
	} else if (imageType == RGB) {
		for (i = 1 ; i <= rows ; i++) {
			MPI_File_seek(outFile, 3*(start_row + i-1) * width + 3*start_col, MPI_SEEK_SET);
			tmpbuf = offset(src, i, 3, cols*3+6);
			MPI_File_write(outFile, tmpbuf, cols*3, MPI_BYTE, MPI_STATUS_IGNORE);
		}
	}
	MPI_File_close(&outFile);

	/* Get times from other processes and print maximum */
    if (process_id != 0)
        MPI_Send(&timer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
    else {
        for (i = 1 ; i != num_processes ; ++i) {
            MPI_Recv(&remote_time, 1, MPI_DOUBLE, i, 0, MPI_COMM_WORLD, &status);
            if (remote_time > timer)
                timer = remote_time;
        }
        printf("%f\n", timer);
    }

    /* De-allocate space */
    free(src);
    free(dst);
    MPI_Type_free(&rgb_col_type);
    MPI_Type_free(&rgb_row_type);
    MPI_Type_free(&grey_col_type);
    MPI_Type_free(&grey_row_type);

	/* Finalize and exit */
    MPI_Finalize();
	return EXIT_SUCCESS;
}
Esempio n. 12
0
File: main.c Progetto: mjftw/CubeSat
//tests the methods used encoding and decoding, uses insert_errors2 to accomodate any bit rate
float message_pass_rate(int num_tests, float BER)
{
  int successes = 0;
  int errors = 0;
  int tries = 0;
  int wrong1 = 0, wrong2 = 0;
  //for(unsigned int i = 0; i < num_tests; i++)
  while(errors < 100)
  {

    raw_data rd;
    rd.length = 64;
    rd.data = (uint8_t*)alloc_named(rd.length, "message_pass_rate rd");
    unsigned int i;
    for(i = 0; i < 64; i++)
      rd.data[i] = rand();

    int t = 2;  //PYTHON//

    //p = make_packet(rd);
    //encoded_packet ep = encode(&p);  //currently convolutional- subject to change

    raw_data rs_encoded = rs_encode(rd, t);
    raw_data ep = convolute(rs_encoded);

    interleave(ep);  //interleaves data in place

    insert_errors2(ep.data, ep.length, BER);

    deinterleave(ep);

    raw_data deconvoluted = deconvolute(ep, NULL);

    int isc = is_correctible(rs_encoded, deconvoluted, t, 0);

    raw_data decoded;
    rs_decode(deconvoluted, &decoded, t, NULL);

    //q = decode(ep, NULL);
    if(rd.length != decoded.length)
    {
      printf("lengths are not the same!\n");
      printf("rd.length = %i, decoded.length = %i\n", rd.length, decoded.length);
    }
    if(!memcmp(decoded.data, rd.data, rd.length))
    {
      if(!isc)
        wrong1++;
      //if(!isc)
      //  is_correctible(rs_encoded, deconvoluted, t, 1);
      //assert(isc);
      successes++;
    }
    else
    {
      if(isc)
        wrong2++;
      //assert(!isc);
      errors++;
    }

    dealloc(ep.data);
    dealloc(rs_encoded.data);
    dealloc(deconvoluted.data);
    dealloc(decoded.data);
    dealloc(rd.data);
    if(tries >= num_tests)
    {
      printf("tries = %i, errors = %i\n", tries, errors);
      break;
    }
    tries++;
  }
  //return (float)successes / (float)num_tests;
  printf("wrong1 = %i\n", wrong1);
  printf("wrong2 = %i\n", wrong2);
  printf("tests = %i\n", successes + errors);
  return (float)successes / ((float)successes + (float)errors);
}