首页 / 算法 / PhotoShop算法原理解析系列-风格化-查找边缘。

PhotoShop算法原理解析系列-风格化-查找边缘。

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了PhotoShop算法原理解析系列-风格化-查找边缘。，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含16519字，纯文字阅读大概需要24分钟。

内容图文

之所以不写系列文章一、系列文章二这样的标题，是因为我不知道我能坚持多久。我知道我对事情的表达能力和语言的丰富性方面的天赋不高。而一段代码需要我去用心的把他从基本原理--》初步实现--》优化速度等过程用文字的方式表述清楚，恐怕不是一件很容易的事情。

我所掌握的一些Photoshop中的算法,不能说百分之一百就是正确的，但是从执行的效果中，大的方向肯定是没有问题的。

目前，从别人的文章、开源的代码以及自己的思考中我掌握的PS的算法可能有近100个吧。如果时间容许、自身的耐心容许，我会将这些东西慢慢的整理开来，虽然在很多人看来，这些算法并不具有什么研究的价值了，毕竟人家都已经商业化了。说的也有道理，我姑且把他作为自我欣赏和自我满足的一种方式吧。

今天，我们讲讲查找边缘算法。可能我说了原理，很多人就不会看下去了，可有几人层仔细的研究过呢。

　　先贴个效果图吧：

PhotoShop算法原理解析系列-风格化-查找边缘。 - 文章图片

　　原理：常见的Sobel边缘算子的结果进行反色即可。

为了能吸引你继续看下去，我先给出我的代码的执行速度：针对3000*4000*3的数码图片，处理时间300ms。

何为Sobel，从百度抄几张图过来了并修改地址后：

PhotoShop算法原理解析系列-风格化-查找边缘。 - 文章图片

　　对上面两个式子不做过多解释，你只需要知道其中A为输入图像，把G作为A的输出图像就可以了，最后还要做一步： G=255-G，就是查找边缘算法。

查找边缘类算法都有个问题，对图像物理边缘处的像素如何处理，在平日的处理代码中，很多人就是忽略四个边缘的像素，作为专业的图像处理软件，这可是违反最基本的原则的。对边缘进行的单独的代码处理，又会给编码带来冗余和繁琐的问题。解决问题的最简单又高效的方式就是采用哨兵边界。

写多了特效类算法的都应该知道，除了那种对单个像素进行处理的算法不需要对原始图像做个备份（不一定去全局备份），那些需要领域信息的算法由于算法的前一步修改了一个像素，而算法的当前步需要未修改的像素值，因此，一般这种算法都会在开始前对原始图像做个克隆，在计算时，需要的领域信息从克隆的数据中读取。如果这个克隆的过程不是完完全全的克隆，而是扩展适当边界后再克隆，就有可能解决上述的边界处理问题。

　　比如对下面的一个图，19×14像素大小，我们的备份图为上下左右各扩展一个像素的大小，并用边缘的值填充，变为21*16大小：

PhotoShop算法原理解析系列-风格化-查找边缘。 - 文章图片

　　这样，在计算原图的3*3领域像素时，从扩展后的克隆图对应点取样，就不会出现不在图像范围内的问题了，编码中即可以少很多判断，可读性也加强了。

在计算速度方面，注意到上面的计算式G中有个开方运算，这是个耗时的过程，由于图像数据的特殊性，都必须是整数，可以采用查找表的方式优化速度，这就需要考虑表的建立。

针对本文的具体问题，我们分两步讨论，第一：针对根号下的所有可能情况建立查找表。看看GX和GY的计算公式，考虑下两者的平方和的最大值是多少，可能要考虑一会吧。第二：就是只建立0^2到255^2范围内的查找表，然后确保根号下的数字不大于255^2。为什么可以这样做，就是因为图像数据的最大值就是255，如果根号下的数字大于255^2，在求出开方值后，还是需要规整为255的。因此，本算法中应该取后者。

private void CmdFindEdgesArray_Click(object sender, EventArgs e)
{    int X, Y;    int Width, Height, Stride, StrideC, HeightC;    int Speed, SpeedOne, SpeedTwo, SpeedThree;    int BlueOne, BlueTwo, GreenOne, GreenTwo, RedOne, RedTwo;    int PowerRed, PowerGreen, PowerBlue;
    Bitmap Bmp = (Bitmap)Pic.Image;    if (Bmp.PixelFormat != PixelFormat.Format24bppRgb) throw new Exception("不支持的图像格式.");    byte[] SqrValue = new byte[65026];    for (Y = 0; Y < 65026; Y++) SqrValue[Y] = (byte)(255 - (int)Math.Sqrt(Y));      // 计算查找表，注意已经砸查找表里进行了反色
    Width = Bmp.Width; Height = Bmp.Height; Stride = (int)((Bmp.Width * 3 + 3) & 0XFFFFFFFC);
    StrideC = (Width + 2) * 3; HeightC = Height + 2;                                 // 宽度和高度都扩展2个像素

    byte[] ImageData = new byte[Stride * Height];                                    // 用于保存图像数据，（处理前后的都为他)
    byte[] ImageDataC = new byte[StrideC * HeightC];                                // 用于保存扩展后的图像数据

    fixed (byte* Scan0 = &ImageData[0])
    {
        BitmapData BmpData = new BitmapData();
        BmpData.Scan0 = (IntPtr)Scan0;                                              //  设置为字节数组的的第一个元素在内存中的地址
        BmpData.Stride = Stride;
        Bmp.LockBits(new Rectangle(0, 0, Bmp.Width, Bmp.Height), ImageLockMode.ReadWrite | ImageLockMode.UserInputBuffer, PixelFormat.Format24bppRgb, BmpData);

        Stopwatch Sw = new Stopwatch();                                             //  只获取计算用时        Sw.Start();        for (Y = 0; Y < Height; Y++)
        {
            System.Buffer.BlockCopy(ImageData, Stride * Y, ImageDataC, StrideC * (Y + 1), 3);        // 填充扩展图的左侧第一列像素(不包括第一个和最后一个点)
            System.Buffer.BlockCopy(ImageData, Stride * Y + (Width - 1) * 3, ImageDataC, StrideC * (Y + 1) + (Width + 1) * 3, 3);  // 填充最右侧那一列的数据
            System.Buffer.BlockCopy(ImageData, Stride * Y, ImageDataC, StrideC * (Y + 1) + 3, Width * 3);
        }
        System.Buffer.BlockCopy(ImageDataC, StrideC, ImageDataC, 0, StrideC);              //  第一行
        System.Buffer.BlockCopy(ImageDataC, (HeightC - 2) * StrideC, ImageDataC, (HeightC - 1) * StrideC, StrideC);    //  最后一行               

        for (Y = 0; Y < Height; Y++)
        {
            Speed = Y * Stride;
            SpeedOne = StrideC * Y;            for (X = 0; X < Width; X++)
            {
                SpeedTwo = SpeedOne + StrideC;          //  尽量减少计算
                SpeedThree = SpeedTwo + StrideC;        //  下面的就是严格的按照Sobel算字进行计算，代码中的*2一般会优化为移位或者两个Add指令的，如果你不放心，当然可以直接改成移位
                BlueOne = ImageDataC[SpeedOne] + 2 * ImageDataC[SpeedTwo] + ImageDataC[SpeedThree] - ImageDataC[SpeedOne + 6] - 2 * ImageDataC[SpeedTwo + 6] - ImageDataC[SpeedThree + 6];
                GreenOne = ImageDataC[SpeedOne + 1] + 2 * ImageDataC[SpeedTwo + 1] + ImageDataC[SpeedThree + 1] - ImageDataC[SpeedOne + 7] - 2 * ImageDataC[SpeedTwo + 7] - ImageDataC[SpeedThree + 7];
                RedOne = ImageDataC[SpeedOne + 2] + 2 * ImageDataC[SpeedTwo + 2] + ImageDataC[SpeedThree + 2] - ImageDataC[SpeedOne + 8] - 2 * ImageDataC[SpeedTwo + 8] - ImageDataC[SpeedThree + 8];
                BlueTwo = ImageDataC[SpeedOne] + 2 * ImageDataC[SpeedOne + 3] + ImageDataC[SpeedOne + 6] - ImageDataC[SpeedThree] - 2 * ImageDataC[SpeedThree + 3] - ImageDataC[SpeedThree + 6];
                GreenTwo = ImageDataC[SpeedOne + 1] + 2 * ImageDataC[SpeedOne + 4] + ImageDataC[SpeedOne + 7] - ImageDataC[SpeedThree + 1] - 2 * ImageDataC[SpeedThree + 4] - ImageDataC[SpeedThree + 7];
                RedTwo = ImageDataC[SpeedOne + 2] + 2 * ImageDataC[SpeedOne + 5] + ImageDataC[SpeedOne + 8] - ImageDataC[SpeedThree + 2] - 2 * ImageDataC[SpeedThree + 5] - ImageDataC[SpeedThree + 8];

                PowerBlue = BlueOne * BlueOne + BlueTwo * BlueTwo;
                PowerGreen = GreenOne * GreenOne + GreenTwo * GreenTwo;
                PowerRed = RedOne * RedOne + RedTwo * RedTwo;                if (PowerBlue > 65025) PowerBlue = 65025;           //  处理掉溢出值
                if (PowerGreen > 65025) PowerGreen = 65025;                if (PowerRed > 65025) PowerRed = 65025;
                ImageData[Speed] = SqrValue[PowerBlue];             //  查表
                ImageData[Speed + 1] = SqrValue[PowerGreen];
                ImageData[Speed + 2] = SqrValue[PowerRed];

                Speed += 3;                                  // 跳往下一个像素
                SpeedOne += 3;
            }
        }
        Sw.Stop();        this.Text = "计算用时: " + Sw.ElapsedMilliseconds.ToString() + " ms";

        Bmp.UnlockBits(BmpData);                         //  必须先解锁，否则Invalidate失败     }
    Pic.Invalidate();
}

　　为简单的起见，这里先是用的C#的一维数组实现的，并且计时部分未考虑图像数据的获取和更新，因为真正的图像处理过程中图像数据肯定是已经获得的了。

针对上述代码，编译为Release模式后，执行编译后的EXE，对于3000*4000*3的彩色图像，耗时约480ms，如果你是在IDE的模式先运行，记得一定要在选项--》调试--》常规里不勾选在模块加载时取消JIT优化（仅限托管）一栏。

PhotoShop算法原理解析系列-风格化-查找边缘。 - 文章图片

上述代码中的填充克隆图数据时并没有新建一副图，然后再填充其中的图像数据，而是直接填充一个数组，图像其实不就是一片连续内存加一点头信息吗，头信息已经有了，所以只要一片内存就够了。

克隆数据的填充采用了系统Buffer.BlockCopy函数，该函数类似于我们以前常用CopyMemory，速度非常快。

为进一步调高执行速度，我们首先来看看算法的关键耗时部位的代码，即for (X = 0; X < Width; X++)内部的代码，我们取一行代码的反编译码来看看：

 BlueOne = ImageDataC[SpeedOne] + 2 * ImageDataC[SpeedTwo] + ImageDataC[SpeedThree] - ImageDataC[SpeedOne + 6] - 2 * ImageDataC[SpeedTwo + 6] - ImageDataC[SpeedThree + 6];

00000302  cmp         ebx,edi 
00000304  jae         0000073C 　　　　　　　　　　　　//   数组是否越界？
0000030a  movzx       eax,byte ptr [esi+ebx+8] 　　　//　 将ImageDataC[SpeedOne]中的数据传送的eax寄存器
0000030f  mov         dword ptr [ebp-80h],eax 
00000312  mov         edx,dword ptr [ebp-2Ch] 
00000315  cmp         edx,edi 
00000317  jae         0000073C 　　　　　　　　　　　//     数组是否越界？　　　　　　　　　　　
0000031d  movzx       edx,byte ptr [esi+edx+8] 　　// 　　将ImageDataC[SpeedTwo]中的数据传送到edx寄存器00000322  add         edx,edx 　　　　　　　　　　　　//    计算2*ImageDataC[SpeedTwo]　　　　00000324  add         eax,edx 　　　　　　　　　　　　//    计算ImageDataC[SpeedOne]+2*ImageDataC[SpeedTwo]，并保存在eax寄存器中　　　　　　　　　　　00000326  cmp         ecx,edi 
00000328  jae         0000073C 
0000032e  movzx       edx,byte ptr [esi+ecx+8] 　　//    将ImageDataC[SpeedThree]中的数据传送到edx寄存器00000333  mov         dword ptr [ebp+FFFFFF78h],edx 
00000339  add         eax,edx 
0000033b  lea         edx,[ebx+6] 
0000033e  cmp         edx,edi 
00000340  jae         0000073C 
00000346  movzx       edx,byte ptr [esi+edx+8] 
0000034b  mov         dword ptr [ebp+FFFFFF7Ch],edx 
00000351  sub         eax,edx 
00000353  mov         edx,dword ptr [ebp-2Ch] 
00000356  add         edx,6 00000359  cmp         edx,edi 
0000035b  jae         0000073C 
00000361  movzx       edx,byte ptr [esi+edx+8] 
00000366  add         edx,edx 
00000368  sub         eax,edx 
0000036a  lea         edx,[ecx+6] 
0000036d  cmp         edx,edi 
0000036f  jae         0000073C 
00000375  movzx       edx,byte ptr [esi+edx+8] 
0000037a  mov         dword ptr [ebp+FFFFFF74h],edx 
00000380  sub         eax,edx 
00000382  mov         dword ptr [ebp-30h],eax

　　上述汇编码我只注释一点点，其中最0000073c 标号，我们跟踪后返现是调用了另外一个函数：

0000073c call 685172A4

我们看到在获取每一个数组元素前，都必须执行一个cmp 和 jae指令，从分析我认为这里是做类似于判断数组的下标是否越界之类的工作的。如果我们能确保我们的算法那不会产生越界，这部分代码有很用呢，不是耽误我做正事吗。

为此，我认为需要在C#中直接利用指针来实现算法，C#中有unsafe模式，也有指针，所以很方便，而且指针的表达即可以用*，也可以用[]，比如*(P+4) 和P[4]是一个意思。那么只要做很少的修改就可以将上述代码修改为指针版。

private void CmdFindEdgesPointer_Click(object sender, EventArgs e)
    {        int X, Y;        int Width, Height, Stride, StrideC, HeightC;        int Speed, SpeedOne, SpeedTwo, SpeedThree;        int BlueOne, BlueTwo, GreenOne, GreenTwo, RedOne, RedTwo;        int PowerRed, PowerGreen, PowerBlue;
        Bitmap Bmp = (Bitmap)Pic.Image;        if (Bmp.PixelFormat != PixelFormat.Format24bppRgb) throw new Exception("不支持的图像格式.");        byte[] SqrValue = new byte[65026];        for (Y = 0; Y < 65026; Y++) SqrValue[Y] = (byte)(255 - (int)Math.Sqrt(Y));      // 计算查找表，注意已经砸查找表里进行了反色
        Width = Bmp.Width; Height = Bmp.Height; Stride = (int)((Bmp.Width * 3 + 3) & 0XFFFFFFFC);
        StrideC = (Width + 2) * 3; HeightC = Height + 2;                                 // 宽度和高度都扩展2个像素

        byte[] ImageData = new byte[Stride * Height];                                    // 用于保存图像数据，（处理前后的都为他)
        byte[] ImageDataC = new byte[StrideC * HeightC];                                 // 用于保存扩展后的图像数据

        fixed (byte* P = &ImageData[0], CP = &ImageDataC[0], LP = &SqrValue[0])
        {            byte* DataP = P, DataCP = CP, LutP = LP;
            BitmapData BmpData = new BitmapData();
            BmpData.Scan0 = (IntPtr)DataP;                                              //  设置为字节数组的的第一个元素在内存中的地址
            BmpData.Stride = Stride;
            Bmp.LockBits(new Rectangle(0, 0, Bmp.Width, Bmp.Height), ImageLockMode.ReadWrite | ImageLockMode.UserInputBuffer, PixelFormat.Format24bppRgb, BmpData);

            Stopwatch Sw = new Stopwatch();                                             //  只获取计算用时            Sw.Start();            for (Y = 0; Y < Height; Y++)
            {
                System.Buffer.BlockCopy(ImageData, Stride * Y, ImageDataC, StrideC * (Y + 1), 3);        // 填充扩展图的左侧第一列像素(不包括第一个和最后一个点)
                System.Buffer.BlockCopy(ImageData, Stride * Y + (Width - 1) * 3, ImageDataC, StrideC * (Y + 1) + (Width + 1) * 3, 3);  // 填充最右侧那一列的数据
                System.Buffer.BlockCopy(ImageData, Stride * Y, ImageDataC, StrideC * (Y + 1) + 3, Width * 3);
            }
            System.Buffer.BlockCopy(ImageDataC, StrideC, ImageDataC, 0, StrideC);              //  第一行
            System.Buffer.BlockCopy(ImageDataC, (HeightC - 2) * StrideC, ImageDataC, (HeightC - 1) * StrideC, StrideC);    //  最后一行               

            for (Y = 0; Y < Height; Y++)
            {
                Speed = Y * Stride;
                SpeedOne = StrideC * Y;                for (X = 0; X < Width; X++)
                {
                    SpeedTwo = SpeedOne + StrideC;          //  尽量减少计算
                    SpeedThree = SpeedTwo + StrideC;        //  下面的就是严格的按照Sobel算字进行计算，代码中的*2一般会优化为移位或者两个Add指令的，如果你不放心，当然可以直接改成移位
                    BlueOne = DataCP[SpeedOne] + 2 * DataCP[SpeedTwo] + DataCP[SpeedThree] - DataCP[SpeedOne + 6] - 2 * DataCP[SpeedTwo + 6] - DataCP[SpeedThree + 6];
                    GreenOne = DataCP[SpeedOne + 1] + 2 * DataCP[SpeedTwo + 1] + DataCP[SpeedThree + 1] - DataCP[SpeedOne + 7] - 2 * DataCP[SpeedTwo + 7] - DataCP[SpeedThree + 7];
                    RedOne = DataCP[SpeedOne + 2] + 2 * DataCP[SpeedTwo + 2] + DataCP[SpeedThree + 2] - DataCP[SpeedOne + 8] - 2 * DataCP[SpeedTwo + 8] - DataCP[SpeedThree + 8];
                    BlueTwo = DataCP[SpeedOne] + 2 * DataCP[SpeedOne + 3] + DataCP[SpeedOne + 6] - DataCP[SpeedThree] - 2 * DataCP[SpeedThree + 3] - DataCP[SpeedThree + 6];
                    GreenTwo = DataCP[SpeedOne + 1] + 2 * DataCP[SpeedOne + 4] + DataCP[SpeedOne + 7] - DataCP[SpeedThree + 1] - 2 * DataCP[SpeedThree + 4] - DataCP[SpeedThree + 7];
                    RedTwo = DataCP[SpeedOne + 2] + 2 * DataCP[SpeedOne + 5] + DataCP[SpeedOne + 8] - DataCP[SpeedThree + 2] - 2 * DataCP[SpeedThree + 5] - DataCP[SpeedThree + 8];

                    PowerBlue = BlueOne * BlueOne + BlueTwo * BlueTwo;
                    PowerGreen = GreenOne * GreenOne + GreenTwo * GreenTwo;
                    PowerRed = RedOne * RedOne + RedTwo * RedTwo;                    if (PowerBlue > 65025) PowerBlue = 65025;           //  处理掉溢出值
                    if (PowerGreen > 65025) PowerGreen = 65025;                    if (PowerRed > 65025) PowerRed = 65025;

                    DataP[Speed] = LutP[PowerBlue];                     //  查表
                    DataP[Speed + 1] = LutP[PowerGreen];
                    DataP[Speed + 2] = LutP[PowerRed];

                    Speed += 3;                                         //  跳往下一个像素
                    SpeedOne += 3;
                }
            }
            Sw.Stop();            this.Text = "计算用时: " + Sw.ElapsedMilliseconds.ToString() + " ms";

            Bmp.UnlockBits(BmpData);                         //  必须先解锁，否则Invalidate失败         }
        Pic.Invalidate();
    }

同样的效果，同样的图像，计算用时330ms。

我们在来看看相同代码的汇编码：

BlueOne = DataCP[SpeedOne] + 2 * DataCP[SpeedTwo] + DataCP[SpeedThree] - DataCP[SpeedOne + 6] - 2 * DataCP[SpeedTwo + 6] - DataCP[SpeedThree + 6];

00000318  movzx       eax,byte ptr [esi+edi] 
0000031c  mov         dword ptr [ebp-74h],eax 
0000031f  movzx       edx,byte ptr [esi+ebx] 
00000323  add         edx,edx 
00000325  add         eax,edx 
00000327  movzx       edx,byte ptr [esi+ecx] 
0000032b  mov         dword ptr [ebp-7Ch],edx 
0000032e  add         eax,edx 
00000330  movzx       edx,byte ptr [esi+edi+6] 
00000335  mov         dword ptr [ebp-78h],edx 
00000338  sub         eax,edx 
0000033a  movzx       edx,byte ptr [esi+ebx+6] 
0000033f  add         edx,edx 
00000341  sub         eax,edx 
00000343  movzx       edx,byte ptr [esi+ecx+6] 
00000348  mov         dword ptr [ebp-80h],edx 
0000034b  sub         eax,edx 
0000034d  mov         dword ptr [ebp-30h],eax

生产的汇编码简洁，意义明确，对比下少了很多指令。当然速度会快很多。

注意这一段代码：

  fixed (byte* P = &ImageData[0], CP = &ImageDataC[0], LP = &SqrValue[0])
        {            byte* DataP = P, DataCP = CP, LutP = LP;

如果你把更换为：

  fixed (byte* DataP = &ImageData[0], DataCP = &ImageDataC[0], LutP = &SqrValue[0])
{

代码的速度反而比纯数组版的还慢，至于为什么，实践为王吧，我也没有去分析，反正我知道有这个结果。你可以参考铁哥的一篇文章：

闲谈.Net类型之public的不public，fixed的不能fixed

当然这个还可以进一步做小动作的的优化，比如movzx eax,byte ptr [esi+edi] 这句中，esi其实就是数组的基地址，向这样写DataCP[SpeedOne] ，每次都会有这个基址+偏移的计算的，如果能实时直接动态控制一个指针变量，使他直接指向索要的位置，则少了一次加法，虽然优化不是很明显，基本可以达到问中之前所提到的300ms的时间了。具体的代码可见附件。

很多人可能对我这些东西不感冒，说这些东西丢给GPU比你现在的.......希望这些朋友也不要过分的打击吧，每个人都有自己的爱好,我只爱好CPU。

更多PhotoShop算法原理解析系列 - 风格化-查找边缘。相关文章请关注PHP中文网！

内容总结

以上是互联网集市为您收集整理的PhotoShop算法原理解析系列-风格化-查找边缘。全部内容，希望文章能够帮你解决PhotoShop算法原理解析系列-风格化-查找边缘。所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/420817.html

来源：【匿名】

【上一篇】PhotoShop算法原理解析系列-像素化-碎片【下一篇】浅谈php实现映射的两种方法（链表和二叉树）

更多 ►

【PhotoShop算法原理解析系列-风格化-查找边缘。】教程文章相关的互联网学习教程文章

GBDT算法原理【图】

一、GBDT 在介绍AdaBoost的时候我们讲到了，AdaBoost算法是模型为加法模型，损失函数为指数函数（针对分类为题），学习算法为前向分步算法时的分类问题。而GBDT算法是模型为加法模型，学习算法为前向分步算法，基函数为CART树（树是回归树），损失函数为平方损失函数的回归问题，为指数函数的分类问题和为一般损失函数的一般决策问题。在针对基学习器的不足上，AdaBoost算法是通过提升错分数据点的权重来定位模型的不足，而梯...

微博URL短网址生成算法原理及（java版、php版实现实例）【代码】

短网址（Short URL），顾名思义就是在形式上比较短的网址。通常用的是asp或者php转向，在Web 2.0的今天，不得不说，这是一个潮流。目前已经有许多类似服务，借助短网址您可以用简短的网址替代原来冗长的网址，让使用者可以更容易的分享链接。例如：http://t.cn/SzjPjA短网址服务，可能很多朋友都已经不再陌生，现在大部分微博、手机邮件提醒等地方已经有很多应用模式了，并占据了一定的市场。估计很多朋友现在也正在使用。看过新...

【算法基础笔记】常用的排序算法的时间、空间复杂度，部分排序算法原理【图】

冒泡排序比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较堆排序将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无须区；将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序...

十一、Powell算法（鲍威尔算法）原理以及实现【代码】

一、介绍　　Powell算法是图像配准里面的常用的加速算法，可以加快搜索速度，而且对于低维函数的效果很好，所以本篇博客主要是为了介绍Powell算法的原理以及实现。　　由于网上已经有了对于Powell算法的讲解，所以我只是把链接放出来（我觉得自己目前还没有这个讲解的能力），大家自己去了解。　　放在这里主要也是为了节省大家搜索的时间。（都是我辛辛苦苦搜出来的^-^）。二、预备知识　　了解一维搜索算法：进退法，消去法，黄金...

【机器学习】算法原理详细推导与实现(五):支持向量机(下)【代码】【图】

【机器学习】算法原理详细推导与实现(五):支持向量机(下)上一章节介绍了支持向量机的生成和求解方式，能够根据训练集依次得出\(\omega\)、\(b\)的计算方式，但是如何求解需要用到核函数，将在这一章详细推导实现。核函数在讲核函数之前，要对上一章节得到的结果列举出来。之前需要优化的凸函数为：\[ min_{\gamma,\omega,b}->\frac{1}{2}||\omega||^2 \]\[ y^{(i)}(\omega^Tx^{(i)}+b) \geq 1 ,i=1,2,...,m \]这里假设数据是线性可...

郑捷《机器学习算法原理与编程实践》学习笔记（第六章神经网络初步）6.3 自组织特征映射神经网路（SMO）【代码】【图】

具体原理网址：http://wenku.baidu.com/link?url=zSDn1fRKXlfafc_tbofxw1mTaY0LgtH4GWHqs5rl8w2l5I4GF35PmiO43Cnz3YeFrrkGsXgnFmqoKGGaCrylnBgx4cZC3vymiRYvC4d3DF3自组织特征映射神经网络（Self-Organizing Feature Map。也称Kohonen映射），简称为SMO网络，主要用于解决模式识别类的问题。SMO网络属于无监督学习算法，与之前的Kmeans算法类似。所不同的是，SMO网络不需要预先提供聚类的数量，类别的数量是由网络自动识别出来的。...

MD5算法原理【图】

MD5（单向散列算法）的全称是Message-DigestAlgorithm 5（信息-摘要算法），经MD2、MD3和MD4发展而来。MD5算法的使用不须要支付不论什么版权费用。 MD5功能：输入随意长度的信息，经过处理，输出为128位的信息（数字指纹）；不同的输入得到的不同的结果（唯一性）；依据128位的输出结果不可能反推出输入的信息（不可逆）； MD5属不属于加密算法：觉得不属于的人是由于他们觉得不能从密文（散列值）反过来得...

多层神经网络BP算法原理及推导【图】

首先什么是人工神经网络？简单来说就是将单个感知器作为一个神经网络节点，然后用此类节点组成一个层次网络结构，我们称此网络即为人工神经网络（本人自己的理解）。当网络的层次大于等于3层（输入层+隐藏层（大于等于1）+输出层）时，我们称之为多层人工神经网络。1、神经单元的选择　　那么我们应该使用什么样的感知器来作为神经网络节点呢？在上一篇文章我们介绍过感知器算法，但是直接使用的话会存在以下问题：　　1）感知器训...

经典的7种排序算法原理C++实现

经典的7种排序算法原理C++实现排序是编程过程中经常遇到的操作，它在很大程度上影响了程序的执行效率。7种常见的排序算法大致可以分为两类：第一类是低级排序算法，有选择排序、冒泡排序、插入排序；第二类是高级排序算法，有堆排序、排序树、归并排序、快速排序。一、低级排序算法1. 选择排序排序过程：给定一个数值集合，循环遍历集合，每次遍历从集合中选择出最小或最大的放入集合的开头或结尾的位置，下次循环从剩余的元素集合...

深入一致性哈希(Consistent Hashing)算法原理，并附100行代码实现【代码】【图】

本文为实现分布式任务调度系统中用到的一些关键技术点分享——Consistent Hashing算法原理和Java实现，以及效果测试。　背景介绍　　一致性Hashing在分布式系统中经常会被用到，用于尽可能地降低节点变动带来的数据迁移开销。Consistent Hashing算法在1997年就在论文Consistenthashing and random trees中被提出。　　先来简单理解下Hash是解决什么问题。假设一个分布式任务调度系统，执行任务的节点有n台机器，现有m个job在这n台...

Canny边缘检测算法原理及其VC实现详解(二)【代码】【图】

3、 Canny算法的实现流程由于本文主要目的在于学习和实现算法，而对于图像读取、视频获取等内容不进行阐述。因此选用OpenCV算法库作为其他功能的实现途径（关于OpenCV的使用，作者将另文表述）。首先展现本文将要处理的彩色图片。图2 待处理的图像3.1 图像读取和灰度化编程时采用上文所描述的第二种方法来实现图像的灰度化。其中ptr数组中保存的灰度化后的图像数据。具体的灰度化后的效果如图3所示。IplImage* Colo...

DES加密算法原理

DES的每个分组是64位，既明文和密钥都是64位（密钥实际用56位，每字节第8位为校验）。这个算法的核心是Feistel密码，由于其设计的巧妙，加密解密都用一个函数，具体原理请查阅其他资料。DES的流程基本是执行16轮下面的运算： 1 初始变换Initial Permutation 2 右边32位f函数 2.1 E置换 2.2 与轮密钥XOR 2.3 S盒替换 2.4 P置换 2.5 和左边32位XOR 3 左右交换，最终变换final permutation 需要特别注意的是，最后一轮是不需要做左右交...

Apriori 关联分析算法原理分析与代码实现【代码】【图】

前言　　想必大家都听过数据挖掘领域那个经典的故事 - "啤酒与尿布" 的故事。　　那么，具体是怎么从海量销售信息中挖掘出啤酒和尿布之间的关系呢？　　这就是关联分析所要完成的任务了。　　本文将讲解关联分析领域中最为经典的Apriori算法，并给出具体的代码实现。关联分析领域的一些概念　　1. 频繁项集: 数据集中经常出现在一起的物品的集合。例如 "啤酒和尿布"　　2. 关联规则: 指两个物品集之间可能存在很强的关系。例如 "{啤...

算法原理与分析第二次作业【代码】【图】

#include<stdio.h> #include<string.h> #define MAX 100 int n=0,i=0; char *keyshuru[6]={"begin","if","then","while","do","end"};void KEYword(char shuru[MAX]) {int k=0,key=0;char token[MAX];while(shuru[i]!=‘#‘){ while((shuru[i]>=‘a‘&&shuru[i]<=‘z‘) || (shuru[i]>=‘A‘&&shuru[i]<=‘Z‘)){if((shuru[i]>=‘a‘&&shuru[i]<=‘z‘) || (shuru[i]>=‘A‘&&shuru[i]<=‘Z‘)){token[n]=shuru[i];n++;token[n]...

《TensorFlow深度学习算法原理与编程实战》_蒋子阳_学习资料整理【图】

内容简介 TensorFlow是谷歌研发的人工智能学习系统，是一个用于数值计算的开源软件库。《TensorFlow深度学习算法原理与编程实战》以基础实践相结合的形式，详细介绍了TensorFlow深度学习算法原理及编程技巧。通读全书，读者不仅可以系统了解深度学习的相关知识，还能对使用TensorFlow进行深度学习算法设计的过程有更深入的理解。《TensorFlow深度学习算法原理与编程实战》共14章，主要内容有：人工智能、大数据、机器学习和深度学...

PHOTOSHOP - 相关标签

算法 - 最热教程

浅谈SQLServer查询优化器中的JOIN算法有没那种可逆算法是密文比明文短的呢？...javascript-类似Excel里面的NORMDIST函...C++中的分治算法及常见题目汇总压缩感知重构算法综述-学习笔记 c++中内置函数qsort（快速排序）和bsea...一、fpga图像处理算法整合基于遗传算法（deap）的非线性函数寻优...集成学习-Bagging集成学习算法随机森林...机器学习笔记（九）聚类算法及实践（K-...

首页 / 算法 / PhotoShop算法原理解析系列-风格化-查找边缘。

PhotoShop算法原理解析系列-风格化-查找边缘。

内容导读

内容图文

内容总结

内容备注

内容手机端

【PhotoShop算法原理解析系列-风格化-查找边缘。】教程文章相关的互联网学习教程文章

GBDT算法原理【图】

微博URL短网址生成算法原理及（java版、php版实现实例）【代码】

【算法基础笔记】常用的排序算法的时间、空间复杂度，部分排序算法原理【图】

十一、Powell算法（鲍威尔算法）原理以及实现【代码】

【机器学习】算法原理详细推导与实现(五):支持向量机(下)【代码】【图】

郑捷《机器学习算法原理与编程实践》学习笔记（第六章神经网络初步）6.3 自组织特征映射神经网路（SMO）【代码】【图】

MD5算法原理【图】

多层神经网络BP算法原理及推导【图】

经典的7种排序算法原理C++实现

深入一致性哈希(Consistent Hashing)算法原理，并附100行代码实现【代码】【图】

Canny边缘检测算法原理及其VC实现详解(二)【代码】【图】

DES加密算法原理

Apriori 关联分析算法原理分析与代码实现【代码】【图】

算法原理与分析第二次作业【代码】【图】

《TensorFlow深度学习算法原理与编程实战》_蒋子阳_学习资料整理【图】

PHOTOSHOP - 相关标签

算法 - 相关标签

算法 - 最新教程

算法 - 最热教程