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()))]) {}