diff --git a/Software/PC_Application/Traces/smithchartdialog.ui b/Software/PC_Application/Traces/smithchartdialog.ui
index d2e6d94..275d458 100644
--- a/Software/PC_Application/Traces/smithchartdialog.ui
+++ b/Software/PC_Application/Traces/smithchartdialog.ui
@@ -6,8 +6,8 @@
0
0
- 302
- 76
+ 307
+ 255
@@ -18,29 +18,84 @@
-
-
-
-
-
-
- Display mode:
-
-
-
- -
-
-
-
+
+
+ Display mode
+
+
+
-
+
- Show complete traces
+ Frequency:
-
- -
+
+
+ -
+
+
-
+
+ Show complete traces
+
+
+ -
+
+ Limit to current span
+
+
+
+
+ -
+
- Limit to current span
+ Impedance:
-
-
-
-
+
+
+ -
+
+
-
+
+ Show complete traces
+
+
+ -
+
+ Limit to visible area
+
+
+
+
+
+
+
+ -
+
+
+ Zoom
+
+
+
-
+
+
+ Factor:
+
+
+
+ -
+
+
+ -
+
+
+ <html><head/><body><p>|Γ| at edge:</p></body></html>
+
+
+
+ -
+
+
+
+
-
@@ -54,6 +109,13 @@
+
+
+ SIUnitEdit
+ QLineEdit
+ CustomWidgets/siunitedit.h
+
+
diff --git a/Software/PC_Application/Traces/tracesmithchart.cpp b/Software/PC_Application/Traces/tracesmithchart.cpp
index 70213ed..7a3117c 100644
--- a/Software/PC_Application/Traces/tracesmithchart.cpp
+++ b/Software/PC_Application/Traces/tracesmithchart.cpp
@@ -17,6 +17,7 @@ TraceSmithChart::TraceSmithChart(TraceModel &model, QWidget *parent)
: TracePlot(model, parent)
{
limitToSpan = true;
+ edgeReflection = 1.0;
initializeTraceInfo();
}
@@ -24,6 +25,8 @@ nlohmann::json TraceSmithChart::toJSON()
{
nlohmann::json j;
j["limit_to_span"] = limitToSpan;
+ j["limit_to_edge"] = limitToEdge;
+ j["edge_reflection"] = edgeReflection;
nlohmann::json jtraces;
for(auto t : traces) {
if(t.second) {
@@ -37,6 +40,8 @@ nlohmann::json TraceSmithChart::toJSON()
void TraceSmithChart::fromJSON(nlohmann::json j)
{
limitToSpan = j.value("limit_to_span", true);
+ limitToEdge = j.value("limit_to_edge", false);
+ edgeReflection = j.value("edge_reflection", 1.0);
for(unsigned int hash : j["traces"]) {
// attempt to find the traces with this hash
bool found = false;
@@ -53,35 +58,71 @@ void TraceSmithChart::fromJSON(nlohmann::json j)
}
}
+void TraceSmithChart::wheelEvent(QWheelEvent *event)
+{
+ // most mousewheel have 15 degree increments, the reported delta is in 1/8th degree -> 120
+ auto increment = event->angleDelta().y() / 120.0;
+ // round toward bigger step in case of special higher resolution mousewheel
+ int steps = increment > 0 ? ceil(increment) : floor(increment);
+
+ constexpr double zoomfactor = 1.1;
+ auto zoom = pow(zoomfactor, steps);
+ edgeReflection /= zoom;
+ triggerReplot();
+}
+
void TraceSmithChart::axisSetupDialog()
{
auto dialog = new QDialog();
auto ui = new Ui::SmithChartDialog();
ui->setupUi(dialog);
if(limitToSpan) {
- ui->displayMode->setCurrentIndex(1);
+ ui->displayModeFreq->setCurrentIndex(1);
} else {
- ui->displayMode->setCurrentIndex(0);
+ ui->displayModeFreq->setCurrentIndex(0);
}
+ if(limitToEdge) {
+ ui->displayModeImp->setCurrentIndex(1);
+ } else {
+ ui->displayModeImp->setCurrentIndex(0);
+ }
+ ui->zoomReflection->setPrecision(3);
+ ui->zoomFactor->setPrecision(3);
+ ui->zoomReflection->setValue(edgeReflection);
+ ui->zoomFactor->setValue(1.0/edgeReflection);
connect(ui->buttonBox, &QDialogButtonBox::accepted, [=](){
- limitToSpan = ui->displayMode->currentIndex() == 1;
+ limitToSpan = ui->displayModeFreq->currentIndex() == 1;
+ limitToEdge = ui->displayModeImp->currentIndex() == 1;
triggerReplot();
});
+ connect(ui->zoomFactor, &SIUnitEdit::valueChanged, [=](){
+ edgeReflection = 1.0 / ui->zoomFactor->value();
+ ui->zoomReflection->setValueQuiet(edgeReflection);
+ });
+ connect(ui->zoomReflection, &SIUnitEdit::valueChanged, [=](){
+ edgeReflection = ui->zoomReflection->value();
+ ui->zoomFactor->setValueQuiet(1.0 / edgeReflection);
+ });
dialog->show();
}
+QPoint TraceSmithChart::dataToPixel(std::complex d)
+{
+ return transform.map(QPoint(d.real() * smithCoordMax * (1.0 / edgeReflection), -d.imag() * smithCoordMax * (1.0 / edgeReflection)));
+}
+
QPoint TraceSmithChart::dataToPixel(Trace::Data d)
{
if(d.x < sweep_fmin || d.x > sweep_fmax) {
return QPoint();
}
- return transform.map(QPoint(d.y.real() * smithCoordMax, -d.y.imag() * smithCoordMax));
+ return dataToPixel(d.y);
}
std::complex TraceSmithChart::pixelToData(QPoint p)
{
auto data = transform.inverted().map(QPointF(p));
- return complex(data.x() / smithCoordMax, -data.y() / smithCoordMax);
+ return complex(data.x() / smithCoordMax * edgeReflection, -data.y() / smithCoordMax * edgeReflection);
}
QPoint TraceSmithChart::markerToPixel(Marker *m)
@@ -90,7 +131,7 @@ QPoint TraceSmithChart::markerToPixel(Marker *m)
// if(!m->isTimeDomain()) {
if(m->getPosition() >= sweep_fmin && m->getPosition() <= sweep_fmax) {
auto d = m->getData();
- ret = transform.map(QPoint(d.real() * smithCoordMax, -d.imag() * smithCoordMax));
+ ret = dataToPixel(d);
}
// }
return ret;
@@ -138,7 +179,7 @@ bool TraceSmithChart::xCoordinateVisible(double x)
void TraceSmithChart::draw(QPainter &p) {
auto pref = Preferences::getInstance();
- // translate coordinate system so that the smith chart sits in the origin has a size of 1
+ // translate coordinate system so that the smith chart sits in the origin and has a size of 1
auto w = p.window();
p.save();
p.translate(w.width()/2, w.height()/2);
@@ -146,34 +187,40 @@ void TraceSmithChart::draw(QPainter &p) {
p.scale(scale, scale);
transform = p.transform();
+ p.restore();
+
+ auto drawArc = [&](Arc a) {
+ a.constrainToCircle(QPointF(0,0), edgeReflection);
+ auto topleft = dataToPixel(complex(a.center.x() - a.radius, a.center.y() - a.radius));
+ auto bottomright = dataToPixel(complex(a.center.x() + a.radius, a.center.y() + a.radius));
+ a.startAngle *= 5760 / (2*M_PI);
+ a.spanAngle *= 5760 / (2*M_PI);
+ p.drawArc(QRect(topleft, bottomright), a.startAngle, a.spanAngle);
+ };
// Outer circle
auto pen = QPen(pref.Graphs.Color.axis);
pen.setCosmetic(true);
p.setPen(pen);
- QRectF rectangle(-smithCoordMax, -smithCoordMax, 2*smithCoordMax, 2*smithCoordMax);
- p.drawArc(rectangle, 0, 5760);
+ drawArc(Arc(QPointF(0, 0), edgeReflection, 0, 2*M_PI));
constexpr int Circles = 6;
pen = QPen(pref.Graphs.Color.Ticks.divisions, 0.5, Qt::DashLine);
pen.setCosmetic(true);
p.setPen(pen);
- for(int i=1;i(edgeReflection,0)),dataToPixel(complex(-edgeReflection,0)));
constexpr std::array impedanceLines = {10, 25, 50, 100, 250};
for(auto z : impedanceLines) {
z /= ReferenceImpedance;
- auto radius = smithCoordMax/z;
- double span = M_PI - 2 * atan(radius/smithCoordMax);
- span *= 5760 / (2 * M_PI);
- QRectF rectangle(smithCoordMax - radius, -2 * radius, 2 * radius, 2 * radius);
- p.drawArc(rectangle, 4320 - span, span);
- rectangle = QRectF(smithCoordMax - radius, 0, 2 * radius, 2 * radius);
- p.drawArc(rectangle, 1440, span);
+ auto radius = 1.0/z;
+ drawArc(Arc(QPointF(1.0, radius), radius, 0, 2*M_PI));
+ drawArc(Arc(QPointF(1.0, -radius), radius, 0, 2*M_PI));
}
for(auto t : traces) {
@@ -199,11 +246,15 @@ void TraceSmithChart::draw(QPainter &p) {
if(isnan(now.y.real())) {
break;
}
+ if (limitToEdge && (abs(last.y) > edgeReflection || abs(now.y) > edgeReflection)) {
+ // outside of visible area
+ continue;
+ }
// scale to size of smith diagram
- last.y *= smithCoordMax;
- now.y *= smithCoordMax;
+ auto p1 = dataToPixel(last);
+ auto p2 = dataToPixel(now);
// draw line
- p.drawLine(std::real(last.y), -std::imag(last.y), std::real(now.y), -std::imag(now.y));
+ p.drawLine(p1, p2);
}
if(trace->size() > 0) {
// only draw markers if the trace has at least one point
@@ -220,19 +271,22 @@ void TraceSmithChart::draw(QPainter &p) {
continue;
}
auto coords = m->getData();
- coords *= smithCoordMax;
+ if (limitToEdge && abs(coords) > edgeReflection) {
+ // outside of visible area
+ continue;
+ }
+ auto point = dataToPixel(coords);
auto symbol = m->getSymbol();
- symbol = symbol.scaled(symbol.width()/scale, symbol.height()/scale);
- p.drawPixmap(coords.real() - symbol.width()/2, -coords.imag() - symbol.height(), symbol);
+ p.drawPixmap(point.x() - symbol.width()/2, point.y() - symbol.height(), symbol);
}
}
}
if(dropPending) {
+ // TODO adjust coords due to shifted restore
p.setOpacity(0.5);
p.setBrush(Qt::white);
p.setPen(Qt::white);
p.drawEllipse(-smithCoordMax, -smithCoordMax, 2*smithCoordMax, 2*smithCoordMax);
- p.restore();
auto font = p.font();
font.setPixelSize(20);
p.setFont(font);
@@ -241,7 +295,6 @@ void TraceSmithChart::draw(QPainter &p) {
auto text = "Drop here to add\n" + dropTrace->name() + "\nto Smith chart";
p.drawText(p.window(), Qt::AlignCenter, text);
} else {
- p.restore();
}
}
@@ -257,8 +310,8 @@ void TraceSmithChart::traceDropped(Trace *t, QPoint position)
QString TraceSmithChart::mouseText(QPoint pos)
{
auto data = pixelToData(pos);
- if(abs(data) <= 1.0) {
- data = 50.0 * (1-.0 + data) / (1.0 - data);
+ if(abs(data) <= edgeReflection) {
+ data = 50.0 * (1.0 + data) / (1.0 - data);
auto ret = Unit::ToString(data.real(), "", " ", 3);
if(data.imag() >= 0) {
ret += "+";
@@ -351,3 +404,77 @@ bool TraceSmithChart::dropSupported(Trace *t)
return false;
}
}
+
+TraceSmithChart::Arc::Arc(QPointF center, double radius, double startAngle, double spanAngle)
+ : center(center),
+ radius(radius),
+ startAngle(startAngle),
+ spanAngle(spanAngle)
+{
+
+}
+
+void TraceSmithChart::Arc::constrainToCircle(QPointF center, double radius)
+{
+ // check if arc/circle intersect
+ auto centerDiff = this->center - center;
+ auto centerDistSquared = centerDiff.x() * centerDiff.x() + centerDiff.y() * centerDiff.y();
+ if (centerDistSquared >= (radius + this->radius) * (radius + this->radius)) {
+ // arc completely outside of constraining circle
+ spanAngle = 0.0;
+ return;
+ } else if (centerDistSquared <= (radius - this->radius) * (radius - this->radius)) {
+ if (radius >= this->radius) {
+ // arc completely in constraining circle, do nothing
+ return;
+ } else {
+ // arc completely outside of circle
+ spanAngle = 0.0;
+ return;
+ }
+ } else {
+ // there are intersections between the arc and the circle. Calculate points according to https://stackoverflow.com/questions/3349125/circle-circle-intersection-points
+ auto distance = sqrt(centerDistSquared);
+ auto a = (this->radius*this->radius-radius*radius+distance*distance) / (2*distance);
+ auto h = sqrt(this->radius*this->radius - a*a);
+ auto intersectMiddle = this->center + a*(center - this->center) / distance;
+ auto rotatedCenterDiff = center - this->center;
+ swap(rotatedCenterDiff.rx(), rotatedCenterDiff.ry());
+ rotatedCenterDiff.setY(-rotatedCenterDiff.y());
+ auto intersect1 = intersectMiddle + h * rotatedCenterDiff / distance;
+ auto intersect2 = intersectMiddle - h * rotatedCenterDiff / distance;
+
+ // got intersection points, convert into angles from arc center
+ auto wrapAngle = [](double angle) -> double {
+ double ret = fmod(angle, 2*M_PI);
+ if(ret < 0) {
+ ret += 2*M_PI;
+ }
+ return ret;
+ };
+
+ auto angle1 = wrapAngle(atan2((intersect1 - this->center).y(), (intersect1 - this->center).x()));
+ auto angle2 = wrapAngle(atan2((intersect2 - this->center).y(), (intersect2 - this->center).x()));
+
+ auto angleDiff = wrapAngle(angle2 - angle1);
+ if ((angleDiff >= M_PI) ^ (a > 0.0)) {
+ // allowed angles go from intersect1 to intersect2
+ if(startAngle < angle1) {
+ startAngle = angle1;
+ }
+ auto maxSpan = wrapAngle(angle2 - startAngle);
+ if(spanAngle > maxSpan) {
+ spanAngle = maxSpan;
+ }
+ } else {
+ // allowed angles go from intersect2 to intersect1
+ if(startAngle < angle2) {
+ startAngle = angle2;
+ }
+ auto maxSpan = wrapAngle(angle1 - startAngle);
+ if(spanAngle > maxSpan) {
+ spanAngle = maxSpan;
+ }
+ }
+ }
+}
diff --git a/Software/PC_Application/Traces/tracesmithchart.h b/Software/PC_Application/Traces/tracesmithchart.h
index f5de4c4..8939dc3 100644
--- a/Software/PC_Application/Traces/tracesmithchart.h
+++ b/Software/PC_Application/Traces/tracesmithchart.h
@@ -17,6 +17,8 @@ public:
virtual nlohmann::json toJSON() override;
virtual void fromJSON(nlohmann::json j) override;
+
+ void wheelEvent(QWheelEvent *event) override;
public slots:
void axisSetupDialog();
@@ -25,6 +27,18 @@ protected:
static constexpr double screenUsage = 0.9;
static constexpr double smithCoordMax = 4096;
+ class Arc
+ {
+ public:
+ Arc(QPointF center, double radius, double startAngle, double spanAngle);
+ void constrainToCircle(QPointF center, double radius);
+
+ QPointF center;
+ double radius;
+ double startAngle, spanAngle;
+ };
+
+ QPoint dataToPixel(std::complex d);
QPoint dataToPixel(Trace::Data d);
std::complex pixelToData(QPoint p);
QPoint markerToPixel(Marker *m) override;
@@ -39,6 +53,8 @@ protected:
virtual void traceDropped(Trace *t, QPoint position) override;
QString mouseText(QPoint pos) override;
bool limitToSpan;
+ bool limitToEdge;
+ double edgeReflection; // magnitude of reflection coefficient at the edge of the smith chart (zoom factor)
QTransform transform;
};