コード例 #1
0
ファイル: graphicarea.cpp プロジェクト: jcespinoza/JCAirlines
void GraphicArea::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    QPixmap ocean(":/graphics/img/ocean.png");
    painter.drawTiledPixmap(geometry(),ocean);

    QPixmap map(":/graphics/img/greenmap.png");
    painter.drawPixmap(geometry(),map);
    for(int i = 0; i < figures.length(); i++)
        figures.at(i)->draw(&painter);
}
コード例 #2
0
ファイル: ocean_main.c プロジェクト: sd-omkar/ece757
int main(int argc, char* argv[])
{
    int xdim,ydim,timesteps;
    int** grid;
    int i,j,t;

    hwtimer_t timer;
    initTimer(&timer);
    
    /********************Get the arguments correctly (start) **************************/
    /* 
    Three input Arguments to the program
    1. X Dimension of the grid
    2. Y dimension of the grid
    3. number of timesteps the algorithm is to be performed
    */
    
    if (argc!=4) {
        printf("The Arguments you entered are wrong.\n");
        printf("./serial_ocean <x-dim> <y-dim> <timesteps>\n");
        return EXIT_FAILURE;
    } else {
        xdim = atoi(argv[1]);
        ydim = atoi(argv[2]);
        timesteps = atoi(argv[3]);
    }
    ///////////////////////Get the arguments correctly (end) //////////////////////////


    /*********************create the grid as required (start) ************************/
    /*
    The grid needs to be allocated as per the input arguments and randomly initialized.
    Remember during allocation that we want to gaurentee a contiguous block, hence the
    nasty pointer math.

    To test your code for correctness please comment this section of random initialization.
    */
    grid = (int**) malloc(ydim*sizeof(int*));
    int *temp = (int*) malloc(xdim*ydim*sizeof(int));
    for (i=0; i<ydim; i++) {
        grid[i] = &temp[i*xdim];
    }
    for (i=0; i<ydim; i++) {
        for (j=0; j<xdim; j++) {
            grid[i][j] = rand() % 100;
            //grid[i][j] = ydim;
        }
    }
    ///////////////////////create the grid as required (end) //////////////////////////

    startTimer(&timer); // Start the time measurment here before the algorithm starts

    ocean(grid, xdim, ydim, timesteps);

    stopTimer(&timer); // End the time measuremnt here since the algorithm ended

    //Do the time calcuclation
    printf("Total Execution time: %.3f ms\n", (float)getTimerNs(&timer)/1000000);

    //Calculate average
    if (VERBOSE >= 1) {
      long long sum = 0;
      for (i=0; i<ydim; i++)
        for (j=0; j<xdim; j++)
          sum += grid[i][j];
      sum /= (xdim*ydim);
      printf("Avg = %d\n", sum);
    }

    // Free the memory we allocated for grid
    free(temp);
    free(grid);

    return EXIT_SUCCESS;
}
コード例 #3
0
ファイル: ocean_main.c プロジェクト: achinmishra/CS757
int main(int argc, char* argv[])
{
	int xdim,ydim,timesteps;
	int** grid[2];
	int i,j,t;

	hwtimer_t timer;
	initTimer(&timer);

	/********************Get the arguments correctly (start) **************************/
	/* 
	   Three input Arguments to the program
	   1. X Dimension of the grid
	   2. Y dimension of the grid
	   3. number of timesteps the algorithm is to be performed
	   */

	if (argc!=4) {
		printf("The Arguments you entered are wrong.\n");
		printf("./serial_ocean <x-dim> <y-dim> <timesteps>\n");
		return EXIT_FAILURE;
	} else {
		xdim = atoi(argv[1]);
		ydim = atoi(argv[2]);
		timesteps = atoi(argv[3]);
	}
	///////////////////////Get the arguments correctly (end) //////////////////////////


	/*********************create the grid as required (start) ************************/
	/*
	   The grid needs to be allocated as per the input arguments and randomly initialized.
	   Remember during allocation that we want to guarantee a contiguous block, hence the
	   nasty pointer math.

	// TA NOTE: If you dislike this scheme and want to say, allocate a single contiguous
	// 1D array, and do the pointer arithmetic yourself during the iteration, you may do so.

	To test your code for correctness please comment this section of random initialization.
	*/
	grid[0] = (int**) malloc(ydim*sizeof(int*));
	grid[1] = (int**) malloc(ydim*sizeof(int*));
	int *temp = (int*) malloc(xdim*ydim*sizeof(int));
	int *other_temp = (int*) malloc(xdim*ydim*sizeof(int));
	// Force xdim to be a multiple of 64 bytes.
	for (i=0; i<ydim; i++) {
		grid[0][i] = &temp[i*xdim];
		grid[1][i] = &other_temp[i*ydim];
	}
	for (i=0; i<ydim; i++) {
		for (j=0; j<xdim; j++) {
			
			if (i == 0 || j == 0 || i == ydim - 1 || j == xdim - 1)
			{
				grid[0][j][i] = 1000;
				grid[1][j][i] = 1000;
			} else {
				grid[0][j][i] = 500;
				grid[1][j][i] = 500;
			}
			//grid[0][i][j] = rand();
		}
	}

	
	for (i=0; i<xdim; i++) {
		printf("\n");
		for (j=0; j<ydim; j++) {
			printf("%d\t",grid[0][i][j]);
		}
	}
	///////////////////////create the grid as required (end) //////////////////////////

	startTimer(&timer); // Start the time measurment here before the algorithm starts

	ocean(grid, xdim, ydim, timesteps);

	stopTimer(&timer); // End the time measuremnt here since the algorithm ended

	//printf("New Matrix after Ocean wave\n");
	
	for (i=0; i<xdim; i++) {
		printf("\n");
		for (j=0; j<ydim; j++) {
			printf("%d\t",grid[0][i][j]);
		}
	}
	//Do the time calcuclation
	printf("Total Execution time: %lld ns\n", getTimerNs(&timer));

	// Free the memory we allocated for grid
	free(temp);
	free(other_temp);
	free(grid[0]);
	free(grid[1]);

	return EXIT_SUCCESS;
}