void CurvedHistogram::processInteraction( ::scene2D::data::Event::sptr _event) { SLM_TRACE_FUNC(); bool updatePointedPos = false; // Vertical scaling if( _event->getType() == ::scene2D::data::Event::MouseWheelUp ) { m_scale *= SCALE; m_layer->setTransform(QTransform::fromScale(1, SCALE), true); updatePointedPos = true; } else if( _event->getType() == ::scene2D::data::Event::MouseWheelDown ) { m_scale /= SCALE; m_layer->setTransform(QTransform::fromScale(1, 1 / SCALE), true); updatePointedPos = true; } else if( _event->getType() == ::scene2D::data::Event::MouseMove ) { updatePointedPos = true; } if( !m_histogramPointUID.empty() ) { updateCurrentPoint( _event ); } }
bool QgsAdvancedDigitizingDockWidget::applyConstraints( QgsMapMouseEvent *e ) { QgsCadUtils::AlignMapPointContext context; context.snappingUtils = mMapCanvas->snappingUtils(); context.mapUnitsPerPixel = mMapCanvas->mapUnitsPerPixel(); context.xConstraint = _constraint( mXConstraint.get() ); context.yConstraint = _constraint( mYConstraint.get() ); context.distanceConstraint = _constraint( mDistanceConstraint.get() ); context.angleConstraint = _constraint( mAngleConstraint.get() ); context.cadPointList = mCadPointList; context.commonAngleConstraint.locked = true; context.commonAngleConstraint.relative = context.angleConstraint.relative; context.commonAngleConstraint.value = mCommonAngleConstraint; QgsCadUtils::AlignMapPointOutput output = QgsCadUtils::alignMapPoint( e->originalMapPoint(), context ); bool res = output.valid; QgsPointXY point = output.finalMapPoint; mSnappedSegment.clear(); if ( output.edgeMatch.hasEdge() ) { QgsPointXY edgePt0, edgePt1; output.edgeMatch.edgePoints( edgePt0, edgePt1 ); mSnappedSegment << edgePt0 << edgePt1; } if ( mAngleConstraint->lockMode() != CadConstraint::HardLock ) { if ( output.softLockCommonAngle != -1 ) { mAngleConstraint->setLockMode( CadConstraint::SoftLock ); mAngleConstraint->setValue( output.softLockCommonAngle ); } else { mAngleConstraint->setLockMode( CadConstraint::NoLock ); } } // set the point coordinates in the map event e->setMapPoint( point ); // update the point list updateCurrentPoint( point ); updateUnlockedConstraintValues( point ); if ( res ) { emit popWarning(); } else { emit pushWarning( tr( "Some constraints are incompatible. Resulting point might be incorrect." ) ); } return res; }
void Stroker::handleLineSegment(Segment* segment) { const Path::Segment* pathSegment = segment->getSegment(); // Where are we going to? updateCurrentPoint(pathSegment); // Calculate stroke normal calculateStrokeNormal(prevPoint_,currentPoint_,normal_); Vector outer; Vector inner; // Join segments or begin the first segment if(numSegments_ == 0) { firstPoint_ = prevPoint_; firstNormal_ = normal_; outer = firstPoint_ + firstNormal_; inner = firstPoint_ - firstNormal_; addPoint(&outerPoints_,outer); addPoint(&innerPoints_,inner); } else joiner_(this,prevPoint_,prevNormal_,normal_); outer = currentPoint_ + normal_; inner = currentPoint_ - normal_; // Add point addPoint(&outerPoints_,outer); addPoint(&innerPoints_,inner); // Update state prevPoint_ = currentPoint_; prevNormal_ = normal_; }
void Histogram::processInteraction( ::scene2D::data::Event::sptr _event) { SLM_TRACE_FUNC(); bool updatePointedPos = false; // Vertical scaling if( _event->getType() == ::scene2D::data::Event::MouseWheelUp ) { m_scale *= SCALE; m_layer->scale(1, SCALE); //_event->setAccepted( true ); m_yAxis->setScale( m_scale ); updatePointedPos = true; } else if( _event->getType() == ::scene2D::data::Event::MouseWheelDown ) { m_scale /= SCALE; m_layer->scale(1, 1 / SCALE); //_event->setAccepted( true ); m_yAxis->setScale( m_scale ); updatePointedPos = true; } else if( _event->getType() == ::scene2D::data::Event::MouseMove ) { updatePointedPos = true; } if( !m_histogramPointUID.empty() && updatePointedPos ) { updateCurrentPoint( _event ); } }
bool SVGPathBlender::BlendState::blendSegments( const PathSegmentData& fromSeg, const PathSegmentData& toSeg, PathSegmentData& blendedSegment) { if (!canBlend(fromSeg, toSeg)) return false; blendedSegment.command = m_isInFirstHalfOfAnimation ? fromSeg.command : toSeg.command; switch (toSeg.command) { case PathSegCurveToCubicRel: case PathSegCurveToCubicAbs: blendedSegment.point1 = blendAnimatedFloatPoint(fromSeg.point1, toSeg.point1); /* fall through */ case PathSegCurveToCubicSmoothRel: case PathSegCurveToCubicSmoothAbs: blendedSegment.point2 = blendAnimatedFloatPoint(fromSeg.point2, toSeg.point2); /* fall through */ case PathSegMoveToRel: case PathSegMoveToAbs: case PathSegLineToRel: case PathSegLineToAbs: case PathSegCurveToQuadraticSmoothRel: case PathSegCurveToQuadraticSmoothAbs: blendedSegment.targetPoint = blendAnimatedFloatPoint(fromSeg.targetPoint, toSeg.targetPoint); break; case PathSegLineToHorizontalRel: case PathSegLineToHorizontalAbs: blendedSegment.targetPoint.setX(blendAnimatedDimensonalFloat( fromSeg.targetPoint.x(), toSeg.targetPoint.x(), BlendHorizontal)); break; case PathSegLineToVerticalRel: case PathSegLineToVerticalAbs: blendedSegment.targetPoint.setY(blendAnimatedDimensonalFloat( fromSeg.targetPoint.y(), toSeg.targetPoint.y(), BlendVertical)); break; case PathSegClosePath: break; case PathSegCurveToQuadraticRel: case PathSegCurveToQuadraticAbs: blendedSegment.targetPoint = blendAnimatedFloatPoint(fromSeg.targetPoint, toSeg.targetPoint); blendedSegment.point1 = blendAnimatedFloatPoint(fromSeg.point1, toSeg.point1); break; case PathSegArcRel: case PathSegArcAbs: blendedSegment.targetPoint = blendAnimatedFloatPoint(fromSeg.targetPoint, toSeg.targetPoint); blendedSegment.point1 = blendAnimatedFloatPointSameCoordinates( fromSeg.arcRadii(), toSeg.arcRadii()); blendedSegment.point2 = blendAnimatedFloatPointSameCoordinates(fromSeg.point2, toSeg.point2); if (m_addTypesCount) { blendedSegment.arcLarge = fromSeg.arcLarge || toSeg.arcLarge; blendedSegment.arcSweep = fromSeg.arcSweep || toSeg.arcSweep; } else { blendedSegment.arcLarge = m_isInFirstHalfOfAnimation ? fromSeg.arcLarge : toSeg.arcLarge; blendedSegment.arcSweep = m_isInFirstHalfOfAnimation ? fromSeg.arcSweep : toSeg.arcSweep; } break; default: ASSERT_NOT_REACHED(); } updateCurrentPoint(m_fromSubPathPoint, m_fromCurrentPoint, fromSeg); updateCurrentPoint(m_toSubPathPoint, m_toCurrentPoint, toSeg); return true; }
void Stroker::generateStrokeOutlines(SubPath* subPath, const AffineMatrix& transform) { if(subPath->getNumberOfPoints() == 0) return; // Iterate over all segments in subpath Segment* segment = subPath->beginSegmentIteration(); const Path::Segment* pathSegment = segment->getSegment(); // Clear state varibles and helper paths for this subpath numSegments_ = 0; innerPoints_.clear(); outerPoints_.clear(); // Store transform pathTransform_ = transform; inversePathTransform_ = transform; inversePathTransform_.invert(); float xScale; float yScale; pathTransform_.getScale(xScale,yScale); scale_.makeIdentity(); scale_.scale(xScale,yScale); inverseScale_ = scale_; inverseScale_.invert(); // Handle the case where we start with // a move to separetely for now if(pathSegment->command_ == Path::cMoveToAbs || pathSegment->command_ == Path::cMoveToRel) { updateCurrentPoint(pathSegment); firstPoint_ = prevPoint_ = currentPoint_; segment = subPath->getNextSegment(); pathSegment = segment->getSegment(); } // Iterate over sub path and handle all segments const Path::Segment* lastSegment = pathSegment; while(subPath->hasMoreSegments()) { if(pathSegment->command_ < Path::cQuadBezierToAbs) handleLineSegment(segment); else if(pathSegment->command_ > Path::cSmoothCubicBezierToRel) handleArcSegment(segment); else handleBezierSegment(segment); ++numSegments_; segment = subPath->getNextSegment(); lastSegment = pathSegment; pathSegment = segment->getSegment(); } // Join or add ends if(lastSegment->command_ == Path::cClosePath) joiner_(this,firstPoint_,prevNormal_,firstNormal_); else endStroke(); }
void Stroker::handleBezierSegment(Segment* segment) { // Where are we going to? updateCurrentPoint(segment->getSegment()); // Calculate first normal float* points = segment->beginPointIteration(); calculateStrokeNormal(points,normal_); // Join segments or begin the first segment Vector outer; Vector inner; if(numSegments_ == 0) { firstPoint_ = prevPoint_; firstNormal_ = normal_; outer = firstPoint_ + firstNormal_; inner = firstPoint_ - firstNormal_; addPoint(&outerPoints_,outer); addPoint(&innerPoints_,inner); } else joiner_(this,prevPoint_,prevNormal_,normal_); // Add points,ignoring the first // since it is already added points = segment->getNextPoint(); Vector point; if(segment->getNumberOfPoints() > 2) { while(!segment->atSecondToLastPoint()) { point.x_ = *points; point.y_ = *(points + 1); calculateStrokeNormal(points,normal_); outer = point + normal_; inner = point - normal_; addPoint(&outerPoints_,outer); addPoint(&innerPoints_,inner); points = segment->getNextPoint(); } } // Calculate last normal calculateStrokeNormal(point,currentPoint_,normal_); // Add last point outer = currentPoint_ + normal_; inner = currentPoint_ - normal_; addPoint(&outerPoints_,outer); addPoint(&innerPoints_,inner); prevPoint_ = currentPoint_; prevNormal_ = normal_; }
void Stroker::handleArcSegment(Segment* segment) { // Where are we going to? updateCurrentPoint(segment->getSegment()); // First point is already added float* points = segment->beginPointIteration(); points = segment->getNextPoint(); // First normal using segment end points Vector firstNormal = prevPoint_ - currentPoint_; firstNormal.normalize(); firstNormal *= size_ /2; scale_.transform(firstNormal); // Calculate first and second normal from points Vector secondNormal; calculateStrokeNormal(points,normal_); calculateStrokeNormal(points + 2,secondNormal); // Adjust first normal so it points // in the same direction as the second normal Winding firstWinding = determineWinding(firstNormal,normal_); Winding secondWinding = determineWinding(normal_,secondNormal); if(firstWinding != secondWinding) firstNormal.invert(); // Join segments or begin the first segment Vector outer; Vector inner; if(numSegments_ == 0) { firstPoint_ = prevPoint_; firstNormal_ = firstNormal; outer = firstPoint_ + firstNormal_; inner = firstPoint_ - firstNormal_; addPoint(&outerPoints_,outer); addPoint(&innerPoints_,inner); } else joiner_(this,prevPoint_,prevNormal_,firstNormal); // Add points while(segment->hasMorePoints()) { Vector point(*points,*(points + 1)); calculateStrokeNormal(points,normal_); outer = point + normal_; inner = point - normal_; addPoint(&outerPoints_,outer); addPoint(&innerPoints_,inner); points = segment->getNextPoint(); } // Add last normal_ = invert(firstNormal); outer = currentPoint_ + normal_; inner = currentPoint_ - normal_; addPoint(&outerPoints_,outer); addPoint(&innerPoints_,inner); prevPoint_ = currentPoint_; prevNormal_ = normal_; }