Page 85 -
P. 85

Chapter 2 ■ Edge-Detection Techniques    59



                                 /* Convolution of source image with a Gaussian in X and Y directions */
                                        smx = f2d (im->info->nr, im->info->nc);
                                        printf (“Convolution with LoG:\n“);
                                        convolution (im, lgau, n, n, smx, im->info->nr, im->info->nc);

                                 /* Locate the zero crossings */
                                        printf (“Zero crossings:\n“);
                                        zero_cross (smx, im);

                                 /* Clear the boundary */
                                        for (i=0; i<im->info->nr; i++)
                                        {
                                          for (j=0; j<=width; j++) im->data[i][j] = 0;
                                          for (j=im->info->nc-width-1; j<im->info->nc; j++)
                                              im->data[i][j] = 0;
                                        }
                                        for (j=0; j<im->info->nc; j++)
                                        {
                                          for (i=0; i<= width; i++) im->data[i][j] = 0;
                                          for (i=im->info->nr-width-1; i<im->info->nr; i++)
                                              im->data[i][j] = 0;
                                        }

                                        free(smx[0]); free(smx);
                                        free(lgau[0]); free(lgau);
                                 }

                                 /*     Gaussian     */
                                 float gauss(float x, float sigma)
                                 {
                                     return (float)exp((double) ((-x*x)/(2*sigma*sigma)));
                                 }

                                 float meanGauss (float x, float sigma)
                                 {
                                        float z;
                                        z = (gauss(x,sigma)+gauss(x+0.5,sigma)+gauss(x-0.5,sigma))/3.0;
                                        z = z/(PI*2.0*sigma*sigma);
                                        return z;
                                 }

                                 float LoG (float x, float sigma)
                                 {
                                        float x1;

                                        x1 = gauss (x, sigma);
                                        return (x*x-2*sigma*sigma)/(sigma*sigma*sigma*sigma) * x1;
                                 }
   80   81   82   83   84   85   86   87   88   89   90