programcg.cpp

SiftGPU is an implementation of SIFT [1] for GPU. SiftGPU processes pixels parallely to build Gaussi

{
	cgGLSetTextureParameter(_param_dog_texu, texU);
	cgGLEnableTextureParameter(_param_dog_texu);
	cgGLSetTextureParameter(_param_dog_texd, texD);
	cgGLEnableTextureParameter(_param_dog_texd);
}

void ShaderBagCG::SetGenListStepParam(int tex, int tex0)
{
	cgGLSetTextureParameter(_param_genlist_step_tex, tex);
	cgGLEnableTextureParameter(_param_genlist_step_tex);
	cgGLSetTextureParameter(_param_genlist_step_tex0, tex0);
	cgGLEnableTextureParameter(_param_genlist_step_tex0);
}

void ShaderBagCG::SetGenVBOParam(float width, float fwidth, float size)
{
	float sizes[4] = {size*3.0f, fwidth, width, 1.0f/width};
	cgGLSetParameter4fv(_param_genvbo_size, sizes);
}


ProgramGPU* FilterGLCG::CreateFilterH(float kernel[], float offset[], int width)
{


	char buffer[10240];
	ostrstream out(buffer, 10240);

	out<<setprecision(8);

	if(GlobalUtil::_BetaFilter)
	{
		out<< "void main(uniform samplerRECT tex,";
		out<<"\n\tin float4 TexCoord0: TEXCOORD0,";
		out<<"\n\tout float4 FragColor : COLOR0 )";
		out<<"\n{\n\tfloat4 intensity4 = float4(0, 0, 0, 0), data;\n";
		out<<"float or = texRECT(tex, TexCoord0.xy).r, intensity;\n";

		for(int i = 0; i< width; i+=4)
		{
			out <<"data = float4(";
			for(int j = i; j < i + 4; j++)
			{
				if(j != i) out <<", \n";
				if(j >= width)
				{
					out<<"0";
				}else if(offset[j]==0.0)
				{
					out<<"or";
				}else
				{
					out<<"texRECT(tex, TexCoord0.xy + float2(float("<<offset[j] <<") , 0)).r";
				}
			}
			out << ");\n";
			out << "intensity4 += data * float4(";
			for(int k = i; k < i + 4; k++)
			{
				if(k != i) out <<", ";
				if(k >= width)	out<<"0";
				else			out<<kernel[k];
			}
			out << ");\n";

 		}
		out << "intensity4.xy += intensity4.zw;\n";
		out << "intensity = intensity4.x + intensity4.y;\n";
	}else
	{
		out<< "void main(uniform samplerRECT tex,";
		out<<"\n\tin float4 TexCoord0: TEXCOORD0,";
		out<<"\n\tout float4 FragColor : COLOR0 )";
		out<<"\n{\n\tfloat intensity = 0.0 ;  float2 pos;\n";

		for(int i = 0; i< width; i++)
		{
			if(offset[i]==0.0)
			{
				out<<"float or = texRECT(tex, TexCoord0.xy).r;\n";
				out<<"intensity+= or * "<<kernel[i]<<";\n";

			}else
			{
				out<<"pos = TexCoord0.xy + float2(float("<<offset[i] <<") , 0);\n";
				out<<"intensity+= "<<kernel[i]<<"*texRECT(tex, pos).r;\n";
			}
		}
	}
	//copy original data to red channel
	out<<"FragColor.r = or;\n"; 
	out<<"FragColor.b  = intensity;}\n"<<'\0';

	return new ProgramCG( buffer);
}


ProgramGPU* FilterGLCG::CreateFilterV(float kernel[], float offset[], int height)
{
	char buffer[10240];
	ostrstream out(buffer, 10240);
	out<<setprecision(8);

	if(GlobalUtil::_BetaFilter)
	{
		out<< "void main(uniform samplerRECT tex,";
		out<<"\n\tin float4 TexCoord0: TEXCOORD0,";
		out<<"\n\tout float4 FragColor : COLOR0 )";
		out<<"\n{\n\tfloat4 intensity4 = float4(0, 0, 0, 0), data;\n";
		out<<"float2 orb = texRECT(tex, TexCoord0.xy).rb; float intensity;\n";

		for(int i = 0; i< height; i+=4)
		{
			out <<"data = float4(";
			for(int j = i; j < i + 4; j++)
			{
				if(j != i) out <<", \n";
				if(j >= height)
				{
					out<<"0";
				}else if(offset[j]==0.0)
				{
					out<<"orb.y";
				}else
				{
					out<<"texRECT(tex, TexCoord0.xy + float2(0, float("<<offset[j] <<"))).b";
				}
			}
			out << ");\n";
			out << "intensity4 += data * float4(";
			for(int k = i; k < i + 4; k++)
			{
				if(k != i) out <<", ";
				if(k >= height)	out<<"0";
				else			out<<kernel[k];
			}
			out << ");\n";

 		}
		out << "intensity4.xy += intensity4.zw;\n";
		out << "intensity = intensity4.x + intensity4.y;\n";
	}else
	{
		out<< "void main(uniform samplerRECT tex,";
		out<<"\n\tin float4 TexCoord0: TEXCOORD0,";
		out<<"\n\tout float4 FragColor : COLOR0 )";
		out<<"\n{\n\tfloat intensity = 0.0 ;  float2 pos;\n";

		for(int i = 0; i< height; i++)
		{
			if(offset[i]==0.0)
			{
				out<<"float2 orb = texRECT(tex, TexCoord0.xy).rb;\n";
				out<<"intensity+= orb.y * "<<kernel[i]<<";\n";

			}else
			{
				out<<"pos = TexCoord0.xy + float2(0, float("<<offset[i] <<"));\n";
				out<<"intensity+= "<<kernel[i]<<"*texRECT(tex, pos).b;\n";
			}
		}
	}
	out<<"FragColor.b = orb.y;\n";
	out<<"FragColor.g = intensity - orb.x;\n"; // difference of gaussian..
	out<<"FragColor.r = intensity;}\n"<<'\0';
	
	return new ProgramCG( buffer);
}


ProgramGPU* FilterGLCG::CreateFilterHPK(float kernel[], float offset[], int width)
{
	//both h and v are packed...
	int i, j , xw, xwn;
	int halfwidth  = width >>1;
	float * pf = kernel + halfwidth;
	int nhpixel = (halfwidth+1)>>1;	//how many neighbour pixels need to be looked up
	int npixel  = (nhpixel<<1)+1;//
	char buffer[10240];
	float weight[3];
	ostrstream out(buffer, 10240);
	out<<setprecision(8);

	out<< "void main(uniform samplerRECT tex, float4 TexCoord0 : TEXCOORD0, out float4 FragColor : COLOR0 ){\n";
	out<< "float4 result = float4(0, 0, 0, 0); \nfloat4 pc; float2 coord; \n";
	///use multi texture coordinate because nhpixels can be at most 3
	for( i = 0 ; i < npixel ; i++)
	{

		out<<"coord = TexCoord0.xy + float2(float("<<i-nhpixel<<"),0);\n";
		out<<"pc=texRECT(tex, coord);\n";
		if(GlobalUtil::_PreciseBorder)		out<<"if(coord.x < 0) pc = pc.rrbb;\n";

		//for each sub-pixel j  in center, the weight of sub-pixel k 
		xw = (i - nhpixel)*2;
		for( j = 0; j < 3; j++)
		{
			xwn = xw  + j  -1;
			weight[j] = xwn < -halfwidth || xwn > halfwidth? 0 : pf[xwn];
		}
		//if(weight[1]!=0.0)	out<<"FragColor += "<<weight[1]<<"*pc;\n";
		//out<<"FragColor += float4("<<weight[2]<<","<<weight[0]<<","<<weight[2]<<","<<weight[0]<<")*pc.grab;\n";

		if(weight[1] == 0.0)
		{
			out<<"result += float4("<<weight[2]<<","<<weight[0]<<","<<weight[2]<<","<<weight[0]<<")*pc.grab;\n";
		}
		else
		{
			out<<"result += float4("<<weight[1]<<", "<<weight[0]<<", "<<weight[1]<<", "<<weight[0]<<")*pc.rrbb;\n";
			out<<"result += float4("<<weight[2]<<", "<<weight[1]<<", "<<weight[2]<<", "<<weight[1]<<")*pc.ggaa;\n";
		}

	}
	out<<
	"	 FragColor = result; }\n"<<'\0';
	return new ProgramCG( buffer);
}

ProgramGPU* FilterGLCG::CreateFilterVPK(float kernel[], float offset[], int height)
{

	//both h and v are packed...
	int i, j , yw, ywn;
	int halfh  = height >>1;
	float * pf = kernel + halfh;
	int nhpixel = (halfh+1)>>1;	//how many neighbour pixels need to be looked up
	int npixel  = (nhpixel<<1)+1;//
	char buffer[10240];
	float weight[3];
	ostrstream out(buffer, 10240);
	out<<setprecision(8);

	out<< "void main(uniform samplerRECT tex, float4 TexCoord0 : TEXCOORD0, out float4 FragColor : COLOR0 ){\n";
	out<< "float4 result = float4(0, 0, 0, 0);\nfloat4 pc; float2 coord;\n";
	///use multi texture coordinate because nhpixels can be at most 3

	for( i = 0 ; i < npixel ; i++)
	{

		out<<"coord = TexCoord0.xy + float2(0, float("<<i-nhpixel<<"));\n";
		out<<"pc=texRECT(tex, coord);\n";
		if(GlobalUtil::_PreciseBorder)	out<<"if(coord.y < 0) pc = pc.rgrg;\n";
		//for each sub-pixel j  in center, the weight of sub-pixel k 
		yw = (i - nhpixel)*2;
		for( j = 0; j < 3; j++)
		{
			ywn = yw + j  -1;
			weight[j] = ywn < -halfh || ywn > halfh? 0 : pf[ywn];
		}
		//if(weight[1]!=0.0)	out<<"FragColor += "<<weight[1]<<"*pc;\n";
		//out<<"FragColor += float4("<<weight[2]<<","<<weight[2]<<","<<weight[0]<<","<<weight[0]<<")*pc.barg;\n";
		if(weight[1] == 0.0)
		{
			out<<"result += float4("<<weight[2]<<","<<weight[2]<<","<<weight[0]<<","<<weight[0]<<")*pc.barg;\n";
		}else
		{
			out<<"result += float4("<<weight[1]<<","<<weight[1]<<","<<weight[0]<<","<<weight[0]<<")*pc.rgrg;\n";
			out<<"result += float4("<<weight[2]<<","<<weight[2]<<","<<weight[1]<<","<<weight[1]<<")*pc.baba;\n";
		}
	}
	out<<
	"	 FragColor = result; }\n"<<'\0';
	return new ProgramCG( buffer);
}


void ShaderBagCG::LoadGenListShader(int ndoglev, int nlev)
{
	ProgramCG * program;

	s_genlist_init_tight = new ProgramCG(
	"void main (\n"
	"uniform samplerRECT tex, in float4 TexCoord0 : TEXCOORD0,\n"
	"in float4 TexCoord1 : TEXCOORD1, in float4 TexCoord2 : TEXCOORD2, in float4 TexCoord3 : TEXCOORD3,\n"
	"out float4 FragColor : COLOR0){\n"
	"float4 helper = float4( texRECT(tex, TexCoord0.xy).r,  texRECT(tex, TexCoord1.xy).r,\n"
	"texRECT(tex, TexCoord2.xy).r, texRECT(tex, TexCoord3.xy).r);\n"
	"FragColor = float4(helper>0.0);\n"
	"}");

	s_genlist_init_ex = program = new ProgramCG(
	"void main (uniform float2 bbox, \n"
	"uniform samplerRECT tex, \n"
	"in float4 TexCoord0 : TEXCOORD0,\n"
	"in float4 TexCoord1 : TEXCOORD1, \n"
	"in float4 TexCoord2 : TEXCOORD2, \n"
	"in float4 TexCoord3 : TEXCOORD3,\n"
	"out float4 FragColor : COLOR0){\n"
	"float4 helper = float4( \n"
	"texRECT(tex, TexCoord0.xy).r, texRECT(tex, TexCoord1.xy).r,\n"
	"texRECT(tex, TexCoord2.xy).r, texRECT(tex, TexCoord3.xy).r);\n"
	"bool4 helper4 = bool4(TexCoord0.xy < bbox, TexCoord3.xy < bbox); \n"
	"bool4 helper2 = helper4.xzxz && helper4.yyww; \n"
	"FragColor = float4(helper2 && (helper>0.0 ));\n"
	"}");
	_param_genlist_init_bbox = cgGetNamedParameter( *program, "bbox");


	//reduction ...
	s_genlist_histo = new ProgramCG(
	"void main (\n"
	"uniform samplerRECT tex, in float2 TexCoord0 : TEXCOORD0,\n"
	"in float2 TexCoord1 : TEXCOORD1, in float2 TexCoord2 : TEXCOORD2, in float2 TexCoord3 : TEXCOORD3,\n"
	"out float4 FragColor : COLOR0){\n"
	"float4 helper; float4 helper2; \n"
	"helper = texRECT(tex, TexCoord0); helper2.xy = helper.xy + helper.zw; \n"
	"helper = texRECT(tex, TexCoord1); helper2.zw = helper.xy + helper.zw; \n"
	"FragColor.rg = helper2.xz + helper2.yw;\n"
	"helper = texRECT(tex, TexCoord2); helper2.xy = helper.xy + helper.zw; \n"
	"helper = texRECT(tex, TexCoord3); helper2.zw = helper.xy + helper.zw; \n"
	"FragColor.ba= helper2.xz+helper2.yw;\n"
	"}");


	//read of the first part, which generates tex coordinates 

	s_genlist_start= program =  LoadGenListStepShader(1, 1);
	_param_ftex_width= cgGetNamedParameter(*program, "width");
	_param_genlist_start_tex0 = cgGetNamedParameter(*program, "tex0");
	//stepping
	s_genlist_step = program = LoadGenListStepShader(0, 1);
	_param_genlist_step_tex= cgGetNamedParameter(*program, "tex");
	_param_genlist_step_tex0= cgGetNamedParameter(*program, "tex0");


}

ProgramCG* ShaderBagCG::LoadGenListStepShader(int start, int step)
{
	int i;
	char buffer[10240];
	//char chanels[5] = "rgba";
	ostrstream out(buffer, 10240);
	out<<"void main(out float4 FragColor : COLOR0, \n";

	for(i = 0; i < step; i++) out<<"uniform samplerRECT tex"<<i<<",\n";

	if(start)
	{
		out<<"uniform float width, \nin float2 tpos : TEXCOORD0){\n";
		out<<"float  index = floor(tpos.y) * width + floor(tpos.x) + 0.0001;\n";
		out<<"float2 pos = float2(0.5, 0.5);\n";
	}else
	{
		out<<"uniform samplerRECT tex, in float2 tpos: TEXCOORD0 ){\n";
		out<<"float4 tc = texRECT( tex, tpos);\n";
		out<<"float2 pos = tc.rg; float index = tc.b;\n";
	}
	out<<"float2 sum; 	float4 cc;\n";



	if(step>0)
	{
		out<<"float2 cpos = float2(-0.5, 0.5);\t float2 opos;\n";
		for(i = 0; i < step; i++)
		{
//#define SETP_CODE_2

#ifndef SETP_CODE_2
/*			out<<"cc = texRECT(tex"<<i<<", pos);\n";
			out<<"float sum3[3] = {cc.r, cc.r + cc.g, cc.r + cc.g + cc.b};\n";
			out<<"float3 cmp = float3(index > float3(sum3[0], sum3[1], sum3[2]));\n";
			out<<"opos.y = -0.5 + cmp.y; opos.x = -0.5 + cmp.x + (cmp.z - cmp.y);\n";
			out<<"index -= dot(cmp, cc.rgb);\n";
			out<<"pos = (pos + pos + opos);\n";*/

			out<<"cc = texRECT(tex"<<i<<", pos); sum.x = cc.r + cc.g;\n";
			out<<"if (index < sum.x){ if(index < cc.r) opos = cpos.xx; else {opos = cpos.yx; index -= cc.r;}}\n";
			out<<"else {index -= sum.x; if(index < cc.b) opos = cpos.xy; else{opos = cpos.yy; index -= cc.b;}}";
			out<<"pos = (pos + pos + opos);\n";

/*			out<<"cc = texRECT(tex"<<i<<", pos);\n";
			out<<"if (index <cc.r){ opos = cpos.xx;}\n";
			out<<"else{sum.x = cc.r + cc.g;";
					out<<"if(index < sum.x ) {opos = cpos.yx; index -= cc.r;}\n";
					out<<"else{sum.y = sum.x + cc.b;";
							out<<"if(index < sum.y ) {opos = cpos.xy; index -= sum.x;}\n";