bool Clipping::clipCurve(Object *obj){ auto& coords = obj->getNCoords(); Coordinates newPath; bool prevInside = true; Coordinate prev; for(unsigned int i = 0; i < coords.size(); i++){ if(clipPoint(coords[i])){ if(!prevInside){ clipLine(prev, coords[i]); newPath.push_back(prev); } newPath.push_back(coords[i]); prevInside = true; }else{ if(prevInside && newPath.size() != 0){ clipLine(prev, coords[i]); newPath.push_back(coords[i]); } prevInside = false; } prev = coords[i]; } if(newPath.size() == 0) return false; obj->setNCoord(newPath); return true; }
void main(){ int color; int clip1X, clip1Y, clip2X, clip2Y; int end1X, end1Y, end2X, end2Y, retval; srand(*my_clock); set_mode(VGA_256_COLOR_MODE); // color=rand()%NUM_COLORS; color=175; // membuat view (kotak) line_bresenham(KIRI,ATAS,KANAN,ATAS,color); line_bresenham(KANAN,ATAS,KANAN,BAWAH,color); line_bresenham(KANAN,BAWAH,KIRI,BAWAH,color); line_bresenham(KIRI,BAWAH,KIRI,ATAS,color); // garis pemotong 1 clip1X = clip1Y = clip2X = clip2Y = 0; end1X = 130; end1Y = 30; end2X = 150; end2Y = 150; line_bresenham(end1X,end1Y,end2X,end2Y,color); retval = clipLine(end1X,end1Y,end2X,end2Y,&clip1X,&clip1Y,&clip2X,&clip2Y); if(retval) { line_bresenham(clip1X,clip1Y,clip2X,clip2Y,color-99); } // garis pemotong 2 end1X = 50; end1Y = 90; end2X = 215; end2Y = 90; line_bresenham(end1X,end1Y,end2X,end2Y,color); retval = clipLine(end1X,end1Y,end2X,end2Y,&clip1X,&clip1Y,&clip2X,&clip2Y); if(retval) { line_bresenham(clip1X,clip1Y,clip2X,clip2Y,color-99); } // garis tak memotong end1X = 200; end1Y = 15; end2X = 200; end2Y = 170; line_bresenham(end1X,end1Y,end2X,end2Y,color); retval = clipLine(end1X,end1Y,end2X,end2Y,&clip1X,&clip1Y,&clip2X,&clip2Y); if(retval) { line_bresenham(clip1X,clip1Y,clip2X,clip2Y,color-99); } // garis memotong di dalam (trivial accept) end1X = KANAN; end1Y = ATAS; end2X = KIRI; end2Y = BAWAH; line_bresenham(end1X,end1Y,end2X,end2Y,color); retval = clipLine(end1X,end1Y,end2X,end2Y,&clip1X,&clip1Y,&clip2X,&clip2Y); if(retval) { line_bresenham(clip1X,clip1Y,clip2X,clip2Y,color-99); } sleep(2); set_mode(TEXT_MODE); return; }
// clip the triangle (V1, V2, V3) by the near and far clipping plane and // obtain a set of vertices after the clipping. The number of vertices // is at most 5. void BlenderFileLoader::clipTriangle(int numTris, float triCoords[][3], float v1[3], float v2[3], float v3[3], float triNormals[][3], float n1[3], float n2[3], float n3[3], bool edgeMarks[], bool em1, bool em2, bool em3, int clip[3]) { float *v[3], *n[3]; bool em[3]; int i, j, k; v[0] = v1; n[0] = n1; v[1] = v2; n[1] = n2; v[2] = v3; n[2] = n3; em[0] = em1; /* edge mark of the edge between v1 and v2 */ em[1] = em2; /* edge mark of the edge between v2 and v3 */ em[2] = em3; /* edge mark of the edge between v3 and v1 */ k = 0; for (i = 0; i < 3; i++) { j = (i + 1) % 3; if (clip[i] == NOT_CLIPPED) { copy_v3_v3(triCoords[k], v[i]); copy_v3_v3(triNormals[k], n[i]); edgeMarks[k] = em[i]; k++; if (clip[j] != NOT_CLIPPED) { clipLine(v[i], v[j], triCoords[k], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far); copy_v3_v3(triNormals[k], n[j]); edgeMarks[k] = false; k++; } } else if (clip[i] != clip[j]) { if (clip[j] == NOT_CLIPPED) { clipLine(v[i], v[j], triCoords[k], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far); copy_v3_v3(triNormals[k], n[i]); edgeMarks[k] = em[i]; k++; } else { clipLine(v[i], v[j], triCoords[k], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far); copy_v3_v3(triNormals[k], n[i]); edgeMarks[k] = em[i]; k++; clipLine(v[i], v[j], triCoords[k], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far); copy_v3_v3(triNormals[k], n[j]); edgeMarks[k] = false; k++; } } } BLI_assert(k == 2 + numTris); (void)numTris; /* Ignored in release builds. */ }
bool Clipping::clip(Object* obj){ switch(obj->getType()){ case ObjType::OBJECT: break; case ObjType::POINT: return clipPoint(obj->getNCoord(0)); case ObjType::LINE: return clipLine(obj->getNCoord(0), obj->getNCoord(1)); case ObjType::POLYGON: return clipPolygon(obj); case ObjType::BEZIER_CURVE: case ObjType::BSPLINE_CURVE: return clipCurve(obj); case ObjType::OBJECT3D:{ Object3D *obj3d = (Object3D*) obj; bool draw = false; for(auto &face : obj3d->getFaceList()){ bool tmp = clipPolygon(&face); if(!tmp){ face.getNCoords().clear(); } draw |= tmp; } return draw; }case ObjType::BEZIER_SURFACE: case ObjType::BSPLINE_SURFACE:{ Surface *surf = (Surface*) obj; bool draw = false; for(auto &curve : surf->getCurveList()){ bool tmp = clipCurve(&curve); if(!tmp){ curve.getNCoords().clear(); } draw |= tmp; } return draw; }} return false; }
/* ** Routine for clipping a polyline, stored in a shapeObj struct, to a ** rectangle. Uses clipLine() function to create a new shapeObj. */ void msClipPolylineRect(shapeObj *shape, rectObj rect) { int i,j; lineObj line={0,NULL}; double x1, x2, y1, y2; shapeObj tmp={0,NULL}; if(shape->numlines == 0) /* nothing to clip */ return; for(i=0; i<shape->numlines; i++) { line.point = (pointObj *)malloc(sizeof(pointObj)*shape->line[i].numpoints); line.numpoints = 0; x1 = shape->line[i].point[0].x; y1 = shape->line[i].point[0].y; for(j=1; j<shape->line[i].numpoints; j++) { x2 = shape->line[i].point[j].x; y2 = shape->line[i].point[j].y; if(clipLine(&x1,&y1,&x2,&y2,rect) == MS_TRUE) { if(line.numpoints == 0) { /* first segment, add both points */ line.point[0].x = x1; line.point[0].y = y1; line.point[1].x = x2; line.point[1].y = y2; line.numpoints = 2; } else { /* add just the last point */ line.point[line.numpoints].x = x2; line.point[line.numpoints].y = y2; line.numpoints++; } if((x2 != shape->line[i].point[j].x) || (y2 != shape->line[i].point[j].y)) { msAddLine(&tmp, &line); line.numpoints = 0; /* new line */ } } x1 = shape->line[i].point[j].x; y1 = shape->line[i].point[j].y; } if(line.numpoints > 0) msAddLine(&tmp, &line); free(line.point); line.numpoints = 0; /* new line */ } for (i=0; i<shape->numlines; i++) free(shape->line[i].point); free(shape->line); shape->line = tmp.line; shape->numlines = tmp.numlines; }
inline void fill2EllipseLines(pb_rgba *pb, const uint32_t cx, const uint32_t cy, const unsigned int x, const unsigned int y, const uint32_t color) { int x1 = cx - x; int y1 = cy+y; int x2 = cx + x; int y2 = cy+y; if (clipLine(pb->frame, x1, y1, x2, y2)) { raster_rgba_hline_blend(pb, x1, y1, x2-x1, color); } y1 = cy - y; y2 = cy - y; if (clipLine(pb->frame, x1, y1, x2, y2)) { raster_rgba_hline_blend(pb, x1, y1, x2 - x1, color); } //raster_rgba_hline_blend(pb, cx - x, cy - y, 2 * x, color); }
bool Frustum::project(osg::Vec3 &v1, osg::Vec3 &v2) { bool v1Inside, v2Inside; bool projected = false; osg::Vec3 ov1,ov2; ov1 = v1; ov2 = v2; v1Inside = inside(v1); v2Inside = inside(v2); if ((v1Inside) && (v2Inside)) return true; // ok, einer oder beide punkte liegen ausserhalb des frustum-volumes, // jetzt müssen wir die Schnittpunkte suchen PlaneVector::iterator itr; if (!v1Inside) { for (itr = _planes.begin(); itr !=_planes.end(); itr++) { if (clipLine((*itr), v1,ov2)) { osg::notify(osg::DEBUG_INFO) << "clipped " << ov1 << " to " << v1 << " plane: " << ((*itr).name) << std::endl; projected = true; break; } } } if (!v2Inside) { for (itr = _planes.begin(); itr !=_planes.end(); itr++) { if (clipLine((*itr), v2,ov1)) { osg::notify(osg::DEBUG_INFO) << "clipped " << ov2 << " to " << v2 << " plane: " << ((*itr).name) << std::endl; projected = true; break; } } } return projected; }
bool Clipping::clip(Object* obj){ switch(obj->getType()){ case ObjType::POINT: return clipPoint(obj->getNCoord(0)); case ObjType::LINE: return clipLine(obj->getNCoord(0), obj->getNCoord(1)); case ObjType::POLYGON: return clipPolygon(obj); case ObjType::BEZIER_CURVE: return clipCurve(obj); default: return false; } }
void PipeLine::drawLine(int x1,int y1,int x2,int y2,uint32_t c,uint32_t depth){ if( clipLine(x1,y1,x2,y2) == false) return; int x, y, rem = 0; if (x1 == x2 && y1 == y2) { fillPoint( x1, y1, c,depth); }else if (x1 == x2) { int inc = (y1 <= y2)? 1 : -1; for (y = y1; y != y2; y += inc) fillPoint( x1, y, c,depth); fillPoint( x2, y2, c,depth); }else if (y1 == y2) { int inc = (x1 <= x2)? 1 : -1; for (x = x1; x != x2; x += inc) fillPoint( x, y1, c,depth); fillPoint( x2, y2, c,depth); }else { // Bresenham line int dx = (x1 < x2)? (x2 - x1) : (x1 - x2); int dy = (y1 < y2)? (y2 - y1) : (y1 - y2); if (dx >= dy) { /* x axis 每次加1 y + dy 如果大于 dx需要矫正 */ if (x2 < x1) { std::swap(x1, x2);std::swap(y1, y2); } int delta = (y2 >= y1)? 1 : -1; for (x = x1, y = y1; x <= x2; x++/* x 每次加1 */) { rem += dy; if (rem >= dx) { rem -= dx; y += delta; } fillPoint(x,y,c,depth); } }else { if (y2 < y1) std::swap(x1,x2),std::swap(y1,y2); int delta = (x2 >= x1)? 1 : -1; for (x = x1, y = y1; y <= y2; y++) { rem += dx; if (rem >= dy) { rem -= dy; x += delta; } fillPoint(x, y,c,depth); } } fillPoint(x2,y2,c,depth); } }
static void WinClipAndDrawLine( EDA_RECT* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int width ) { GRLastMoveToX = x2; GRLastMoveToY = y2; if( ClipBox ) { EDA_RECT clipbox(*ClipBox); clipbox.Inflate(width/2); if( clipLine( &clipbox, x1, y1, x2, y2 ) ) return; } DC->DrawLine( x1, y1, x2, y2 ); }
void ProjectVisitor::ProjectTriangleToHeightField::insertTouchedLines(const osg::Vec3d& v1, const osg::Vec3d& v2) { osg::Vec2d p1InGrind, p2InGrind; findGridFromPoint(v1, p1InGrind); findGridFromPoint(v2, p2InGrind); bool valid = clipLine(p1InGrind, p2InGrind); if (!valid) return; osg::ref_ptr<osg::Vec3Array> array = followLine(p1InGrind, p2InGrind); InsertGeometryHelper inserter; inserter.init(_result.get()); inserter.appendLineStrip(array.get()); }
static void WinClipAndDrawLine( EDA_RECT* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, EDA_COLOR_T Color, int width = 1 ) { GRLastMoveToX = x2; GRLastMoveToY = y2; if( ClipBox ) { EDA_RECT clipbox(*ClipBox); clipbox.Inflate(width/2); if( clipLine( &clipbox, x1, y1, x2, y2 ) ) return; } GRSetColorPen( DC, Color, width ); DC->DrawLine( x1, y1, x2, y2 ); }
//Implementation of the Cohen-Sutherland clipping algorithm. ClipResult clipLine(float x0, float y0, float x1, float y1, float xMin, float yMin, float xMax, float yMax){ ClipResult result; int startCode = getOutCode(x0, y0, xMin, yMin, xMax, yMax); int endCode = getOutCode(x1, y1, xMin, yMin, xMax, yMax); //Line is entirely within the clipping window. if((startCode | endCode) == 0){ return ClipResult(x0, y0, x1, y1, false); } //Line does not cross the clipping window, remove it. if(startCode & endCode) return ClipResult(x0, y0, x1, y1, true); int clipCode = startCode ? startCode : endCode; float xClip = 0; float yClip = 0; if(clipCode & Math::UP_OUTCODE){ // Get x intersection with window's top border. xClip = x0 + ((yMin - y0) / (y1 - y0)) * (x1 - x0); yClip = yMin; } else if(clipCode & Math::DOWN_OUTCODE){ // Get x intersection with window's bottom border. xClip = x0 + ((yMax - y0) / (y1 - y0)) * (x1 - x0); yClip = yMax; } else if(clipCode & Math::LEFT_OUTCODE){ // Get y intersection with window's left border. xClip = xMin; yClip = y0 + ((xMin - x0) / (x1 - x0)) * (y1 - y0); } else if(clipCode & Math::RIGHT_OUTCODE){ // Get y intersection with window's right border. xClip = xMax; yClip = y0 + ((xMax - x0) / (x1 - x0)) * (y1 - y0); } // Update coordinates of the result. if(clipCode == startCode){ x0 = xClip; y0 = yClip; } else { x1 = xClip; y1 = yClip; } // Recursive, but maximum of two calls (if in a corner region), so little overhead. return clipLine(x0, y0, x1, y1, xMin, yMin, xMax, yMax); };
void pamd_line(tuple ** const tuples, int const cols, int const rows, int const depth, sample const maxval, pamd_point const p0, pamd_point const p1, pamd_drawproc drawProc, const void * const clientdata) { pamd_point c0, c1; bool noLine; /* There's no line left after clipping */ pamd_validateCoord(cols); pamd_validateCoord(rows); pamd_validatePoint(p0); pamd_validatePoint(p1); if (lineclip) { clipLine(p0, p1, cols, rows, &c0, &c1, &noLine); } else { c0 = p0; c1 = p1; noLine = FALSE; } if (noLine) { /* Nothing to draw */ } else if (pointsEqual(c0, c1)) { /* This line is just a point. Because there aren't two distinct endpoints, we have a special case. */ drawPoint(drawProc, clientdata, tuples, cols, rows, depth, maxval, c0); } else { /* Draw, using a simple DDA. */ if (abs(c1.x - c0.x) > abs(c1.y - c0.y)) drawShallowLine(drawProc, clientdata, tuples, cols, rows, depth, maxval, c0, c1); else drawSteepLine(drawProc, clientdata, tuples, cols, rows, depth, maxval, c0, c1); } }
void plotLinesToPainter(QPainter& painter, const Numpy1DObj& x1, const Numpy1DObj& y1, const Numpy1DObj& x2, const Numpy1DObj& y2, const QRectF* clip, bool autoexpand) { const int maxsize = min(x1.dim, x2.dim, y1.dim, y2.dim); // if autoexpand, expand rectangle by line width QRectF clipcopy; if ( clip != 0 && autoexpand ) { const qreal lw = painter.pen().widthF(); qreal x1, y1, x2, y2; clip->getCoords(&x1, &y1, &x2, &y2); clipcopy.setCoords(x1, y1, x2, y2); clipcopy.adjust(-lw, -lw, lw, lw); } if( maxsize != 0 ) { QVector<QLineF> lines; for(int i = 0; i < maxsize; ++i) { QPointF pt1(x1(i), y1(i)); QPointF pt2(x2(i), y2(i)); if( clip != 0 ) { if( clipLine(clipcopy, pt1, pt2) ) lines << QLineF(pt1, pt2); } else lines << QLineF(pt1, pt2); } painter.drawLines(lines); } }
void Viewer::paintGL() { draw_init(); auto viewM = viewPoint.getViewMatrix(); auto perspectiveM = perspectiveMatrix(); // Norms of clipping planes Vector3D nearNorm = {0, 0, 1}; Vector3D farNorm = {0, 0, -1}; Vector3D leftNorm = {1, 0, 0}; Vector3D rightNorm = {-1, 0, 0}; Vector3D topNorm = {0, -1, 0}; Vector3D bottomNorm = {0, 1, 0}; // Points on clipping planes Point3D nearPoint = {0, 0, near}; Point3D farPoint = {0, 0, far}; Point3D leftPoint = {-1, 0, 0}; Point3D rightPoint = {1, 0, 0}; Point3D topPoint = {0, 1, 0}; Point3D bottomPoint = {0, -1, 0}; // Convert vp1 and vp2 into points in range [-1, 1] Point2D vp1, vp2; getAdjustedViewportBounds(&vp1, &vp2); int idx = 0; for (const auto& model : {boxModel, boxGnomon, worldGnomon}) { idx += 1; auto v = model.getLines(); int jdx = -1; for (auto& line : v) { jdx += 1; // Last minute colour additions lol if (idx == 1) { if (jdx < 4) { set_colour(QColor(0.0, 1.0, 1.0)); } else { set_colour(QColor(1.0, 1.0, 1.0)); } } else if (idx == 2) { // Draw box gnomon as some kind of red set_colour(QColor(1.0, 1.0, 0.0)); } else { // Draw world gnomon in fancy colours set_colour(QColor(jdx == 0 ? 1.0 : 0.0, jdx == 1 ? 1.0 : 0.0, jdx == 2 ? 1.0 : 0.0)); } // Now we have the view coordinates line.start = viewM * line.start; line.end = viewM * line.end; // Now we want to clip the line to the near and far planes first, to // avoid ambiguity. (Actually, we only need to do the near one, but // far is the same so why not do that too) :) if (!clipLine(&line, nearNorm, nearPoint) || !clipLine(&line, farNorm, farPoint)) { continue; } // We need these because our vectors are 3D not 4D... auto startZ = line.start[2]; auto endZ = line.end[2]; // Now multiply to project it onto the near plane line.start = perspectiveM * line.start; line.end = perspectiveM * line.end; // We no longer care about depth // TODO: Convert to 2D for (int i = 0; i < 3; ++i) { line.start[i] /= startZ; line.end[i] /= endZ; } // We can clip these afterwards (in 2D, since we don't care about depth) // TODO: 2D if (!clipLine(&line, rightNorm, rightPoint) || !clipLine(&line, leftNorm, leftPoint) || !clipLine(&line, topNorm, topPoint) || !clipLine(&line, bottomNorm, bottomPoint)) { continue; } const Line2D windowLine = { {line.start[0], line.start[1]}, {line.end[0], line.end[1]} }; const Line2D viewportLine = { adjustForViewport(windowLine.start, vp1, vp2), adjustForViewport(windowLine.end, vp1, vp2) }; draw_line(viewportLine.start, viewportLine.end); } } // Finally, draw viewport lines set_colour(QColor(0.0, 0.0, 0.0)); draw_line(vp1, {vp1[0], vp2[1]}); draw_line(vp1, {vp2[0], vp1[1]}); draw_line({vp1[0], vp2[1]}, vp2); draw_line({vp2[0], vp1[1]}, vp2); }
void timelineWidget::paintEvent( QPaintEvent * ) { if( jLib::math::fcmp( timeInView( ), 0 ) ) { if( endTime() != jLib::floatLimits::infinity() && beginTime() != jLib::floatLimits::infinity() ) { timeInView( endTime() - beginTime() ); viewCentre( ( endTime() + beginTime() ) / 2 ); } else { timeInView( 10 ); viewCentre( 5 ); } } QPainter painter(this); painter.setRenderHint( QPainter::Antialiasing, TRUE ); if( timeInView() > ( endTime( ) - beginTime( ) ) ) { timeInView( endTime( ) - beginTime( ) ); } JFLOAT realBeginDrawing = viewCentre() - ( timeInView()/2 ); JFLOAT realEndDrawing = viewCentre() + ( timeInView()/2 ); if( realEndDrawing > endTime() ) { realEndDrawing = endTime( ); realBeginDrawing = endTime( ) - timeInView( ); viewCentre( endTime( ) - ( timeInView()/2 ) ); } if( realBeginDrawing < beginTime() ) { realBeginDrawing = beginTime( ); realEndDrawing = beginTime( ) + timeInView( ); viewCentre( beginTime( ) + ( timeInView()/2 ) ); } JFLOAT timeSpikeIntervals[] = { 0.125, 0.25, 0.5, 1, 1.25, 2.5, 5, 10, 50 }; JFLOAT timeSpikeInterval = jLib::floatLimits::nan(); JFLOAT minDist = jLib::floatLimits::infinity(); for( int x=0; x<9; x++ ) { JFLOAT size = timeToPixel( timeSpikeIntervals[x], 0, ( realEndDrawing - realBeginDrawing ), width() ); if( ( size - 50.0 ) < minDist ) { timeSpikeInterval = timeSpikeIntervals[x]; minDist = size; } } if( timeSpikeInterval != timeSpikeInterval ) { timeSpikeInterval = 1.0; } JFLOAT beginDrawing = realBeginDrawing - fmod( realBeginDrawing, timeSpikeInterval ) - 1; JFLOAT endDrawing = realEndDrawing + ( timeSpikeInterval - fmod( realEndDrawing, timeSpikeInterval ) ); painter.setPen( QApplication::palette().color( QPalette::Text ) ); for( JFLOAT x=( beginDrawing - timeSpikeInterval ); x<=endDrawing; x+=timeSpikeInterval ) { JFLOAT actualTime = x + 1; JFLOAT xMidPos = timeToPixel( actualTime + ( 0.5 * timeSpikeInterval ), realBeginDrawing, realEndDrawing, width() ); painter.drawLine( QPointF( xMidPos, height() ), QPointF( xMidPos, height() - minorTimeHeight() ) ); JFLOAT xPos = timeToPixel( actualTime, realBeginDrawing, realEndDrawing, width() ); painter.drawText( (int)(xPos+2), (int)(height() - majorTimeHeight()-5), formatTime( actualTime ) ); painter.drawLine( QPointF( xPos, height() ), QPointF( xPos, height() - majorTimeHeight() ) ); } QColor clipColourA( QApplication::palette().color( QPalette::Shadow ) ); clipColourA.setAlpha( 200 ); QColor clipColourB( QApplication::palette().color( QPalette::Shadow ) ); clipColourB.setAlpha(100 ); QLinearGradient clipGrad( 0, 0, 0, height() ); clipGrad.setColorAt( 0.0, clipColourA ); clipGrad.setColorAt( 1.0, clipColourB ); QPen clipLine( QApplication::palette().color( QPalette::Shadow ) ); clipLine.setWidthF( 1.5 ); if( clipBegin() > realBeginDrawing ) { JFLOAT clipBeginPix = timeToPixel( clipBegin(), realBeginDrawing, realEndDrawing, width() ); painter.setPen( Qt::transparent ); painter.setBrush( clipGrad ); painter.drawRect( 0, 0, (int)clipBeginPix, (int)height() ); painter.setPen( clipLine ); painter.drawLine( (int)(clipBeginPix+1), 0, (int)(clipBeginPix+1), height() ); } if( clipEnd() < realEndDrawing ) { JFLOAT clipEndPix = timeToPixel( clipEnd(), realBeginDrawing, realEndDrawing, width() ); if( clipEndPix < 0 ) { clipEndPix = 0; } painter.setPen( Qt::transparent ); painter.setBrush( clipGrad ); painter.drawRect( (int)clipEndPix, 0, width(), height() ); painter.setPen( clipLine ); painter.drawLine( (int)clipEndPix, 0, (int)clipEndPix, height() ); } JFLOAT now = timeToPixel( currentTime(), realBeginDrawing, realEndDrawing, width() ); QColor nowColour = QApplication::palette().color( QPalette::Highlight ); nowColour.setAlpha( 200 ); QPen nowPen( nowColour ); nowPen.setWidthF( 2.5 ); painter.setPen( nowPen ); painter.drawLine( QPointF( now, 0 ), QPointF( now, height() ) ); painter.setPen( QApplication::palette().color( QPalette::Text ) ); painter.drawText( (int)(now+2), (int)(height() - majorTimeHeight()-20), formatTime( currentTime() ) ); nowColour.setAlpha( 150 ); QLinearGradient highlight( now, 0, now-_nowGradientSpread, 0 ); highlight.setColorAt(0, nowColour ); highlight.setColorAt(1, Qt::transparent ); painter.fillRect( QRectF( now-_nowGradientSpread, 0, _nowGradientSpread, height() ), highlight ); }
void WireframeTriangleRasterizer::drawLine(const math::vertex &p1, const math::vertex &p2, FrameBuffer *fb) { math::vec3 pc1(p1.p), pc2(p2.p); int cols = fb->width(); if (clipLine(pc1, pc2, fb)) { int error; int x0 = pc1.x, x1 = pc2.x; int y0 = pc1.y, y1 = pc2.y; int pixNum; pixNum = y0 * cols + x0; int dx = x1 - x0; int dy = y1 - y0; int xInc, yInc; if (dx >= 0) xInc = 1; else { xInc = -1; dx = -dx; } if (dy >= 0) yInc = cols; else { yInc = -cols; dy = -dy; } int dx2 = dx * 2; int dy2 = dy * 2; if (dx > dy) { error = dy2 - dx; for (int index = 0; index <= dx; index++) { fb->wpixel(pixNum, p1.color); if (error >= 0) { error -= dx2; pixNum += yInc; } error += dy2; pixNum += xInc; } } else { error = dx2 - dy; for (int index = 0; index <= dy; index++) { fb->wpixel(pixNum, p1.color); if (error >= 0) { error -= dy2; pixNum += xInc; } error += dx2; pixNum += yInc; } } } }
void drawLine(float *img, /* pointer to start of image region to draw to */ int w, int h, int bands, /* with height, and bands of region */ int pitch, /* distance between rows in image */ int x, int y, int dx, int dy, float *rgb) { float *p; int xinc, yinc; int i; int j; int error; int ret; /* do line clipping */ if (x<0 || x>=w || x+dx<0 || x+dx>=w || y<0 || y>=h || y+dy<0 || y+dy>=h) { ret=clipLine(&x,&y,&dx,&dy,w,h); if (ret==ALL_OUTSIDE) return; } p=&img[pitch*y+bands*x]; if (dx>=0) xinc=bands; else { xinc=-bands; dx=-dx; } if (dy>=0) yinc=pitch; else { yinc=-pitch; dy=-dy; } error=0; if (dx>dy) { for (i=0;i<=dx;i++) { for (j=0;j<bands;j++) p[j]=rgb[j]; error+=dy; if (error>dx) { error-=dx; p+=yinc; } p+=xinc; } } else { for (i=0;i<=dy;i++) { for (j=0;j<bands;j++) p[j]=rgb[j]; error+=dx; if (error>=dy) { error-=dy; p+=xinc; } p+=yinc; } } return; }