CPU_并行(多线程)不同高性能旋转图片

最新推荐文章于 2024-06-16 22:47:03 发布
最新推荐文章于 2024-06-16 22:47:03 发布
阅读量590 收藏 1
点赞数
分类专栏： cuda 文章标签： c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mikowoo007/article/details/128605378
版权

并行(多线程)不同高性能旋转图片

代码

ImageStuff.h

struct ImgProp
{
	int Hpixels;
	int Vpixels;
	unsigned char HeaderInfo[54];
	unsigned long int Hbytes;
};

struct Pixel
{
	unsigned char R;
	unsigned char G;
	unsigned char B;
};

unsigned char** CreateBlankBMP();
unsigned char** ReadBMP(char* );
void WriteBMP(unsigned char** , char*);

extern struct ImgProp 	ip;

ImageStuff.c

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>

#include "ImageStuff.h"


unsigned char** CreateBlankBMP()
{
    int i,j;

	unsigned char** img = (unsigned char **)malloc(ip.Vpixels * sizeof(unsigned char*));
    for(i=0; i<ip.Vpixels; i++){
        img[i] = (unsigned char *)malloc(ip.Hbytes * sizeof(unsigned char));
		memset((void *)img[i],0,(size_t)ip.Hbytes); // zero out every pixel
    }
    return img;
}


unsigned char** ReadBMP(char* filename)
{
	int i;
	FILE* f = fopen(filename, "rb");
	if(f == NULL){
		printf("\n\n%s NOT FOUND\n\n",filename);
		exit(1);
	}

	unsigned char HeaderInfo[54];
	fread(HeaderInfo, sizeof(unsigned char), 54, f); // read the 54-byte header

	// extract image height and width from header
	int width = *(int*)&HeaderInfo[18];
	int height = *(int*)&HeaderInfo[22];

	//copy header for re-use
	for(i=0; i<54; i++) {
		ip.HeaderInfo[i] = HeaderInfo[i];
	}

	ip.Vpixels = height;
	ip.Hpixels = width;
	int RowBytes = (width*3 + 3) & (~3);
	ip.Hbytes = RowBytes;

	printf("\n   Input BMP File name: %20s  (%u x %u)",filename,ip.Hpixels,ip.Vpixels);

	unsigned char tmp;
	unsigned char **TheImage = (unsigned char **)malloc(height * sizeof(unsigned char*));
	for(i=0; i<height; i++) {
		TheImage[i] = (unsigned char *)malloc(RowBytes * sizeof(unsigned char));
	}

	for(i = 0; i < height; i++) {
		fread(TheImage[i], sizeof(unsigned char), RowBytes, f);
	}
	fclose(f);
	return TheImage;  // remember to free() it in caller!
}


void WriteBMP(unsigned char** img, char* filename)
{
	FILE* f = fopen(filename, "wb");
	if(f == NULL){
		printf("\n\nFILE CREATION ERROR: %s\n\n",filename);
		exit(1);
	}

	unsigned long int x,y;
	unsigned char temp;

	//write header
	for(x=0; x<54; x++) {	fputc(ip.HeaderInfo[x],f);	}

	//write data
	for(x=0; x<ip.Vpixels; x++) {
		for(y=0; y<ip.Hbytes; y++){
			temp=img[x][y];
			fputc(temp,f);
		}
	}
	printf("\n  Output BMP File name: %20s  (%u x %u)",filename,ip.Hpixels,ip.Vpixels);
	fclose(f);
}

imrotateMC.c

#include <pthread.h>
#include <stdint.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <sys/time.h>

#include "ImageStuff.h"

#define REPS 	     129
#define MAXTHREADS   128

long  			NumThreads;         		// Total number of threads working in parallel
int 	     	ThParam[MAXTHREADS];		// Thread parameters ...
double			RotAngle;					// rotation angle
pthread_t      	ThHandle[MAXTHREADS];		// Thread handles
pthread_attr_t 	ThAttr;						// Pthread attrributes
void* (*RotateFunc)(void *arg);				// Function pointer to rotate the image (multi-threaded)

unsigned char**	TheImage;					// This is the main image
unsigned char**	CopyImage;					// This is the copy image
struct ImgProp 	ip;


void *Rotate(void* tid)
{
    long tn;            		     // My thread number (ID) is stored here
    int row,col,h,v,c;
	int NewRow,NewCol;
	double X, Y, newX, newY, ScaleFactor;
	double Diagonal, H, V;
    struct Pixel pix;

    tn = *((int *) tid);           // Calculate my Thread ID
    tn *= ip.Vpixels/NumThreads;
	
    for(row=tn; row<tn+ip.Vpixels/NumThreads; row++){
        col=0;
        while(col<ip.Hpixels*3){
			// transpose image coordinates to Cartesian coordinates
			c=col/3;  		h=ip.Hpixels/2;   v=ip.Vpixels/2;	// integer div
			X=(double)c-(double)h;
			Y=(double)v-(double)row;
			
			// pixel rotation matrix
			newX=cos(RotAngle)*X-sin(RotAngle)*Y;
			newY=sin(RotAngle)*X+cos(RotAngle)*Y;
			
			// Scale to fit everything in the image box
			H=(double)ip.Hpixels;
			V=(double)ip.Vpixels;
			Diagonal=sqrt(H*H+V*V);
			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
			newX=newX*ScaleFactor;
			newY=newY*ScaleFactor;
			
			// convert back from Cartesian to image coordinates
			NewCol=((int) newX+h);
			NewRow=v-(int)newY;     
			if((NewCol>=0) && (NewRow>=0) && (NewCol<ip.Hpixels) && (NewRow<ip.Vpixels)){
				NewCol*=3;
				CopyImage[NewRow][NewCol]   = TheImage[row][col];
				CopyImage[NewRow][NewCol+1] = TheImage[row][col+1];
				CopyImage[NewRow][NewCol+2] = TheImage[row][col+2];
            }
            col+=3;
        }
    }
    pthread_exit(NULL);
}
void *Rotate2(void* tid)
{
    long tn;            		     // My thread number (ID) is stored here
    int row,col,h,v,c;
	int NewRow,NewCol;
	double X, Y, newX, newY, ScaleFactor;
	double Diagonal, H, V;
    struct Pixel pix;

    tn = *((int *) tid);           // Calculate my Thread ID
    tn *= ip.Vpixels/NumThreads;
	
			H=(double)ip.Hpixels;
			V=(double)ip.Vpixels;
			Diagonal=sqrt(H*H+V*V);
			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
    for(row=tn; row<tn+ip.Vpixels/NumThreads; row++){
        col=0;
        while(col<ip.Hpixels*3){
			// transpose image coordinates to Cartesian coordinates
			c=col/3;  		h=ip.Hpixels/2;   v=ip.Vpixels/2;	// integer div
			X=(double)c-(double)h;
			Y=(double)v-(double)row;
			
			// pixel rotation matrix
			newX=cos(RotAngle)*X-sin(RotAngle)*Y;
			newY=sin(RotAngle)*X+cos(RotAngle)*Y;
			
			// Scale to fit everything in the image box
//			H=(double)ip.Hpixels;
//			V=(double)ip.Vpixels;
//			Diagonal=sqrt(H*H+V*V);
//			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
			newX=newX*ScaleFactor;
			newY=newY*ScaleFactor;
			
			// convert back from Cartesian to image coordinates
			NewCol=((int) newX+h);
			NewRow=v-(int)newY;     
			if((NewCol>=0) && (NewRow>=0) && (NewCol<ip.Hpixels) && (NewRow<ip.Vpixels)){
				NewCol*=3;
				CopyImage[NewRow][NewCol]   = TheImage[row][col];
				CopyImage[NewRow][NewCol+1] = TheImage[row][col+1];
				CopyImage[NewRow][NewCol+2] = TheImage[row][col+2];
            }
            col+=3;
        }
    }
    pthread_exit(NULL);
}


void *Rotate3(void* tid)
{
    long tn;            		     // My thread number (ID) is stored here
    int row,col,h,v,c;
	int NewRow,NewCol;
	double X, Y, newX, newY, ScaleFactor;
	double Diagonal, H, V;
	double CRA,SRA;
    struct Pixel pix;

    tn = *((int *) tid);           // Calculate my Thread ID
    tn *= ip.Vpixels/NumThreads;
	
			H=(double)ip.Hpixels;
			V=(double)ip.Vpixels;
			Diagonal=sqrt(H*H+V*V);
			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
			
			CRA=cos(RotAngle);
    for(row=tn; row<tn+ip.Vpixels/NumThreads; row++){
        col=0;
        while(col<ip.Hpixels*3){
			// transpose image coordinates to Cartesian coordinates
			c=col/3;  		h=ip.Hpixels/2;   v=ip.Vpixels/2;	// integer div
			X=(double)c-(double)h;
			Y=(double)v-(double)row;
			
			// pixel rotation matrix
			newX=CRA*X-sin(RotAngle)*Y;
			newY=sin(RotAngle)*X+CRA*Y;
//			newX=cos(RotAngle)*X-sin(RotAngle)*Y;
//			newY=sin(RotAngle)*X+cos(RotAngle)*Y;
			
			// Scale to fit everything in the image box
//			H=(double)ip.Hpixels;
//			V=(double)ip.Vpixels;
//			Diagonal=sqrt(H*H+V*V);
//			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
			newX=newX*ScaleFactor;
			newY=newY*ScaleFactor;
			
			// convert back from Cartesian to image coordinates
			NewCol=((int) newX+h);
			NewRow=v-(int)newY;     
			if((NewCol>=0) && (NewRow>=0) && (NewCol<ip.Hpixels) && (NewRow<ip.Vpixels)){
				NewCol*=3;
				CopyImage[NewRow][NewCol]   = TheImage[row][col];
				CopyImage[NewRow][NewCol+1] = TheImage[row][col+1];
				CopyImage[NewRow][NewCol+2] = TheImage[row][col+2];
            }
            col+=3;
        }
    }
    pthread_exit(NULL);
}


void *Rotate4(void* tid)
{
    long tn;            		     // My thread number (ID) is stored here
    int row,col,h,v,c;
	int NewRow,NewCol;
	double X, Y, newX, newY, ScaleFactor;
	double Diagonal, H, V;
	double CRA,SRA;
    struct Pixel pix;

    tn = *((int *) tid);           // Calculate my Thread ID
    tn *= ip.Vpixels/NumThreads;
	
			H=(double)ip.Hpixels;
			V=(double)ip.Vpixels;
			Diagonal=sqrt(H*H+V*V);
			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
			
			CRA=cos(RotAngle);
			SRA=sin(RotAngle);
    for(row=tn; row<tn+ip.Vpixels/NumThreads; row++){
        col=0;
        while(col<ip.Hpixels*3){
			// transpose image coordinates to Cartesian coordinates
			c=col/3;  		h=ip.Hpixels/2;   v=ip.Vpixels/2;	// integer div
			X=(double)c-(double)h;
			Y=(double)v-(double)row;
			
			// pixel rotation matrix
			newX=CRA*X-SRA*Y;
			newY=SRA*X+CRA*Y;
//			newX=cos(RotAngle)*X-sin(RotAngle)*Y;
//			newY=sin(RotAngle)*X+cos(RotAngle)*Y;
			
			// Scale to fit everything in the image box
//			H=(double)ip.Hpixels;
//			V=(double)ip.Vpixels;
//			Diagonal=sqrt(H*H+V*V);
//			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
			newX=newX*ScaleFactor;
			newY=newY*ScaleFactor;
			
			// convert back from Cartesian to image coordinates
			NewCol=((int) newX+h);
			NewRow=v-(int)newY;     
			if((NewCol>=0) && (NewRow>=0) && (NewCol<ip.Hpixels) && (NewRow<ip.Vpixels)){
				NewCol*=3;
				CopyImage[NewRow][NewCol]   = TheImage[row][col];
				CopyImage[NewRow][NewCol+1] = TheImage[row][col+1];
				CopyImage[NewRow][NewCol+2] = TheImage[row][col+2];
            }
            col+=3;
        }
    }
    pthread_exit(NULL);
}


void *Rotate5(void* tid)
{
    long tn;            		     // My thread number (ID) is stored here
//    int row,col,h,v,c;
    int row,col,h,v,c, hp3;
	int NewRow,NewCol;
	double X, Y, newX, newY, ScaleFactor;
	double Diagonal, H, V;
	double CRA,SRA;
    struct Pixel pix;

    tn = *((int *) tid);           // Calculate my Thread ID
    tn *= ip.Vpixels/NumThreads;
	
			H=(double)ip.Hpixels;
			V=(double)ip.Vpixels;
			Diagonal=sqrt(H*H+V*V);
			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
			
			CRA=cos(RotAngle);
			SRA=sin(RotAngle);
			h=ip.Hpixels/2;   v=ip.Vpixels/2;	// integer div
			hp3=ip.Hpixels*3;
    for(row=tn; row<tn+ip.Vpixels/NumThreads; row++){
        col=0;
		c=0;
//      while(col<ip.Hpixels*3){
        while(col<hp3){
			// transpose image coordinates to Cartesian coordinates
//			c=col/3;  		h=ip.Hpixels/2;   v=ip.Vpixels/2;	// integer div
			X=(double)c-(double)h;
			Y=(double)v-(double)row;
			
			// pixel rotation matrix
			newX=CRA*X-SRA*Y;
			newY=SRA*X+CRA*Y;
//			newX=cos(RotAngle)*X-sin(RotAngle)*Y;
//			newY=sin(RotAngle)*X+cos(RotAngle)*Y;
			
			// Scale to fit everything in the image box
//			H=(double)ip.Hpixels;
//			V=(double)ip.Vpixels;
//			Diagonal=sqrt(H*H+V*V);
//			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
			newX=newX*ScaleFactor;
			newY=newY*ScaleFactor;
			
			// convert back from Cartesian to image coordinates
			NewCol=((int) newX+h);
			NewRow=v-(int)newY;     
			if((NewCol>=0) && (NewRow>=0) && (NewCol<ip.Hpixels) && (NewRow<ip.Vpixels)){
				NewCol*=3;
				CopyImage[NewRow][NewCol]   = TheImage[row][col];
				CopyImage[NewRow][NewCol+1] = TheImage[row][col+1];
				CopyImage[NewRow][NewCol+2] = TheImage[row][col+2];
            }
			
            col+=3;
			c++;
        }
    }
    pthread_exit(NULL);
}


void *Rotate6(void* tid)
{
    long tn;            		     // My thread number (ID) is stored here
//    int row,col,h,v,c;
    int row,col,h,v,c, hp3;
	int NewRow,NewCol;
	double X, Y, newX, newY, ScaleFactor;
	double Diagonal, H, V;
	double CRA,SRA, CRAS, SRAS, SRAYS, CRAYS;
    struct Pixel pix;

    tn = *((int *) tid);           // Calculate my Thread ID
    tn *= ip.Vpixels/NumThreads;
	
			H=(double)ip.Hpixels;
			V=(double)ip.Vpixels;
			Diagonal=sqrt(H*H+V*V);
			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
			
			CRA=cos(RotAngle);	CRAS=ScaleFactor*CRA;
			SRA=sin(RotAngle);	SRAS=ScaleFactor*SRA;
			h=ip.Hpixels/2;   v=ip.Vpixels/2;	// integer div
			hp3=ip.Hpixels*3;
    for(row=tn; row<tn+ip.Vpixels/NumThreads; row++){
        col=0;
		c=0;
			Y=(double)v-(double)row;
			SRAYS=SRAS*Y;     CRAYS=CRAS*Y;
//      while(col<ip.Hpixels*3){
        while(col<hp3){
			// transpose image coordinates to Cartesian coordinates
//			c=col/3;  		h=ip.Hpixels/2;   v=ip.Vpixels/2;	// integer div
			X=(double)c-(double)h;
//			Y=(double)v-(double)row;
			
			// pixel rotation matrix
			newX=CRAS*X-SRAYS;
			newY=SRAS*X+CRAYS;
//			newX=CRA*X-SRA*Y;
//			newY=SRA*X+CRA*Y;
//			newX=cos(RotAngle)*X-sin(RotAngle)*Y;
//			newY=sin(RotAngle)*X+cos(RotAngle)*Y;
			
			// Scale to fit everything in the image box
//			H=(double)ip.Hpixels;
//			V=(double)ip.Vpixels;
//			Diagonal=sqrt(H*H+V*V);
//			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
//			newX=newX*ScaleFactor;
//			newY=newY*ScaleFactor;
			
			// convert back from Cartesian to image coordinates
			NewCol=((int) newX+h);
			NewRow=v-(int)newY;     
			if((NewCol>=0) && (NewRow>=0) && (NewCol<ip.Hpixels) && (NewRow<ip.Vpixels)){
				NewCol*=3;
				CopyImage[NewRow][NewCol]   = TheImage[row][col];
				CopyImage[NewRow][NewCol+1] = TheImage[row][col+1];
				CopyImage[NewRow][NewCol+2] = TheImage[row][col+2];
            }
			
            col+=3;
			c++;
        }
    }
    pthread_exit(NULL);
}


void *Rotate7(void* tid)
{
    long tn;            		     // My thread number (ID) is stored here
//    int row,col,h,v,c;
    int row,col,h,v,c, hp3;
	double cc, ss, k1, k2;
	int NewRow,NewCol;
	double X, Y, newX, newY, ScaleFactor;
	double Diagonal, H, V;
	double CRA,SRA, CRAS, SRAS, SRAYS, CRAYS;
    struct Pixel pix;

    tn = *((int *) tid);           // Calculate my Thread ID
    tn *= ip.Vpixels/NumThreads;
	
			H=(double)ip.Hpixels;
			V=(double)ip.Vpixels;
			Diagonal=sqrt(H*H+V*V);
			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
			
			CRA=cos(RotAngle);	CRAS=ScaleFactor*CRA;
			SRA=sin(RotAngle);	SRAS=ScaleFactor*SRA;
			h=ip.Hpixels/2;   v=ip.Vpixels/2;	// integer div
			hp3=ip.Hpixels*3;
    for(row=tn; row<tn+ip.Vpixels/NumThreads; row++){
        col=0;
		cc=0.00;
		ss=0.00;
			Y=(double)v-(double)row;
			SRAYS=SRAS*Y;     CRAYS=CRAS*Y;
			k1=CRAS*(double)h + SRAYS;
			k2=SRAS*(double)h - CRAYS;
//      while(col<ip.Hpixels*3){
        while(col<hp3){
			// transpose image coordinates to Cartesian coordinates
//			c=col/3;  		h=ip.Hpixels/2;   v=ip.Vpixels/2;	// integer div
//			X=(double)c-(double)h;
//			Y=(double)v-(double)row;
			
			// pixel rotation matrix
			newX=cc-k1;
			newY=ss-k2;
//			newX=CRA*X-SRA*Y;
//			newY=SRA*X+CRA*Y;
//			newX=cos(RotAngle)*X-sin(RotAngle)*Y;
//			newY=sin(RotAngle)*X+cos(RotAngle)*Y;
			
			// Scale to fit everything in the image box
//			H=(double)ip.Hpixels;
//			V=(double)ip.Vpixels;
//			Diagonal=sqrt(H*H+V*V);
//			ScaleFactor=(ip.Hpixels>ip.Vpixels) ? V/Diagonal : H/Diagonal;
//			newX=newX*ScaleFactor;
//			newY=newY*ScaleFactor;
			
			// convert back from Cartesian to image coordinates
			NewCol=((int) newX+h);
			NewRow=v-(int)newY;     
			if((NewCol>=0) && (NewRow>=0) && (NewCol<ip.Hpixels) && (NewRow<ip.Vpixels)){
				NewCol*=3;
				CopyImage[NewRow][NewCol]   = TheImage[row][col];
				CopyImage[NewRow][NewCol+1] = TheImage[row][col+1];
				CopyImage[NewRow][NewCol+2] = TheImage[row][col+2];
            }
			
            col+=3;
			cc += CRAS;
			ss += SRAS;
        }
    }
    pthread_exit(NULL);
}


int main(int argc, char** argv)
{
	int					RotDegrees, Function;
    int 				a,i,ThErr;
    struct timeval 		t;
    double         		StartTime, EndTime;
    double         		TimeElapsed;
	char				FuncName[50];
	
    switch (argc){
		case 3 : NumThreads=1; 				RotDegrees=45;					Function=1; 			break;
		case 4 : NumThreads=1;  			RotDegrees = atoi(argv[3]);		Function=1; 			break;
		case 5 : NumThreads=atoi(argv[4]);  RotDegrees = atoi(argv[3]);		Function=1; 			break;
		case 6 : NumThreads=atoi(argv[4]);  RotDegrees = atoi(argv[3]);		Function=atoi(argv[5]); break;
		default: printf("\nUsage: %s inputBMP outputBMP [RotAngle] [NumThreads : 1-128] [Function:1-6]\n\n",argv[0]);
				 printf("Example: %s infilename.bmp outname.bmp -75\n\n",argv[0]);
				 printf("Example: %s infilename.bmp outname.bmp 45 8\n\n",argv[0]);
				 printf("Example: %s infilename.bmp outname.bmp 125 4 3\n\n",argv[0]);
				 printf("Nothing executed ... Exiting ...\n\n");
				 exit(EXIT_FAILURE);
    }
	if((NumThreads<1) || (NumThreads>MAXTHREADS)){
        printf("\nNumber of threads must be between 1 and %u... \n",MAXTHREADS);
        printf("\n'1' means Pthreads version with a single thread\n");
		printf("\n\nNothing executed ... Exiting ...\n\n");
        exit(EXIT_FAILURE);
	}
	if((RotDegrees<-360) || (RotDegrees>360)){
        printf("\nRotation angle of %d degrees is invalid ...\n",RotDegrees);
        printf("\nPlease enter an angle between -360 and +360 degrees ...\n");
		printf("\n\nNothing executed ... Exiting ...\n\n");
        exit(EXIT_FAILURE);
	}
	switch(Function){
		case 1:  strcpy(FuncName,"Rotate()");	RotateFunc=Rotate;	break;
		case 2:  strcpy(FuncName,"Rotate2()");	RotateFunc=Rotate2;	break;
		case 3:  strcpy(FuncName,"Rotate3()");	RotateFunc=Rotate3;	break;
		case 4:  strcpy(FuncName,"Rotate4()");	RotateFunc=Rotate4;	break;
		case 5:  strcpy(FuncName,"Rotate5()");	RotateFunc=Rotate5;	break;
		case 6:  strcpy(FuncName,"Rotate6()");	RotateFunc=Rotate6;	break;
		case 7:  strcpy(FuncName,"Rotate7()");	RotateFunc=Rotate7;	break;
//		case 8:  strcpy(FuncName,"Rotate8()");	RotateFunc=Rotate8;	break;
//		case 9:  strcpy(FuncName,"Rotate9()");	RotateFunc=Rotate9;	break;
		default: printf("Wrong function %d ... \n",Function);
					printf("\n\nNothing executed ... Exiting ...\n\n");
					exit(EXIT_FAILURE);
	}
	printf("\nLaunching %li Pthread%s using function:  %s\n",NumThreads,NumThreads<=1?"":"s",FuncName);
	RotAngle=2*3.141592/360.000*(double) RotDegrees;   // Convert the angle to radians
	printf("\nRotating image by %d degrees (%5.4f radians) ...\n",RotDegrees,RotAngle);

	TheImage = ReadBMP(argv[1]);
	CopyImage = CreateBlankBMP();

	gettimeofday(&t, NULL);
    StartTime = (double)t.tv_sec*1000000.0 + ((double)t.tv_usec);
	
	pthread_attr_init(&ThAttr);
	pthread_attr_setdetachstate(&ThAttr, PTHREAD_CREATE_JOINABLE);
	for(a=0; a<REPS; a++){
		for(i=0; i<NumThreads; i++){
			ThParam[i] = i;
			ThErr = pthread_create(&ThHandle[i], &ThAttr, RotateFunc, (void *)&ThParam[i]);
			if(ThErr != 0){
				printf("\nThread Creation Error %d. Exiting abruptly... \n",ThErr);
				exit(EXIT_FAILURE);
			}
		}
		pthread_attr_destroy(&ThAttr);
		for(i=0; i<NumThreads; i++){
			pthread_join(ThHandle[i], NULL);
		}
	}
	
    gettimeofday(&t, NULL);
    EndTime = (double)t.tv_sec*1000000.0 + ((double)t.tv_usec);
	TimeElapsed=(EndTime-StartTime)/1000.00;
	TimeElapsed/=(double)REPS;
	
    //merge with header and write to file
    WriteBMP(CopyImage, argv[2]);
 
 	// free() the allocated area for the images
	for(i = 0; i < ip.Vpixels; i++) { free(TheImage[i]); free(CopyImage[i]); }
	free(TheImage);   free(CopyImage);   
   
    printf("\n\nExecution time:%10.4f ms  ",TimeElapsed);
	if(NumThreads>=1) printf("(%10.4f  Thread-ms)  ",TimeElapsed*(double)NumThreads);
    printf(" (%6.3f ns/pixel)\n", 1000000*TimeElapsed/(double)(ip.Hpixels*ip.Vpixels));
    
    return (EXIT_SUCCESS);
}

编译

gcc imrotateMC.c ImageStuff.c -o imrotateMC -lpthread -lm

在这里插入图片描述
在这里插入图片描述

运行效果

使用2个线程,通过Rotate() 方法顺时针旋转图片 10 ° 10\degree 10°

./imrotateMC nature_monte.bmp nature_monte_10_2_func1.bmp 10 2 1

在这里插入图片描述

使用2个线程,通过Rotate2() 方法顺时针旋转图片 10 ° 10\degree 10°

./imrotateMC nature_monte.bmp nature_monte_10_2_func2.bmp 10 2 2

在这里插入图片描述

使用2个线程,通过Rotate3() 方法顺时针旋转图片 10 ° 10\degree 10°

./imrotateMC nature_monte.bmp nature_monte_10_2_func3.bmp 10 2 3

在这里插入图片描述

使用2个线程,通过Rotate4() 方法顺时针旋转图片 10 ° 10\degree 10°

 ./imrotateMC nature_monte.bmp nature_monte_10_2_func4.bmp 10 2 4

在这里插入图片描述

使用2个线程,通过Rotate5() 方法顺时针旋转图片 10 ° 10\degree 10°

 ./imrotateMC nature_monte.bmp nature_monte_10_2_func5.bmp 10 2 5

在这里插入图片描述
使用2个线程,通过Rotate6() 方法顺时针旋转图片 10 ° 10\degree 10°

./imrotateMC nature_monte.bmp nature_monte_10_2_func6.bmp 10 2 6

在这里插入图片描述
使用2个线程,通过Rotate7() 方法顺时针旋转图片 10 ° 10\degree 10°

./imrotateMC nature_monte.bmp nature_monte_10_2_func7.bmp 10 2 7

在这里插入图片描述

原图
在这里插入图片描述
顺时针旋转 10 ° 10\degree 10° 后
在这里插入图片描述

Mikowoo007
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 多线程（一）入门
jianbiancheng的博客
05-17 1246
C++ 多线程（一） Multi-Threaded 多线程编程术语 线程 更确切地说，是执行线程，它是最小的处理单元。 由操作系统调度。 通常它包含在进程中。 因此，同一个进程中可以存在多个线程。它与进程共享资源:内存、代码(指令)和全局变量(上下文——它的变量在任何给定时刻引用的值)。 在单个处理器上，每个线程根据时间进行多路复用；在多处理器上，每个线程同时运行，每个处理器/核心运行一个特定的线程。 为什么用多线程 在应用程序本身中有多个执行线程的应用程序称为多线程应用程序。 例如，如果我们想创
Python 高性能编程
GitChat
04-13 4698
你将获得 通过阅读本书，你将能够： 更好地掌握 numpy、Cython 和剖析器； 了解 Python 如何抽象化底层的计算机架构； 使用剖析手段来寻找 CPU 时间和内存使用的瓶颈； 通过选择合适的数据结构来编写高效的程序； 加速矩阵和矢量计算； 使用工具把 Python 编译成机器代码； 管理并发的多 I O 和计算操作； 把多进程代码转换到在本地或者远程集群上运行； 用更少的内存...
CPU / GPU串行/并行翻转图片（一）
weixin_43087913的博客
11-09 321
参考书籍：《基于CUDA的GPU并行程序开发指南》 在Windows10中的项目，原来的程序可以在Linux中直接运行，这里做了一点修改。 测试电脑为：四核心八线程 单线程水平方向翻转： 单线程竖直方向翻转： 多线程水平方向翻转： 多线程竖直方向翻转： 可以看到多线程处理计算密集型任务是很有效的，后面继续改进程序。 源码地址：待定 ...
gopython 多线程问题_Python 的多线程与多进程-Go语言中文社区
weixin_39946274的博客
02-23 185
初学者的并行编程指南在参加 Kaggle 的Understanding the Amazon from Space比赛时，我试图对自己代码的各个部分进行加速。速度在 Kaggle 比赛中至关重要。高排名常常需要尝试数百种模型结构与超参组合，能在一个持续一分钟的 epoch 中省出 10 秒都是一个巨大的胜利。让我吃惊的是，数据处理是最大的瓶颈。我用了 Numpy 的矩阵旋转、矩阵翻转、缩放及裁...
python高性能后端_理解高性能 Python
weixin_39576336的博客
12-07 192
第1章 理解高性能Python读完本章之后你将能够回答下列问题计算机架构有哪些元素？常见的计算机架构有哪些？计算机架构在Python中的抽象表达是什么？实现高性能Python代码的障碍在哪里？性能问题有哪些种类？计算机编程可以被认为是以特定的方式进行数据的移动和转换来得到某种结果。然而这些操作有时间上的开销。因此，高性能编程可以被认为是通过降低开销(比如撰写更高效的代码)或改变操作方式(比如寻找一...
Python 的多线程与多进程
python学习者的博客
08-31 632
原文地址：Intro to Threads and Processes in Python 原文作者：Brendan Fortuner 译文出自：掘金翻译计划 本文永久链接：github.com/xitu/gold-m… 译者：lsvih 校对者：yqian1991 初学者的并行编程指南 在参加 Kaggle 的Understanding the Amaz...
Python高性能编程--理解高性能Python
xxxicebrother的博客
12-24 1739
Python高性能编程--理解高性能Python首先理解高性能编程基本计算机架构计算单元存储单元通信层Python虚拟机Python的优势 《Python高性能编程》笔记 首先理解高性能编程 高性能编程 可以被认为是通过降低开销（撰写更高效的代码）或改变操作方式（寻找更适合的算法）使得操作的代价更小。 基本计算机架构 计算机底层组件分为三部分： 连接连接计算单元存储单元 计算单元 计算单元：计算机...
【随笔】论多线程CPU离线渲染器的实现：A CPU BASED OFFLINE RENDERING ENGINE
这里是大千小熊的博客，一个温暖故事的开篇
10-15 1292
一个高性能，低占用，便于用户使用的CPU离线渲染器。本项目不使用现有的相关图形库（如：OpenGL、DirectX）而是从头自己写一遍（根据现有的论文），重新设计相关算法与技术。它具有高性能，低占用的特点，它便于用户使用，采用离线算法进行渲染计算。在这个渲染器项目中，实现了众多算法包括不限于NPR基于物理的真实渲染，PBR非真实渲染等；可以配合现有的Blender、C4D、3DMAX等DCC软件，进行协同使用；它操作简单，支持简单化云计算等创新功能；完全使用CPU进行渲染，对GPU做到了0占用。
Android性能优化-线程性能优化
yubachang2012的博客
12-14 442
线程的性能 熟练使用Android上的线程可以帮助你提高应用程序的性能。 本篇文章讨论了使用线程的几个方面：使用UI或主线程; 应用程序生命周期和线程优先级之间的关系; 以及平台提供的帮助管理线程复杂性的方法。 在每一部分，本篇都描述了潜在的陷阱以及如何避免它们的策略。 主线程 当用户启动你的应用程序时，Android会创建一个新的 Linux process 以及一个执行线
python什么时候用进程什么时候用线程_[译] Python 的多线程与多进程
weixin_39551554的博客
11-26 126
Python 的多线程与多进程初学者的并行编程指南在参加 Kaggle 的 Understanding the Amazon from Space 比赛时，我试图对自己代码的各个部分进行加速。速度在 Kaggle 比赛中至关重要。高排名常常需要尝试数百种模型结构与超参组合，能在一个持续一分钟的 epoch 中省出 10 秒都是一个巨大的胜利。让我吃惊的是，数据处理是最大的瓶颈。我用了 Numpy ...
并行计算_并行计算_多线程_
10-03
使用三种多线程并行计算的方法计算pi值，内附c++可执行源码
mpi.rar_mpi作业_mpi多线程 c++_圆周率_并行计算 作业
09-22
C++编写的多线程圆周率运算。并行计算课上老师的作业
MST.rar_OpenMP多线程_mst_openmp_并行计算_最小生成树
09-23
最小生成树问题。多线程编程、并行计算。使用OpenMP计算最小生成树。
HPC.rar_HPC_并行机_并行程序设计_并行计算_计算机 性能
09-14
高性能并行计算机系统分类,可作为并行程序设计的入门介绍
C语言笔记第15篇：文件操作
2302_78977491的博客
06-14 1040
磁盘（硬盘）上的文件就是文件。但是程序设计中，我们一般谈两个文件，分别是程序文件、数据文件（从文件的角度来分类的）。2.1函数名功能适用于fgetc字符输入函数所有输入流fputc字符输出函数所有输出流fgets文本行输入函数所有输入流fputs文本行输出函数所有输出流fscanf格式化输入函数所有输入流fprintf格式化输出函数所有输出流fread二进制输入文件fwrite二进制输出文件fputc的使用fputc函数：参数1：character是需要输出的字符。
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 455
【代码】力扣LCP 08.剧情触发时间。
算法训练营day60
最新发布
stmfresher的博客
06-16 224
【代码】算法训练营day60。
算法体系-20 第二十节暴力递归到动态规划
m0_61164038的博客
06-12 345
四种模型和体系班两种模型一共六种模型0.1 从左往右模型0.2 范围讨论模型范围尝试模型 （这种模型特别在乎讨论开头如何如何 结尾如何如何）玩家博弈问题，玩家玩纸牌只能那左或者右0.3 样本对应样本对应模型（特别在乎两个样本结尾如何如何 最长公共子序列）0.4 业务限制模型动态规划只是暴力尝试的一个缓存。
多线程分别绑定cpu属于并行吗
06-01
并行是指同时执行多个任务的情况，而多线程分别绑定CPU可以使得多个线程在不同的CPU核心上同时执行，实现了并行。 在多核CPU中，操作系统可以将多个线程分别绑定到不同的CPU核心上执行，这样不同的线程可以在不同的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值