图：（描述下图片：黄色框表示四个图片控件中的显示部分。其他的框架就是4个图片控件的边缘，是矩形的）
 
 
重叠区域选取出想要的 平行四边形对象，这图画的是理想状态，其实有2.3.4个图片相交的情况...
在sl4中提供了 VisualTreeHelper 来实现多层对象选择 放入一个uielementscollection中
这里分为很多种情况 ，最多是4个块相交
判断鼠标选择了哪个区域，就使用sl中的intersect方法求出4个矩形区域与自定义鼠标图片的交叉部分矩形区域，然后对比交叉区域面积大小，从大到小判断鼠标选择优先性，
这样就能选择出想要的对象了，但这方法精度不是100%准，效果还算理想。
 

最近在做一款拼图游戏，由于要设计到拖拽判断，UGUI中如何更方便的判断两个图片是否重叠呢？可参考如下方法：



 

    public static bool IsRectTransformOverlap(RectTransform rect1, RectTransform rect2)

    {

        Vector3[] corners1 = new Vector3[4];

        rect1.GetWorldCorners(corners1);

        corners1[2].x = Mathf.Abs(corners1[2].x - corners1[0].x);

        corners1[2].y = Mathf.Abs(corners1[2].y - corners1[0].y);

        Rect b1 = new Rect(corners1[0].x, corners1[0].y, corners1[2].x, corners1[2].y);



        rect2.GetWorldCorners(corners1);

        corners1[2].x = Mathf.Abs(corners1[2].x - corners1[0].x);

        corners1[2].y = Mathf.Abs(corners1[2].y - corners1[0].y);

        Rect b2 = new Rect(corners1[0].x, corners1[0].y, corners1[2].x, corners1[2].y);

        return b1.Overlaps(b2);

    }

使用Spark SQL和 DataFrame 的简单解决方案：
Scala：
import org.apache.spark.sql.functions.udf
case class Interval(start_time: Long, end_time: Long)
val rdd = sc.parallelize(
Interval(0, 3) :: Interval(1, 4) ::
Interval(2, 5) :: Interval(3, 4) ::
Interval(5, 8) :: Interval(7, 10) :: Nil
)
val df = sqlContext.createDataFrame(rdd)
// Simple check if a given intervals overlap
def overlaps(start_first: Long, end_first: Long,
start_second: Long, end_second: Long):Boolean = {
(start_second > start_first & start_second < end_first) |
(end_second > start_first & end_second < end_first)
}
// Register udf and data frame aliases
// It look like Spark SQL doesn't support
// aliases in FROM clause [1] so we have to
// register df twice
sqlContext.udf.register("overlaps", overlaps)
df.registerTempTable("df1")
df.registerTempTable("df2")
// Join and filter
sqlContext.sql("""
SELECT * FROM df1 JOIN df2
WHERE overlaps(df1.start_time, df1.end_time, df2.start_time, df2.end_time)
""").show
使用PySark也一样
from pyspark.sql.functions import udf
from pyspark.sql.types import BooleanType
rdd = sc.parallelize([
(0, 3), (1, 4),
(2, 5), (3, 4),
(5, 8), (7, 10)
])
df = sqlContext.createDataFrame(rdd, ('start_time', 'end_time'))
def overlaps(start_first, end_first, start_second, end_second):
return ((start_first < start_second < end_first) or
(start_first < end_second < end_first))
sqlContext.registerFunction('overlaps', overlaps, BooleanType())
df.registerTempTable("df1")
df.registerTempTable("df2")
sqlContext.sql("""
SELECT * FROM df1 JOIN df2
WHERE overlaps(df1.start_time, df1.end_time, df2.start_time, df2.end_time)
""").show()
按窗口分组的低级 transformation
一个更聪明的方法是使用指定宽度的窗口生成候选对。这里有一个相当简单的解决方案：
Scala：
// Generates list of "buckets" for a given interval
def genRange(interval: Interval) = interval match {
case Interval(start_time, end_time) => {
(start_time / 10L * 10L) to (((end_time / 10) + 1) * 10) by 1
}
}
// For each interval generate pairs (bucket, interval)
val pairs = rdd.flatMap( (i: Interval) => genRange(i).map((r) => (r, i)))
// Join (in the worst case scenario it is still O(n^2)
// But in practice should be better than a naive
// Cartesian product
val candidates = pairs.
join(pairs).
map({
case (k, (Interval(s1, e1), Interval(s2, e2))) => (s1, e1, s2, e2)
}).distinct
// For each candidate pair check if there is overlap
candidates.filter { case (s1, e1, s2, e2) => overlaps(s1, e1, s2, e2) }
Python：
def genRange(start_time, end_time):
return xrange(start_time / 10L * 10L, ((end_time / 10) + 1) * 10)
pairs = rdd.flatMap(lambda (s, e): ((r, (s, e)) for r in genRange(s, e)))
candidates = (pairs
.join(pairs)
.map(lambda (k, ((s1, e1), (s2, e2))): (s1, e1, s2, e2))
.distinct())
candidates.filter(lambda (s1, e1, s2, e2): overlaps(s1, e1, s2, e2))
虽然在某些 DataSet 上它可以满足于生产就绪的解决方案，但是您应该考虑实现一些最先进的算法，如nclist。
http://docs.datastax.com/en/datastax_enterprise/4.6/datastax_enterprise/spark/sparksqlsupportedsyntax.html

重叠I/O之事件对象通知
 
重叠I/O，Overlapped I/O。

一、 重叠I/O的优点

 

1. 可以运行在支持Winsock2的所有Windows平台 ,而不像完成端口只是支持NT系统。

2. 比起阻塞、select、WSAAsyncSelect以及WSAEventSelect等模型，重叠I/O使应用程序能达到更佳的系统性能。因为它和这4种模型不同的是，使用重叠I/O的应用程序通知缓冲区收发系统直接使用数据，也就是说，如果应用程序投递了一个10KB大小的缓冲区来接收数据，且数据已经到达套接字，则该数据将直接被拷贝到投递的缓冲区。而这4种模型种，数据到达并拷贝到单套接字接收缓冲区中，此时应用程序会被告知可以读入的容量。当应用程序调用接收函数之后，数据才从单套接字缓冲区拷贝到应用程序的缓冲区，差别就体现出来了。

3. 从《windows网络编程》中提供的试验结果中可以看到，在使用了P4 1.7G Xero处理器(CPU很强啊)以及768MB的回应服务器中，最大可以处理4万多个SOCKET连接，在处理1万2千个连接的时候CPU占用率才40% 左右 ―― 非常好的性能，已经直逼完成端口了。

二、重叠I/O的基本原理

 

概括一点说，重叠I/O是让应用程序使用重叠数据结构（WSAOVERLAPPED），一次投递一个或多个Winsock I/O请求。针对这些提交的请求，在它们完成之后，应用程序会收到通知，于是就可以通过自己另外的代码来处理这些数据了。

 

需要注意的是，有两个方法可以用来管理重叠I/O请求的完成情况（就是说接到重叠操作完成的通知）：

 

1. 事件对象通知(Event Object Notification) 。

2. 完成例程（Completion Routines）（注意，这里并不是完成端口）

 

本文只是讲述如何来使用事件通知的的方法实现重叠I/O，如没有特殊说明，本文的重叠I/O默认就是指基于事件通知的重叠I/O。

 

既然是基于事件通知，就要求将Windows事件对象与WSAOVERLAPPED结构关联在一起（WSAOVERLAPPED结构中专门有对应的参数），既然要使用重叠结构，我们常用的send, sendto, recv, recvfrom也都要被WSASend，WSASendto, WSARecv, WSARecvFrom替换掉了，它们的用法我后面会讲到，这里只需要注意一点，它们的参数中都有一个Overlapped参数，我们可以假设是把我们的WSARecv这样的操作操作“绑定”到这个重叠结构上，提交一个请求，其他的事情就交给重叠结构去操心，而其中重叠结构又要与Windows的事件对象“绑定”在一起，这样我们调用完WSARecv以后就可以“坐享其成”，等到重叠操作完成以后，自然会有与之对应的事件来通知我们操作完成，然后我们就可以来根据重叠操作的结果取得我们想要德数据了。

 

三、关于重叠I/O的基础知识

 

下面来介绍并举例说明一下编写重叠I/O的程序中将会使用到的几个关键数据结构和函数。

 

1. WSAOVERLAPPED结构

 

这个结构自然是重叠I/O里的核心，它是这么定义的：

 

typedef struct _WSAOVERLAPPED 
{

DWORD Internal;

DWORD InternalHigh;

DWORD Offset;

DWORD OffsetHigh;

WSAEVENT hEvent; // 唯一需要关注的参数，用来关联WSAEvent对象

} WSAOVERLAPPED, *LPWSAOVERLAPPED;

我们需要把WSARecv等操作投递到一个重叠结构上，而我们又需要一个与重叠结构“绑定”在一起的事件对象来通知我们操作的完成，看到了和hEvent参数，不用我说你们也该知道如何来来把事件对象绑定到重叠结构上吧？大致如下：

WSAEVENT event; // 定义事件

WSAOVERLAPPED AcceptOverlapped ; // 定义重叠结构

event = WSACreateEvent(); // 建立一个事件对象句柄

ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED)); // 初始化重叠结构

AcceptOverlapped.hEvent = event;

 

2. WSARecv系列函数

 

在重叠I/O中，接收数据就要靠它了，它的参数也比recv要多，因为要用刀重叠结构嘛，它是这样定义的：

 

int WSARecv
(

SOCKET s, // 当然是投递这个操作的套接字

LPWSABUF lpBuffers, // 接收缓冲区，与Recv函数不同这里需要一个由WSABUF结构构成的数组

DWORD dwBufferCount, // 数组中WSABUF结构的数量

LPDWORD lpNumberOfBytesRecvd, // 如果接收操作立即完成，这里会返回所接收到的字节数

LPDWORD lpFlags, // 说来话长了，我们这里设置为0 即可

LPWSAOVERLAPPED lpOverlapped, // “绑定”的重叠结构

LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine // 完成例程中将会用到的参数，我们这里设置为 NULL

);


返回值：

WSA_IO_PENDING ： 最常见的返回值，这是说明我们的WSARecv操作成功了。

 

举个例子：(变量的定义顺序和上面的说明的顺序是对应的，下同)

SOCKET s;

WSABUF DataBuf; // 定义WSABUF结构的缓冲区

// 初始化一下DataBuf

#define DATA_BUFSIZE 5096

char buffer[DATA_BUFSIZE];

ZeroMemory(buffer, DATA_BUFSIZE);

DataBuf.len = DATA_BUFSIZE;

DataBuf.buf = buffer;

DWORD dwBufferCount = 1, dwRecvBytes = 0, Flags = 0;

// 重叠结构，如果要处理多个操作，这里当然需要一个WSAOVERLAPPED数组。

WSAOVERLAPPED AcceptOverlapped ;
// 事件，如果要多个事件，这里当然也需要一个WSAEVENT数组。需要注意的是，可能一个SOCKET同时会有一个以上的重叠请求，也就会对应一个以上的WSAEVENT。

WSAEVENT event; 


Event = WSACreateEvent();

ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED));

AcceptOverlapped.hEvent = event; // 关键的一步，把事件句柄“绑定”到重叠结构上。


作了这么多工作，终于可以使用WSARecv来把我们的请求投递到重叠结构上了，呼…

WSARecv(s, &DataBuf, dwBufferCount, &dwRecvBytes, &Flags, &AcceptOverlapped, NULL);

其他的函数我这里就不一一介绍了，因为我们毕竟还有MSDN这么个好帮手，而且在讲后面的完成例程和完成端口的时候我还会讲到一些 ^_^

 

3. WSAWaitForMultipleEvents函数

 

熟悉WSAEventSelect模型的朋友对这个函数肯定不会陌生，不对，其实大家都不应该陌生，这个函数与线程中常用的WaitForMultipleObjects函数有些地方还是比较像的，因为都是在等待某个事件的触发嘛。

 

因为我们需要事件来通知我们重叠操作的完成，所以自然需要这个等待事件的函数与之配套。

 

DWORD WSAWaitForMultipleEvents(

DWORD cEvents, // 等候事件的总数量

const WSAEVENT* lphEvents, // 事件数组的指针

BOOL fWaitAll, // 这个要多说两句：如果设置为 TRUE，则事件数组中所有事件被传信的时候函数才会返回；FALSE则任何一个事件被传信函数都要返回。我们这里肯定是要设置为FALSE的。

DWORD dwTimeout, // 超时时间，如果超时，函数会返回。

WSA_WAIT_TIMEOUT  // 如果设置为0，函数会立即返回；如果设置为 WSA_INFINITE只有在某一个事件被传信后才会返回。在这里不建议设置为WSA_INFINITE，因为…后面再讲吧。

 

BOOL fAlertable // 在完成例程中会用到这个参数，这里我们先设置为FALSE。

);


返回值：

WSA_WAIT_TIMEOUT ：最常见的返回值，我们需要做的就是继续等待。

WSA_WAIT_FAILED ： 出现了错误，请检查cEvents和lphEvents两个参数是否有效如果事件数组中有某一个事件被传信了，函数会返回这个事件的索引值，但是这个索引值需要减去预定义值 WSA_WAIT_EVENT_0才是这个事件在事件数组中的位置。具体的例子就先不在这里举了，后面还会讲到。

注意：WSAWaitForMultipleEvents函数只能支持由WSA_MAXIMUM_WAIT_EVENTS对象定义的一个最大值，是 64，就是说WSAWaitForMultipleEvents只能等待64个事件，如果想同时等待多于64个事件，就要创建额外的工作者线程，就不得不去管理一个线程池，这一点就不如下一篇要讲到的完成例程模型了。

 

4. WSAGetOverlappedResult函数

 

既然我们可以通过WSAWaitForMultipleEvents函数来得到重叠操作完成的通知，那么我们自然也需要一个函数来查询一下重叠操作的结果，定义如下：

 

BOOL WSAGetOverlappedResult(

SOCKET s, // 套接字，不用说了

LPWSAOVERLAPPED lpOverlapped, // 要查询的那个重叠结构的指针

LPDWORD lpcbTransfer, // 本次重叠操作的实际接收(或发送)的字节数

… //其他参数暂略，以后补充。

);

如果WSAGetOverlappedResult完成以后，第三个参数返回是 0 ，则说明通信对方已经关闭连接，我们这边的SOCKET, Event之类的也就可以关闭了。

 

四、实现重叠I/O的步骤

 

下面我们配合代码，来一步步的讲解如何亲手完成一个重叠I/O。

 

第一步：定义变量

 

#define DATA_BUFSIZE 4096 // 接收缓冲区大小

SOCKET ListenSocket, // 监听套接字

SOCKET AcceptSocket; // 与客户端通信的套接字

WSAOVERLAPPED AcceptOverlapped; // 重叠结构一个

WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS]; // 用来通知重叠操作完成的事件句柄数组

WSABUF DataBuf[DATA_BUFSIZE] ; 

DWORD dwEventTotal = 0, // 程序中事件的总数

dwRecvBytes = 0, // 接收到的字符长度

Flags = 0; // WSARecv的参数

 

 

第二步：创建一个套接字，开始在指定的端口上监听连接请求。

 

和其他SOCKET初始化一样，直接照搬即可。

 

WSADATA wsaData;

WSAStartup(MAKEWORD(2,2),&wsaData);

 

ListenSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); //创建TCP套接字

SOCKADDR_IN ServerAddr; //分配端口及协议族并绑定

ServerAddr.sin_family=AF_INET; 

ServerAddr.sin_addr.S_un.S_addr =htonl(INADDR_ANY); 

ServerAddr.sin_port=htons(11111);

bind(ListenSocket,(LPSOCKADDR)&ServerAddr, sizeof(ServerAddr)); // 绑定套接字

listen(ListenSocket, 5); //开始监听

 

第三步：接受一个入站的连接请求

 

AcceptSocket = accept (ListenSocket, NULL,NULL) ; 

当然，这里是偷懒，如果想要获得连入客户端的信息（记得论坛上也常有人问到），accept的后两个参数就不要用NULL，而是这样：

 

SOCKADDR_IN ClientAddr; // 定义一个客户端得地址结构作为参数

int addr_length=sizeof(ClientAddr);

AcceptSocket = accept(ListenSocket,(SOCKADDR*)&ClientAddr, &addr_length);

// 于是乎，我们就可以轻松得知连入客户端的信息了

LPCTSTR lpIP = inet_ntoa(ClientAddr.sin_addr); // IP

UINT nPort = ClientAddr.sin_port; // Port

 

第四步：建立并初始化重叠结构

 

为连入的这个套接字新建立一个WSAOVERLAPPED重叠结构，并且象前面讲到的那样，为这个重叠结构从事件句柄数组里挑出一个空闲的对象句柄“绑定”上去。

 

// 创建一个事件，dwEventTotal可以暂时先作为Event数组的索引。

EventArray[dwEventTotal] = WSACreateEvent(); 

 

ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED)); // 置零

AcceptOverlapped.hEvent = EventArray[dwEventTotal]; // 关联事件

 

char buffer[DATA_BUFSIZE];

ZeroMemory(buffer, DATA_BUFSIZE);

DataBuf.len = DATA_BUFSIZE;

DataBuf.buf = buffer; // 初始化一个WSABUF结构

dwEventTotal ++; // 总数加一

 

第五步：以WSAOVERLAPPED结构为参数，在套接字上投递WSARecv请求。

 

各个变量都已经初始化OK以后，我们就可以开始Socket操作了，然后让WSAOVERLAPPED结构来替我们管理I/O 请求，我们只须等待事件的触发就可以了。

 

if(SOCKET_ERROR==WSARecv(AcceptSocket ,&DataBuf,1,&dwRecvBytes,&Flags,&AcceptOverlapped, NULL))

{ 

// 返回WSA_IO_PENDING是正常情况，表示IO操作正在进行，不能立即完成。如果不是WSA_IO_PENDING错误，就大事不好了！

if(WSAGetLastError() != WSA_IO_PENDING) 

{

// 那就只能关闭大吉了

closesocket(AcceptSocket);

WSACloseEvent(EventArray[dwEventTotal]);

}

}

 

第六步：用WSAWaitForMultipleEvents函数等待重叠操作返回的结果

 
因为前面已经把事件和Overlapped绑定在一起，重叠操作完成后我们会接到事件通知。

DWORD dwIndex;
// 等候重叠I/O调用结束

dwIndex=WSAWaitForMultipleEvents(dwEventTotal,EventArray ,FALSE ,WSA_INFINITE,FALSE);

// 注意这里返回的Index并非是事件在数组里的Index，而是需要减去WSA_WAIT_EVENT_0

dwIndex = dwIndex – WSA_WAIT_EVENT_0;

 

第七步：使用WSAResetEvent函数重设当前这个用完的事件对象

 

事件已经被触发了之后，它对于我们来说已经没有利用价值了，所以要将它重置一下留待下一次使用，很简单，就一步，连返回值都不用考虑。

WSAResetEvent(EventArray[dwIndex]);

 

第八步：使用WSAGetOverlappedResult函数取得重叠调用的返回状态

 

这是我们最关心的事情，费了那么大劲投递的这个重叠操作究竟是个什么结果呢？其实对于本模型来说，唯一需要检查一下的就是对方的Socket连接是否已经关闭了。

 

DWORD dwBytesTransferred;

WSAGetOverlappedResult( AcceptSocket,AcceptOverlapped,&dwBytesTransferred, FALSE, &Flags);

// 先检查通信对方是否已经关闭连接，如果dwBytesTransferred等于0则表示连接已经关闭，就关闭套接字。

if(dwBytesTransferred == 0)

{

closesocket(AcceptSocket);

WSACloseEvent(EventArray[dwIndex]); // 关闭事件

return;

}

 

 

第九步：“享受”接收到的数据

 

如果程序执行到了这里，那么就说明一切正常，WSABUF结构里面就存有我们WSARecv来的数据了，终于到了尽情享用成果的时候了！喝杯茶，休息一下吧~~~^_^

 

DataBuf.buf就是一个char*字符串指针，听凭你的处理吧，这里就不多说了。

 

 

第十步：同第五步一样，在套接字上继续投递WSARecv请求，然后重复步骤 6 ~ 9。

 

这样一路下来，我们终于可以从客户端接收到数据了，但是回想起来，呀~~~~~，这岂不是只能收到一次数据，然后程序不就Over了？所以我们接下来不得不重复一遍第五步到第九步的工作，再次在这个套接字上投递另一个WSARecv请求，并且使整个过程循环起来，are u clear？

 

五、多客户端情况的注意事项

 

完成了上面的循环以后，重叠I/O就已经基本上搭建好了80%了，为什么不是100%呢？因为仔细一回想起来，呀~~~~~~~，这样岂不是只能连接一个客户端？是的，如果只处理一个客户端，那重叠I/O就半点优势也没有了，我们正是要使用重叠I/O来处理多个客户端。

 

所以我们不得不再对结构作一些改动。

 

首先需要一个SOCKET数组 ,分别用来和每一个SOCKET通信。其次，因为重叠I/O中每一个SOCKET操作都是要“绑定”一个重叠结构的，所以需要为每一个SOCKET操作搭配一个WSAOVERLAPPED结构，但是这样说并不严格，因为如果每一个SOCKET同时只有一个操作，比如WSARecv，那么一个SOCKET就可以对应一个WSAOVERLAPPED结构，但是如果一个SOCKET上会有WSARecv 和WSASend两个操作，那么一个SOCKET肯定就要对应两个WSAOVERLAPPED结构，所以有多少个SOCKET操作就会有多少个WSAOVERLAPPED结构。

 

然后，同样是为每一个WSAOVERLAPPED结构都要搭配一个WSAEVENT事件，所以说有多少个SOCKET操作就应该有多少个WSAOVERLAPPED结构，有多少个WSAOVERLAPPED结构就应该有多少个WSAEVENT事件，最好把SOCKET、WSAOVERLAPPED 、WSAEVENT三者的关联起来，到了关键时刻才会临危不乱。

 

须要开两个线程。一个线程用来循环监听端口，接收请求的连接，然后给在这个套接字上配合一个WSAOVERLAPPED结构投递第一个WSARecv请求。另一个个线程用来不停的对WSAEVENT数组WSAWaitForMultipleEvents，等待任何一个重叠操作的完成，然后根据返回的索引值进行处理，处理完毕以后再继续投递下一个WSARecv请求。

 

这里需要注意一点的是，前面是把WSAWaitForMultipleEvents函数的参数设置为WSA_INFINITE的，但是在多客户端的时候这样就不好了，需要设定一个超时时间，如果等待超时了再重新WSAWaitForMultipleEvents。因为WSAWaitForMultipleEvents函数在没有触发的时候是阻塞在那里的，我们可以设想一下，这时如果监听线程中接入了新的连接，自然也会为这个连接增加一个Event，但是WSAWaitForMultipleEvents还是阻塞在那里就不会处理这个新连接的Event了。