-
Notifications
You must be signed in to change notification settings - Fork 0
/
patch.cpp
122 lines (105 loc) · 3.22 KB
/
patch.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include "patch.h"
#include <iostream>
// --------------------------------------------------------------------------
patch::patch(int owner, double x0, double x1,
double y0, double y1, double z0, double z1) : m_owner(owner), m_x(def_alloc())
{
double bds[] = {x0, x1, y0, y1, z0, z1};
hamr::buffer<double> x(def_alloc(), 6, bds);
m_x.swap(x);
}
// --------------------------------------------------------------------------
patch::patch(const patch &p) : m_x(p.m_x)
{
m_owner = p.m_owner;
}
// --------------------------------------------------------------------------
void patch::operator=(const patch &p)
{
m_owner = p.m_owner;
m_x.assign(p.m_x);
}
// --------------------------------------------------------------------------
std::ostream &operator<<(std::ostream &os, const patch &p)
{
auto spx = p.m_x.get_host_accessible();
const double *px = spx.get();
os << "{" << p.m_owner << " [" << px[0] << ", " << px[1] << ", "
<< px[2] << ", " << px[3] << ", " << px[4] << ", " << px[5] << "]}";
return os;
}
/*
// --------------------------------------------------------------------------
void grow(patch &p, double amt)
{
p.m_x[0] -= amt;
p.m_x[1] += amt;
p.m_x[2] -= amt;
p.m_x[3] += amt;
}
// --------------------------------------------------------------------------
void shrink(patch &p, double amt)
{
p.m_x[0] += amt;
p.m_x[1] -= amt;
p.m_x[2] += amt;
p.m_x[3] -= amt;
}
*/
/*
// --------------------------------------------------------------------------
bool intersects(const patch &lp, const patch &rp)
{
double lx = std::max(lp.m_x[0], rp.m_x[0]);
double hx = std::min(lp.m_x[1], rp.m_x[1]);
double ly = std::max(lp.m_x[2], rp.m_x[2]);
double hy = std::min(lp.m_x[3], rp.m_x[3]);
return (lx <= hx) && (ly <= hy);
}
*/
/*
// --------------------------------------------------------------------------
bool inside(const patch &p, double x, double y)
{
return (x >= p.m_x[0]) && (x < p.m_x[1]) && (y >= p.m_x[2]) && (y < p.m_x[3]);
}
*/
/** finds the list of patch neighbors and returns them in pn. returns the
* non-neighbor patches in pnn
// --------------------------------------------------------------------------
void neighbors(const std::vector<patch> &patches,
double ofs, std::vector<std::vector<int>> &pn, std::vector<std::vector<int>> &pnn)
{
std::vector<patch> smallp(patches);
// make patches disjoint by shrinking a small amount
int n = patches.size();
for (int i = 0; i < n; ++i)
shrink(smallp[i], ofs);
double ofs2 = 2*ofs;
// a neighbor list for each patch
pn.resize(n);
pnn.resize(n);
for (int i = 0; i < n; ++i)
{
// grow active patch by 2x the small amount
patch actp = patches[i];
grow(actp, ofs2);
// see which of the others this patch intersects
for (int j = 0; j < n; ++j)
{
// dont test a patch against itself
if (i == j) continue;
const patch &spj = smallp[j];
if (intersects(actp, spj))
{
// j is a neighbor of i
pn[i].push_back(j);
}
else
{
pnn[i].push_back(j);
}
}
}
}
*/