GetLinesByRelativeIntensity() 공개 메소드

Get lines with relative intensity higher then specified value.
public GetLinesByRelativeIntensity ( double minRelativeIntensity ) : AForge.Imaging.HoughLine[]
minRelativeIntensity double Minimum relative intesity of lines.
리턴 AForge.Imaging.HoughLine[]
        //1. bright pixel / dark pixel
        //2.lowest gray level
        //3.highest gray level
        //4.number of peaks in the x direction.
        //5.number of peaks in the y direction.
        public static double[] ExtractFeatures(Bitmap bmp,int i)
        {
            //Apply GrayScale
            GrayscaleBT709 greyScaleFilter = new GrayscaleBT709();
            Bitmap newBmp = greyScaleFilter.Apply((Bitmap)bmp.Clone());

            //Count Blobs
            BlobCounter blobCounter = new BlobCounter();
            blobCounter.BackgroundThreshold = Color.FromArgb(255, 150, 150, 150);
            blobCounter.ProcessImage(newBmp);
            int blobs = (blobCounter.ObjectsCount - 1) * 30;

            //Count Corner
            SusanCornersDetector scd = new SusanCornersDetector();
            scd.DifferenceThreshold = 70;
            scd.GeometricalThreshold = 8;
            int corners = scd.ProcessImage((Bitmap)newBmp.Clone()).Count();

            //Apply Edge Filter
            CannyEdgeDetector filter = new CannyEdgeDetector();
            //newBmp = filter.Apply(newBmp);
            Histogram his = new HorizontalIntensityStatistics(newBmp).Gray;
            Histogram vis = new VerticalIntensityStatistics(newBmp).Gray;

            HoughLineTransformation lineTransform = new HoughLineTransformation();
            // apply Hough line transofrm
            lineTransform.ProcessImage(filter.Apply(newBmp));
            Bitmap houghLineImage = lineTransform.ToBitmap();
            // get lines using relative intensity
            HoughLine[] lines = lineTransform.GetLinesByRelativeIntensity(1);
            int linesCount = lines.Count() * 30;

            double[] features = new double[13] { blobs, corners, his.Max, his.Min, his.Mean, his.Median, his.StdDev,
                vis.Max, vis.Min, vis.Mean, vis.Median, vis.StdDev,linesCount};

            //double[] features = new double[3] { blobs, corners,lines};

            newBmp.Save(String.Format("test{0}.bmp",i));
            return features;
        }
예제 #2
0
        //Finds the degree tilt of the part using Hough Line Detection
        //Reference Documentation for Method:http://www.aforgenet.com/framework/docs/html/6141703e-d685-efb5-2f7f-b430aa42210f.htm
        public double findDegreeTilt(Bitmap inImage)
        {
            //Creating HoughLineTranformation object
            AForge.Imaging.HoughLineTransformation lineTransform = new AForge.Imaging.HoughLineTransformation();
            //Adjusts the number of decimal places of the returned angle (Reference Documentation:http://www.aforgenet.com/framework/docs/html/24be38e1-20d8-214e-7adb-31a61854e839.htm)
            lineTransform.StepsPerDegree = 10;
            //Applys filter on image
            lineTransform.ProcessImage(inImage);
            //Creating a temporary bitmap to apply graphics to(Grpahics doesn't accept canny images)
            Bitmap   tempBitmap = new Bitmap(inImage.Width, inImage.Height);
            Graphics g          = Graphics.FromImage(tempBitmap);

            //Redrawing original image on temporary image
            g.DrawImage(inImage, 0, 0);
            Pen bluePen = new Pen(Color.Blue, 2.0f);

            //Stores all Hough lines found with the filter
            //.8 repersents the intensity constant(higher the constant the less lines the filter picks up)
            AForge.Imaging.HoughLine[] lines = lineTransform.GetLinesByRelativeIntensity(.8);
            double averageAngle = 0;

            //Converts each Hough line found to cartesian coordinates and draw each one
            foreach (AForge.Imaging.HoughLine line in lines)
            {
                //Stores the radius and theta and polar line
                int    lineRadius = line.Radius;
                double lineTheta  = line.Theta;
                //Negative radii are made positive
                if (lineRadius < 0)
                {
                    lineTheta += 180;
                    lineRadius = -lineRadius;
                }
                //Converting line theta from degrees to radians
                lineTheta = (lineTheta / 180) * Math.PI;

                //Image center coordinates
                double centerX = inImage.Width / 2.0;
                double centerY = inImage.Height / 2.0;

                //Initialization of hough line coordinates
                double firstX = 0, lastX = 0, firstY = 0, lastY = 0;

                //Creating line coordinates
                if (line.Theta != 0)
                {
                    firstX = -centerX;
                    lastX  = centerX;

                    firstY = (-Math.Cos(lineTheta) * firstX + lineRadius) / Math.Sin(lineTheta);
                    lastY  = (-Math.Cos(lineTheta) * lastX + lineRadius) / Math.Sin(lineTheta);
                }
                else
                {
                    firstX = line.Radius;
                    lastX  = line.Radius;

                    firstY = centerY;
                    lastY  = -centerY;
                }

                //Adjusting lineTheta angle to be in a range from 0 to 90 degrees
                double partRotationAngle = 90.0 - (double)(lines[0].Theta);
                if (partRotationAngle < 0)
                {
                    partRotationAngle += 90;
                }
                //Treat the angle of 90 the same as 0
                if (partRotationAngle == 90)
                {
                    partRotationAngle = 0;
                }
                //Adding the returned angles to average result later on
                averageAngle += partRotationAngle;
                //Draws cartesian line repersenting polar hough line
                g.DrawLine(bluePen, new System.Drawing.Point((int)(firstX + centerX), (int)(centerY - firstY)), new System.Drawing.Point((int)(lastX + centerX), (int)(centerY - lastY)));
            }
            //Calculate the average degree of tilt to improve consistancy
            averageAngle /= (double)lines.Length;
            //Set the label to display rotation angle
            offsetAngle.Text = averageAngle.ToString();
            //If wanted by the user, the hough lines will be displayed in they canny image panel
            if (houghLineCheckBox.Checked)
            {
                cannyImagePanel.Image = tempBitmap;
            }
            //Returns the avearge offset angle
            return(averageAngle);
        }
예제 #3
0
파일: Form1.cs 프로젝트: zStyle/GoRecorder
        private bool GetIntersect(Bitmap grayImage, Bitmap bitmap, int[, ,] intersectPoint)
        {
            HoughLineTransformation lineTransform = new HoughLineTransformation();
            lineTransform.ProcessImage(grayImage);
            Bitmap houghLineImage = lineTransform.ToBitmap();
            // get lines using relative intensity
            HoughLine[] lines = lineTransform.GetLinesByRelativeIntensity(0.5);

            BitmapData bitmapData = bitmap.LockBits(
               new Rectangle(0, 0, bitmap.Width, bitmap.Height),
               ImageLockMode.ReadWrite, bitmap.PixelFormat);
            BitmapData grayImageData = grayImage.LockBits(
               new Rectangle(0, 0, grayImage.Width, grayImage.Height),
               ImageLockMode.ReadWrite, grayImage.PixelFormat);
            UnmanagedImage unmanagedImage = new UnmanagedImage(bitmapData);

            int w2 = 0, h2 = 0;
            Color color = Color.Black;
            int[] mVer = new int[19];
            double[] mHor = new double[19];
            double[] cVer = new double[19];
            double[] cHor = new double[19];
            int verCount = 0;
            int horCount = 0;

            foreach (HoughLine line in lines)
            {

                String temp = line.Theta.ToString();
                // get line's radius and theta values
                int r = line.Radius;
                double t = line.Theta;

                // check if line is in lower part of the image
                if (r < 0)
                {
                    t += 180;
                    r = -r;
                }

                // convert degrees to radians
                t = (t / 180) * Math.PI;

                // get image centers (all coordinate are measured relative
                // to center)
                w2 = grayImage.Width / 2;
                h2 = grayImage.Height / 2;

                double x0 = 0, x1 = 0, y0 = 0, y1 = 0;

                if (line.Theta != 0)
                {
                    // vertical line
                    if (line.Theta > 0 && line.Theta < 10 || line.Theta > 170)
                    {
                        if (verCount == 19)
                        {
                            bitmap.UnlockBits(bitmapData);
                            grayImage.UnlockBits(grayImageData);
                            return false;

                        }
                        y0 = -h2;
                        y1 = h2;
                        x0 = (r - (Math.Sin(t) * y0)) / Math.Cos(t);
                        x1 = (r - (Math.Sin(t) * y1)) / Math.Cos(t);

                        color = Color.Red;

                        x0 = w2 + (int)x0;
                        x1 = w2 + (int)x1;
                        y0 = (h2 - y0);
                        y1 = (h2 - y1);

                        //mVer[verCount] = (int) -(Math.Cos(t)/Math.Sin(t));
                        //cVer[verCount] = (double)r*(1/Math.Sin(t));

                        if ((int)x0 == (int)x1)
                        {
                            mVer[verCount] = (int)((y1 - y0) / (x1 - x0 + 1));
                            cVer[verCount] = y0 - (mVer[verCount] * x0);
                        }
                        else
                        {
                            mVer[verCount] = (int)((y1 - y0) / (x1 - x0));
                            cVer[verCount] = (y0 - (mVer[verCount] * x0));
                        }
                        Drawing.Line(bitmapData,
                        new IntPoint((int)x0, (int)y0),
                        new IntPoint((int)x1 ,(int)y1),
                        color);
                        Drawing.Line(grayImageData,
                        new IntPoint((int)x0 , (int)y0),
                        new IntPoint((int)x1 , (int)y1),
                        color);

                        verCount++;
                    }

                    // horizontal
                    if (line.Theta > 80 && line.Theta < 100)
                    {
                        if (horCount == 19)
                        {
                            bitmap.UnlockBits(bitmapData);
                            grayImage.UnlockBits(grayImageData);
                            return false;

                        }

                        x0 = -w2; // most left point
                        x1 = w2;  // most right point6

                        y0 = (-Math.Cos(t) * x0 + r) / Math.Sin(t);
                        y1 = (-Math.Cos(t) * x1 + r) / Math.Sin(t);

                        x0 = x0 + w2;
                        x1 = x1 + w2;
                        y0 = (int)(h2 - (int)y0);
                        y1 = (int)(h2 - (int)y1);

                        //mHor[horCount] = (int)-(Math.Cos(t) / Math.Sin(t));
                        //cHor[horCount] = (double)r * (1 / Math.Sin(t));
                        if (y0 - (mHor[horCount] * x0) < 10 || y0 - (mHor[horCount] * x0) > bitmap.Height - 10)
                            continue;
                        mHor[horCount] = ((y1 - y0) / (x1 - x0));
                        cHor[horCount] = y0 - (mHor[horCount] * x0);
                        horCount++;

                        Drawing.Line(bitmapData,
                        new IntPoint((int)x0,(int)y0),
                        new IntPoint((int)x1, (int)y1),
                        Color.Blue);
                        Drawing.Line(grayImageData,
                         new IntPoint((int)x0, (int)y0),
                         new IntPoint((int)x1, (int)y1),
                         Color.Blue);
                    }
                }
                else
                {
                    if (verCount == 19)
                    {
                        bitmap.UnlockBits(bitmapData);
                        grayImage.UnlockBits(grayImageData);
                        return false;

                    }
                    // vertical line
                    x0 = line.Radius;
                    x1 = line.Radius;
                    y0 = h2;
                    y1 = -h2;

                    color = Color.Yellow;

                    x0 = x0 + w2;
                    x1 = x1 + w2;
                    y0 = (h2 - (int)y0);
                    y1 = (h2 - (int)y1);

                    //mVer[verCount] = (int)-(Math.Cos(t) / Math.Sin(t));
                    //cVer[verCount] = (double)r * (1 / Math.Sin(t));

                    if (x0 < 10 || x0 > bitmap.Width - 10)
                        continue;
                    mVer[verCount] = (int)((y1 - y0) / (x1 - x0 + 1));
                    cVer[verCount] = y0 - (mVer[verCount] * x0);

                    Drawing.Line(bitmapData,
                    new IntPoint((int)x0, (int)y0),
                    new IntPoint((int)x1, (int)y1),
                    color);
                    Drawing.Line(grayImageData,
                     new IntPoint((int)x0, (int)y0),
                     new IntPoint((int)x1, (int)y1),
                     color);
                    //MessageBox.Show("y0 = " + y0 + " y1 = " + y1 + " x0 = " + x0 + " x1 = " + x1 +
                    //       " m = " + mVer[verCount] + " c = " + cVer[verCount], "ok", MessageBoxButtons.OK);
                    verCount++;

                }
            }

            int m = 0;
            int n = 0;
            if (horCount == 19 && verCount == 19)
            {
                for (int i = 0; i < 19; i++)
                {
                    for (int j = 0; j < 19; j++)
                    {

                        intersectPoint[0, i, j] = (int)((cHor[j] - cVer[i]) / (mVer[i] - mHor[j]));
                        intersectPoint[1, i, j] = (int)((mHor[j] * intersectPoint[0, i, j]) + cHor[j]);
                        Debug.WriteLine(intersectPoint[0, i, j] + " " + intersectPoint[1, i, j] + " " + cHor[j] + " " + mHor[j]);
                    }
                }
                bitmap.UnlockBits(bitmapData);
                grayImage.UnlockBits(grayImageData);
                return true;
            }
            else {
                bitmap.UnlockBits(bitmapData);
                grayImage.UnlockBits(grayImageData);
                return false;
            }

            //int num = 0;
            //MessageBox.Show("num = " + num + " mv =" + mVer[num] + "," + " cv = " + cVer[num] + " mh =" + mHor[num] + "," + " ch = " + cHor[num] + "," + "x = "
            //    + intersectPoint[0, num, num] + "y = " + intersectPoint[1, num, num], "ok", MessageBoxButtons.OK);

            //MessageBox.Show(mVer[18] + "," + cVer[18] + "," + intersectPoint[0, 18, 18], "ok", MessageBoxButtons.OK);
            //MessageBox.Show(intersectPoint. + "", "ok", MessageBoxButtons.OK);
        }
예제 #4
0
        // Process image
        private void ProcessImage( Bitmap bitmap )
        {
            Grayscale grayscaleFilter = new Grayscale(0.33, 0.33, 0.34);
            // apply the filter
            Bitmap grayImage = grayscaleFilter.Apply(bitmap);

            //Get Histogram
            /*int[] histogram = new int[256];
            for (int i = 0; i < 256; i++) {
                histogram[i] = 0;
            }
            for (int i = 0; i < grayImage.Width; i++ )
            {
                for (int j = 0; j < grayImage.Height; j++) {
                    histogram[(Convert.ToInt32(grayImage.GetPixel(i, j).R.ToString()) + Convert.ToInt32(grayImage.GetPixel(i, j).G.ToString()) +
                        Convert.ToInt32(grayImage.GetPixel(i, j).B.ToString()))/3] +=1;
                }
            }*/

            //create filter
            SobelEdgeDetector sobelFilter = new SobelEdgeDetector();
            // apply the filter
            sobelFilter.ApplyInPlace(grayImage);
            Threshold filter = new Threshold(243);
            // apply the filter
            filter.ApplyInPlace(grayImage);

            HoughLineTransformation lineTransform = new HoughLineTransformation();

            lineTransform.ProcessImage(grayImage);
            Bitmap houghLineImage = lineTransform.ToBitmap();
            // get lines using relative intensity
            HoughLine[] lines = lineTransform.GetLinesByRelativeIntensity(0.5);

            BitmapData bitmapData = bitmap.LockBits(
               new Rectangle(0, 0, bitmap.Width, bitmap.Height),
               ImageLockMode.ReadWrite, bitmap.PixelFormat);
            BitmapData grayImageData = grayImage.LockBits(
               new Rectangle(0, 0, grayImage.Width, grayImage.Height),
               ImageLockMode.ReadWrite, grayImage.PixelFormat);
            UnmanagedImage unmanagedImage = new UnmanagedImage(bitmapData);

            int w2 = 0, h2 = 0;
            int vertical = 0;
            int horizons = 0;

            int testColor = 0;
            Color color = Color.Black;

            foreach (HoughLine line in lines)
            {

                String temp = line.Theta.ToString();
                //MessageBox.Show(temp, "ok", MessageBoxButtons.OK);
                // get line's radius and theta values
                int r = line.Radius;
                double t = line.Theta;

                // check if line is in lower part of the image
                if (r < 0)
                {
                    t += 180;
                    r = -r;
                }

                // convert degrees to radians
                t = (t / 180) * Math.PI;

                // get image centers (all coordinate are measured relative
                // to center)
                w2 = grayImage.Width / 2;
                h2 = grayImage.Height / 2;

                double x0 = 0, x1 = 0, y0 = 0, y1 = 0;

                if (line.Theta != 0)
                {
                    // horizontal
                    // none-vertical line

                    if (line.Theta > 0 && line.Theta < 10 || line.Theta > 170)
                    {
                        x0 = -w2; // most left point
                        x1 = w2;  // most right point

                        y0 = (-Math.Cos(t) * x0 + r) / Math.Sin(t);
                        y1 = (-Math.Cos(t) * x1 + r) / Math.Sin(t);

                        color = Color.Red;

                        Drawing.Line(bitmapData,
                        new IntPoint((int)x0 + w2, h2 - (int)y0),
                        new IntPoint((int)x1 + w2, h2 - (int)y1),
                        color);
                        Drawing.Line(grayImageData,
                         new IntPoint((int)x0 + w2, h2 - (int)y0),
                         new IntPoint((int)x1 + w2, h2 - (int)y1),
                         color);
                    }

                    if (line.Theta > 80 && line.Theta < 100)
                    {
                        x0 = -w2; // most left point
                        x1 = w2;  // most right point

                        y0 = (-Math.Cos(t) * x0 + r) / Math.Sin(t);
                        y1 = (-Math.Cos(t) * x1 + r) / Math.Sin(t);

                        Drawing.Line(bitmapData,
                        new IntPoint((int)x0 + w2, h2 - (int)y0),
                        new IntPoint((int)x1 + w2, h2 - (int)y1),
                        Color.Blue);
                        Drawing.Line(grayImageData,
                         new IntPoint((int)x0 + w2, h2 - (int)y0),
                         new IntPoint((int)x1 + w2, h2 - (int)y1),
                         Color.Blue);
                    }

                }
                else
                {
                    // vertical line
                    x0 = line.Radius;
                    x1 = line.Radius;
                    y0 = h2;
                    y1 = -h2;

                    color = Color.Red;

                    Drawing.Line(bitmapData,
                    new IntPoint((int)x0 + w2, h2 - (int)y0),
                    new IntPoint((int)x1 + w2, h2 - (int)y1),
                    color);
                    Drawing.Line(grayImageData,
                     new IntPoint((int)x0 + w2, h2 - (int)y0),
                     new IntPoint((int)x1 + w2, h2 - (int)y1),
                     color);
                }
            }

            bitmap.UnlockBits(bitmapData);
            grayImage.UnlockBits(grayImageData);
            MessageBox.Show(lines.Length+"", "ok", MessageBoxButtons.OK);
            // put new image to clipboard

            Clipboard.SetDataObject(bitmap);
            // and to picture box
            pictureBox.Image = bitmap;

            UpdatePictureBoxPosition();
        }
예제 #5
0
        /// <summary>
        /// Apply - search for broken bones - by finding lines and detecting angles between them
        /// </summary>
        /// <param name="bmp">Bitmap - original</param>
        /// <returns>Bitmap - processed</returns>
        public Bitmap Apply(Bitmap bmp)
        {
            System.Drawing.Imaging.PixelFormat pf = bmp.PixelFormat;
            ROI = bmp.Rectangle();
            var lineTransform = new AForge.Imaging.HoughLineTransformation();

            lineTransform.MinLineIntensity = 60;
            lineTransform.LocalPeakRadius  = 15;
            //lineTransform.StepsPerDegree = 10;
            //lineTransform.LocalPeakRadius = 10;
            // apply Hough line transofrm
            lineTransform.ProcessImage(bmp);
            Bitmap houghLineImage = lineTransform.ToBitmap();
            // get lines using relative intensity
            var lines = lineTransform.GetLinesByRelativeIntensity(0.5);

            lines = filterLinesByTheta(lines);


            Dilatation dl = new Dilatation();

            dl.ApplyInPlace(bmp);

            Invert filter = new Invert();

            filter.ApplyInPlace(bmp);

            bmp = bmp.Bit8ToBit24();

            foreach (var line in lines)
            {
                // get line's radius and theta values
                int    radius             = line.Radius;
                double lineSlopeInDegrees = line.Theta;

                // check if line is in lower part of the image
                if (radius < 0)
                {
                    lineSlopeInDegrees += 180;
                    radius              = -radius;
                }

                var radians = lineSlopeInDegrees.DegreesToRadians();

                var imageCenter = bmp.GetCenter();

                double x0 = 0,  //most left point
                       y0 = 0,
                       x1 = 0,  //most right point
                       y1 = 0;

                if (line.Theta != 0)
                {
                    // none-vertical line
                    x0 = -imageCenter.X; // most left point
                    x1 = imageCenter.X;  // most right point

                    // calculate corresponding y values
                    y0 = (-radians.Cosinus() * x0 + radius) / radians.Sinus();
                    y1 = (-radians.Cosinus() * x1 + radius) / radians.Sinus();
                }
                else
                {
                    // vertical line
                    x0 = line.Radius;
                    x1 = line.Radius;

                    y0 = imageCenter.Y;
                    y1 = -imageCenter.Y;
                }

                var line2 = new Line(
                    (int)x0 + imageCenter.X, imageCenter.Y - (int)y0,
                    (int)x1 + imageCenter.X, imageCenter.Y - (int)y1);
                line2.X1 = (int)x0 + imageCenter.X;
                line2.Y1 = imageCenter.Y - (int)y0;
                line2.X2 = (int)x1 + imageCenter.X;
                line2.Y2 = imageCenter.Y - (int)y1;
                Lines.Add(line2);
            }
            return(drawLines(bmp));
        }