我说,你已经确定这2种颜色,如被描述为先处理步骤。

我认为,如果每个(x,y)代表不是一种幻灯,而是4个针头触及的点,那么你会发现,使用一种协调制度是有益的。 然后,你可以写出一项功能,确定北方是否是边界线标,同样对南、东、西(或者也许你倾向于术语上下/下/右边)。

从边界一站开始,例如,将4x4居民区扫描成一个N/S/E/W作为边界点。 沿这条边界,然后扫描除你所走方向外的四条方向,用于下一个六甲边界。 页: 1 之后,你知道你会重一点。

回到边界一开始,以与你最初的经历不同的方向追踪边界,直到你到达另一个终点。

This gives you all the pixel borders. Each pixel border has colour 1 on one side and colour 2 on the other side.

(我本来会认为,病媒化比确定边界要困难得多,但这不是你的问题主要在于什么正确?) 为此,我从终点开始,沿边界沿循边境的边界顺序,每次检查从终点到目前点的直线是否与平线相匹配。 一行一行,一行一行即告终,一行即行一行。

这里有几条思想和算法的开始:

寻找平等肤色的area>的大纲比找到边界容易,特别是当边界不是真正的“组合”时(即只有2个色体)似乎出现在你的形象上。

寻找两个大纲的对应部分并不十分复杂。 关于大纲A的每一点,都找到了大纲B的最接近点。 如果距离 > > > >;X ,A和B之间的中间点位于边界。 (X) 取决于贵国边界的模糊性。

如果你能够使用户在边界两侧两次点击,那将是巨大的。 如果你坚持one点击,则在点击点周围X的半径处发现两个最大的地区。

确定一个地区的大纲并不复杂:

1. take a point (x,y) to start, take a direction (dx,dy)=(1,0) to start
2. take color C of point (x,y) which will be the color to trace
3. run x+=dx,y+=dy until at (x+dx,y+dy) you have another color and are on a boundary
4. peek at (x+dx,y+dy), if it is not the same color C, you are hitting a boundary: turn left and goto 4.
5. x+=dx, y+=dy, i.e. take a step
6. record (x,y) as part of the boundary
7. if ( x==xstart && y==ystart ) you re done
8. turn right and goto 4.

<<>tturn 左 系指(dx ,dy ) = (dy,-dx),Revs++

<turn right means: (dx ,dy ) = (-dy,dx), Revolutions--

<代码>revolutions,视追溯方向(内部/外)而终止正或负。

有一个独角兽案,即当你开始在一只六餐区时,这种 lo就无限制。 很容易检查。 此外,你还可能要检查X/y边界。 当然,“同肤色”和“其他肤色”也可作为某种肤色距离限加以实施(即r(g,b)-(R,G,B><D)。

<>strong>dis claimer, 这是一个行之有效但简单、缓慢算法 在没有任何相关知识和经验的情况下,我一劳永逸。

你的描述对我来说是很明确的,但如果我正确理解你的话,你要赞扬以下几点:

• the set of contiguously connected points of colour A which are adjacent to a point of colour B
• that contains the given starting point.

鉴于这一具体特点,你的法典实际上写了自己。 你们现在需要决定的唯一一点是,“毗连”的含义是什么(例如,只有与玉米相连的ix子?)?

此外,你的描述也不明确。 如果你把“最终点”定义为“在定点中仅有一个邻国的定点”的话,则考虑该地区武器属于单一颜色的区域:如果你将最终点定为“定点”。 如果你放松要求,允许任何最终点,那么你的法典就可以收集一套最终点。

Gla你解决了你的问题。 我勾画出一种解决办法,为你的样本问题产生这一结果:

1111***2222
111**222222
111*2222222
111*2222222
111***22222
11111*33322
11333333333

这部法典只是因为我需要加以确认,以便将其编码: 报告撰写时要明确,而不是速度。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace StackOverflowEdgeDetection
{
    class Program
    {
        private static HashSet<Point> FindBorder(char[,] grid, Point start, char inside, char outside)
        {
            var border = new HashSet<Point> {};
            var endpoints = new HashSet<Point> { start };

            while (endpoints.Count != 0)
            {
                var p = endpoints.First();
                endpoints.Remove(p);
                border.Add(p);
                var newEndpoints = Neighbours(p).Where(q =>
                        Grid(grid, q) == inside &&
                        !border.Contains(q) &&
                        Neighbours(q).Any(r => Grid(grid, r) == outside)
                    );
                endpoints.UnionWith(newEndpoints);
            }

            return border;
        }

        private static IEnumerable<Point> Neighbours(Point p)
        {
            yield return new Point(p.X - 0, p.Y - 1);
            yield return new Point(p.X + 1, p.Y - 1);
            yield return new Point(p.X + 1, p.Y + 0);
            yield return new Point(p.X + 1, p.Y + 1);
            yield return new Point(p.X + 0, p.Y + 1);
            yield return new Point(p.X - 1, p.Y + 1);
            yield return new Point(p.X - 1, p.Y - 0);
            yield return new Point(p.X - 1, p.Y - 1);
        }

        public static char Grid(char[,] grid, Point p) {
            var x = p.X;
            var y = p.Y;
            var height = grid.GetLength(0);
            var width = grid.GetLength(1);
            return (0 <= x && x < width && 0 <= y && y < height) ? grid[y, x] :   ;
        }

        static void Main(string[] args)
        {
            var border = FindBorder(TestGrid, TestStart, TestInside, TestOutside);

            var points = Enumerable.Range(0, TestHeight)
                                   .SelectMany(y => Enumerable.Range(0, TestWidth)
                                                              .Select(x => new Point(x, y)));

            foreach (var p in points) {
                Console.Write(border.Contains(p) ?  *  : Grid(TestGrid, p));
                if (p.X + 1 == TestWidth) Console.WriteLine();
            }

            Console.ReadLine();
        }

        private static readonly char[,] TestGrid = new char[,] {
            {  1 ,  1 ,  1 ,  1 ,  1 ,  1 ,  1 ,  2 ,  2 ,  2 ,  2  }, 
            {  1 ,  1 ,  1 ,  1 ,  1 ,  2 ,  2 ,  2 ,  2 ,  2 ,  2  }, 
            {  1 ,  1 ,  1 ,  1 ,  2 ,  2 ,  2 ,  2 ,  2 ,  2 ,  2  }, 
            {  1 ,  1 ,  1 ,  1 ,  2 ,  2 ,  2 ,  2 ,  2 ,  2 ,  2  }, 
            {  1 ,  1 ,  1 ,  1 ,  1 ,  1 ,  2 ,  2 ,  2 ,  2 ,  2  }, 
            {  1 ,  1 ,  1 ,  1 ,  1 ,  1 ,  3 ,  3 ,  3 ,  2 ,  2  }, 
            {  1 ,  1 ,  3 ,  3 ,  3 ,  3 ,  3 ,  3 ,  3 ,  3 ,  3  }
        };
        private static readonly Point TestStart = new Point(3, 3);
        private static readonly Point TestAdjacent = new Point(4, 3);
        private static readonly char TestInside = Grid(TestGrid, TestStart);
        private static readonly char TestOutside = Grid(TestGrid, TestAdjacent);
        private static readonly int TestWidth = TestGrid.GetLength(1);
        private static readonly int TestHeight = TestGrid.GetLength(0);
    }
}

http://www.sakri.net/blog/2009/05/28/detecting-ant-pixels-with-marching-squares-algorithm/“rel=“nofollow”>detecting ant pixels with pathing平价算/a> and on wikipedia (should that connection goew) marchingsalgoa/