/// Locate a span in the state. /// \param s The span we are locating. /// \return Those ItemTokens that the span comprises. const ItemTokens State::locate_span(const Span& s) const { Span tmps(_frontier); assert(tmps.left() <= s.left()); assert(tmps.right() >= s.right()); ItemTokens is; ItemTokens::const_iterator i; for (i = _frontier.begin(); i != _frontier.end(); i++) { if ((*i)->span().left() == s.left()) break; assert((*i)->span().left() < s.left()); } assert((*i)->span().left() == s.left()); for (; i != _frontier.end(); i++) { is.push_back(*i); if ((*i)->span().right() == s.right()) break; assert((*i)->span().right() < s.right()); } assert((*i)->span().right() == s.right()); assert(!is.empty()); return is; }
int ArcArcIntof(const Span& arc0, const Span& arc1, Point& pLeft, Point& pRight) { // Intof 2 arcs int numInts = Intof(Circle(arc0.pc, arc0.radius), Circle(arc1.pc, arc1.radius), pLeft, pRight); if(numInts == 0) { pLeft = arc0.p1; pLeft.ok = false; return 0; } int nLeft = arc0.OnSpan(pLeft) && arc1.OnSpan(pLeft); int nRight = (numInts == 2)?arc0.OnSpan(pRight) && arc1.OnSpan(pRight) : 0; if(nLeft == 0 && nRight) pLeft = pRight; return nLeft + nRight; }
/// Locate the left and right iterators of a span in the state. /// The left iterator points to the leftmost *inside* the span. /// The right iterator points to the rightmost *inside* the span. /// (For a span containing one item, left == right.) /// \param s The span we are locating. /// \return A pair of ItemToken iterators, left and right. pair<ItemTokens::const_iterator, ItemTokens::const_iterator> State::span_iterators(const Span& s) const { Span tmps(_frontier); assert(tmps.left() <= s.left()); assert(tmps.right() >= s.right()); ItemTokens::const_iterator l, r; ItemTokens::const_iterator i; for (i = _frontier.begin(); i != _frontier.end(); i++) { if ((*i)->span().left() == s.left()) break; assert((*i)->span().left() < s.left()); } assert((*i)->span().left() == s.left()); l = i; for (; i != _frontier.end(); i++) { if ((*i)->span().right() == s.right()) break; assert((*i)->span().right() < s.right()); } assert((*i)->span().right() == s.right()); r = i; return make_pair(l, r); }
void testRuntimeSpan(Span sp) { ASSERT_NOEXCEPT(std::as_bytes(sp)); auto spBytes = std::as_bytes(sp); using SB = decltype(spBytes); ASSERT_SAME_TYPE(const std::byte, typename SB::element_type); if (sp.extent == std::dynamic_extent) assert(spBytes.extent == std::dynamic_extent); else assert(spBytes.extent == sizeof(typename Span::element_type) * sp.extent); assert((void *) spBytes.data() == (void *) sp.data()); assert(spBytes.size() == sp.size_bytes()); }
already_AddRefed<nsIDocument> DOMParser::ParseFromBuffer(Span<const uint8_t> aBuf, SupportedType aType, ErrorResult& aRv) { // The new stream holds a reference to the buffer nsCOMPtr<nsIInputStream> stream; nsresult rv = NS_NewByteInputStream(getter_AddRefs(stream), reinterpret_cast<const char *>(aBuf.Elements()), aBuf.Length(), NS_ASSIGNMENT_DEPEND); if (NS_FAILED(rv)) { aRv.Throw(rv); return nullptr; } return ParseFromStream(stream, VoidString(), aBuf.Length(), aType, aRv); }
void CArea::SpanIntersections(const Span& span, std::list<Point> &pts)const { // this returns all the intersections of this area with the given span, ordered along the span // get all points where this area's curves intersect the span std::list<Point> pts2; for(std::list<CCurve>::const_iterator It = m_curves.begin(); It != m_curves.end(); It++) { const CCurve &c = *It; c.SpanIntersections(span, pts2); } // order them along the span std::multimap<double, Point> ordered_points; for(std::list<Point>::iterator It = pts2.begin(); It != pts2.end(); It++) { Point &p = *It; double t; if(span.On(p, &t)) { ordered_points.insert(std::make_pair(t, p)); } } // add them to the given list of points for(std::multimap<double, Point>::iterator It = ordered_points.begin(); It != ordered_points.end(); It++) { Point p = It->second; pts.push_back(p); } }
int main() { std::srand(time(0)); Span sp = Span(10000); try { while (1) sp.addNumber(rand()); } catch(std::exception &e) { std::cout << e.what() << std::endl; } std::cout << sp.shortestSpan() << std::endl; std::cout << sp.longestSpan() << std::endl; }
void testRuntimeSpan(Span sp) { LIBCPP_ASSERT((noexcept(sp.template first<Count>()))); LIBCPP_ASSERT((noexcept(sp.first(Count)))); auto s1 = sp.template first<Count>(); auto s2 = sp.first(Count); using S1 = decltype(s1); using S2 = decltype(s2); ASSERT_SAME_TYPE(typename Span::value_type, typename S1::value_type); ASSERT_SAME_TYPE(typename Span::value_type, typename S2::value_type); static_assert(S1::extent == Count, ""); static_assert(S2::extent == std::dynamic_extent, ""); assert(s1.data() == s2.data()); assert(s1.size() == s2.size()); assert(std::equal(s1.begin(), s1.end(), sp.begin())); }
Point Span::NearestPointToSpan(const Span& p, double &d)const { Point midpoint = MidParam(0.5); Point np = p.NearestPoint(m_p); Point best_point = m_p; double dist = np.dist(m_p); if(p.m_start_span)dist -= (CArea::m_accuracy * 2); // give start of curve most priority Point npm = p.NearestPoint(midpoint); double dm = npm.dist(midpoint) - CArea::m_accuracy; // lie about midpoint distance to give midpoints priority if(dm < dist){dist = dm; best_point = midpoint;} Point np2 = p.NearestPoint(m_v.m_p); double dp2 = np2.dist(m_v.m_p); if(dp2 < dist){dist = dp2; best_point = m_v.m_p;} d = dist; return best_point; }
static bool DoesIntersInterfere(const Point& pInt, const Kurve& k, double offset) { // check that intersections don't interfere with the original kurve Span sp; Point dummy; int kCheckVertex = 0; k.Get(kCheckVertex++, sp.p0, sp.pc); offset = fabs(offset) - geoff_geometry::TOLERANCE; while(kCheckVertex <= k.nSpans()) { sp.dir = k.Get(kCheckVertex++, sp.p1, sp.pc); sp.SetProperties(true); // check for interference if(Dist(sp, pInt, dummy) < offset) return true; sp.p0 = sp.p1; } return false; // intersection is ok }
constexpr bool testConstexprSpan(Span sp) { LIBCPP_ASSERT((noexcept(sp.template subspan<Offset>()))); LIBCPP_ASSERT((noexcept(sp.subspan(Offset)))); auto s1 = sp.template subspan<Offset>(); auto s2 = sp.subspan(Offset); using S1 = decltype(s1); using S2 = decltype(s2); ASSERT_SAME_TYPE(typename Span::value_type, typename S1::value_type); ASSERT_SAME_TYPE(typename Span::value_type, typename S2::value_type); static_assert(S1::extent == (Span::extent == std::dynamic_extent ? std::dynamic_extent : Span::extent - Offset), ""); static_assert(S2::extent == std::dynamic_extent, ""); return s1.data() == s2.data() && s1.size() == s2.size() && std::equal(s1.begin(), s1.end(), sp.begin() + Offset, sp.end()); }
int main() { Span sp = Span(5); Span sp1 = Span(10000); Span sp2 = Span(10000); Span sp3 = Span(10); Span sp4 = Span(1); srand(time(NULL)); sp.addNumber(5); sp.addNumber(3); sp.addNumber(17); sp.addNumber(9); sp.addNumber(11); std::cout << sp.shortestSpan() << std::endl; std::cout << sp.longestSpan() << std::endl; sp1.RandInterval(9000); std::cout << sp1.shortestSpan() << std::endl; std::cout << sp1.longestSpan() << std::endl; sp2.Interval(42, 9000); std::cout << sp2.shortestSpan() << std::endl; std::cout << sp2.longestSpan() << std::endl; sp3.RandInterval(9000); std::cout << sp3.shortestSpan() << std::endl; std::cout << sp3.longestSpan() << std::endl; sp4.addNumber(5); sp4.addNumber(6); std::cout << sp4.shortestSpan() << std::endl; std::cout << sp4.longestSpan() << std::endl; return (0); }
int main() { srand(std::time(0)); try { Span sp = Span(5); sp.addNumber(5); sp.addNumber(3); sp.addNumber(17); sp.addNumber(9); sp.addNumber(11); std::cout << sp.shortestSpan() << std::endl; std::cout << sp.longestSpan() << std::endl; Span big(10000); big.initAll(randNumber); std::cout << big.shortestSpan() << std::endl; std::cout << big.longestSpan() << std::endl; Span sp2(1); std::cout << sp2.shortestSpan() << std::endl; } catch (std::exception & e) { std::cout << e.what() << std::endl; } }
void URI::set_uri( uri_identifier_code_t id, const Span<const uint8_t> &uri_field ) { delete[] _uri; if (uri_field.empty()) { _uri = NULL; _uri_size = 0; return; } _uri = new uint8_t[uri_id_code_size + uri_field.size()]; _uri_size = uri_id_code_size + uri_field.size(); _uri[uri_id_index] = id; memcpy(_uri + uri_field_index, uri_field.data(), uri_field.size()); }
static void parseVar (Lexer& lex, SigPtr sig) { std::string name; TyPtr ty; Span sp; parseVar(lex, name, ty, sp); for (auto& a : sig->args) if (a.first == name) { std::ostringstream ss; ss << "variable '" << name << "' already declared in signature"; throw sp.die(ss.str()); } sig->args.push_back(Sig::Arg { name, ty }); sig->span = sig->span + sp; }
void TriRasterizer::drawSpansBetweenEdges(const Edge &longEdge, const Edge &shortEdge) { if(shortEdge.m_V1.m_Y == shortEdge.m_V2.m_Y) return; // horizontal edge, return // snap current y-axis val to next pixel center // using short edge as the reference top float currY = getNextPixCenter(shortEdge.m_V1.m_Y); float topY = shortEdge.m_V2.m_Y; // get current colors Color currLongColor; Color currShortColor; // get inverse slopes float shortInvSlope = (shortEdge.m_V2.m_X == shortEdge.m_V1.m_X) ? 0.f : (shortEdge.m_V2.m_X-shortEdge.m_V1.m_X)/(shortEdge.m_V2.m_Y-shortEdge.m_V1.m_Y); float longInvSlope = (longEdge.m_V2.m_X == longEdge.m_V1.m_X) ? 0.f : (longEdge.m_V2.m_X-longEdge.m_V1.m_X)/(longEdge.m_V2.m_Y-longEdge.m_V1.m_Y); // get current x-axis vals float currLongX = longEdge.m_V1.m_X + (currY-longEdge.m_V1.m_Y) * longInvSlope; float currShortX = shortEdge.m_V1.m_X + (currY-shortEdge.m_V1.m_Y) * shortInvSlope; // move along edges Span span; while (currY < topY) { // TODO: only calc interpolatants once interpolateColor(currY, shortEdge.m_V1.m_Y, shortEdge.m_V2.m_Y, shortEdge.m_V1.m_Color, shortEdge.m_V2.m_Color, currShortColor); interpolateColor(currY, longEdge.m_V1.m_Y, longEdge.m_V2.m_Y, longEdge.m_V1.m_Color, longEdge.m_V2.m_Color, currLongColor); // set & draw span span.setSpan(currShortColor, currLongColor, currShortX, currLongX, currY); drawSpan(span); currY += 1.f; currShortX += shortInvSlope; currLongX += longInvSlope; } }
Span* Span::CreateClientSpan(const std::string& full_method_name, int64_t base_real_us) { Span* span = butil::get_object<Span>(Forbidden()); if (__builtin_expect(span == NULL, 0)) { return NULL; } span->_log_id = 0; span->_base_cid = INVALID_BTHREAD_ID; span->_ending_cid = INVALID_BTHREAD_ID; span->_type = SPAN_TYPE_CLIENT; span->_async = false; span->_protocol = PROTOCOL_UNKNOWN; span->_error_code = 0; span->_request_size = 0; span->_response_size = 0; span->_base_real_us = base_real_us; span->_received_real_us = 0; span->_start_parse_real_us = 0; span->_start_callback_real_us = 0; span->_start_send_real_us = 0; span->_sent_real_us = 0; span->_next_client = NULL; span->_tls_next = NULL; span->_full_method_name = full_method_name; span->_info.clear(); Span* parent = (Span*)bthread::tls_bls.rpcz_parent_span; if (parent) { span->_trace_id = parent->trace_id(); span->_parent_span_id = parent->span_id(); span->_local_parent = parent; span->_next_client = parent->_next_client; parent->_next_client = span; } else { span->_trace_id = GenerateTraceId(); span->_parent_span_id = 0; span->_local_parent = NULL; } span->_span_id = GenerateSpanId(); return span; }
double Dist(const Span& sp, const Point& p , Point& pnear ) { // returns distance of p from span, pnear is the nearpoint on the span (or endpoint) if(!sp.dir) { double d, t; Point3d unused_pnear; d = Dist(Line(sp), Point3d(p), unused_pnear, t); if(t < -geoff_geometry::TOLERANCE) { pnear = sp.p0; // nearpoint d = pnear.Dist(p); } else if(t > sp.length + geoff_geometry::TOLERANCE) { pnear = sp.p1; d = pnear.Dist(p); } return d; } else { // put pnear on the circle double radiusp; Vector2d v(sp.pc, p); if((radiusp = v.magnitude()) < geoff_geometry::TOLERANCE) { // point specified on circle centre - use first point as near point pnear = sp.p0; // nearpoint return sp.radius; } else { pnear = v * (sp.radius / radiusp) + sp.pc; // check if projected point is on the arc if(sp.OnSpan(pnear)) return fabs(radiusp - sp.radius); // double h1 = pnear.x - sp.p0.x ; // double v1 = pnear.y - sp.p0.y ; // double h2 = sp.p1.x - pnear.x ; // double v2 = sp.p1.y - pnear.y ; // if ( sp.dir * ( h1 * v2 - h2 * v1 ) >= 0 )return fabs(radiusp - sp.radius); // point not on arc so calc nearest end-point double ndist = p.Dist(sp.p0); double dist = p.Dist(sp.p1); if(ndist >= dist) { // sp.p1 is near point pnear = sp.p1; return dist; } // sp.p0 is near point pnear = sp.p0; // nearpoint return ndist ; } } }
void AdaptiveWaterline::adaptive_sampling_run() { minx = surf->bb.minpt.x - 2*cutter->getRadius(); maxx = surf->bb.maxpt.x + 2*cutter->getRadius(); miny = surf->bb.minpt.y - 2*cutter->getRadius(); maxy = surf->bb.maxpt.y + 2*cutter->getRadius(); Line* line = new Line( Point(minx,miny,zh) , Point(maxx,maxy,zh) ); Span* linespan = new LineSpan(*line); xfibers.clear(); Point xstart_p1 = Point( minx, linespan->getPoint(0.0).y, zh ); Point xstart_p2 = Point( maxx, linespan->getPoint(0.0).y, zh ); Point xstop_p1 = Point( minx, linespan->getPoint(1.0).y, zh ); Point xstop_p2 = Point( maxx, linespan->getPoint(1.0).y, zh ); Fiber xstart_f = Fiber( xstart_p1, xstart_p2 ) ; Fiber xstop_f = Fiber( xstop_p1, xstop_p2 ); subOp[0]->run(xstart_f); subOp[0]->run(xstop_f); xfibers.push_back(xstart_f); std::cout << " XFiber adaptive sample \n"; xfiber_adaptive_sample( linespan, 0.0, 1.0, xstart_f, xstop_f); yfibers.clear(); Point ystart_p1 = Point( linespan->getPoint(0.0).x, miny, zh ); Point ystart_p2 = Point( linespan->getPoint(0.0).x, maxy, zh ); Point ystop_p1 = Point( linespan->getPoint(1.0).x, miny, zh ); Point ystop_p2 = Point( linespan->getPoint(1.0).x, maxy, zh ); Fiber ystart_f = Fiber( ystart_p1, ystart_p2 ) ; Fiber ystop_f = Fiber( ystop_p1, ystop_p2 ); subOp[1]->run(ystart_f); subOp[1]->run(ystop_f); yfibers.push_back(ystart_f); std::cout << " YFiber adaptive sample \n"; yfiber_adaptive_sample( linespan, 0.0, 1.0, ystart_f, ystop_f); delete line; delete linespan; }
void DateTimeGrid::paintRowGrid( QPainter* painter, const QRectF& /*sceneRect*/, const QRectF& exposedRect, AbstractRowController* rowController, QWidget* /*widget*/ ) { if ( rowController && rowSeparators() ) { // First draw the rows QPen pen = painter->pen(); pen.setBrush( QApplication::palette().dark() ); pen.setStyle( Qt::DashLine ); painter->setPen( pen ); QModelIndex idx = rowController->indexAt( qRound( exposedRect.top() ) ); qreal y = 0; while ( y < exposedRect.bottom() && idx.isValid() ) { const Span s = rowController->rowGeometry( idx ); y = s.start()+s.length(); //painter->drawLine( QPointF( sceneRect.left(), y ), QPointF( sceneRect.right(), y ) ); // Is alternating background better? if ( idx.row()%2 ) painter->fillRect( QRectF( exposedRect.x(), s.start(), exposedRect.width(), s.length() ), QApplication::palette().alternateBase() ); idx = rowController->indexBelow( idx ); } } }
Point Span::NearestPoint(const Span& p, double *d)const { double best_dist; Point best_point = this->NearestPointToSpan(p, best_dist); // try the other way round too double best_dist2; Point best_point2 = p.NearestPointToSpan(*this, best_dist2); if(best_dist2 < best_dist) { best_point = NearestPoint(best_point2); best_dist = best_dist2; } if(d)*d = best_dist; return best_point; }
bool OnSpan(const Span& sp, const Point& p, bool nearPoints, Point& pNear, Point& pOnSpan) { // function returns true if pNear == pOnSpan // returns pNear & pOnSpan if nearPoints true // pNear (nearest on unbound span) // pOnSpan (nearest on finite span) if(sp.dir) { // arc if(fabs(p.Dist(sp.pc) - sp.radius) > geoff_geometry::TOLERANCE) { if(!nearPoints) return false; } pNear = On(Circle(sp.pc, sp.radius), p); if(sp.OnSpan(pNear)) { if(nearPoints) pOnSpan = pNear; return true; // near point is on arc - already calculated } // point not on arc return the nearest end-point if(nearPoints) pOnSpan = (p.Dist(sp.p0) >= p.Dist(sp.p1)) ?sp.p1 : sp.p0; return false; } else { // straight if(fabs(CLine(sp.p0, sp.vs).Dist(p)) > geoff_geometry::TOLERANCE) { if(!nearPoints) return false; } Vector2d v(sp.p0, p); double t = v * sp.vs; if(nearPoints) pNear = sp.vs * t + sp.p0; bool onSpan = (t > - geoff_geometry::TOLERANCE && t < sp.length + geoff_geometry::TOLERANCE); if(! onSpan) { if(nearPoints) pOnSpan = (p.Dist(sp.p0) >= p.Dist(sp.p1))?sp.p1 : sp.p0; } else { if(nearPoints) pOnSpan = pNear; } return onSpan; } }
void Text::set_text( encoding_t text_encoding, const Span<const uint8_t> &language_code, const Span<const uint8_t> &text ) { delete[] _text_record; _text_record_size = header_size + language_code.size() + text.size(); _text_record = new uint8_t[_text_record_size]; // build the header _text_record[header_index] = 0; if (text_encoding == UTF16) { _text_record[header_index] |= utf16_encoding_bit; } _text_record[header_index] |= language_code.size(); // language code memcpy(_text_record + language_code_index, language_code.data(), language_code.size()); // actual text memcpy(_text_record + language_code_index + language_code.size(), text.data(), text.size()); }
void CheckAccess(Cm::Sym::Symbol* fromSymbol, const Span& fromSpan, Cm::Sym::Symbol* toSymbol) { if (!fromSymbol || !toSymbol) return; Cm::Sym::FunctionSymbol* toContainingFunction = toSymbol->ContainingFunction(); if (toContainingFunction) { Cm::Sym::FunctionSymbol* fromFunction = fromSymbol->Function(); if (fromFunction == toContainingFunction) { return; } } if (fromSymbol->IsFunctionSymbol()) { Cm::Sym::FunctionSymbol* fromFun = static_cast<Cm::Sym::FunctionSymbol*>(fromSymbol); if (fromFun->IsFunctionTemplateSpecialization()) { return; } if (fromFun->IsMemberOfTemplateType()) { return; } } Cm::Sym::ClassTypeSymbol* toContainingClass = toSymbol->ContainingClass(); if (toContainingClass) { CheckAccess(fromSymbol, fromSpan, toContainingClass); } switch (toSymbol->DeclaredAccess()) { case Cm::Sym::SymbolAccess::public_: { return; } case Cm::Sym::SymbolAccess::protected_: { Cm::Sym::ClassTypeSymbol* fromContainingClass = fromSymbol->ContainingClass(); if (fromContainingClass) { if (toContainingClass->IsSameParentOrAncestorOf(fromContainingClass)) { return; } if (fromContainingClass->HasBaseClass(toContainingClass)) { return; } } break; } case Cm::Sym::SymbolAccess::internal_: { return; } case Cm::Sym::SymbolAccess::private_: { if (toContainingClass) { Cm::Sym::ClassTypeSymbol* fromContainingClass = fromSymbol->ContainingClass(); if (toContainingClass->IsSameParentOrAncestorOf(fromContainingClass)) { return; } } break; } } Span span = fromSpan.Valid() ? fromSpan : fromSymbol->GetSpan(); throw Cm::Core::Exception(toSymbol->TypeString() + " '" + toSymbol->FullName() + "' is inaccessible due to its protection level", span, toSymbol->GetSpan()); }
void PolygonClipping2D( const Span<glm::vec2> & subject, const Span<glm::vec2> & clipping, std::vector<glm::vec2> & result) { Assert(subject.size() > 2); Assert(clipping.size() > 2); std::vector<glm::vec2> input; std::vector<glm::vec2> output; /** * Determine winding order of clipping polygon */ bool clippingCCW = false; { auto edge0 = glm::vec2( clipping[1].x - clipping[0].x, clipping[1].y - clipping[0].y); auto edge1 = glm::vec2( clipping[2].x - clipping[1].x, clipping[2].y - clipping[1].y); auto sign = (edge0.x * edge1.y) - (edge0.y * edge1.x); clippingCCW = sign >= 0; } // std::cout << "Clipping: "; // for (auto & v : clipping.toVector()) { // std::cout << v << "; "; // } // std::cout << std::endl; output = subject.toVector(); for (int c0 = 0; c0 < clipping.size(); c0++) { auto c1 = (c0 + 1) % clipping.size(); auto & C0 = clipping[c0]; auto & C1 = clipping[c1]; Ray2D edge = clippingCCW ? Ray2D::fromTo(C0, C1) : Ray2D::fromTo(C1, C0); // std::cout << edge << " " << clippingCCW << ": "; // for (auto & v : output) { // std::cout << v << " "; // } // std::cout << " -> "; input = output; output.clear(); auto S = input.back(); for (int i = 0; i < input.size(); i++) { auto & E = input[i]; if (PointRay2DHalfspace(E, edge) <= 0) { if (PointRay2DHalfspace(S, edge) > 0) { bool exists; output.push_back(Ray2DIntersectionPoint( Ray2D::fromTo(S, E), edge, exists)); Assert(exists); } output.push_back(E); } else if (PointRay2DHalfspace(S, edge) <= 0) { bool exists; output.push_back( Ray2DIntersectionPoint(Ray2D::fromTo(S, E), edge, exists)); Assert(exists); } S = E; } // for (auto & v : output) { // std::cout << v << " "; // } // std::cout << std::endl; } /** * Populate result */ result = output; }
void set_payload(Span new_load) { pckt_->set_data_end(pckt_->ip_header_length() + header_size() + new_load.size()); memcpy(payload().data(), new_load.data(), payload().size()); }
} KDAB_SCOPED_UNITTEST_SIMPLE( KDGantt, DateTimeGrid, "test" ) { QStandardItemModel model( 3, 2 ); DateTimeGrid grid; QDateTime dt = QDateTime::currentDateTime(); grid.setModel( &model ); grid.setStartDateTime( dt.addDays( -10 ) ); model.setData( model.index( 0, 0 ), dt, StartTimeRole ); model.setData( model.index( 0, 0 ), dt.addDays( 17 ), EndTimeRole ); model.setData( model.index( 2, 0 ), dt.addDays( 18 ), StartTimeRole ); model.setData( model.index( 2, 0 ), dt.addDays( 19 ), EndTimeRole ); Span s = grid.mapToChart( model.index( 0, 0 ) ); //qDebug() << "span="<<s; assertTrue( s.start()>0 ); assertTrue( s.length()>0 ); grid.mapFromChart( s, model.index( 1, 0 ) ); QDateTime s1 = model.data( model.index( 0, 0 ), StartTimeRole ).toDateTime(); QDateTime e1 = model.data( model.index( 0, 0 ), EndTimeRole ).toDateTime(); QDateTime s2 = model.data( model.index( 1, 0 ), StartTimeRole ).toDateTime(); QDateTime e2 = model.data( model.index( 1, 0 ), EndTimeRole ).toDateTime(); assertTrue( s1.isValid() ); assertTrue( e1.isValid() ); assertTrue( s2.isValid() );
int Kurve::OffsetMethod1(Kurve& kOffset, double off, int direction, int method, int& ret)const { // offset kurve with simple span elimination // direction 1 = left, -1 = right // ret = 0 - kurve offset ok // = 1 - kurve has differential scale (not allowed) // = 2 - offset failed // = 3 - offset too large if(this == &kOffset) FAILURE(L"Illegal Call - 'this' must not be kOffset"); double offset = (direction == GEOFF_LEFT)?off : -off; if(fabs(offset) < geoff_geometry::TOLERANCE || m_nVertices < 2) { kOffset = *this; ret = 0; return 1; } Span curSpan, curSpanOff; // current & offset spans Span prevSpanOff; // previous offset span Point p0, p1; // Offset span intersections // offset Kurve kOffset = Matrix(*this); if(m_mirrored) offset = -offset; int RollDir = ( off < 0 ) ? direction : - direction; // Roll arc direction double scalex; if(!GetScale(scalex)) { ret = 1; return 0; // differential scale } offset /= scalex; bool bClosed = Closed(); int nspans = nSpans(); if(bClosed) { Get(nspans, curSpan, true); // assign previus span for closed prevSpanOff = curSpan.Offset(offset); nspans++; // read first again } for(int spannumber = 1; spannumber <= nspans; spannumber++) { if(spannumber > nSpans()) Get(1, curSpan, true); // closed kurve - read first span again else Get(spannumber, curSpan, true); if(!curSpan.NullSpan) { int numint = 0; curSpanOff = curSpan.Offset(offset); curSpanOff.ID = 0; if(!kOffset.m_started) { kOffset.Start(curSpanOff.p0); kOffset.AddSpanID(0); } if(spannumber > 1) { // see if tangent double d = curSpanOff.p0.Dist(prevSpanOff.p1); if((d > geoff_geometry::TOLERANCE) && (curSpanOff.NullSpan == false && prevSpanOff.NullSpan == false)) { // see if offset spans intersect double cp = prevSpanOff.ve ^ curSpanOff.vs; bool inters = (cp > 0 && direction == GEOFF_LEFT) || (cp < 0 && direction == GEOFF_RIGHT); if(inters) { double t[4]; numint = prevSpanOff.Intof(curSpanOff, p0, p1, t); } if(numint == 1) { // intersection - modify previous endpoint kOffset.Replace(kOffset.m_nVertices-1, prevSpanOff.dir, p0, prevSpanOff.pc, prevSpanOff.ID); } else { // 0 or 2 intersections, add roll around (remove -ve loops in elimination function) if(kOffset.Add(RollDir, curSpanOff.p0, curSpan.p0, false)) kOffset.AddSpanID(ROLL_AROUND); } } } // add span if(spannumber < m_nVertices) { curSpanOff.ID = spannumber; kOffset.Add(curSpanOff, false); } else if(numint == 1) // or replace the closed first span kOffset.Replace(0, 0, p0, Point(0, 0), 0); } if(!curSpanOff.NullSpan)prevSpanOff = curSpanOff; } // end of main pre-offsetting loop #ifdef _DEBUG //testDraw->AddKurve("", &kOffset, 0, GREEN); // outXML oxml(L"c:\\temp\\eliminateLoops.xml"); // oxml.startElement(L"eliminateLoops"); // oxml.Write(kOffset, L"kOffset"); // oxml.endElement(); #endif // eliminate loops if(method == NO_ELIMINATION) { ret = 0; return 1; } kOffset = eliminateLoops(kOffset, *this, offset, ret); if(ret == 0 && bClosed) { // check for inverted offsets of closed kurves if(kOffset.Closed()) { double a = Area(); int dir = (a < 0); double ao = kOffset.Area(); int dirOffset = ao < 0; if(dir != dirOffset) ret = 3; else { // check area change compatible with offset direction - catastrophic failure bool bigger = (a > 0 && offset > 0) || (a < 0 && offset < 0); if(bigger && fabs(ao) < fabs(a)) ret = 2; } } else ret = 2; // started closed but now open?? } return (ret == 0)?1 : 0; }
static Kurve eliminateLoops(const Kurve& k , const Kurve& originalk, double offset, int& ret) { // a simple loop elimination routine based on first offset ideas in Peps // this needs extensive work for future // start point musn't disappear & only one valid offset is determined // // ret = 0 for ok // ret = 2 for impossible geometry Span sp0, sp1; Point pInt, pIntOther; Kurve ko; // eliminated output ko = Matrix(k); int kinVertex = 0; while(kinVertex <= k.nSpans()) { bool clipped = false ; // not in a clipped section (assumption with this simple method) sp0.dir = k.Get(kinVertex, sp0.p0, sp0.pc); sp0.ID = k.GetSpanID(kinVertex++); if (kinVertex == 1) { ko.Start(sp0.p0); // start point mustn't dissappear for this simple method ko.AddSpanID(sp0.ID); } if (kinVertex <= k.nSpans()) { // any more? int ksaveVertex = kinVertex ; sp0.dir = k.Get(kinVertex, sp0.p1, sp0.pc); // first span sp0.ID = k.GetSpanID(kinVertex++); sp0.SetProperties(true); int ksaveVertex1 = kinVertex; // mark position AA if (kinVertex <= k.nSpans()) { // get the next but one span sp1.dir = k.Get(kinVertex, sp1.p0, sp1.pc); sp1.ID = k.GetSpanID(kinVertex++); int ksaveVertex2 = kinVertex; // mark position BB int fwdCount = 0; while(kinVertex <= k.nSpans()) { sp1.dir = k.Get(kinVertex, sp1.p1, sp1.pc); // check span sp1.ID = k.GetSpanID(kinVertex++); sp1.SetProperties(true); double t[4]; int numint = sp0.Intof(sp1, pInt, pIntOther, t); // find span intersections if(numint && sp0.p0.Dist(pInt) < geoff_geometry::TOLERANCE ) numint=0; // check that intersection is not at the start of the check span if(numint ) { if(numint == 2) { // choose first intercept on sp0 Span spd = sp0; spd.p1 = pInt; spd.SetProperties(true); double dd = spd.length; spd.p1 = pIntOther; spd.SetProperties(true); if(dd > spd.length) pInt = pIntOther; numint = 1; } ksaveVertex = ksaveVertex1 ; clipped = true ; // in a clipped section if(DoesIntersInterfere(pInt, originalk, offset) == false) { sp0.p1 = pInt; // ok so truncate this span to the intersection clipped = false; // end of clipped section break; } // no valid intersection found so carry on } sp1.p0 = sp1.p1 ; // next ksaveVertex1 = ksaveVertex2 ; // pos AA = BB ksaveVertex2 = kinVertex; // mark if((kinVertex > k.nSpans() || fwdCount++ > 25) && clipped == false) break; } } if(clipped) { ret = 2; // still in a clipped section - error return ko; } ko.Add(sp0, false); kinVertex = ksaveVertex; } } ret = 0; return ko; // no more spans - seems ok }
void AdaptiveWaterline::adaptive_sampling_run() { minx = surf->bb.minpt.x - 2*cutter->getRadius(); maxx = surf->bb.maxpt.x + 2*cutter->getRadius(); miny = surf->bb.minpt.y - 2*cutter->getRadius(); maxy = surf->bb.maxpt.y + 2*cutter->getRadius(); Line* line = new Line( Point(minx,miny,zh) , Point(maxx,maxy,zh) ); Span* linespan = new LineSpan(*line); #ifdef _WIN32 // OpenMP task not supported with the version 2 of VS2013 OpenMP #pragma omp parallel sections { #pragma omp section // Replace OMP Task by Parallel sections { // first child #else #pragma omp parallel { #pragma omp single nowait { // initial root task #pragma omp task { // first child task #endif // _WIN32 xfibers.clear(); Point xstart_p1 = Point(minx, linespan->getPoint(0.0).y, zh); Point xstart_p2 = Point(maxx, linespan->getPoint(0.0).y, zh); Point xstop_p1 = Point(minx, linespan->getPoint(1.0).y, zh); Point xstop_p2 = Point(maxx, linespan->getPoint(1.0).y, zh); Fiber xstart_f = Fiber(xstart_p1, xstart_p2); Fiber xstop_f = Fiber(xstop_p1, xstop_p2); subOp[0]->run(xstart_f); subOp[0]->run(xstop_f); xfibers.push_back(xstart_f); std::cout << " XFiber adaptive sample \n"; xfiber_adaptive_sample(linespan, 0.0, 1.0, xstart_f, xstop_f); #ifdef _WIN32 // OpenMP task not supported with the version 2 of VS2013 OpenMP } #pragma omp section { // second child #else } # pragma omp task { // second child task #endif // _WIN32 yfibers.clear(); Point ystart_p1 = Point(linespan->getPoint(0.0).x, miny, zh); Point ystart_p2 = Point(linespan->getPoint(0.0).x, maxy, zh); Point ystop_p1 = Point(linespan->getPoint(1.0).x, miny, zh); Point ystop_p2 = Point(linespan->getPoint(1.0).x, maxy, zh); Fiber ystart_f = Fiber(ystart_p1, ystart_p2); Fiber ystop_f = Fiber(ystop_p1, ystop_p2); subOp[1]->run(ystart_f); subOp[1]->run(ystop_f); yfibers.push_back(ystart_f); std::cout << " YFiber adaptive sample \n"; yfiber_adaptive_sample(linespan, 0.0, 1.0, ystart_f, ystop_f); #ifdef _WIN32 // OpenMP task not supported with the version 2 of VS2013 OpenMP } } // end omp parallel #else } } } // end omp parallel #endif // _WIN32 delete line; delete linespan; }