int structuralThresholdingAtPoint(intVectorType point ,densityDataType *sourceData, densityDataType *targetData, float absMin, float deltaEpsilon, float absMax,int scanningRange)
{
float datum=ACCESSDATAATPOINT((*sourceData), point.x, point.y);
if(datum<absMin)
{
ACCESSDATAATPOINT((*targetData), point.x, point.y)=0.0;
return 0;
}
if(datum>absMax)
{
ACCESSDATAATPOINT((*targetData), point.x, point.y)=1.0;
return 0;
}
float massAroundPoint=calculateMassArroundPoint(*sourceData, point, scanningRange);
float volume=(scanningRange-1)*(scanningRange-1);
float meanSignal=massAroundPoint/volume;
if ((datum)>(meanSignal+deltaEpsilon))
{
//printf("Mean siganl: %f datum : %f\n",datum, meanSignal);
//printf("Delta Epsilon:%f\n",deltaEpsilon);
ACCESSDATAATPOINT((*targetData), point.x, point.y)=0.5;
return 0;
}
ACCESSDATAATPOINT((*targetData), point.x, point.y)=0.0;
return 0;
}
int momentThresholdingAtPoint(intVectorType point ,densityDataType *sourceData, densityDataType *targetData, float structuresignal, float absMin, float deltaEpsilon, float absMax,int scanningRange)
{
float datum=ACCESSDATAATPOINT((*sourceData), point.x, point.y);
if(datum<absMin)
{
ACCESSDATAATPOINT((*targetData), point.x, point.y)=0.0;
return 0;
}
if(datum>absMax)
{
ACCESSDATAATPOINT((*targetData), point.x, point.y)=1.0;
return 0;
}
float alpha, structure;
momentOfInertiaType Inertia;
evaluateDirectionAndStructure(&alpha, &structure, &Inertia, *sourceData, point, 4);
float massAroundPoint=calculateMassArroundPoint(*sourceData, point, scanningRange);
float volume=(scanningRange-1)*(scanningRange-1);
float meanSignal=massAroundPoint/volume;
if (structure>structuresignal && (datum)>(meanSignal+deltaEpsilon))
{
ACCESSDATAATPOINT((*targetData), point.x, point.y)=structure;
return 0;
}
ACCESSDATAATPOINT((*targetData), point.x, point.y)=0.0;
return 0;
}
float gradU_Y(int x, int y, densityDataType *densityData)
{
//return ACCESSDATAATPOINT((*densityData), x, (y+1))-ACCESSDATAATPOINT((*densityData), x, y); //first order
//return 0.5*(ACCESSDATAATPOINT((*densityData), x, (y+1))-ACCESSDATAATPOINT((*densityData), x, (y-1))); //second order
float up = (ACCESSDATAATPOINT((*densityData), x, (y+1))-ACCESSDATAATPOINT((*densityData), x, (y)));
float low= (ACCESSDATAATPOINT((*densityData), x, (y)) -ACCESSDATAATPOINT((*densityData), x, (y-1)));
return tau * up + (1.0 - tau ) * low;
};
float gradU_X(int x, int y,densityDataType *densityData)
{
//return ACCESSDATAATPOINT((*densityData), (x+1), y)-ACCESSDATAATPOINT((*densityData), x, y); //first order
//return 0.5*(ACCESSDATAATPOINT((*densityData), (x+1), y)-ACCESSDATAATPOINT((*densityData), (x-1), y)); //secondorder
float up = (ACCESSDATAATPOINT((*densityData), (x+1), y)-ACCESSDATAATPOINT((*densityData), (x) , y));
float low= (ACCESSDATAATPOINT((*densityData), (x), y) -ACCESSDATAATPOINT((*densityData), (x-1), y)); //upwindig
return tau * up + (1.0 - tau ) * low;
};
int nextTatPoint(intVectorType point ,densityDataType *densityData, densityDataType *targetData, float deltaT, int scanningRange)
{
//float dU=divDGradU(point, densityData, scanningRange);
//float dU=divDGradUAtPointFiniteVolume(point, densityData, scanningRange);
float dU=divDGradUAtPointSevenPointStar(point, densityData, scanningRange);
ACCESSDATAATPOINT((*targetData), point.x, point.y)=ACCESSDATAATPOINT((*densityData), point.x, point.y)+deltaT*dU;
return 0;
};
float dilate (densityDataType* data, intVectorType x0, int range)
{
float max,b;
b=0;
max=0;
range=range/2;
INTEGRATE(range, b=ACCESSDATAATPOINT((*data), x0.x-x, x0.y-y);if (b>max) max=b;);
int structuralThresholdingWithParameter(densityDataType data, ucharDataType target, float globalMinThreshold, float globalMaxThreshold, float epsilon, int scanningRange)
{
// int scanningRange=5;
//Segmentation
int x,y;
for (y=scanningRange+5;y<data.sizeY-(scanningRange+5);y++)
{
int percent= (int) ((y*100.0)/(data.sizeY-(scanningRange+5)));
if ( ((float) (percent/10.0)) == ((int) (percent/10)) ) {printf("percent done: %d of segmentation\n",percent);};
for (x=scanningRange+5;x<data.sizeX-(scanningRange+5);x++)
{
intVectorType point;
point.x=x;
point.y=y;
float datum=ACCESSDATAATPOINT(data, point.x, point.y);
if(datum<globalMinThreshold)
{
//printf("Global Min");
SetBinaryDataAtPoint(target,x,y,0);
continue;
}
if(datum>globalMaxThreshold)
{
//printf("Global Max");
SetBinaryDataAtPoint(target,x,y,1);
continue;
}
float meanSignal=meanArroundXY(data, x, y, scanningRange);
if ((datum)>(meanSignal+epsilon))
{
//printf("+Mean siganl: %f datum : %f\n", meanSignal, datum);
//printf("Delta Epsilon:%f\n",epsilon);
//printf("Check Neigbours");
if (checkNeigbours(data, x, y, scanningRange, meanSignal+epsilon,3))
{
float structure;
evaluateStructure(&structure, data, point, scanningRange);
if (structure>0.4)
{
SetBinaryDataAtPoint(target,x,y,1);
continue;
};
}
}
//printf("-Mean siganl: %f datum : %f\n",datum, meanSignal);
//printf("Delta Epsilon:%f\n",epsilon);
SetBinaryDataAtPoint(target,x,y,0);
}; //x loop
}; //y loop
return 0;
}
int checkNeigbours(densityDataType data, int x, int y, int scanningRange, float value, int minNr)
{
int dx, dy;
int counter=0;
for (dy=-1;dy<=1;dy++)
for (dx=-1;dx<=1;dx++)
if (ACCESSDATAATPOINT(data, x+dx, y+dy)>value)
counter=counter+1;
return (counter>=minNr);
}
int DilationXY(densityDataType* data, int range, densityDataType* dilation)
{
int height=(*data).sizeY;
int width=(*data).sizeX;
int imagesize=height*width+1;
densityDataType help;
(help).sizeX=width;
(help).sizeY=height;
(help).data=(float*) malloc( sizeof(float) * imagesize);
int n=range/2;
int x,y;
for ( y=n+10;y<(*data).sizeY-(n+10);y++)
{
for ( x=n+10;x<(*data).sizeX-(n+10);x++)
{
//printf("hello\n");
intVectorType x0;
x0.x=x;
x0.y=y;
ACCESSDATAATPOINT(help,x,y) = dilateX(data,x0,range);
//printf("x=%d y=%d diletate=%f\n",x,y,value);
};
};
for ( y=n+10;y<(*data).sizeY-(n+10);y++)
{
for ( x=n+10;x<(*data).sizeX-(n+10);x++)
{
//printf("hello\n");
intVectorType x0;
x0.x=x;
x0.y=y;
ACCESSDATAATPOINT((*dilation),x,y) = dilateY(&help,x0,range);
//printf("x=%d y=%d diletate=%f\n",x,y,value);
};
};
free(help.data);
return 0;
};
float dilateY (densityDataType* data, intVectorType x0, int range)
{
float max,b;
b=0;
max=0;
range=range/2;
int y;
for ( y=-range; y<=+range; y=y+1)
{
b=ACCESSDATAATPOINT((*data), x0.x, x0.y-y);
if (b>max) max=b;
}
return max;
//printf("max: %f\n", max);
}
float meanArroundXY(densityDataType data, int x, int y, int scanningRange)
{
int dx, dy;
int counter=0;
float sum=0.0;
for (dy=1-scanningRange;dy<scanningRange;dy=dy+1)
for (dx=1-scanningRange;dx<scanningRange;dx=dx+1)
{
counter=counter+1;
sum=sum+ACCESSDATAATPOINT(data, x+dx, y+dy);
}
return sum/counter;
}
int globalThresholding (densityDataType data, ucharDataType segData, float value)
{
int x,y;
for ( y=0;y<data.sizeY;y++)
{
int percent= (int) ((y*100.0)/(data.sizeY));
if ( ((float) (percent/10.0)) == ((int) (percent/10)) ) {printf("percent done: %d of segmentation\n",percent);};
for ( x=0;x<data.sizeX;x++)
{
if (ACCESSDATAATPOINT(data, x, y)>value)
{
SetBinaryDataAtPoint(segData,x,y,1);
}
else
SetBinaryDataAtPoint(segData,x,y,0);
};
};
return 0;
};
