形态学操作是指基于形状的一系列图像处理操作,包括膨胀,腐蚀,二值化,开运算,闭运算,顶帽算法,黑帽算法,形态学梯度等,最基本的形态学操作就是膨胀和腐蚀.

一.膨胀

首先需要明确一个概念,膨胀和腐蚀都是针对于图像中较亮的区域而言的,膨胀就是亮的区域变多了,而腐蚀就是暗的区域变多了.

膨胀的功能主要有消除噪声,分割出独立的图像元素,在图像操作的时候,有时候需要对图像中的某些形状进行检测,而这些形状相互连接在一起,不好分开检测,膨胀就能切开这些形状(很小的连接位置),或者图像中有很小块的黑斑,或许是相机上的影响,膨胀,也能消除这些小的黑斑

膨胀的基本思路就是图像与一个核函数进行卷积,并取出结果中的极大值作为结果,使得图像中的高亮区域增长.这个核的形状,锚点都可以进行设置,OPENCV提供了API供我们获得核.

API:Mat getStructuringElement(int 内核形状,Size 内核尺寸,Point 锚点位置)

注:内核形状可以取方形MORPH_RECT,十字形MORPH_CROSS,椭圆形MORPH_ELLIPSE

锚点位置默认值Point(-1,-1),取形状的中心

通过该API就可以获得相应的计算核,接下来计算膨胀的函数为

API:void dilate(源图像,目标图像,膨胀核,锚点,int 迭代次数,int边界模式,int 边界为常数时边界值)

注:该API支持in_place(源图像可以做目的图像参数,算法会修改源图像内数据),迭代次数默认为1

例子如下

  1. Mat srcImage;
  2. //膨胀
  3. const int g_dilateIterMax = 100;//迭代次数
  4. int g_nDilateIterValue;
  5. const int g_dilateCoreMax = 100;//核大小
  6. int g_nDilateCoreValue;
  7. Mat dilateImage;
  8. void OnDilateIterTrackbar(int pos,void* userData);
  9. void onDilateCoreSizeTrackBar(int pos,void* userData);
  10.  
  11. int main(int argc,char* argv)
  12. {
  13. 	srcImage = imread("F:\\opencv\\OpenCVImage\\erode_dilate.jpg");
  14. 	namedWindow("src image");
  15. 	namedWindow("dilate image");
  16.  
  17. 	g_nDilateIterValue = 1;
  18. 	g_nDilateCoreValue = 5;
  19. 	createTrackbar("inter count", "dilate image", &g_nDilateIterValue, g_dilateIterMax,OnDilateIterTrackbar);
  20. 	createTrackbar("core size", "dilate image", &g_nDilateCoreValue, g_dilateCoreMax,onDilateCoreSizeTrackBar);
  21. 	OnDilateIterTrackbar(g_nDilateIterValue,0);
  22.  
  23. 	moveWindow("src image", 0, 0);
  24. 	moveWindow("dilate image", srcImage.cols, 0);
  25.  
  26. 	imshow("src image", srcImage);
  27.  
  28. 	waitKey(0);
  29. 	return 0;
  30. }
  31.  
  32. //调整迭代次数
  33. void OnDilateIterTrackbar(int pos,void* userData)
  34. {
  35.    if(pos == 0||g_nDilateCoreValue == 0)
  36.    {
  37.        imshow("dilate image", srcImage);
  38.    }
  39.    else
  40.    {
  41.        if(g_nDilateCoreValue%2 == 0)
  42.        {
  43.            g_nDilateCoreValue++;
  44.        }
  45.        Mat core = getStructuringElement(MORPH_RECT, Size(g_nDilateCoreValue,g_nDilateCoreValue));
  46.        dilate(srcImage, dilateImage, core,Point(-1,-1),g_nDilateIterValue);
  47.        imshow("dilate image", dilateImage);
  48.    }
  49. }
  50.  
  51. //调整核大小
  52. void onDilateCoreSizeTrackBar(int pos,void* userData)
  53. {
  54.    if(pos == 0 || g_nDilateIterValue == 0)
  55.    {
  56.        imshow("dilate image", srcImage);
  57.    }
  58.    else
  59.    {
  60.        if(g_nDilateCoreValue%2 == 0)
  61.        {
  62.            g_nDilateCoreValue++;
  63.        }
  64.        Mat core = getStructuringElement(MORPH_RECT, Size(g_nDilateCoreValue,g_nDilateCoreValue));
  65.        dilate(srcImage, dilateImage, core,Point(-1,-1),g_nDilateIterValue);
  66.        imshow("dilate image", dilateImage);
  67.    }
  68. }

　　

二.腐蚀

腐蚀与膨胀正好相反,是求局部最小值的操作,亮的地方会减少,黑的地方会增多,在图像中连接接近的区域,消除高亮造成的噪声

API: void erode(源,目的,核,锚点,迭代次数,边缘类型,边缘为常数时边界值);

注:腐蚀和膨胀API的形式一致

使用代码

  1. //腐蚀
  2. Mat srcImage;
  3. const int g_erodeIterMax = 100;
  4. int g_nErodeIterValue;
  5. const int g_erodeCoreMax = 100;
  6. int g_nErodeCoreValue;
  7. Mat erodeImage;
  8. void OnErodeIterTrackbar(int pos,void* userData);
  9. void onErodeCoreSizeTrackBar(int pos,void* userData);
  10.  
  11. int main(int argc,char* argv)
  12.  
  13. {
  14. 	srcImage = imread("F:\\opencv\\OpenCVImage\\erode_dilate.jpg");
  15. 	namedWindow("src image");
  16.     namedWindow("erode image");
  17.  
  18.    g_nErodeIterValue = 1;
  19.    g_nErodeCoreValue = 5;
  20.    createTrackbar("inter count", "erode image", &g_nErodeIterValue, g_erodeIterMax,OnErodeIterTrackbar);
  21.    createTrackbar("core size", "erode image", &g_nErodeCoreValue, g_erodeCoreMax,onErodeCoreSizeTrackBar);
  22.    OnErodeIterTrackbar(g_nErodeIterValue, 0);
  23.  
  24. 	moveWindow("src image", 0, 0);
  25.     moveWindow("erode image", srcImage.cols, 0);
  26.  
  27. 	imshow("src image", srcImage);
  28. 	waitKey(0);
  29. 	return 0;	
  30.  
  31. }
  32.  
  33. //调整迭代次数
  34. void OnErodeIterTrackbar(int pos,void* userData)
  35. {
  36.    if(pos == 0 || g_nErodeCoreValue == 0)
  37.    {
  38.        imshow("erode image", srcImage);
  39.    }
  40.    else
  41.    {
  42.        if(g_nErodeCoreValue%2 == 0)
  43.        {
  44.            g_nErodeCoreValue++;
  45.        }
  46.        Mat core = getStructuringElement(MORPH_RECT, Size(g_nErodeCoreValue,g_nErodeCoreValue),Point(-1,-1));
  47.        erode(srcImage, erodeImage, core,Point(-1,-1),g_nErodeIterValue);
  48.        imshow("erode image", erodeImage);
  49.    }
  50. }
  51. //调整核大小
  52. void onErodeCoreSizeTrackBar(int pos,void* userData)
  53. {
  54.    if(pos == 0 || g_nErodeIterValue == 0)
  55.    {
  56.        imshow("erode image", srcImage);
  57.    }
  58.    else
  59.    {
  60.        if(g_nErodeCoreValue%2 == 0)
  61.        {
  62.            g_nErodeCoreValue++;
  63.        }
  64.        Mat core = getStructuringElement(MORPH_RECT, Size(g_nErodeCoreValue,g_nErodeCoreValue),Point(-1,-1));
  65.        erode(srcImage, erodeImage, core,Point(-1,-1),g_nErodeIterValue);
  66.        imshow("erode image", erodeImage);
  67.    }
  68. }

　　

三.形态学滤波算法

形态学的高级操作,往往都建立在基础的膨胀和腐蚀的操作之上

1.开运算:开运算是一个先腐蚀,后膨胀的过程,用于在图像中消除小的物体,在纤细点处分离物体,在平滑化较大的物体的边界的同时不明显改变物体的体积.

2.闭运算:先膨胀后腐蚀的过程,能够用于消除物体中的小型黑洞

3.形态学梯度:膨胀图和腐蚀图之差,对二值图像进行这一操作,可以将团块的边缘突出来,可以使用形态学梯度来保留物体的边缘轮廓.

4.顶帽:源图像和开运算的结果的差值,往往用来分离比邻近点亮一点的斑块,在一幅图具体大幅的背景,而微小物体有比较有规律的情况下,可以使用top_hat运算进行背景的提取

5.黑帽:闭运算的结果与源图像之差,突出了比源图像轮廓周围更暗的区域,往往用于分离比邻近点暗一些的斑块.

核心API:void morpholgyEx(源,目标,int 形态学操作标志,mat 形态学操作内核,Point 锚点,int 迭代次数,int 边界模式,int 边界为常数时的边界值).

注:形态学操作标志的取值如下:MORPH_OPEN开运算  MORPH_CLOSE 闭运算 MORPH_GRENIENT 形态学梯度 MORPH_TOPHAT顶帽 MORPH_BLACKHAT黑帽 MORPH_ERODE腐蚀 MORPH_DILATE 膨胀

形态学操作内核就是前面膨胀腐蚀使用的内核.

使用范例如下:

1.开运算 闭运算 形态学梯度三者联合

  1. //源¡ä图ª?像?
  2. Mat srcImage;
  3.  
  4. //开a运?算?
  5. const int g_openIterMax = 100;
  6. int g_nopenIterValue;
  7. const int g_openCoreMax = 100;
  8. int g_nopenCoreValue;
  9. Mat openImage;
  10. void OnopenIterTrackbar(int pos,void* userData);
  11. void onopenCoreSizeTrackBar(int pos,void* userData);
  12.  
  13. //闭À?运?算?
  14. const int g_closeIterMax = 100;
  15. int g_ncloseIterValue;
  16. const int g_closeCoreMax = 100;
  17. int g_ncloseCoreValue;
  18. Mat closeImage;
  19. void OncloseIterTrackbar(int pos,void* userData);
  20. void oncloseCoreSizeTrackBar(int pos,void* userData);
  21.  
  22. //形?态¬?学¡ì梯¬Y度¨¨
  23. const int g_gredientIterMax = 100;
  24. int g_ngredientIterValue;
  25. const int g_gredientCoreMax = 100;
  26. int g_ngredientCoreValue;
  27. Mat gredientImage;
  28. void OngredientIterTrackbar(int pos,void* userData);
  29. void ongredientCoreSizeTrackBar(int pos,void* userData);
  30.  
  31. int main(int argc,char* argv[])
  32. {
  33.    srcImage = imread("F:\\opencv\\OpenCVImage\\morpholgy.jpg");
  34.  
  35.    g_nopenIterValue = 1;
  36.    g_nopenCoreValue = 5;
  37.    namedWindow("open image");
  38.    createTrackbar("iter count", "open image", &g_nopenIterValue, g_openIterMax,OnopenIterTrackbar,0);
  39.    createTrackbar("core size", "open image", &g_nopenCoreValue, g_openCoreMax,onopenCoreSizeTrackBar,0);
  40.    onopenCoreSizeTrackBar(g_nopenCoreValue, 0);
  41.  
  42.    g_ncloseCoreValue = 5;
  43.    g_ncloseIterValue = 1;
  44.    namedWindow("close image");
  45.    createTrackbar("iter count", "close image", &g_ncloseIterValue, g_closeIterMax,OncloseIterTrackbar,0);
  46.    createTrackbar("core size", "close image", &g_ncloseCoreValue, g_closeCoreMax,oncloseCoreSizeTrackBar,0);
  47.    oncloseCoreSizeTrackBar(g_ncloseCoreValue, 0);
  48.  
  49.    g_ngredientCoreValue = 5;
  50.    g_ngredientIterValue = 1;
  51.    namedWindow("gredient image");
  52.    createTrackbar("iter count", "gredient image", &g_ngredientIterValue, g_gredientIterMax,OngredientIterTrackbar,0);
  53.    createTrackbar("core size", "gredient image", &g_ngredientCoreValue, g_gredientCoreMax,OngredientIterTrackbar,0);
  54.    OngredientIterTrackbar(g_ngredientIterValue, 0);
  55.  
  56.    imshow("src image", srcImage);
  57.  
  58.    moveWindow("src image", 0, 0);
  59.    moveWindow("open image", srcImage.cols, 0);
  60.    moveWindow("close image", srcImage.cols*2, 0);
  61.    moveWindow("gredient image", srcImage.cols*3, 0);
  62.  
  63.    waitKey(0);
  64.    return 0;
  65. }
  66.  
  67. void OnopenIterTrackbar(int pos,void* userData)
  68. {
  69.    if(g_nopenCoreValue == 0||g_nopenIterValue == 0)
  70.    {
  71.        imshow("open image", srcImage);
  72.    }
  73.    else
  74.    {
  75.        if(g_nopenCoreValue%2 == 0)
  76.            g_nopenCoreValue++;
  77.        Mat core = getStructuringElement(MORPH_RECT, Size(g_nopenCoreValue,g_nopenCoreValue));
  78.        morphologyEx(srcImage, openImage, MORPH_OPEN, core,Point(-1,-1),g_nopenIterValue);
  79.        imshow("open image", openImage);
  80.    }
  81. }
  82. void onopenCoreSizeTrackBar(int pos,void* userData)
  83. {
  84.    if(g_nopenCoreValue == 0||g_nopenIterValue == 0)
  85.    {
  86.        imshow("open image", srcImage);
  87.    }
  88.    else
  89.    {
  90.        if(g_nopenCoreValue%2 == 0)
  91.            g_nopenCoreValue++;
  92.        Mat core = getStructuringElement(MORPH_RECT, Size(g_nopenCoreValue,g_nopenCoreValue));
  93.        morphologyEx(srcImage, openImage, MORPH_OPEN, core,Point(-1,-1),g_nopenIterValue);
  94.        imshow("open image", openImage);
  95.    }
  96. }
  97. void OncloseIterTrackbar(int pos,void* userData)
  98. {
  99.    if(g_ncloseCoreValue == 0||g_ncloseIterValue == 0)
  100.    {
  101.        imshow("close image", srcImage);
  102.    }
  103.    else
  104.    {
  105.        if(g_ncloseCoreValue%2 == 0)
  106.            g_ncloseCoreValue++;
  107.        Mat core = getStructuringElement(MORPH_RECT, Size(g_ncloseCoreValue,g_ncloseCoreValue));
  108.        morphologyEx(srcImage, closeImage, MORPH_CLOSE, core,Point(-1,-1),g_ncloseIterValue);
  109.        imshow("close image", closeImage);
  110.    }
  111. }
  112. void oncloseCoreSizeTrackBar(int pos,void* userData)
  113. {
  114.    if(g_ncloseCoreValue == 0||g_ncloseIterValue == 0)
  115.    {
  116.        imshow("close image", srcImage);
  117.    }
  118.    else
  119.    {
  120.        if(g_ncloseCoreValue%2 == 0)
  121.            g_ncloseCoreValue++;
  122.        Mat core = getStructuringElement(MORPH_RECT, Size(g_ncloseCoreValue,g_ncloseCoreValue));
  123.        morphologyEx(srcImage, closeImage, MORPH_CLOSE, core,Point(-1,-1),g_ncloseIterValue);
  124.        imshow("close image", closeImage);
  125.    }
  126. }
  127. void OngredientIterTrackbar(int pos,void* userData)
  128. {
  129.    if(g_ngredientCoreValue == 0||g_ngredientIterValue == 0)
  130.    {
  131.        imshow("gredient image", srcImage);
  132.    }
  133.    else
  134.    {
  135.        if(g_ngredientCoreValue%2 == 0)
  136.            g_ngredientCoreValue++;
  137.        Mat core = getStructuringElement(MORPH_RECT, Size(g_ngredientCoreValue,g_ngredientCoreValue));
  138.        morphologyEx(srcImage, gredientImage, MORPH_GRADIENT, core,Point(-1,-1),g_ngredientIterValue);
  139.        imshow("gredient image", gredientImage);
  140.    }
  141. }
  142. void ongredientCoreSizeTrackBar(int pos,void* userData)
  143. {
  144.    if(g_ngredientCoreValue == 0||g_ngredientIterValue == 0)
  145.    {
  146.        imshow("gredient image", srcImage);
  147.    }
  148.    else
  149.    {
  150.        if(g_ngredientCoreValue%2 == 0)
  151.            g_ngredientCoreValue++;
  152.        Mat core = getStructuringElement(MORPH_RECT, Size(g_ngredientCoreValue,g_ngredientCoreValue));
  153.        morphologyEx(srcImage, gredientImage, MORPH_GRADIENT, core,Point(-1,-1),g_ngredientIterValue);
  154.        imshow("gredient image", gredientImage);
  155.    }
  156. }

　　

2. 顶帽 黑帽结合

  1. Mat srcImage;
  2.  
  3. //顶£¤帽¡À tophat
  4. const int g_tophatIterMax = 100;
  5. int g_ntophatIterValue;
  6. const int g_tophatCoreMax = 100;
  7. int g_ntophatCoreValue;
  8. Mat tophatImage;
  9. void OntophatIterTrackbar(int pos,void* userData);
  10. void ontophatCoreSizeTrackBar(int pos,void* userData);
  11.  
  12. //黑¨²帽¡À
  13. const int g_blackhatIterMax = 100;
  14. int g_nblackhatIterValue;
  15. const int g_blackhatCoreMax = 100;
  16. int g_nblackhatCoreValue;
  17. Mat blackhatImage;
  18. void OnblackhatIterTrackbar(int pos,void* userData);
  19. void onblackhatCoreSizeTrackBar(int pos,void* userData);
  20.  
  21. int main(int argc,char* argv[])
  22. {
  23.    srcImage = imread("F:\\opencv\\OpenCVImage\\morpholgy.jpg");
  24.  
  25.    g_ntophatIterValue = 1;
  26.    g_ntophatCoreValue = 5;
  27.    namedWindow("tophat image");
  28.    createTrackbar("iter count", "tophat image", &g_ntophatIterValue, g_tophatIterMax,OntophatIterTrackbar,0);
  29.    createTrackbar("core size", "tophat image", &g_ntophatCoreValue, g_tophatCoreMax,ontophatCoreSizeTrackBar,0);
  30.    ontophatCoreSizeTrackBar(g_ntophatCoreValue, 0);
  31.  
  32.    g_nblackhatCoreValue = 5;
  33.    g_nblackhatIterValue = 1;
  34.    namedWindow("blackhat image");
  35.    createTrackbar("iter count", "blackhat image", &g_nblackhatIterValue, g_blackhatIterMax,OnblackhatIterTrackbar,0);
  36.    createTrackbar("core size", "blackhat image", &g_nblackhatCoreValue, g_blackhatCoreMax,onblackhatCoreSizeTrackBar,0);
  37.    onblackhatCoreSizeTrackBar(g_nblackhatCoreValue, 0);
  38.  
  39.    imshow("src image", srcImage);
  40.  
  41.    moveWindow("src image", 0, 0);
  42.    moveWindow("tophat image", srcImage.cols, 0);
  43.    moveWindow("blackhat image", srcImage.cols*2, 0);
  44.  
  45.    waitKey(0);
  46.    return 0;
  47. }
  48.  
  49. void OntophatIterTrackbar(int pos,void* userData)
  50. {
  51.    if(g_ntophatCoreValue == 0||g_ntophatIterValue == 0)
  52.    {
  53.        imshow("tophat image", srcImage);
  54.    }
  55.    else
  56.    {
  57.        if(g_ntophatCoreValue%2 == 0)
  58.            g_ntophatCoreValue++;
  59.        Mat core = getStructuringElement(MORPH_RECT, Size(g_ntophatCoreValue,g_ntophatCoreValue));
  60.        morphologyEx(srcImage, tophatImage, MORPH_TOPHAT, core,Point(-1,-1),g_ntophatIterValue);
  61.        imshow("tophat image", tophatImage);
  62.    }
  63. }
  64. void ontophatCoreSizeTrackBar(int pos,void* userData)
  65. {
  66.    if(g_ntophatCoreValue == 0||g_ntophatIterValue == 0)
  67.    {
  68.        imshow("tophat image", srcImage);
  69.    }
  70.    else
  71.    {
  72.        if(g_ntophatCoreValue%2 == 0)
  73.            g_ntophatCoreValue++;
  74.        Mat core = getStructuringElement(MORPH_RECT, Size(g_ntophatCoreValue,g_ntophatCoreValue));
  75.        morphologyEx(srcImage, tophatImage, MORPH_TOPHAT, core,Point(-1,-1),g_ntophatIterValue);
  76.        imshow("tophat image", tophatImage);
  77.    }
  78. }
  79.  
  80. void OnblackhatIterTrackbar(int pos,void* userData)
  81. {
  82.    if(g_nblackhatCoreValue == 0||g_nblackhatIterValue == 0)
  83.    {
  84.        imshow("blackhat image", srcImage);
  85.    }
  86.    else
  87.    {
  88.        if(g_nblackhatCoreValue%2 == 0)
  89.            g_nblackhatCoreValue++;
  90.        Mat core = getStructuringElement(MORPH_RECT, Size(g_nblackhatCoreValue,g_nblackhatCoreValue));
  91.        morphologyEx(srcImage, blackhatImage, MORPH_BLACKHAT, core,Point(-1,-1),g_nblackhatIterValue);
  92.        imshow("blackhat image", blackhatImage);
  93.    }
  94. }
  95. void onblackhatCoreSizeTrackBar(int pos,void* userData)
  96. {
  97.    if(g_nblackhatCoreValue == 0||g_nblackhatIterValue == 0)
  98.    {
  99.        imshow("blackhat image", srcImage);
  100.    }
  101.    else
  102.    {
  103.        if(g_nblackhatCoreValue%2 == 0)
  104.            g_nblackhatCoreValue++;
  105.        Mat core = getStructuringElement(MORPH_RECT, Size(g_nblackhatCoreValue,g_nblackhatCoreValue));
  106.        morphologyEx(srcImage, blackhatImage, MORPH_BLACKHAT, core,Point(-1,-1),g_nblackhatIterValue);
  107.        imshow("blackhat image", blackhatImage);
  108.    }
  109. }

　　

OPENCV形态学操作1的更多相关文章

  1. opencv::形态学操作

    形态学操作 开操作- open 闭操作- close 形态学梯度- Morphological Gradient 顶帽 – top hat 黑帽 – black hat 开操作- open 先腐蚀后膨 ...

  2. opencv 形态学操作应用-提取水平与垂直线

    adaptiveThreshold(~gray_src, binImg, , ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, , -); #include <ope ...

  3. OpenCV学习笔记（六） 滤波器 形态学操作（腐蚀、膨胀等）

    转自:OpenCV 教程 另附:计算机视觉:算法与应用(2012),Learning OpenCV(2009) 平滑图像:滤波器 平滑 也称 模糊, 是一项简单且使用频率很高的图像处理方法.平滑处理的 ...

  4. OpenCV 图象腐蚀形态学操作 全家桶

    图象腐蚀与形态学操作 opencv 1. 通过调用库函数实现图像的腐蚀.膨胀: 2. 通过设置结构元素.元素大小.形态学操作类型实现对图象的形态学操作. 源码(VS2017+OpenCV 4.0) # ...

  5. 【图像处理】OpenCV+Python图像处理入门教程（七）图像形态学操作

    图像形态学主要从图像内提取分量信息,该分量信息通常对表达图像的特征具有重要意义.例如,在车牌号码识别中,能够使用形态学计算其重要特征信息,在进行识别时,只需对这些特征信息运算即可.图像形态学在目标视觉 ...

  6. opencv学习笔记(五)----图像的形态学操作

    图像的形态学操作有基本的腐蚀和膨胀操作和其余扩展形态学变换操作(高级操作)-----开运算,闭运算,礼帽(顶帽)操作,黑帽操作...(主要也是为了去噪声,改善图像) 形态学操作都是用于处理二值图像(其 ...

  7. EasyPR--开发详解（4）形态学操作、尺寸验证、旋转等操作

    在上一篇深度分析与调优讨论中,我们介绍了高斯模糊,灰度化和Sobel算子.在本文中,会分析剩余的定位步骤. 根据前文的内容,车牌定位的功能还剩下如下的步骤,见下图中未涂灰的部分. 图1 车牌定位步骤 ...

  8. opencv6.1-imgproc图像处理模块之平滑与形态学操作

    这个部分是<opencv-tutorials.pdf>的部分,这部分也是几大部分中例子最多的,其实这个教程的例子都很不错,不过有些看得出来还是c接口的例子,说明例子有些年头了,其实在&qu ...

  9. OpenCV-Python：形态学操作

    常用的形态学操作:腐蚀.膨胀.开运算和闭运算 一.什么叫形态学操作 形态学操作就是改变物体的形状,比如腐蚀就是"变瘦",膨胀就是"变胖" 形态学操作一般作用于二 ...

随机推荐

  1. Ubuntu配置eclipse

    1.安装jdk 去官网下载最新版jdk,目前是 jdk-8u45-linux-x64.tar.gz 创建Java的目标路径文件夹,这里我们放在/usr/lib/jvm下面.在终端下操作: sudo m ...

  2. IO流的操作规律

    输入流和输出流相对于内存设备而言. 将外设中的数据读取到内存中:输入将内存的数写入到外设中:输出. 字符流的由来:其实就是:字节流读取文字字节数据后,不直接操作而是先查指定的编码表.获取对应的文字.在 ...

  3. 异步加载AsyncTask

    private void huodeshuju() {        new AsyncTask<String, Void, String>() {            @Overrid ...

  4. AsyncTask异步加载和HttpURLConnection网络请求数据

    //获得网络数据    private void huodeshuju() { //这里是使用线程,已注释掉        /*new Thread(){            public void ...

  5. 用python计算md5,sha1,crc32

    Linux下计算md5sum,sha1sum,crc: 命令 输出 $md5sum hello f19dd746bc6ab0f0155808c388be8ff0  hello $sha1sum hel ...

  6. HDU1896Stones(优先队列)

    Stones Time Limit : 5000/3000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other) Total Submis ...

  7. java 接口参数

    Example6_5.java interface SpeakHello { void speakHello(); } class Chinese implements SpeakHello { pu ...

  8. 当浏览器窗体改变时，div跟着变动方法

    $(function(){ resizeU(); $(window).resize(resizeU); }); function resizeU() { var divkuangH = $(windo ...

  9. 服务器 vps 空间

    服务器 服务器是一台独立的机器,拥有独立的ip,磁盘空间,内存空间,可以认为是一台功能强大的电脑. VPS VPS是利用虚拟化技术将服务器虚拟成多台服务器,独立的ip,磁盘空间,内存空间,服务器的vp ...

  10. jsp如果超过字数就变成...

    <script> var infoTitle = '<ww:property value="infoTitle"/>'; if(infoTitle.leng ...