图像基本处理算法的简单实现（二）

 图像基本处理算法的简单实现（一）

 图像基本处理算法的简单实现（二）

 

4）膨胀腐蚀
属于什么心态学==，膨胀、腐蚀、击中/击不中变换、细化…（又晕了T^T）。简单点好像就是集合运算，图像与一结构元素的交差补什么的。图像一点的周围是否符合结构元素，然后该怎么处理。
结构元素（B）由0和1组成，用于扫描比较二值化图像（A）。
膨胀：
1、用结构元素B，扫描图像A的每一个像素
2、用结构元素与其覆盖的二值图像做“与”操作
3、如果都为0，结果图像的该像素为0。否则为1
腐蚀：
1、用结构元素B，扫描图像A的每一个像素
2、用结构元素与其覆盖的二值图像做“与”操作
3、如果都为1，结果图像的该像素为1。否则为0
膨胀腐蚀是形态学处理的基础。（copy的==）
膨胀的实现：
 
  1. /** 
  2.  * 对二值化Bitmap进行膨胀运算后返回 
  3.  * 
  4.  * 膨胀结构元素：3x3 全 
  5.  * 
  6.  * JNIEnv*  jni环境（jni必要参数） 
  7.  * jobject  java对象（jni必要参数） 
  8.  * jintArray    Bitmap所有像素值 
  9.  * int  Bitmap宽度 
  10.  * int  Bitmap高度 
  11.  */ 
  12. JNIEXPORT jintArray JNICALL Java_org_join_image_util_JoinImage_dilation( 
  13.         JNIEnv* env, jobject obj, jintArray buf, int w, int h) { 
  14.     LOGE("==dilation=="); 
  15.  
  16.     jint * cbuf; // 源图像 
  17.     cbuf = (*env)->GetIntArrayElements(env, buf, 0); // 获取int数组元素 
  18.  
  19.     int white = 0xFFFFFFFF; // 不透明白色 
  20.     int black = 0xFF000000; // 不透明黑色 
  21.  
  22.     int size = w * h; 
  23.     jint rbuf[size]; // 目标图像 
  24.     memset(rbuf, black, size * sizeof(jint)); // 将目标图像置成全黑 
  25.  
  26.     int i, j, m, n, gray; 
  27.     jint *p, *q; 
  28.     // 由于使用3×3的结构元素，为防止越界，所以不处理上下左右四边像素 
  29.     for (i = 1; i < h - 1; i++) { 
  30.         for (j = 1; j < w - 1; j++) { 
  31.             p = cbuf + w * i + j; // 指向源图像i行j列 
  32.  
  33.             // 遍历源图像对应结构元素的各点 
  34.             for (m = -1; m <= 1; m++) { 
  35.                 for (n = -1; n <= 1; n++) { 
  36.                     gray = (*(p + w * m + n)) & 0xFF; // 获取源图像对应结构元素点的灰度值 
  37.                     // 如果对应3x3范围内有白点（其他色都算为黑） 
  38.                     if (gray == 255) { 
  39.                         q = rbuf + w * i + j; // 指向目标图像i行j列 
  40.                         *q = white; // 将目标图像中的当前点赋成白色 
  41.                         break; 
  42.                     } 
  43.                 } 
  44.             } 
  45.         } 
  46.     } 
  47.  
  48.     jintArray result = (*env)->NewIntArray(env, size); // 新建一个jintArray 
  49.     (*env)->SetIntArrayRegion(env, result, 0, size, rbuf); // 将rbuf转存入result 
  50.     (*env)->ReleaseIntArrayElements(env, buf, cbuf, 0); // 释放int数组元素 
  51.     return result; 
  52. } 
 
腐蚀的实现：
 
 
  1. /** 
  2.  * 对二值化Bitmap进行腐蚀运算后返回 
  3.  * 
  4.  * 腐蚀结构元素：3x3 全 
  5.  * 
  6.  * JNIEnv*  jni环境（jni必要参数） 
  7.  * jobject  java对象（jni必要参数） 
  8.  * jintArray    Bitmap所有像素值 
  9.  * int  Bitmap宽度 
  10.  * int  Bitmap高度 
  11.  */ 
  12. JNIEXPORT jintArray JNICALL Java_org_join_image_util_JoinImage_erosion( 
  13.         JNIEnv* env, jobject obj, jintArray buf, int w, int h) { 
  14.     LOGE("==erosion=="); 
  15.  
  16.     jint * cbuf; // 源图像 
  17.     cbuf = (*env)->GetIntArrayElements(env, buf, 0); // 获取int数组元素 
  18.  
  19.     int white = 0xFFFFFFFF; // 不透明白色 
  20.     int black = 0xFF000000; // 不透明黑色 
  21.  
  22.     int size = w * h; 
  23.     jint rbuf[size]; // 目标图像 
  24.     memset(rbuf, black, size * sizeof(jint)); // 将目标图像置成全黑 
  25.  
  26.     int i, j, m, n, gray; 
  27.     jint *p, *q; 
  28.     // 由于使用3×3的结构元素，为防止越界，所以不处理上下左右四边像素 
  29.     for (i = 1; i < h - 1; i++) { 
  30.         for (j = 1; j < w - 1; j++) { 
  31.             p = cbuf + w * i + j; // 指向源图像i行j列 
  32.  
  33.             q = rbuf + w * i + j; // 指向目标图像i行j列 
  34.             *q = white; // 将目标图像中的当前点赋成白色 
  35.  
  36.             // 遍历源图像对应结构元素的各点 
  37.             for (m = -1; m <= 1; m++) { 
  38.                 for (n = -1; n <= 1; n++) { 
  39.                     gray = (*(p + w * m + n)) & 0xFF; // 获取源图像对应结构元素点的灰度值 
  40.                     // 如果对应3x3范围内有黑点（其他色都算为白） 
  41.                     if (gray == 0) { 
  42.                         *q = black; // 将目标图像中的当前点赋成黑色 
  43.                         break; 
  44.                     } 
  45.                 } 
  46.             } 
  47.         } 
  48.     } 
  49.  
  50.     jintArray result = (*env)->NewIntArray(env, size); // 新建一个jintArray 
  51.     (*env)->SetIntArrayRegion(env, result, 0, size, rbuf); // 将rbuf转存入result 
  52.     (*env)->ReleaseIntArrayElements(env, buf, cbuf, 0); // 释放int数组元素 
  53.     return result; 
  54. } 
 
好吧，都一样的结构元素==，这是偷懒呢。没必要非这样，也可以如“背景色点上下左右>=3点为前景色，则将其填充为前景色”什么的。
 
 
 5）细化 
 
提取图像骨架的。主要有Zhang快速并行细化方法、Hilditch、Pavlidis、Rosenfeld、索引表细化方法等。
 
简述下连通图概念先：分为四连通和八连通（或者称之为邻域）。四连通就是图像上下左右有一点时，才算这两点是连接的；而八连通则周围一圈有一点都行。也就是一点只有右上角有邻点，则是八连通非四连通^^。
 
算法按着名字查找下就好==，不想再表述了（实现代码注释了其实有了的^^）。
 
 
 Zhang快速并行细化方法： 
 
 
  1. /** 
  2.  * 对二值化Bitmap进行细化运算后返回 
  3.  * 
  4.  * 采用“Zhang快速并行细化方法” 
  5.  * 
  6.  * JNIEnv*  jni环境（jni必要参数） 
  7.  * jobject  java对象（jni必要参数） 
  8.  * jintArray    Bitmap所有像素值 
  9.  * int  Bitmap宽度 
  10.  * int  Bitmap高度 
  11.  */ 
  12. JNIEXPORT jintArray JNICALL Java_org_join_image_util_JoinImage_thinning( 
  13.         JNIEnv* env, jobject obj, jintArray buf, int w, int h) { 
  14.     LOGE("==thinning=="); 
  15.  
  16.     jint * cbuf; 
  17.     cbuf = (*env)->GetIntArrayElements(env, buf, 0); // 获取int数组元素 
  18.  
  19.     int black = 0xFF000000; // 不透明黑色 
  20.  
  21.     unsigned char foreground = 0xFF; // 前景灰度值：255（白） 
  22.     unsigned char background = 0; // 背景灰度值：0（黑） 
  23.  
  24.     jboolean modified = 1; // 设置脏标记：true 
  25.     unsigned char count; // 计数器 
  26.     unsigned char mark[w][h]; // 可删除标记 
  27.  
  28.     int size = w * h; // 数据数目 
  29.  
  30.     /* 
  31.      * 8-领域示意图 
  32.      * 
  33.      * P9   P2  P3 
  34.      * P8   P1  P4 
  35.      * P7   P6  P5 
  36.      */ 
  37.  
  38.     int i, j, m, n; // 循环标记 
  39.     unsigned char gray; // 灰度值 
  40.     unsigned char grays[3][3]; // 领域各点灰度值 
  41.     jint *p; // 指向源图像像素的指针 
  42.  
  43.     // 一次迭代操作（直到没有点再满足标记条件） 
  44.     while (modified) { 
  45.         modified = 0; // 设置脏标记：false 
  46.  
  47.         /* 
  48.          * 第一层子循环，删除条件： 
  49.          * 
  50.          * (1.1) 2<=N(p1)<=6 
  51.          * (1.2) S(p1)=1 
  52.          * (1.3) p2*p4*p6=0 
  53.          * (1.4) p4*p6*p8=0 
  54.          * 
  55.          * N(p1)：p1的非零邻点的个数 
  56.          * S(p1)：以p2 ，p3 ，…… ，p9为序时这些点的值从0到1变化的次数 
  57.          */ 
  58.  
  59.         memset(mark, 0, sizeof(mark)); // 重置删除标记为false 
  60.  
  61.         // 防止越界，不处理上下左右四边像素 
  62.         for (i = 1; i < h - 1; i++) { 
  63.             for (j = 1; j < w - 1; j++) { 
  64.  
  65.                 p = cbuf + w * i + j; // 指向源图像i行j列 
  66.                 gray = (*p) & 0xFF; // 获得灰度值 
  67.  
  68.                 if (gray == foreground) { // 判断是否为细化像素（前景像素） 
  69.  
  70.                     // 计算N(p1) 
  71.                     count = 0; // 重置计数器 
  72.                     for (m = -1; m <= 1; m++) { 
  73.                         for (n = -1; n <= 1; n++) { 
  74.                             gray = (*(p + w * m + n)) & 0xFF; // 获取领域各点的灰度值 
  75.                             grays[m + 1][n + 1] = gray; // 同时存储领域各点的灰度值 
  76.                             if (gray == foreground) { // 如果为前景像素 
  77.                                 count++; 
  78.                             } 
  79.                         } 
  80.                     } 
  81.                     count--; // 去除中心点 
  82.  
  83.                     // 判断条件(1.1) 
  84.                     if (2 <= count && count <= 6) { 
  85.                     } else { 
  86.                         continue; // 条件(1.1)不成立，跳出循环 
  87.                     } 
  88.  
  89.                     // 计算S(p1)：四周像素由0变255的次数 
  90.                     // 需先计算N(p1)，获取领域各点的灰度值 
  91.                     count = 0; // 重置计数器 
  92.                     if (grays[0][1] < grays[0][2]) 
  93.                         count++; // p2->p3 
  94.                     if (grays[0][2] < grays[1][2]) 
  95.                         count++; // p3->p4 
  96.                     if (grays[1][2] < grays[2][2]) 
  97.                         count++; // p4->p5 
  98.                     if (grays[2][2] < grays[2][1]) 
  99.                         count++; // p5->p6 
  100.                     if (grays[2][1] < grays[2][0]) 
  101.                         count++; // p6->p7 
  102.                     if (grays[2][0] < grays[1][0]) 
  103.                         count++; // p7->p8 
  104.                     if (grays[1][0] < grays[0][0]) 
  105.                         count++; // p8->p9 
  106.                     if (grays[0][0] < grays[0][1]) 
  107.                         count++; // p9->p2 
  108.  
  109.                     // 判断条件(1.2) 
  110.                     if (1 == count) { 
  111.                     } else { 
  112.                         continue; // 条件(1.2)不成立，跳出循环 
  113.                     } 
  114.  
  115.                     // 判断条件(1.3) 
  116.                     if (background == grays[0][1] || background == grays[1][2] 
  117.                             || background == grays[2][1]) { 
  118.                     } else { 
  119.                         continue; // 条件(1.3)不成立，跳出循环 
  120.                     } 
  121.  
  122.                     // 判断条件(1.4) 
  123.                     if (background == grays[1][2] || background == grays[2][1] 
  124.                             || background == grays[1][0]) { 
  125.                     } else { 
  126.                         continue; // 条件(1.4)不成立，跳出循环 
  127.                     } 
  128.  
  129.                     /* 
  130.                      * 四条件都成立时 
  131.                      */ 
  132.                     mark[j][i] = 1; // 删除标记为true 
  133.                     modified = 1; // 脏标记为true 
  134.                 } 
  135.             } 
  136.         } 
  137.  
  138.         // 由删除标记去除 
  139.         if (modified) { 
  140.             for (i = 1; i < h - 1; i++) { 
  141.                 for (j = 1; j < w - 1; j++) { 
  142.                     // 如果删除标记为true 
  143.                     if (1 == mark[j][i]) { 
  144.                         cbuf[w * i + j] = black; // 修改成背景色（黑） 
  145.                     } 
  146.                 } 
  147.             } 
  148.         } 
  149.  
  150.         /* 
  151.          * 第二层子循环，删除条件： 
  152.          * 
  153.          * (1.1) 2<=N(p1)<=6 
  154.          * (1.2) S(p1)=1 
  155.          * (2.3) p2*p4*p8=0 
  156.          * (2.4) p2*p6*p8=0 
  157.          */ 
  158.         memset(mark, 0, sizeof(mark)); // 重置删除标记为false 
  159.  
  160.         // 防止越界，不处理上下左右四边像素 
  161.         for (i = 1; i < h - 1; i++) { 
  162.             for (j = 1; j < w - 1; j++) { 
  163.  
  164.                 p = cbuf + w * i + j; // 指向源图像i行j列 
  165.                 gray = (*p) & 0xFF; // 获得灰度值 
  166.  
  167.                 if (gray == foreground) { // 判断是否为细化像素（前景像素） 
  168.  
  169.                     // 计算N(p1) 
  170.                     count = 0; // 重置计数器 
  171.                     for (m = -1; m <= 1; m++) { 
  172.                         for (n = -1; n <= 1; n++) { 
  173.                             gray = (*(p + w * m + n)) & 0xFF; // 获取领域各点的灰度值 
  174.                             grays[m + 1][n + 1] = gray; // 同时存储领域各点的灰度值 
  175.                             if (gray == foreground) { // 如果为前景像素 
  176.                                 count++; 
  177.                             } 
  178.                         } 
  179.                     } 
  180.                     count--; // 去除中心点 
  181.  
  182.                     // 判断条件(1.1) 
  183.                     if (2 <= count && count <= 6) { 
  184.                     } else { 
  185.                         continue; // 条件(1.1)不成立，跳出循环 
  186.                     } 
  187.  
  188.                     // 计算S(p1)：四周像素由0变255的次数 
  189.                     // 需先计算N(p1)，获取领域各点的灰度值 
  190.                     count = 0; // 重置计数器 
  191.                     if (grays[0][1] < grays[0][2]) 
  192.                         count++; // p2->p3 
  193.                     if (grays[0][2] < grays[1][2]) 
  194.                         count++; // p3->p4 
  195.                     if (grays[1][2] < grays[2][2]) 
  196.                         count++; // p4->p5 
  197.                     if (grays[2][2] < grays[2][1]) 
  198.                         count++; // p5->p6 
  199.                     if (grays[2][1] < grays[2][0]) 
  200.                         count++; // p6->p7 
  201.                     if (grays[2][0] < grays[1][0]) 
  202.                         count++; // p7->p8 
  203.                     if (grays[1][0] < grays[0][0]) 
  204.                         count++; // p8->p9 
  205.                     if (grays[0][0] < grays[0][1]) 
  206.                         count++; // p9->p2 
  207.  
  208.                     // 判断条件(1.2) 
  209.                     if (1 == count) { 
  210.                     } else { 
  211.                         continue; // 条件(1.2)不成立，跳出循环 
  212.                     } 
  213.  
  214.                     // 判断条件(2.3) 
  215.                     if (background == grays[0][1] || background == grays[1][2] 
  216.                             || background == grays[1][0]) { 
  217.                     } else { 
  218.                         continue; // 条件(2.3)不成立，跳出循环 
  219.                     } 
  220.  
  221.                     // 判断条件(2.4) 
  222.                     if (background == grays[0][1] || background == grays[2][1] 
  223.                             || background == grays[1][0]) { 
  224.                     } else { 
  225.                         continue; // 条件(2.4)不成立，跳出循环 
  226.                     } 
  227.  
  228.                     /* 
  229.                      * 四条件都成立时 
  230.                      */ 
  231.                     mark[j][i] = 1; // 删除标记为true 
  232.                     modified = 1; // 脏标记为true 
  233.                 } 
  234.             } 
  235.         } 
  236.  
  237.         // 由删除标记去除 
  238.         if (modified) { 
  239.             for (i = 1; i < h - 1; i++) { 
  240.                 for (j = 1; j < w - 1; j++) { 
  241.                     // 如果删除标记为true 
  242.                     if (1 == mark[j][i]) { 
  243.                         cbuf[w * i + j] = black; // 修改成背景色（黑） 
  244.                     } 
  245.                 } 
  246.             } 
  247.         } 
  248.     } 
  249.  
  250.     jintArray result = (*env)->NewIntArray(env, size); // 新建一个jintArray 
  251.     (*env)->SetIntArrayRegion(env, result, 0, size, cbuf); // 将cbuf转存入result 
  252.     (*env)->ReleaseIntArrayElements(env, buf, cbuf, 0); // 释放int数组元素 
  253.     return result; 
  254. } 
 
 
 图像基本处理算法的简单实现（三）
 

 

 

 

 
     本文转自winorlose2000 51CTO博客，原文链接：http://blog.51cto.com/vaero/823000，如需转载请自行联系原作者
 

 

 

 

 





    











本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/256215.shtml


如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！











相关文章










【WIN10】WIN2D——基本圖形的繪製








【WIN10】WIN2D——基本圖形的繪製




DEMO下載地址&#xff1a;http://yunpan.cn/c3iNuHFFAcr8h &#xff08;提取码&#xff1a;8e48&#xff09; 先看一個截圖&#xff1a; 繪製了一些基本形狀。 DEMO的繪製代碼都非常簡單&#xff0c;不想在博客裡細說了&#xff0c;看代碼更為清晰些。 可能繪製扇形的代碼有些麻…




阅读更多...

















python socket 网络编程








python socket 网络编程




socket 套接字&#xff1a;网络接口。 我们在网络上需要传输自己需要的数据&#xff0c;我们在网络上传输数据使用的是网络协议&#xff0c; 而套接字就是我们将数据从本地采用协议传输的接口 socket模型&#xff1a; socket族&#xff1a; #AF_UNIX 被使用在类unix系统之间进行…




阅读更多...

















C# 并行运算方法简析








C# 并行运算方法简析




一、概述 
首先应该明白并行和并发的区别。 并发就是有多个几乎同时到达的线程需要被处理&#xff0c;但只有有限个CPU&#xff0c;所以需要竞争上岗。 并行指有多个CPU资源同时处理多个线程&#xff0c;不存在竞争的概念&#xff0c;可以大量节省运行时间。 
二、实现方法 
C#…




阅读更多...

















强烈建议使用国外DNS解析域名，解决访问速度和某些访问故障！








强烈建议使用国外DNS解析域名，解决访问速度和某些访问故障！




域名解析的基本原理是把域名翻译成IP地址&#xff0c;以便计算机能够进一步通信&#xff0c;传递网址和内容等。　　域名劫持就是在劫持的网络范围内拦截域名解析的请求&#xff0c;分析请求的域名&#xff0c;把审查范围以外的请求放行&#xff0c;否则直接返回假的IP地址或者…




阅读更多...

















Windows 8 系统快捷键热键列表收集








Windows 8 系统快捷键热键列表收集




值得收藏参考的 Windows 8 系统快捷键热键列表收集大全汇总&#xff0c;键盘党效率党必备啊&#xff01; 相信不少喜欢接触新鲜软件的同学都已经给电脑安装上Windows 8 操作系统了吧&#xff01;这个系统优秀与否我们暂且不讨论&#xff0c;作为一个键盘党&#xff0c;学习了解…




阅读更多...

















格式化字符串使用








格式化字符串使用




#codingutf-8  可以指定所需长度的字符串的对齐方式: < &#xff08;默认&#xff09;左对齐 > 右对齐 ^ 中间对齐  &#xff08;只用于数字&#xff09;在小数点后进行补齐  print 1:\t|{0:>10},.format(wangyu) print 2:\t|{0:4.2f}.format(1.1415926) print 3:\t|,…




阅读更多...

















Python中利用plt显示中文标题解决方案








Python中利用plt显示中文标题解决方案




解决方法 
plt.rcParams[font.sans-serif][SimHei]
plt.rcParams[axes.unicode_minus]  False
plt.title(灰度级别频率图)
plt.show()




阅读更多...

















Pytorch基础（三）—— DataSet的应用








Pytorch基础（三）—— DataSet的应用




一、概念 
Pytorch的标准数据集包括很多种类型&#xff0c;如CIFAR&#xff0c;COCO&#xff0c;KITTI&#xff0c;MNIST等&#xff0c;我们可以在官网查看。当然我们也可以做数据集&#xff0c;但需要自己标注。 
二、如何调用数据集 
一、调用torchvision 
在程序中调用torch…




阅读更多...

















【图像处理】——Python霍夫变换之直线检测（主要是两个函数HoughlinesHoughlinesP）








【图像处理】——Python霍夫变换之直线检测（主要是两个函数HoughlinesHoughlinesP）




目录 
一、原理（摘自《数字图像处理冈萨雷斯》） 
2、Python函数 
参数详解 
3、效果 
4、实




阅读更多...

















实验五实验报告








实验五实验报告




实     验    报     告 课程&#xff1a;信息安全系统设计基础           班级&#xff1a; 1353 姓名&#xff1a;魏静静 刘虹辰 文艺             学号&#xff1a;20135302  20135325 20135331 成绩&#xff1a;           指导教师&#xff1a;娄佳鹏 实验日期&#xff1a…




阅读更多...

















Eclipse快捷键 10个最有用的快捷键








Eclipse快捷键 10个最有用的快捷键




Eclipse中10个最有用的快捷键组合 一个Eclipse骨灰级开发者总结了他认为最有用但又不太为人所知的快捷键组合。通过这些组合可以更加容易的浏览源代码&#xff0c;使得整体的开发效率和质量得到提升。 1. ctrlshiftr&#xff1a;打开资源 这可能是所有快捷键组合中最省时间的了…




阅读更多...

















iOS 检查指定日期是否在当前日期之前








iOS 检查指定日期是否在当前日期之前




iOS检查指定日期是否在当前日期之前, 直接上代码: - (BOOL)checkProductDate: (NSString *)tempDate {NSDateFormatter *dateFormatter  [[NSDateFormatter alloc] init];[dateFormatter setDateFormat:"yyyy-MM-dd"];NSDate *date  [dateFormatter dateFromString:t…




阅读更多...

















Pytorch基础（四）—— 卷积层








Pytorch基础（四）—— 卷积层




一、概念 
卷积从数学的角度讲是一种矩阵的运算方法。我们可以用一个卷积核对一个矩阵进行卷积运算&#xff0c;具体运算过程图示可以见pytorch官网。   
卷积运算按输入数据的通道数可分为单通道和多通道两种。 单通道是指卷积核只有一个的情况。 多通道包括两种。 分别是单个…




阅读更多...

















【图像处理】——创建一个新的图片








【图像处理】——创建一个新的图片




方法一:直接复制一个已经存在的图片 
img.copy() 
如果是想生成一个指定大小的图片，则可以通过numpy数组进行创建 
方法二：通过numpy创建（注意有坑） 
img = numpy.zeros((h,w))#h,w是指定的图像的高和宽，这样看似可以其实不然上述方法得到的图像不是8位的，但是图像数组的…




阅读更多...

















BUAA  更大公约数








BUAA  更大公约数




题目链接 给一个n*m的矩阵&#xff0c; 删除里面的一行一列&#xff0c; 使得剩下的数的最大公约数最大。 一个格子&#xff08;x&#xff0c;y&#xff09;&#xff0c; 先预处理出&#xff08;1,1)到这个格子的内所有数的最大公约数&#xff0c; 同理处理出(1, m), (n, m), (…




阅读更多...

















How to make a Logical Volume ON AIX5.3








How to make a Logical Volume ON AIX5.3




本文转自 xkdcc 51CTO博客&#xff0c;原文链接&#xff1a;http://blog.51cto.com/brantc/116431&#xff0c;如需转载请自行联系原作者1.       确定要建立的卷大小&#xff0c;比如700M 2.       检查要建立逻辑卷的卷组上的PP大小&#xff08;PP:物理分区&#xff0c;PP si…




阅读更多...

















启动Tomcat 7一闪而过的问题








启动Tomcat 7一闪而过的问题




点击bin目录&#xff08;"D:\apache-tomcat-7.0.33\bin"&#xff09;下的startup.bat一闪而过&#xff0c;什么都没发生... 解决&#xff1a;环境变量里配置一个JAVA_HOME&#xff0c;值为JDK的home目录&#xff08;"D:\Java\jdk1.7.0_80"&#xff09;转载…




阅读更多...

















Pytorch基础（五）—— 池化层








Pytorch基础（五）—— 池化层




一、概念 
池化就是把数据压缩的过程&#xff0c;属于下采样的一种方法&#xff0c;可以显著降低神经网络计算复杂度&#xff0c;减少训练中的过拟合&#xff0c;同时可以使数据具有一定的不变性。 
池化从方法上来讲可以分为average Pooling、max Pooling、Overlapping Poolin…




阅读更多...

















【图像处理】——鼠标点击图像的一处，获得点击点的坐标值








【图像处理】——鼠标点击图像的一处，获得点击点的坐标值




import cv2
import numpy as np# 图片路径
img = cv2.imread(5-.jpg)
a = []
b = []def on_EVENT_LBUTTONDOWN(event, x, y, flags, param)::param event: 鼠标事件:param x: 点击点的横坐标:param y: #点击点的纵坐标:param flags: :param param: :return: if event == cv2.EV…




阅读更多...

















解决sybase数据库的死锁问题








解决sybase数据库的死锁问题




在使用数据库操作时&#xff0c;由于多人同时使用&#xff0c;导致数据库某些表无法访问&#xff0c;原因可能是由于多个用户操作同一个表&#xff0c;争抢统一资源出现死锁现象&#xff0c;现将解决死锁的方法总结如下&#xff1a; 1、执行  sp_who 语句&#xff0c;观察执行结…




阅读更多...


















最新文章


















Copyright @ 2022~2023