区域填充算法运行代码

halcon填充空洞算子
Halcon是一款强大的机器视觉软件，它提供了许多图像处理算法，其中之一就是填充空洞算子。

在图像处理中，空洞是指图像中的一些区域被其他物体包围，但是这些区域内部没有任何像素点。

这些空洞可能会影响图像的分析和处理，因此需要使用填充空洞算子来填充这些空洞。

填充空洞算子的原理是将空洞区域内的像素点填充为与其相邻的像素点的灰度值。

这样可以使得空洞区域与周围的物体区域融合在一起，从而更好地进行图像分析和处理。

在Halcon中，填充空洞算子可以通过以下代码实现：
fill_up(holes, filled);
其中，holes是包含空洞的二值图像，filled是填充后的二值图像。

fill_up算子会将holes中的空洞填充为与其相邻的像素点的灰度值，并将结果保存在filled中。

除了填充空洞算子，Halcon还提供了许多其他的图像处理算法，如边缘检测、形态学处理、图像分割等。

这些算法可以帮助用户更好地处理图像，从而提高图像分析的准确性和效率。

填充空洞算子是图像处理中非常重要的一个算法，它可以帮助我们填充图像中的空洞，从而更好地进行图像分析和处理。

在Halcon中，填充空洞算子非常容易实现，只需要一行代码即可完成。

如果您需
要进行图像处理，不妨尝试使用Halcon来实现您的需求。

实验三区域填充算法的实现一、实验目的和要求：1、掌握区域填充算法基本知识2、理解区域的表示和类型，能正确区分四连通和八连通的区域3、了解区域填充的实现原理，利用Microsoft Visual C++ 6.0或win-TC实现区域种子填充的递归算法。

二、实验内容：1、编程完成区域填色2、利用画线函数，在屏幕上定义一个封闭区域。

3、利用以下两种种子填充算法，填充上述步骤中定义的区域(1)边界表示的四连通区域种子填充的实现(2)内点表示的四连通区域种子填充的实现4、将上述算法作部分改动应用于八连通区域，构成八连通区域种子填充算法，并编程实现。

三、实验结果分析四连通图的实现:程序代码：#include<graphics.h>#include <conio.h>#include<math.h>#include<time.h>void BoundaryFill4(int x,int y,int Boundarycolor,int newcolor){if(getpixel(x,y) != newcolor && getpixel(x,y) !=Boundarycolor){putpixel(x,y,newcolor);Sleep(1);BoundaryFill4(x-1,y,Boundarycolor,newcolor);BoundaryFill4(x,y+1,Boundarycolor,newcolor);BoundaryFill4(x+1,y,Boundarycolor,newcolor);BoundaryFill4(x,y-1,Boundarycolor,newcolor);}}void polygon(int x0,int y0,int a,int n,float af){int x,y,i;double dtheta,theta;if(n<3)return;dtheta=6.28318/n;theta=af*0.0174533;moveto(x0,y0);x=x0;y=y0;for(i=1;i<n;i++){x=x+a*cos(theta);y=y+a*sin(theta);lineto(x,y);theta=theta+dtheta;}lineto(x0,y0);}void main(){int x=50,y=75;int a,b,c,d,i,j;int graphdriver=DETECT;int graphmode=0;initgraph(&graphdriver,&graphmode," ");cleardevice();setcolor(RGB(0,255,0));setfillstyle(WHITE);polygon(x,y,60,5,0.);a=100;b=100;c=RGB(0,255,0);d=RGB(255,0,255);BoundaryFill4(a,b,c,d);getch();closegraph();｝实验结果八连通的实现程序代码：#include<graphics.h>#include<conio.h>#include<time.h>#include <malloc.h>#include <windows.h>#define MaxSize 100typedef struct{int x;int y;}Seed,ElemType;typedef struct{ElemType data[MaxSize];int top; //栈顶指针} SqStack;void InitStack(SqStack *&s){s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}int StackEmpty(SqStack *s){return(s->top==-1);}int Push(SqStack *&s,ElemType e){if (s->top==MaxSize-1)return 0;s->top++;s->data[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e){if (s->top==-1)return 0;e=s->data[s->top];s->top--;return 1;}void floodfill8(int x,int y,int oldcolor,int newcolor) {if(getpixel(x,y)==oldcolor){putpixel(x,y,newcolor);Sleep(2);floodfill8(x,y+1,oldcolor,newcolor);floodfill8(x,y-1,oldcolor,newcolor);floodfill8(x-1,y,oldcolor,newcolor);floodfill8(x+1,y,oldcolor,newcolor);floodfill8(x+1,y+1,oldcolor,newcolor);floodfill8(x+1,y-1,oldcolor,newcolor);floodfill8(x-1,y+1,oldcolor,newcolor);floodfill8(x-1,y-1,oldcolor,newcolor);}}void main(){int a,b,c,d,i,j;int graphdriver=DETECT;int graphmode=0;initgraph(&graphdriver,&graphmode," "); cleardevice();setfillstyle(RGB(255,255,255));setcolor(GREEN);int points[]={320,200,270,290,370,290}; fillpoly(3,points);rectangle(500,420,100,100);a=RGB(255,255,255);b=RGB(255,0,0);floodfill8(320,240,a,b);c=RGB(0,0,0);d=RGB(0,0,255);floodfill8(320,180,c,d);getch();closegraph();}实验结果:2、结果分析：通过以上各算法运行结果分析与对比可知：1．四连通算法的缺点是有时不能通过狭窄区域，因而不能填满多边形。

通过VBA实现Excel数据填充的方法Excel是一款广泛使用的电子表格软件，可以用于数据分析、计算、图表绘制等各种任务。

而Visual Basic for Applications （VBA）是一种基于Visual Basic语言的宏编程语言，可以嵌入到Excel中，用于定义和控制Excel的各种功能。

在VBA中，我们可以通过编写宏来实现自动化操作，其中之一就是实现Excel数据填充的功能。

数据填充是Excel中非常常见的一个操作，它可以将某个单元格的值或者公式自动拖拽填充到其他相邻的单元格中，从而实现批量填充的效果。

使用VBA可以极大地提高数据填充的效率，减少人工操作的重复性。

在使用VBA实现Excel数据填充之前，我们首先需要了解一些基本的概念和操作。

首先，我们需要知道填充的起始单元格和目标单元格。

起始单元格是包含要填充内容的单元格，而目标单元格是将起始单元格的内容自动填充到的位置。

其次，我们需要知道填充的方式。

Excel提供了不同的填充方式：顺序填充、按列填充、按行填充等。

在VBA中，我们可以通过选择不同的填充方式来实现灵活的填充操作。

接下来，我们需要知道填充的范围。

填充的范围是指要填充的连续单元格的区域，可以是一列、一行，也可以是一个矩形区域。

最后，我们需要掌握如何使用VBA语言来编写宏代码来实现Excel数据填充的功能。

以下是一个通过VBA实现Excel数据填充的示例代码：```vbaSub FillData()Dim startRange As RangeDim fillRange As Range' 设置起始单元格和目标单元格Set startRange = Range("A2")Set fillRange = Range("B2:F2")' 设置填充方式为按行填充fillRange.FillDown' 设置填充方式为按列填充fillRange.FillRight' 设置填充方式为顺序填充fillRange.AutoFill Destination:=fillRange.Resize(3, 3), Type:=xlFillDefaultEnd Sub```在上面的示例代码中，首先我们使用`Range`方法来设置起始单元格和目标单元格。

三、区域填充%Fill_Test.m文件，这是主文件clear all;clc;num=GetFigure();ET=Create_ET(num);%输出桶size(ET);for i=1:length(ET)T=ET(i).AET;if ~isempty(T)ET(i).ystart;length(T);for k=1:length(T)T(k);endendendPoint=Fill(ET);figure();scatter(Point(:,1),Point(:,2),'.','r');%GetFigure.m文件，获取图形数据文件,数据源为程序自带的*.xls文件function Figure=GetFigure()%从指定文件中读取图形数据矩阵%图形数据矩阵的各列含义如下：%点编号点坐标x 点坐标y 线段起点编号线段终点编号%[FileName,PathName,FilterIndex]=uigetfile('*.xls','select an office file'); [num,text,head]=xlsread(strcat(PathName,FileName));Figure=num;end%Create_ET.m文件，创建边表文件function ET=Create_ET(num)%num共五列数据，每一列的数据含义如下：%点编号点坐标x 点坐标y 线段起点编号线段终点编号%采用矩阵存储相同深度的有效边，ET(i).AET即指向该矩阵%构造桶,先确定桶深Ymin=min(num(:,3));Ymax=max(num(:,3));Ymin=Ymin(1);Ymax=Ymax(1);%构造了空桶ET,同ystart字段为起点的y值,next为此层桶内的有效边矩阵for i=1:Ymax-Ymin+1% ET(i).x=-1;% ET(i).ystart=i+Ymin-1;% ET(i).k1=-100;% ET(i).AET=[];ET(i)=struct('x',-1,'ystart',i+Ymin-1,'k1',-100,'AET',[]);end%构造有效边AETfor i=1:length(num(:,4))%取出第i条线段的端点p=[num(num(i,4),[2,3]);num(num(i,5),[2,3])];% break;%做两个端点的差if p(1,2)>p(2,2)t=p(1,:);p(1,:)=p(2,:);p(2,:)=t;end%开始计算斜率倒数d=p(2,:)-p(1,:);if d(2)==0k1=Inf;elsek1=d(1)/d(2);end%斜率为0的边不输入桶中if k1==Infcontinue;end%构造有效边,%x字段为边起始点横坐标,ymax为终点纵坐标,k1为斜率的倒数,next为具有相同起点纵坐标的下一条有效边% AET.x=p(1,1);% AET.ymax=p(2,2);% AET.k1=k1;AET=struct('x',p(1,1),'ymax',p(2,2),'k1',k1);%定位有效边深度Tindex=p(1,2)-Ymin+1;T=ET(Tindex).AET;j=1;%j表示新节点的插入位置if isempty(T)%若当前矩阵为空,则指定结构体矩阵的各个字段T(1).x=AET.x;T(1).ymax=AET.ymax;T(1).k1=AET.k1;elsewhile j<=length(T)if T(j).x<AET.x||T(j).x==AET.x&&T(j).k1<AET.k1j=j+1;elsebreak;endend%将后序点后移for k=length(T):-1:jT(k+1)=T(k);end%插入节点T(j)=AET;end%更新当前桶层的结构体矩阵ET(Tindex).AET=T;T=ET(1).AET;end%处理点扫描数为1的情况for i=1:length(ET);T=ET(i).AET;if ~isempty(T)for k=1:length(T)if ~isempty(ET(T(k).ymax-Ymin+1).AET)T(k).ymax=T(k).ymax-1;endendendET(i).AET=T;endend%Fill.m文件，填充区域文件function Point=Fill(ET)%ET为边表%Point为填充的像素点%T是当前有效边的头节点，T.next指向首元节点%用矩阵AET存储当前AET表AET=[];Point=[];for i=1:length(ET)if ~isempty(ET(i).AET)%开始合并T1=ET(i).AET;T2=AET;T3=[];%临时矩阵m=1;n=1;if i==61Temp=ET(i).AET;size(Temp);for q=1:length(Temp)Temp(q);endendwhile m<=length(T1)&&n<=length(T2)if T1(m).x<T2(n).x||T1(m).x==T2(n).x&&T1(m).k1<=T2(n).k1Elem=T1(m);m=m+1;elseElem=T2(n);n=n+1;endT3=[T3;Elem];end%连接T1剩余部分for p=m:length(T1)T3=[T3;T1(p)];end%连接T2剩余部分for p=n:length(T2)T3=[T3;T2(p)];endAET=T3;%合并完成end%%if ~isempty(AET)sign=false;%开始填充for p=1:length(AET)sign=~sign;if signx=[ceil(AET(p).x) floor(AET(p+1).x)];for k=x(1):x(2)Point=[Point;[k ET(i).ystart]];endendend%删除ET(i).ystart=AET(j).ymax的边T3=[];for p=1:length(AET)if ~(AET(p).ymax<=ET(i).ystart)T3=[T3;AET(p)];endend%重新计算xfor p=1:length(T3)T3(p).x=T3(p).x+T3(p).k1;endAET=T3;endendPoint=Point;end%FigureData.xls文件，数据源文件点编号点坐标x 点坐标y 线段起点编号线段终点编号1 30 10 1 22 60 50 2 33 80 10 3 44 120 90 4 55 70 80 5 66 30 120 6 77 10 70 7 1。

c语言多边形区域填充算法C语言多边形区域填充算法一、介绍多边形区域填充算法是计算机图形学中的一项重要技术，用于将给定的多边形区域进行填充，使其呈现出丰富的颜色或纹理，增强图形的效果和表现力。

本文将介绍一种常用的C语言多边形区域填充算法——扫描线填充算法。

二、扫描线填充算法原理扫描线填充算法是一种基于扫描线的填充方法，其基本思想是将多边形区域按照水平扫描线的顺序，从上到下逐行扫描，通过判断扫描线与多边形边界的交点个数来确定是否进入多边形区域。

具体步骤如下：1. 首先，确定多边形的边界，将其存储为一个边表。

边表中的每个边都包含起点和终点的坐标。

2. 创建一个活性边表（AET），用于存储当前扫描线与多边形边界的交点。

初始时，AET为空。

3. 从上到下逐行扫描多边形区域，对每一条扫描线，从边表中找出与该扫描线相交的边，并将其加入AET中。

4. 对于AET中的每一对交点，按照从左到右的顺序两两配对，形成水平线段，将其填充为指定的颜色或纹理。

5. 在扫描线的下一行，更新AET中的交点的坐标，然后重复步骤4，直到扫描到多边形区域的底部。

三、代码实现下面是一个简单的C语言实现扫描线填充算法的示例代码：```#include <stdio.h>#include <stdlib.h>#include <stdbool.h>typedef struct {int x;int y;} Point;typedef struct {int yMax;float x;float dx;int next;} Edge;void fillPolygon(int n, Point* points, int color) {// 获取多边形的边界int yMin = points[0].y;int yMax = points[0].y;for (int i = 1; i < n; i++) {if (points[i].y < yMin) {yMin = points[i].y;}if (points[i].y > yMax) {yMax = points[i].y;}}// 创建边表Edge* edges = (Edge*)malloc(sizeof(Edge) * n);int k = n - 1;for (int i = 0; i < n; i++) {if (points[i].y < points[k].y) {edges[i].yMax = points[k].y;edges[i].x = points[i].x;edges[i].dx = (float)(points[k].x - points[i].x) / (points[k].y - points[i].y);edges[i].next = k;} else {edges[i].yMax = points[i].y;edges[i].x = points[k].x;edges[i].dx = (float)(points[i].x - points[k].x) / (points[i].y - points[k].y);edges[i].next = i;}k = i;}// 扫描线填充for (int y = yMin; y < yMax; y++) {int xMin = INT_MAX;int xMax = INT_MIN;for (int i = 0; i < n; i++) {if (y >= edges[i].yMax) {continue;}edges[i].x += edges[i].dx;if (edges[i].x < xMin) {xMin = edges[i].x;}if (edges[i].x > xMax) {xMax = edges[i].x;}int j = edges[i].next;while (j != i) {edges[j].x += edges[j].dx; if (edges[j].x < xMin) {xMin = edges[j].x;}if (edges[j].x > xMax) {xMax = edges[j].x;}j = edges[j].next;}}for (int x = xMin; x < xMax; x++) { drawPixel(x, y, color);}}free(edges);}int main() {// 定义多边形的顶点坐标Point points[] = {{100, 100},{200, 200},{300, 150},{250, 100}};// 填充多边形区域为红色fillPolygon(4, points, RED);return 0;}```四、总结通过扫描线填充算法，我们可以实现对多边形区域的填充，从而提升图形的表现效果。

区域填充算法⼀、区域填充概念区域：指已经表⽰成点阵形式的填充图形，是象素的集合。

区域填充：将区域内的⼀点（常称种⼦点）赋予给定颜⾊，然后将这种颜⾊扩展到整个区域内的过程。

区域填充算法要求区域是连通的，因为只有在连通区域中，才可能将种⼦点的颜⾊扩展到区域内的其它点。

1、区域有两种表⽰形式1. 内点表⽰：枚举出区域内部的所有象素内部所有象素着同⼀个颜⾊边界像素着与内部象素不同的颜⾊。

2. 边界表⽰：枚举出区域外部的所有象素边界上的所有象素着同⼀个颜⾊内部像素着与边界象素不同的颜⾊。

2、区域连通1. 四向连通区域：从区域上⼀点出发可通过上、下、左、右四个⽅向移动的组合，在不越出区域的前提下，到达区域内的任意象素。

2. ⼋向连通区域：从区域上⼀点出发可通过上、下、左、右、左上、右上、左下、右下⼋个⽅向移动的组合，在不越出区域的前提下，到达区域内的任意象素。

3. 四连通与⼋连通区域的区别连通性：四连通可以看作⼋连通的⾃⼰，但是对边界有要求⼆、简单种⼦填充算法1、基本思想给定区域G⼀种⼦点（x, y）,⾸先判断该点是否是区域内的⼀点，如果是，则将该点填充为新的颜⾊，然后将该点周围的四个点（四连通）或⼋个点（⼋连通）作为新的种⼦点进⾏同样的处理，通过这种扩散完成对整个区域的填充。

这⾥给出⼀个四连通的种⼦填充算法（区域填充递归算法），使⽤【栈结构】来实现原理算法原理如下：种⼦像素⼊栈，当【栈⾮空】时重复如下三步：2、算法代码这⾥给出⼋连通的种⼦填充算法的代码：void flood_fill_8(int[] pixels, int x, int y, int old_color, int new_color) { if (x < w && x > 0 && y < h && y > 0) {// 如果是旧的颜⾊⽽且还没有给他填充过if (pixels[y * w + x] == old_color) {// 填充为新的颜⾊pixels[y * w + x]== new_color);// 递归flood_fill_8(pixels, x, y + 1, old_color, new_color);flood_fill_8(pixels, x, y - 1, old_color, new_color);flood_fill_8(pixels, x - 1, y, old_color, new_color);flood_fill_8(pixels, x + 1, y, old_color, new_color);flood_fill_8(pixels, x + 1, y + 1, old_color, new_color);flood_fill_8(pixels, x + 1, y - 1, old_color, new_color);flood_fill_8(pixels, x - 1, y + 1, old_color, new_color);flood_fill_8(pixels, x - 1, y - 1, old_color, new_color);}}}3、OpenCV实现import cv2def seed_fill(img):ret, img = cv2.threshold(img, 128, 255, cv2.THRESH_BINARY_INV) label = 100stack_list = []h, w = img.shapefor i in range(1, h-1, 1):for j in range(1, w-1, 1):if (img[i][j] == 255):img[i][j] = labelstack_list.append((i, j))while len(stack_list) != 0:cur_i = stack_list[-1][0]cur_j = stack_list[-1][1]img[cur_i][cur_j] = labelstack_list.remove(stack_list[-1])# 四邻域，可改为⼋邻域if (img[cur_i-1][cur_j] == 255):stack_list.append((cur_i-1, cur_j))if (img[cur_i][cur_j-1] == 255):stack_list.append((cur_i, cur_j-1))if (img[cur_i+1][cur_j] == 255):stack_list.append((cur_i+1, cur_j))if (img[cur_i][cur_j+1] == 255):stack_list.append((cur_i, cur_j+1))cv2.imwrite('./result.jpg', img)cv2.imshow('img', img)cv2.waitKey()if __name__ == '__main__':img = cv2.imread('./test.jpeg', 0)seed_fill(img)4、简单种⼦填充算法的优点和缺点优点：1. 该算法也可以填充有孔区域缺点：1. 有些像素会多次⼊栈，降低算法效率，栈结构占空间2. 递归执⾏，算法简单，但效率不⾼，区域内每⼀像素都要进/出栈，费时费内存3. 改进算法，减少递归次数，提⾼效率三、扫描线种⼦填充算法⽬标：减少递归层次适⽤于边界表⽰的4连通区间1、基本思想在任意不间断区间中只取⼀个种⼦像素（不间断区间指在⼀条扫描线上⼀组相邻元素），填充当前扫描线上的该段区间；然后确定与这⼀区段相邻的上下两条扫描线上位于区域内的区段，并依次把它们保存起来，反复进⾏这个过程，直到所保存的各个区段都填充完毕。

区域填充算法的实现实现区域填充算法的一种常见方法是使用递归。

以下是一个使用递归实现的区域填充算法的伪代码：1. 定义函数fillPixel(x, y, targetColor, fillColor)：-如果像素点(x,y)的颜色与目标颜色相同，将其颜色修改为填充颜色。

-否则，返回。

2. 定义函数regionFill(x, y, targetColor, fillColor)：-如果像素点(x,y)的颜色与目标颜色相同，返回。

- 否则，调用fillPixel(x, y, targetColor, fillColor)。

- 递归调用regionFill(x-1, y, targetColor, fillColor)。

- 递归调用regionFill(x+1, y, targetColor, fillColor)。

- 递归调用regionFill(x, y-1, targetColor, fillColor)。

- 递归调用regionFill(x, y+1, targetColor, fillColor)。

3. 调用regionFill(seedX, seedY, targetColor, fillColor)。

在上述算法中，fillPixel函数用于将特定颜色填充到像素点(x, y)。

regionFill函数使用递归的方式遍历相邻的像素点，并对目标颜色的像素点调用fillPixel函数。

seedX和seedY表示种子像素点的坐标，targetColor表示目标颜色，fillColor表示填充颜色。

实现区域填充算法时还需要考虑以下几个问题：1.像素点的表示：图像可以由二维数组表示，其中每个元素表示一个像素点的颜色。

2.填充颜色选择：填充颜色可以由RGB值表示，或者在预定义的颜色集合中选择。

3.边界处理：对于位于图像边界上的种子像素点，需要特殊处理以防止数组越界错误。

4.递归终止条件：填充算法使用递归，需要定义递归终止的条件，以防止无限递归。

区域生长算法代码//函数名称：FillDibEx//函数功能：区域生长//入口参数：SrcIm g : TGrayImg - 原图象// Seed : TPoint - 起始种子坐标// DestIm g : TGrayImg - 目的图象//返回参数：Boolean - 成功返回True,否则返回False//================================================= ==================//function FillDibEx(SrcImg : TGrayImg; Seed : TPoint; var DestIm g : TGrayImg) : Boolean;vari, j : Integer;Seeds : array of TPoint; //种子堆栈StackPoint : Integer; //堆栈指针iCurrentPixelx, iCurrentPixely : Integer; //当前象素位置pixel : Byte;begin//初始化种子trySetLength(Seeds, SrcIm g.Width * SrcImg.Height);exceptResult := False;Exit;end;Seeds[1].Y := Seed.Y;Seeds[1].X := Seed.X;StackPoint := 1;While (StackPoint <> 0) dobegin//取出种子iCurrentPixelx := Seeds[StackPoint].X;iCurrentPixely := Seeds[StackPoint].Y;//退栈Dec(StackPoint);pixel := SrcImg.Img[iCurrentPixely, iCurrentPixelx];//不是二值图象if (pixel <> 255) and (pixel <> 0) and (pixel <> 128) thenbeginResult := False;Exit;end;//将当前的点涂黑SrcIm g.Img[iCurrentPixely, iCurrentPixelx] := 128;//判断左边的点，如果为白，则压入堆栈//注意防止越界if iCurrentPixelx > 0 thenbeginpixel := SrcIm g.Img[iCurrentPixely, iCurrentPixelx - 1];if pixel = 255 thenbeginInc(StackPoint);Seeds[StackPoint].Y := iCurrentPixely;Seeds[StackPoint].X := iCurrentPixelx - 1;end;if (pixel <> 0) and (pixel <> 128) and (pixel <> 255) then beginResult := False;Exit;end;end;//判断下面的点，如果为白，压入堆栈//注意防止越界if (iCurrentPixely < SrcImg.Height - 1) thenbeginpixel := SrcIm g.Img[iCurrentPixely + 1, iCurrentPixelx];if pixel = 255 thenbeginInc(StackPoint);Seeds[StackPoint].Y := iCurrentPixely + 1;Seeds[StackPoint].X := iCurrentPixelx;end;if (pixel <> 0) and (pixel <> 128) and (pixel <> 255) then beginResult := False;Exit;end;end;//判断右边的点，如果为白，则压入堆栈//注意防止越界if iCurrentPixelx < SrcImg.Width - 1 thenbeginpixel := SrcIm g.Img[iCurrentPixely, iCurrentPixelx + 1];if pixel = 255 thenbeginInc(StackPoint);Seeds[StackPoint].Y := iCurrentPixely;Seeds[StackPoint].X := iCurrentPixelx + 1;end;if (pixel <> 0) and (pixel <> 128) and (pixel <> 255) then beginResult := False;Exit;end;end;//判断上面的点，如果为白，压入堆栈//注意防止越界if (iCurrentPixely > 0) thenbeginpixel := SrcIm g.Img[iCurrentPixely - 1, iCurrentPixelx];if pixel = 255 thenbeginInc(StackPoint);Seeds[StackPoint].Y := iCurrentPixely - 1;Seeds[StackPoint].X := iCurrentPixelx;end;if (pixel <> 0) and (pixel <> 128) a nd (pixel <> 255) then beginResult := False;Exit;end;end;end;//保存填充区域，恢复原始图象if not SetImgArray(SrcImg.Width, SrcIm g.Height, DestImg) then beginResult := False;Exit;end;for i := 0 to SrcIm g.Height - 1 dofor j := 0 to SrcImg.Width - 1 dobeginDestIm g.Img[i, j] := SrcImg.Img[i, j];if SrcImg.Img[i, j] = 128 thenbegin// SrcIm g.Img[i,j] := 255;DestImg.Img[i,j] := 0;end;end;Result := True;end;。