void QSegmentWidget::clearSegment(int cyl, qreal startAngle, qreal stopAngle) { Segment s(startAngle, stopAngle, QColor(Qt::black)); SegmentList sl; sl.push_back(s); clearSegments(cyl, sl); }
void QSegmentWidget::DrawSegments(QPainter *painter, const SegmentList &s, qreal radius) { for (SegmentList::const_iterator i = s.begin(); i != s.end(); i++) { painter->setRenderHint(QPainter::Antialiasing); painter->setRenderHint(QPainter::SmoothPixmapTransform); QBrush b(i->color); painter->setBrush(b); QBrush c(i->color.darker(200)); painter->setPen(QPen(c, 0)); int startAngle = qRound(i->first * 16.0); qreal dAngle = i->second - i->first; if (dAngle < 0.0) dAngle += 360.0; int spanAngle = qRound(dAngle * 16.0); QRectF r(-radius, -radius, radius * 2.0, radius * 2.0); if (spanAngle >= 360 * 16) { // qDebug() << QString("DrawSegments drawEllipse (%1, %2)").arg(-radius).arg(radius * 2.0); painter->drawEllipse(r); } else { // qDebug() << QString("DrawSegments drawPie (%1, %2, %3, %4)").arg(-radius).arg(radius * 2.0).arg(startAngle).arg(spanAngle); painter->drawPie(r, startAngle, spanAngle); } } }
void BoxShape::getExcludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const { if (m_marginBounds.isEmpty()) return; float y1 = logicalTop; float y2 = logicalTop + logicalHeight; const FloatRect& rect = m_marginBounds.rect(); if (y2 <= rect.y() || y1 >= rect.maxY()) return; if (!m_marginBounds.isRounded()) { result.append(LineSegment(m_marginBounds.rect().x(), m_marginBounds.rect().maxX())); return; } float x1 = rect.maxX(); float x2 = rect.x(); float minXIntercept; float maxXIntercept; if (m_marginBounds.xInterceptsAtY(y1, minXIntercept, maxXIntercept)) { x1 = std::min<float>(x1, minXIntercept); x2 = std::max<float>(x2, maxXIntercept); } if (m_marginBounds.xInterceptsAtY(y1, minXIntercept, maxXIntercept)) { x1 = std::min<float>(x1, minXIntercept); x2 = std::max<float>(x2, maxXIntercept); } ASSERT(x2 >= x1); result.append(LineSegment(x1, x2)); }
void ShapeOutsideInfo::updateDeltasForContainingBlockLine(const RenderBlockFlow* containingBlock, const FloatingObject* floatingObject, LayoutUnit lineTop, LayoutUnit lineHeight) { LayoutUnit shapeTop = containingBlock->logicalTopForFloat(floatingObject) + std::max(LayoutUnit(), containingBlock->marginBeforeForChild(*m_renderer)); LayoutUnit lineTopInShapeCoordinates = lineTop - shapeTop + logicalTopOffset(); if (shapeSizeDirty() || m_lineTop != lineTopInShapeCoordinates || m_lineHeight != lineHeight) { m_lineTop = lineTopInShapeCoordinates; m_shapeLineTop = lineTopInShapeCoordinates - logicalTopOffset(); m_lineHeight = lineHeight; LayoutUnit floatMarginBoxWidth = containingBlock->logicalWidthForFloat(floatingObject); if (lineOverlapsShapeBounds()) { SegmentList segments = computeSegmentsForLine(lineTopInShapeCoordinates, lineHeight); if (segments.size()) { LayoutUnit rawLeftMarginBoxDelta = segments.first().logicalLeft + containingBlock->marginStartForChild(*m_renderer); m_leftMarginBoxDelta = clampTo<LayoutUnit>(rawLeftMarginBoxDelta, LayoutUnit(), floatMarginBoxWidth); LayoutUnit rawRightMarginBoxDelta = segments.last().logicalRight - containingBlock->logicalWidthForChild(*m_renderer) - containingBlock->marginEndForChild(*m_renderer); m_rightMarginBoxDelta = clampTo<LayoutUnit>(rawRightMarginBoxDelta, -floatMarginBoxWidth, LayoutUnit()); return; } } // Lines that do not overlap the shape should act as if the float // wasn't there for layout purposes. So we set the deltas to remove the // entire width of the float. // FIXME: The latest CSS Shapes spec says that in this case, the // content should interact with previously stacked floats on the line // as if this outermost float did not exist. Perhaps obviously, this // solution cannot do that, and will be revisted with bug 122576. m_leftMarginBoxDelta = floatMarginBoxWidth; m_rightMarginBoxDelta = -floatMarginBoxWidth; } }
void Tessellation::generateExtrusionContour() { for( auto& pos : positions ) extrusionContourVertices.push_back( pos ); extrusionContourIndices = segments; SegmentList additionalSegments; Vector n; int originalSegments = extrusionContourIndices.size(); for( auto& segment : extrusionContourIndices ) { auto& a = positions[ segment.i1 ]; auto& b = positions[ segment.i2 ]; n.x = (float)(a.y - b.y); n.y = (float)(b.x - a.x); n = n.normalized(); _assignNormal( n, segment, 0, additionalSegments ); _assignNormal( n, segment, 1, additionalSegments ); } //add the created segments to the extrusion segments extrusionContourIndices.insert( extrusionContourIndices.end(), additionalSegments.begin(), additionalSegments.end() ); }
bool SegmentInformation::getSegmentNumberByTime(mtime_t time, uint64_t *ret) const { SegmentList *segList; MediaSegmentTemplate *mediaTemplate; uint64_t timescale = 1; mtime_t duration = 0; if( (mediaTemplate = inheritSegmentTemplate()) ) { timescale = mediaTemplate->inheritTimescale(); duration = mediaTemplate->duration.Get(); } else if ( (segList = inheritSegmentList()) ) { timescale = segList->inheritTimescale(); duration = segList->getDuration(); } if(duration) { *ret = time / (CLOCK_FREQ * duration / timescale); return true; } return false; }
void BoxShape::getIncludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const { const FloatRoundedRect& paddingBounds = shapePaddingBounds(); if (paddingBounds.isEmpty()) return; const FloatRect& rect = paddingBounds.rect(); float y1 = logicalTop; float y2 = logicalTop + logicalHeight; if (y1 < rect.y() || y2 > rect.maxY()) return; if (!paddingBounds.isRounded()) { result.append(LineSegment(rect.x(), rect.maxX())); return; } float x1 = rect.x(); float x2 = rect.maxX(); float minXIntercept; float maxXIntercept; if (paddingBounds.xInterceptsAtY(y1, minXIntercept, maxXIntercept)) { x1 = std::max<float>(x1, minXIntercept); x2 = std::min<float>(x2, maxXIntercept); } if (paddingBounds.xInterceptsAtY(y2, minXIntercept, maxXIntercept)) { x1 = std::max<float>(x1, minXIntercept); x2 = std::min<float>(x2, maxXIntercept); } result.append(LineSegment(x1, x2)); }
void ShapeOutsideInfo::updateDeltasForContainingBlockLine(const RenderBlockFlow& containingBlock, const FloatingObject& floatingObject, LayoutUnit lineTop, LayoutUnit lineHeight) { LayoutUnit borderBoxTop = containingBlock.logicalTopForFloat(&floatingObject) + containingBlock.marginBeforeForChild(&m_renderer); LayoutUnit borderBoxLineTop = lineTop - borderBoxTop; if (isShapeDirty() || m_borderBoxLineTop != borderBoxLineTop || m_lineHeight != lineHeight) { m_borderBoxLineTop = borderBoxLineTop; m_referenceBoxLineTop = borderBoxLineTop - logicalTopOffset(); m_lineHeight = lineHeight; LayoutUnit floatMarginBoxWidth = containingBlock.logicalWidthForFloat(&floatingObject); if (lineOverlapsShapeBounds()) { SegmentList segments = computeSegmentsForLine(borderBoxLineTop, lineHeight); if (segments.size()) { LayoutUnit logicalLeftMargin = containingBlock.style()->isLeftToRightDirection() ? containingBlock.marginStartForChild(&m_renderer) : containingBlock.marginEndForChild(&m_renderer); LayoutUnit rawLeftMarginBoxDelta = segments.first().logicalLeft + logicalLeftMargin; m_leftMarginBoxDelta = clampToLayoutUnit(rawLeftMarginBoxDelta, LayoutUnit(), floatMarginBoxWidth); LayoutUnit logicalRightMargin = containingBlock.style()->isLeftToRightDirection() ? containingBlock.marginEndForChild(&m_renderer) : containingBlock.marginStartForChild(&m_renderer); LayoutUnit rawRightMarginBoxDelta = segments.last().logicalRight - containingBlock.logicalWidthForChild(&m_renderer) - logicalRightMargin; m_rightMarginBoxDelta = clampToLayoutUnit(rawRightMarginBoxDelta, -floatMarginBoxWidth, LayoutUnit()); m_lineOverlapsShape = true; return; } } // Lines that do not overlap the shape should act as if the float // wasn't there for layout purposes. So we set the deltas to remove the // entire width of the float. m_leftMarginBoxDelta = floatMarginBoxWidth; m_rightMarginBoxDelta = -floatMarginBoxWidth; m_lineOverlapsShape = false; } }
mtime_t SegmentInformation::getPlaybackTimeBySegmentNumber(uint64_t number) const { SegmentList *segList; MediaSegmentTemplate *mediaTemplate; mtime_t time = 0; if( (mediaTemplate = inheritSegmentTemplate()) ) { uint64_t timescale = mediaTemplate->inheritTimescale(); if(mediaTemplate->segmentTimeline.Get()) { time = mediaTemplate->segmentTimeline.Get()-> getScaledPlaybackTimeByElementNumber(number); } else { time = number * mediaTemplate->duration.Get(); } time = CLOCK_FREQ * time / timescale; } else if ( (segList = inheritSegmentList()) ) { time = segList->getPlaybackTimeBySegmentNumber(number); } return time; }
FileInfo* PieView::_FileAt(const BPoint& where) { BRect b = Bounds(); float cx = b.left + b.Width() / 2.0; float cy = b.top + b.Height() / 2.0; float dx = where.x - cx; float dy = where.y - cy; float dist = sqrt(dx*dx + dy*dy); int level; if (dist < kPieCenterSize) level = 0; else level = 1 + (int)((dist - kPieCenterSize) / kPieRingSize); float angle = rad2deg(atan(dy / dx)); angle = ((dx < 0.0) ? 180.0 : (dy < 0.0) ? 0.0 : 360.0) - angle; if (fMouseOverInfo.find(level) == fMouseOverInfo.end()) { // No files in this level (ring) of the pie. return NULL; } SegmentList s = fMouseOverInfo[level]; SegmentList::iterator i = s.begin(); while (i != s.end() && (angle < (*i).begin || (*i).end < angle)) i++; if (i == s.end()) { // Nothing at this angle. return NULL; } return (*i).info; }
QGraphicsScene * ClusteredArranger::arrange(SegmentList const & segments) const { QGraphicsScene * arrangement = new QGraphicsScene(); QTime time; time.start(); // determine background Segment * background = determineBackground(segments); SegmentList segmentsWOBack = removeBackground(segments, background); arrangement->setBackgroundBrush(QBrush(QColor(background->color().toQRgb()))); segmentsWOBack.calculateFeatureVariances(); // initialize layout //initializeLayout(segmentsWOBack, segmentsWOBack.featX(), segmentsWOBack.featY()); initializeLayout(segmentsWOBack, xAxisBox->currentIndex(), yAxisBox->currentIndex()); // find clusters time.restart(); QList<SegmentList> clusters = meanShift(segmentsWOBack); qDebug("Segments clustered in %f seconds", time.restart()/1000.0); qDebug(" %d clusters found", clusters.size()); // refine clusters //int counter = 0; foreach (SegmentList cluster, clusters) { if (clusterBox->currentIndex() == 0) { refineLayoutCircles(cluster); } else if (clusterBox->currentIndex() == 1) { refineLayoutPiles(cluster); } // debug output /*QGraphicsScene scene; scene.setBackgroundBrush(QBrush(QColor(255, 255, 255))); foreach(Segment * const segment, cluster) { scene.addItem(segment->toQGraphicsItem()); // without the following line QPainter tends to crash scene.width(); } ++counter; saveScene(&scene, QString("Test%1.png").arg(counter, 2));*/ } // refine layout if (clusterBox->currentIndex() == 0) { refineLayoutByPlace(clusters); } else if (clusterBox->currentIndex() == 1) { refineLayoutBySize(clusters); } // convert the segments to QGraphicsItems and add to QGraphicsScene foreach(Segment const * const segment, segmentsWOBack) { arrangement->addItem(segment->toQGraphicsItem()); // without the following line QPainter tends to crash arrangement->width(); }
size_t IsoffMainParser::parseSegmentList(Node * segListNode, SegmentInformation *info) { size_t total = 0; if(segListNode) { std::vector<Node *> segments = DOMHelper::getElementByTagName(segListNode, "SegmentURL", false); SegmentList *list; if((list = new (std::nothrow) SegmentList(info))) { parseInitSegment(DOMHelper::getFirstChildElementByName(segListNode, "Initialization"), list, info); if(segListNode->hasAttribute("duration")) list->duration.Set(Integer<stime_t>(segListNode->getAttributeValue("duration"))); if(segListNode->hasAttribute("timescale")) list->timescale.Set(Integer<uint64_t>(segListNode->getAttributeValue("timescale"))); uint64_t nzStartTime = 0; std::vector<Node *>::const_iterator it; for(it = segments.begin(); it != segments.end(); ++it) { Node *segmentURL = *it; Segment *seg = new (std::nothrow) Segment(info); if(!seg) continue; std::string mediaUrl = segmentURL->getAttributeValue("media"); if(!mediaUrl.empty()) seg->setSourceUrl(mediaUrl); if(segmentURL->hasAttribute("mediaRange")) { std::string range = segmentURL->getAttributeValue("mediaRange"); size_t pos = range.find("-"); seg->setByteRange(atoi(range.substr(0, pos).c_str()), atoi(range.substr(pos + 1, range.size()).c_str())); } if(list->duration.Get()) { seg->startTime.Set(nzStartTime); seg->duration.Set(list->duration.Get()); nzStartTime += list->duration.Get(); } seg->setSequenceNumber(total); list->addSegment(seg); total++; } info->setSegmentList(list); } } return total; }
SegmentList SegmentList::clone() const { SegmentList dl; Segment* s = _first; for (int i = 0; i < _size; ++i) { Segment* ns = s->clone(); dl.push_back(ns); s = s->next(); } dl.check(); return dl; }
void QSegmentWidget::addSegment(int cyl, qreal startAngle, qreal stopAngle, QColor color) { // Segment s(startAngle, stopAngle, color); QSegmentWidget::Segment s; s.first = startAngle; s.second = stopAngle; s.color = color; SegmentList sl; sl.push_back(s); addSegments(cyl, sl); }
void drawInputSegments(){ glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.0,0.0,0.0); glPointSize(3.0); cout << segments.size() << endl; for (int i = 0; i < segments.size(); i++){ glBegin(GL_LINES); glVertex2d(segments[i].p1[0], segments[i].p1[1]); glVertex2d(segments[i].p2[0], segments[i].p2[1]); glEnd(); glFlush(); } }
void getInputSegments(){ segments.push_back(Line(20, 55, 60, 55)); segments.push_back(Line(20, 5, 20, 55)); //TODO: real input segments.push_back(Line(60, 5, 20, 5)); segments.push_back(Line(60, 55, 60, 5)); //segments.push_back(Line(20, 5, 40, 63)); planner = PathPlanner(segments); planner.populateTrajectory(); StateTrajectory* traj = planner.getPathTrajectory(); for (int i = 0; i < traj->size(); i++){ cout << traj->at(i).toString() << endl; } }
SegmentList ShapeOutsideInfo::computeSegmentsForLine(LayoutUnit lineTop, LayoutUnit lineHeight) const { ASSERT(lineHeight >= 0); SegmentList segments; computedShape().getExcludedIntervals((lineTop - logicalTopOffset()), std::min(lineHeight, shapeLogicalBottom() - lineTop), segments); for (size_t i = 0; i < segments.size(); i++) { segments[i].logicalLeft += logicalLeftOffset(); segments[i].logicalRight += logicalLeftOffset(); } return segments; }
size_t IsoffMainParser::parseSegmentBase(Node * segmentBaseNode, SegmentInformation *info) { size_t list_count = 0; if(!segmentBaseNode) return 0; else if(segmentBaseNode->hasAttribute("indexRange")) { SegmentList *list = new SegmentList(); Segment *seg; size_t start = 0, end = 0; if (std::sscanf(segmentBaseNode->getAttributeValue("indexRange").c_str(), "%zu-%zu", &start, &end) == 2) { IndexSegment *index = new DashIndexSegment(info); index->setByteRange(start, end); list->indexSegment.Set(index); /* index must be before data, so data starts at index end */ seg = new Segment(info); seg->setByteRange(end + 1, 0); } else { seg = new Segment(info); } list_count++; list->addSegment(seg); info->setSegmentList(list); Node *initSeg = DOMHelper::getFirstChildElementByName(segmentBaseNode, "Initialization"); if(initSeg) { SegmentBase *base = new SegmentBase(); parseInitSegment(initSeg, base, info); info->setSegmentBase(base); } } else { SegmentBase *base = new SegmentBase(); parseInitSegment(DOMHelper::getFirstChildElementByName(segmentBaseNode, "Initialization"), base, info); info->setSegmentBase(base); } return list_count; }
/// arc in radians void TrackData::AddCurve (SegmentList& segments, float arc, float radius, float end_width_l, float end_width_r) { arc = arc * PI/180.0f; float length = fabs(arc) * radius; int N = 1 + (int) floor(length/step); float s = length / (float) N; float d_width_l = (end_width_l - width_l) / (float) N; float d_width_r = (end_width_r - width_r) / (float) N; float d_angle = arc / (float) N; float start_angle = angle; float hpi = (float) (PI/2.0); for (int i=0; i<N; ++i) { mid.x += s*sin(angle); mid.y += s*cos(angle); Point left(mid.x + width_l*sin(angle - hpi), mid.y + width_l*cos(angle - hpi), mid.z); Point right(mid.x + width_r*sin(angle + hpi), mid.y + width_r*cos(angle + hpi), mid.z); segments.Add (Segment (left, right)); angle += d_angle; width_l += d_width_l; width_r += d_width_r; } width_l = end_width_l; width_r = end_width_r; angle = start_angle + arc; }
void ExclusionRectangle::getExcludedIntervals(float logicalTop, float logicalBottom, SegmentList& result) const { float y1 = minYForLogicalLine(logicalTop, logicalBottom); float y2 = maxYForLogicalLine(logicalTop, logicalBottom); if (y2 < m_y || y1 >= m_y + m_height) return; float x1 = m_x; float x2 = m_x + m_width; if (m_ry > 0) { if (y2 < m_y + m_ry) { float yi = y2 - m_y - m_ry; float xi = ellipseXIntercept(yi, m_rx, m_ry); x1 = m_x + m_rx - xi; x2 = m_x + m_width - m_rx + xi; } else if (y1 > m_y + m_height - m_ry) { float yi = y1 - (m_y + m_height - m_ry); float xi = ellipseXIntercept(yi, m_rx, m_ry); x1 = m_x + m_rx - xi; x2 = m_x + m_width - m_rx + xi; } } result.append(LineSegment(x1, x2)); }
void RectangleShape::getExcludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const { const FloatRoundedRect& bounds = shapeMarginBounds(); if (bounds.isEmpty()) return; float y1 = logicalTop; float y2 = logicalTop + logicalHeight; if (y2 < bounds.y() || y1 >= bounds.maxY()) return; float x1 = bounds.x(); float x2 = bounds.maxX(); if (bounds.ry() > 0) { if (y2 < bounds.y() + bounds.ry()) { float yi = y2 - bounds.y() - bounds.ry(); float xi = ellipseXIntercept(yi, bounds.rx(), bounds.ry()); x1 = bounds.x() + bounds.rx() - xi; x2 = bounds.maxX() - bounds.rx() + xi; } else if (y1 > bounds.maxY() - bounds.ry()) { float yi = y1 - (bounds.maxY() - bounds.ry()); float xi = ellipseXIntercept(yi, bounds.rx(), bounds.ry()); x1 = bounds.x() + bounds.rx() - xi; x2 = bounds.maxX() - bounds.rx() + xi; } } result.append(LineSegment(x1, x2)); }
void PolygonShape::getExcludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const { const FloatPolygon& polygon = shapeMarginBounds(); if (polygon.isEmpty()) return; float y1 = logicalTop; float y2 = logicalTop + logicalHeight; FloatShapeIntervals y1XIntervals, y2XIntervals; computeXIntersections(polygon, y1, true, y1XIntervals); computeXIntersections(polygon, y2, false, y2XIntervals); FloatShapeIntervals mergedIntervals; FloatShapeInterval::uniteShapeIntervals(y1XIntervals, y2XIntervals, mergedIntervals); FloatShapeIntervals edgeIntervals; computeOverlappingEdgeXProjections(polygon, y1, y2, edgeIntervals); FloatShapeIntervals excludedIntervals; FloatShapeInterval::uniteShapeIntervals(mergedIntervals, edgeIntervals, excludedIntervals); for (unsigned i = 0; i < excludedIntervals.size(); ++i) { FloatShapeInterval interval = excludedIntervals[i]; result.append(LineSegment(interval.x1(), interval.x2())); } }
void PolygonShape::getIncludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const { const FloatPolygon& polygon = shapePaddingBounds(); if (polygon.isEmpty()) return; float y1 = logicalTop; float y2 = logicalTop + logicalHeight; FloatShapeIntervals y1XIntervals, y2XIntervals; computeXIntersections(polygon, y1, true, y1XIntervals); computeXIntersections(polygon, y2, false, y2XIntervals); FloatShapeIntervals commonIntervals; FloatShapeInterval::intersectShapeIntervals(y1XIntervals, y2XIntervals, commonIntervals); FloatShapeIntervals edgeIntervals; computeOverlappingEdgeXProjections(polygon, y1, y2, edgeIntervals); FloatShapeIntervals includedIntervals; FloatShapeInterval::subtractShapeIntervals(commonIntervals, edgeIntervals, includedIntervals); for (unsigned i = 0; i < includedIntervals.size(); ++i) { const FloatShapeInterval& interval = includedIntervals[i]; result.append(LineSegment(interval.x1(), interval.x2())); } }
void PolygonShape::getExcludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const { float y1 = logicalTop; float y2 = logicalTop + logicalHeight; if (m_polygon.isEmpty() || !m_polygon.boundingBox().overlapsYRange(y1 - shapeMargin(), y2 + shapeMargin())) return; Vector<const FloatPolygonEdge*> overlappingEdges; if (!m_polygon.overlappingEdges(y1 - shapeMargin(), y2 + shapeMargin(), overlappingEdges)) return; FloatShapeInterval excludedInterval; for (unsigned i = 0; i < overlappingEdges.size(); i++) { const FloatPolygonEdge& edge = *(overlappingEdges[i]); if (!shapeMargin()) excludedInterval.unite(OffsetPolygonEdge(edge, FloatSize()).clippedEdgeXRange(y1, y2)); else { excludedInterval.unite(OffsetPolygonEdge(edge, outwardEdgeNormal(edge) * shapeMargin()).clippedEdgeXRange(y1, y2)); excludedInterval.unite(OffsetPolygonEdge(edge, inwardEdgeNormal(edge) * shapeMargin()).clippedEdgeXRange(y1, y2)); excludedInterval.unite(clippedCircleXRange(edge.vertex1(), shapeMargin(), y1, y2)); } } if (!excludedInterval.isEmpty()) result.append(LineSegment(excludedInterval.x1(), excludedInterval.x2())); }
void ExclusionPolygon::getIncludedIntervals(float logicalTop, float logicalHeight, SegmentList& result) const { if (isEmpty()) return; float y1 = minYForLogicalLine(logicalTop, logicalHeight); float y2 = maxYForLogicalLine(logicalTop, logicalHeight); Vector<ExclusionInterval> y1XIntervals, y2XIntervals; computeXIntersections(y1, true, y1XIntervals); computeXIntersections(y2, false, y2XIntervals); Vector<ExclusionInterval> commonIntervals; intersectExclusionIntervals(y1XIntervals, y2XIntervals, commonIntervals); Vector<ExclusionInterval> edgeIntervals; computeEdgeIntersections(y1, y2, edgeIntervals); Vector<ExclusionInterval> includedIntervals; subtractExclusionIntervals(commonIntervals, edgeIntervals, includedIntervals); for (unsigned i = 0; i < includedIntervals.size(); i++) { ExclusionInterval interval = includedIntervals[i]; result.append(LineSegment(interval.x1, interval.x2)); } }
void ExclusionPolygon::getExcludedIntervals(float logicalTop, float logicalHeight, SegmentList& result) const { const FloatPolygon& polygon = shapeMarginBounds(); if (polygon.isEmpty()) return; float y1 = logicalTop; float y2 = y1 + logicalHeight; Vector<ExclusionInterval> y1XIntervals, y2XIntervals; computeXIntersections(polygon, y1, true, y1XIntervals); computeXIntersections(polygon, y2, false, y2XIntervals); Vector<ExclusionInterval> mergedIntervals; mergeExclusionIntervals(y1XIntervals, y2XIntervals, mergedIntervals); Vector<ExclusionInterval> edgeIntervals; computeOverlappingEdgeXProjections(polygon, y1, y2, edgeIntervals); Vector<ExclusionInterval> excludedIntervals; mergeExclusionIntervals(mergedIntervals, edgeIntervals, excludedIntervals); for (unsigned i = 0; i < excludedIntervals.size(); ++i) { ExclusionInterval interval = excludedIntervals[i]; result.append(LineSegment(interval.x1, interval.x2)); } }
void ExclusionPolygon::getIncludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const { const FloatPolygon& polygon = shapePaddingBounds(); if (polygon.isEmpty()) return; float y1 = logicalTop; float y2 = logicalTop + logicalHeight; Vector<ExclusionInterval> y1XIntervals, y2XIntervals; computeXIntersections(polygon, y1, true, y1XIntervals); computeXIntersections(polygon, y2, false, y2XIntervals); Vector<ExclusionInterval> commonIntervals; intersectExclusionIntervals(y1XIntervals, y2XIntervals, commonIntervals); Vector<ExclusionInterval> edgeIntervals; computeOverlappingEdgeXProjections(polygon, y1, y2, edgeIntervals); Vector<ExclusionInterval> includedIntervals; subtractExclusionIntervals(commonIntervals, edgeIntervals, includedIntervals); for (unsigned i = 0; i < includedIntervals.size(); ++i) { ExclusionInterval interval = includedIntervals[i]; result.append(LineSegment(interval.x1, interval.x2)); } }
void Convex::FacetToSegmentsGorizon(FacetList *FL, SegmentList *SL) { Facet *pF; Segment S; SegmentList SN; if ( FL->GetFirst(&pF) ) { // з кожної грані створюємо три ребра do { S.Init(pF->A, pF->B); SN.Add(S); S.Init(pF->A, pF->C); SN.Add(S); S.Init(pF->C, pF->B); SN.Add(S); } while (FL->GetNext(&pF)); // В список ребер горизонту включаємо лише зовнішні ребра видимої області while(!SN.IsEmpty()) { SN.Remove(&S); if (SN.FindAndRemoveAll(S)==0) { SL->Add(S); #ifdef CONVEX_DEBUG printf( "Add to horizon : "); S.PrintPoints(); #endif }; }; }; }
bool SegmentInformation::getPlaybackTimeDurationBySegmentNumber(uint64_t number, mtime_t *time, mtime_t *duration) const { SegmentList *segList; MediaSegmentTemplate *mediaTemplate; if( (mediaTemplate = inheritSegmentTemplate()) ) { const Timescale timescale = mediaTemplate->inheritTimescale(); stime_t stime, sduration; if(mediaTemplate->segmentTimeline.Get()) { mediaTemplate->segmentTimeline.Get()-> getScaledPlaybackTimeDurationBySegmentNumber(number, &stime, &sduration); } else { stime = number * mediaTemplate->duration.Get(); sduration = mediaTemplate->duration.Get(); } *time = timescale.ToTime(stime); *duration = timescale.ToTime(sduration); return true; } else if ( (segList = inheritSegmentList()) ) { return segList->getPlaybackTimeDurationBySegmentNumber(number, time, duration); } else { const Timescale timescale = inheritTimescale(); const ISegment *segment = getSegment(SegmentInfoType::INFOTYPE_MEDIA, number); if( segment ) { *time = timescale.ToTime(segment->startTime.Get()); *duration = timescale.ToTime(segment->duration.Get()); return true; } } return false; }
void BoxShape::getExcludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const { const FloatRoundedRect& marginBounds = shapeMarginBounds(); if (marginBounds.isEmpty() || !lineOverlapsShapeMarginBounds(logicalTop, logicalHeight)) return; float y1 = logicalTop; float y2 = logicalTop + logicalHeight; const FloatRect& rect = marginBounds.rect(); if (!marginBounds.isRounded()) { result.append(LineSegment(rect.x(), rect.maxX())); return; } float topCornerMaxY = std::max<float>(marginBounds.topLeftCorner().maxY(), marginBounds.topRightCorner().maxY()); float bottomCornerMinY = std::min<float>(marginBounds.bottomLeftCorner().y(), marginBounds.bottomRightCorner().y()); if (y1 <= topCornerMaxY && y2 >= bottomCornerMinY) { result.append(LineSegment(rect.x(), rect.maxX())); return; } float x1 = rect.maxX(); float x2 = rect.x(); float minXIntercept; float maxXIntercept; if (marginBounds.xInterceptsAtY(y1, minXIntercept, maxXIntercept)) { x1 = std::min<float>(x1, minXIntercept); x2 = std::max<float>(x2, maxXIntercept); } if (marginBounds.xInterceptsAtY(y2, minXIntercept, maxXIntercept)) { x1 = std::min<float>(x1, minXIntercept); x2 = std::max<float>(x2, maxXIntercept); } ASSERT(x2 >= x1); result.append(LineSegment(x1, x2)); }