半块菠萝

C#图片处理

查找图片所在位置

原理：使用OpenCvSharp对比查找小图片在大图片上的位置

private static System.Drawing.Point Find(Mat BackGround, Mat Identify, double threshold = 0.8)
{
     using (Mat res = new Mat(BackGround.Rows - Identify.Rows + 1, BackGround.Cols - Identify.Cols + 1, MatType.CV_32FC1))
     {
         Mat gref = BackGround.CvtColor(ColorConversionCodes.BGR2GRAY);
         Mat gtpl = Identify.CvtColor(ColorConversionCodes.BGR2GRAY);

         Cv2.MatchTemplate(gref, gtpl, res, TemplateMatchModes.CCoeffNormed);
         Cv2.Threshold(res, res, 0.8, 1.0, ThresholdTypes.Tozero);

         double minval, maxval;
         OpenCvSharp.Point minloc, maxloc;

         Cv2.MinMaxLoc(res, out minval, out maxval, out minloc, out maxloc);

         if (maxval >= threshold)
         {
             return new System.Drawing.Point(maxloc.X,maxloc.Y);
         }
         return new System.Drawing.Point(0, 0);
     }
 }

图片转化

引用的博客比较多，这是其中几个引用，其他的找不到原出处了

https://blog.csdn.net/wchstrife/article/details/78984735?ydreferer=aHR0cHM6Ly9jbi5iaW5nLmNvbS8%3D
https://blog.csdn.net/jiangxinyu/article/details/6222322
https://blog.csdn.net/fangyu723/article/details/108240479

界面效果


数字提取

网上找的一张游戏界面图

    /// 
    /// 图像处理转换
    /// 
    public class ImgConvert
    {
        /// 
        /// 图片脱色（灰度）
        /// 
        /// 
        /// 
        /// 
        public static Bitmap DeColor(Bitmap bitmap,int Case)
        {
            int Height = bitmap.Height;
            int Width = bitmap.Width;
            Bitmap newBitmap = new Bitmap(Width, Height);
            Color pixel;
            for (int x = 0; x < Width; x++)
                for (int y = 0; y < Height; y++)
                {
                    pixel = bitmap.GetPixel(x, y);
                    int r, g, b, Result = 0;
                    r = pixel.R;
                    g = pixel.G;
                    b = pixel.B;
                    switch (Case)
                    {
                        case 0://平均值法
                            Result = ((r + g + b) / 3);
                            break;
                        case 1://最大值法
                            Result = r > g ? r : g;
                            Result = Result > b ? Result : b;
                            break;
                        case 2://加权平均值法1
                            Result = ((int)(0.7 * r) + (int)(0.2 * g) + (int)(0.1 * b));
                            break;
                        case 3://加权平均值法2
                            Result = ((int)(0.3 * r) + (int)(0.59 * g) + (int)(0.11 * b));
                            break;
                    }
                    newBitmap.SetPixel(x, y, Color.FromArgb(Result, Result, Result));
                }
            return newBitmap;
        }

        /// 
        /// 图片暗角
        /// 
        /// 
        /// 
        public static Bitmap DarkCorner(Bitmap bitmap)
        {
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            int width = newbitmap.Width;
            int height = newbitmap.Height;
            float cx = width / 2;
            float cy = height / 2;
            float maxDist = cx * cx + cy * cy;
            float currDist = 0, factor;
            Color pixel;

            for (int i = 0; i < width; i++)
            {
                for (int j = 0; j < height; j++)
                {
                    currDist = ((float)i - cx) * ((float)i - cx) + ((float)j - cy) * ((float)j - cy);
                    factor = currDist / maxDist;

                    pixel = newbitmap.GetPixel(i, j);
                    int red = (int)(pixel.R * (1 - factor));
                    int green = (int)(pixel.G * (1 - factor));
                    int blue = (int)(pixel.B * (1 - factor));
                    newbitmap.SetPixel(i, j, Color.FromArgb(red, green, blue));
                }
            }
            return newbitmap;
        }

        /// 
        /// 加马赛克
        /// 
        /// 
        /// 
        public static Bitmap Mosaic(Bitmap bitmap)
        {
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            int RIDIO = 20;//马赛克的尺度，默认为周围两个像素
            for (int h = 0; h < newbitmap.Height; h += RIDIO)
            {
                for (int w = 0; w < newbitmap.Width; w += RIDIO)
                {
                    int avgRed = 0, avgGreen = 0, avgBlue = 0;
                    int count = 0;
                    //取周围的像素
                    for (int x = w; (x < w + RIDIO && x < newbitmap.Width); x++)
                    {
                        for (int y = h; (y < h + RIDIO && y < newbitmap.Height); y++)
                        {
                            Color pixel = newbitmap.GetPixel(x, y);
                            avgRed += pixel.R;
                            avgGreen += pixel.G;
                            avgBlue += pixel.B;
                            count++;
                        }
                    }

                    //取平均值
                    avgRed = avgRed / count;
                    avgBlue = avgBlue / count;
                    avgGreen = avgGreen / count;

                    //设置颜色
                    for (int x = w; (x < w + RIDIO && x < newbitmap.Width); x++)
                    {
                        for (int y = h; (y < h + RIDIO && y < newbitmap.Height); y++)
                        {
                            Color newColor = Color.FromArgb(avgRed, avgGreen, avgBlue);
                            newbitmap.SetPixel(x, y, newColor);
                        }
                    }
                }
            }
            return newbitmap;
        }

        /// 
        /// 底片
        /// 
        /// 
        /// 
        public static Bitmap Negative(Bitmap bitmap)
        {
            int Height = bitmap.Height;
            int Width = bitmap.Width;
            Bitmap newbitmap = new Bitmap(Width, Height);
            Color pixel;
            for (int x = 1; x < Width; x++)
            {
                for (int y = 1; y < Height; y++)
                {
                    int r, g, b;
                    pixel = bitmap.GetPixel(x, y);
                    r = 255 - pixel.R;
                    g = 255 - pixel.G;
                    b = 255 - pixel.B;
                    newbitmap.SetPixel(x, y, Color.FromArgb(r, g, b));
                }
            }
            return newbitmap;
        }

        /// 
        /// 浮雕
        /// 
        /// 
        /// 
        public static Bitmap Relief(Bitmap bitmap)
        {
            int Height = bitmap.Height;
            int Width = bitmap.Width;
            Bitmap newbitmap = new Bitmap(Width, Height);
            Color pixel1, pixel2;
            for (int x = 0; x < Width - 1; x++)
            {
                for (int y = 0; y < Height - 1; y++)
                {
                    int r = 0, g = 0, b = 0;
                    pixel1 = bitmap.GetPixel(x, y);
                    pixel2 = bitmap.GetPixel(x + 1, y + 1);
                    r = Math.Abs(pixel1.R - pixel2.R + 128);
                    g = Math.Abs(pixel1.G - pixel2.G + 128);
                    b = Math.Abs(pixel1.B - pixel2.B + 128);
                    if (r > 255)
                        r = 255;
                    if (r < 0)
                        r = 0;
                    if (g > 255)
                        g = 255;
                    if (g < 0)
                        g = 0;
                    if (b > 255)
                        b = 255;
                    if (b < 0)
                        b = 0;
                    newbitmap.SetPixel(x, y, Color.FromArgb(r, g, b));
                }
            }
            return newbitmap;
        }

        /// 
        /// 图片柔化
        /// 
        /// 
        /// 
        public static Bitmap Soften(Bitmap bitmap)
        {
            int width = bitmap.Width;
            int height = bitmap.Height;
            Bitmap newbitmap = new Bitmap(width, height);
            Color pixel;
            //高斯模板
            int[] Gauss = { 1, 2, 1, 2, 4, 2, 1, 2, 1 };
            for (int x = 1; x < width - 1; x++)
                for (int y = 1; y < height - 1; y++)
                {
                    int r = 0, g = 0, b = 0;
                    int Index = 0;
                    for (int col = -1; col <= 1; col++)
                        for (int row = -1; row <= 1; row++)
                        {
                            pixel = bitmap.GetPixel(x + row, y + col);
                            r += pixel.R * Gauss[Index];
                            g += pixel.G * Gauss[Index];
                            b += pixel.B * Gauss[Index];
                            Index++;
                        }
                    r /= 16;
                    g /= 16;
                    b /= 16;
                    //处理颜色值溢出
                    r = r > 255 ? 255 : r;
                    r = r < 0 ? 0 : r;
                    g = g > 255 ? 255 : g;
                    g = g < 0 ? 0 : g;
                    b = b > 255 ? 255 : b;
                    b = b < 0 ? 0 : b;
                    newbitmap.SetPixel(x - 1, y - 1, Color.FromArgb(r, g, b));
                }
            return newbitmap;
        }

        /// 
        /// 图片锐化
        /// 
        /// 
        /// 
        public static Bitmap Sharpen(Bitmap bitmap)
        {
            int Width = bitmap.Width;
            int Height = bitmap.Height;
            Bitmap newBitmap = new Bitmap(Width, Height);
            Color pixel;
            //拉普拉斯模板
            int[] Laplacian = { -1, -1, -1, -1, 9, -1, -1, -1, -1 };
            for (int x = 1; x < Width - 1; x++)
            {
                for (int y = 1; y < Height - 1; y++)
                {
                    int r = 0, g = 0, b = 0;
                    int Index = 0;
                    for (int col = -1; col <= 1; col++)
                        for (int row = -1; row <= 1; row++)
                        {
                            pixel = bitmap.GetPixel(x + row, y + col); r += pixel.R * Laplacian[Index];
                            g += pixel.G * Laplacian[Index];
                            b += pixel.B * Laplacian[Index];
                            Index++;
                        }
                    //处理颜色值溢出
                    r = r > 255 ? 255 : r;
                    r = r < 0 ? 0 : r;
                    g = g > 255 ? 255 : g;
                    g = g < 0 ? 0 : g;
                    b = b > 255 ? 255 : b;
                    b = b < 0 ? 0 : b;
                    newBitmap.SetPixel(x - 1, y - 1, Color.FromArgb(r, g, b));
                }
            }
            return newBitmap;
        }

        /// 
        /// 图片雾化
        /// 
        /// 
        /// 
        public static Bitmap Nebulization(Bitmap bitmap)
        {
            int Width = bitmap.Width;
            int Height = bitmap.Height;
            Bitmap newBitmap = new Bitmap(Width, Height);
            Color pixel;
            for (int x = 1; x < Width - 1; x++)
            {
                for (int y = 1; y < Height - 1; y++)
                {
                    System.Random MyRandom = new Random();
                    int k = MyRandom.Next(123456);
                    //像素块大小
                    int dx = x + k % 19;
                    int dy = y + k % 19;
                    if (dx >= Width)
                        dx = Width - 1;
                    if (dy >= Height)
                        dy = Height - 1;
                    pixel = bitmap.GetPixel(dx, dy);
                    newBitmap.SetPixel(x, y, pixel);
                }
            }  
            return newBitmap;
        }

        /// 
        /// 翻转
        /// 
        /// 
        /// 
        public static Bitmap TurnOver(Bitmap bitmap)
        {
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            newbitmap.RotateFlip(RotateFlipType.Rotate90FlipNone);
            return newbitmap;
        }

        /// 
        /// 直方图均衡化
        /// 
        /// 
        /// 
        public static Bitmap HistAverage(Bitmap bitmap)
        {
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            int iw = bitmap.Width, ih = bitmap.Height;
            int[] hist = ImgConvertHelper.GetHist(bitmap, iw, ih);
            Color c = new Color();
            double p = (double)255 / (iw * ih);
            double[] sum = new double[256];
            int[] outg = new int[256];
            int r, g, b;
            sum[0] = hist[0];
            for (int i = 1; i < 256; i++)
                sum[i] = sum[i - 1] + hist[i];

            //灰度变换:i-->outg[i]	
            for (int i = 0; i < 256; i++)
                outg[i] = (int)(p * sum[i]);

            for (int j = 0; j < ih; j++)
            {
                for (int i = 0; i < iw; i++)
                {
                    r = (newbitmap.GetPixel(i, j)).R;
                    g = (newbitmap.GetPixel(i, j)).G;
                    b = (newbitmap.GetPixel(i, j)).B;
                    c = Color.FromArgb(outg[r], outg[g], outg[b]);
                    bitmap.SetPixel(i, j, c);
                }
            }
            return newbitmap;
        }

        / 
        / 对比度扩展
        / 
        / 
        / 
        //public static Bitmap Contrast(Bitmap bitmap)
        //{
        //    Bitmap newbitmap = bitmap.Clone() as Bitmap;
        //    int x1 = Convert.ToInt32(dialog.getX01);
        //    int y1 = Convert.ToInt32(dialog.getY01);
        //    int x2 = Convert.ToInt32(dialog.getX02);
        //    int y2 = Convert.ToInt32(dialog.getY02);


        //    //计算灰度映射表
        //    int[] pixMap = pixelsMap(x1, y1, x2, y2);


        //    //线性拉伸
        //    bm = stretch(bm, pixMap, iw, ih);
        //    return newbitmap;
        //}

        /// 
        /// 3 X 3 阈值滤波
        /// 
        /// 
        /// 
        public static Bitmap ThresholdFilter(Bitmap bitmap)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            int avr,          //灰度平均 
                sum,          //灰度和
                num = 0,      //计数器
                nT = 4,       //计数器阈值
                T = 50;       //阈值
            int pij, pkl,     //(i,j),(i+k,j+l)处灰度值
                err;          //误差


            for (int j = 1; j < ih - 1; j++)
            {
                for (int i = 1; i < iw - 1; i++)
                {
                    //取3×3块的9个象素, 求和
                    sum = 0;
                    for (int k = -1; k < 2; k++)
                    {
                        for (int l = -1; l < 2; l++)
                        {
                            if ((k != 0) || (l != 0))
                            {
                                pkl = (bitmap.GetPixel(i + k, j + l)).R;
                                pij = (bitmap.GetPixel(i, j)).R;
                                err = Math.Abs(pkl - pij);
                                sum = sum + pkl;
                                if (err > T) num++;
                            }
                        }
                    }
                    avr = (int)(sum / 8.0f);         //平均值
                    if (num > nT)
                        newbitmap.SetPixel(i, j, Color.FromArgb(avr, avr, avr));
                }
            }
            return newbitmap;
        }

        /// 
        /// 均值滤波
        /// 
        /// 
        /// 
        public static Bitmap AverageFilter(Bitmap bitmap)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            for (int j = 1; j < ih - 1; j++)
            {
                for (int i = 1; i < iw - 1; i++)
                {
                    int avr;
                    int avr1;
                    int avr2;
                    int sum = 0;
                    int sum1 = 0;
                    int sum2 = 0;
                    for (int k = -1; k <= 1; k++)
                    {
                        for (int l = -1; l <= 1; l++)
                        {
                            sum = sum + (bitmap.GetPixel(i + k, j + 1).R);
                            sum1 = sum1 + (bitmap.GetPixel(i + k, j + 1).G);
                            sum2 = sum2 + (bitmap.GetPixel(i + k, j + 1).B);
                        }
                    }
                    avr = (int)(sum / 9.0f);
                    avr1 = (int)(sum1 / 9.0f);
                    avr2 = (int)(sum2 / 9.0f);
                    newbitmap.SetPixel(i, j, Color.FromArgb(avr, avr1, avr2));
                }
            }
            return newbitmap;
        }

        /// 
        /// 中值滤波
        /// 
        /// 
        /// 
        /// 
        public static Bitmap MedianFilter(Bitmap bitmap,int n)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            for (int j = 2; j < ih - 2; j++)
            {
                int[] dt;
                int[] dt1;
                int[] dt2;
                for (int i = 2; i < iw - 2; i++)
                {
                    int m = 0, r = 0, r1 = 0, r2 = 0, a = 0, b = 0;
                    if (n == 3)
                    {
                        dt = new int[25];
                        dt1 = new int[25];
                        dt2 = new int[25];
                        //取5×5块的25个象素
                        for (int k = -2; k < 3; k++)
                        {
                            for (int l = -2; l < 3; l++)
                            {
                                //取(i+k,j+l)处的象素，赋于数组dt
                                dt[m] = (bitmap.GetPixel(i + k, j + l)).R;
                                dt1[a] = (bitmap.GetPixel(i + k, j + l)).G;
                                dt2[b] = (bitmap.GetPixel(i + k, j + l)).B;
                                m++;
                                a++;
                                b++;
                            }
                        }
                        //冒泡排序,输出中值
                        r = ImgConvertHelper.MedianSorter(dt, 25); //中值      
                        r1 = ImgConvertHelper.MedianSorter(dt1, 25);
                        r2 = ImgConvertHelper.MedianSorter(dt2, 25);
                    }
                    else if (n == 1)
                    {
                        dt = new int[5];

                        //取1×5窗口5个像素
                        dt[0] = (bitmap.GetPixel(i, j - 2)).R;
                        dt[1] = (bitmap.GetPixel(i, j - 1)).R;
                        dt[2] = (bitmap.GetPixel(i, j)).R;
                        dt[3] = (bitmap.GetPixel(i, j + 1)).R;
                        dt[4] = (bitmap.GetPixel(i, j + 2)).R;
                        r = ImgConvertHelper.MedianSorter(dt, 5);   //中值
                        dt1 = new int[5];


                        //取1×5窗口5个像素
                        dt1[0] = (bitmap.GetPixel(i, j - 2)).G;
                        dt1[1] = (bitmap.GetPixel(i, j - 1)).G;
                        dt1[2] = (bitmap.GetPixel(i, j)).G;
                        dt1[3] = (bitmap.GetPixel(i, j + 1)).G;
                        dt1[4] = (bitmap.GetPixel(i, j + 2)).G;
                        r1 = ImgConvertHelper.MedianSorter(dt1, 5);   //中值   
                        dt2 = new int[5];


                        //取1×5窗口5个像素
                        dt2[0] = (bitmap.GetPixel(i, j - 2)).B;
                        dt2[1] = (bitmap.GetPixel(i, j - 1)).B;
                        dt2[2] = (bitmap.GetPixel(i, j)).B;
                        dt2[3] = (bitmap.GetPixel(i, j + 1)).B;
                        dt2[4] = (bitmap.GetPixel(i, j + 2)).B;
                        r2 = ImgConvertHelper.MedianSorter(dt2, 5);   //中值                           
                    }
                    else if (n == 2)
                    {
                        dt = new int[5];


                        //取5×1窗口5个像素
                        dt[0] = (bitmap.GetPixel(i - 2, j)).R;
                        dt[1] = (bitmap.GetPixel(i - 1, j)).R;
                        dt[2] = (bitmap.GetPixel(i, j)).R;
                        dt[3] = (bitmap.GetPixel(i + 1, j)).R;
                        dt[4] = (bitmap.GetPixel(i + 2, j)).R;
                        r = ImgConvertHelper.MedianSorter(dt, 5);  //中值 dt = new int[5];


                        //取5×1窗口5个像素
                        dt1 = new int[5];
                        dt1[0] = (bitmap.GetPixel(i - 2, j)).G;
                        dt1[1] = (bitmap.GetPixel(i - 1, j)).G;
                        dt1[2] = (bitmap.GetPixel(i, j)).G;
                        dt1[3] = (bitmap.GetPixel(i + 1, j)).G;
                        dt1[4] = (bitmap.GetPixel(i + 2, j)).G;
                        r1 = ImgConvertHelper.MedianSorter(dt1, 5);  //中值       

                        //取5×1窗口5个像素
                        dt2 = new int[5];
                        dt2[0] = (bitmap.GetPixel(i - 2, j)).B;
                        dt2[1] = (bitmap.GetPixel(i - 1, j)).B;
                        dt2[2] = (bitmap.GetPixel(i, j)).B;
                        dt2[3] = (bitmap.GetPixel(i + 1, j)).B;
                        dt2[4] = (bitmap.GetPixel(i + 2, j)).B;
                        r2 = ImgConvertHelper.MedianSorter(dt2, 5);  //中值       

                    }
                    newbitmap.SetPixel(i, j, Color.FromArgb(r, r1, r2));         //输出                  
                }
            }
            return newbitmap;
        }

        /// 
        /// 3×3 低通滤波
        /// 
        /// 
        /// 
        public static Bitmap LowpassFilter(Bitmap bitmap, int n)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            int[,] h;

            //定义扩展输入图像矩阵
            int[,] ex_inpix = ImgConvertHelper.Exinpix(bitmap, iw, ih);

            //低通滤波
            for (int j = 1; j < ih + 1; j++)
            {
                for (int i = 1; i < iw + 1; i++)
                {
                    int r = 0, sum = 0;

                    //低通模板		
                    h = ImgConvertHelper.LowMatrix(n);

                    //求3×3窗口9个像素加权和
                    for (int k = -1; k < 2; k++)
                        for (int l = -1; l < 2; l++)
                            sum = sum + h[k + 1, l + 1] * ex_inpix[i + k, j + l];

                    if (n == 1)
                        r = (int)(sum / 9);       //h1平均值
                    else if (n == 2)
                        r = (int)(sum / 10);      //h2
                    else if (n == 3)
                        r = (int)(sum / 16);      //h3 
                    newbitmap.SetPixel(i - 1, j - 1, Color.FromArgb(r, r, r));    //输出                    
                }
            }
            return newbitmap;
        }

        /// 
        /// Kirsch锐化
        /// 
        /// 
        /// 
        public static Bitmap KirschSharpen(Bitmap bitmap)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            Color c = new Color();
            int i, j, r;
            int[,] inr = new int[iw, ih]; //红色分量矩阵
            int[,] ing = new int[iw, ih]; //绿色分量矩阵
            int[,] inb = new int[iw, ih]; //蓝色分量矩阵
            int[,] gray = new int[iw, ih];//灰度图像矩阵	

            //转变为灰度图像矩阵

            for (j = 0; j < ih; j++)
            {
                for (i = 0; i < iw; i++)
                {
                    c = bitmap.GetPixel(i, j);
                    inr[i, j] = c.R;
                    ing[i, j] = c.G;
                    inb[i, j] = c.B;
                    gray[i, j] = (int)((c.R + c.G + c.B) / 3.0);
                }
            }
            int[,] kir0 = {{ 5, 5, 5},
                               {-3, 0,-3},
                               {-3,-3,-3}},//kir0

                       kir1 =  {{-3, 5, 5},
                                {-3, 0, 5},
                                {-3,-3,-3}},//kir1

                       kir2 = {{-3,-3, 5},
                               {-3, 0, 5},
                               {-3,-3, 5}},//kir2

                       kir3 = {{-3,-3,-3},
                               {-3, 0, 5},
                               {-3, 5, 5}},//kir3

                       kir4 = {{-3,-3,-3},
                               {-3, 0,-3},
                               { 5, 5, 5}},//kir4

                       kir5 = {{-3,-3,-3},
                               { 5, 0,-3},
                               { 5, 5,-3}},//kir5

                       kir6 = {{ 5,-3,-3},
                               { 5, 0,-3},
                               { 5,-3,-3}},//kir6

                       kir7 = {{ 5, 5,-3},
                               { 5, 0,-3},
                               {-3,-3,-3}};//kir7	
                                           //边缘检测

            int[,] edge0 = new int[iw, ih];

            int[,] edge1 = new int[iw, ih];

            int[,] edge2 = new int[iw, ih];

            int[,] edge3 = new int[iw, ih];

            int[,] edge4 = new int[iw, ih];

            int[,] edge5 = new int[iw, ih];

            int[,] edge6 = new int[iw, ih];

            int[,] edge7 = new int[iw, ih];

            edge0 = ImgConvertHelper.EdgeEnhance(gray, kir0, iw, ih);
            edge1 = ImgConvertHelper.EdgeEnhance(gray, kir1, iw, ih);
            edge2 = ImgConvertHelper.EdgeEnhance(gray, kir2, iw, ih);
            edge3 = ImgConvertHelper.EdgeEnhance(gray, kir3, iw, ih);
            edge4 = ImgConvertHelper.EdgeEnhance(gray, kir4, iw, ih);
            edge5 = ImgConvertHelper.EdgeEnhance(gray, kir5, iw, ih);
            edge6 = ImgConvertHelper.EdgeEnhance(gray, kir6, iw, ih);
            edge7 = ImgConvertHelper.EdgeEnhance(gray, kir7, iw, ih);

            int[] tem = new int[8];
            int max;
            for (j = 0; j < ih; j++)
            {
                for (i = 0; i < iw; i++)
                {
                    tem[0] = edge0[i, j];
                    tem[1] = edge1[i, j];
                    tem[2] = edge2[i, j];
                    tem[3] = edge3[i, j];
                    tem[4] = edge4[i, j];
                    tem[5] = edge5[i, j];
                    tem[6] = edge6[i, j];
                    tem[7] = edge7[i, j];
                    max = 0;
                    for (int k = 0; k < 8; k++)
                        if (tem[k] > max) max = tem[k];
                    if (max > 255) max = 255;
                    r = 255 - max;
                    newbitmap.SetPixel(i, j, Color.FromArgb(r, r, r));
                }
            }
            return newbitmap;
        }

        /// 
        /// Laplace锐化
        /// 
        /// 
        /// 
        public static Bitmap LaplaceSharpen(Bitmap bitmap)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            Color c = new Color();
            int i, j, r;
            int[,] inr = new int[iw, ih]; //红色分量矩阵
            int[,] ing = new int[iw, ih]; //绿色分量矩阵
            int[,] inb = new int[iw, ih]; //蓝色分量矩阵
            int[,] gray = new int[iw, ih];//灰度图像矩阵	

            //转变为灰度图像矩阵

            for (j = 0; j < ih; j++)
            {
                for (i = 0; i < iw; i++)
                {
                    c = bitmap.GetPixel(i, j);
                    inr[i, j] = c.R;
                    ing[i, j] = c.G;
                    inb[i, j] = c.B;
                    gray[i, j] = (int)((c.R + c.G + c.B) / 3.0);
                }
            }
            int[,] lap1 = {{ 1, 1, 1},
                               { 1,-8, 1},
                               { 1, 1, 1}};

            //边缘增强
            int[,] edge = ImgConvertHelper.EdgeEnhance(gray, lap1, iw, ih);

            for (j = 0; j < ih; j++)
            {
                for (i = 0; i < iw; i++)
                {
                    r = edge[i, j];
                    if (r > 255) r = 255;

                    if (r < 0) r = 0;
                    c = Color.FromArgb(r, r, r);
                    newbitmap.SetPixel(i, j, c);
                }
            }
            return newbitmap;
        }

        /// 
        /// Prewitt锐化
        /// 
        /// 
        /// 
        public static Bitmap PrewittSharpen(Bitmap bitmap)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            Color c = new Color();
            int i, j, r;
            int[,] inr = new int[iw, ih]; //红色分量矩阵
            int[,] ing = new int[iw, ih]; //绿色分量矩阵
            int[,] inb = new int[iw, ih]; //蓝色分量矩阵
            int[,] gray = new int[iw, ih];//灰度图像矩阵	

            //转变为灰度图像矩阵

            for (j = 0; j < ih; j++)
            {
                for (i = 0; i < iw; i++)
                {
                    c = bitmap.GetPixel(i, j);
                    inr[i, j] = c.R;
                    ing[i, j] = c.G;
                    inb[i, j] = c.B;
                    gray[i, j] = (int)((c.R + c.G + c.B) / 3.0);
                }
            }
            //Prewitt算子D_x模板
            int[,] pre1 = {{ 1, 0,-1},
                               { 1, 0,-1},
                               { 1, 0,-1}};

            //Prewitt算子D_y模板
            int[,] pre2 = {{ 1, 1, 1},
                               { 0, 0, 0},
                               {-1,-1,-1}};
            int[,] edge1 = ImgConvertHelper.EdgeEnhance(gray, pre1, iw, ih);

            int[,] edge2 = ImgConvertHelper.EdgeEnhance(gray, pre2, iw, ih);
            for (j = 0; j < ih; j++)
            {
                for (i = 0; i < iw; i++)
                {
                    r = Math.Max(edge1[i, j], edge2[i, j]);

                    if (r > 255) r = 255;
                    c = Color.FromArgb(r, r, r);
                    newbitmap.SetPixel(i, j, c);
                }
            }
            return newbitmap;
        }

        /// 
        /// Roberts锐化
        /// 
        /// 
        /// 
        public static Bitmap RobertsSharpen(Bitmap bitmap)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            int r, r0, r1, r2, r3, g, g0, g1, g2, g3, b, b0, b1, b2, b3;
            int[,] inr = new int[iw, ih];//红色分量矩阵
            int[,] ing = new int[iw, ih];//绿色分量矩阵
            int[,] inb = new int[iw, ih];//蓝色分量矩阵
            int[,] gray = new int[iw, ih];//灰度图像矩阵	             

            for (int j = 1; j < ih - 1; j++)
            {
                for (int i = 1; i < iw - 1; i++)
                {
                    r0 = (bitmap.GetPixel(i, j)).R;
                    r1 = (bitmap.GetPixel(i, j + 1)).R;
                    r2 = (bitmap.GetPixel(i + 1, j)).R;
                    r3 = (bitmap.GetPixel(i + 1, j + 1)).R;

                    r = (int)Math.Sqrt((r0 - r3) * (r0 - r3) + (r1 - r2) * (r1 - r2));

                    g0 = (bitmap.GetPixel(i, j)).G;
                    g1 = (bitmap.GetPixel(i, j + 1)).G;
                    g2 = (bitmap.GetPixel(i + 1, j)).G;
                    g3 = (bitmap.GetPixel(i + 1, j + 1)).G;
                    g = (int)Math.Sqrt((g0 - g3) * (g0 - g3) + (g1 - g2) * (g1 - g2));

                    b0 = (bitmap.GetPixel(i, j)).B;
                    b1 = (bitmap.GetPixel(i, j + 1)).B;
                    b2 = (bitmap.GetPixel(i + 1, j)).B;
                    b3 = (bitmap.GetPixel(i + 1, j + 1)).B;
                    b = (int)Math.Sqrt((b0 - b3) * (b0 - b3)
                      + (b1 - b2) * (b1 - b2));

                    if (r < 0)
                        r = 0;                                       //黑色，边缘点
                    if (r > 255)
                        r = 255;

                    newbitmap.SetPixel(i, j, Color.FromArgb(r, r, r));
                }
            }
            return newbitmap;
        }

        /// 
        /// Sobel锐化
        /// 
        /// 
        /// 
        public static Bitmap SobelSharpen(Bitmap bitmap)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = bitmap.Clone() as Bitmap;
            Color c = new Color();
            int i, j, r;
            int[,] inr = new int[iw, ih]; //红色分量矩阵
            int[,] ing = new int[iw, ih]; //绿色分量矩阵
            int[,] inb = new int[iw, ih]; //蓝色分量矩阵
            int[,] gray = new int[iw, ih];//灰度图像矩阵	

            //转变为灰度图像矩阵

            for (j = 0; j < ih; j++)
            {
                for (i = 0; i < iw; i++)
                {
                    c = bitmap.GetPixel(i, j);
                    inr[i, j] = c.R;
                    ing[i, j] = c.G;
                    inb[i, j] = c.B;
                    gray[i, j] = (int)((c.R + c.G + c.B) / 3.0);
                }
            }
            int[,] sob1 = {{ 1, 0,-1},
                               { 2, 0,-2},
                               { 1, 0,-1}};
            int[,] sob2 = {{ 1, 2, 1},
                               { 0, 0, 0},
                               {-1,-2,-1}};


            int[,] edge1 = ImgConvertHelper.EdgeEnhance(gray, sob1, iw, ih);
            int[,] edge2 = ImgConvertHelper.EdgeEnhance(gray, sob2, iw, ih);
            for (j = 0; j < ih; j++)
            {
                for (i = 0; i < iw; i++)
                {
                    r = Math.Max(edge1[i, j], edge2[i, j]);
                    if (r > 255) r = 255;
                    c = Color.FromArgb(r, r, r);
                    newbitmap.SetPixel(i, j, c);
                }
            }
            return newbitmap;
        }

        /// 
        /// 透明化
        /// 
        /// 
        /// 
        public static Bitmap Transparent(Bitmap bitmap)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = new Bitmap(iw, ih);
            int alpha = 0;
            Color demo;
            Color pixel;
            for (int x = 0; x < iw; x++)
            {
                for (int y = 0; y < ih; y++)
                {
                    demo = bitmap.GetPixel(1, 1);
                    pixel = bitmap.GetPixel(x, y);
                    int R = demo.R;
                    int G = demo.G;
                    int B = demo.B;
                    int r1 = pixel.R;
                    int g1 = pixel.G;
                    int b1 = pixel.B;
                    int a = 40;  //RGB误差范围
                    if (Math.Abs(R - r1) < a && Math.Abs(G - g1) < a && Math.Abs(B - b1) < a)
                    {
                        alpha = 0;  //RGB在色差范围内，透明度为0
                    }
                    else
                    {
                        alpha = 255;
                    }
                    newbitmap.SetPixel(x, y, Color.FromArgb(alpha, r1, g1, b1));
                }
            }
            return newbitmap;
        }

        /// 
        /// 指定颜色透明化
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static Bitmap Transparent(Bitmap bitmap, int R, int G, int B)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = new Bitmap(iw, ih);
            int alpha = 0;
            Color pixel;
            for (int x = 0; x < iw; x++)
            {
                for (int y = 0; y < ih; y++)
                {
                    pixel = bitmap.GetPixel(x, y);
                    int r1 = pixel.R;
                    int g1 = pixel.G;
                    int b1 = pixel.B;
                    int a = 40;  //色差范围值
                    if (Math.Abs(R - r1) < a && Math.Abs(G - g1) < a && Math.Abs(B - b1) < a)
                    {
                        alpha = 0;    //若两种颜色比较接近，透明度设为0
                    }
                    else
                    {
                        alpha = 255;
                    }
                    newbitmap.SetPixel(x, y, Color.FromArgb(alpha, r1, g1, b1));
                }
            }
            return newbitmap;
        }

        /// 
        /// 指定颜色替换
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static Bitmap ColorReplace(Bitmap bitmap, int R, int G, int B, int newR, int newG, int newB)
        {
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = new Bitmap(iw, ih);
            Color pixel;
            for (int x = 0; x < iw; x++)
            {
                for (int y = 0; y < ih; y++)
                {
                    pixel = bitmap.GetPixel(x, y);
                    int r1 = pixel.R;
                    int g1 = pixel.G;
                    int b1 = pixel.B;
                    int a = 40;
                    if (Math.Abs(R - r1) < a && Math.Abs(G - g1) < a && Math.Abs(B - b1) < a)
                    {
                        newbitmap.SetPixel(x, y, Color.FromArgb(newR, newG, newB));
                    }
                    else
                    {
                        newbitmap.SetPixel(x, y, Color.FromArgb(r1, g1, b1));
                    }
                }
            }
            return newbitmap;
        }

        /// 
        /// 指定颜色保留（其余透明化）
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static Bitmap ColorRetain(Bitmap bitmap, int R, int G, int B)
        {
            // 色差值
            int difference = 40;
            int iw = bitmap.Width, ih = bitmap.Height;
            Bitmap newbitmap = new Bitmap(iw, ih);
            int alpha = 0;
            Color pixel;
            for (int x = 0; x < iw; x++)
            {
                for (int y = 0; y < ih; y++)
                {
                    pixel = bitmap.GetPixel(x, y);
                    int r1 = pixel.R;
                    int g1 = pixel.G;
                    int b1 = pixel.B;
                    if (Math.Abs(R - r1) < difference && Math.Abs(G - g1) < difference && Math.Abs(B - b1) < difference)
                    {
                        alpha = 0;
                        r1 = 0;
                        b1 = 0;
                        g1 = 0;
                    }
                    else
                    {
                        alpha = 255;
                        r1 = 255;
                        b1 = 255;
                        g1 = 255;
                    }
                    newbitmap.SetPixel(x, y, Color.FromArgb(alpha, r1, g1, b1));
                }
            }
            return newbitmap;
        }
    }

我的代码
https://download.csdn.net/download/qq_21703215/88055234

C#中使用split分割字符串互联网打工人no1 c#
1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
你可能遗漏的一些C#/.NET/.NET Core知识点追逐时光者 C#.NET DotNetGuide编程指南 c#.net .netcore microsoft
前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
遥感影像的切片处理 sand&wich 计算机视觉 python 图像处理
在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
Python实现下载当前年份的谷歌影像 sand&wich python 开发语言
在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
Python实现TIFF 文件转换为 PNG 和 JPG 格式 sand&wich python 开发语言
在日常的图像处理工作中，可能会遇到需要将TIFF格式的图像转换为其他格式的情况，例如PNG和JPG。下面，本文将介绍如何使用Python和GDAL库实现这一功能。准备工作在开始之前，请确保已经安装了必要的库：GDAL（GeospatialDataAbstractionLibrary）可以使用以下命令安装GDAL：pipinstallgdal代码实现以下是一个将TIFF文件转换为PNG文件的示例代码
C#动态加载DLL程序集及使用反射创建实例-简记不全 C#相关 Asp.net WebForm Asp.net MVC c#Assembly 反射程序集
Assembly动态加载程序集：分两种情况：1、需要加载的程序集已经在程序中被引用了，则直接从当前程序域中查找即可：Assemblyassembly=AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x=>x.GetName().Name.Contains("theAssemblyName"));2、需要加载的程序集未被加载，则使用程序集
开发游戏的学习规划杰克逊的日记游戏学习
第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
python可以制作大型游戏_python能做游戏吗-python能开发游戏吗靖dede python可以制作大型游戏
python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
OpenCV图像处理技术（Python）——入门森屿_ opencv
©FuXianjun.AllRightsReserved.OpenCV入门图像作为人类感知世界的视觉基础，是人类获取信息、表达信息的重要手段，OpenCV作为一个开源的计算机视觉库，它包括几百个易用的图像成像和视觉函数，既可以用于学术研究，也可用于工业邻域，它于1999年由因特尔的GaryBradski启动，OpenCV库主要由C和C++语言编写，它可以在多个操作系统上运行。1.1图像处理基本操作
opencv学习：图像旋转的两种方法，旋转后的图片进行模板匹配代码实现夜清寒风学习 opencv 机器学习人工智能计算机视觉
图像旋转在图像处理中，rotate和rot90是两种常见的图像旋转方法，它们在功能和使用上有一些区别。下面我将分别介绍这两种方法，并解释它们的主要区别rot90方法rot90方法是NumPy提供的一种数组旋转函数，它主要用于对二维数组（如图像）进行90度的旋转。这个方法比较简单，只支持90度的倍数旋转，不支持任意角度旋转。使用NumPy进行旋转使用NumPy的rot90函数对模板图像进行旋转操作。
Python OpenCV图像处理：从基础到高级的全方位指南极客代码玩转Python 开发语言 python opencv 图像处理计算机视觉
目录第一部分：PythonOpenCV图像处理基础1.1OpenCV简介1.2PythonOpenCV安装1.3实战案例：图像显示与保存1.4注意事项第二部分：PythonOpenCV图像处理高级技巧2.1图像变换2.2图像增强2.3图像复原第三部分：PythonOpenCV图像处理实战项目3.1图像滤波3.2图像分割3.3图像特征提取第四部分：PythonOpenCV图像处理注意事项与优化策略4
【C#生态园】深度剖析：C#嵌入式开发工具大揭秘 friklogff C#生态园 c#开发语言
C#嵌入式开发：全面了解六大框架与库前言随着物联网和嵌入式系统的快速发展，越来越多的开发者开始关注使用C#语言进行嵌入式开发。本文将介绍几种用于C#的嵌入式开发框架和相关库，以及它们的核心功能、安装配置方法和API概览，帮助读者了解并选择适合自己项目的工具和资源。欢迎订阅专栏：C#生态园文章目录C#嵌入式开发：全面了解六大框架与库前言1.nanoFramework：一个用于C#的嵌入式开发框架1.
Lua 与 C#交互 z2014z lua c#开发语言
Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
C# 开发教程-入门基础天马3798 教程系列整理 c#开发语言
1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
C# 禁止程序重复启动 wiseyao1219 c#
修改：Program.cs[STAThread]staticvoidMain(){Mutexmutex=newMutex(true,"NewGuid123456",outboolisCreatedNew);if(!isCreatedNew){MessageBox.Show(Application.ProductName+"isrunning...");return;}Application.Ena
C#中判断socket是否已断开的方法 wiseyao1219 c#
代码如下：Sockets=newSocket(..);if(s.Poll(-1,SelectMode.SelectRead)){intnRead=s.Receive();if(nRead==0){//socket连接已断开}}参考：C#中判断socket是否已断开的方法
服务器状态监控php源码,服务器状态监控_监控Linux服务器网站状态的SHELL脚本温糯米服务器状态监控php源码
摘要腾兴网为您分享:监控Linux服务器网站状态的SHELL脚本，蜗牛集市，同花顺，探客宝，手柄助手等软件知识，以及日期倒计时插件，云南省教育资源公共，rui手机桌面，小屁孩桌面便签，合金装备崛起复仇，朝夕日历，photoshop图像处理软件,一年级学生每日计划表，悟空找房，饿了吗外卖商家版，逃生，中国民宿网，realpolitiks，交通安全知识竞赛，雅思流利说等软件it资讯，欢迎关注腾兴网。1
C#文件被占用的解决方案花北城 C#项目文件占用
问题打更新包时，提示文件被占用。System.IO.IOException:文件“D:\RS\RS_CCVI20111210.exe”正由另一进程使用，因此该进程无法访问该文件。在System.IO.__Error.WinIOError(Int32errorCode,StringmaybeFullPath)在System.IO.FileStream.Init(Stringpath,FileMode
C#实现软件自动升级 BruceEditCode
winform程序相对web程序而言，功能更强大，编程更方便，但软件更新却相当麻烦，要到客户端一台一台地升级，本文结合实际情况，通过软件实现自动升级，弥补了这一缺陷，有较好的参考价值。由于程序在运行时不能用新的版本覆盖自己，因此，我们将登录窗口单独做成一个可执行文件，用户登录时，从网上检测是否有新的主程序，如果有，则从后台下载并覆盖老的版本，用户输入正确的用户名和密码后，通过参数将必要的信息（如用
C# 自动化 TineAine C#代码片段自动化 c#自动化模拟操作
实现的方法可能很笨，但是确实很好用usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Runtime.InteropServices;usingSystem.Text;usingSystem.Threading;usingSystem.Threading.Tasks;/******************
技术周总结 09.09~09.15周日(C# WinForm WPF) 打破砂锅问到底007 wpf c#WinForm
文章目录一、09.09周一1.1)问题01:Windows桌面开发中，WPF和WinForm的区别和联系？联系：区别：二、09.12周四2.1）问题01：visualstudio的相关快捷键有哪些？通用快捷键编辑导航调试窗口管理2.2）问题02：publicpartialclassChoosePLReason:CommonBaseForm2.3)问题03：介绍WindowsForms中的Syste
通过C# 裁剪PDF页面 Eiceblue C#.NET PDF c#pdf 开发语言 visual studio
在处理PDF文档时，有时需要精确地裁剪页面以适应特定需求，比如去除广告、背景信息或者仅仅是为了简化文档内容。本文将指导如何使用免费.NET控件通过C#实现裁剪PDF页面。免费库FreeSpire.PDFfor.NET支持在.NET(C#,VB.NET,ASP.NET,.NETCore)程序中实现创建、操作、转换和打印PDF文档等操作。可以从以下链接下载产品包后手动添加引用，或者直接通过NuGet安
【Unity基础】如何选择脚本编译方式Mono和IL2CPP？ tealcwu Unity基础 unity 游戏引擎
Edit->ProjectSettings->Player在Unity中，ScriptingBackend决定了项目的脚本编译方式，即如何将C#代码转换为可执行代码。Unity提供了两种主要的ScriptingBackend选项：Mono和IL2CPP。它们之间的区别影响了项目的性能、平台支持、编译时间和调试体验。以下是两者的详细对比：1.Mono简介:Mono是Unity最早使用的脚本后端，基于
C# Tuple、ValueTuple 語衣 C#知识补充 c#
栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
多模态Transformer之文本与图像联合建模 - Transformer教程 shandianfk_com ChatGPT Transformer transformer 深度学习人工智能
大家好，今天我们来聊聊一个既前沿又有趣的话题——多模态Transformer，特别是文本与图像的联合建模。对于很多小伙伴来说，Transformer这个词已经不陌生了，但它不仅仅应用于自然语言处理，还能在图像处理、甚至是多模态数据的处理上大显身手。接下来，我会带大家深入了解什么是多模态Transformer，以及它是如何实现文本与图像的联合建模的。Transformer简介首先，我们简单回顾一下T
C# Linq语句用法大全以及Lambda表达式一个小码码 c#linq 开发语言 .net
C#Linq语句用法大全以及Lambda表达式Linq：是一种用于数据查询和操作的语言集成查询（LanguageIntegratedQuery）技术。通过Linq，我们可以使用类似于SQL查询的方式来查询、筛选和操作各种类型的数据集合，包括数组、列表、集合、XML文档、数据库表等等。常见的有：LinqtoObjects：用于操作对象集合，例如数组、列表等。LinqtoXML：用于操作XML数据，支
C#中的LInq语句 weixin_30588907 c#数据库
语言集成查询(LINQ)是一组技术的名称，这些技术建立在将查询功能直接集成到C#语言（以及VisualBasic和可能的任何其他.NET语言）的基础上。借助于LINQ，查询现在已是高级语言构造，就如同类、方法、事件等等。对于编写查询的开发人员来说，LINQ最明显的“语言集成”部分是查询表达式。查询表达式是使用C#3.0中引入的声明性查询语法编写的。通过使用查询语法，您甚至可以使用最少的代码对数据源
C#的linq语句木生火18624 C#开发
/查询表达式必须以form子句开头，以select或者group子句结束，在这两个子句之间，可以使用///where、orderby、join、let和其他的from子句本章要点用列表在对象上执行传统查询扩展方法LINQ查询操作符平行LNQ表达式树本章源代码下载地址(wrox.com)打开网页www.wrox.com/go/procsharp,单击DownloadCode选项卡即可下载本章源代码。
C# 多线程操作同一个文件，如何避免冲突 FlYFlOWERANDLEAF c#开发语言
1使用lock经测试，依然存在线程冲突privatestaticobjectlocker=newobject();……lock(locker){stringbText=File.ReadAllText(FPath);returnbText;}……lock(locker){File.WriteAllText(FPath,aContent);}2使用ReaderWriterLockSlim经测试，依然
C#LINQ常用扩展语句月落. C#c#linq solr
在C#中，LINQ提供了许多扩展方法，这些方法定义在System.Linq命名空间中。以下是一些常用的LINQ扩展方法：Where-过滤数据集合，返回满足条件的元素。varfilteredItems=collection.Where(item=>item.SomeProperty>10);Select-从数据集合中选择数据或创建新的投影。varprojectedItems=collection.S
深入浅出Java Annotation(元注解和自定义注解） Josh_Persistence Java Annotation 元注解自定义注解
一、基本概述　　 Annontation是Java5开始引入的新特征。中文名称一般叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。　　更通俗的意思是为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且是供指定的工具或
mysql优化特定类型的查询 annan211 java 工作 mysql
本节所介绍的查询优化的技巧都是和特定版本相关的，所以对于未来mysql的版本未必适用。 1 优化count查询对于count这个函数的网上的大部分资料都是错误的或者是理解的都是一知半解的。在做优化之前我们先来看看真正的count()函数的作用到底是什么。 count()是一个特殊的函数，有两种非常不同的作用，他可以统计某个列值的数量，也可以统计行数。在统
MAC下安装多版本JDK和切换几种方式棋子chessman jdk
环境： MAC AIR,OS X 10.10,64位历史：过去 Mac 上的 Java 都是由 Apple 自己提供，只支持到 Java 6，并且OS X 10.7 开始系统并不自带（而是可选安装）（原自带的是1.6）。后来 Apple 加入 OpenJDK 继续支持 Java 6，而 Java 7 将由 Oracle 负责提供。在终端中输入jav
javaScript （1） Array_06 JavaScript java 浏览器
JavaScript 1、运算符　　运算符就是完成操作的一系列符号，它有七类：　　赋值运算符（=,+=,-=,*=,/=,%=,<<=,>>=,|=,&=）、算术运算符(+,-,*,/,++,--,%)、比较运算符(>,<,<=,>=,==,===,!=,!==)、逻辑运算符(||,&&,!)、条件运算(?:)、位
国内顶级代码分享网站袁潇含 java jdk oracle .net PHP
现在国内很多开源网站感觉都是为了利益而做的当然利益是肯定的,否则谁也不会免费的去做网站 &
Elasticsearch、MongoDB和Hadoop比较随意而生 mongodb hadoop 搜索引擎
IT界在过去几年中出现了一个有趣的现象。很多新的技术出现并立即拥抱了“大数据”。稍微老一点的技术也会将大数据添进自己的特性，避免落大部队太远，我们看到了不同技术之间的边际的模糊化。假如你有诸如Elasticsearch或者Solr这样的搜索引擎，它们存储着JSON文档，MongoDB存着JSON文档，或者一堆JSON文档存放在一个Hadoop集群的HDFS中。你可以使用这三种配
mac os 系统科研软件总结张亚雄 mac os
1.1 Microsoft Office for Mac 2011 大客户版，自行搜索。 1.2 Latex （MacTex）: 系统环境：https://tug.org/mactex/ &nb
Maven实战（四）生命周期 AdyZhang maven
1. 三套生命周期 Maven拥有三套相互独立的生命周期，它们分别为clean，default和site。每个生命周期包含一些阶段，这些阶段是有顺序的，并且后面的阶段依赖于前面的阶段，用户和Maven最直接的交互方式就是调用这些生命周期阶段。以clean生命周期为例，它包含的阶段有pre-clean, clean 和 post
Linux下Jenkins迁移 aijuans Jenkins
1. 将Jenkins程序目录copy过去源程序在/export/data/tomcatRoot/ofctest-jenkins.jd.com下面 tar -cvzf jenkins.tar.gz ofctest-jenkins.jd.com &
request.getInputStream()只能获取一次的问题 ayaoxinchao request Inputstream
问题：在使用HTTP协议实现应用间接口通信时，服务端读取客户端请求过来的数据，会用到request.getInputStream()，第一次读取的时候可以读取到数据，但是接下来的读取操作都读取不到数据原因： 1. 一个InputStream对象在被读取完成后，将无法被再次读取，始终返回-1； 2. InputStream并没有实现reset方法（可以重
数据库SQL优化大总结之百万级数据库优化方案 BigBird2012 SQL优化
网上关于SQL优化的教程很多，但是比较杂乱。近日有空整理了一下，写出来跟大家分享一下，其中有错误和不足的地方，还请大家纠正补充。这篇文章我花费了大量的时间查找资料、修改、排版，希望大家阅读之后，感觉好的话推荐给更多的人，让更多的人看到、纠正以及补充。 1.对查询进行优化，要尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。 2.应尽量避免在 where
jsonObject的使用 bijian1013 java json
在项目中难免会用java处理json格式的数据，因此封装了一个JSONUtil工具类。 JSONUtil.java package com.bijian.json.study; import java.util.ArrayList; import java.util.Date; import java.util.HashMap;
[Zookeeper学习笔记之六]Zookeeper源代码分析之Zookeeper.WatchRegistration bit1129 zookeeper
Zookeeper类是Zookeeper提供给用户访问Zookeeper service的主要API，它包含了如下几个内部类首先分析它的内部类，从WatchRegistration开始，为指定的znode path注册一个Watcher， /** * Register a watcher for a particular p
【Scala十三】Scala核心七：部分应用函数 bit1129 scala
何为部分应用函数？ Partially applied function: A function that’s used in an expression and that misses some of its arguments.For instance, if function f has type Int => Int => Int, then f and f(1) are p
Tomcat Error listenerStart 终极大法 ronin47 tomcat
Tomcat报的错太含糊了，什么错都没报出来，只提示了Error listenerStart。为了调试，我们要获得更详细的日志。可以在WEB-INF/classes目录下新建一个文件叫logging.properties，内容如下 Java代码 handlers = org.apache.juli.FileHandler, java.util.logging.ConsoleHa
不用加减符号实现加减法 BrokenDreams 实现
今天有群友发了一个问题，要求不用加减符号(包括负号)来实现加减法。分析一下，先看最简单的情况，假设1+1，按二进制算的话结果是10，可以看到从右往左的第一位变为0，第二位由于进位变为1。
读《研磨设计模式》-代码笔记-状态模式-State bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* 当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情况把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简化如果在
CUDA程序block和thread超出硬件允许值时的异常 cherishLC CUDA
调用CUDA的核函数时指定block 和 thread大小，该大小可以是dim3类型的（三维数组），只用一维时可以是usigned int型的。以下程序验证了当block或thread大小超出硬件允许值时会产生异常！！！GPU根本不会执行运算！！！所以验证结果的正确性很重要！！！在VS中创建CUDA项目会有一个模板，里面有更详细的状态验证。以下程序在K5000GPU上跑的。
诡异的超长时间GC问题定位 chenchao051 jvm cms GC hbase swap
HBase的GC策略采用PawNew+CMS, 这是大众化的配置，ParNew经常会出现停顿时间特别长的情况，有时候甚至长到令人发指的地步，例如请看如下日志： 2012-10-17T05:54:54.293+0800: 739594.224: [GC 739606.508: [ParNew: 996800K->110720K(996800K), 178.8826900 secs] 3700
maven环境快速搭建 daizj 安装 mavne 环境配置
一下载maven 安装maven之前，要先安装jdk及配置JAVA_HOME环境变量。这个安装和配置java环境不用多说。 maven下载地址：http://maven.apache.org/download.html，目前最新的是这个apache-maven-3.2.5-bin.zip，然后解压在任意位置，最好地址中不要带中文字符，这个做java 的都知道，地址中出现中文会出现很多
PHP网站安全，避免PHP网站受到攻击的方法 dcj3sjt126com PHP
对于PHP网站安全主要存在这样几种攻击方式:1、命令注入(Command Injection)2、eval注入(Eval Injection)3、客户端脚本攻击(Script Insertion)4、跨网站脚本攻击(Cross Site Scripting, XSS)5、SQL注入攻击(SQL injection)6、跨网站请求伪造攻击(Cross Site Request Forgerie
yii中给CGridView设置默认的排序根据时间倒序的方法 dcj3sjt126com GridView
public function searchWithRelated() { $criteria = new CDbCriteria; $criteria->together = true; //without th
Java集合对象和数组对象的转换 dyy_gusi java集合
在开发中，我们经常需要将集合对象（List，Set）转换为数组对象，或者将数组对象转换为集合对象。Java提供了相互转换的工具，但是我们使用的时候需要注意，不能乱用滥用。 1、数组对象转换为集合对象最暴力的方式是new一个集合对象，然后遍历数组，依次将数组中的元素放入到新的集合中，但是这样做显然过
nginx同一主机部署多个应用 geeksun nginx
近日有一需求，需要在一台主机上用nginx部署2个php应用，分别是wordpress和wiki，探索了半天，终于部署好了，下面把过程记录下来。 1. 在nginx下创建vhosts目录，用以放置vhost文件。 mkdir vhosts 2. 修改nginx.conf的配置，在http节点增加下面内容设置，用来包含vhosts里的配置文件 #
ubuntu添加admin权限的用户账号 hongtoushizi ubuntu useradd
ubuntu创建账号的方式通常用到两种：useradd 和adduser . 本人尝试了useradd方法，步骤如下： 1:useradd 使用useradd时，如果后面不加任何参数的话，如：sudo useradd sysadm 创建出来的用户将是默认的三无用户：无home directory ,无密码,无系统shell。顾应该如下操作：
第五章常用Lua开发库2-JSON库、编码转换、字符串处理 jinnianshilongnian nginx lua
JSON库在进行数据传输时JSON格式目前应用广泛，因此从Lua对象与JSON字符串之间相互转换是一个非常常见的功能；目前Lua也有几个JSON库，本人用过cjson、dkjson。其中cjson的语法严格（比如unicode \u0020\u7eaf），要求符合规范否则会解析失败（如\u002），而dkjson相对宽松，当然也可以通过修改cjson的源码来完成
Spring定时器配置的两种实现方式OpenSymphony Quartz和java Timer详解 yaerfeng1989 timer quartz 定时器
原创整理不易，转载请注明出处：Spring定时器配置的两种实现方式OpenSymphony Quartz和java Timer详解代码下载地址：http://www.zuidaima.com/share/1772648445103104.htm 有两种流行Spring定时器配置：Java的Timer类和OpenSymphony的Quartz。 1.Java Timer定时首先继承jav
Linux下df与du两个命令的差别？ pda158 linux
　一、df显示文件系统的使用情况，与du比較，就是更全盘化。　　最经常使用的就是 df -T，显示文件系统的使用情况并显示文件系统的类型。　　举比例如以下：　　[root@localhost ~]# df -T 　　Filesystem Type &n
[转]SQLite的工具类 ---- 通过反射把Cursor封装到VO对象 ctfzh VO android sqlite 反射 Cursor
在写DAO层时，觉得从Cursor里一个一个的取出字段值再装到VO(值对象)里太麻烦了，就写了一个工具类，用到了反射，可以把查询记录的值装到对应的VO里，也可以生成该VO的List。使用时需要注意：考虑到Android的性能问题，VO没有使用Setter和Getter，而是直接用public的属性。表中的字段名需要和VO的属性名一样，要是不一样就得在查询的SQL中
该学习笔记用到的Employee表 vipbooks oracle sql 工作
这是我在学习Oracle是用到的Employee表，在该笔记中用到的就是这张表，大家可以用它来学习和练习。 drop table Employee; -- 员工信息表 create table Employee( -- 员工编号 EmpNo number(3) primary key, -- 姓

C#图片处理

查找图片所在位置

图片转化

你可能感兴趣的:(c#,图像处理)