public static void SetAdaptTreshold(IplImage gray, ref IplImage threshold, AdaptiveThresholdType aptTValue, ThresholdType thsType, double ThresholdValue, int AdaptativeVal1, int AdaptativeVal2) { try { gray.AdaptiveThreshold(threshold, ThresholdValue, aptTValue, thsType, AdaptativeVal1, AdaptativeVal1); } catch (Exception e) { MainWindow.Instance.OpenDialog("Invalid value combination", e.Message); } }
public static Image <Gray, byte> AdaptiveThreshold ( this Image <Gray, byte> inImage , double maxVal = 250 , AdaptiveThresholdType adaptiveThresholdType = AdaptiveThresholdType.MeanC , ThresholdType thresholdType = ThresholdType.BinaryInv , int blockSize = 39 , double param1 = 4) { var outImage = inImage.Copy(); CvInvoke.AdaptiveThreshold (GaussBlur(inImage), outImage, maxVal, adaptiveThresholdType, thresholdType, blockSize, param1); return(outImage); }
/// <summary> /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する /// </summary> /// <param name="src">入力画像</param> /// <param name="dst">出力画像</param> /// <param name="maxValue">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param> /// <param name="adaptiveMethod">適応的閾値処理で使用するアルゴリズム</param> /// <param name="thresholdType">閾値処理の種類. BinaryかBinaryInvのどちらか</param> /// <param name="blockSize">ピクセルの閾値を計算するために用いる隣接領域のサイズ: 3, 5, 7, ... </param> /// <param name="param1">各適応手法に応じたパラメータ. 適応手法がMeanCおよびGaussianCの場合は,平均値または重み付き平均値から引く定数. 負の値の場合もある.</param> #else /// <summary> /// Applies adaptive threshold to array. /// </summary> /// <param name="src">Source image.</param> /// <param name="dst">Destination image. </param> /// <param name="maxValue">Maximum value that is used with Binary and BinaryInv. </param> /// <param name="adaptiveMethod">Adaptive thresholding algorithm to use: MeanC or GaussianC.</param> /// <param name="thresholdType">Thresholding type.</param> /// <param name="blockSize">The size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, ... </param> /// <param name="param1">The method-dependent parameter. For the methods MeanC and GaussianC it is a constant subtracted from mean or weighted mean (see the discussion), though it may be negative. </param> #endif public static void AdaptiveThreshold(CvArr src, CvArr dst, double maxValue, AdaptiveThresholdType adaptiveMethod, ThresholdType thresholdType, int blockSize, double param1) { if (src == null) { throw new ArgumentNullException("src"); } if (dst == null) { throw new ArgumentNullException("dst"); } if (thresholdType != ThresholdType.Binary && thresholdType != ThresholdType.BinaryInv) { throw new ArgumentException("thresholdType == Binary || thresholdType == BinaryInv"); } NativeMethods.cvAdaptiveThreshold(src.CvPtr, dst.CvPtr, maxValue, adaptiveMethod, thresholdType, blockSize, param1); }
private void comboAdaptiveThresholdType_SelectedIndexChanged(object sender, EventArgs e) { if (useAdaptive) { switch (comboAdaptiveThresholdType.SelectedIndex) { case (int)AdaptiveThresholdType.MeanC: _adaptiveThresholdType = AdaptiveThresholdType.MeanC; break; case (int)AdaptiveThresholdType.GaussianC: _adaptiveThresholdType = AdaptiveThresholdType.GaussianC; break; default: break; } buttonBinarisation_Click(sender, e); } }
/// <summary> /// Applies an adaptive threshold to an array. /// Source matrix must be 8-bit single-channel image. /// </summary> /// <param name="maxValue">Non-zero value assigned to the pixels for which the condition is satisfied. See the details below.</param> /// <param name="adaptiveMethod">Adaptive thresholding algorithm to use, ADAPTIVE_THRESH_MEAN_C or ADAPTIVE_THRESH_GAUSSIAN_C .</param> /// <param name="thresholdType">Thresholding type that must be either THRESH_BINARY or THRESH_BINARY_INV .</param> /// <param name="blockSize">Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.</param> /// <param name="c">Constant subtracted from the mean or weighted mean (see the details below). /// Normally, it is positive but may be zero or negative as well.</param> /// <returns>Destination image of the same size and the same type as src.</returns> public Mat AdaptiveThreshold(double maxValue, AdaptiveThresholdType adaptiveMethod, ThresholdType thresholdType, int blockSize, double c) { var dst = new Mat(); Cv2.AdaptiveThreshold(this, dst, maxValue, adaptiveMethod, thresholdType, blockSize, c); return dst; }
public static extern void cvAdaptiveThreshold(IntPtr src, IntPtr dst, double max_value, AdaptiveThresholdType adaptiveType, ThresholdType threshold_type, int block_size, double param1);
/// <summary> /// Applies an adaptive threshold to an array. /// </summary> /// <param name="src">Source 8-bit single-channel image.</param> /// <param name="dst">Destination image of the same size and the same type as src .</param> /// <param name="maxValue">Non-zero value assigned to the pixels for which the condition is satisfied. See the details below.</param> /// <param name="adaptiveMethod">Adaptive thresholding algorithm to use, ADAPTIVE_THRESH_MEAN_C or ADAPTIVE_THRESH_GAUSSIAN_C .</param> /// <param name="thresholdType">Thresholding type that must be either THRESH_BINARY or THRESH_BINARY_INV .</param> /// <param name="blockSize">Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.</param> /// <param name="c">Constant subtracted from the mean or weighted mean (see the details below). /// Normally, it is positive but may be zero or negative as well.</param> public static void AdaptiveThreshold(InputArray src, OutputArray dst, double maxValue, AdaptiveThresholdType adaptiveMethod, ThresholdType thresholdType, int blockSize, double c) { if (src == null) throw new ArgumentNullException("src"); if (dst == null) throw new ArgumentNullException("dst"); src.ThrowIfDisposed(); dst.ThrowIfNotReady(); NativeMethods.imgproc_adaptiveThreshold(src.CvPtr, dst.CvPtr, maxValue, (int)adaptiveMethod, (int)thresholdType, blockSize, c); dst.Fix(); }
public void AdaptiveThreshold(AdaptiveThresholdType adaptiveType = AdaptiveThresholdType.MeanC, ThresholdType thresholdType = ThresholdType.Binary, double maxValue = 255) { CvInvoke.AdaptiveThreshold(this.Data, this.Data, maxValue, adaptiveType, thresholdType, 201, -2); }
public Mat Quantize(Mat image) { var stopwatch = new Stopwatch(); stopwatch.Start(); var sourceImage = image; var destImage = new Mat(sourceImage.Size, DepthType.Default, 1); var destImageBin = new Mat(sourceImage.Size, DepthType.Default, 1); Matrix <float> srcKeypoints = new Matrix <float>(_keypoints); Matrix <float> destKeypoints = new Matrix <float>(new float[, ] { { 0, 0 }, { GameBoyConstants.ScreenWidth, 0 }, { 0, GameBoyConstants.ScreenHeight }, { GameBoyConstants.ScreenWidth, GameBoyConstants.ScreenHeight } }); // calculate transformation matrix var transform = CvInvoke.GetPerspectiveTransform(srcKeypoints, destKeypoints); _logger.Info($"{stopwatch.ElapsedMilliseconds} ms, GetPerspectiveTransform"); stopwatch.Restart(); /* Too resource-intensive! * // denoise * CvInvoke.FastNlMeansDenoising(sourceImage, sourceImage); * * _logger.Info($"{stopwatch.ElapsedMilliseconds} ms, FastNlMeansDenoising"); * stopwatch.Restart(); */ // transform CvInvoke.WarpPerspective(sourceImage, destImage, transform, new Size(GameBoyConstants.ScreenWidth, GameBoyConstants.ScreenHeight), Inter.Linear, Warp.Default); _logger.Info($"{stopwatch.ElapsedMilliseconds} ms, WarpPerspective"); stopwatch.Restart(); // threshold CvInvoke.AdaptiveThreshold(destImage, destImageBin, 255, _mode, ThresholdType.Binary, _block, _c); _logger.Info($"{stopwatch.ElapsedMilliseconds} ms, AdaptiveThreshold"); stopwatch.Restart(); while (_adjust) { CvInvoke.AdaptiveThreshold(destImage, destImageBin, 255, _mode, ThresholdType.Binary, _block, _c); CvInvoke.NamedWindow("Test"); CvInvoke.Imshow("Test", destImageBin); string outputFilename = "quantizer_output.png"; string outputPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), outputFilename); destImageBin.Save(outputPath); int key = CvInvoke.WaitKey(); Debug.Write(key); if (key == 2490368) { _block += 2; } if (key == 2621440) { _block -= 2; } if (key == 2424832) { _c++; } if (key == 2555904) { _c--; } if (key == 109) { _mode = AdaptiveThresholdType.MeanC; } if (key == 103) { _mode = AdaptiveThresholdType.GaussianC; } if (key == 27) { break; } if (_block < 3) { _block = 3; } _logger.Info("Constant: " + _c); _logger.Info("Block size: " + _block); _logger.Info("Mode: " + _mode); } return(destImageBin); }
/// <summary> /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する /// </summary> /// <param name="src">入力画像</param> /// <param name="dst">出力画像</param> /// <param name="maxValue">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param> /// <param name="adaptiveMethod">適応的閾値処理で使用するアルゴリズム</param> /// <param name="thresholdType">閾値処理の種類. BinaryかBinaryInvのどちらか</param> /// <param name="blockSize">ピクセルの閾値を計算するために用いる隣接領域のサイズ: 3, 5, 7, ... </param> #else /// <summary> /// Applies adaptive threshold to array. /// </summary> /// <param name="src">Source image.</param> /// <param name="dst">Destination image. </param> /// <param name="maxValue">Maximum value that is used with Binary and BinaryInv. </param> /// <param name="adaptiveMethod">Adaptive thresholding algorithm to use: MeanC or GaussianC.</param> /// <param name="thresholdType">Thresholding type.</param> /// <param name="blockSize">The size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, ... </param> #endif public static void AdaptiveThreshold(CvArr src, CvArr dst, double maxValue, AdaptiveThresholdType adaptiveMethod, ThresholdType thresholdType, int blockSize) { AdaptiveThreshold(src, dst, maxValue, adaptiveMethod, thresholdType, blockSize, 5); }
/// <summary> /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する /// </summary> /// <param name="src">入力画像</param> /// <param name="dst">出力画像</param> /// <param name="maxValue">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param> /// <param name="adaptiveMethod">適応的閾値処理で使用するアルゴリズム</param> #else /// <summary> /// Applies adaptive threshold to array. /// </summary> /// <param name="src">Source image.</param> /// <param name="dst">Destination image. </param> /// <param name="maxValue">Maximum value that is used with Binary and BinaryInv. </param> /// <param name="adaptiveMethod">Adaptive thresholding algorithm to use: MeanC or GaussianC.</param> #endif public static void AdaptiveThreshold(CvArr src, CvArr dst, double maxValue, AdaptiveThresholdType adaptiveMethod) { AdaptiveThreshold(src, dst, maxValue, adaptiveMethod, ThresholdType.Binary, 3, 5); }
/// <summary> /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する /// </summary> /// <param name="src">入力画像</param> /// <param name="dst">出力画像</param> /// <param name="max_value">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param> /// <param name="adaptive_method">適応的閾値処理で使用するアルゴリズム</param> /// <param name="threshold_type">閾値処理の種類. BinaryかBinaryInvのどちらか</param> /// <param name="block_size">ピクセルの閾値を計算するために用いる隣接領域のサイズ: 3, 5, 7, ... </param> /// <param name="param1">各適応手法に応じたパラメータ. 適応手法がMeanCおよびGaussianCの場合は,平均値または重み付き平均値から引く定数. 負の値の場合もある.</param> #else /// <summary> /// Applies adaptive threshold to array. /// </summary> /// <param name="src">Source image.</param> /// <param name="dst">Destination image. </param> /// <param name="max_value">Maximum value that is used with CV_THRESH_BINARY and CV_THRESH_BINARY_INV. </param> /// <param name="adaptive_method">Adaptive thresholding algorithm to use: CV_ADAPTIVE_THRESH_MEAN_C or CV_ADAPTIVE_THRESH_GAUSSIAN_C.</param> /// <param name="threshold_type">Thresholding type.</param> /// <param name="block_size">The size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, ... </param> /// <param name="param1">The method-dependent parameter. For the methods CV_ADAPTIVE_THRESH_MEAN_C and CV_ADAPTIVE_THRESH_GAUSSIAN_C it is a constant subtracted from mean or weighted mean (see the discussion), though it may be negative. </param> #endif public static void AdaptiveThreshold(CvArr src, CvArr dst, double max_value, AdaptiveThresholdType adaptive_method, ThresholdType threshold_type, int block_size, double param1) { if (src == null) throw new ArgumentNullException("src"); if (dst == null) throw new ArgumentNullException("dst"); if (threshold_type != ThresholdType.Binary && threshold_type != ThresholdType.BinaryInv) { throw new ArgumentOutOfRangeException("閾値処理の種類は、BinaryかBinaryInvのどちらかである必要があります。"); } CvInvoke.cvAdaptiveThreshold(src.CvPtr, dst.CvPtr, max_value, adaptive_method, threshold_type, block_size, param1); }
/// <summary> /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する /// </summary> /// <param name="src">入力画像</param> /// <param name="dst">出力画像</param> /// <param name="max_value">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param> /// <param name="adaptive_method">適応的閾値処理で使用するアルゴリズム</param> /// <param name="threshold_type">閾値処理の種類. BinaryかBinaryInvのどちらか</param> /// <param name="block_size">ピクセルの閾値を計算するために用いる隣接領域のサイズ: 3, 5, 7, ... </param> #else /// <summary> /// Applies adaptive threshold to array. /// </summary> /// <param name="src">Source image.</param> /// <param name="dst">Destination image. </param> /// <param name="max_value">Maximum value that is used with CV_THRESH_BINARY and CV_THRESH_BINARY_INV. </param> /// <param name="adaptive_method">Adaptive thresholding algorithm to use: CV_ADAPTIVE_THRESH_MEAN_C or CV_ADAPTIVE_THRESH_GAUSSIAN_C.</param> /// <param name="threshold_type">Thresholding type.</param> /// <param name="block_size">The size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, ... </param> #endif public static void AdaptiveThreshold(CvArr src, CvArr dst, double max_value, AdaptiveThresholdType adaptive_method, ThresholdType threshold_type, Int32 block_size) { AdaptiveThreshold(src, dst, max_value, adaptive_method, threshold_type, block_size, 5); }
/// <summary> /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する /// </summary> /// <param name="src">入力画像</param> /// <param name="dst">出力画像</param> /// <param name="maxValue">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param> /// <param name="adaptiveMethod">適応的閾値処理で使用するアルゴリズム</param> /// <param name="thresholdType">閾値処理の種類. BinaryかBinaryInvのどちらか</param> /// <param name="blockSize">ピクセルの閾値を計算するために用いる隣接領域のサイズ: 3, 5, 7, ... </param> /// <param name="param1">各適応手法に応じたパラメータ. 適応手法がMeanCおよびGaussianCの場合は,平均値または重み付き平均値から引く定数. 負の値の場合もある.</param> #else /// <summary> /// Applies adaptive threshold to array. /// </summary> /// <param name="src">Source image.</param> /// <param name="dst">Destination image. </param> /// <param name="maxValue">Maximum value that is used with Binary and BinaryInv. </param> /// <param name="adaptiveMethod">Adaptive thresholding algorithm to use: MeanC or GaussianC.</param> /// <param name="thresholdType">Thresholding type.</param> /// <param name="blockSize">The size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, ... </param> /// <param name="param1">The method-dependent parameter. For the methods MeanC and GaussianC it is a constant subtracted from mean or weighted mean (see the discussion), though it may be negative. </param> #endif public static void AdaptiveThreshold(CvArr src, CvArr dst, double maxValue, AdaptiveThresholdType adaptiveMethod, ThresholdType thresholdType, int blockSize, double param1) { if (src == null) throw new ArgumentNullException("src"); if (dst == null) throw new ArgumentNullException("dst"); if (thresholdType != ThresholdType.Binary && thresholdType != ThresholdType.BinaryInv) { throw new ArgumentException("thresholdType == Binary || thresholdType == BinaryInv"); } NativeMethods.cvAdaptiveThreshold(src.CvPtr, dst.CvPtr, maxValue, adaptiveMethod, thresholdType, blockSize, param1); }
private void runFilterButton_Click(object sender, EventArgs e) { Bitmap pBoxImage; Image <Bgr, byte> inputImage; Image <Gray, Byte> grayImage; try { pBoxImage = new Bitmap(pictureBox1.Image); inputImage = new Image <Bgr, Byte>(pBoxImage); grayImage = inputImage.Convert <Gray, Byte>(); } catch (Exception ex) { MessageBox.Show(ex.Message); throw; } switch (filtersComboBox.SelectedIndex) { case 0: //Gaussian colorFlag = true; filterLabel1.Visible = false; int otherGaussKernal = 5; if (otherGaussKernal % 2 == 0) { gaussKernel--; //textBox1.Text = otherGaussKernal.ToString(); } inputImage._SmoothGaussian(otherGaussKernal); break; case 1: //Histogram Equalization colorFlag = true; inputImage._EqualizeHist(); break; case 2: //MorphClose colorFlag = true; Mat kernel = CvInvoke.GetStructuringElement(Emgu.CV.CvEnum.ElementShape.Cross, new Size(15, 15), new Point(1, 1)); Emgu.CV.CvEnum.MorphOp operation = Emgu.CV.CvEnum.MorphOp.Close; Point anchor = new Point(-1, -1); int iterations = 1; Emgu.CV.CvEnum.BorderType borderType = Emgu.CV.CvEnum.BorderType.Default; Emgu.CV.Structure.MCvScalar borderValue = new MCvScalar(); inputImage._MorphologyEx(operation, kernel, anchor, iterations, borderType, borderValue); break; case 3: //MorphCloseB&W colorFlag = false; //Image<Gray, Byte> grayImage = inputImage.Convert<Gray, Byte>(); Mat kernel1 = CvInvoke.GetStructuringElement(Emgu.CV.CvEnum.ElementShape.Cross, new Size(15, 15), new Point(1, 1)); Emgu.CV.CvEnum.MorphOp operation1 = Emgu.CV.CvEnum.MorphOp.Close; Point anchor1 = new Point(-1, -1); int iterations1 = 1; Emgu.CV.CvEnum.BorderType borderType1 = Emgu.CV.CvEnum.BorderType.Default; Emgu.CV.Structure.MCvScalar borderValue1 = new MCvScalar(); grayImage._MorphologyEx(operation1, kernel1, anchor1, iterations1, borderType1, borderValue1); break; case 4: //Monochrome colorFlag = false; break; case 5: //Canny colorFlag = false; double cannyThresh = 10; double cannyThreshLinking = 500; grayImage = grayImage.Canny(cannyThresh, cannyThreshLinking); break; case 6: //Laplace colorFlag = false; int laplaceApertureSize = 1; //grayImage = grayImage.Laplace(apertureSize); //grayImage.Laplace(apertureSize).ConvertFrom(); Image <Gray, float> cannyGrayImageFloat = grayImage.Laplace(laplaceApertureSize); grayImage = cannyGrayImageFloat.Convert <Gray, Byte>(); break; case 7: //Sobel colorFlag = false; int sobelXOrder = 1; int sobelYOrder = 1; int sobelApertureSize = 5; Image <Gray, float> sobelGrayImageFloat = grayImage.Sobel(sobelXOrder, sobelYOrder, sobelApertureSize); grayImage = sobelGrayImageFloat.Convert <Gray, Byte>(); break; case 8: //SmoothBilatral colorFlag = true; int kernelSize = 25; int colorSigma = 55; int spaceSigma = 55; inputImage = inputImage.SmoothBilatral(kernelSize, colorSigma, spaceSigma); break; case 9: //ThresholdAdaptive colorFlag = false; Emgu.CV.Structure.Gray maxValue = new Gray(150); AdaptiveThresholdType adaptiveType = AdaptiveThresholdType.GaussianC; ThresholdType thresholdType = ThresholdType.Binary; int blockSize = 3; Emgu.CV.Structure.Gray param1 = new Gray(); grayImage = grayImage.ThresholdAdaptive(maxValue, adaptiveType, thresholdType, blockSize, param1); break; case 10: //SmoothMedian colorFlag = true; int smoothMedianSize = 25; inputImage = inputImage.SmoothMedian(smoothMedianSize); break; case 11: //CLAHE colorFlag = true; IInputArray CLAHEsrc = inputImage.GetOutputArray(); double CLAHEClipLimit = 40; Size CLAHETileGridSize = new System.Drawing.Size(8, 8); OutputArray CLAHEdst; Emgu.CV.CvInvoke.CLAHE(CLAHEsrc, CLAHEClipLimit, CLAHETileGridSize, CLAHEdst); break; default: MessageBox.Show("No filter selected, or failure occured"); break; } filterPictureBox.SizeMode = PictureBoxSizeMode.Zoom; if (colorFlag) { filterPictureBox.Image = inputImage.ToBitmap(); } else { filterPictureBox.Image = grayImage.ToBitmap(); } }