二维区域扫描线填充算法的实现

最新推荐文章于 2023-06-07 17:37:16 发布
最新推荐文章于 2023-06-07 17:37:16 发布
阅读量1.2w 收藏 1
点赞数
分类专栏： WIN32 编程 文章标签： 算法 null callback winapi button application
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anyue417/article/details/910934
版权

                                                           二维区域扫描线填充算法的实现
  这个程序从一放暑假就开始做，直做到今天，花了1个星期的时间，真是不应该啊，唉，谁让咱编程技术不太好呢，得，闲话少说。
  关于区域填充，我们常用的算法有扫描线填充算法以及种子填充算法，我现在只完成了前一种，后一种等过两天实现之，扫描算法的理解不难，可是实现起来有许多细节问题还是有点烦琐，下面这个是非常粗糙的一个版本，只能说是实现了所需，代码一点也不好，到处充斥着各种命名模糊的变量，又不很多注释，谁要是想看，那肯定费很大劲，不过整体结构是正确的。我本来想把整个算法详细地一步一步列出来，可是要讲解算法的话，还要画很多图，还要贴上来，就此做罢，如果谁也在做这个程序，就在下面留下评论即可，我一定在最短时间内给你回复。下面是我的代码，直接CTRL+V到VC6中就可以看到效果了：
  (通过这个程序我还发现，当代码一上500行，变量就开始混淆了，尤其是用来控制循环的那些小变量，还有就是在这个程序中我初步使用了VC6的调试功能 ，确实非常方便，但还有些功能不清楚，唉，慢慢来吧)

下面是一个简单的填充效果：


///

#include<windows.h>  
#include<math.h>

#define FILLING    1
#define RESET      2

typedef struct        
{
 int xStart,yStart;      
 int xEnd,yEnd;         
}LINE,*PLINE;

LINE lines[100];
LINE line;
static int  j=0;
POINT draw_refresh[1000];
static int  l=0;


LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE prevInstance,PSTR szCmdLine,int iCmdShow)
{
 static TCHAR szAppName[]="2D Region Filling"; 
 HWND hwnd;          
 MSG  msg;          
 WNDCLASS wndclass;
 
 for(int i=0;i<100;i++)
 {
  lines[i].xStart=0;
  lines[i].yStart=0;
  lines[i].xEnd=0;
  lines[i].yEnd=0;
 }

 wndclass.style=CS_HREDRAW | CS_VREDRAW |CS_DBLCLKS;   
 wndclass.lpfnWndProc=WndProc;     
 wndclass.cbClsExtra=0;       
 wndclass.cbWndExtra=0;       
 wndclass.hInstance=hInstance;     
 wndclass.hIcon=LoadIcon(NULL,IDI_APPLICATION); 
 wndclass.hCursor=LoadCursor(NULL,IDC_CROSS); 
 wndclass.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);
 wndclass.lpszMenuName=NULL;      
 wndclass.lpszClassName=szAppName;    

 if(!RegisterClass(&wndclass))
 {
  MessageBox(NULL,"Regist window class failed!","Error",MB_OK);
 }
 hwnd=CreateWindow(szAppName,"2D Region Filling",WS_OVERLAPPED | WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,NULL,NULL,hInstance,NULL);
 ShowWindow(hwnd,iCmdShow);      
 UpdateWindow(hwnd);        

 while(GetMessage(&msg,NULL,0,0))    
 {
  TranslateMessage(&msg);      
  DispatchMessage(&msg);      
 }
 return msg.wParam;        
}


LRESULT CALLBACK WndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
{    
 HWND hButtonFilling;
 HWND hButtonReset;

 int cxChar=0;
 int cyChar=0;

 static PLINE head=lines;
 
 int i=0;
        
 HDC hdc;         
 PAINTSTRUCT ps; 
 RECT clientrect;

 POINT need_draw={0,0};
 POINT draw[100];
 int b=0;
 static int filled=0;

 for(int e=0;e<100;e++)
 {
  draw[e].x=0;
  draw[e].y=0;
 }

 int k=0;
 int smallest_y=0;
 int lardgest_y=0;

 int m=0;
 int n=0;
 int h=0;

 int x=0;

 int x1=0;
 int x2=0;
 int y1=0;
 int y2=0;


 int a=0;
 int c=0;

 int flag=0;

 switch(message)         
 {
 case WM_CREATE:
  cxChar=LOWORD(GetDialogBaseUnits());
  cyChar=HIWORD(GetDialogBaseUnits());
  hButtonFilling=CreateWindow(TEXT("BUTTON"),"Filling",   WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,40*cxChar,28*cyChar,20*cxChar,7*cyChar/4,hwnd,(HMENU)FILLING,   ((LPCREATESTRUCT)lParam)->hInstance,NULL);
  hButtonReset   =CreateWindow(TEXT("BUTTON"),"Reset",     WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,70*cxChar,28*cyChar,20*cxChar,7*cyChar/4,hwnd,(HMENU)RESET,     ((LPCREATESTRUCT)lParam)->hInstance,NULL);
  return 0;
 case WM_LBUTTONDOWN:
//  SetCapture(hwnd);
  line.xStart=(int)LOWORD(lParam);
  line.yStart=(int)HIWORD(lParam);
  for(i=0;j>=1 && i<=j-1;i++)
  {   
   if((line.xStart>lines[i].xStart-30) && (line.xStart<lines[i].xStart+30) && (line.yStart>lines[i].yStart-30) && (line.yStart<lines[i].yStart+30))
   {
    line.xStart=lines[i].xStart;
    line.yStart=lines[i].yStart;
   }
   else if((line.xStart>lines[i].xEnd-30) && (line.xStart<lines[i].xEnd+30) &&(line.yStart>lines[i].yEnd-30) && (line.yStart<lines[i].yEnd+30))
   {
    line.xStart=lines[i].xEnd;
    line.yStart=lines[i].yEnd;
   }
  }
  return 0;
 case WM_MOUSEMOVE:
  if(wParam & MK_LBUTTON)
  {
   hdc=GetDC(hwnd);
   SelectObject(hdc,GetStockObject(WHITE_PEN));
   if(line.xEnd!=0 && line.yEnd!=0)
   {
    MoveToEx(hdc,line.xStart,line.yStart,NULL);
    LineTo(hdc,line.xEnd,line.yEnd);
   }
   
   line.xEnd=(int)LOWORD(lParam);
   line.yEnd=(int)HIWORD(lParam);

   SelectObject(hdc,GetStockObject(BLACK_PEN));

   MoveToEx(hdc,line.xStart,line.yStart,NULL);
   LineTo(hdc,line.xEnd,line.yEnd);
   InvalidateRect(hwnd,NULL,FALSE);
   ReleaseDC(hwnd,hdc);
  }
  return 0;
 case WM_LBUTTONUP:
  line.xEnd=LOWORD(lParam);
  line.yEnd=HIWORD(lParam);
  for(i=0;j>=1 && i<=j-1;i++)
  {   
   if((line.xEnd>lines[i].xStart-30) && (line.xEnd<lines[i].xStart+30) && (line.yEnd>lines[i].yStart-30) && (line.yEnd<lines[i].yStart+30))
   {
    hdc=GetDC(hwnd);

    SelectObject(hdc,GetStockObject(WHITE_PEN));//clear the last black line if find a adjacent vetex
    MoveToEx(hdc,line.xStart,line.yStart,NULL);
    LineTo(hdc,line.xEnd,line.yEnd);
    

    line.xEnd=lines[i].xStart;
    line.yEnd=lines[i].yStart;

    SelectObject(hdc,GetStockObject(BLACK_PEN));

    MoveToEx(hdc,line.xStart,line.yStart,NULL);
    LineTo(hdc,line.xEnd,line.yEnd);
    
    ReleaseDC(hwnd,hdc);
   }
   else if((line.xEnd>lines[i].xEnd-30) && (line.xEnd<lines[i].xEnd+30) &&(line.yEnd>lines[i].yEnd-30) && (line.yEnd<lines[i].yEnd+30))
   {
    hdc=GetDC(hwnd);

    SelectObject(hdc,GetStockObject(WHITE_PEN));//clear the last black line if find a adjacent vetex
    MoveToEx(hdc,line.xStart,line.yStart,NULL);
    LineTo(hdc,line.xEnd,line.yEnd);

    line.xEnd=lines[i].xEnd;
    line.yEnd=lines[i].yEnd;

    SelectObject(hdc,GetStockObject(BLACK_PEN));

    MoveToEx(hdc,line.xStart,line.yStart,NULL);
    LineTo(hdc,line.xEnd,line.yEnd);
    
    ReleaseDC(hwnd,hdc);


   }
  }
  lines[j].xStart=line.xStart;
  lines[j].yStart=line.yStart;
  lines[j].xEnd=line.xEnd;
  lines[j].yEnd=line.yEnd;
  j++;
  line.xStart=0;
  line.yStart=0;
  line.xEnd=0;
  line.yEnd=0;
//  ReleaseCapture();
  return 0;
 case WM_COMMAND:
  switch(LOWORD(wParam))
  {
  case FILLING:
   smallest_y=lines[0].yStart;
   lardgest_y=lines[0].yStart;

   for(h=0;h<=100;h++)
   {
    draw[h].x=0;
    draw[h].y=0;
   }

   filled=1;

   for(h=0;h<j;h++)//find the smallest y coordinate of the edges
   {
    if(lines[h].yStart<smallest_y)
    {
     smallest_y=lines[h].yStart;
    }
    if(lines[h].yEnd<smallest_y)
    {
     smallest_y=lines[h].yEnd;
    }
   }
   for(h=0;h<j;h++)//find the lardgest y coordinate of the edges
   {
    if(lines[h].yStart>lardgest_y)
    {
     lardgest_y=lines[h].yStart;
    }
    if(lines[h].yEnd>lardgest_y)
    {
     lardgest_y=lines[h].yEnd;
    }
   }
   for(k=smallest_y;k<=lardgest_y;k++)
   {//check every scan line to filling the region
    for(m=0;m<j;m++)
    {
     a=lines[m].yStart>lines[m].yEnd ? lines[m].yStart:lines[m].yEnd ;
     c=lines[m].yStart<lines[m].yEnd ? lines[m].yStart:lines[m].yEnd ;
   
     if(k>a)
     {
      continue;      
     }
     else if(k<c)
     {
      continue;      
     }
     else if(lines[m].yStart==lines[m].yEnd && k==lines[m].yStart)
     {
      continue;
     }
     else
     {
      x=0;
      if(lines[m].yStart==k)
      {
       for(n=0;n<j;n++)
       {
        if((n!=m) && (lines[m].yStart==lines[n].yStart))
        {
         if((lines[m].yEnd>lines[m].yStart && lines[n].yEnd>lines[m].yStart) || (lines[m].yEnd<lines[m].yStart && lines[n].yEnd<lines[m].yStart))
         {
          x=lines[m].xStart;
          draw[b].x=x;
          draw[b].y=k;
          b++;
          draw[b].x=x;
          draw[b].y=k;
          b++;
         }
         else
         {
//          MessageBox(hwnd,"error2","error2",MB_OK);
          x=lines[m].xStart;

          flag=0;
          for(h=0;h<b;h++)
          {
           if(x==draw[h].x && k==draw[h].y)
           {
            flag=1;
            break;
           }
          }
          if(flag!=1)
          {
           draw[b].x=x;
           draw[b].y=k;
           b++;
          }
         }

        }
        else if((n!=m) && (lines[m].yStart==lines[n].yEnd))
        {
         if((lines[m].yEnd>lines[m].yStart && lines[n].yStart>lines[m].yStart) || (lines[m].yEnd<lines[m].yStart && lines[n].yStart<lines[m].yStart))
         {
//          MessageBox(hwnd,"error3","error3",MB_OK);
          x=lines[m].xStart;
          draw[b].x=x;
          draw[b].y=k;
          b++;
          draw[b].x=x;
          draw[b].y=k;
          b++;
         }
         else
         {
//          MessageBox(hwnd,"error4","error4",MB_OK);
          x=lines[m].xStart;

          flag=0;
          for(h=0;h<b;h++)
          {
           if(x==draw[h].x && k==draw[h].y)
           {
            flag=1;
            break;
           }
          }
          if(flag!=1)
          {
           draw[b].x=x;
           draw[b].y=k;
           b++;
          }

         }
        }
       }
      }
      else if(lines[m].yEnd==k)
      {
       for(n=0;n<j;n++)
       {
        if(m!=n && k==lines[n].yStart )
        {
         if((lines[m].yStart>lines[m].yEnd && lines[n].yEnd>lines[m].yEnd) || (lines[m].yStart<lines[m].yEnd && lines[n].yEnd<lines[m].yEnd))
         {
//          MessageBox(hwnd,"error","error",MB_OK);
          x=lines[m].xEnd;
          draw[b].x=x;
          draw[b].y=k;
          b++;
          draw[b].x=x;
          draw[b].y=k;
          b++;
         }
         else
         {
          x=lines[m].xEnd;

          flag=0;
          for(h=0;h<b;h++)
          {
           if(x==draw[h].x && k==draw[h].y)
           {
            flag=1;
            break;
           }
          }
          if(flag!=1)
          {
           draw[b].x=x;
           draw[b].y=k;
           b++;
          }
         
         }

        }
        else if(m!=n && k==lines[n].yEnd)
        {
         if((lines[m].yStart>lines[m].yEnd && lines[n].yStart>lines[m].yEnd) || (lines[m].yStart<lines[m].yEnd && lines[n].yStart<lines[m].yEnd))
         {
          x=lines[m].xEnd;
          draw[b].x=x;
          draw[b].y=k;
          b++;
          draw[b].x=x;
          draw[b].y=k;
          b++;
         }
         else
         {
          x=lines[m].xEnd;

          flag=0;
          for(h=0;h<b;h++)
          {
           if(x==draw[h].x && k==draw[h].y)
           {
            flag=1;
            break;
           }
          }
          if(flag!=1)
          {
           draw[b].x=x;
           draw[b].y=k;
           b++;
          }

         }
        }
       }
      }
      else
      {
       if(lines[m].yStart>lines[m].yEnd)
       {
        x1=lines[m].xEnd;
        y1=lines[m].yEnd;
        x2=lines[m].xStart;
        y2=lines[m].yStart;
       }
       else if(lines[m].yStart<lines[m].yEnd)
       {
        x1=lines[m].xStart;
        y1=lines[m].yStart;
        x2=lines[m].xEnd;
        y2=lines[m].yEnd;
       }
       x=x2+(x1-x2)*(y2-k)/(y2-y1);
       draw[b].x=x;
       draw[b].y=k;
       b++;
      }
     }
    }
    //check complete,then draw them
    //sorting first!
    for(h=0;h<b;h++)
    {
     for(m=h+1;m<b;m++)
     {
      if(draw[h].x>draw[m].x)
      {
       x=draw[h].x;
       draw[h].x=draw[m].x;
       draw[m].x=x;
       x=draw[h].y;
       draw[h].y=draw[m].y;
       draw[m].y=x;
      }
     }
    }
    
    hdc=GetDC(hwnd);              //real filling
    for(h=0;h<b;h+=2)
    {     
     MoveToEx(hdc,draw[h].x,draw[h].y,NULL);
     LineTo(hdc,draw[h+1].x,draw[h+1].y);
    }
    ReleaseDC(hwnd,hdc);

    for(h=0;h<b;h++)
    {
     draw_refresh[l].x=draw[h].x;
     draw_refresh[l].y=draw[h].y;
     l++;
    }

    b=0;
   }
   break;
  case RESET:
   filled=0;
   j=0;
   head=lines;
   for(int i=0;i<100;i++)
   {
    lines[i].xStart=0;
    lines[i].yStart=0;
    lines[i].xEnd=0;
    lines[i].yEnd=0;
   }
   for(h=0;h<l;h++)
   {
    draw_refresh[h].x=0;
    draw_refresh[h].y=0;
   }
   hdc=GetDC(hwnd);
   GetClientRect(hwnd,&clientrect);
   Rectangle(hdc,clientrect.left-5,clientrect.top-5,clientrect.right+5,clientrect.bottom+5);
   ReleaseDC(hwnd,hdc);

   InvalidateRect(hwnd,NULL,FALSE);
   break;
  }
  return 0;
 case WM_PAINT:
  hdc=BeginPaint(hwnd,&ps);

  for(head=lines;head->xStart!=0 && head->yStart!=0 && head->xEnd!=0 && head->yEnd!=0;head++)
  {
   MoveToEx(hdc,head->xStart,head->yStart,NULL);
   LineTo(hdc,head->xEnd,head->yEnd);
  }
  head=lines;

  if(filled==1)
  {
//   MessageBox(hwnd,"filled","filled",MB_OK);
   for(h=0;h<l;h+=2)
   {     
    MoveToEx(hdc,draw_refresh[h].x,draw_refresh[h].y,NULL);
    LineTo(hdc,draw_refresh[h+1].x,draw_refresh[h+1].y);
   }
  }

  EndPaint(hwnd,&ps);
  return 0;
 case WM_DESTROY:
  PostQuitMessage(0);
  return 0;
 }
 return DefWindowProc(hwnd,message,wParam,lParam);
}
///END/
如果你真要运行下的话，请务必在粘进VC的时候把行隔开，因为我暂时还不知道怎么能以好的格式把代码贴进CSDN的BLOG中。我自己做的测试中尚未发现错误，如果你发现了，麻烦好心和你告诉我，谢谢你

anyue417
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 14
    评论
专栏目录
C#：实现扫描线算法​(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-31 334
C#：实现扫描线算法​(附完整源码)
区域填充之扫描线算法
秋水齐飞的专栏
04-12 1907
区域的填充可以根据区域的填充，采用不同的填充算法，而其中有扫描线类算法和种子填充算法。这里，先介绍扫描线类算法之有序边表的扫描线算法。其他什么种子填充、边界标志算法、4连通区域的递归算法、8连通区域的递归算法、扫描线种子填充算法比较简单。         其实有序边表其实领会了也好理解，关键是将思想转化为代码。         先介绍算法思想：         1.根据给出的多边形顶点坐标，
《计算机图形学》二维填充图元的扫描线算法2
05-15
这是我在学习《计算机图形学》时编写的程序，我在编写程序时使用了定时器，因此执行的每一步都看的很清楚，按b开始，按s结束，可能在写的有些粗糙，有些地方也没有优化，希望对大家有所帮助。
区域填充——二维图像生成
qq_43542818的博客
06-01 1137
区域填充：即给出一个区域的边界，要求对边界范围内的所有像素单元赋予指定的颜色代码。区域填充中最常见的是多边形填色。 多边形光栅化主要有三种方法： 逐点判断法： 即逐个判断绘图窗口内的像素，确定它们是否在多边形区域内部，从而求出位于多边形区域内的像素的集合，通常有两种方法：射线法，累计角度法。 1）射线法 从v点发出射线与多边形P的边相交，若交点的个数为奇数，则v位于多边形P内：若为偶数，则v位于多边形P的外部。 2）累计角度法 计算各边的夹角的和，若代数和为零，该点属于域外；若代数和为2Π，则高低点属于域
二维数组，重新填充数据
最新发布
zxp_smile的博客
06-07 83
excelData[] 和 $ary_rank_data[$key]$val['key'] = $val['key']?
二维前缀和（矩形割补法）——杨子曰算法
杨子曰：代码是神奇的
03-30 583
二维前缀和（矩形割补法）——杨子曰算法 今天曰一个很实用的技巧，二维前缀和 来,先问一个问题，如果我给出一个矩阵，让你求出任意一个子矩阵的和，你会怎么搞？ 哦，简单简单，O（n^2）咔咔地暴力一下，欧了 要是真这么简单，我会问你吗？我们追求的是速度，做到O（n^2）读入后，O(1)搞定。 好的，你先要知道一个东西叫做前缀和，就是让你算出一个序列中子序列的和， 方法就是用f[i]...
二维区域扫描线填充算法[借鉴].pdf
10-12
二维区域扫描线填充算法是一种广泛应用于图形处理和计算机图形学中的技术，主要用于填充二维图形内部的像素区域。这种算法的基本思想是从图形的边界开始，通过扫描线的方式逐步填充区域内的像素。以下是对该算法的...
cg.rar_二维填充图形_扫描线 种子填充
09-24
二维填充：二维填充有三种算法，其中有序边扫描线转换算法是固定填充的，四连通和扫描线种子填充法是可以填充任意形状的图形（曲线，多边形等）的，并且还可以判断种子点为外部点还是内部点。在使用时只需先画好需要...
扫描线填充算法的OpenGL实现
01-25
扫描线填充算法是一种在计算机图形学中广泛使用的算法，主要用于在屏幕上绘制二维图形，如多边形。它通过沿屏幕的水平方向（即扫描线）逐行处理来完成填充任务。在OpenGL中，这种算法可以被用来高效地渲染复杂图形。...
扫描线法填充多边形（完整C++代码）(QT工程)
09-29
扫描线法填充多边形，头一次写图形学相关的习题。代码有点啰嗦，而且完全没注意效率。没什么注释。但是保证可以运行。环境：QT5.0
区域填充的扫描线算法
02-24
计算机图形学中的区域填充的扫描线算法的程序实现.
基本图元绘制及二维图形的种子填充算法
10-16
实现二维基本图元直线段生成的DDA算法，中点算法和Bresenham算法； 实现二维基本图元圆弧生成的中点算法； 实现二维基本图元椭圆圆弧生成的中点算法； 用菜单或按钮调用方式实现每个基本算法 用种子填充算法实现多边形内部填充
二维填充图元的生成---图像填充算法
12-17
内容：(1)扫描转换：矩形、多边形、扇形；(2)确定图元内部像素；(3)内部颜色显示：均匀填色，图像填充；
种子填充算法，扫描线填充算法，带报告
01-15
多边形的区域填充 学时：2 实验类型：设计性 实验类别：专业实验 实验目的 1. 通过实验，进一步理解和掌握几种常用多边形填充算法的基本原理 2. 掌握多边形区域填充算法的基本过程 3. 掌握在C/C++环境下用多边形填充算法编程实现指定多边形的填充。 实验设备及实验环境 计算机（每人一台） VC++6.0或其他C/C++语言程序设计环境 实验学时：2学时 实验内容 用种子填充算法和扫描线填充算法等任意两种算法实现指定多边形的区域填充。 实验步骤 1. 复习有关算法，明确实验目的和要求； 2. 依据算法思想，绘制程序流程图（指定填充多边形）； 3. 设计程序界面，要求操作方便； 4. 用C/C++语言编写源程序并调试、执行（最好能用动画显示填充过程）； 5. 分析实验结果 6. 对程序设计过程中出现的问题进行分析与总结； 7. 打印源程序或把源程序以文件的形式提交； 8. 按格式要求完成实验报告。 实验报告要求： 1. 分析算法的工作原理； 2. 画出算法的流程图 3. 实验结果及分析（比较两种算法的不同） 4. 实验总结（含问题分析及解决方法）
基于EasyX库下的扫描线填充算法
03-02
扫描线填充算法是一种在二维图形处理中常见的技术，主要用于图像的内部填充，它通过一系列的逻辑操作将指定区域内的像素点染成特定的颜色。在基于EasyX库的应用中，这种算法能够有效地帮助开发者实现图形的内部填充...
二维填充图元的生成
@清欢_
05-21 845
文章目录二维填充图元的生成1. 扫描转换矩形2. 扫描转换多边形2.1 多边形的表示方法2.1.1 顶点表示2.2.2 点阵表示2.2 多边形的扫描转换2.3 扫描转换方法：2.3.1 逐点判断法2.3.1.1 射线法2.3.1.2 累计角度法2.3.1.3 编码方法2.3.2 扫描线算法2.3.2.1 区域连贯性2.3.2.2 扫描线的连贯性2.3.2.3 边的连贯性2.3.2.4 算法2.3.2.5 数据结构2.3.2.6 算法实现2.3.2.7 算法特点3. 扫描转换扇形区域4. 区域填充5. 以图像
OpenCV C++ 在二维数据中，将点阵包围的区域填充，并返回区域内所有点位置
蓦然回首
11-06 1072
//在二维数据中，将点阵包围的区域填充，并返回区域内所有点位置 void getRegionPoint(int size[2], std::vector&lt;cv::Point&gt; edge, std::vector&lt;cv::Point&gt; &amp;outResult) {     cv::Mat mat = cv::Mat::zeros(size[1], size[0], CV...
算法系列之十二：多边形区域填充算法－－扫描线填充算法（有序边表法）
java开发指南博客 【转载】
03-19 6284
二、扫描线算法（Scan-Line Filling） 扫描线算法适合对矢量图形进行区域填充，只需要直到多边形区域的几何位置，不需要指定种子点，适合计算机自动进行图形处理的场合使用，比如电脑游戏和三维CAD软件的渲染等等。 对矢量多边形区域填充，算法核心还是求交。《计算几何与图形学有关的几种常用算法》一文给出了判断点与多边形关系的算法――扫描交点的奇偶数判断算法，利用此算法可以判断一个点是否在多...
扫描线填充算法实现与优化
扫描线填充算法是一种在计算机图形学中用于填充二维图形内部区域的常用技术，尤其适用于处理多边形。在这个文档中，介绍的是一种基于C++实现的扫描线填充算法。核心类`CPFill`包含了关键的算法逻辑。 1. **构造函数...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值