//compute the shadow
vec3 get_shadow(vec3 eye, vec3 ray, vec3 surf_norm, void *sph, vec3 hit, int isplane) {
vec3 raynormal = normalize(ray);
float dist = dot(ray, ray);
vec3 color=vec3(0,0,0);
vec3 reflect_vector = 2*dot(raynormal, surf_norm)*surf_norm - raynormal;
vec3 diffuse;
vec3 specular;
if(isplane==1) {
struct plane *pln = (struct plane *)sph;
if((int(hit.x) + int(hit.z))%2==0) diffuse=max_float(dot(raynormal,surf_norm),0)*light1_intensity*pln->mat_diffuse1;
else diffuse=max_float(dot(raynormal,surf_norm),0)*light1_intensity*pln->mat_diffuse2;
specular = pow(max_float(dot(reflect_vector,eye),0), pln->shineness)*light1_intensity*pln->mat_specular;
}
else {
Spheres *sphr= (Spheres *)sph;
color += global_ambient * sphr->mat_ambient;
diffuse = max_float(dot(raynormal, surf_norm),0)*light1_intensity*sphr->mat_diffuse;
specular = pow(max_float(dot(reflect_vector, eye),0),sphr->mat_shineness)*light1_intensity * sphr->mat_specular;
}
color += 1.0 * light1_shadow *(diffuse+specular)/(decay_c*dist+decay_b*sqrt(dist)+decay_a);
return color;
}
Vec2<float> max(const Vec2<float> &v1, const Vec2<float> &v2) {
Vec2<float> rv;
rv.x = max_float(v1.x, v2.x);
rv.y = max_float(v1.y, v2.y);
return rv;
}
Vec4<float> max(const Vec4<float> &v1, const Vec4<float> &v2) {
Vec4<float> rv;
rv.x = max_float(v1.x, v2.x);
rv.y = max_float(v1.y, v2.y);
rv.z = max_float(v1.z, v2.z);
rv.w = max_float(v1.w, v2.w);
return rv;
}
VecN<float, N> max(const VecN<float, N> &v1, const VecN<float, N> &v2) {
VecN<float, N> rv;
for(unsigned int i=0; i < N; i++) {
rv.v[i] = max_float(v1.v[i], v2.v[i]);
}
return rv;
}
static void to_sRGB(float *pixel_buffer, u32 num_values)
{
//TODO(Vidar): Do this properly...
for(u32 i=0;i<num_values;i++){
pixel_buffer[i] = powf(min_float(max_float(pixel_buffer[i],0.f),1.f),1.f/2.2f);
}
}
/*********************************************************************
* Phong illumination - you need to implement this!
*********************************************************************/
vec3 phong(vec3 eye, vec3 ray, vec3 surf_norm, void *sph, vec3 hit, int isplane) {
//
// do your thing here
//
vec3 color=vec3(0,0,0);
vec3 raynormal = normalize(ray);
float dist = dot(ray, ray);
vec3 diffuse;
vec3 specular;
vec3 reflect_vector = 2*dot(raynormal, surf_norm)*surf_norm - raynormal;
if(isplane==1) {
struct plane* pln= (struct plane*)sph;
color += global_ambient * pln->mat_ambient;
if(hit.x>=0) {
if((int(hit.x)+int(hit.z))%2==0) diffuse = max_float(dot(raynormal,surf_norm),0)*light1_intensity*pln->mat_diffuse1;
else diffuse = max_float(dot(raynormal,surf_norm),0)*light1_intensity*pln->mat_diffuse2;
}
else {
if((int(hit.x)-1+int(hit.z))%2==0) diffuse = max_float(dot(raynormal,surf_norm),0)*light1_intensity*pln->mat_diffuse1;
else diffuse = max_float(dot(raynormal,surf_norm),0)*light1_intensity*pln->mat_diffuse2;
}
specular = pow(max_float(dot(reflect_vector,eye),0), pln->shineness)*light1_intensity*pln->mat_specular;
}
else {
Spheres *sphr = (Spheres *)sph;
color += global_ambient * sphr->mat_ambient;
//printf("ambient: %f %f %f\n", color.x, color.y, color.z);
//printf("mat_diffuse: %f %f %f\n", sph->mat_diffuse.x,sph->mat_diffuse.y, sph->mat_diffuse.z);
diffuse = max_float(dot(raynormal, surf_norm),0)*light1_intensity*sphr->mat_diffuse;
//printf("diffuse: %f %f %f\n", diffuse.x, diffuse.y, diffuse.z);
specular = pow(max_float(dot(reflect_vector, eye),0),sphr->mat_shineness)*light1_intensity * sphr->mat_specular;
//printf("specular: %f %f %f\n", specular.x, specular.y, specular.z);
}
color += 1.0 * (diffuse+specular)/(decay_c*dist+decay_b*sqrt(dist)+decay_a);
return color;
}
void reconstruct_video(nTupleVolume<T>* imgVol, nTupleVolume<T>* occVol,
nTupleVolume<T>* dispField, float sigmaColour, int useAllPatches, int reconstructionType)
{
/*decalarations*/
int xSize, ySize, tSize, nTupleSize; //img Size
int i,j,k; //3-D index
int iMin,iMax,jMin,jMax,kMin,kMax; //Boundary of index Volume
int ii,jj,kk, weightInd;
int xDisp, yDisp, tDisp,xDispShift,yDispShift,tDispShift;
int shiftI,shiftJ,shiftK;
int hPatchSizeX,hPatchSizeY,hPatchSizeT; //half patchsize
int hI,hJ,hK,doubleII,doubleJJ,doubleKK;
int nbNeighbours;
int correctInfo;
float alpha, adaptiveSigma;
float *weights,sumWeights, avgColourR, avgColourG, avgColourB, *colours;
/*get image volume sizes*/
xSize = imgVol->xSize;
ySize = imgVol->ySize;
tSize = imgVol->tSize;
nTupleSize = imgVol->nTupleSize;
hPatchSizeX = imgVol->hPatchSizeX; //half patchsize
hPatchSizeY = imgVol->hPatchSizeY;
hPatchSizeT = imgVol->hPatchSizeT;
/*allocate the (maximum) memory for the weights*/
nbNeighbours = (imgVol->patchSizeX)*(imgVol->patchSizeY)*(imgVol->patchSizeT); //number of neighbor
weights = (float*)malloc((size_t)(nbNeighbours*sizeof(float)));
colours = (float*)malloc((size_t)(NCHANNELS*nbNeighbours*sizeof(float)));
/*check certain parameters*/
if( (imgVol->patchSizeX != (imgVol->patchSizeX)) || (imgVol->patchSizeY != (imgVol->patchSizeY)) ||
(imgVol->patchSizeT != (imgVol->patchSizeT)) ) /*check that the patch sizes are equal*/ //what is this for?
{
MY_PRINTF("Error in estimate_colour, the size of the patches are not equal in the two image volumes.");
return;
}
if ( ( imgVol->patchSizeX > imgVol->xSize) || ( imgVol->patchSizeY > imgVol->ySize) || ( imgVol->patchSizeT > imgVol->tSize) ) /*check that the patch size is less or equal to each dimension in the images*/
{
MY_PRINTF("Error in estimate_colour, the patch size is to large for one or more of the dimensions of the image volume.");
return;
}
for (k=0; k<(occVol->tSize); k++) //run all over occVolume, t dimension
for (j=0; j<(occVol->ySize); j++) // y dimension
for (i=0; i<(occVol->xSize); i++)//x dimension
{
if ( ((occVol->get_value(i,j,k,0)) == 0) || ((occVol->get_value(i,j,k,0) == 2) ) ) //do not inpaint
continue;
else /*an occluded pixel (therefore to be modified)*/
{
if (reconstructionType == NEAREST_NEIGHBOUR_RECONSTRUCTION ) //nearest neighbor reconstruction
{
xDisp = i + (int)dispField->get_value(i,j,k,0); // x Displacement
yDisp = j + (int)dispField->get_value(i,j,k,1); // y Displacement
tDisp = k + (int)dispField->get_value(i,j,k,2); // t displacement
////if pure replacing of pixels
copy_pixel_values_nTuple_volume(imgVol, imgVol,xDisp, yDisp, tDisp, i, j, k); //copy pixel value of ANN to occluded pixel.
///set_value_nTuple_volume(occVol,i,j,k,2,0);
///set_value_nTuple_volume(imgVol,i,j,k,0,0);
continue;
}
// init array weight and colours
for (ii=0;ii<(imgVol->patchSizeX)*(imgVol->patchSizeY)*(imgVol->patchSizeT); ii++) //all the pixel in a patch
{
weights[ii] = (float)-1; //weight for all pixel in patch
colours[ii] = (float)-1; //red
colours[ii + nbNeighbours] = (float)-1;//green chanel
colours[ii + 2*nbNeighbours] = (float)-1; //blue chanel
}
sumWeights = 0.0;
alpha = FLT_MAX;
correctInfo = 0;
avgColourR = 0.0;
avgColourG = 0.0;
avgColourB = 0.0;
//boudary for each patch
iMin = max_int(i - hPatchSizeX,0);
iMax = min_int(i + hPatchSizeX,(imgVol->xSize)-1 );
jMin = max_int(j - hPatchSizeY,0);
jMax = min_int(j + hPatchSizeY,(imgVol->ySize)-1 );
kMin = max_int(k - hPatchSizeT,0);
kMax = min_int(k + hPatchSizeT,(imgVol->tSize)-1 );
/*
MY_PRINTF("iMin : %d, iMax : %d\n",iMin,iMax);
MY_PRINTF("jMin : %d, jMax : %d\n",jMin,jMax);
MY_PRINTF("kMin : %d, kMax : %d\n",kMin,kMax);*/
/*first calculate the weights*/
//run for each patch, calculate the spatial temporal neighbor of the patch
for (kk=kMin; kk<=kMax;kk++) //t dimension
for (jj=jMin; jj<=jMax;jj++)//y dimension
for (ii=iMin; ii<=iMax;ii++) //x dimension
{
/*get ssd similarity*/
xDisp = ii + (int)dispField->get_value(ii,jj,kk,0); //get value dispX for pixel in the patch
yDisp = jj + (int)dispField->get_value(ii,jj,kk,1);
tDisp = kk + (int)dispField->get_value(ii,jj,kk,2);
/*(spatio-temporally) shifted values of the covering patches*/
xDispShift = xDisp - (ii-i); //i + dispField (dispField for pixel (ii,jj,kk))
yDispShift = yDisp - (jj-j);
tDispShift = tDisp - (kk-k);
if (useAllPatches == 1) // if use all patches
{
alpha = (float)min_float(dispField->get_value(ii,jj,kk,3),alpha); //get min SSD and assign to alpha
//transform matrice indice to array indice.
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
weights[weightInd] = dispField->get_value(ii,jj,kk,3); //weight is an array, SSD error of patch
//colours is an array
colours[weightInd] = (float)(imgVol->get_value(xDispShift,yDispShift,tDispShift,0)); //red
colours[weightInd + nbNeighbours] = (float)(imgVol->get_value(xDispShift,yDispShift,tDispShift,1));//green
colours[weightInd + 2*nbNeighbours] = (float)(imgVol->get_value(xDispShift,yDispShift,tDispShift,2)); //blue
correctInfo = 1;
}
else /*only use some of the patches*/
{
if (((occVol->get_value(ii,jj,kk,0)) == 0) || (occVol->get_value(ii,jj,kk,0) ==-1))
{
alpha = (float)min_float(dispField->get_value(ii,jj,kk,3),alpha);
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
weights[weightInd] = dispField->get_value(ii,jj,kk,3);
colours[weightInd] = (float)(imgVol->get_value(xDispShift,yDispShift,tDispShift,0));
colours[weightInd + nbNeighbours] = (float)(imgVol->get_value(xDispShift,yDispShift,tDispShift,1));
colours[weightInd + 2*nbNeighbours] = (float)(imgVol->get_value(xDispShift,yDispShift,tDispShift,2));
correctInfo = 1;
}
else
{
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
weights[weightInd] = -1;
colours[weightInd] = -1;
colours[weightInd + nbNeighbours] = -1;
colours[weightInd + 2*nbNeighbours] = -1;
continue;
}
}
}
alpha = max_float(alpha,1);
if (correctInfo == 0)
continue;
if (reconstructionType == BEST_PATCH_RECONSTRUCTION)
{
estimate_best_colour(imgVol,imgVol, weights, nbNeighbours, colours, sigmaColour, i, j, k);
continue;
}
//get the 75th percentile of the distances for setting the adaptive sigma
adaptiveSigma = get_adaptive_sigma(weights,(imgVol->patchSizeX)*(imgVol->patchSizeY)*(imgVol->patchSizeT),sigmaColour);
adaptiveSigma = max_float(adaptiveSigma,(float)0.1);
/* ///MY_PRINTF("alpha : %f\n",alpha);
//adjust the weights : note, the indices which are outside the image boundaries
//will have no influence on the final weights (they are initialised to 0) */
for (kk=kMin; kk<=kMax;kk++)
for (jj=jMin; jj<=jMax;jj++)
for (ii=iMin; ii<=iMax;ii++)
{
if (useAllPatches)
{
/*weights = exp( -weights/(2*sigma�*alpha))*/
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
weights[weightInd] = (float)(exp( - ((weights[weightInd])/(2*adaptiveSigma*adaptiveSigma)) ));/*exp( - ((weights[ii])/(2*sigmaColour*sigmaColour*alpha)) );*/
//
sumWeights = (float)(sumWeights+weights[weightInd]);
}
else /*only use some of the patches*/
{
if (((occVol->get_value(ii,jj,kk,0)) == 0) || (occVol->get_value(ii,jj,kk,0) ==-1))
{
/*weights = exp( -weights/(2*sigma�*alpha))*/
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
weights[weightInd] = (float)(exp( - ((weights[weightInd])/(2*adaptiveSigma*adaptiveSigma)) ));/*exp( - ((weights[ii])/(2*sigmaColour*sigmaColour*alpha)) );*/
//
sumWeights = (float)(sumWeights+weights[weightInd]);
}
else
continue;
}
}
/*now calculate the pixel value(s)*/
for (kk=kMin; kk<=kMax;kk++)
for (jj=jMin; jj<=jMax;jj++)
for (ii=iMin; ii<=iMax;ii++)
{
if (useAllPatches)
{
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
/*get ssd similarity*/
xDisp = ii + (int)dispField->get_value(ii,jj,kk,0);
yDisp = jj + (int)dispField->get_value(ii,jj,kk,1);
tDisp = kk + (int)dispField->get_value(ii,jj,kk,2);
/*(spatio-temporally) shifted values of the covering patches*/
xDispShift = xDisp - (ii-i);
yDispShift = yDisp - (jj-j);
tDispShift = tDisp - (kk-k);
avgColourR = avgColourR + (float)(weights[weightInd])*(imgVol->get_value(xDispShift,yDispShift,tDispShift,0));
avgColourG = avgColourG + (float)(weights[weightInd])*(imgVol->get_value(xDispShift,yDispShift,tDispShift,1));
avgColourB = avgColourB + (float)(weights[weightInd])*(imgVol->get_value(xDispShift,yDispShift,tDispShift,2));
}
else
{
if (((occVol->get_value(ii,jj,kk,0)) == 0) || (occVol->get_value(ii,jj,kk,0) ==-1))
{
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
/*get ssd similarity*/
xDisp = ii + (int)dispField->get_value(ii,jj,kk,0);
yDisp = jj + (int)dispField->get_value(ii,jj,kk,1);
tDisp = kk + (int)dispField->get_value(ii,jj,kk,2);
/*(spatio-temporally) shifted values of the covering patches*/
xDispShift = xDisp - (ii-i);
yDispShift = yDisp - (jj-j);
tDispShift = tDisp - (kk-k);
avgColourR = avgColourR + (float)(weights[weightInd])*(imgVol->get_value(xDispShift,yDispShift,tDispShift,0));
avgColourG = avgColourG + (float)(weights[weightInd])*(imgVol->get_value(xDispShift,yDispShift,tDispShift,1));
avgColourB = avgColourB + (float)(weights[weightInd])*(imgVol->get_value(xDispShift,yDispShift,tDispShift,2));
}
else
continue;
}
}
/*MY_PRINTF("SumWeights : %f\n",sumWeights);*/
imgVol->set_value(i,j,k,0,(T)(avgColourR/(sumWeights)));
imgVol->set_value(i,j,k,1,(T)(avgColourG/(sumWeights)));
imgVol->set_value(i,j,k,2,(T)(avgColourB/(sumWeights)));
/*set_value_nTuple_volume(occVol,i,j,k,0,0);*/
}
}
free(weights);
free(colours);
return;
}
float max(const float v1, const float v2) {
return max_float(v1, v2);
}
static void
vorbis_test (void)
{ static float float_data [DFT_DATA_LENGTH] ;
const char * filename = "vorbis_test.oga" ;
SNDFILE * file ;
SF_INFO sfinfo ;
float max_abs = 0.0 ;
unsigned k ;
print_test_name ("vorbis_test", filename) ;
/* Generate float data. */
gen_windowed_sine_float (float_data, ARRAY_LEN (float_data), 1.0) ;
/* Set up output file type. */
memset (&sfinfo, 0, sizeof (sfinfo)) ;
sfinfo.format = SF_FORMAT_OGG | SF_FORMAT_VORBIS ;
sfinfo.channels = 1 ;
sfinfo.samplerate = SAMPLE_RATE ;
/* Write the output file. */
/* The Vorbis encoder has a bug on PowerPC and X86-64 with sample rates
** <= 22050. Increasing the sample rate to 32000 avoids triggering it.
** See https://trac.xiph.org/ticket/1229
*/
if ((file = sf_open (filename, SFM_WRITE, &sfinfo)) == NULL)
{ const char * errstr ;
errstr = sf_strerror (NULL) ;
if (strstr (errstr, "Sample rate chosen is known to trigger a Vorbis") == NULL)
{ printf ("Line %d: sf_open (SFM_WRITE) failed : %s\n", __LINE__, errstr) ;
dump_log_buffer (NULL) ;
exit (1) ;
} ;
printf ("\n Sample rate -> 32kHz ") ;
sfinfo.samplerate = 32000 ;
file = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
} ;
test_write_float_or_die (file, 0, float_data, ARRAY_LEN (float_data), __LINE__) ;
sf_close (file) ;
memset (float_data, 0, sizeof (float_data)) ;
/* Read the file back in again. */
memset (&sfinfo, 0, sizeof (sfinfo)) ;
file = test_open_file_or_die (filename, SFM_READ, &sfinfo, SF_FALSE, __LINE__) ;
test_read_float_or_die (file, 0, float_data, ARRAY_LEN (float_data), __LINE__) ;
sf_close (file) ;
for (k = 0 ; k < ARRAY_LEN (float_data) ; k ++)
max_abs = max_float (max_abs, fabs (float_data [k])) ;
if (max_abs > 1.02)
{ printf ("\n\n Error : max_abs %f should be < 1.02.\n\n", max_abs) ;
exit (1) ;
} ;
puts ("ok") ;
unlink (filename) ;
} /* vorbis_test */
/*this function calculates a nearest neighbour field, from imgVolA to imgVolB*/
void reconstruct_image_and_features(nTupleVolume* imgVol, nTupleVolume* occVol,
nTupleVolume *normGradXvol, nTupleVolume *normGradYvol,
nTupleVolume* dispField, float sigmaColour, int reconstructionType, bool initialisation)
{
int useAllPatches = 0;
if (initialisation==true)
useAllPatches = 0;
else
useAllPatches = 1;
/*decalarations*/
int iMin,iMax,jMin,jMax,kMin,kMax;
int weightInd;
int xDisp, yDisp, tDisp,xDispShift,yDispShift,tDispShift;
int hPatchSizeX,hPatchSizeY,hPatchSizeT;
int nbNeighbours;
int correctInfo;
float alpha, adaptiveSigma;
float *weights,sumWeights, *colours, *avgColours;
float avgNormGradX,avgNormGradY;
hPatchSizeX = imgVol->hPatchSizeX;
hPatchSizeY = imgVol->hPatchSizeY;
hPatchSizeT = imgVol->hPatchSizeT;
/*allocate the (maximum) memory for the weights*/
nbNeighbours = (imgVol->patchSizeX)*(imgVol->patchSizeY)*(imgVol->patchSizeT);
weights = new float[nbNeighbours];
colours = new float[(imgVol->nTupleSize)*nbNeighbours];
avgColours = new float[imgVol->nTupleSize];
/*check certain parameters*/
if( (imgVol->patchSizeX != (imgVol->patchSizeX)) || (imgVol->patchSizeY != (imgVol->patchSizeY)) ||
(imgVol->patchSizeT != (imgVol->patchSizeT)) ) /*check that the patch sizes are equal*/
{
MY_PRINTF("Error in estimate_colour, the size of the patches are not equal in the two image volumes.");
return;
}
if ( ( imgVol->patchSizeX > imgVol->xSize) || ( imgVol->patchSizeY > imgVol->ySize) || ( imgVol->patchSizeT > imgVol->tSize) ) /*check that the patch size is less or equal to each dimension in the images*/
{
MY_PRINTF("Error in estimate_colour, the patch size is to large for one or more of the dimensions of the image volume.");
return;
}
for (int k=0; k<(occVol->tSize); k++)
for (int j=0; j<(occVol->ySize); j++)
for (int i=0; i<(occVol->xSize); i++)
{
if ( ((occVol->get_value(i,j,k,0)) == 0) || ((occVol->get_value(i,j,k,0) == 2) ) )
continue;
else /*an occluded pixel (therefore to be modified)*/
{
if (reconstructionType == 1 )
{
xDisp = i + (int)dispField->get_value(i,j,k,0);
yDisp = j + (int)dispField->get_value(i,j,k,1);
tDisp = k + (int)dispField->get_value(i,j,k,2);
////if pure replacing of pixels
copy_pixel_values_nTuple_volume(imgVol, imgVol,xDisp, yDisp, tDisp, i, j, k);
///set_value_nTuple_volume(occVol,i,j,k,2,0);
///set_value_nTuple_volume(imgVol,i,j,k,0,0);
continue;
}
//initialisation of the weight and colour vectors
for (int ii=0;ii<(imgVol->patchSizeX)*(imgVol->patchSizeY)*(imgVol->patchSizeT); ii++)
{
weights[ii] = (float)-1;
for (int colourInd=0; colourInd<(imgVol->nTupleSize); colourInd++)
{
colours[ii + colourInd*nbNeighbours] = (float)-1;
}
}
for (int colourInd=0; colourInd<(imgVol->nTupleSize); colourInd++)
{
avgColours[colourInd] = (float)0.0;
}
sumWeights = 0.0;
alpha = FLT_MAX;
correctInfo = 0;
avgNormGradX = 0.0;
avgNormGradY = 0.0;
iMin = max_int(i - hPatchSizeX,0);
iMax = min_int(i + hPatchSizeX,(imgVol->xSize)-1 );
jMin = max_int(j - hPatchSizeY,0);
jMax = min_int(j + hPatchSizeY,(imgVol->ySize)-1 );
kMin = max_int(k - hPatchSizeT,0);
kMax = min_int(k + hPatchSizeT,(imgVol->tSize)-1 );
/*
MY_PRINTF("iMin : %d, iMax : %d\n",iMin,iMax);
MY_PRINTF("jMin : %d, jMax : %d\n",jMin,jMax);
MY_PRINTF("kMin : %d, kMax : %d\n",kMin,kMax);*/
/*first calculate the weights*/
for (int kk=kMin; kk<=kMax;kk++)
for (int jj=jMin; jj<=jMax;jj++)
for (int ii=iMin; ii<=iMax;ii++)
{
/*get ssd similarity*/
xDisp = ii + (int)dispField->get_value(ii,jj,kk,0);
yDisp = jj + (int)dispField->get_value(ii,jj,kk,1);
tDisp = kk + (int)dispField->get_value(ii,jj,kk,2);
/*(spatio-temporally) shifted values of the covering patches*/
xDispShift = xDisp - (ii-i);
yDispShift = yDisp - (jj-j);
tDispShift = tDisp - (kk-k);
if (useAllPatches == 1)
{
alpha = (float)min_float(dispField->get_value(ii,jj,kk,3),alpha);
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
weights[weightInd] = dispField->get_value(ii,jj,kk,3);
for (int colourInd=0; colourInd<(imgVol->nTupleSize); colourInd++)
{
colours[weightInd + colourInd*nbNeighbours] = (float)(imgVol->get_value(xDispShift,yDispShift,tDispShift,colourInd));
}
correctInfo = 1;
}
else /*only use some of the patches*/
{
if ((occVol->get_value(ii,jj,kk,0)) == 0)
{
alpha = (float)min_float(dispField->get_value(ii,jj,kk,3),alpha);
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
weights[weightInd] = dispField->get_value(ii,jj,kk,3);
for (int colourInd=0; colourInd<(imgVol->nTupleSize); colourInd++)
{
colours[weightInd + colourInd*nbNeighbours] = (float)(imgVol->get_value(xDispShift,yDispShift,tDispShift,colourInd));
}
correctInfo = 1;
}
else
{
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
weights[weightInd] = -1;
for (int colourInd=0; colourInd<(imgVol->nTupleSize); colourInd++)
{
colours[weightInd + colourInd*nbNeighbours] = (float)-1;
}
continue;
}
}
}
alpha = max_float(alpha,1);
if (correctInfo == 0)
continue;
if (reconstructionType == 3)
{
estimate_best_colour(imgVol, weights, nbNeighbours, colours, i, j, k);
continue;
}
//get the 75th percentile of the distances for setting the adaptive sigma
adaptiveSigma = get_adaptive_sigma(weights,(imgVol->patchSizeX)*(imgVol->patchSizeY)*(imgVol->patchSizeT),sigmaColour);
adaptiveSigma = max_float(adaptiveSigma,(float)0.1);
/* ///MY_PRINTF("alpha : %f\n",alpha);
//adjust the weights : note, the indices which are outside the image boundaries
//will have no influence on the final weights (they are initialised to 0) */
for (int kk=kMin; kk<=kMax;kk++)
for (int jj=jMin; jj<=jMax;jj++)
for (int ii=iMin; ii<=iMax;ii++)
{
if (useAllPatches)
{
/*weights = exp( -weights/(2*sigma*alpha))*/
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
weights[weightInd] = (float)(exp( - ((weights[weightInd])/(2*adaptiveSigma*adaptiveSigma)) ));/*exp( - ((weights[ii])/(2*sigmaColour*sigmaColour*alpha)) );*/
//
sumWeights = (float)(sumWeights+weights[weightInd]);
}
else /*only use some of the patches*/
{
if ((occVol->get_value(ii,jj,kk,0)) == 0)
{
/*weights = exp( -weights/(2*sigma*alpha))*/
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
weights[weightInd] = (float)(exp( - ((weights[weightInd])/(2*adaptiveSigma*adaptiveSigma)) ));/*exp( - ((weights[ii])/(2*sigmaColour*sigmaColour*alpha)) );*/
//
sumWeights = (float)(sumWeights+weights[weightInd]);
}
else
continue;
}
}
/*now calculate the pixel value(s)*/
for (int kk=kMin; kk<=kMax;kk++)
for (int jj=jMin; jj<=jMax;jj++)
for (int ii=iMin; ii<=iMax;ii++)
{
if (useAllPatches)
{
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
/*get ssd similarity*/
xDisp = ii + (int)dispField->get_value(ii,jj,kk,0);
yDisp = jj + (int)dispField->get_value(ii,jj,kk,1);
tDisp = kk + (int)dispField->get_value(ii,jj,kk,2);
/*(spatio-temporally) shifted values of the covering patches*/
xDispShift = xDisp - (ii-i);
yDispShift = yDisp - (jj-j);
tDispShift = tDisp - (kk-k);
for (int colourInd=0; colourInd<(imgVol->nTupleSize); colourInd++)
{
avgColours[colourInd] = avgColours[colourInd] + (float)(weights[weightInd])*(imgVol->get_value(xDispShift,yDispShift,tDispShift,colourInd));
}
avgNormGradX = avgNormGradX + (float)(weights[weightInd])*(normGradXvol->get_value(xDispShift,yDispShift,tDispShift,0));
avgNormGradY = avgNormGradY + (float)(weights[weightInd])*(normGradYvol->get_value(xDispShift,yDispShift,tDispShift,0));
}
else
{
if ((occVol->get_value(ii,jj,kk,0)) == 0)
{
weightInd = (int)((kk-kMin)*(imgVol->patchSizeX)*(imgVol->patchSizeY) + (jj-jMin)*(imgVol->patchSizeX) + ii-iMin);
/*get ssd similarity*/
xDisp = ii + (int)dispField->get_value(ii,jj,kk,0);
yDisp = jj + (int)dispField->get_value(ii,jj,kk,1);
tDisp = kk + (int)dispField->get_value(ii,jj,kk,2);
/*(spatio-temporally) shifted values of the covering patches*/
xDispShift = xDisp - (ii-i);
yDispShift = yDisp - (jj-j);
tDispShift = tDisp - (kk-k);
for (int colourInd=0; colourInd<(imgVol->nTupleSize); colourInd++)
{
avgColours[colourInd] = avgColours[colourInd] + (float)(weights[weightInd])*(imgVol->get_value(xDispShift,yDispShift,tDispShift,colourInd));
}
avgNormGradX = avgNormGradX + (float)(weights[weightInd])*(normGradXvol->get_value(xDispShift,yDispShift,tDispShift,0));
avgNormGradY = avgNormGradY + (float)(weights[weightInd])*(normGradYvol->get_value(xDispShift,yDispShift,tDispShift,0));
}
else
continue;
}
}
/*MY_PRINTF("SumWeights : %f\n",sumWeights);*/
for (int colourInd=0; colourInd<(imgVol->nTupleSize); colourInd++)
{
imgVol->set_value(i,j,k,colourInd,(imageDataType)((avgColours[colourInd])/(sumWeights)));
}
normGradXvol->set_value(i,j,k,0,(imageDataType)(avgNormGradX/(sumWeights)));
normGradYvol->set_value(i,j,k,0,(imageDataType)(avgNormGradY/(sumWeights)));
/*set_value_nTuple_volume(occVol,i,j,k,0,0);*/
}
}
delete weights;
delete colours;
delete avgColours;
return;
}
