重複する長方形の領域を見つけるための効率的なアルゴリズムとは
私の状況
- 入力：長方形のセット
- 各長方形は、次のような4つのdoubleで構成されます：（x0、y0、x1、y1）
- それらはどの角度でも「回転」せず、画面に対して「上/下」および「左/右」になる「通常」の長方形です。
- ランダムに配置されている-端が接触している、重なり合っている、または接触していない
- 数百の長方形ができます
- これはC＃で実装されています
私は見つける必要があります
- オーバーラップによって形成される領域-複数の長方形が「覆う」キャンバス内のすべての領域（たとえば、2つの長方形の場合、交差点になります）
- オーバーラップのジオメトリは必要ありません-領域のみ（例：4平方インチ）
- 重複は複数回カウントされるべきではありません-たとえば、同じサイズと位置をもつ3つの長方形を想像してください-それらは互いに真っ直ぐです-この領域は1回（3回ではなく）カウントされるべきです
例
- 以下の画像には3つの長方形が含まれています：A、B、C
- AとBが重複している（ダッシュで示されている）
- BとCが重複している（ダッシュで示されている）
- 私が探しているのは、ダッシュが表示される領域です
-
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAA--------------BBB
AAAAAAAAAAAAAAAA--------------BBB
AAAAAAAAAAAAAAAA--------------BBB
AAAAAAAAAAAAAAAA--------------BBB
BBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBB
BBBBBB-----------CCCCCCCC
BBBBBB-----------CCCCCCCC
BBBBBB-----------CCCCCCCC
CCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCC
この領域を計算する効率的な方法は、スイープアルゴリズムを使用することです。長方形のユニオンUを通る垂直線L(x)）をスイープすると仮定します。
- まず、イベントキューQを作成する必要があります。この場合は、長方形のすべてのx座標（左右）の順序付きリストです。
- スイープ中は、1Dデータ構造を維持する必要があります。これにより、L(x)とUの交点の合計長が得られます。 Qのイベントqおよびq '。したがって、l(q)がL（q +）の全長（すなわち、qの右側にあるL）がUと交差する場合、面積はスイープイベントqとq 'の間のLによるl（q）*（q'-q）.
- これらすべての掃引エリアを合計して、合計1つを取得する必要があります。
1D問題を解決する必要があります。 （垂直）セグメントの和集合を動的に計算する1D構造が必要です。動的には、新しいセグメントを追加したり、削除したりすることがあります。
私はすでにこれに対する回答で詳細に説明しています 折りたたみ範囲の質問 静的な方法での方法（実際には1Dスイープです）。したがって、単純なものが必要な場合は、それを直接適用できます（各イベントのユニオンを再計算することにより）。より効率的なものが必要な場合は、少し調整する必要があります。
- セグメントSの結合を知っていると仮定します1... Sn 互いに素なセグメントDで構成されます1... Dk。 Sを追加するn + 1 とても簡単です。Sの両端を見つけるだけですn + 1 Dの両端の中1... Dk。
- セグメントSの結合を知っていると仮定します1... Sn 互いに素なセグメントDで構成されます1... Dk、セグメントSの削除私 （S私 Dに含まれていたj）は、Dのセグメントの和集合を再計算することを意味しますj Sを除く私 （静的アルゴリズムを使用）。
これが動的アルゴリズムです。 Dを表すために、ログ時間の場所のクエリで並べ替えられたセットを使用すると仮定します1... Dk、これはおそらくあなたが得ることができる最も効率的な非専門化された方法です。
解決方法の1つは、キャンバスにプロットすることです！半透明の色を使用して各長方形を描きます。 .NETランタイムは、最適化されたネイティブコードで、またはハードウェアアクセラレータを使用して描画を行います。
次に、ピクセルを読み戻す必要があります。各ピクセルは背景色、長方形色、または別の色ですか？別の色にできる唯一の方法は、2つ以上の長方形が重なっている場合です...
これがチートすぎる場合、別の回答者が行ったようにクアッドツリー、または r-tree をお勧めします。
最も簡単な解決策
_import numpy as np
A = np.zeros((100, 100))
B = np.zeros((100, 100))
A[rect1.top : rect1.bottom, rect1.left : rect1.right] = 1
B[rect2.top : rect2.bottom, rect2.left : rect2.right] = 1
area_of_union = np.sum((A + B) > 0)
area_of_intersect = np.sum((A + B) > 1)
_この例では、キャンバスのサイズである2つのゼロ行列を作成します。各長方形について、これらのマトリックスの1つを、長方形がスペースを占有するマトリックスで満たします。次に、行列を合計します。 sum(A+B > 0)はユニオンの領域であり、sum(A+B > 1)はオーバーラップの領域です。この例は、複数の長方形に簡単に一般化できます。
これは、TopCoder SRM 160 Div 2で使用した、すばやくて汚いコードです。
t =トップ
b =底
l =左
r =右
public class Rect
{
public int t, b, l, r;
public Rect(int _l, int _b, int _r, int _t)
{
t = _t;
b = _b;
l = _l;
r = _r;
}
public bool Intersects(Rect R)
{
return !(l > R.r || R.l > r || R.b > t || b > R.t);
}
public Rect Intersection(Rect R)
{
if(!this.Intersects(R))
return new Rect(0,0,0,0);
int [] horiz = {l, r, R.l, R.r};
Array.Sort(horiz);
int [] vert = {b, t, R.b, R.t};
Array.Sort(vert);
return new Rect(horiz[1], vert[1], horiz[2], vert[2]);
}
public int Area()
{
return (t - b)*(r-l);
}
public override string ToString()
{
return l + " " + b + " " + r + " " + t;
}
}
これは私の頭上でうまくいくかもしれないと思われるものです：
次のように、ダブルキーと、長方形とブール値のリストを使用して辞書を作成します。
辞書<ダブル、リスト<KeyValuePair <長方形、ブール値>>>長方形。
セット内の各長方形について、x0値とx1値に対応するリストを見つけ、そのリストに長方形を追加します。ブール値はx0に対してtrue、x1に対してfalseです。これにより、各長方形がx方向に入る（true）または出る（false）すべてのx座標の完全なリストが得られます。
そのディクショナリからすべてのキー（すべての個別のX座標）を取得し、並べ替え、順番にループし、現在のX値と次のX値の両方に到達できることを確認します（両方が必要です） ）。これにより、長方形の個々のストリップが得られます
- 現在見ている長方形のセットを維持します。これは空から始まります。長方形が真の値で登録されている場合、ポイント3で反復する各x値について、セットに追加し、そうでない場合は削除します。
- ストリップの場合、y座標で長方形をソートします
- ストリップ内の長方形をループし、重複する距離をカウントします（これを効率的に行う方法はまだわかりません）
- ストリップの幅と重複する距離の高さを計算して面積を取得する
例、5つの長方形、aからeまで、互いの上に描画します。
aaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbb
aaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbb
aaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbb
aaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbb
aaaaaaaadddddddddddddddddddddddddddddbbbbbb
aaaaaaaadddddddddddddddddddddddddddddbbbbbb
ddddddddddddddddddddddddddddd
ddddddddddddddddddddddddddddd
ddddddddddddddeeeeeeeeeeeeeeeeee
ddddddddddddddeeeeeeeeeeeeeeeeee
ddddddddddddddeeeeeeeeeeeeeeeeee
ccccccccddddddddddddddeeeeeeeeeeeeeeeeee
ccccccccddddddddddddddeeeeeeeeeeeeeeeeee
cccccccccccc eeeeeeeeeeeeeeeeee
cccccccccccc eeeeeeeeeeeeeeeeee
cccccccccccc
cccccccccccc
X座標のリストは次のとおりです。
v v v v v v v v v
|aaaaaaa|aa|aaaa | bbbbbbbbbb|bb|bbb
|aaaaaaa|aa|aaaa | bbbbbbbbbb|bb|bbb
|aaaaaaa|aa|aaaa | bbbbbbbbbb|bb|bbb
|aaaaaaa|aa|aaaa | bbbbbbbbbb|bb|bbb
|aaaaaaaddd|dddddddddd|ddddddddddddddbb|bbb
|aaaaaaaddd|dddddddddd|ddddddddddddddbb|bbb
| ddd|dddddddddd|dddddddddddddd |
| ddd|dddddddddd|dddddddddddddd |
| ddd|ddddddddddeeeeeeeeeeeeeeeeee
| ddd|ddddddddddeeeeeeeeeeeeeeeeee
| ddd|ddddddddddeeeeeeeeeeeeeeeeee
ccccccccddd|ddddddddddeeeeeeeeeeeeeeeeee
ccccccccddd|ddddddddddeeeeeeeeeeeeeeeeee
cccccccccccc eeeeeeeeeeeeeeeeee
cccccccccccc eeeeeeeeeeeeeeeeee
cccccccccccc
cccccccccccc
リストは次のようになります（各vには、0から始まり上に向かう座標が単に与えられます）。
0: +a, +c
1: +d
2: -c
3: -a
4: +e
5: +b
6: -d
7: -e
8: -b
したがって、各ストリップは次のようになります（長方形は上から下にソートされます）。
0-1: a, c
1-2: a, d, c
2-3: a, d
3-4: d
4-5: d, e
5-6: b, d, e
6-7: b, e
7-8: b
各ストリップのオーバーラップは次のようになります。
0-1: none
1-2: a/d, d/c
2-3: a/d
3-4: none
4-5: d/e
5-6: b/d, d/e
6-7: none
7-8: none
上下チェック用のソートとエンター/リーブアルゴリズムのバリエーションも同様に実行できると思います。
- ストリップで現在分析している四角形を上から下に並べ替えます。同じ上座標を持つ四角形については、下の座標でも並べ替えます
- y座標を反復処理し、長方形を入力するとセットに追加され、長方形を離れるとセットから削除されます
- セットに複数の長方形がある場合は常にオーバーラップします（また、現在見ている上下座標が同じであるすべての長方形を追加/削除するようにすれば、複数の長方形の重なりは問題になりません。
上記の1-2ストリップでは、次のように繰り返します。
0. empty set, zero sum
1. enter a, add a to set (1 rectangle in set)
2. enter d, add d to set (>1 rectangles in set = overlap, store this y-coordinate)
3. leave a, remove a from set (now back from >1 rectangles in set, add to sum: y - stored_y
4. enter c, add c to set (>1 rectangles in set = overlap, store this y-coordinate)
5. leave d, remove d from set (now back from >1 rectangles in set, add to sum: y - stored_y)
6. multiply sum with width of strip to get overlapping areas
ここに実際のセットを保持する必要もありません。1から2になったときは常にyを保存し、2から1になったときは現在のyを計算します。 yを保存し、この差を合計します。
これが理解できることを願っています、そして、私が言ったように、これは私の頭のてっぺんから外れており、いかなる方法でもテストされていません。
例の使用：
1 2 3 4 5 6 1 + --- + --- + | | 2 + A + --- + --- + | | B | 3 + + + --- + --- + | | | | | 4 + --- + --- + --- + --- + + | | 5 + C + | | 6 + --- + --- +
1）すべてのx座標（左と右の両方）をリストに収集し、それをソートして重複を削除します
1 3 4 5 6
2）すべてのy座標（上部と下部の両方）をリストに収集し、ソートして重複を削除します
1 2 3 4 6
3）一意のx座標間のギャップ数*一意のy座標間のギャップ数によって2D配列を作成します。
4 * 4
4）すべての長方形をこのグリッドにペイントし、発生する各セルの数を増やします：
1 3 4 5 6 1 + --- + | 1 | 0 0 0 2 + --- + --- + --- + | 1 | 1 | 1 | 0 3 + --- + --- + --- + --- + | 1 | 1 | 2 | 1 | 4 + --- + --- + --- + --- + 0 0 | 1 | 1 | 6 + --- + --- +
5）カウントが1より大きいグリッド内のセルの面積の合計が、重複する面積です。スパースユースケースの効率を高めるために、セルを1から2に移動するたびに長方形をペイントするときに、実際に面積の合計を維持できます。
質問では、長方形は4つのdoubleとして記述されています。通常、倍精度には丸め誤差が含まれ、計算された重複領域に誤差が入り込む可能性があります。有効な座標が有限点にある場合、整数表現の使用を検討してください。
私の他の答えのようにハードウェアアクセラレータを使用するPSは、解像度が許容できる場合、そのようなみすぼらしいアイデアではありません。また、上記で説明したアプローチよりもはるかに少ないコードで簡単に実装できます。コース用の馬。
エリアスイープアルゴリズム用に書いたコードは次のとおりです。
#include <iostream>
#include <vector>
using namespace std;
class Rectangle {
public:
int x[2], y[2];
Rectangle(int x1, int y1, int x2, int y2) {
x[0] = x1;
y[0] = y1;
x[1] = x2;
y[1] = y2;
};
void print(void) {
cout << "Rect: " << x[0] << " " << y[0] << " " << x[1] << " " << y[1] << " " <<endl;
};
};
// return the iterator of rec in list
vector<Rectangle *>::iterator bin_search(vector<Rectangle *> &list, int begin, int end, Rectangle *rec) {
cout << begin << " " <<end <<endl;
int mid = (begin+end)/2;
if (list[mid]->y[0] == rec->y[0]) {
if (list[mid]->y[1] == rec->y[1])
return list.begin() + mid;
else if (list[mid]->y[1] < rec->y[1]) {
if (mid == end)
return list.begin() + mid+1;
return bin_search(list,mid+1,mid,rec);
}
else {
if (mid == begin)
return list.begin()+mid;
return bin_search(list,begin,mid-1,rec);
}
}
else if (list[mid]->y[0] < rec->y[0]) {
if (mid == end) {
return list.begin() + mid+1;
}
return bin_search(list, mid+1, end, rec);
}
else {
if (mid == begin) {
return list.begin() + mid;
}
return bin_search(list, begin, mid-1, rec);
}
}
// add rect to rects
void add_rec(Rectangle *rect, vector<Rectangle *> &rects) {
if (rects.size() == 0) {
rects.Push_back(rect);
}
else {
vector<Rectangle *>::iterator it = bin_search(rects, 0, rects.size()-1, rect);
rects.insert(it, rect);
}
}
// remove rec from rets
void remove_rec(Rectangle *rect, vector<Rectangle *> &rects) {
vector<Rectangle *>::iterator it = bin_search(rects, 0, rects.size()-1, rect);
rects.erase(it);
}
// calculate the total vertical length covered by rectangles in the active set
int vert_dist(vector<Rectangle *> as) {
int n = as.size();
int totallength = 0;
int start, end;
int i = 0;
while (i < n) {
start = as[i]->y[0];
end = as[i]->y[1];
while (i < n && as[i]->y[0] <= end) {
if (as[i]->y[1] > end) {
end = as[i]->y[1];
}
i++;
}
totallength += end-start;
}
return totallength;
}
bool mycomp1(Rectangle* a, Rectangle* b) {
return (a->x[0] < b->x[0]);
}
bool mycomp2(Rectangle* a, Rectangle* b) {
return (a->x[1] < b->x[1]);
}
int findarea(vector<Rectangle *> rects) {
vector<Rectangle *> start = rects;
vector<Rectangle *> end = rects;
sort(start.begin(), start.end(), mycomp1);
sort(end.begin(), end.end(), mycomp2);
// active set
vector<Rectangle *> as;
int n = rects.size();
int totalarea = 0;
int current = start[0]->x[0];
int next;
int i = 0, j = 0;
// big loop
while (j < n) {
cout << "loop---------------"<<endl;
// add all recs that start at current
while (i < n && start[i]->x[0] == current) {
cout << "add" <<endl;
// add start[i] to AS
add_rec(start[i], as);
cout << "after" <<endl;
i++;
}
// remove all recs that end at current
while (j < n && end[j]->x[1] == current) {
cout << "remove" <<endl;
// remove end[j] from AS
remove_rec(end[j], as);
cout << "after" <<endl;
j++;
}
// find next event x
if (i < n && j < n) {
if (start[i]->x[0] <= end[j]->x[1]) {
next = start[i]->x[0];
}
else {
next = end[j]->x[1];
}
}
else if (j < n) {
next = end[j]->x[1];
}
// distance to next event
int horiz = next - current;
cout << "horiz: " << horiz <<endl;
// figure out vertical dist
int vert = vert_dist(as);
cout << "vert: " << vert <<endl;
totalarea += vert * horiz;
current = next;
}
return totalarea;
}
int main() {
vector<Rectangle *> rects;
rects.Push_back(new Rectangle(0,0,1,1));
rects.Push_back(new Rectangle(1,0,2,3));
rects.Push_back(new Rectangle(0,0,3,3));
rects.Push_back(new Rectangle(1,0,5,1));
cout << findarea(rects) <<endl;
}
各長方形を小さな長方形に分割すると、この問題をかなり単純化できます。すべての長方形のすべてのX座標とY座標を収集します。これらは分割点になります。長方形が線と交差する場合は、2つに分割します。完了すると、0％または100％のいずれかに重なる長方形のリストが表示されます。それらを並べ替えると、同一の長方形を簡単に見つけることができます。
リンクにリストされたソリューションがあります http://codercareer.blogspot.com/2011/12/no-27-area-of-rectangles.html 複数の長方形の合計面積を見つけるために重複した領域は1回だけカウントされます。
上記のソリューションを拡張して、連続する垂直スイープラインのペアごとに水平スイープラインを使用して、オーバーラップエリア（重複エリアが複数の長方形で覆われていても1回だけ）のみを計算できます。
目的が、すべての長方形でカバーされる総面積を見つけることだけである場合、水平スイープラインは不要であり、2つの垂直スイープライン間のすべての長方形のマージだけで領域が得られます。
一方、重複領域のみを計算する場合は、垂直（y1、y2）スイープラインの間にいくつの長方形が重なっているかを調べるために水平スイープラインが必要です。
Javaで実装したソリューションの作業コードは次のとおりです。
import Java.io.*;
import Java.util.*;
class Solution {
static class Rectangle{
int x;
int y;
int dx;
int dy;
Rectangle(int x, int y, int dx, int dy){
this.x = x;
this.y = y;
this.dx = dx;
this.dy = dy;
}
Range getBottomLeft(){
return new Range(x, y);
}
Range getTopRight(){
return new Range(x + dx, y + dy);
}
@Override
public int hashCode(){
return (x+y+dx+dy)/4;
}
@Override
public boolean equals(Object other){
Rectangle o = (Rectangle) other;
return o.x == this.x && o.y == this.y && o.dx == this.dx && o.dy == this.dy;
}
@Override
public String toString(){
return String.format("X = %d, Y = %d, dx : %d, dy : %d", x, y, dx, dy);
}
}
static class RW{
Rectangle r;
boolean start;
RW (Rectangle r, boolean start){
this.r = r;
this.start = start;
}
@Override
public int hashCode(){
return r.hashCode() + (start ? 1 : 0);
}
@Override
public boolean equals(Object other){
RW o = (RW)other;
return o.start == this.start && o.r.equals(this.r);
}
@Override
public String toString(){
return "Rectangle : " + r.toString() + ", start = " + this.start;
}
}
static class Range{
int l;
int u;
public Range(int l, int u){
this.l = l;
this.u = u;
}
@Override
public int hashCode(){
return (l+u)/2;
}
@Override
public boolean equals(Object other){
Range o = (Range) other;
return o.l == this.l && o.u == this.u;
}
@Override
public String toString(){
return String.format("L = %d, U = %d", l, u);
}
}
static class XComp implements Comparator<RW>{
@Override
public int compare(RW rw1, RW rw2){
//TODO : revisit these values.
Integer x1 = -1;
Integer x2 = -1;
if(rw1.start){
x1 = rw1.r.x;
}else{
x1 = rw1.r.x + rw1.r.dx;
}
if(rw2.start){
x2 = rw2.r.x;
}else{
x2 = rw2.r.x + rw2.r.dx;
}
return x1.compareTo(x2);
}
}
static class YComp implements Comparator<RW>{
@Override
public int compare(RW rw1, RW rw2){
//TODO : revisit these values.
Integer y1 = -1;
Integer y2 = -1;
if(rw1.start){
y1 = rw1.r.y;
}else{
y1 = rw1.r.y + rw1.r.dy;
}
if(rw2.start){
y2 = rw2.r.y;
}else{
y2 = rw2.r.y + rw2.r.dy;
}
return y1.compareTo(y2);
}
}
public static void main(String []args){
Rectangle [] rects = new Rectangle[4];
rects[0] = new Rectangle(10, 10, 10, 10);
rects[1] = new Rectangle(15, 10, 10, 10);
rects[2] = new Rectangle(20, 10, 10, 10);
rects[3] = new Rectangle(25, 10, 10, 10);
int totalArea = getArea(rects, false);
System.out.println("Total Area : " + totalArea);
int overlapArea = getArea(rects, true);
System.out.println("Overlap Area : " + overlapArea);
}
static int getArea(Rectangle []rects, boolean overlapOrTotal){
printArr(rects);
// step 1: create two wrappers for every rectangle
RW []rws = getWrappers(rects);
printArr(rws);
// steps 2 : sort rectangles by their x-coordinates
Arrays.sort(rws, new XComp());
printArr(rws);
// step 3 : group the rectangles in every range.
Map<Range, List<Rectangle>> rangeGroups = groupRects(rws, true);
for(Range xrange : rangeGroups.keySet()){
List<Rectangle> xRangeRects = rangeGroups.get(xrange);
System.out.println("Range : " + xrange);
System.out.println("Rectangles : ");
for(Rectangle rectx : xRangeRects){
System.out.println("\t" + rectx);
}
}
// step 4 : iterate through each of the pairs and their rectangles
int sum = 0;
for(Range range : rangeGroups.keySet()){
List<Rectangle> rangeRects = rangeGroups.get(range);
sum += getOverlapOrTotalArea(rangeRects, range, overlapOrTotal);
}
return sum;
}
static Map<Range, List<Rectangle>> groupRects(RW []rws, boolean isX){
//group the rws with either x or y coordinates.
Map<Range, List<Rectangle>> rangeGroups = new HashMap<Range, List<Rectangle>>();
List<Rectangle> rangeRects = new ArrayList<Rectangle>();
int i=0;
int prev = Integer.MAX_VALUE;
while(i < rws.length){
int curr = isX ? (rws[i].start ? rws[i].r.x : rws[i].r.x + rws[i].r.dx): (rws[i].start ? rws[i].r.y : rws[i].r.y + rws[i].r.dy);
if(prev < curr){
Range nRange = new Range(prev, curr);
rangeGroups.put(nRange, rangeRects);
rangeRects = new ArrayList<Rectangle>(rangeRects);
}
prev = curr;
if(rws[i].start){
rangeRects.add(rws[i].r);
}else{
rangeRects.remove(rws[i].r);
}
i++;
}
return rangeGroups;
}
static int getOverlapOrTotalArea(List<Rectangle> rangeRects, Range range, boolean isOverlap){
//create horizontal sweep lines similar to vertical ones created above
// Step 1 : create wrappers again
RW []rws = getWrappers(rangeRects);
// steps 2 : sort rectangles by their y-coordinates
Arrays.sort(rws, new YComp());
// step 3 : group the rectangles in every range.
Map<Range, List<Rectangle>> yRangeGroups = groupRects(rws, false);
//step 4 : for every range if there are more than one rectangles then computer their area only once.
int sum = 0;
for(Range yRange : yRangeGroups.keySet()){
List<Rectangle> yRangeRects = yRangeGroups.get(yRange);
if(isOverlap){
if(yRangeRects.size() > 1){
sum += getArea(range, yRange);
}
}else{
if(yRangeRects.size() > 0){
sum += getArea(range, yRange);
}
}
}
return sum;
}
static int getArea(Range r1, Range r2){
return (r2.u-r2.l)*(r1.u-r1.l);
}
static RW[] getWrappers(Rectangle []rects){
RW[] wrappers = new RW[rects.length * 2];
for(int i=0,j=0;i<rects.length;i++, j+=2){
wrappers[j] = new RW(rects[i], true);
wrappers[j+1] = new RW(rects[i], false);
}
return wrappers;
}
static RW[] getWrappers(List<Rectangle> rects){
RW[] wrappers = new RW[rects.size() * 2];
for(int i=0,j=0;i<rects.size();i++, j+=2){
wrappers[j] = new RW(rects.get(i), true);
wrappers[j+1] = new RW(rects.get(i), false);
}
return wrappers;
}
static void printArr(Object []a){
for(int i=0; i < a.length;i++){
System.out.println(a[i]);
}
System.out.println();
}
2つの長方形（AとB）があり、左下（x1、y1）と右上（x2、y2）の調整があることを考慮してください。次のコードを使用すると、C++で重複領域を計算できます。
#include <iostream>
using namespace std;
int rectoverlap (int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2)
{
int width, heigh, area;
if (ax2<bx1 || ay2<by1 || ax1>bx2 || ay1>by2) {
cout << "Rectangles are not overlapped" << endl;
return 0;
}
if (ax2>=bx2 && bx1>=ax1){
width=bx2-bx1;
heigh=by2-by1;
} else if (bx2>=ax2 && ax1>=bx1) {
width=ax2-ax1;
heigh=ay2-ay1;
} else {
if (ax2>bx2){
width=bx2-ax1;
} else {
width=ax2-bx1;
}
if (ay2>by2){
heigh=by2-ay1;
} else {
heigh=ay2-by1;
}
}
area= heigh*width;
return (area);
}
int main()
{
int ax1,ay1,ax2,ay2,bx1,by1,bx2,by2;
cout << "Inter the x value for bottom left for rectangle A" << endl;
cin >> ax1;
cout << "Inter the y value for bottom left for rectangle A" << endl;
cin >> ay1;
cout << "Inter the x value for top right for rectangle A" << endl;
cin >> ax2;
cout << "Inter the y value for top right for rectangle A" << endl;
cin >> ay2;
cout << "Inter the x value for bottom left for rectangle B" << endl;
cin >> bx1;
cout << "Inter the y value for bottom left for rectangle B" << endl;
cin >> by1;
cout << "Inter the x value for top right for rectangle B" << endl;
cin >> bx2;
cout << "Inter the y value for top right for rectangle B" << endl;
cin >> by2;
cout << "The overlapped area is " << rectoverlap (ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) << endl;
}
次の答えは、合計面積を一度だけ与える必要があります。以前の回答がありますが、現在はC＃で実装されています。また、float（または必要な場合はdoubleでも機能します。
クレジット： http://codercareer.blogspot.co.il/2011/12/no-27-area-of-rectangles.html
編集：OPは重複領域を要求しました-それは明らかに非常に簡単です：
var totArea = rects.Sum(x => x.Width * x.Height);
そして、答えは次のとおりです。
var overlappingArea =totArea-GetArea(rects)
コードは次のとおりです。
#region rectangle overlapping
/// <summary>
/// see algorithm for detecting overlapping areas here: https://stackoverflow.com/a/245245/3225391
/// or easier here:
/// http://codercareer.blogspot.co.il/2011/12/no-27-area-of-rectangles.html
/// </summary>
/// <param name="dim"></param>
/// <returns></returns>
public static float GetArea(RectangleF[] rects)
{
List<float> xs = new List<float>();
foreach (var item in rects)
{
xs.Add(item.X);
xs.Add(item.Right);
}
xs = xs.OrderBy(x => x).Cast<float>().ToList();
rects = rects.OrderBy(rec => rec.X).Cast<RectangleF>().ToArray();
float area = 0f;
for (int i = 0; i < xs.Count - 1; i++)
{
if (xs[i] == xs[i + 1])//not duplicate
continue;
int j = 0;
while (rects[j].Right < xs[i])
j++;
List<Range> rangesOfY = new List<Range>();
var rangeX = new Range(xs[i], xs[i + 1]);
GetRangesOfY(rects, j, rangeX, out rangesOfY);
area += GetRectArea(rangeX, rangesOfY);
}
return area;
}
private static void GetRangesOfY(RectangleF[] rects, int rectIdx, Range rangeX, out List<Range> rangesOfY)
{
rangesOfY = new List<Range>();
for (int j = rectIdx; j < rects.Length; j++)
{
if (rangeX.less < rects[j].Right && rangeX.greater > rects[j].Left)
{
rangesOfY = Range.AddRange(rangesOfY, new Range(rects[j].Top, rects[j].Bottom));
#if DEBUG
Range rectXRange = new Range(rects[j].Left, rects[j].Right);
#endif
}
}
}
static float GetRectArea(Range rangeX, List<Range> rangesOfY)
{
float width = rangeX.greater - rangeX.less,
area = 0;
foreach (var item in rangesOfY)
{
float height = item.greater - item.less;
area += width * height;
}
return area;
}
internal class Range
{
internal static List<Range> AddRange(List<Range> lst, Range rng2add)
{
if (lst.isNullOrEmpty())
{
return new List<Range>() { rng2add };
}
for (int i = lst.Count - 1; i >= 0; i--)
{
var item = lst[i];
if (item.IsOverlapping(rng2add))
{
rng2add.Merge(item);
lst.Remove(item);
}
}
lst.Add(rng2add);
return lst;
}
internal float greater, less;
public override string ToString()
{
return $"ln{less} gtn{greater}";
}
internal Range(float less, float greater)
{
this.less = less;
this.greater = greater;
}
private void Merge(Range rng2add)
{
this.less = Math.Min(rng2add.less, this.less);
this.greater = Math.Max(rng2add.greater, this.greater);
}
private bool IsOverlapping(Range rng2add)
{
return !(less > rng2add.greater || rng2add.less > greater);
//return
// this.greater < rng2add.greater && this.greater > rng2add.less
// || this.less > rng2add.less && this.less < rng2add.greater
// || rng2add.greater < this.greater && rng2add.greater > this.less
// || rng2add.less > this.less && rng2add.less < this.greater;
}
}
#endregion rectangle overlapping
このタイプの衝突検出は、AABB（Axis Aligned Bounding Boxes）と呼ばれることが多く、 google search の出発点として適しています。
スイープアルゴリズムとは異なる解決策を見つけました。
長方形はすべて長方形に配置されるため、長方形の水平線と垂直線は長方形の不規則なグリッドを形成します。このグリッド上の長方形を「ペイント」できます。つまり、グリッドのどのフィールドに入力するかを決定できます。グリッド線は指定された長方形の境界から形成されるため、このグリッドのフィールドは常に完全に空になるか、長方形で完全に塗りつぶされます。
私はJavaの問題を解決しなければならなかったので、ここに私の解決策があります： http://Pastebin.com/03mss8yf
この関数は、長方形が占める完全な領域を計算します。 「重複」部分のみに関心がある場合は、コードブロックを行70と72の間で拡張する必要があります。2番目のセットを使用して、どのグリッドフィールドが複数回使用されるかを格納できます。 70行目から72行目までのコードは、次のようなブロックに置き換える必要があります。
GridLocation gl = new GridLocation(curX, curY);
if(usedLocations.contains(gl) && usedLocations2.add(gl)) {
ret += width*height;
} else {
usedLocations.add(gl);
}
ここで使用される変数usedLocations2は、usedLocationsと同じ型です。同じ時点で構築されます。
私は複雑さの計算にあまり精通していません。そのため、2つのソリューション（スイープまたはグリッドソリューション）のどちらがパフォーマンス/スケーリングが優れているかわかりません。
X軸とy軸でオーバーラップを見つけ、それらを乗算できます。
int LineOverlap(int line1a, line1b, line2a, line2b)
{
// assume line1a <= line1b and line2a <= line2b
if (line1a < line2a)
{
if (line1b > line2b)
return line2b-line2a;
else if (line1b > line2a)
return line1b-line2a;
else
return 0;
}
else if (line2a < line1b)
return line2b-line1a;
else
return 0;
}
int RectangleOverlap(Rect rectA, rectB)
{
return LineOverlap(rectA.x1, rectA.x2, rectB.x1, rectB.x2) *
LineOverlap(rectA.y1, rectA.y2, rectB.y1, rectB.y2);
}