DBbox auxdata::DrcPoly::overlap() const
{
DBbox ovl(_pdata[0], _pdata[1]) ;
for (word i = 1; i < _psize; i++)
ovl.overlap(_pdata[2*i], _pdata[2*i+1]);
return ovl;
}
DBbox auxdata::DrcSeg::overlap() const
{
DBbox ovl(_sdata[0], _sdata[1]) ;
ovl.overlap(_sdata[2], _sdata[3]);
for (word i = 1; i < _ssize; i++)
{
ovl.overlap(_sdata[4*i ], _sdata[4*i+1]);
ovl.overlap(_sdata[4*i+2], _sdata[4*i+3]);
}
return ovl;
}
// Associate two windows given by a1->window() and a2->window().
void Rocface::
overlay( const COM::DataItem *a1,
const COM::DataItem *a2,
const MPI_Comm *comm,
const char *path) {
COM_assertion_msg( validate_object()==0, "Invalid object");
std::string n1 = a1->window()->name();
std::string n2 = a2->window()->name();
Overlay ovl( a1->window(), a2->window(), path);
ovl.set_tolerance( _ctrl.snap); // set tolerance for snapping vertices
// Perform overlay
ovl.overlay();
// Create new data structures for data transfer.
std::string wn1, wn2;
get_name( n1, n2, wn1); get_name( n2, n1, wn2);
TRS_Windows::iterator it1 = _trs_windows.find( wn1);
TRS_Windows::iterator it2 = _trs_windows.find( wn2);
if ( it1 != _trs_windows.end()) {
RFC_assertion( it2 != _trs_windows.end());
delete it1->second; delete it2->second;
}
else {
it1 = _trs_windows.
insert( TRS_Windows::value_type( wn1, NULL)).first;
RFC_assertion( it2 == _trs_windows.end());
it2 = _trs_windows.
insert( TRS_Windows::value_type( wn2, NULL)).first;
}
MPI_Comm com = (comm==NULL)?MPI_COMM_WORLD:*comm;
it1->second = new RFC_Window_transfer(const_cast<COM::Window*>(a1->window()),
BLUE, com);
it2->second = new RFC_Window_transfer(const_cast<COM::Window*>(a2->window()),
GREEN, com);
ovl.export_windows( it1->second, it2->second);
}
/*! Puts the shape into current quadTree object without sorting. Updates
the overlapping box though. */
void laydata::quadTree::put(tdtdata* shape) {
DBbox ovl(shape->overlap());ovl.normalize();
update_overlap(ovl);
shape->nextis(_first); _first = shape;
}
extern float pia_area(const point_t *a, size_t na,
const point_t *b, size_t nb)
{
if ( (na < 3) || (nb < 3) ) return 0.0;
box_t B = {{ FLT_MAX, FLT_MAX},
{-FLT_MAX, -FLT_MAX}};
range(a, na, &B);
range(b, nb, &B);
const float
gamut = 500000000.0,
mid = gamut / 2.0;
float
rngx = B.max.x - B.min.x,
sclx = gamut / rngx,
rngy = B.max.y - B.min.y,
scly = gamut / rngy;
vertex_t ipa[na + 1], ipb[nb + 1];
fit(a, na, ipa, 0, sclx, scly, mid, B);
fit(b, nb, ipb, 2, sclx, scly, mid, B);
double ascale = (double)sclx * (double)scly;
int64_t s = 0;
for (size_t j = 0 ; j < na ; ++j)
{
for (size_t k = 0 ; k < nb ; ++k)
{
if ( ovl(ipa[j].rx, ipb[k].rx) && ovl(ipa[j].ry, ipb[k].ry) )
{
int64_t
a1 = -area(ipa[j].ip, ipb[k].ip, ipb[k + 1].ip),
a2 = area(ipa[j + 1].ip, ipb[k].ip, ipb[k + 1].ip);
bool o = (a1<0);
if (o == (a2<0))
{
int64_t
a3 = area(ipb[k].ip, ipa[j].ip, ipa[j + 1].ip),
a4 = -area(ipb[k + 1].ip, ipa[j].ip, ipa[j + 1].ip);
if ((a3<0) == (a4<0))
{
if (o)
cross(ipa + j, ipa + j + 1, ipb + k, ipb + k + 1, a1, a2, a3, a4, &s);
else
cross(ipb + k, ipb + k + 1, ipa + j, ipa + j + 1, a3, a4, a1, a2, &s);
}
}
}
}
}
inness(ipa, na, ipb, nb, &s);
inness(ipb, nb, ipa, na, &s);
return s / ascale;
}
ExecStatus
IntBase<VY>::prune_lower(Space& home, int* dis, int n_dis) {
assert(n_dis > 0);
// At least one more value will be needed
GECODE_ME_CHECK(y.gq(home,vs.size() + 1));
Region r(home);
// Only one additional value is allowed
if (y.max() == vs.size() + 1) {
// Compute possible values
ViewRanges<IntView>* r_dis = r.alloc<ViewRanges<IntView> >(n_dis);
for (int i=n_dis; i--; )
r_dis[i] = ViewRanges<IntView>(x[dis[i]]);
Iter::Ranges::NaryInter iv(r, r_dis, n_dis);
// Is there a common value at all?
if (!iv())
return ES_FAILED;
ValSet::Ranges vsr(vs);
Iter::Ranges::NaryUnion pv(r,iv,vsr);
// Enforce common values
for (int i=x.size(); i--; ) {
pv.reset();
GECODE_ME_CHECK(x[i].inter_r(home, pv, false));
}
return ES_OK;
}
// Compute independent set for lower bound
// ovl is a bit-matrix defining whether two views overlap
SymBitMatrix ovl(r,x.size());
// deg[i] is the degree of x[i]
int* deg = r.alloc<int>(x.size());
// ovl_i[i] is an array of indices j such that x[j] overlaps with x[i]
int** ovl_i = r.alloc<int*>(x.size());
// n_ovl_i[i] defines how many integers are stored for ovl_i[i]
int* n_ovl_i = r.alloc<int>(x.size());
{
#ifndef NDEBUG
// Initialize all to null pointers so that things crash ;-)
for (int i=x.size(); i--; )
ovl_i[i] = NULL;
#endif
// For each i there can be at most n_dis-1 entries in ovl_i[i]
int* m = r.alloc<int>(n_dis*(n_dis-1));
for (int i=n_dis; i--; ) {
deg[dis[i]] = 0;
ovl_i[dis[i]] = m; m += n_dis-1;
}
}
// Initialize overlap matrix by analyzing the view ranges
{
// Compute how many events are needed
// One event for the end marker
int n_re = 1;
// Two events for each range
for (int i=n_dis; i--; )
for (ViewRanges<IntView> rx(x[dis[i]]); rx(); ++rx)
n_re += 2;
// Allocate and initialize events
RangeEvent* re = r.alloc<RangeEvent>(n_re);
int j=0;
for (int i=n_dis; i--; )
for (ViewRanges<IntView> rx(x[dis[i]]); rx(); ++rx) {
// Event when a range starts
re[j].ret=RET_FST; re[j].val=rx.min(); re[j].view=dis[i]; j++;
// Event when a range ends
re[j].ret=RET_LST; re[j].val=rx.max(); re[j].view=dis[i]; j++;
}
// Make this the last event
re[j].ret=RET_END; re[j].val=Int::Limits::infinity;
assert(j+1 == n_re);
// Sort and process events
Support::quicksort(re,n_re);
// Current views with a range being active
Support::BitSet<Region> cur(r,static_cast<unsigned int>(x.size()));
// Process all events
for (int i=0; true; i++)
switch (re[i].ret) {
case RET_FST:
// Process all overlapping views
for (Iter::Values::BitSet<Support::BitSet<Region> > j(cur);
j(); ++j) {
int di = re[i].view, dj = j.val();
if (!ovl.get(di,dj)) {
ovl.set(di,dj);
ovl_i[di][deg[di]++] = dj;
ovl_i[dj][deg[dj]++] = di;
}
}
cur.set(static_cast<unsigned int>(re[i].view));
break;
case RET_LST:
cur.clear(static_cast<unsigned int>(re[i].view));
break;
case RET_END:
goto done;
default:
GECODE_NEVER;
}
done:
r.free<RangeEvent>(re,n_re);
}
// While deg changes, n_ovl_i remains unchanged and is needed, so copy it
for (int i=n_dis; i--; ) {
assert(deg[dis[i]] < n_dis);
n_ovl_i[dis[i]] = deg[dis[i]];
}
// Views in the independent set
int* ind = r.alloc<int>(n_dis);
int n_ind = 0;
while (n_dis > 0) {
int i_min = n_dis-1;
int d_min = deg[dis[i_min]];
unsigned int s_min = x[dis[i_min]].size();
// Find view with smallest (degree,size)
for (int i=n_dis-1; i--; )
if ((d_min > deg[dis[i]]) ||
((d_min == deg[dis[i]]) && (s_min > x[dis[i]].size()))) {
i_min = i;
d_min = deg[dis[i]];
s_min = x[dis[i]].size();
}
// i_min refers to view with smallest (degree,size)
ind[n_ind++] = dis[i_min]; dis[i_min] = dis[--n_dis];
// Filter out non disjoint views
for (int i=n_dis; i--; )
if (ovl.get(dis[i],ind[n_ind-1])) {
// Update degree information
for (int j=n_ovl_i[dis[i]]; j--; )
deg[ovl_i[dis[i]][j]]--;
// Eliminate view
dis[i] = dis[--n_dis];
}
}
// Enforce lower bound
GECODE_ME_CHECK(y.gq(home,vs.size() + n_ind));
// Prune, if possible
if (vs.size() + n_ind == y.max()) {
// Only values from the indepent set a can be taken
ViewRanges<IntView>* r_ind = r.alloc<ViewRanges<IntView> >(n_ind);
for (int i=n_ind; i--; )
r_ind[i] = ViewRanges<IntView>(x[ind[i]]);
Iter::Ranges::NaryUnion v_ind(r, r_ind, n_ind);
ValSet::Ranges vsr(vs);
v_ind |= vsr;
for (int i=x.size(); i--; ) {
v_ind.reset();
GECODE_ME_CHECK(x[i].inter_r(home,v_ind,false));
}
}
return ES_OK;
}
double DkIntersectPoly::compute() {
// defines
gamut = 500000000;
minRange = nmc::DkVector(FLT_MAX, FLT_MAX);
maxRange = nmc::DkVector(-FLT_MAX, -FLT_MAX);
computeBoundingBox(vecA, &minRange, &maxRange);
computeBoundingBox(vecB, &minRange, &maxRange);
scale = maxRange - minRange;
if (scale.minCoord() == 0) return 0; //rechteck mit h�he oder breite = 0
scale.x = gamut / scale.x;
scale.y = gamut / scale.y;
float ascale = scale.x * scale.y;
// check input
if (vecA.size() < 3 || vecB.size() < 3) {
qDebug() << "The polygons must consist of at least 3 points but they are: (vecA: " << vecA.size() << ", vecB: " << vecB.size();
return 0;
}
// compute edges
std::vector<DkVertex> ipA;
std::vector<DkVertex> ipB;
getVertices(vecA, &ipA, 0);
getVertices(vecB, &ipB, 2);
for (unsigned int idxA = 0; idxA < ipA.size() - 1; idxA++) {
for (unsigned int idxB = 0; idxB < ipB.size() - 1; idxB++) {
if (ovl(ipA[idxA].rx, ipB[idxB].rx) && ovl(ipA[idxA].ry, ipB[idxB].ry)) {
int64 a1 = -area(ipA[idxA].ip, ipB[idxB].ip, ipB[idxB + 1].ip);
int64 a2 = area(ipA[idxA + 1].ip, ipB[idxB].ip, ipB[idxB + 1].ip);
if (a1 < 0 == a2 < 0) {
int64 a3 = area(ipB[idxB].ip, ipA[idxA].ip, ipA[idxA + 1].ip);
int64 a4 = -area(ipB[idxB + 1].ip, ipA[idxA].ip, ipA[idxA + 1].ip);
if (a3 < 0 == a4 < 0) {
if (a1 < 0) {
cross(ipA[idxA], ipA[idxA + 1], ipB[idxB], ipB[idxB + 1], (double)a1, (double)a2, (double)a3, (double)a4);
ipA[idxA].in++;
ipB[idxB].in--;
}
else {
cross(ipB[idxB], ipB[idxB + 1], ipA[idxA], ipA[idxA + 1], (double)a3, (double)a4, (double)a1, (double)a2);
ipA[idxA].in--;
ipB[idxB].in++;
}
}
}
}
}
}
inness(ipA, ipB);
inness(ipB, ipA);
double areaD = (double)interArea / (ascale + FLT_MIN);
return areaD;
}
template <class T> void f(T, char (&buffer)[sizeof(ovl(T()))]) {}
