MultibandImage *layer_n(MultibandImage *im, int n_filters, int prior_n_filters, MultibandKernel **kernels, int activation, int stride, float radio, float alpha,
int normalizationSize){
int i;
MultibandImage **images;
MultibandImage *pooled, *normalized, *appended;
AdjRel *rectangular = RectangularKernel(normalizationSize,normalizationSize);
images = (MultibandImage **)calloc(n_filters,sizeof(MultibandImage**));
for(i=0; i< n_filters; i++)
{
images[i] = MultibandCorrelation(im, kernels[i], activation);
}
appended = AppendManyMultibandImages(images, n_filters);
for(i=0; i<n_filters; i++){
DestroyMultibandImage(&images[i]);
}
free(images);
pooled = pooling(appended, stride, radio, alpha);
DestroyMultibandImage(&appended);
normalized = normalize(pooled, rectangular);
DestroyMultibandImage(&pooled);
DestroyAdjRel(&rectangular);
return normalized;
}
void ComputeFrequencyProperty(Image *img, Property *ppt)
{
long x, y, p, q;
int i, border;
AdjRel *A;
Pixel v;
A = Circular(1.0);
for(y=0; y<img->nrows; y++){
for(x=0; x<img->ncols; x++){
p = x + img->tbrow[y];
border=false;
for (i=1; i < A->n; i++){
v.x = x + A->dx[i];
v.y = y + A->dy[i];
if (ValidPixel(img,v.x,v.y)){
q = v.x + img->tbrow[v.y];
if(ppt[p].color!=ppt[q].color){
border=true;
break;
}
}
}
if(border==false)
ppt[p].frequency=LOW;
else
ppt[p].frequency=HIGH;
}
}
DestroyAdjRel(&A);
}
void ComputeFrequencyProperty(Image *img, ACCProperty *ppt)
{
ulong x, y, p, q;
uchar d, r;
AdjRel *A;
Pixel v;
int i;
for (p=0; p<img->nrows*img->ncols; p++)
for (d=0; d<4; d++)
ppt[p].frequency[d] = 0;
A = Circular(1.0);
for(y=0; y<img->nrows; y++)
for(x=0; x<img->ncols; x++){
p = x + img->tbrow[y];
for(r=1,d=0; r<=7; r+=2,d++)
for (i=1; i < A->n; i++){
v.x = x + r * A->dx[i];
v.y = y + r * A->dy[i];
if (ValidPixel(img,v.x,v.y)){
q = v.x + img->tbrow[v.y];
if(ppt[p].color == ppt[q].color)
ppt[p].frequency[d]++;
}
}
}
DestroyAdjRel(&A);
}
CImage *DrawLabeledRegions(Image *img, Image *label){
CImage *border=CreateCImage(img->ncols,img->nrows);
int x,y,k,p,q,u,v;
AdjRel *A;
A = Circular(1.0);
for(y=0;y<img->nrows;y++){
for(x=0;x<img->ncols;x++){
p = x + img->tbrow[y];
border->C[0]->val[p]=
border->C[1]->val[p]=border->C[2]->val[p]=img->val[p];
for(k=1;k<A->n;k++){
u = x+A->dx[k];
v = y+A->dy[k];
if(ValidPixel(img,u,v)){
q= u + img->tbrow[v];
if (label->val[p] != label->val[q]){
border->C[0]->val[p]=255;
border->C[1]->val[p]=0;
border->C[2]->val[p]=0;
break;
}
}
}
}
}
DestroyAdjRel(&A);
return(border);
}
MultibandImage *layer0(MultibandImage *im, int normalizationSize){
AdjRel *rectangular = RectangularKernel(normalizationSize,normalizationSize);
MultibandImage *normalized;
normalized = normalize(im, rectangular);
DestroyAdjRel(&rectangular);
return normalized;
}
MultibandImage *layer0(MultibandImage *im){
AdjRel *rectangular = Rectangular(3,3);
MultibandImage *normalized;
normalized = normalize(im, rectangular);
DestroyAdjRel(&rectangular);
return normalized;
}
CImage *DrawCBorder(Image *img, Image *label){
CImage *border;
int i,j,k,p,q,u,v;
AdjRel *A;
Image *img8;
img8 = ConvertToNbits(img, 8);
border = Convert2CImage(img8);
DestroyImage(&img8);
A = Circular(1.0);
for(i=0;i<img->nrows;i++){
for(j=0;j<img->ncols;j++){
p = j + img->tbrow[i];
for(k=1;k<A->n;k++){
u = j+A->dx[k];
v = i+A->dy[k];
if(ValidPixel(img,u,v)){
q= u + img->tbrow[v];
if (label->val[p] < label->val[q]){
switch( label->val[q]){
case 0:
border->C[0]->val[p] = 255;
border->C[1]->val[p] = 255;
border->C[2]->val[p] = 255;
break;
case 1:
border->C[0]->val[p] = 255;
border->C[1]->val[p] = 0;
border->C[2]->val[p] = 0;
break;
case 2:
border->C[0]->val[p] = 0;
border->C[1]->val[p] = 255;
border->C[2]->val[p] = 0;
break;
case 3:
border->C[0]->val[p] = 0;
border->C[1]->val[p] = 0;
border->C[2]->val[p] = 255;
break;
default:
border->C[0]->val[p] = 255;
border->C[1]->val[p] = 255;
border->C[2]->val[p] = 0;
}
break;
}
}
}
}
}
DestroyAdjRel(&A);
return border;
}
void ComputeHistograms(Image *img, float sum[4][511], float dif[4][511])
{
ulong x, y, p, q;
ulong npixels;
AdjRel *A;
int i, j;
Pixel v;
A = Circular(1.5);
for (i=0; i<4; i++)
for (j=0; j<=510; j++){
sum[i][j] = 0.0;
dif[i][j] = 0.0;
}
for(y=1; y<img->nrows-1; y++){
for(x=1; x<img->ncols-1; x++){
p = x + img->tbrow[y];
for (i=1; i <= A->n>>1; i++){
v.x = x + A->dx[i];
v.y = y + A->dy[i];
q = v.x + img->tbrow[v.y];
if (ValidPixel(img,v.x,v.y)){
sum[i - 1][img->val[p] + img->val[q]] += 1.0;
dif[i - 1][img->val[p] - img->val[q] + 255] += 1.0;
}
}
}
}
DestroyAdjRel(&A);
npixels = img->ncols * img->nrows;
for (i=0; i<4; i++)
for (j=0; j<=510; j++){
sum[i][j] /= (float) npixels;
dif[i][j] /= (float) npixels;
}
}
void DiffWatershed(Image *grad, ImageForest *fst, Set *Obj, Set *Bkg, Set *Rm)
{
AdjRel *A=NULL;
GQueue *Q=NULL;
Pixel u,v;
int i,p,q,n,tmp,Cmax=MaximumValue(grad);
Set *aux, *Frontier=NULL;
Image *cost=fst->cost,*pred=fst->pred,*label=fst->label,*root=fst->root;
n = grad->ncols*grad->nrows;
Q = CreateGQueue(Cmax+1,n,cost->val);
A = Circular(1.5);
if (Rm != NULL) { // Treat removed trees
Frontier = ForestRemoval(fst,Rm,A);
while (Frontier != NULL) {
p = RemoveSet(&Frontier);
InsertGQueue(&Q,p);
}
}
/* Trivial path initialization for new seeds */
aux = Obj;
while(aux != NULL){
p=aux->elem;
if (Q->L.elem[p].color == GRAY) { /* p is also a frontier pixel,
but the priority is it as a seed. */
RemoveGQueueElem(Q,p);
}
label->val[p]=1; cost->val[p]=0; root->val[p]=p; pred->val[p]=NIL;
InsertGQueue(&Q,p);
aux = aux->next;
}
aux = Bkg;
while(aux != NULL){
p=aux->elem;
if (Q->L.elem[p].color == GRAY) { /* p is also a frontier pixel,
but the priority is it as a seed. */
RemoveGQueueElem(Q,p);
}
label->val[p]=0; cost->val[p]=0; root->val[p]=p; pred->val[p]=NIL;
InsertGQueue(&Q,p);
aux = aux->next;
}
/* Path propagation */
while (!EmptyGQueue(Q)){
p = RemoveGQueue(Q);
u.x = p%grad->ncols;
u.y = p/grad->ncols;
for (i=1; i < A->n; i++) {
v.x = u.x + A->dx[i];
v.y = u.y + A->dy[i];
if (ValidPixel(grad,v.x,v.y)){
q = v.x + grad->tbrow[v.y];
if (Q->L.elem[q].color != BLACK) {
tmp = MAX(cost->val[p] , grad->val[q]);
if ((tmp < cost->val[q])||(pred->val[q]==p)){
if (Q->L.elem[q].color == GRAY) {
RemoveGQueueElem(Q,q);
}
cost->val[q] = tmp;
label->val[q] = label->val[p];
root->val[q] = root->val[p];
pred->val[q] = p;
InsertGQueue(&Q,q);
}
}
}
}
}
DestroyGQueue(&Q);
DestroyAdjRel(&A);
}
int main(int argc, char **argv)
{
timer *t1=NULL,*t2=NULL;
Image *img=NULL,*grad=NULL,*marker=NULL;
Image *label=NULL;
CImage *cimg=NULL;
AdjRel *A=NULL;
char outfile[100];
char *file_noext;
/*--------------------------------------------------------*/
void *trash = malloc(1);
struct mallinfo info;
int MemDinInicial, MemDinFinal;
free(trash);
info = mallinfo();
MemDinInicial = info.uordblks;
/*--------------------------------------------------------*/
if (argc!=4){
fprintf(stderr,"Usage: watergray <image.pgm> <gradient.pgm> <H>\n");
fprintf(stderr,"image.pgm: grayscale image to overlay the watershed lines on it\n");
fprintf(stderr,"gradient.pgm: gradient image to compute the watershed segmentation\n");
fprintf(stderr,"H: an integer that will be added to the gradient to eliminate irrelevant basins (typically <= 100)\n");
exit(-1);
}
img = ReadImage(argv[1]);
grad = ReadImage(argv[2]);
file_noext = strtok(argv[1],".");
// A grayscale marker can be created by any extensive operation:
// A value H may be added to eliminate irrelevant basins, for instance.
marker = AddValue(grad,atoi(argv[3]));
// Watershed from grayscale marker
A = Circular(1.0); // try also higher adjacency radii: 1.5, 2.5, etc.
t1 = Tic();
label = WaterGray(grad,marker,A);
t2 = Toc();
fprintf(stdout,"Processing time in %f ms\n",CTime(t1,t2));
// Draw watershed lines
cimg = DrawLabeledRegions(img,label);
sprintf(outfile,"%s_result.ppm",file_noext);
WriteCImage(cimg,outfile);
DestroyImage(&grad);
DestroyImage(&img);
DestroyImage(&marker);
DestroyCImage(&cimg);
DestroyImage(&label);
DestroyAdjRel(&A);
/* ---------------------------------------------------------- */
info = mallinfo();
MemDinFinal = info.uordblks;
if (MemDinInicial!=MemDinFinal)
printf("\n\nDinamic memory was not completely deallocated (%d, %d)\n",
MemDinInicial,MemDinFinal);
return(0);
}
