SlideShare a Scribd company logo
1 of 49
Download to read offline
第11回 画像処理
長岡技術科学大学 電気電子情報工学専攻 出川智啓
今回の内容
2015/06/24GPGPU実践プログラミング2
 ビットマップ画像のフォーマット
 ビットマップの読込と保存
 画像処理
 ネガティブ処理
 グレイスケール
 空間フィルタ
 CUDAの組み込み型uchar4の利用
ビットマップ画像
2015/06/24GPGPU実践プログラミング3
 画像の表現・保存形式の一つ
 画像を画素(pixel)の集合として捉え,各画素の色を3原色
(赤緑青,RGB)で表す
 1画素あたり1バイト~4バイト
 jpg画像のように画像圧縮を施さないのでデータ量が画像サ
イズに比例して増大
 圧縮形式もあるがあまり利用されない
 zip形式等のファイル圧縮を使うと効果的に圧縮可能
 画像の幅,高さが2の冪乗,24bitビットマップのみを対象
ビットマップファイルフォーマット
2015/06/24GPGPU実践プログラミング4
 ファイルの情報を表すヘッダ+画像の各画素情報
 ヘッダ
 ファイルヘッダ+情報ヘッダの合計54バイト
 ファイルヘッダ
 ファイルの種類,ファイルサイズ等
 情報ヘッダ
 画像の幅,高さ,1画素あたりのデータサイズなど
ビットマップファイルフォーマット
2015/06/24GPGPU実践プログラミング5
 24bitビットマップファイルのバイナリダンプ
ファイルヘッダ
情報ヘッダ
画像情報
1画素の情報
ビットマップファイルフォーマット
2015/06/24GPGPU実践プログラミング6
 ファイルヘッダ
 エンディアン(endian, 多バイトデータの記述・格納形式)
内容 サイズ 備考
ファイルの種類 u2 ビットマップの場合はBM
ファイルサイズ(byte)
u4
16進数表記(リトルエンディアン,下位
ビットが先に書かれる)
予約領域1 u2 必ず0
予約領域2 u2 必ず0
ファイル先頭から画像までの
オフセット u4
windowsビットマップでは54
(16進数表記で36)
36 00 03 00
リトルエンディアン 00 03 00 3616=196,662 byte
ビッグエンディアン 36 00 03 0016=905,970,432 byte
ビットマップファイルフォーマット
2015/06/24GPGPU実践プログラミング7
 情報ヘッダ
内容 byte数 備考
情報ヘッダのサイズ u4 必ず40(byte, 16進数表記で28)
画像の幅(pixel) 4 16進数表記
画像の高さ(pixel) 4 16進数表記
プレーン数 u2 必ず1
色ビット数(bit/pixel) u2 1,4,8,24,32(16進数表記)
圧縮形式 u4 0,1,2,3のいずれか
画像データサイズ u4 16進数表記
水平解像度(dot/m) 4 0の場合もある
垂直解像度(dot/m) 4 0の場合もある
パレット数(使用色数) u4 0の場合もある
重要な色の数 u4 0の場合もある
ビットマップファイルフォーマット
2015/06/24GPGPU実践プログラミング8
 画像情報(24bitビットマップ)
 3原色の情報をそれぞれ1バイト(unsigned char)で保持
 3原色の並び順はBGR
 幅は行単位で4バイトの倍数に揃えられる
 画素の並びは左下から右方向,下から上方向
B G R
ビットマップファイルの読み込み
2015/06/24GPGPU実践プログラミング9
1. 対象ファイルをオープン
2. ファイルヘッダを読み込み
 ファイルサイズを取得
3. 情報ヘッダを読み込み
 画像の幅,高さ,1画素のビット数を取得
4. メモリ確保
5. 画素情報を読み込み
#include<stdio.h>
#ifndef __BMPHEADER__
#define __BMPHEADER__
#pragma pack(push,1)
//ビットマップファイルヘッダ
typedef struct{
unsigned short bfType;   //ファイルの種類
unsigned int bfSize;   //ファイルサイズ
unsigned short bfReserved1; //予約領域1
unsigned short bfReserved2; //予約領域2
unsigned int bfOffBits;    //オフセット
} BmpFileHeader;
//ビットマップ情報ヘッダ
typedef struct{
unsigned int biSize; //情報ヘッダサイズ
int biWidth;           //幅
int biHeight;         //高さ
unsigned short biPlanes;    //プレーン数
unsigned short biBitCount;   //色ビット数
unsigned int biCompression;//圧縮形式
unsigned int biSizeImage; //画像サイズ
int biXPelsPerMeter;//解像度
int biYPelsPerMeter;//解像度
unsigned int biClrUsed;    //使用色数
unsigned int biClrImportant; //重要色
} BmpInfoHeader;
//1画素の情報
typedef struct{
unsigned char B;
unsigned char G;
unsigned char R;
} BGR;
#pragma pack(pop)
typedef struct{
BGR *pixel;
int width;
int height;
} Img;
#endif
CPUプログラム(ビットマップヘッダ)
2015/06/24GPGPU実践プログラミング10
bmpheader.h
ビットマップヘッダ用構造体定義時の注意
2015/06/24GPGPU実践プログラミング11
 構造体のサイズ
 メンバ変数サイズの合計にならない場合がある
 アクセス最適化のためのパディング
 多くの場合4バイト境界にアライメント
 アライメントを変更する命令
 #pragma pack(push, 1)~#pragma pack(pop)
 pack~popで挟まれた範囲では1バイト境界にアライメント
 実質的に構造体のパディングを防止
ヘッダファイル作成時の注意
2015/06/24GPGPU実践プログラミング12
 インクルードガード
 ヘッダファイルの多重includeによる多重定義を回避
bmpheader.h
typedef struct{
}BmpFileHeader;
bmpheader.h
#ifndef __BMPHEADER_H__
#define __BMPHEADER_H__
typedef struct{
}BmpFileHeader;
#endif
source1.c
#include<bmpheader.h>
source2.c
#include<bmpheader.h>
source1.c
#include<bmpheader.h>
source2.c
#include<bmpheader.h>
BmpFileHeaderが2
回定義される
2回目のincludeでは定
義部分は処理されない
__BMPHEADER_H__が定
義されていないときだけ
BmpFileHeaderを定義
インクルードガード無 インクルードガード有
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"bmpheader.h"
int readBmpHeader(FILE *fp, BmpFileHeader *fileHdr, 
BmpInfoHeader *infoHdr){
fread(fileHdr, sizeof(BmpFileHeader), 1, fp);
fread(infoHdr, sizeof(BmpInfoHeader), 1, fp);
return 0;
}
int readBmpBody(FILE *fp, Img *bmp){
fread(bmp‐>pixel, sizeof(BGR), 
bmp‐>width*bmp‐>height, fp);
return 0;
}
int readBmp(char *filename, Img *bmp,
BmpFileHeader *fileHdr, BmpInfoHeader *infoHdr){
//ファイルをバイナリモードで開く
FILE *fp = fopen(filename, "rb");
readBmpHeader(fp, fileHdr, infoHdr);
bmp‐>width = infoHdr‐>biWidth;
bmp‐>height = infoHdr‐>biHeight;
bmp‐>pixel = (BGR *)malloc
(bmp‐>width*bmp‐>height*sizeof(BGR));
readBmpBody(fp, bmp);
fclose(fp);
return 0;
}
int writeBmp(char *outputfilename, Img *bmp,
BmpFileHeader *fileHdr, BmpInfoHeader *infoHdr){
//ファイルをバイナリモードで開く
FILE *fp = fopen(outputfilename, "wb");
fwrite(fileHdr, sizeof(BmpFileHeader), 1, fp);
fwrite(infoHdr, sizeof(BmpInfoHeader), 1, fp);
fwrite(bmp‐>pixel, sizeof(BGR), 
bmp‐>width*bmp‐>height, fp);
fclose(fp);
return 0;
}
CPUプログラム(ビットマップ読み込み)
2015/06/24GPGPU実践プログラミング13
main.c
ファイル入力
2015/06/24GPGPU実践プログラミング14
 fread
 指定したバイト数のデータを指定回数ファイルから読み込む
 stdio.hで定義
#include<stdio.h>
fread(読込先変数,1回あたりの読込サイズ,読込回数,ファイルポインタ);
//ファイルfpからBmpFileHeaderのバイト数分(14バイト)のデータを1回読み込み,
//fileHdrに格納
fread(fileHdr, sizeof(BmpFileHeader), 1, fp);
//ファイルfpからBGRのバイト数分(3バイト)のデータを幅×高さのピクセル数回
//読み込み,bmpのメンバpixelに格納
fread(bmp‐>pixel, sizeof(BGR),bmp‐>width*bmp‐>height, fp);
ファイル出力
2015/06/24GPGPU実践プログラミング15
 fwrite
 指定したバイト数のデータを指定回数ファイルへ書き込む
 stdio.hで定義
#include<stdio.h>
fwrite(書込元変数,1回あたりの書込サイズ,書込回数,ファイルポインタ);
//fileHdrの内容をBmpFileHeaderのバイト数分(14バイト)だけファイルfpに書込む
//書込回数は1回
fwrite(fileHdr, sizeof(BmpFileHeader), 1, fp);
//pixelの内容をBGRのバイト数分(3バイト)ファイルfpに書込む
//書込回数はデータを幅×高さのピクセル数
fwrite(bmp‐>pixel, sizeof(BGR), bmp‐>width*bmp‐>height, fp);
int main(void){
char *filename = "Parrots.bmp";
char *outputfilename = "output.bmp";
BmpFileHeader fileHdr;
BmpInfoHeader infoHdr;
Img bmp;
readBmp(filename, &bmp, &fileHdr, &infoHdr);
//ここに画像処理を記述
writeBmp(outputfilename,&bmp, &fileHdr, &infoHdr);
free(bmp.pixel);
return 0;
}
CPUプログラム(ビットマップ読み込み)
2015/06/24GPGPU実践プログラミング16
main.c
画像処理
2015/06/24GPGPU実践プログラミング17
 比較的簡単な4種類のフィルタを実装
 ネガティブ処理
 画像の反転
 グレイスケール
 空間フィルタ
ネガティブ処理
2015/06/24GPGPU実践プログラミング18
 色の反転処理
 黒(0,0,0)↔白(255,255,255)
 各ピクセルの色(B,G,R)を(255−B,255−G,255−R)に置換
元画像 処理画像
void negative(Img *bmp){
for(int j=0;j<bmp‐>height;j++){
for(int i=0;i<bmp‐>width ;i++){
int ij = i+bmp‐>width*j;
bmp‐>pixel[ij].B = 255 ‐ bmp‐>pixel[ij].B;
bmp‐>pixel[ij].G = 255 ‐ bmp‐>pixel[ij].G;
bmp‐>pixel[ij].R = 255 ‐ bmp‐>pixel[ij].R;
}
}
}
ネガティブ処理
2015/06/24GPGPU実践プログラミング19
main.c
画像の反転
2015/06/24GPGPU実践プログラミング20
 画像の幾何的位置を反転
 元画像から画素を読み込み,配列添字を変更して書き出し
 j→(height‐1)‐j
元画像 処理画像
j
height‐10
void yreflect(Img *bmp){
BGR *filtered;
filtered = (BGR *)malloc(bmp‐>width*bmp‐>height*sizeof(BGR));
for(int j=0;j<bmp‐>height;j++)
for(int i=0;i<bmp‐>width ;i++){
int ij = i+bmp‐>width*j;
int ijreflected = i+bmp‐>width*(bmp‐>height‐j‐1);
filtered[ijreflected].B = bmp‐>pixel[ij].B;
filtered[ijreflected].G = bmp‐>pixel[ij].G;
filtered[ijreflected].R = bmp‐>pixel[ij].R;
}
for(int j=1;j<bmp‐>height‐1;j++)
for(int i=1;i<bmp‐>width ‐1;i++){
int i__j__ = (i )+bmp‐>width*(j  );
bmp‐>pixel[i__j__].B = filtered[i__j__].B;
bmp‐>pixel[i__j__].G = filtered[i__j__].G;
bmp‐>pixel[i__j__].R = filtered[i__j__].R;
}
free(filtered);
}
画像の反転
2015/06/24GPGPU実践プログラミング21
main.c
グレイスケール
2015/06/24GPGPU実践プログラミング22
 フルカラー画像をモノクロ256階調に変換
 NTSC加重平均法を用いて各画素に重みを付けて計算
 0.114478×B+0.586611×G+0.298912×R
元画像 処理画像
void gray(Img *bmp){
for(int j=0;j<bmp‐>height;j++)
for(int i=0;i<bmp‐>width ;i++){
int ij = i+bmp‐>width*j;
unsigned char gray =(unsigned char)( 0.114478f*(float)bmp‐>pixel[ij].B
+0.586611f*(float)bmp‐>pixel[ij].G
+0.298912f*(float)bmp‐>pixel[ij].R);
bmp‐>pixel[ij].B = gray; //ビットマップファイルフォーマットを変更すれば1色のみ保持する
bmp‐>pixel[ij].G = gray; //だけでよくなるが,今回は24bitのまま変更せず,BGRに同じ値
bmp‐>pixel[ij].R = gray; //を代入する
}
}
グレイスケール
2015/06/24GPGPU実践プログラミング23
main.c
空間フィルタ
2015/06/24GPGPU実践プログラミング24
 ある画素に処理を施す際に,周囲の画素の情報も利用
 処理の仕方を規定したカーネルを定義
 カーネルを変更することで様々な処理が可能
元画像 処理画像
空間フィルタ
2015/06/24GPGPU実践プログラミング25
 ぼかし処理(平均フィルタ)
元画像 処理画像
1/9 1/9 1/9
1/9 1/9 1/9
1/9 1/9 1/9
=( a+b+c
+d+e+f
+g+h+i)/9
フィルタ
(カーネル)
a b c
d e f
g h i
空間フィルタ
2015/06/24GPGPU実践プログラミング26
 ガウスぼかし処理(加重平均フィルタ)
元画像 処理画像
1/16 2/16 1/16
2/16 4/16 2/16
1/16 2/16 1/16
a b c
d e f
g h i
=(   a+2*b+  c
+2*d+4*e+2*f
+  g+2*h+  i)/16
フィルタ
(カーネル)
void boxfilter(Img *bmp, float filter[3][3]){
BGR *filtered = (BGR *)malloc(bmp‐>width*bmp‐>height*sizeof(BGR));
int width = bmp‐>width;
for(int j=1;j<bmp‐>height‐1;j++){
for(int i=1;i<bmp‐>width ‐1;i++){
int i__j__ = (i  )+width*(j  );
int ip1j__ = (i+1)+width*(j  );
int im1j__ = (i‐1)+width*(j  );
int i__jp1 = (i )+width*(j+1);
int i__jm1 = (i  )+width*(j‐1);
int ip1jp1 = (i+1)+width*(j+1);
int im1jp1 = (i‐1)+width*(j+1);
int ip1jm1 = (i+1)+width*(j‐1);
int im1jm1 = (i‐1)+width*(j‐1);
filtered[i__j__].B =(unsigned char)( filter[0][0]*bmp‐>pixel[im1jm1].B
+filter[1][0]*bmp‐>pixel[i__jm1].B+filter[2][0]*bmp‐>pixel[ip1jm1].B
+filter[0][1]*bmp‐>pixel[im1j__].B+filter[1][1]*bmp‐>pixel[i__j__].B
+filter[2][1]*bmp‐>pixel[ip1j__].B+filter[0][2]*bmp‐>pixel[im1jp1].B
+filter[1][2]*bmp‐>pixel[i__jp1].B+filter[2][2]*bmp‐>pixel[ip1jp1].B);
空間フィルタ
2015/06/24GPGPU実践プログラミング27
main.c
空間フィルタ
2015/06/24GPGPU実践プログラミング28
filtered[i__j__].G =(unsigned char)( filter[0][0]*bmp‐>pixel[im1jm1].G
+filter[1][0]*bmp‐>pixel[i__jm1].G+filter[2][0]*bmp‐>pixel[ip1jm1].G
+filter[0][1]*bmp‐>pixel[im1j__].G+filter[1][1]*bmp‐>pixel[i__j__].G
+filter[2][1]*bmp‐>pixel[ip1j__].G+filter[0][2]*bmp‐>pixel[im1jp1].G
+filter[1][2]*bmp‐>pixel[i__jp1].G+filter[2][2]*bmp‐>pixel[ip1jp1].G);
filtered[i__j__].R =(unsigned char)( filter[0][0]*bmp‐>pixel[im1jm1].R
+filter[1][0]*bmp‐>pixel[i__jm1].R+filter[2][0]*bmp‐>pixel[ip1jm1].R
+filter[0][1]*bmp‐>pixel[im1j__].R+filter[1][1]*bmp‐>pixel[i__j__].R
+filter[2][1]*bmp‐>pixel[ip1j__].R+filter[0][2]*bmp‐>pixel[im1jp1].R
+filter[1][2]*bmp‐>pixel[i__jp1].R+filter[2][2]*bmp‐>pixel[ip1jp1].R);
}
}
for(int j=1;j<bmp‐>height‐1;j++){
for(int i=1;i<bmp‐>width ‐1;i++){
int i__j__ = (i )+bmp‐>width*(j  );
bmp‐>pixel[i__j__].B = filtered[i__j__].B;
bmp‐>pixel[i__j__].G = filtered[i__j__].G;
bmp‐>pixel[i__j__].R = filtered[i__j__].R;
}
}
free(filtered);
} main.c
空間フィルタの数学的記述
2015/06/24GPGPU実践プログラミング29
 2次元畳み込み演算
 入力画像IへのフィルタK(サイズm×m)の適用
 Iw,hは画像Iの(w, h)番目のピクセル











dXdYYyXxgYXfgf ),(),(
  

2/
2/
2/
2/
,,,
m
mi
m
mj
jhiwjihw IAKII
空間フィルタの数学的記述
2015/06/24GPGPU実践プログラミング30
 フィルタの分離
 フィルタKがKx, Kyの畳み込みで表される場合,空間フィルタを
縦と横に分離可能
 横方向にフィルタ書けた後,縦方向にフィルタをかける
)()( IKKIKKIK yxyx 



































3
1
3
1
3
1
3
1
,
3
1
,
3
1
1,11,1,1
,1,,1
1,11,1,1
hwhwhw
hwhwhw
hwhwhw
III
III
III
平均フィルタ



































4
1
4
2
4
1
4
1
,
4
2
,
4
1
1,11,1,1
,1,,1
1,11,1,1
hwhwhw
hwhwhw
hwhwhw
III
III
III
加重平均フィルタ
GPU実装
2015/06/24GPGPU実践プログラミング31
 1スレッドが1ピクセル(3原色)の処理を実行
 空間フィルタ以外は単純に実装可能
 forの2重ループを排除し,配列添字とスレッド番号を対応
 カーネル内でメモリの確保ができないため,入力画像と
出力画像を分離
 空間フィルタは端の画素の処理ができないので今回は
処理しない
 フィルタの係数はコンスタントメモリにコピー
uchar4型
2015/06/24GPGPU実践プログラミング32
 CUDAで定義されているベクトル型
 利用するとメモリアクセスが最適化されることがある
 8bit符号なし整数
 x, y, z, wをメンバに持つ
 宣言
 uchar4 pixel
 pixel.x, pixel.y, pixel.z, pixel.wとして利用
 xを青,yを緑,zを赤に対応
 wは利用しない
__global__ void cvtBGRToUchar4(BGR *bmp, uchar4 *pixel, int width, int height){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
int ij = i + width*j;
//make_uchar4はCUDAで定義される関数
pixel[ij] = make_uchar4(bmp[ij].B, bmp[ij].G, bmp[ij].R, 0);
}
__global__ void cvtUchar4ToBGR(uchar4 *pixel, BGR *bmp,int width, int height){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
int ij = i + width*j;
bmp[ij].B = pixel[ij].x;
bmp[ij].G = pixel[ij].y;
bmp[ij].R = pixel[ij].z;
}
BGR型とuchar4の相互変換
2015/06/24GPGPU実践プログラミング33
kernel.cu
__global__ void negativeUchar4(uchar4 *pixel, int width, int height, uchar4 *filtered){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
int ij = i + width*j;
filtered[ij].x = 255 ‐ pixel[ij].x;
filtered[ij].y = 255 ‐ pixel[ij].y;
filtered[ij].z = 255 ‐ pixel[ij].z;
//filtered[ij].w = 255 ‐ pixel[ij].w;//.wの処理は不要
}
ネガティブ処理(uchar4版)
2015/06/24GPGPU実践プログラミング34
kernel.cu
__global__ void negativeBGR(BGR *pixel, int width, int height, BGR *filtered){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
int ij = i + width*j;
filtered[ij].B = 255 ‐ pixel[ij].B;
filtered[ij].G = 255 ‐ pixel[ij].G;
filtered[ij].R = 255 ‐ pixel[ij].R;
}
ネガティブ処理(BGR版)
2015/06/24GPGPU実践プログラミング35
kernel.cu
__global__ void yreflectUchar4(uchar4 *pixel, int width, int height, uchar4 *filtered){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
int ij = i + width*j;
int ijreflected = i + width*(height‐1 ‐ j);
filtered[ijreflected].x = pixel[ij].x;
filtered[ijreflected].y = pixel[ij].y;
filtered[ijreflected].z = pixel[ij].z;
filtered[ijreflected].w = pixel[ij].w;//単純な代入の場合,.wは無駄でも処理を記述しておく
}
画像の反転(uchar4版)
2015/06/24GPGPU実践プログラミング36
kernel.cu
__global__ void yreflectBGR(BGR *pixel, int width, int height, BGR *filtered){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
int ij = i + width*j;
int ijreflected = i + width*(height ‐ j ‐ 1);
filtered[ijreflected].B = pixel[ij].B;
filtered[ijreflected].G = pixel[ij].G;
filtered[ijreflected].R = pixel[ij].R;
}
画像の反転(BGR版)
2015/06/24GPGPU実践プログラミング37
kernel.cu
__global__ void grayUchar4(uchar4 *pixel, int width, int height, uchar4 *filtered){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
int ij = i + width*j;
unsigned char gray = (unsigned char)(  0.114478f*(float)pixel[ij].x
+ 0.586611f*(float)pixel[ij].y
+ 0.298912f*(float)pixel[ij].z);
filtered[ij].x = gray;
filtered[ij].y = gray;
filtered[ij].z = gray;
}
グレイスケール(uchar4版)
2015/06/24GPGPU実践プログラミング38
kernel.cu
__global__ void grayBGR(BGR *pixel, int width, int height, BGR *filtered){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
int ij = i + width*j;
unsigned char gray = (unsigned char)( 0.114478f*(float)pixel[ij].B
+ 0.586611f*(float)pixel[ij].G
+ 0.298912f*(float)pixel[ij].R);
filtered[ij].B = gray;
filtered[ij].G = gray;
filtered[ij].R = gray;
}
グレイスケール(BGR版)
2015/06/24GPGPU実践プログラミング39
kernel.cu
__global__ void boxfilterUchar4(uchar4 *pixel, int width, int height, uchar4 *filtered){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
if (0<i&&i<width && 0<j&&j<height){
int i__j__ = (i  )+width*(j  );
int ip1j__ = (i+1)+width*(j  );
int im1j__ = (i‐1)+width*(j  );
int i__jp1 = (i )+width*(j+1);
int i__jm1 = (i  )+width*(j‐1);
int ip1jp1 = (i+1)+width*(j+1);
int im1jp1 = (i‐1)+width*(j+1);
int ip1jm1 = (i+1)+width*(j‐1);
int im1jm1 = (i‐1)+width*(j‐1);
//cfilterはコンスタントメモリ
filtered[i__j__].x =(unsigned char)( cfilter[0][0]*pixel[im1jm1].x
+cfilter[1][0]*pixel[i__jm1].x+cfilter[2][0]*pixel[ip1jm1].x
+cfilter[0][1]*pixel[im1j__].x+cfilter[1][1]*pixel[i__j__].x
+cfilter[2][1]*pixel[ip1j__].x+cfilter[0][2]*pixel[im1jp1].x
+cfilter[1][2]*pixel[i__jp1].x+cfilter[2][2]*pixel[ip1jp1].x);
空間フィルタ(uchar4版)
2015/06/24GPGPU実践プログラミング40
kernel.cu
filtered[i__j__].y =(unsigned char)( cfilter[0][0]*pixel[im1jm1].y
+cfilter[1][0]*pixel[i__jm1].y+cfilter[2][0]*pixel[ip1jm1].y
+cfilter[0][1]*pixel[im1j__].y+cfilter[1][1]*pixel[i__j__].y
+cfilter[2][1]*pixel[ip1j__].y+cfilter[0][2]*pixel[im1jp1].y
+cfilter[1][2]*pixel[i__jp1].y+cfilter[2][2]*pixel[ip1jp1].y);
filtered[i__j__].z =(unsigned char)( cfilter[0][0]*pixel[im1jm1].z
+cfilter[1][0]*pixel[i__jm1].z+cfilter[2][0]*pixel[ip1jm1].z
+cfilter[0][1]*pixel[im1j__].z+cfilter[1][1]*pixel[i__j__].z
+cfilter[2][1]*pixel[ip1j__].z+cfilter[0][2]*pixel[im1jp1].z
+cfilter[1][2]*pixel[i__jp1].z+cfilter[2][2]*pixel[ip1jp1].z);
}
}
空間フィルタ(uchar4版)
2015/06/24GPGPU実践プログラミング41
kernel.cu
__global__ void boxfilterBGR(BGR *pixel, int width, int height, BGR *filtered){
int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;
if (0<i&&i<width && 0<j&&j<height){
int i__j__ = (i  )+width*(j  );
int ip1j__ = (i+1)+width*(j  );
int im1j__ = (i‐1)+width*(j  );
int i__jp1 = (i )+width*(j+1);
int i__jm1 = (i  )+width*(j‐1);
int ip1jp1 = (i+1)+width*(j+1);
int im1jp1 = (i‐1)+width*(j+1);
int ip1jm1 = (i+1)+width*(j‐1);
int im1jm1 = (i‐1)+width*(j‐1);
filtered[i__j__].B =(unsigned char)( cfilter[0][0]*pixel[im1jm1].B
+cfilter[1][0]*pixel[i__jm1].B+cfilter[2][0]*pixel[ip1jm1].B
+cfilter[0][1]*pixel[im1j__].B+cfilter[1][1]*pixel[i__j__].B
+cfilter[2][1]*pixel[ip1j__].B+cfilter[0][2]*pixel[im1jp1].B
+cfilter[1][2]*pixel[i__jp1].B+cfilter[2][2]*pixel[ip1jp1].B);
空間フィルタ(BGR版)
2015/06/24GPGPU実践プログラミング42
kernel.cu
filtered[i__j__].G =(unsigned char)( cfilter[0][0]*pixel[im1jm1].G
+cfilter[1][0]*pixel[i__jm1].G+cfilter[2][0]*pixel[ip1jm1].G
+cfilter[0][1]*pixel[im1j__].G+cfilter[1][1]*pixel[i__j__].G
+cfilter[2][1]*pixel[ip1j__].G+cfilter[0][2]*pixel[im1jp1].G
+cfilter[1][2]*pixel[i__jp1].G+cfilter[2][2]*pixel[ip1jp1].G);
filtered[i__j__].R =(unsigned char)( cfilter[0][0]*pixel[im1jm1].R
+cfilter[1][0]*pixel[i__jm1].R+cfilter[2][0]*pixel[ip1jm1].R
+cfilter[0][1]*pixel[im1j__].R+cfilter[1][1]*pixel[i__j__].R
+cfilter[2][1]*pixel[ip1j__].R+cfilter[0][2]*pixel[im1jp1].R
+cfilter[1][2]*pixel[i__jp1].R+cfilter[2][2]*pixel[ip1jp1].R);
}
}
空間フィルタ(BGR版)
2015/06/24GPGPU実践プログラミング43
kernel.cu
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<cuda_runtime.h>
#include"bmpheader.h"
#include"kernel.cu"
int main(void){
float blurfilter[3][3]={{1.0f/9.0f,1.0f/9.0f,1.0f/9.0f},
{1.0f/9.0f,1.0f/9.0f,1.0f/9.0f},
{1.0f/9.0f,1.0f/9.0f,1.0f/9.0f}};
float gaussianfilter[3][3]={{1.0f/16.0f,2.0f/16.0f,1.0f/16.0f},
{2.0f/16.0f,4.0f/16.0f,2.0f/16.0f},
{1.0f/16.0f,2.0f/16.0f,1.0f/16.0f}};
//フィルタ用の係数テーブルをコンスタントメモリへコピー
cudaMemcpyToSymbol(cfilter, gaussianfilter,3*3*sizeof(float));
GPUプログラム(メイン)
2015/06/24GPGPU実践プログラミング44
main.cu
char *filename = "ParrotsLarge.bmp";
char *outputfilename = "output.bmp";
BmpFileHeader fileHdr;
BmpInfoHeader infoHdr;
Img bmp;
//ビットマップファイルの読み込み
readBmp(filename, &bmp, &fileHdr, &infoHdr);
//画像データをBGR型でGPUへコピー
BGR *dev_bmp;
cudaMalloc((void **)&dev_bmp,sizeof(BGR)*bmp.width*bmp.height);
cudaMemcpy(dev_bmp, bmp.pixel, sizeof(BGR)*bmp.width*bmp.height,cudaMemcpyHostToDevice);
//ここに画像処理を記述
//ビットマップファイルの書き出し
writeBmp(outputfilename, &bmp, &fileHdr, &infoHdr);
free(bmp.pixel);
return 0;
}
GPUプログラム(メイン)
2015/06/24GPGPU実践プログラミング45
main.cu
dim3 thread = dim3(THREADX, THREADY, 1);
dim3 block  = dim3(bmp.width/thread.x, bmp.height/thread.y, 1);
uchar4 *pixel,*uchar4filtered;
cudaMalloc((void **)&pixel, sizeof(uchar4)*bmp.width*bmp.height);
cudaMalloc((void **)&uchar4filtered, sizeof(uchar4)*bmp.width*bmp.height);
//BGR型をuchar4型に変換
cvtBGRToUchar4<<<block,thread>>>(dev_bmp, pixel, bmp.width, bmp.height);
//negativeUchar4<<<block, thread>>>(pixel,bmp.width, bmp.height, uchar4filtered);
//yreflectUchar4<<<block, thread>>>(pixel,bmp.width, bmp.height, uchar4filtered);
//grayUchar4<<<block, thread>>>(pixel, bmp.width, bmp.height, uchar4filtered);
boxfilterUchar4 <<<block, thread>>>(pixel, bmp.width, bmp.height, uchar4filtered);
//フィルタ処理後の画像と原画像のポインタを交換し,処理後の画像をBGR型に変換
uchar4 *swap = uchar4filtered; uchar4filtered = pixel; pixel = swap;
cvtUchar4ToBGR <<<block, thread>>>(pixel, dev_bmp, bmp.width, bmp.height);
//画像をホストメモリへコピー
cudaMemcpy(bmp.pixel, dev_bmp, sizeof(BGR)*bmp.width*bmp.height, cudaMemcpyDeviceToHost);
cudaFree(pixel);
cudaFree(uchar4filtered);
GPUプログラム(uchar4型を使う場合)
2015/06/24GPGPU実践プログラミング46
main.cu
dim3 thread = dim3(THREADX, THREADY, 1);
dim3 block  = dim3(bmp.width/thread.x, bmp.height/thread.y, 1);
BGR *BGRfiltered;
cudaMalloc((void **)&BGRfiltered, sizeof(BGR)*bmp.width*bmp.height);
//negativeBGR<<<block, thread>>>(dev_bmp, bmp.width, bmp.height, BGRfiltered);
//yreflectBGR<<<block, thread>>>(dev_bmp, bmp.width, bmp.height, BGRfiltered);
//grayBGR<<<block, thread>>>(dev_bmp, bmp.width, bmp.height, BGRfiltered);
boxfilterBGR<<<block, thread>>>(dev_bmp, bmp.width, bmp.height, BGRfiltered);
BGR *swap = BGRfiltered; BGRfiltered = dev_bmp; dev_bmp = swap;
//画像をホストメモリへコピー
cudaMemcpy(bmp.pixel, dev_bmp, sizeof(BGR)*bmp.width*bmp.height, cudaMemcpyDeviceToHost);
cudaFree(dev_bmp);
cudaFree(BGRfiltered);
GPUプログラム(BGR型を使う場合)
2015/06/24GPGPU実践プログラミング47
main.cu
uchar4版とBGR4版の比較
(Tesla M2050, CUDA4.0)
2015/06/24GPGPU実践プログラミング48
0
200
400
600
800
1000
1200
1400
1600
negative yreflect gray boxfilter cvtBGRToUchar4 cvtUchar4ToBGR
BGR
uchar4
GPU Time [s]
uchar4版とBGR4版の比較
(GTX Titan, CUDA6.5)
2015/06/24GPGPU実践プログラミング49
0
200
400
600
800
1000
1200
1400
1600
negative yreflect gray boxfilter cvtBGRToUchar4 cvtUchar4ToBGR
BGR
uchar4
GPU Time [s]

More Related Content

What's hot

2015年度GPGPU実践基礎工学 第3回 GPUクラスタ上でのプログラミング(CUDA)
2015年度GPGPU実践基礎工学 第3回 GPUクラスタ上でのプログラミング(CUDA)2015年度GPGPU実践基礎工学 第3回 GPUクラスタ上でのプログラミング(CUDA)
2015年度GPGPU実践基礎工学 第3回 GPUクラスタ上でのプログラミング(CUDA)
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第15回 CPUとGPUの協調
2015年度先端GPGPUシミュレーション工学特論 第15回 CPUとGPUの協調2015年度先端GPGPUシミュレーション工学特論 第15回 CPUとGPUの協調
2015年度先端GPGPUシミュレーション工学特論 第15回 CPUとGPUの協調
智啓 出川
 
2015年度GPGPU実践基礎工学 第9回 GPUのアーキテクチャ
2015年度GPGPU実践基礎工学 第9回 GPUのアーキテクチャ2015年度GPGPU実践基礎工学 第9回 GPUのアーキテクチャ
2015年度GPGPU実践基礎工学 第9回 GPUのアーキテクチャ
智啓 出川
 
2015年度GPGPU実践プログラミング 第3回 GPGPUプログラミング環境
2015年度GPGPU実践プログラミング 第3回 GPGPUプログラミング環境2015年度GPGPU実践プログラミング 第3回 GPGPUプログラミング環境
2015年度GPGPU実践プログラミング 第3回 GPGPUプログラミング環境
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第4回 GPUのメモリ階層の詳細 (共有メモリ)
2015年度先端GPGPUシミュレーション工学特論 第4回 GPUのメモリ階層の詳細(共有メモリ)2015年度先端GPGPUシミュレーション工学特論 第4回 GPUのメモリ階層の詳細(共有メモリ)
2015年度先端GPGPUシミュレーション工学特論 第4回 GPUのメモリ階層の詳細 (共有メモリ)
智啓 出川
 
GPGPU Seminar (Accelerataion of Lattice Boltzmann Method using CUDA Fortran)
GPGPU Seminar (Accelerataion of Lattice Boltzmann Method using CUDA Fortran)GPGPU Seminar (Accelerataion of Lattice Boltzmann Method using CUDA Fortran)
GPGPU Seminar (Accelerataion of Lattice Boltzmann Method using CUDA Fortran)
智啓 出川
 
2015年度GPGPU実践プログラミング 第6回 パフォーマンス解析ツール
2015年度GPGPU実践プログラミング 第6回 パフォーマンス解析ツール2015年度GPGPU実践プログラミング 第6回 パフォーマンス解析ツール
2015年度GPGPU実践プログラミング 第6回 パフォーマンス解析ツール
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第1回 先端シミュレーションおよび産業界におけるGPUの役割
2015年度先端GPGPUシミュレーション工学特論 第1回 先端シミュレーションおよび産業界におけるGPUの役割2015年度先端GPGPUシミュレーション工学特論 第1回 先端シミュレーションおよび産業界におけるGPUの役割
2015年度先端GPGPUシミュレーション工学特論 第1回 先端シミュレーションおよび産業界におけるGPUの役割
智啓 出川
 
2015年度GPGPU実践基礎工学 第1回 学際的分野における先端シミュレーション技術の歴史
2015年度GPGPU実践基礎工学 第1回 学際的分野における先端シミュレーション技術の歴史2015年度GPGPU実践基礎工学 第1回 学際的分野における先端シミュレーション技術の歴史
2015年度GPGPU実践基礎工学 第1回 学際的分野における先端シミュレーション技術の歴史
智啓 出川
 
2015年度GPGPU実践基礎工学 第10回 GPUのプログラム構造
2015年度GPGPU実践基礎工学 第10回 GPUのプログラム構造2015年度GPGPU実践基礎工学 第10回 GPUのプログラム構造
2015年度GPGPU実践基礎工学 第10回 GPUのプログラム構造
智啓 出川
 
2015年度GPGPU実践基礎工学 第13回 GPUのメモリ階層
2015年度GPGPU実践基礎工学 第13回 GPUのメモリ階層2015年度GPGPU実践基礎工学 第13回 GPUのメモリ階層
2015年度GPGPU実践基礎工学 第13回 GPUのメモリ階層
智啓 出川
 
GPGPU Seminar (GPGPU and CUDA Fortran)
GPGPU Seminar (GPGPU and CUDA Fortran)GPGPU Seminar (GPGPU and CUDA Fortran)
GPGPU Seminar (GPGPU and CUDA Fortran)
智啓 出川
 
2015年度GPGPU実践基礎工学 第5回 ハードウェアによるCPUの高速化技術
2015年度GPGPU実践基礎工学 第5回 ハードウェアによるCPUの高速化技術2015年度GPGPU実践基礎工学 第5回 ハードウェアによるCPUの高速化技術
2015年度GPGPU実践基礎工学 第5回 ハードウェアによるCPUの高速化技術
智啓 出川
 
2015年度GPGPU実践プログラミング 第5回 GPUのメモリ階層
2015年度GPGPU実践プログラミング 第5回 GPUのメモリ階層2015年度GPGPU実践プログラミング 第5回 GPUのメモリ階層
2015年度GPGPU実践プログラミング 第5回 GPUのメモリ階層
智啓 出川
 
2015年度GPGPU実践プログラミング 第4回 GPUでの並列プログラミング(ベクトル和,移動平均,差分法)
2015年度GPGPU実践プログラミング 第4回 GPUでの並列プログラミング(ベクトル和,移動平均,差分法)2015年度GPGPU実践プログラミング 第4回 GPUでの並列プログラミング(ベクトル和,移動平均,差分法)
2015年度GPGPU実践プログラミング 第4回 GPUでの並列プログラミング(ベクトル和,移動平均,差分法)
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第2回 GPUによる並列計算の概念と メモリアクセス
2015年度先端GPGPUシミュレーション工学特論 第2回 GPUによる並列計算の概念とメモリアクセス2015年度先端GPGPUシミュレーション工学特論 第2回 GPUによる並列計算の概念とメモリアクセス
2015年度先端GPGPUシミュレーション工学特論 第2回 GPUによる並列計算の概念と メモリアクセス
智啓 出川
 
2015年度GPGPU実践基礎工学 第6回 ソフトウェアによるCPUの高速化技術
2015年度GPGPU実践基礎工学 第6回 ソフトウェアによるCPUの高速化技術2015年度GPGPU実践基礎工学 第6回 ソフトウェアによるCPUの高速化技術
2015年度GPGPU実践基礎工学 第6回 ソフトウェアによるCPUの高速化技術
智啓 出川
 
GPGPU Seminar (PyCUDA)
GPGPU Seminar (PyCUDA)GPGPU Seminar (PyCUDA)
GPGPU Seminar (PyCUDA)
智啓 出川
 

What's hot (20)

2015年度GPGPU実践基礎工学 第3回 GPUクラスタ上でのプログラミング(CUDA)
2015年度GPGPU実践基礎工学 第3回 GPUクラスタ上でのプログラミング(CUDA)2015年度GPGPU実践基礎工学 第3回 GPUクラスタ上でのプログラミング(CUDA)
2015年度GPGPU実践基礎工学 第3回 GPUクラスタ上でのプログラミング(CUDA)
 
2015年度先端GPGPUシミュレーション工学特論 第15回 CPUとGPUの協調
2015年度先端GPGPUシミュレーション工学特論 第15回 CPUとGPUの協調2015年度先端GPGPUシミュレーション工学特論 第15回 CPUとGPUの協調
2015年度先端GPGPUシミュレーション工学特論 第15回 CPUとGPUの協調
 
2015年度GPGPU実践基礎工学 第9回 GPUのアーキテクチャ
2015年度GPGPU実践基礎工学 第9回 GPUのアーキテクチャ2015年度GPGPU実践基礎工学 第9回 GPUのアーキテクチャ
2015年度GPGPU実践基礎工学 第9回 GPUのアーキテクチャ
 
GPGPU Education at Nagaoka University of Technology: A Trial Run
GPGPU Education at Nagaoka University of Technology: A Trial RunGPGPU Education at Nagaoka University of Technology: A Trial Run
GPGPU Education at Nagaoka University of Technology: A Trial Run
 
2015年度GPGPU実践プログラミング 第3回 GPGPUプログラミング環境
2015年度GPGPU実践プログラミング 第3回 GPGPUプログラミング環境2015年度GPGPU実践プログラミング 第3回 GPGPUプログラミング環境
2015年度GPGPU実践プログラミング 第3回 GPGPUプログラミング環境
 
2015年度先端GPGPUシミュレーション工学特論 第4回 GPUのメモリ階層の詳細 (共有メモリ)
2015年度先端GPGPUシミュレーション工学特論 第4回 GPUのメモリ階層の詳細(共有メモリ)2015年度先端GPGPUシミュレーション工学特論 第4回 GPUのメモリ階層の詳細(共有メモリ)
2015年度先端GPGPUシミュレーション工学特論 第4回 GPUのメモリ階層の詳細 (共有メモリ)
 
GPGPU Seminar (Accelerataion of Lattice Boltzmann Method using CUDA Fortran)
GPGPU Seminar (Accelerataion of Lattice Boltzmann Method using CUDA Fortran)GPGPU Seminar (Accelerataion of Lattice Boltzmann Method using CUDA Fortran)
GPGPU Seminar (Accelerataion of Lattice Boltzmann Method using CUDA Fortran)
 
2015年度GPGPU実践プログラミング 第6回 パフォーマンス解析ツール
2015年度GPGPU実践プログラミング 第6回 パフォーマンス解析ツール2015年度GPGPU実践プログラミング 第6回 パフォーマンス解析ツール
2015年度GPGPU実践プログラミング 第6回 パフォーマンス解析ツール
 
2015年度先端GPGPUシミュレーション工学特論 第1回 先端シミュレーションおよび産業界におけるGPUの役割
2015年度先端GPGPUシミュレーション工学特論 第1回 先端シミュレーションおよび産業界におけるGPUの役割2015年度先端GPGPUシミュレーション工学特論 第1回 先端シミュレーションおよび産業界におけるGPUの役割
2015年度先端GPGPUシミュレーション工学特論 第1回 先端シミュレーションおよび産業界におけるGPUの役割
 
2015年度GPGPU実践基礎工学 第1回 学際的分野における先端シミュレーション技術の歴史
2015年度GPGPU実践基礎工学 第1回 学際的分野における先端シミュレーション技術の歴史2015年度GPGPU実践基礎工学 第1回 学際的分野における先端シミュレーション技術の歴史
2015年度GPGPU実践基礎工学 第1回 学際的分野における先端シミュレーション技術の歴史
 
2015年度GPGPU実践基礎工学 第10回 GPUのプログラム構造
2015年度GPGPU実践基礎工学 第10回 GPUのプログラム構造2015年度GPGPU実践基礎工学 第10回 GPUのプログラム構造
2015年度GPGPU実践基礎工学 第10回 GPUのプログラム構造
 
2015年度GPGPU実践基礎工学 第13回 GPUのメモリ階層
2015年度GPGPU実践基礎工学 第13回 GPUのメモリ階層2015年度GPGPU実践基礎工学 第13回 GPUのメモリ階層
2015年度GPGPU実践基礎工学 第13回 GPUのメモリ階層
 
GPGPU Seminar (GPGPU and CUDA Fortran)
GPGPU Seminar (GPGPU and CUDA Fortran)GPGPU Seminar (GPGPU and CUDA Fortran)
GPGPU Seminar (GPGPU and CUDA Fortran)
 
2015年度GPGPU実践基礎工学 第5回 ハードウェアによるCPUの高速化技術
2015年度GPGPU実践基礎工学 第5回 ハードウェアによるCPUの高速化技術2015年度GPGPU実践基礎工学 第5回 ハードウェアによるCPUの高速化技術
2015年度GPGPU実践基礎工学 第5回 ハードウェアによるCPUの高速化技術
 
2015年度GPGPU実践プログラミング 第5回 GPUのメモリ階層
2015年度GPGPU実践プログラミング 第5回 GPUのメモリ階層2015年度GPGPU実践プログラミング 第5回 GPUのメモリ階層
2015年度GPGPU実践プログラミング 第5回 GPUのメモリ階層
 
2015年度GPGPU実践プログラミング 第4回 GPUでの並列プログラミング(ベクトル和,移動平均,差分法)
2015年度GPGPU実践プログラミング 第4回 GPUでの並列プログラミング(ベクトル和,移動平均,差分法)2015年度GPGPU実践プログラミング 第4回 GPUでの並列プログラミング(ベクトル和,移動平均,差分法)
2015年度GPGPU実践プログラミング 第4回 GPUでの並列プログラミング(ベクトル和,移動平均,差分法)
 
2015年度先端GPGPUシミュレーション工学特論 第2回 GPUによる並列計算の概念と メモリアクセス
2015年度先端GPGPUシミュレーション工学特論 第2回 GPUによる並列計算の概念とメモリアクセス2015年度先端GPGPUシミュレーション工学特論 第2回 GPUによる並列計算の概念とメモリアクセス
2015年度先端GPGPUシミュレーション工学特論 第2回 GPUによる並列計算の概念と メモリアクセス
 
2015年度GPGPU実践基礎工学 第6回 ソフトウェアによるCPUの高速化技術
2015年度GPGPU実践基礎工学 第6回 ソフトウェアによるCPUの高速化技術2015年度GPGPU実践基礎工学 第6回 ソフトウェアによるCPUの高速化技術
2015年度GPGPU実践基礎工学 第6回 ソフトウェアによるCPUの高速化技術
 
技術系大学におけるGPU教育の一試行
技術系大学におけるGPU教育の一試行技術系大学におけるGPU教育の一試行
技術系大学におけるGPU教育の一試行
 
GPGPU Seminar (PyCUDA)
GPGPU Seminar (PyCUDA)GPGPU Seminar (PyCUDA)
GPGPU Seminar (PyCUDA)
 

Viewers also liked

2015年度GPGPU実践プログラミング 第7回 総和計算
2015年度GPGPU実践プログラミング 第7回 総和計算2015年度GPGPU実践プログラミング 第7回 総和計算
2015年度GPGPU実践プログラミング 第7回 総和計算
智啓 出川
 
2015年度GPGPU実践プログラミング 第10回 行列計算(行列-行列積の高度な最適化)
2015年度GPGPU実践プログラミング 第10回 行列計算(行列-行列積の高度な最適化)2015年度GPGPU実践プログラミング 第10回 行列計算(行列-行列積の高度な最適化)
2015年度GPGPU実践プログラミング 第10回 行列計算(行列-行列積の高度な最適化)
智啓 出川
 
2015年度GPGPU実践プログラミング 第13回 多粒子の運動
2015年度GPGPU実践プログラミング 第13回 多粒子の運動2015年度GPGPU実践プログラミング 第13回 多粒子の運動
2015年度GPGPU実践プログラミング 第13回 多粒子の運動
智啓 出川
 
2015年度GPGPU実践プログラミング 第14回 N体問題
2015年度GPGPU実践プログラミング 第14回 N体問題2015年度GPGPU実践プログラミング 第14回 N体問題
2015年度GPGPU実践プログラミング 第14回 N体問題
智啓 出川
 
2015年度GPGPU実践プログラミング 第9回 行列計算(行列-行列積)
2015年度GPGPU実践プログラミング 第9回 行列計算(行列-行列積)2015年度GPGPU実践プログラミング 第9回 行列計算(行列-行列積)
2015年度GPGPU実践プログラミング 第9回 行列計算(行列-行列積)
智啓 出川
 
2015年度GPGPU実践プログラミング 第8回 総和計算(高度な最適化)
2015年度GPGPU実践プログラミング 第8回 総和計算(高度な最適化)2015年度GPGPU実践プログラミング 第8回 総和計算(高度な最適化)
2015年度GPGPU実践プログラミング 第8回 総和計算(高度な最適化)
智啓 出川
 
2015年度GPGPU実践プログラミング 第12回 偏微分方程式の差分計算
2015年度GPGPU実践プログラミング 第12回 偏微分方程式の差分計算2015年度GPGPU実践プログラミング 第12回 偏微分方程式の差分計算
2015年度GPGPU実践プログラミング 第12回 偏微分方程式の差分計算
智啓 出川
 
2015年度GPGPU実践基礎工学 第7回 シングルコアとマルチコア
2015年度GPGPU実践基礎工学 第7回 シングルコアとマルチコア2015年度GPGPU実践基礎工学 第7回 シングルコアとマルチコア
2015年度GPGPU実践基礎工学 第7回 シングルコアとマルチコア
智啓 出川
 
2015年度GPGPU実践基礎工学 第8回 並列計算の概念 (プロセスとスレッド)
2015年度GPGPU実践基礎工学 第8回 並列計算の概念(プロセスとスレッド)2015年度GPGPU実践基礎工学 第8回 並列計算の概念(プロセスとスレッド)
2015年度GPGPU実践基礎工学 第8回 並列計算の概念 (プロセスとスレッド)
智啓 出川
 
2015年度GPGPU実践基礎工学 第15回 GPGPU開発環境 (OpenCL)
2015年度GPGPU実践基礎工学 第15回 GPGPU開発環境(OpenCL)2015年度GPGPU実践基礎工学 第15回 GPGPU開発環境(OpenCL)
2015年度GPGPU実践基礎工学 第15回 GPGPU開発環境 (OpenCL)
智啓 出川
 
2015年度GPGPU実践基礎工学 第14回 GPGPU組込開発環境
2015年度GPGPU実践基礎工学 第14回 GPGPU組込開発環境2015年度GPGPU実践基礎工学 第14回 GPGPU組込開発環境
2015年度GPGPU実践基礎工学 第14回 GPGPU組込開発環境
智啓 出川
 

Viewers also liked (12)

2015年度GPGPU実践プログラミング 第7回 総和計算
2015年度GPGPU実践プログラミング 第7回 総和計算2015年度GPGPU実践プログラミング 第7回 総和計算
2015年度GPGPU実践プログラミング 第7回 総和計算
 
2015年度GPGPU実践プログラミング 第10回 行列計算(行列-行列積の高度な最適化)
2015年度GPGPU実践プログラミング 第10回 行列計算(行列-行列積の高度な最適化)2015年度GPGPU実践プログラミング 第10回 行列計算(行列-行列積の高度な最適化)
2015年度GPGPU実践プログラミング 第10回 行列計算(行列-行列積の高度な最適化)
 
2015年度GPGPU実践プログラミング 第13回 多粒子の運動
2015年度GPGPU実践プログラミング 第13回 多粒子の運動2015年度GPGPU実践プログラミング 第13回 多粒子の運動
2015年度GPGPU実践プログラミング 第13回 多粒子の運動
 
2015年度GPGPU実践プログラミング 第14回 N体問題
2015年度GPGPU実践プログラミング 第14回 N体問題2015年度GPGPU実践プログラミング 第14回 N体問題
2015年度GPGPU実践プログラミング 第14回 N体問題
 
2015年度GPGPU実践プログラミング 第9回 行列計算(行列-行列積)
2015年度GPGPU実践プログラミング 第9回 行列計算(行列-行列積)2015年度GPGPU実践プログラミング 第9回 行列計算(行列-行列積)
2015年度GPGPU実践プログラミング 第9回 行列計算(行列-行列積)
 
2015年度GPGPU実践プログラミング 第8回 総和計算(高度な最適化)
2015年度GPGPU実践プログラミング 第8回 総和計算(高度な最適化)2015年度GPGPU実践プログラミング 第8回 総和計算(高度な最適化)
2015年度GPGPU実践プログラミング 第8回 総和計算(高度な最適化)
 
2015年度GPGPU実践プログラミング 第12回 偏微分方程式の差分計算
2015年度GPGPU実践プログラミング 第12回 偏微分方程式の差分計算2015年度GPGPU実践プログラミング 第12回 偏微分方程式の差分計算
2015年度GPGPU実践プログラミング 第12回 偏微分方程式の差分計算
 
2015年度GPGPU実践基礎工学 第9回補足 GROUSEの利用方法
2015年度GPGPU実践基礎工学 第9回補足 GROUSEの利用方法2015年度GPGPU実践基礎工学 第9回補足 GROUSEの利用方法
2015年度GPGPU実践基礎工学 第9回補足 GROUSEの利用方法
 
2015年度GPGPU実践基礎工学 第7回 シングルコアとマルチコア
2015年度GPGPU実践基礎工学 第7回 シングルコアとマルチコア2015年度GPGPU実践基礎工学 第7回 シングルコアとマルチコア
2015年度GPGPU実践基礎工学 第7回 シングルコアとマルチコア
 
2015年度GPGPU実践基礎工学 第8回 並列計算の概念 (プロセスとスレッド)
2015年度GPGPU実践基礎工学 第8回 並列計算の概念(プロセスとスレッド)2015年度GPGPU実践基礎工学 第8回 並列計算の概念(プロセスとスレッド)
2015年度GPGPU実践基礎工学 第8回 並列計算の概念 (プロセスとスレッド)
 
2015年度GPGPU実践基礎工学 第15回 GPGPU開発環境 (OpenCL)
2015年度GPGPU実践基礎工学 第15回 GPGPU開発環境(OpenCL)2015年度GPGPU実践基礎工学 第15回 GPGPU開発環境(OpenCL)
2015年度GPGPU実践基礎工学 第15回 GPGPU開発環境 (OpenCL)
 
2015年度GPGPU実践基礎工学 第14回 GPGPU組込開発環境
2015年度GPGPU実践基礎工学 第14回 GPGPU組込開発環境2015年度GPGPU実践基礎工学 第14回 GPGPU組込開発環境
2015年度GPGPU実践基礎工学 第14回 GPGPU組込開発環境
 

More from 智啓 出川

GPGPU Seminar (GPU Accelerated Libraries, 3 of 3, Thrust)
GPGPU Seminar (GPU Accelerated Libraries, 3 of 3, Thrust) GPGPU Seminar (GPU Accelerated Libraries, 3 of 3, Thrust)
GPGPU Seminar (GPU Accelerated Libraries, 3 of 3, Thrust)
智啓 出川
 
GPGPU Seminar (GPU Accelerated Libraries, 2 of 3, cuSPARSE)
GPGPU Seminar (GPU Accelerated Libraries, 2 of 3, cuSPARSE) GPGPU Seminar (GPU Accelerated Libraries, 2 of 3, cuSPARSE)
GPGPU Seminar (GPU Accelerated Libraries, 2 of 3, cuSPARSE)
智啓 出川
 
GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS)
GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS) GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS)
GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS)
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第13回 数値流体力学への応用 (高度な最適化)
2015年度先端GPGPUシミュレーション工学特論 第13回 数値流体力学への応用(高度な最適化)2015年度先端GPGPUシミュレーション工学特論 第13回 数値流体力学への応用(高度な最適化)
2015年度先端GPGPUシミュレーション工学特論 第13回 数値流体力学への応用 (高度な最適化)
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第11回 数値流体力学への応用 (支配方程式,CPUプログラム)
2015年度先端GPGPUシミュレーション工学特論 第11回 数値流体力学への応用(支配方程式,CPUプログラム)2015年度先端GPGPUシミュレーション工学特論 第11回 数値流体力学への応用(支配方程式,CPUプログラム)
2015年度先端GPGPUシミュレーション工学特論 第11回 数値流体力学への応用 (支配方程式,CPUプログラム)
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第10回 Poisson方程式の求解 (線形連立一次方程式)
2015年度先端GPGPUシミュレーション工学特論 第10回 Poisson方程式の求解(線形連立一次方程式)2015年度先端GPGPUシミュレーション工学特論 第10回 Poisson方程式の求解(線形連立一次方程式)
2015年度先端GPGPUシミュレーション工学特論 第10回 Poisson方程式の求解 (線形連立一次方程式)
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第9回 偏微分方程式の差分計算 (移流方程式)
2015年度先端GPGPUシミュレーション工学特論 第9回 偏微分方程式の差分計算(移流方程式)2015年度先端GPGPUシミュレーション工学特論 第9回 偏微分方程式の差分計算(移流方程式)
2015年度先端GPGPUシミュレーション工学特論 第9回 偏微分方程式の差分計算 (移流方程式)
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第8回 偏微分方程式の差分計算 (拡散方程式)
2015年度先端GPGPUシミュレーション工学特論 第8回 偏微分方程式の差分計算(拡散方程式)2015年度先端GPGPUシミュレーション工学特論 第8回 偏微分方程式の差分計算(拡散方程式)
2015年度先端GPGPUシミュレーション工学特論 第8回 偏微分方程式の差分計算 (拡散方程式)
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第7回 総和計算(Atomic演算)
2015年度先端GPGPUシミュレーション工学特論 第7回 総和計算(Atomic演算)2015年度先端GPGPUシミュレーション工学特論 第7回 総和計算(Atomic演算)
2015年度先端GPGPUシミュレーション工学特論 第7回 総和計算(Atomic演算)
智啓 出川
 
2015年度先端GPGPUシミュレーション工学特論 第6回 プログラムの性能評価指針 (Flop/Byte,計算律速,メモリ律速)
2015年度先端GPGPUシミュレーション工学特論 第6回 プログラムの性能評価指針(Flop/Byte,計算律速,メモリ律速)2015年度先端GPGPUシミュレーション工学特論 第6回 プログラムの性能評価指針(Flop/Byte,計算律速,メモリ律速)
2015年度先端GPGPUシミュレーション工学特論 第6回 プログラムの性能評価指針 (Flop/Byte,計算律速,メモリ律速)
智啓 出川
 

More from 智啓 出川 (20)

Fortranが拓く世界、VSCodeが架ける橋
Fortranが拓く世界、VSCodeが架ける橋Fortranが拓く世界、VSCodeが架ける橋
Fortranが拓く世界、VSCodeが架ける橋
 
Very helpful python code to find coefficients of the finite difference method
Very helpful python code to find coefficients of the finite difference methodVery helpful python code to find coefficients of the finite difference method
Very helpful python code to find coefficients of the finite difference method
 
Why do we confuse String and Array of Characters in Fortran?
Why do we confuse String and Array of Characters in Fortran?Why do we confuse String and Array of Characters in Fortran?
Why do we confuse String and Array of Characters in Fortran?
 
Pythonによる累乗近似
Pythonによる累乗近似Pythonによる累乗近似
Pythonによる累乗近似
 
数値計算結果のPythonによる後処理について(1次元データのピーク値およびその位置の推定)
数値計算結果のPythonによる後処理について(1次元データのピーク値およびその位置の推定)数値計算結果のPythonによる後処理について(1次元データのピーク値およびその位置の推定)
数値計算結果のPythonによる後処理について(1次元データのピーク値およびその位置の推定)
 
オブジェクト指向Fortranが拓く(はずだった)新しい世界
オブジェクト指向Fortranが拓く(はずだった)新しい世界オブジェクト指向Fortranが拓く(はずだった)新しい世界
オブジェクト指向Fortranが拓く(はずだった)新しい世界
 
Schematic diagrams of GPUs' architecture and Time evolution of theoretical FL...
Schematic diagrams of GPUs' architecture and Time evolution of theoretical FL...Schematic diagrams of GPUs' architecture and Time evolution of theoretical FL...
Schematic diagrams of GPUs' architecture and Time evolution of theoretical FL...
 
GPGPU Seminar (GPU Accelerated Libraries, 3 of 3, Thrust)
GPGPU Seminar (GPU Accelerated Libraries, 3 of 3, Thrust) GPGPU Seminar (GPU Accelerated Libraries, 3 of 3, Thrust)
GPGPU Seminar (GPU Accelerated Libraries, 3 of 3, Thrust)
 
GPGPU Seminar (GPU Accelerated Libraries, 2 of 3, cuSPARSE)
GPGPU Seminar (GPU Accelerated Libraries, 2 of 3, cuSPARSE) GPGPU Seminar (GPU Accelerated Libraries, 2 of 3, cuSPARSE)
GPGPU Seminar (GPU Accelerated Libraries, 2 of 3, cuSPARSE)
 
GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS)
GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS) GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS)
GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS)
 
Cuda fortranの利便性を高めるfortran言語の機能
Cuda fortranの利便性を高めるfortran言語の機能Cuda fortranの利便性を高めるfortran言語の機能
Cuda fortranの利便性を高めるfortran言語の機能
 
PGI CUDA FortranとGPU最適化ライブラリの一連携法
PGI CUDA FortranとGPU最適化ライブラリの一連携法PGI CUDA FortranとGPU最適化ライブラリの一連携法
PGI CUDA FortranとGPU最適化ライブラリの一連携法
 
教育機関でのJetsonの活用の可能性
教育機関でのJetsonの活用の可能性教育機関でのJetsonの活用の可能性
教育機関でのJetsonの活用の可能性
 
2015年度先端GPGPUシミュレーション工学特論 第13回 数値流体力学への応用 (高度な最適化)
2015年度先端GPGPUシミュレーション工学特論 第13回 数値流体力学への応用(高度な最適化)2015年度先端GPGPUシミュレーション工学特論 第13回 数値流体力学への応用(高度な最適化)
2015年度先端GPGPUシミュレーション工学特論 第13回 数値流体力学への応用 (高度な最適化)
 
2015年度先端GPGPUシミュレーション工学特論 第11回 数値流体力学への応用 (支配方程式,CPUプログラム)
2015年度先端GPGPUシミュレーション工学特論 第11回 数値流体力学への応用(支配方程式,CPUプログラム)2015年度先端GPGPUシミュレーション工学特論 第11回 数値流体力学への応用(支配方程式,CPUプログラム)
2015年度先端GPGPUシミュレーション工学特論 第11回 数値流体力学への応用 (支配方程式,CPUプログラム)
 
2015年度先端GPGPUシミュレーション工学特論 第10回 Poisson方程式の求解 (線形連立一次方程式)
2015年度先端GPGPUシミュレーション工学特論 第10回 Poisson方程式の求解(線形連立一次方程式)2015年度先端GPGPUシミュレーション工学特論 第10回 Poisson方程式の求解(線形連立一次方程式)
2015年度先端GPGPUシミュレーション工学特論 第10回 Poisson方程式の求解 (線形連立一次方程式)
 
2015年度先端GPGPUシミュレーション工学特論 第9回 偏微分方程式の差分計算 (移流方程式)
2015年度先端GPGPUシミュレーション工学特論 第9回 偏微分方程式の差分計算(移流方程式)2015年度先端GPGPUシミュレーション工学特論 第9回 偏微分方程式の差分計算(移流方程式)
2015年度先端GPGPUシミュレーション工学特論 第9回 偏微分方程式の差分計算 (移流方程式)
 
2015年度先端GPGPUシミュレーション工学特論 第8回 偏微分方程式の差分計算 (拡散方程式)
2015年度先端GPGPUシミュレーション工学特論 第8回 偏微分方程式の差分計算(拡散方程式)2015年度先端GPGPUシミュレーション工学特論 第8回 偏微分方程式の差分計算(拡散方程式)
2015年度先端GPGPUシミュレーション工学特論 第8回 偏微分方程式の差分計算 (拡散方程式)
 
2015年度先端GPGPUシミュレーション工学特論 第7回 総和計算(Atomic演算)
2015年度先端GPGPUシミュレーション工学特論 第7回 総和計算(Atomic演算)2015年度先端GPGPUシミュレーション工学特論 第7回 総和計算(Atomic演算)
2015年度先端GPGPUシミュレーション工学特論 第7回 総和計算(Atomic演算)
 
2015年度先端GPGPUシミュレーション工学特論 第6回 プログラムの性能評価指針 (Flop/Byte,計算律速,メモリ律速)
2015年度先端GPGPUシミュレーション工学特論 第6回 プログラムの性能評価指針(Flop/Byte,計算律速,メモリ律速)2015年度先端GPGPUシミュレーション工学特論 第6回 プログラムの性能評価指針(Flop/Byte,計算律速,メモリ律速)
2015年度先端GPGPUシミュレーション工学特論 第6回 プログラムの性能評価指針 (Flop/Byte,計算律速,メモリ律速)
 

2015年度GPGPU実践プログラミング 第11回 画像処理