PeriDyno 1.0.0
Loading...
Searching...
No Matches
QCurveWidget.cpp
Go to the documentation of this file.
1#include "QCurveWidget.h"
2
3#include <QComboBox>
4#include <QGridLayout>
5#include <QVBoxLayout>
6#include <QPainter>
7#include <QSpacerItem>
8#include <QPainterPath>
9#include "PCustomWidgets.h"
10#include <QCheckBox>
11#include "QToggleButton.h"
12
13#include "Field.h"
14
15namespace dyno
16{
17 IMPL_FIELD_WIDGET(Curve, QCurveWidget)
18
19 QCurveWidget::QCurveWidget(FBase* field)
20 : QFieldWidget(field)
21 {
22 printf("QCurveWidget\n");
23 FVar<Curve>* f = TypeInfo::cast<FVar<Curve>>(field);
24 if (f == nullptr)
25 {
26 printf("QCurve Nullptr\n");
27 return;
28
29 }
30
31
32
33
34
35 //Enum List Direction Mode
36
37 //Enum List InterpMode
38 int curIndex2 = int(f->getValue().mInterpMode);
39 int enumNum2 = f->getValue().InterpolationCount;
40 QComboBox* combox2 = new QComboBox;
41 combox2->setMaximumWidth(256);
42 for (size_t i = 0; i < 2; i++)
43 {
44 auto enumName2 = f->getValue().InterpStrings[i];
45 combox2->addItem(QString::fromStdString(enumName2));
46 }
47 combox2->setCurrentIndex(curIndex2);
48 combox2->setStyleSheet("background-color: qlineargradient(spread : pad, x1 : 0, y1 : 0, x2 : 0, y2 : 0.7, stop : 0 rgba(100, 100, 100, 255), stop : 1 rgba(35, 35, 35, 255)); ");
49
50 auto s = f->getValue();
51
52 //build RampWidget by field
53 //RampWidget name
54 QLabel* name = new QLabel();
55 name->setFixedSize(80, 18);
56 name->setText(FormatFieldWidgetName(field->getObjectName()));
57 name->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);//
58
59
60
61 //build DrawLabel
62 QCurveLabel* DrawLabel = new QCurveLabel(f);
63
64
65
66
67 connect(combox2, SIGNAL(currentIndexChanged(int)), DrawLabel, SLOT(changeInterpValue(int)));
68
69 //VLayout : combox2 / SquardButton / CloseButton
70 QVBoxLayout* VLayout = new QVBoxLayout();
71 QSpacerItem* VSpacer = new QSpacerItem(10, 380, QSizePolicy::Minimum, QSizePolicy::Expanding);
72 VLayout->addItem(VSpacer);
73 VLayout->addWidget(combox2);
74 VLayout->setSpacing(5);
75
76
77 QGridLayout* Gridlayout = new QGridLayout;
78 Gridlayout->setContentsMargins(0, 0, 0, 0);
79 Gridlayout->setSpacing(5);
80 Gridlayout->addWidget(name, 0, 0,3,1, Qt::AlignLeft);
81 Gridlayout->addWidget(DrawLabel,0,1, Qt::AlignCenter);
82 Gridlayout->addLayout(VLayout,0,2, Qt::AlignRight);
83 Gridlayout->setColumnStretch(0, 0);
84 Gridlayout->setColumnStretch(1, 5);
85 Gridlayout->setColumnStretch(2, 0);
86
87
88 QLabel* spacingName = new QLabel("Spacing");
89
90 mQDoubleSlider* spacingSlider = new mQDoubleSlider;
91 spacingSlider->nameLabel = spacingName;
92 spacingSlider->setRange(1, 40);
93 spacingSlider->setValue(f->getValue().Spacing);
94 spacingSlider->id = -1;
95 mQDoubleSpinner* spacingSpinner = new mQDoubleSpinner;
96 spacingSpinner->setRange(1, 40);
97 spacingSpinner->setValue(f->getValue().Spacing);
98 spacingSpinner->id = -1;
99 QObject::connect(spacingSlider, SIGNAL(valueChanged(double)), spacingSpinner, SLOT(setValue(double)));
100 QObject::connect(spacingSpinner, SIGNAL(valueChanged(double)), spacingSlider, SLOT(setValue(double)));
101 QObject::connect(spacingSpinner, SIGNAL(valueChangedAndID(double, int)), DrawLabel, SLOT(setSpacingToDrawLabel(double,int)));
102
103 QHBoxLayout* SpacingHlayout = new QHBoxLayout;
104 SpacingHlayout->setContentsMargins(0, 0, 0, 0);
105 SpacingHlayout->setSpacing(0);
106 SpacingHlayout->addWidget(spacingName);
107 SpacingHlayout->addWidget(spacingSlider);
108 SpacingHlayout->addWidget(spacingSpinner);
109
110
111 QLabel* nameReal[4];
112 mQDoubleSlider* sliderReal[4];
113 mQDoubleSpinner* spinnerReal[4];
114 std::string nameString[4] = { "MinX","MinY","MaxX","MaxY" };
115
116 QHBoxLayout* Hlayout1 = new QHBoxLayout;
117 Hlayout1->setContentsMargins(0, 0, 0, 0);
118 Hlayout1->setSpacing(0);
119
120 QHBoxLayout* Hlayout2 = new QHBoxLayout;
121 Hlayout2->setContentsMargins(0, 0, 0, 0);
122 Hlayout2->setSpacing(0);
123
124 for (size_t i = 0; i < 4; i++)
125 {
126 nameReal[i] = new QLabel(QString::fromStdString(nameString[i]));
127
128 sliderReal[i] = new mQDoubleSlider;
129 sliderReal[i]->id = i;
130
131 spinnerReal[i] = new mQDoubleSpinner;
132 spinnerReal[i]->id = i;
133
134 auto rangeArray = f->getValue().remapRange;
135
136 sliderReal[i]->setRange(rangeArray[2 * i], rangeArray[2 * i + 1]);
137 spinnerReal[i]->setRange(rangeArray[2 * i], rangeArray[2 * i + 1]);
138
139 QObject::connect(sliderReal[i], SIGNAL(valueChanged(double)), spinnerReal[i], SLOT(setValue(double)));
140 QObject::connect(spinnerReal[i], SIGNAL(valueChanged(double)), sliderReal[i], SLOT(setValue(double)));
141 QObject::connect(spinnerReal[i], SIGNAL(valueChangedAndID(double, int)), DrawLabel, SLOT(SetValueToDrawLabel(double, int)));
142
143 switch (i)
144 {
145 case 0:
146 sliderReal[i]->setValue(f->getValue().NminX);
147 spinnerReal[i]->setValue(f->getValue().NminX);
148 break;
149
150 case 1:
151 sliderReal[i]->setValue(f->getValue().mNewMinY);
152 spinnerReal[i]->setValue(f->getValue().mNewMinY);
153 break;
154
155 case 2:
156 sliderReal[i]->setValue(f->getValue().NmaxX);
157 spinnerReal[i]->setValue(f->getValue().NmaxX);
158 break;
159
160 case 3:
161 sliderReal[i]->setValue(f->getValue().NmaxY);
162 spinnerReal[i]->setValue(f->getValue().NmaxY);
163 break;
164 }
165
166
167
168 if (i < 2)
169 {
170 Hlayout1->addWidget(nameReal[i]);
171 Hlayout1->addWidget(sliderReal[i]);
172 Hlayout1->addWidget(spinnerReal[i]);
173 }
174 else
175 {
176 Hlayout2->addWidget(nameReal[i]);
177 Hlayout2->addWidget(sliderReal[i]);
178 Hlayout2->addWidget(spinnerReal[i]);
179 }
180 }
181
182 //Bool
183 QHBoxLayout* boolLayout = new QHBoxLayout;
184 boolLayout->setContentsMargins(0, 0, 0, 0);
185 boolLayout->setSpacing(0);
186
187 QLabel* boolName = new QLabel();
188 boolName->setFixedHeight(24);
189 boolName->setText("Resample");
190 mQCheckBox* Checkbox = new mQCheckBox();
191 Checkbox->nameLabel = boolName;
192 Checkbox->QWidget::setFixedWidth(20);
193 Checkbox->QAbstractButton::setChecked(f->getValue().resample);
194
195 connect(Checkbox, SIGNAL(mValueChanged(int)), DrawLabel, SLOT(setLinearResample(int)));
196 connect(Checkbox, SIGNAL(mValueChanged(int)), spacingSlider, SLOT(setNewVisable(int)));
197 connect(Checkbox, SIGNAL(mValueChanged(int)), spacingSpinner, SLOT(setNewVisable(int)));
198
199 connect(combox2, SIGNAL(currentIndexChanged(int)), Checkbox, SLOT(updateChecked(int)));
200
201 if (f->getValue().resample == false)
202 {
203 spacingSlider->setVisible(false);
204 spacingSpinner->setVisible(false);
205 spacingName->setVisible(false);
206 }
207
208
209 boolLayout->addWidget(boolName, 0);
210 boolLayout->addStretch(1);
211 boolLayout->addWidget(Checkbox, 0);
212
213 //if (f->getDataPtr()->InterpMode == Ramp::Interpolation::Bezier) { boolName->setVisible(0); Checkbox->setVisible(0); }
214
215
216
217
218 if (f->getValue().useSquardButton)
219 {
220 QToggleButton* unfold = new QToggleButton(f->getValue().useSquard);
221
222 unfold->setText("Squard", "Rect");
223 unfold->setStyleSheet(
224 "QPushButton{background-color: qlineargradient(spread : pad, x1 : 0, y1 : 0, x2 : 0, y2 : 0.7, stop : 0 rgba(100, 100, 100, 255), stop : 1 rgba(35, 35, 35, 255));}QPushButton:hover{background-color: qlineargradient(spread : pad, x1 : 0, y1 : 0, x2 : 0, y2 : 0.7, stop : 0 rgba(120,120,120, 255), stop : 1 rgba(90, 90, 90, 255));} "
225 );
226 connect(unfold, &QToggleButton::clicked, DrawLabel, &QCurveLabel::changeLabelSize);
227 unfold->setValue(f->getValue().useSquard);
228 VLayout->addWidget(unfold);
229 }
230
231
232 {
233 if(f->getValue().useColseButton)
234 {
235 QToggleButton* curveCloseButton = new QToggleButton(f->getValue().curveClose);
236 curveCloseButton->setText("Close", "Open");
237 curveCloseButton->setStyleSheet
238 (
239 "QPushButton{background-color: qlineargradient(spread : pad, x1 : 0, y1 : 0, x2 : 0, y2 : 0.7, stop : 0 rgba(100, 100, 100, 255), stop : 1 rgba(35, 35, 35, 255));}QPushButton:hover{background-color: qlineargradient(spread : pad, x1 : 0, y1 : 0, x2 : 0, y2 : 0.7, stop : 0 rgba(120,120,120, 255), stop : 1 rgba(90, 90, 90, 255));} "
240 );
241 VLayout->addWidget(curveCloseButton);
242 connect(curveCloseButton, &QToggleButton::clicked, DrawLabel, &QCurveLabel::setCurveClose);
243 curveCloseButton->setValue(f->getValue().curveClose);
244 }
245 }
246
247
248 QVBoxLayout* TotalLayout = new QVBoxLayout();
249 TotalLayout->setContentsMargins(0, 0, 0, 0);
250 TotalLayout->setSpacing(5);
251 TotalLayout->addLayout(Gridlayout);
252 TotalLayout->addLayout(Hlayout1);
253 TotalLayout->addLayout(Hlayout2);
254 TotalLayout->addLayout(boolLayout);
255 TotalLayout->addLayout(SpacingHlayout);
256
257 this->setLayout(TotalLayout);
258
259 }
260
261 void QCurveWidget::updateField()
262 {
263 FVar<Ramp>* f = TypeInfo::cast<FVar<Ramp>>(field());
264 if (f == nullptr)
265 {
266 return;
267 }
268
269 }
270
271 QCurveLabel::QCurveLabel(FVar<Curve>* f, QWidget* parent)
272 {
273 this->setField(f);
274 this->copySettingFromField();
275 if (isSquard)
276 this->setLabelSize(w, w, w, w);
277 else
278 this->setLabelSize(w, h, w, w);
279 this->setStyleSheet("background:rgba(110,115,100,1)");
280 this->setMouseTracking(true);
281 };
282
283 void QCurveLabel::paintEvent(QPaintEvent* event)
284 {
285
286 //set Point Radius
287 radius = 4;
288 int w = this->width();
289 int h = this->height();
290
291 //set border
292 minX = 0 + 1.5 * radius;
293 maxX = w - 2 * radius;
294 minY = 0 + 2 * radius;
295 maxY = h - 1.5 * radius;
296
297 //get data
298 if (mCoordArray.empty())
299 {
300 if (mField->getValue().Originalcoord.empty()) //If there is no data from the Widget in the field, it is initialized from the field
301 {
302
303 this->copyFromField(mField->getValue().mCoord, mReSortCoordArray);
304 mCoordArray.assign(mReSortCoordArray.begin(), mReSortCoordArray.end());
305 buildCoordToResortMap();
306 this->copyFromField(mField->getValue().myHandlePoint, mHandlePoints);
307 }
308 else //use data from the Widget
309 {
310 this->copyFromField(mField->getValue().Originalcoord, mCoordArray);
311 //this->copyFromField(field->getDataPtr()->OriginalHandlePoint, HandlePoints);
312 this->copyFromField(mField->getValue().OriginalHandlePoint, mHandlePoints);
313 }
314
315 }
316
317 //if useClose,add end & start Point.
318 mReSortCoordArray.assign(mCoordArray.begin(), mCoordArray.end());
319 reSort(mReSortCoordArray);
320
321
322 QPainter painter(this);
323 painter.setRenderHint(QPainter::Antialiasing, true);
324
325 //Background
326 QBrush brush = QBrush(Qt::black, Qt::SolidPattern);
327 painter.setBrush(brush);
328 QRectF Bound = QRectF(QPointF(minX, minY), QPointF(maxX, maxY));
329 painter.drawRect(Bound);
330
331 //Grid
332 QBrush brush2 = QBrush(QColor(100,100,100), Qt::CrossPattern);
333 painter.setBrush(brush2);
334 painter.drawRect(Bound);
335
336 //Draw Ellipse
337 size_t ptNum = mCoordArray.size();
338
339 QVector<QPointF> QCoordArray;
340 for (size_t i = 0; i < mReSortCoordArray.size(); i++)
341 {
342 QCoordArray.push_back(QPointF(mReSortCoordArray[i].x, mReSortCoordArray[i].y));
343 }
344
345
346 buildCoordToResortMap(); //Build map. find element id of sorted reSortCoordArray by CoordArray
347
348 if (mHandlePoints.empty()) //Build HandlePoints for Bezier handles from CoordArray.
349 {
350 buildHandlePointSet();
351 }
352
353
354 QPen LinePen = QPen(QPen(QBrush(QColor(200,200,200)), 2, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin));
355 painter.setPen(LinePen);
356
357 mPath.clear();
358 if (useBezier) //Draw Bezier or Line
359 {
360 //draw Bezier
361 for (size_t i = 1; i < mReSortCoordArray.size(); i++)
362 {
363 int ptnum = i - 1;
364 mPath.moveTo(mReSortCoordArray[ptnum].x, mReSortCoordArray[ptnum].y);
365
366 auto it = mMapResortIDtoOriginalID.find(i);
367 int id = it->second;
368 int s = id * 2;
369
370 auto itf = mMapResortIDtoOriginalID.find(ptnum);
371 int idf = itf->second;
372 int f = idf * 2 + 1;
373
374 mPath.cubicTo(QPointF(mHandlePoints[f].x, mHandlePoints[f].y), QPointF(mHandlePoints[s].x, mHandlePoints[s].y), QPointF(mReSortCoordArray[ptnum + 1].x, mReSortCoordArray[ptnum + 1].y));
375 painter.drawPath(mPath);
376 }
377 // use CurveClose?
378 if (curveClose && mReSortCoordArray.size()>=3)
379 {
380 int end = mReSortCoordArray.size() - 1;
381 int handleEnd = mHandlePoints.size() - 1;
382 mPath.moveTo(mReSortCoordArray[end].x, mReSortCoordArray[end].y);
383 mPath.cubicTo(QPointF(mHandlePoints[handleEnd].x, mHandlePoints[handleEnd].y), QPointF(mHandlePoints[0].x, mHandlePoints[0].y), QPointF(mReSortCoordArray[0].x, mReSortCoordArray[0].y));
384 painter.drawPath(mPath);
385 }
386 }
387 else
388 {
389 if (QCoordArray.size() >= 2)
390 {
391 for (size_t i = 1; i < QCoordArray.size(); i++)
392 {
393 //painter.drawLine(QCoordArray[i], QCoordArray[i + 1]);
394
395 int ptnum = i - 1;
396 mPath.moveTo(mReSortCoordArray[ptnum].x, mReSortCoordArray[ptnum].y);
397 mPath.lineTo(QPointF(mReSortCoordArray[ptnum + 1].x, mReSortCoordArray[ptnum + 1].y));
398 painter.drawPath(mPath);
399 }
400
401 if (curveClose && mReSortCoordArray.size() >= 3)
402 {
403 int end = mReSortCoordArray.size()-1;
404 mPath.moveTo(mReSortCoordArray[end].x, mReSortCoordArray[end].y);
405 mPath.lineTo(QPointF(mReSortCoordArray[0].x, mReSortCoordArray[0].y));
406 painter.drawPath(mPath);
407 }
408 }
409 }
410
411 QPen LinePenWhite = QPen(QPen(QBrush(Qt::white), 2, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin));
412 painter.setPen(LinePenWhite);
413
414 //draw Point
415 for (size_t i = 0; i < ptNum; i++)
416 {
417 painter.setBrush(QBrush(Qt::gray, Qt::SolidPattern));
418 painter.drawEllipse(mCoordArray[i].x - radius, mCoordArray[i].y - radius, 2 * radius, 2 * radius);
419 painter.setPen(QPen(QBrush(QColor(200, 200, 200), Qt::SolidPattern), 2, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin));
420 painter.drawEllipse(mCoordArray[i].x - radius, mCoordArray[i].y - radius, 2 * radius, 2 * radius);
421 }
422
423 //Paint SelectPoint
424 if (mSelectPointID != -1)
425 {
426 painter.setBrush(QBrush(QColor(80, 179, 255), Qt::SolidPattern));
427 painter.drawEllipse(mCoordArray[mSelectPointID].x - radius, mCoordArray[mSelectPointID].y - radius, 2 * radius, 2 * radius);
428 painter.setPen(QPen(QBrush(Qt::white, Qt::SolidPattern), 2, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin));
429 painter.drawEllipse(mCoordArray[mSelectPointID].x - radius, mCoordArray[mSelectPointID].y - radius, 2 * radius, 2 * radius);
430 }
431 //Paint hoverPoint
432 if (mHoverPoint != -1)
433 {
434 painter.setBrush(QBrush(QColor(80, 179, 255), Qt::SolidPattern));
435 painter.drawEllipse(mCoordArray[mHoverPoint].x - radius, mCoordArray[mHoverPoint].y - radius, 2 * radius, 2 * radius);
436 painter.setPen(QPen(QBrush(Qt::white, Qt::SolidPattern), 2, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin));
437 painter.drawEllipse(mCoordArray[mHoverPoint].x - radius, mCoordArray[mHoverPoint].y - radius, 2 * radius, 2 * radius);
438 }
439
440 //drawHandle
441 if (useBezier)
442 {
443
444
445 if (mHandleParent != -1)
446 {
447 int f = mHandleParent * 2;
448 int s = mHandleParent * 2 + 1;
449 //draw Handle
450 painter.drawLine(QPointF(mCoordArray[mHandleParent].x, mCoordArray[mHandleParent].y), QPointF(mHandlePoints[f].x, mHandlePoints[f].y));
451 painter.drawLine(QPointF(mCoordArray[mHandleParent].x, mCoordArray[mHandleParent].y), QPointF(mHandlePoints[s].x, mHandlePoints[s].y));
452 //draw ControlPoint
453 painter.drawEllipse(mHandlePoints[f].x - radius, mHandlePoints[f].y - radius, 2 * radius, 2 * radius);
454 painter.drawEllipse(mHandlePoints[s].x - radius, mHandlePoints[s].y - radius, 2 * radius, 2 * radius);
455 //draw ParentPoint
456 painter.setBrush(QBrush(QColor(80, 179, 255), Qt::SolidPattern));
457 painter.drawEllipse(mCoordArray[mHandleParent].x - radius, mCoordArray[mHandleParent].y - radius, 2 * radius, 2 * radius);
458
459
460 QPen LinePen2 = QPen(QPen(QBrush(QColor(255, 255, 255)), 2, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin));
461 painter.setPen(LinePen2);
462 painter.drawEllipse(mCoordArray[mHandleParent].x - radius, mCoordArray[mHandleParent].y - radius, 2 * radius, 2 * radius);
463 }
464 if (mSelectHandlePoint != -1 )
465 {
466 QPen LinePen2 = QPen(QPen(QBrush(QColor(255, 255, 255)), 2, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin));
467 painter.setPen(LinePen2);
468 painter.drawEllipse(mHandlePoints[mSelectHandlePoint].x - radius, mHandlePoints[mSelectHandlePoint].y - radius, 2 * radius, 2 * radius);
469
470 }
471 }
472
473 if (mForceUpdate)
474 {
475
476 buildBezierPoint();
477 updateDataToField();
478 mForceUpdate = false;
479
480 }
481
482 painter.setBrush(QBrush(QColor(80, 179, 255), Qt::SolidPattern));
483 painter.setPen(QPen(QPen(QBrush(QColor(255, 255, 255)), 2, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin)));
484
485 //draw selected point
486 if (mMultiSelectID.size())
487 {
488 for (auto it : mMultiSelectID)
489 {
490 painter.drawEllipse(mCoordArray[it].x - radius, mCoordArray[it].y - radius, 2 * radius, 2 * radius);
491 }
492 }
493
494
495 painter.setBrush(QBrush(QColor(255, 0, 0), Qt::SolidPattern));
496 painter.setPen(QPen(QPen(QBrush(QColor(255, 0, 0)), 1, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin)));
497
498
499
500 }
501
502 QCurveLabel::~QCurveLabel()
503 {
504
505 }
506
507
508 QCurveLabel::QCurveLabel(QWidget* parent)
509 {
510 this->setLabelSize(w, w, w, w);
511 this->setStyleSheet("background:rgba(110,115,100,1)");
512 this->setMouseTracking(true);
513
514 }
515
516
517 void QCurveLabel::mousePressEvent(QMouseEvent* event)
518 {
519 //MouseLeft
520 mPressCoord.x = event->pos().x();
521 mPressCoord.y = event->pos().y();
522
523 if (mShiftKey)
524 {
525 for (size_t i = 0; i < mCoordArray.size(); i++)
526 {
527 int temp = sqrt(std::pow((mPressCoord.x - mCoordArray[i].x), 2) + std::pow((mPressCoord.y - mCoordArray[i].y), 2));
528 if (temp < selectDistance)
529 {
530 mSelectPointID = i;
531 mIsSelect = true;
532 mHandleParent = mSelectPointID;
533 mInitPosition.set(mCoordArray[mSelectPointID]);
534
535 bool elementInMulti = false;
536
537 std::vector<int>::iterator iter;
538 iter = mMultiSelectID.begin();
539 while (iter != mMultiSelectID.end())
540 {
541 if (*iter == i)
542 {
543 elementInMulti = true;
544 break;
545 }
546 iter++;
547 }
548 if (elementInMulti)
549 {
550
551 mMultiSelectID.erase(iter);
552 elementInMulti = false;
553 }
554 else
555 {
556 mMultiSelectID.push_back(i);
557 }
558 break;
559 }
560 }
561 }
562 else if (!mShiftKey && !mAltKey) //
563 {
564 for (size_t i = 0; i < mCoordArray.size(); i++)
565 {
566 int temp = sqrt(std::pow((mPressCoord.x - mCoordArray[i].x), 2) + std::pow((mPressCoord.y - mCoordArray[i].y), 2));
567
568 if (temp < selectDistance)
569 {
570 mSelectPointID = i;
571 mIsSelect = true;
572 mHandleParent = mSelectPointID;
573 mInitPosition.set(mCoordArray[mSelectPointID]);
574 {
575 if (std::find(mMultiSelectID.begin(), mMultiSelectID.end(), i) != mMultiSelectID.end())
576 {
577 }
578 else
579 {
580 mMultiSelectID.clear();
581 mMultiSelectID.push_back(i);
582 }
583 }
584
585 if (mSelectPointID == 0)
586 {
587 mInsertAtBegin = true;
588 }
589 else if (mSelectPointID == mCoordArray.size() - 1)
590 {
591 mInsertAtBegin = false;
592 }
593
594 break;
595 }
596 }
597 }
598
599 //if select Handle
600 if (useBezier)
601 {
602 //printf("handle\n");
603 int displayHandle[2] = { mHandleParent * 2 ,mHandleParent * 2 + 1};
604 for (size_t k = 0; k < 2; k++)
605 {
606 int i = displayHandle[k];
607
608 if (i < 0) { break; }
609
610 int temp = sqrt(std::pow((mPressCoord.x - mHandlePoints[i].x), 2) + std::pow((mPressCoord.y - mHandlePoints[i].y), 2));
611
612 if (temp < selectDistance && mIsSelect != true)
613 {
614 mSelectHandlePoint = i;
615 mIsHandleSelect = true;
616 mInitHandlePos.set(mHandlePoints[mSelectHandlePoint]);
617
618 if (mSelectHandlePoint % 2 == 0) { mHandleParent = mSelectHandlePoint / 2; }
619 else { mHandleParent = (mSelectHandlePoint - 1) / 2; }
620
621
622 if (mSelectHandlePoint % 2 == 0)
623 {
624 mConnectHandlePoint = mSelectHandlePoint + 1;
625 }
626 else
627 {
628 mConnectHandlePoint = mSelectHandlePoint - 1;
629 }
630
631 Vec2f V2 = Vec2f(mHandlePoints[mConnectHandlePoint].x - mCoordArray[mHandleParent].x, mHandlePoints[mConnectHandlePoint].y - mCoordArray[mHandleParent].y);
632
633 mConnectLength = V2.norm();
634
635 {//handle Connect?
636 Vec2f V3 = Vec2f(mHandlePoints[mSelectHandlePoint].x - mCoordArray[mHandleParent].x, mHandlePoints[mSelectHandlePoint].y - mCoordArray[mHandleParent].y);
637 Vec2f V4 = Vec2f(mHandlePoints[mConnectHandlePoint].x - mCoordArray[mHandleParent].x, mHandlePoints[mConnectHandlePoint].y - mCoordArray[mHandleParent].y);
638 V4.normalize();
639 Vec2f N = -1 * V3.normalize();
640 float angle = acos(V4.dot(N)) / M_PI * 180;
641 if (angle <= HandleAngleThreshold) { mHandleConnection = true; }
642 else { mHandleConnection = false; }
643 }
644
645 break;
646 }
647 }
648 }
649 if (!mIsSelect && !mIsHandleSelect)
650 {
651
652 //pushback Point
653 if (!mCtrlKey)
654 {
655 addPointtoEnd();
656 }
657 //insert Point in Edge
658 else if (mCtrlKey)
659 {
660 if (mReSortCoordArray.size() >= 2)
661 {
662 int id = insertCurvePoint(mPressCoord);
663
664 if (InterpMode == Interpolation::Bezier)
665 {
666 mSelectPointID = -1;
667 mIsSelect = false;
668 mInsertBezierOpenPoint = true;
669 mHandleParent = id;
670 mSelectHandlePoint = id * 2 + 1;
671 mConnectHandlePoint = mSelectHandlePoint - 1;
672 mIsHandleSelect = true;
673 }
674 if (InterpMode == Interpolation::Linear)
675 {
676 mSelectPointID = id;
677 mIsSelect = true;
678 mInsertBezierOpenPoint = false;
679 mHandleParent = id;
680 mSelectHandlePoint = -1;
681 mConnectHandlePoint = -1;
682 mIsHandleSelect = false;
683 }
684
685 mMultiSelectID.clear();
686 mMultiSelectID.push_back(id);
687 }
688 else
689 {
690 addPointtoEnd();
691 }
692
693 }
694
695 }
696
697 else if(event->button() == Qt::RightButton)
698 {
699
700 if(mSelectPointID >=0)
701 {
702 deletePoint();
703 }
704
705 }
706
707
708 this->update();
709 }
710
711 int QCurveLabel::addPointtoEnd()
712 {
713 if (!mInsertAtBegin)
714 {
715 mCoordArray.push_back(mPressCoord);
716 buildCoordToResortMap();
717 insertHandlePoint(mCoordArray.size() - 1,mPressCoord);
718
719 if (InterpMode == Interpolation::Bezier)
720 {
721 mInsertBezierOpenPoint = true;
722 mSelectPointID = -1;
723 mIsSelect = false;
724 mHandleParent = mCoordArray.size() - 1;
725 mSelectHandlePoint = mHandleParent * 2 + 1;
726 mConnectHandlePoint = mSelectHandlePoint - 1;
727 mIsHandleSelect = true;
728 }
729 if (InterpMode == Interpolation::Linear)
730 {
731 mInsertBezierOpenPoint = false;
732 mSelectPointID = mCoordArray.size() - 1;
733 mIsSelect = true;
734 mHandleParent = mSelectPointID;
735 mSelectHandlePoint = -1;
736 mConnectHandlePoint = -1;
737 mIsHandleSelect = false;
738 mInitPosition.set(mCoordArray[mSelectPointID]);
739 }
740
741 mMultiSelectID.clear();
742 mMultiSelectID.push_back(mCoordArray.size() - 1);
743 }
744 else if(mInsertAtBegin)
745 {
746 mCoordArray.insert(mCoordArray.begin(), mPressCoord);
747 buildCoordToResortMap();
748 insertHandlePoint(0, mPressCoord);
749
750
751 if (InterpMode == Interpolation::Bezier)
752 {
753 mInsertBezierOpenPoint = true;
754 mSelectPointID = -1;
755 mIsSelect = false;
756 mHandleParent = 0;
757 mSelectHandlePoint = 1;
758 mConnectHandlePoint = mSelectHandlePoint - 1;
759 mIsHandleSelect = true;
760 }
761 if (InterpMode == Interpolation::Linear)
762 {
763 mInsertBezierOpenPoint = false;
764 mSelectPointID = 0;
765 mIsSelect = true;
766 mHandleParent = mSelectPointID;
767 mSelectHandlePoint = -1;
768 mConnectHandlePoint = -1;
769 mIsHandleSelect = false;
770 mInitPosition.set(mCoordArray[mSelectPointID]);
771 }
772 }
773
774
775 return mHandleParent;
776
777 }
778
779
780
781 void QCurveLabel::mouseMoveEvent(QMouseEvent* event)
782 {
783 this->grabKeyboard();
784 //constrained
785 if (mIsSelect)
786 {
787 mCoordArray[mSelectPointID].x = dyno::clamp(event->pos().x(), minX, maxX);
788 mCoordArray[mSelectPointID].y = dyno::clamp(event->pos().y(), minY, maxY);
789
790 mDtPosition.set(mCoordArray[mSelectPointID].x-mInitPosition.x , mCoordArray[mSelectPointID].y - mInitPosition.y);
791
792 mHandlePoints[mSelectPointID * 2].x = dyno::clamp(mHandlePoints[mSelectPointID * 2].x + mDtPosition.x, minX, maxX);
793 mHandlePoints[mSelectPointID * 2].y = dyno::clamp(mHandlePoints[mSelectPointID * 2].y + mDtPosition.y, minY, maxY);
794
795 mHandlePoints[mSelectPointID * 2 + 1].x = dyno::clamp(mHandlePoints[mSelectPointID * 2 + 1].x + mDtPosition.x, minX, maxX);
796 mHandlePoints[mSelectPointID * 2 + 1].y = dyno::clamp(mHandlePoints[mSelectPointID * 2 + 1].y + mDtPosition.y, minY, maxY);
797
798 mInitPosition = mCoordArray[mSelectPointID];
799
800 if (mMultiSelectID.size() > 1)
801 {
802 for (size_t i = 0; i < mMultiSelectID.size(); i++)
803 {
804 int tempSelect = mMultiSelectID[i];
805 if (tempSelect != mSelectPointID)
806 {
807
808
809 mCoordArray[tempSelect].x = dyno::clamp(mCoordArray[tempSelect].x + mDtPosition.x, minX, maxX);
810 mCoordArray[tempSelect].y = dyno::clamp(mCoordArray[tempSelect].y + mDtPosition.y, minY, maxY);
811
812 //
813 mHandlePoints[tempSelect * 2].x = dyno::clamp(mHandlePoints[tempSelect * 2].x + mDtPosition.x, minX, maxX);
814 mHandlePoints[tempSelect * 2].y = dyno::clamp(mHandlePoints[tempSelect * 2].y + mDtPosition.y, minY, maxY);
815
816 mHandlePoints[tempSelect * 2 + 1].x = dyno::clamp(mHandlePoints[tempSelect * 2 + 1].x + mDtPosition.x, minX, maxX);
817 mHandlePoints[tempSelect * 2 + 1].y = dyno::clamp(mHandlePoints[tempSelect * 2 + 1].y + mDtPosition.y, minY, maxY);
818 }
819 }
820
821 }
822
823
824
825
826
827 update();
828 }
829 //constrained Handle
830 if (mIsHandleSelect)
831 {
832
833 mHandlePoints[mSelectHandlePoint].x = dyno::clamp(event->pos().x(), minX, maxX);
834 mHandlePoints[mSelectHandlePoint].y = dyno::clamp(event->pos().y(), minY, maxY);
835
836 Vec2f V1 = Vec2f(mHandlePoints[mSelectHandlePoint].x - mCoordArray[mHandleParent].x, mHandlePoints[mSelectHandlePoint].y - mCoordArray[mHandleParent].y);
837 Vec2f V2 = V1;
838 Vec2f V3 = Vec2f(mHandlePoints[mConnectHandlePoint].x - mCoordArray[mHandleParent].x, mHandlePoints[mConnectHandlePoint].y - mCoordArray[mHandleParent].y);
839 V3.normalize();
840 Vec2f P = Vec2f(mCoordArray[mHandleParent].x, mCoordArray[mHandleParent].y);
841 Vec2f N = -1 * V1.normalize();
842 float angle = acos(V3.dot(N))/ M_PI *180;
843
844 if (!mAltKey && mHandleConnection)
845 {
846 if (mInsertBezierOpenPoint)
847 {
848 mHandlePoints[mConnectHandlePoint] = N * (V2.norm()) + P;
849 }
850 else
851 {
852 mHandlePoints[mConnectHandlePoint] = N * mConnectLength + P;
853 mHandlePoints[mConnectHandlePoint].x = dyno::clamp(mHandlePoints[mConnectHandlePoint].x, minX, maxX);
854 mHandlePoints[mConnectHandlePoint].y = dyno::clamp(mHandlePoints[mConnectHandlePoint].y, minY, maxY);
855 }
856 }
857
858
859 update();
860 }
861
862
863 if (mIsHover == true)
864 {
865 int tempHover = sqrt(std::pow((event->pos().x() - mCoordArray[mHoverPoint].x), 2) + std::pow((event->pos().y() - mCoordArray[mHoverPoint].y), 2));
866 if (tempHover >= selectDistance)
867 {
868 mHoverPoint = -1;
869 mIsHover = false;
870 }
871 }
872 else
873 {
874 for (size_t i = 0; i < mCoordArray.size(); i++)
875 {
876 int temp = sqrt(std::pow((event->pos().x() - mCoordArray[i].x), 2) + std::pow((event->pos().y() - mCoordArray[i].y), 2));
877
878 if (temp < selectDistance)
879 {
880 mHoverPoint = i;
881 mIsHover = true;
882 break;
883 }
884 }
885 update();
886 }
887
888 }
889
890 void QCurveLabel::updateDataToField()
891 {
892 Curve s;
893 if (mField == nullptr) { return; }
894 else
895 {
896 if (!mReSortCoordArray.empty()) { updateFloatCoordArray(mReSortCoordArray, mFloatCoord); }
897 if (!mHandlePoints.empty()) { updateFloatCoordArray(mHandlePoints, mHandleFloatCoord); }
898
899 CoordtoField(s);
900 }
901 mField->setValue(s);
902 }
903
904 void QCurveLabel::changeValue(int s)
905 {
906 this->mMode = (Dir)s;
907 Curve ras;
908
909 initializeLine(mMode);
910
911 if (mField == nullptr) { return; }
912 else
913 {
914 updateDataToField();
915 if (!mFloatCoord.empty()) { CoordtoField(ras); }
916 }
917
918 this->mForceUpdate = true;
919 update();
920
921 }
922
923 void QCurveLabel::changeInterpValue(int s)
924 {
925 this->InterpMode = (Interpolation)s;
926 if (InterpMode == Interpolation::Linear) { useBezier = 0; }
927 else if (InterpMode == Interpolation::Bezier) { useBezier = 1; }
928 this->mForceUpdate = true;
929 update();
930 }
931
932
933
934
935 void QCurveLabel::CoordtoField(Curve& s)
936 {
937 s.clearMyCoord();
938 for (auto it : mFloatCoord)
939 {
940 s.addFloatItemToCoord(it.x, it.y, s.mCoord);
941 }
942
943 for (auto it : mHandleFloatCoord)
944 {
945 s.addFloatItemToCoord(it.x, it.y, s.myHandlePoint);
946 }
947
948 for (auto it : mCoordArray)
949 {
950 s.addItemOriginalCoord(it.x, it.y);
951 }
952 for (auto it : mHandlePoints)
953 {
954 s.addItemHandlePoint(it.x, it.y);
955 }
956
957 s.useBezierInterpolation = useBezier;
958
959 s.resample = LineResample;
960 s.useSquard = isSquard;
961 s.Spacing = spacing;
962
963 s.NminX = NminX;
964 s.NmaxX = NmaxX;
965 s.mNewMinY = mNewMinY;
966 s.NmaxY = NmaxY;
967
968 s.curveClose = curveClose;
969
970 if (useBezier) { s.mInterpMode = Curve::Interpolation::Bezier; }
971 else { s.mInterpMode = Curve::Interpolation::Linear; }
972
973 s.updateBezierCurve();
974 s.UpdateFieldFinalCoord();
975 }
976
977
978 void QCurveLabel::copySettingFromField()
979 {
980 useBezier = mField->getValue().useBezierInterpolation;
981 LineResample = mField->getValue().resample;
982 spacing = mField->getValue().Spacing;
983 curveClose = mField->getValue().curveClose;
984 isSquard = mField->getValue().useSquard;
985 lockSize = mField->getValue().lockSize;
986
987 if (mField->getValue().mInterpMode == Canvas::Interpolation::Bezier) { InterpMode = Bezier; }
988 else { InterpMode = Linear; }
989
990 useSort = false;
991
992 }
993
994}
995
IMPL_FIELD_WIDGET
#define IMPL_FIELD_WIDGET(_data_type_, _type_)
Definition PPropertyWidget.h:114
M_PI
#define M_PI
Definition Typedef.inl:36
dyno::Canvas::addFloatItemToCoord
void addFloatItemToCoord(float x, float y, std::vector< Coord2D > &coordArray)
Definition Canvas.cpp:20
dyno::Canvas::mInterpMode
Canvas::Interpolation mInterpMode
Definition Canvas.h:242
dyno::Canvas::resample
bool resample
Definition Canvas.h:262
dyno::Canvas::addItemHandlePoint
void addItemHandlePoint(int x, int y)
Definition Canvas.cpp:44
dyno::Canvas::useBezierInterpolation
bool useBezierInterpolation
Definition Canvas.h:261
dyno::Canvas::NmaxX
double NmaxX
Definition Canvas.h:256
dyno::Canvas::NmaxY
double NmaxY
Definition Canvas.h:258
dyno::Canvas::addItemOriginalCoord
void addItemOriginalCoord(int x, int y)
Definition Canvas.cpp:37
dyno::Canvas::mCoord
std::vector< Coord2D > mCoord
Definition Canvas.h:243
dyno::Canvas::curveClose
bool curveClose
Definition Canvas.h:263
dyno::Canvas::mNewMinY
double mNewMinY
Definition Canvas.h:257
dyno::Canvas::useSquard
bool useSquard
Definition Canvas.h:265
dyno::Canvas::updateBezierCurve
virtual void updateBezierCurve()
Definition Canvas.cpp:51
dyno::Canvas::NminX
double NminX
Definition Canvas.h:255
dyno::Canvas::Spacing
float Spacing
Definition Canvas.h:267
dyno::Canvas::myHandlePoint
std::vector< Coord2D > myHandlePoint
Definition Canvas.h:248
dyno::Canvas::clearMyCoord
void clearMyCoord()
Definition Canvas.cpp:292
dyno::Curve::UpdateFieldFinalCoord
void UpdateFieldFinalCoord() override
Updating the data of a Field.
Definition Curve.cpp:57
dyno::FVar::getValue
T getValue()
Definition Field.h:130
dyno::QCurveLabel::changeValue
void changeValue(int s)
Definition QCurveWidget.cpp:904
dyno::QCurveLabel::changeInterpValue
void changeInterpValue(int s)
Definition QCurveWidget.cpp:923
dyno::QCurveLabel::mouseMoveEvent
void mouseMoveEvent(QMouseEvent *event) override
Definition QCurveWidget.cpp:781
dyno::QCurveLabel::mousePressEvent
void mousePressEvent(QMouseEvent *event) override
Definition QCurveWidget.cpp:517
dyno::QCurveLabel::setField
void setField(FVar< Curve > *f)
Definition QCurveWidget.h:65
dyno::QCurveLabel::addPointtoEnd
int addPointtoEnd() override
Definition QCurveWidget.cpp:711
dyno::QCurveLabel::CoordtoField
void CoordtoField(Curve &s)
Definition QCurveWidget.cpp:935
dyno::QCurveLabel::paintEvent
void paintEvent(QPaintEvent *event)
Definition QCurveWidget.cpp:283
dyno::QCurveLabel::QCurveLabel
QCurveLabel(QWidget *parent=nullptr)
Definition QCurveWidget.cpp:508
dyno::QCurveLabel::mField
FVar< Curve > * mField
Definition QCurveWidget.h:76
dyno::QCurveLabel::updateDataToField
void updateDataToField() override
Definition QCurveWidget.cpp:890
dyno::QCurveWidget::QCurveWidget
DECLARE_FIELD_WIDGET QCurveWidget(FBase *field)
Definition QCurveWidget.cpp:19
dyno::QDoubleSlider::setRange
void setRange(double Min, double Max)
Definition PCustomWidgets.cpp:47
dyno::QDoubleSlider::setValue
void setValue(int value)
Definition PCustomWidgets.cpp:30
dyno::QFieldWidget::QFieldWidget
QFieldWidget(FBase *field)
Definition QFieldWidget.cpp:15
dyno::QToggleButton::setText
void setText(std::string textUnCheck, std::string textCheck)
Definition QToggleButton.cpp:43
dyno::QToggleButton::setValue
void setValue(bool press)
Definition QToggleButton.h:64
dyno::mDrawLabel::mInsertBezierOpenPoint
bool mInsertBezierOpenPoint
Definition QComponent.h:938
dyno::mDrawLabel::insertCurvePoint
int insertCurvePoint(MyCoord pCoord)
Definition QComponent.h:591
dyno::mDrawLabel::mCoordArray
std::vector< MyCoord > mCoordArray
Definition QComponent.h:950
dyno::mDrawLabel::InterpMode
Interpolation InterpMode
Definition QComponent.h:901
dyno::mDrawLabel::buildHandlePointSet
void buildHandlePointSet()
Definition QComponent.h:783
dyno::mDrawLabel::updateFloatCoordArray
void updateFloatCoordArray(std::vector< MyCoord > CoordArray, std::vector< Coord0_1 > &myfloatCoord)
Definition QComponent.h:830
dyno::mDrawLabel::mInitPosition
MyCoord mInitPosition
Definition QComponent.h:943
dyno::mDrawLabel::reSort
void reSort(std::vector< MyCoord > &vector1)
Definition QComponent.h:397
dyno::mDrawLabel::initializeLine
void initializeLine(Dir mode)
Definition QComponent.h:373
dyno::mDrawLabel::buildCoordToResortMap
void buildCoordToResortMap()
Definition QComponent.h:693
dyno::mDrawLabel::changeLabelSize
void changeLabelSize()
Definition QComponent.h:303
dyno::mDrawLabel::mMapResortIDtoOriginalID
std::map< int, int > mMapResortIDtoOriginalID
Definition QComponent.h:962
dyno::mDrawLabel::mFloatCoord
std::vector< Coord0_1 > mFloatCoord
Definition QComponent.h:953
dyno::mDrawLabel::mHandleFloatCoord
std::vector< Coord0_1 > mHandleFloatCoord
Definition QComponent.h:954
dyno::mDrawLabel::mPressCoord
MyCoord mPressCoord
Definition QComponent.h:946
dyno::mDrawLabel::mReSortCoordArray
std::vector< MyCoord > mReSortCoordArray
Definition QComponent.h:951
dyno::mDrawLabel::mHandlePoints
std::vector< MyCoord > mHandlePoints
Definition QComponent.h:952
dyno::mDrawLabel::mInitHandlePos
MyCoord mInitHandlePos
Definition QComponent.h:945
dyno::mDrawLabel::setLabelSize
void setLabelSize(int minX, int minY, int maxX, int maxY)
Definition QComponent.h:391
dyno::mDrawLabel::mPath
QPainterPath mPath
Definition QComponent.h:965
dyno::mDrawLabel::insertHandlePoint
void insertHandlePoint(int fp, MyCoord pCoord)
Definition QComponent.h:530
dyno::mDrawLabel::mMultiSelectID
std::vector< int > mMultiSelectID
Definition QComponent.h:956
dyno::mDrawLabel::mDtPosition
MyCoord mDtPosition
Definition QComponent.h:944
dyno::mDrawLabel::copyFromField
void copyFromField(std::vector< Canvas::Coord2D > coord01, std::vector< MyCoord > &thisArray)
Definition QComponent.h:348
dyno::mDrawLabel::buildBezierPoint
void buildBezierPoint()
Definition QComponent.h:561
dyno::mQCheckBox::nameLabel
QLabel * nameLabel
Definition QComponent.h:149
dyno::mQDoubleSpinner::setValue
void setValue(double Value, bool BlockSignals=false)
Definition QComponent.h:79
N
#define N(x, y, z)
TypeInfo::cast
TA * cast(TB *b)
Definition Typedef.inl:286
dyno
This is an implementation of AdditiveCCD based on peridyno.
Definition Array.h:25
dyno::FormatFieldWidgetName
QString FormatFieldWidgetName(std::string name)
Definition Format.cpp:9
dyno::Vec2f
Vector< float, 2 > Vec2f
Definition Vector2D.h:81
dyno::acos
DYN_FUNC Complex< Real > acos(const Complex< Real > &)
Definition Complex.inl:519
dyno::clamp
DYN_FUNC T clamp(const T &v, const T &lo, const T &hi)
Definition SimpleMath.h:42
dyno::sqrt
DYN_FUNC Complex< Real > sqrt(const Complex< Real > &)
Definition Complex.inl:321
Generated by doxygen 1.13.2