• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • krita API Reference
  • KDE Home
  • Contact Us
 

plugins/paintops/libpaintop

  • sources
  • kfour-appscomplete
  • krita
  • plugins
  • paintops
  • libpaintop
kis_curve_option.cpp
Go to the documentation of this file.
1 /* This file is part of the KDE project
2  * SPDX-FileCopyrightText: 2008 Boudewijn Rempt <[email protected]>
3  * SPDX-FileCopyrightText: 2011 Silvio Heinrich <[email protected]>
4  *
5  * SPDX-License-Identifier: LGPL-2.0-or-later
6  */
7 #include "kis_curve_option.h"
8 
9 #include <QDomNode>
10 
11 #include "kis_algebra_2d.h"
12 
13 #include <sensors/kis_dynamic_sensor_distance.h>
14 #include <sensors/kis_dynamic_sensor_drawing_angle.h>
15 #include <sensors/kis_dynamic_sensor_fade.h>
16 #include <sensors/kis_dynamic_sensor_fuzzy.h>
17 #include <sensors/kis_dynamic_sensor_time.h>
18 #include <sensors/kis_dynamic_sensors.h>
19 
20 
21 qreal KisCurveOption::ValueComponents::rotationLikeValue(qreal normalizedBaseAngle, bool absoluteAxesFlipped, qreal scalingPartCoeff, bool disableScalingPart) const {
22  const qreal offset =
23  !hasAbsoluteOffset ? normalizedBaseAngle :
24  absoluteAxesFlipped ? 0.5 - absoluteOffset :
25  absoluteOffset;
26 
27  const qreal realScalingPart = hasScaling && !disableScalingPart ? KisDynamicSensor::scalingToAdditive(scaling) : 0.0;
28  const qreal realAdditivePart = hasAdditive ? additive : 0;
29 
30  qreal value = KisAlgebra2D::wrapValue(2 * offset + constant * (scalingPartCoeff * realScalingPart + realAdditivePart), -1.0, 1.0);
31  if (qIsNaN(value)) {
32  qWarning() << "rotationLikeValue returns NaN!" << normalizedBaseAngle << absoluteAxesFlipped;
33  value = 0;
34  }
35  return value;
36 }
37 
38 qreal KisCurveOption::ValueComponents::sizeLikeValue() const {
39  const qreal offset =
40  hasAbsoluteOffset ? absoluteOffset : 1.0;
41 
42  const qreal realScalingPart = hasScaling ? scaling : 1.0;
43  const qreal realAdditivePart = hasAdditive ? KisDynamicSensor::additiveToScaling(additive) : 1.0;
44 
45  return qBound(minSizeLikeValue,
46  constant * offset * realScalingPart * realAdditivePart,
47  maxSizeLikeValue);
48 }
49 
50 KisCurveOption::KisCurveOption(const QString& name, KisPaintOpOption::PaintopCategory category,
51  bool checked, qreal value, qreal min, qreal max)
52  : m_name(name)
53  , m_category(category)
54  , m_checkable(true)
55  , m_checked(checked)
56  , m_useCurve(true)
57  , m_useSameCurve(true)
58  , m_separateCurveValue(false)
59  , m_curveMode(0)
60 {
61  Q_FOREACH (const DynamicSensorType sensorType, this->sensorsTypes()) {
62  KisDynamicSensorSP sensor = this->type2Sensor(sensorType, m_name);
63  sensor->setActive(false);
64  replaceSensor(sensor);
65  }
66  m_sensorMap[PRESSURE]->setActive(true);
67 
68  setValueRange(min, max);
69  setValue(value);
70 
71 
72  m_commonCurve = defaultCurve();
73 }
74 
75 KisCurveOption::~KisCurveOption()
76 {
77 }
78 
79 const QString& KisCurveOption::name() const
80 {
81  return m_name;
82 }
83 
84 KisPaintOpOption::PaintopCategory KisCurveOption::category() const
85 {
86  return m_category;
87 }
88 
89 qreal KisCurveOption::minValue() const
90 {
91  return m_minValue;
92 }
93 
94 qreal KisCurveOption::maxValue() const
95 {
96  return m_maxValue;
97 }
98 
99 qreal KisCurveOption::value() const
100 {
101  return m_value;
102 }
103 
104 void KisCurveOption::resetAllSensors()
105 {
106  Q_FOREACH (KisDynamicSensorSP sensor, m_sensorMap.values()) {
107  if (sensor->isActive()) {
108  sensor->reset();
109  }
110  }
111 }
112 
113 void KisCurveOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
114 {
115  if (m_checkable) {
116  setting->setProperty("Pressure" + m_name, isChecked());
117  }
118 
119  if (activeSensors().size() == 1) {
120  setting->setProperty(m_name + "Sensor", activeSensors().first()->toXML());
121  }
122  else {
123  QDomDocument doc = QDomDocument("params");
124  QDomElement root = doc.createElement("params");
125  doc.appendChild(root);
126  root.setAttribute("id", "sensorslist");
127 
128  Q_FOREACH (KisDynamicSensorSP sensor, activeSensors()) {
129  QDomElement childelt = doc.createElement("ChildSensor");
130  sensor->toXML(doc, childelt);
131  root.appendChild(childelt);
132  }
133  setting->setProperty(m_name + "Sensor", doc.toString());
134  }
135  setting->setProperty(m_name + "UseCurve", m_useCurve);
136  setting->setProperty(m_name + "UseSameCurve", m_useSameCurve);
137  setting->setProperty(m_name + "Value", m_value);
138  setting->setProperty(m_name + "curveMode", m_curveMode);
139  setting->setProperty(m_name + "commonCurve", QVariant::fromValue(m_commonCurve));
140 
141 }
142 
143 void KisCurveOption::readOptionSetting(KisPropertiesConfigurationSP setting)
144 {
145  readNamedOptionSetting(m_name, setting);
146 }
147 
148 void KisCurveOption::lodLimitations(KisPaintopLodLimitations *l) const
149 {
150  Q_UNUSED(l);
151 }
152 
153 int KisCurveOption::intMinValue() const
154 {
155  return 0;
156 }
157 
158 int KisCurveOption::intMaxValue() const
159 {
160  return 100;
161 }
162 
163 QString KisCurveOption::valueSuffix() const
164 {
165  return i18n("%");
166 }
167 
168 void KisCurveOption::readNamedOptionSetting(const QString& prefix, const KisPropertiesConfigurationSP setting)
169 {
170  if (!setting) return;
171 
172  KisCubicCurve commonCurve = m_commonCurve;
173 
174  //dbgKrita << "readNamedOptionSetting" << prefix;
175  // setting->dump();
176 
177  if (m_checkable) {
178  setChecked(setting->getBool("Pressure" + prefix, false));
179  }
180  //dbgKrita << "\tPressure" + prefix << isChecked();
181 
182  m_sensorMap.clear();
183 
184  // Replace all sensors with the inactive defaults
185  Q_FOREACH (const DynamicSensorType sensorType, this->sensorsTypes()) {
186  replaceSensor(type2Sensor(sensorType, m_name));
187  }
188 
189  QString sensorDefinition = setting->getString(prefix + "Sensor");
190  if (!sensorDefinition.contains("sensorslist")) {
191  KisDynamicSensorSP s = KisDynamicSensor::createFromXML(sensorDefinition, m_name);
192  if (s) {
193  replaceSensor(s);
194  s->setActive(true);
195  commonCurve = s->curve();
196  //dbgKrita << "\tsingle sensor" << s::id(s->sensorType()) << s->isActive() << "added";
197  }
198  }
199  else {
200  QDomDocument doc;
201  doc.setContent(sensorDefinition);
202  QDomElement elt = doc.documentElement();
203  QDomNode node = elt.firstChild();
204  while (!node.isNull()) {
205  if (node.isElement()) {
206  QDomElement childelt = node.toElement();
207  if (childelt.tagName() == "ChildSensor") {
208  KisDynamicSensorSP s = KisDynamicSensor::createFromXML(childelt, m_name);
209  if (s) {
210  replaceSensor(s);
211  s->setActive(true);
212  commonCurve = s->curve();
213  //dbgKrita << "\tchild sensor" << s::id(s->sensorType()) << s->isActive() << "added";
214  }
215  }
216  }
217  node = node.nextSibling();
218  }
219  }
220 
221 
222  m_useSameCurve = setting->getBool(m_name + "UseSameCurve", true);
223 
224  // Only load the old curve format if the curve wasn't saved by the sensor
225  // This will give every sensor the same curve.
226  //dbgKrita << ">>>>>>>>>>>" << prefix + "Sensor" << setting->getString(prefix + "Sensor");
227  if (!setting->getString(prefix + "Sensor").contains("curve")) {
228  //dbgKrita << "\told format";
229  if (setting->getBool("Custom" + prefix, false)) {
230  Q_FOREACH (KisDynamicSensorSP s, m_sensorMap.values()) {
231  s->setCurve(setting->getCubicCurve("Curve" + prefix));
232  commonCurve = s->curve();
233  }
234  } else {
235  commonCurve = emptyCurve();
236  }
237  }
238 
239  if (m_useSameCurve) {
240  m_commonCurve = setting->getCubicCurve(prefix + "commonCurve", commonCurve);
241  }
242 
243  // At least one sensor needs to be active
244  if (activeSensors().size() == 0) {
245  m_sensorMap[PRESSURE]->setActive(true);
246  }
247 
248  m_value = setting->getDouble(m_name + "Value", m_maxValue);
249  //dbgKrita << "\t" + m_name + "Value" << m_value;
250 
251  m_useCurve = setting->getBool(m_name + "UseCurve", true);
252  //dbgKrita << "\t" + m_name + "UseCurve" << m_useSameCurve;
253 
254 
255  //dbgKrita << "\t" + m_name + "UseSameCurve" << m_useSameCurve;
256 
257  m_curveMode = setting->getInt(m_name + "curveMode");
258  //dbgKrita << "-----------------";
259 }
260 
261 void KisCurveOption::replaceSensor(KisDynamicSensorSP s)
262 {
263  Q_ASSERT(s);
264  m_sensorMap[s->sensorType()] = s;
265 }
266 
267 KisDynamicSensorSP KisCurveOption::sensor(DynamicSensorType sensorType, bool active) const
268 {
269  if (m_sensorMap.contains(sensorType)) {
270  if (!active) {
271  return m_sensorMap[sensorType];
272  }
273  else {
274  if (m_sensorMap[sensorType]->isActive()) {
275  return m_sensorMap[sensorType];
276  }
277  }
278  }
279  return 0;
280 }
281 
282 
283 bool KisCurveOption::isRandom() const
284 {
285  return bool(sensor(FUZZY_PER_DAB, true)) ||
286  bool(sensor(FUZZY_PER_STROKE, true));
287 }
288 
289 bool KisCurveOption::isCurveUsed() const
290 {
291  return m_useCurve;
292 }
293 
294 bool KisCurveOption::isSameCurveUsed() const
295 {
296  return m_useSameCurve;
297 }
298 
299 int KisCurveOption::getCurveMode() const
300 {
301  return m_curveMode;
302 }
303 
304 KisCubicCurve KisCurveOption::getCommonCurve() const
305 {
306  return m_commonCurve;
307 }
308 
309 void KisCurveOption::setSeparateCurveValue(bool separateCurveValue)
310 {
311  m_separateCurveValue = separateCurveValue;
312 }
313 
314 bool KisCurveOption::isCheckable()
315 {
316  return m_checkable;
317 }
318 
319 bool KisCurveOption::isChecked() const
320 {
321  return m_checked;
322 }
323 
324 void KisCurveOption::setChecked(bool checked)
325 {
326  m_checked = checked;
327 }
328 
329 void KisCurveOption::setCurveUsed(bool useCurve)
330 {
331  m_useCurve = useCurve;
332 }
333 
334 void KisCurveOption::setCurveMode(int mode)
335 {
336  m_curveMode = mode;
337 }
338 
339 void KisCurveOption::setUseSameCurve(bool useSameCurve)
340 {
341  m_useSameCurve = useSameCurve;
342 }
343 
344 void KisCurveOption::setCommonCurve(KisCubicCurve curve)
345 {
346  m_commonCurve = curve;
347 }
348 
349 void KisCurveOption::setCurve(DynamicSensorType sensorType, bool useSameCurve, const KisCubicCurve &curve)
350 {
351  if (useSameCurve == m_useSameCurve) {
352  if (useSameCurve) {
353  m_commonCurve = curve;
354  }
355  else {
356  KisDynamicSensorSP s = sensor(sensorType, false);
357  if (s) {
358  s->setCurve(curve);
359  }
360 
361  }
362  }
363  else {
364  if (!m_useSameCurve && useSameCurve) {
365  m_commonCurve = curve;
366  }
367  else { //if (m_useSameCurve && !useSameCurve)
368  KisDynamicSensorSP s = 0;
369  // And set the current sensor to the current curve
370  if (!m_sensorMap.contains(sensorType)) {
371  s = type2Sensor(sensorType, m_name);
372  } else {
373  KisDynamicSensorSP s = sensor(sensorType, false);
374  }
375  if (s) {
376  s->setCurve(curve);
377  }
378 
379  }
380  m_useSameCurve = useSameCurve;
381  }
382 }
383 
384 void KisCurveOption::setValueRange(qreal min, qreal max)
385 {
386  m_minValue = qMin(min, max);
387  m_maxValue = qMax(min, max);
388 }
389 
390 void KisCurveOption::setValue(qreal value)
391 {
392  m_value = qBound(m_minValue, value, m_maxValue);
393 }
394 
395 KisCurveOption::ValueComponents KisCurveOption::computeValueComponents(const KisPaintInformation& info) const
396 {
397  ValueComponents components;
398 
399  if (m_useCurve) {
400  QMap<DynamicSensorType, KisDynamicSensorSP>::const_iterator i;
401  QList<double> sensorValues;
402  for (i = m_sensorMap.constBegin(); i != m_sensorMap.constEnd(); ++i) {
403  KisDynamicSensorSP s(i.value());
404 
405  if (s->isActive()) {
406  qreal valueFromCurve = m_useSameCurve ? s->parameter(info, m_commonCurve, true) : s->parameter(info);
407  if (s->isAdditive()) {
408  components.additive += valueFromCurve;
409  components.hasAdditive = true;
410  } else if (s->isAbsoluteRotation()) {
411  components.absoluteOffset = valueFromCurve;
412  components.hasAbsoluteOffset =true;
413  } else {
414  sensorValues << valueFromCurve;
415  components.hasScaling = true;
416  }
417  }
418  }
419 
420  if (sensorValues.count() == 1) {
421  components.scaling = sensorValues.first();
422  } else {
423 
424  if (m_curveMode == 1){ // add
425  components.scaling = 0;
426  double i;
427  foreach (i, sensorValues) {
428  components.scaling += i;
429  }
430  } else if (m_curveMode == 2){ //max
431  components.scaling = *std::max_element(sensorValues.begin(), sensorValues.end());
432 
433  } else if (m_curveMode == 3){ //min
434  components.scaling = *std::min_element(sensorValues.begin(), sensorValues.end());
435 
436  } else if (m_curveMode == 4){ //difference
437  double max = *std::max_element(sensorValues.begin(), sensorValues.end());
438  double min = *std::min_element(sensorValues.begin(), sensorValues.end());
439  components.scaling = max-min;
440 
441  } else { //multuply - default
442  double i;
443  foreach (i, sensorValues) {
444  components.scaling *= i;
445  }
446  }
447  }
448 
449  }
450 
451  if (!m_separateCurveValue) {
452  components.constant = m_value;
453  }
454 
455  components.minSizeLikeValue = m_minValue;
456  components.maxSizeLikeValue = m_maxValue;
457 
458  return components;
459 }
460 
461 qreal KisCurveOption::computeSizeLikeValue(const KisPaintInformation& info) const
462 {
463  const ValueComponents components = computeValueComponents(info);
464  return components.sizeLikeValue();
465 }
466 
467 qreal KisCurveOption::computeRotationLikeValue(const KisPaintInformation& info, qreal baseValue, bool absoluteAxesFlipped, qreal scalingPartCoeff, bool disableScalingPart) const
468 {
469  const ValueComponents components = computeValueComponents(info);
470  return components.rotationLikeValue(baseValue, absoluteAxesFlipped, scalingPartCoeff, disableScalingPart);
471 }
472 
473 KisCubicCurve KisCurveOption::defaultCurve()
474 {
475  QList<QPointF> points;
476  // needs to be set to something, weird curve is better for debugging
477  // it will be reset to the curve from the preset anyway though
478  points.push_back(QPointF(0,0));
479  points.push_back(QPointF(0.25,0.9));
480  points.push_back(QPointF(0.5,0));
481  points.push_back(QPointF(0.75,0.6));
482  points.push_back(QPointF(1,0));
483  return KisCubicCurve(points);
484 }
485 
486 KisCubicCurve KisCurveOption::emptyCurve()
487 {
488  QList<QPointF> points;
489  points.push_back(QPointF(0,0));
490  points.push_back(QPointF(1,1));
491  return KisCubicCurve(points);
492 }
493 
494 QList<KisDynamicSensorSP> KisCurveOption::sensors()
495 {
496  //dbgKrita << "ID" << name() << "has" << m_sensorMap.count() << "Sensors of which" << sensorList.count() << "are active.";
497  return m_sensorMap.values();
498 }
499 
500 QList<KisDynamicSensorSP> KisCurveOption::activeSensors() const
501 {
502  QList<KisDynamicSensorSP> sensorList;
503  Q_FOREACH (KisDynamicSensorSP sensor, m_sensorMap.values()) {
504  if (sensor->isActive()) {
505  sensorList << sensor;
506  }
507  }
508  //dbgKrita << "ID" << name() << "has" << m_sensorMap.count() << "Sensors of which" << sensorList.count() << "are active.";
509  return sensorList;
510 }
511 
512 QList<KoID> KisCurveOption::sensorsIds()
513 {
514  QList<KoID> ids;
515 
516  ids << PressureId
517  << PressureInId
518  << XTiltId
519  << YTiltId
520  << TiltDirectionId
521  << TiltElevationId
522  << SpeedId
523  << DrawingAngleId
524  << RotationId
525  << DistanceId
526  << TimeId
527  << FuzzyPerDabId
528  << FuzzyPerStrokeId
529  << FadeId
530  << PerspectiveId
531  << TangentialPressureId;
532 
533  return ids;
534 }
535 
536 DynamicSensorType KisCurveOption::id2Type(const KoID &id)
537 {
538  if (id.id() == PressureId.id()) {
539  return PRESSURE;
540  }
541  else if (id.id() == PressureInId.id()) {
542  return PRESSURE_IN;
543  }
544  else if (id.id() == XTiltId.id()) {
545  return XTILT;
546  }
547  else if (id.id() == YTiltId.id()) {
548  return YTILT;
549  }
550  else if (id.id() == TiltDirectionId.id()) {
551  return TILT_DIRECTION;
552  }
553  else if (id.id() == TiltElevationId.id()) {
554  return TILT_ELEVATATION;
555  }
556  else if (id.id() == SpeedId.id()) {
557  return SPEED;
558  }
559  else if (id.id() == DrawingAngleId.id()) {
560  return ANGLE;
561  }
562  else if (id.id() == RotationId.id()) {
563  return ROTATION;
564  }
565  else if (id.id() == DistanceId.id()) {
566  return DISTANCE;
567  }
568  else if (id.id() == TimeId.id()) {
569  return TIME;
570  }
571  else if (id.id() == FuzzyPerDabId.id()) {
572  return FUZZY_PER_DAB;
573  }
574  else if (id.id() == FuzzyPerStrokeId.id()) {
575  return FUZZY_PER_STROKE;
576  }
577  else if (id.id() == FadeId.id()) {
578  return FADE;
579  }
580  else if (id.id() == PerspectiveId.id()) {
581  return PERSPECTIVE;
582  }
583  else if (id.id() == TangentialPressureId.id()) {
584  return TANGENTIAL_PRESSURE;
585  }
586  return UNKNOWN;
587 }
588 
589 KisDynamicSensorSP KisCurveOption::id2Sensor(const KoID& id, const QString &parentOptionName)
590 {
591  if (id.id() == PressureId.id()) {
592  return new KisDynamicSensorPressure();
593  }
594  else if (id.id() == PressureInId.id()) {
595  return new KisDynamicSensorPressureIn();
596  }
597  else if (id.id() == XTiltId.id()) {
598  return new KisDynamicSensorXTilt();
599  }
600  else if (id.id() == YTiltId.id()) {
601  return new KisDynamicSensorYTilt();
602  }
603  else if (id.id() == TiltDirectionId.id()) {
604  return new KisDynamicSensorTiltDirection();
605  }
606  else if (id.id() == TiltElevationId.id()) {
607  return new KisDynamicSensorTiltElevation();
608  }
609  else if (id.id() == SpeedId.id()) {
610  return new KisDynamicSensorSpeed();
611  }
612  else if (id.id() == DrawingAngleId.id()) {
613  return new KisDynamicSensorDrawingAngle();
614  }
615  else if (id.id() == RotationId.id()) {
616  return new KisDynamicSensorRotation();
617  }
618  else if (id.id() == DistanceId.id()) {
619  return new KisDynamicSensorDistance();
620  }
621  else if (id.id() == TimeId.id()) {
622  return new KisDynamicSensorTime();
623  }
624  else if (id.id() == FuzzyPerDabId.id()) {
625  return new KisDynamicSensorFuzzy(false, parentOptionName);
626  }
627  else if (id.id() == FuzzyPerStrokeId.id()) {
628  return new KisDynamicSensorFuzzy(true, parentOptionName);
629  }
630  else if (id.id() == FadeId.id()) {
631  return new KisDynamicSensorFade();
632  }
633  else if (id.id() == PerspectiveId.id()) {
634  return new KisDynamicSensorPerspective();
635  }
636  else if (id.id() == TangentialPressureId.id()) {
637  return new KisDynamicSensorTangentialPressure();
638  }
639  dbgPlugins << "Unknown transform parameter :" << id.id();
640  return 0;
641 }
642 
643 KisDynamicSensorSP KisCurveOption::type2Sensor(DynamicSensorType sensorType, const QString &parentOptionName)
644 {
645  switch (sensorType) {
646  case FUZZY_PER_DAB:
647  return new KisDynamicSensorFuzzy(false, parentOptionName);
648  case FUZZY_PER_STROKE:
649  return new KisDynamicSensorFuzzy(true, parentOptionName);
650  case SPEED:
651  return new KisDynamicSensorSpeed();
652  case FADE:
653  return new KisDynamicSensorFade();
654  case DISTANCE:
655  return new KisDynamicSensorDistance();
656  case TIME:
657  return new KisDynamicSensorTime();
658  case ANGLE:
659  return new KisDynamicSensorDrawingAngle();
660  case ROTATION:
661  return new KisDynamicSensorRotation();
662  case PRESSURE:
663  return new KisDynamicSensorPressure();
664  case XTILT:
665  return new KisDynamicSensorXTilt();
666  case YTILT:
667  return new KisDynamicSensorYTilt();
668  case TILT_DIRECTION:
669  return new KisDynamicSensorTiltDirection();
670  case TILT_ELEVATATION:
671  return new KisDynamicSensorTiltElevation();
672  case PERSPECTIVE:
673  return new KisDynamicSensorPerspective();
674  case TANGENTIAL_PRESSURE:
675  return new KisDynamicSensorTangentialPressure();
676  case PRESSURE_IN:
677  return new KisDynamicSensorPressureIn();
678  default:
679  return 0;
680  }
681 }
682 
683 QList<DynamicSensorType> KisCurveOption::sensorsTypes()
684 {
685  QList<DynamicSensorType> sensorTypes;
686  sensorTypes
687  << PRESSURE
688  << PRESSURE_IN
689  << XTILT
690  << YTILT
691  << TILT_DIRECTION
692  << TILT_ELEVATATION
693  << SPEED
694  << ANGLE
695  << ROTATION
696  << DISTANCE
697  << TIME
698  << FUZZY_PER_DAB
699  << FUZZY_PER_STROKE
700  << FADE
701  << PERSPECTIVE
702  << TANGENTIAL_PRESSURE;
703  return sensorTypes;
704 }
705 
706 
QMap::constBegin
const_iterator constBegin() const
QList::first
T & first()
KisDynamicSensorDistance
Definition: kis_dynamic_sensor_distance.h:12
KisCurveOption::setCurveMode
void setCurveMode(int mode)
Definition: kis_curve_option.cpp:334
KisCurveOption::value
qreal value() const
Definition: kis_curve_option.cpp:99
ROTATION
Definition: kis_dynamic_sensor.h:66
KisCurveOption::setCurve
void setCurve(DynamicSensorType sensorType, bool useSameCurve, const KisCubicCurve &curve)
Definition: kis_curve_option.cpp:349
YTiltId
const KoID YTiltId("ytilt", ki18nc("Context: dynamic sensors", "Y-Tilt"))
number depending on Y-tilt
QDomDocument::toString
QString toString(int indent) const
TIME
Definition: kis_dynamic_sensor.h:64
KisCurveOption::defaultCurve
KisCubicCurve defaultCurve()
defaultCurve returns a curve that is set when the KisCurveOption is not initialized yet the purpose o...
Definition: kis_curve_option.cpp:473
KisCurveOption::ValueComponents::maxSizeLikeValue
qreal maxSizeLikeValue
Definition: kis_curve_option.h:122
QMap::contains
bool contains(const Key &key) const
QDomNode::firstChild
QDomNode firstChild() const
QDomNode::toElement
QDomElement toElement() const
KisCurveOption::writeOptionSetting
virtual void writeOptionSetting(KisPropertiesConfigurationSP setting) const
Definition: kis_curve_option.cpp:113
KisCurveOption::setSeparateCurveValue
void setSeparateCurveValue(bool separateCurveValue)
Definition: kis_curve_option.cpp:309
KisCurveOption::m_value
qreal m_value
Definition: kis_curve_option.h:192
QVariant::fromValue
QVariant fromValue(const T &value)
KisDynamicSensorFade
Definition: kis_dynamic_sensor_fade.h:12
KisCurveOption::resetAllSensors
void resetAllSensors()
Definition: kis_curve_option.cpp:104
KisCurveOption::m_maxValue
qreal m_maxValue
Definition: kis_curve_option.h:194
KisCurveOption::sensors
QList< KisDynamicSensorSP > sensors()
Definition: kis_curve_option.cpp:494
QDomNode
QDomElement::tagName
QString tagName() const
kis_curve_option.h
QMap::clear
void clear()
QMap::value
const T value(const Key &key) const
FuzzyPerDabId
const KoID FuzzyPerDabId("fuzzy", ki18nc("Context: dynamic sensors", "Fuzzy Dab"))
generate a random number
KisCurveOption::isSameCurveUsed
bool isSameCurveUsed() const
Definition: kis_curve_option.cpp:294
QList::count
int count(const T &value) const
DistanceId
const KoID DistanceId("distance", ki18nc("Context: dynamic sensors", "Distance"))
generate a number that increase with distance
KisCurveOption::getCommonCurve
KisCubicCurve getCommonCurve() const
Returns the curve that is being used instead of sensor ones in case "Use the same curve" is checked.
Definition: kis_curve_option.cpp:304
QDomNode::isNull
bool isNull() const
KisCurveOption::ValueComponents
Definition: kis_curve_option.h:101
KisCurveOption::ValueComponents::additive
qreal additive
Definition: kis_curve_option.h:116
KisCurveOption::maxValue
qreal maxValue() const
Definition: kis_curve_option.cpp:94
RotationId
const KoID RotationId("rotation", ki18nc("Context: dynamic sensors", "Rotation"))
rotation coming from the device
KisCurveOption::m_name
QString m_name
Definition: kis_curve_option.h:173
DynamicSensorType
DynamicSensorType
Definition: kis_dynamic_sensor.h:58
PRESSURE
Definition: kis_dynamic_sensor.h:67
ANGLE
Definition: kis_dynamic_sensor.h:65
QList::push_back
void push_back(const T &value)
QDomDocument::setContent
bool setContent(const QByteArray &data, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn)
PERSPECTIVE
Definition: kis_dynamic_sensor.h:72
FuzzyPerStrokeId
const KoID FuzzyPerStrokeId("fuzzystroke", ki18nc("Context: dynamic sensors", "Fuzzy Stroke"))
generate a random number
KisCurveOption::setValue
void setValue(qreal value)
Definition: kis_curve_option.cpp:390
KisCurveOption::ValueComponents::hasScaling
bool hasScaling
Definition: kis_curve_option.h:119
QDomDocument::createElement
QDomElement createElement(const QString &tagName)
QList
KisCurveOption::m_commonCurve
KisCubicCurve m_commonCurve
Curve that is being used instead of sensors' internal ones in case "Use the same curve" is checked.
Definition: kis_curve_option.h:186
QPointF
KisDynamicSensor::createFromXML
static KisDynamicSensorSP createFromXML(const QString &, const QString &parentOptionName)
Definition: kis_dynamic_sensor.cc:279
KisDynamicSensorPressure
Definition: kis_dynamic_sensors.h:39
KisDynamicSensorDrawingAngle
Definition: kis_dynamic_sensor_drawing_angle.h:16
KisDynamicSensorSpeed
Definition: kis_dynamic_sensors.h:16
KisDynamicSensorFuzzy
Definition: kis_dynamic_sensor_fuzzy.h:21
KisCurveOption::KisCurveOption
KisCurveOption(const QString &name, KisPaintOpOption::PaintopCategory category, bool checked, qreal value=1.0, qreal min=0.0, qreal max=1.0)
Definition: kis_curve_option.cpp:50
KisCurveOption::minValue
qreal minValue() const
Definition: kis_curve_option.cpp:89
QDomElement::setAttribute
void setAttribute(const QString &name, const QString &value)
KisCurveOption::m_useSameCurve
bool m_useSameCurve
Definition: kis_curve_option.h:179
KisCurveOption::name
const QString & name() const
Definition: kis_curve_option.cpp:79
TILT_DIRECTION
Definition: kis_dynamic_sensor.h:70
PressureInId
const KoID PressureInId("pressurein", ki18nc("Context: dynamic sensors", "PressureIn"))
number depending on the pressure
KisCurveOption::m_checkable
bool m_checkable
Definition: kis_curve_option.h:176
PerspectiveId
const KoID PerspectiveId("perspective", ki18nc("Context: dynamic sensors", "Perspective"))
< tilt elevation is 90 when stylus is perpendicular to tablet and 0 when it's parallel to tablet
FADE
Definition: kis_dynamic_sensor.h:62
KisCurveOption::~KisCurveOption
virtual ~KisCurveOption()
Definition: kis_curve_option.cpp:75
KisCurveOption::sensor
KisDynamicSensorSP sensor(DynamicSensorType sensorType, bool active) const
Definition: kis_curve_option.cpp:267
QMap::constEnd
const_iterator constEnd() const
QString
KisCurveOption::sensorsIds
virtual QList< KoID > sensorsIds()
Definition: kis_curve_option.cpp:512
KisCurveOption::m_minValue
qreal m_minValue
Definition: kis_curve_option.h:193
KisDynamicSensorXTilt
Definition: kis_dynamic_sensors.h:69
FUZZY_PER_STROKE
Definition: kis_dynamic_sensor.h:60
kis_dynamic_sensor_fade.h
KisCurveOption::computeSizeLikeValue
qreal computeSizeLikeValue(const KisPaintInformation &info) const
Definition: kis_curve_option.cpp:461
KisCurveOption::setUseSameCurve
void setUseSameCurve(bool useSameCurve)
Sets the bool indicating whether "Share curve across all settings" is checked.
Definition: kis_curve_option.cpp:339
KisDynamicSensorTiltElevation
Definition: kis_dynamic_sensors.h:99
KisCurveOption::getCurveMode
int getCurveMode() const
Definition: kis_curve_option.cpp:299
TILT_ELEVATATION
Definition: kis_dynamic_sensor.h:71
KisDynamicSensorPressureIn
Definition: kis_dynamic_sensors.h:49
KisCurveOption::readOptionSetting
virtual void readOptionSetting(KisPropertiesConfigurationSP setting)
Definition: kis_curve_option.cpp:143
KisCurveOption::m_sensorMap
QMap< DynamicSensorType, KisDynamicSensorSP > m_sensorMap
Definition: kis_curve_option.h:190
SpeedId
const KoID SpeedId("speed", ki18nc("Context: dynamic sensors", "Speed"))
generate a number depending on the speed of the cursor
KisCurveOption::sensorsTypes
virtual QList< DynamicSensorType > sensorsTypes()
Definition: kis_curve_option.cpp:683
KisCurveOption::intMinValue
virtual int intMinValue() const
Definition: kis_curve_option.cpp:153
KisCurveOption::ValueComponents::hasAdditive
bool hasAdditive
Definition: kis_curve_option.h:120
UNKNOWN
Definition: kis_dynamic_sensor.h:87
KisCurveOption::setValueRange
void setValueRange(qreal min, qreal max)
Definition: kis_curve_option.cpp:384
QMap::values
QList< T > values() const
KisCurveOption::computeRotationLikeValue
qreal computeRotationLikeValue(const KisPaintInformation &info, qreal baseValue, bool absoluteAxesFlipped, qreal scalingPartCoeff, bool disableScalingPart) const
Definition: kis_curve_option.cpp:467
KisCurveOption::m_separateCurveValue
bool m_separateCurveValue
Definition: kis_curve_option.h:180
TiltElevationId
const KoID TiltElevationId("declination", ki18nc("Context: dynamic sensors", "Tilt elevation"))
< number depending on the X and Y tilt, tilt direction is 0 when stylus nib points to you and changes...
QDomDocument::documentElement
QDomElement documentElement() const
KisCurveOption::readNamedOptionSetting
virtual void readNamedOptionSetting(const QString &prefix, const KisPropertiesConfigurationSP setting)
Read the option using the prefix in argument.
Definition: kis_curve_option.cpp:168
KisCurveOption::type2Sensor
virtual KisDynamicSensorSP type2Sensor(DynamicSensorType sensorType, const QString &parentOptionName)
Definition: kis_curve_option.cpp:643
KisCurveOption::category
KisPaintOpOption::PaintopCategory category() const
Definition: kis_curve_option.cpp:84
TiltDirectionId
const KoID TiltDirectionId("ascension", ki18nc("Context: dynamic sensors", "Tilt direction"))
"TiltDirection" and "TiltElevation" parameters are written to preset files as "ascension" and "declin...
KisCurveOption::id2Type
virtual DynamicSensorType id2Type(const KoID &id)
Definition: kis_curve_option.cpp:536
KisCurveOption::ValueComponents::constant
qreal constant
Definition: kis_curve_option.h:114
KisCurveOption::m_category
KisPaintOpOption::PaintopCategory m_category
Definition: kis_curve_option.h:174
KisDynamicSensorSP
KisSharedPtr< KisDynamicSensor > KisDynamicSensorSP
Definition: kis_dynamic_sensor.h:55
DISTANCE
Definition: kis_dynamic_sensor.h:63
KisCurveOption::setCurveUsed
void setCurveUsed(bool useCurve)
Definition: kis_curve_option.cpp:329
XTILT
Definition: kis_dynamic_sensor.h:68
PRESSURE_IN
Definition: kis_dynamic_sensor.h:75
kis_dynamic_sensor_distance.h
QMap
KisCurveOption::isChecked
bool isChecked() const
Definition: kis_curve_option.cpp:319
SPEED
Definition: kis_dynamic_sensor.h:61
KisCurveOption::ValueComponents::sizeLikeValue
qreal sizeLikeValue() const
Definition: kis_curve_option.cpp:38
KisCurveOption::isRandom
bool isRandom() const
Definition: kis_curve_option.cpp:283
KisCurveOption::m_checked
bool m_checked
Definition: kis_curve_option.h:177
KisCurveOption::m_useCurve
bool m_useCurve
Definition: kis_curve_option.h:178
KisCurveOption::computeValueComponents
ValueComponents computeValueComponents(const KisPaintInformation &info) const
Uses the curves set on the sensors to compute a single double value that can control the parameters o...
Definition: kis_curve_option.cpp:395
QDomElement
KisCurveOption::isCheckable
bool isCheckable()
Definition: kis_curve_option.cpp:314
QDomNode::appendChild
QDomNode appendChild(const QDomNode &newChild)
KisCurveOption::ValueComponents::minSizeLikeValue
qreal minSizeLikeValue
Definition: kis_curve_option.h:121
KisCurveOption::emptyCurve
KisCubicCurve emptyCurve()
emptyCurve returns the simplest usable curve
Definition: kis_curve_option.cpp:486
KisCurveOption::isCurveUsed
bool isCurveUsed() const
Definition: kis_curve_option.cpp:289
KisCurveOption::activeSensors
QList< KisDynamicSensorSP > activeSensors() const
Definition: kis_curve_option.cpp:500
KisCurveOption::id2Sensor
virtual KisDynamicSensorSP id2Sensor(const KoID &id, const QString &parentOptionName)
Definition: kis_curve_option.cpp:589
KisDynamicSensorPerspective
Definition: kis_dynamic_sensors.h:109
KisCurveOption::ValueComponents::absoluteOffset
qreal absoluteOffset
Definition: kis_curve_option.h:117
PressureId
const KoID PressureId("pressure", ki18nc("Context: dynamic sensors", "Pressure"))
number depending on the pressure
FUZZY_PER_DAB
Definition: kis_dynamic_sensor.h:59
KisDynamicSensorTangentialPressure
Definition: kis_dynamic_sensors.h:119
kis_dynamic_sensor_fuzzy.h
QDomNode::nextSibling
QDomNode nextSibling() const
QList::begin
iterator begin()
DrawingAngleId
const KoID DrawingAngleId("drawingangle", ki18nc("Context: dynamic sensors", "Drawing angle"))
number depending on the angle
KisDynamicSensorTime
Definition: kis_dynamic_sensor_time.h:12
KisDynamicSensor::additiveToScaling
static qreal additiveToScaling(qreal x)
Definition: kis_dynamic_sensor.h:193
KisCurveOption::m_curveMode
int m_curveMode
Definition: kis_curve_option.h:188
KisCurveOption::ValueComponents::scaling
qreal scaling
Definition: kis_curve_option.h:115
TimeId
const KoID TimeId("time", ki18nc("Context: dynamic sensors", "Time"))
generate a number that increase with time
QDomDocument
TangentialPressureId
const KoID TangentialPressureId("tangentialpressure", ki18nc("Context: dynamic sensors", "Tangential pressure"))
the wheel on an airbrush device
TANGENTIAL_PRESSURE
Definition: kis_dynamic_sensor.h:73
QString::contains
bool contains(QChar ch, Qt::CaseSensitivity cs) const
QDomNode::isElement
bool isElement() const
KisDynamicSensorYTilt
Definition: kis_dynamic_sensors.h:79
KisCurveOption::lodLimitations
virtual void lodLimitations(KisPaintopLodLimitations *l) const
Definition: kis_curve_option.cpp:148
QList::end
iterator end()
KisCurveOption::ValueComponents::hasAbsoluteOffset
bool hasAbsoluteOffset
Definition: kis_curve_option.h:118
kis_dynamic_sensor_time.h
kis_dynamic_sensor_drawing_angle.h
KisCurveOption::setCommonCurve
void setCommonCurve(KisCubicCurve curve)
Sets the curve that is being used instead of sensor ones in case "Share curve across all settings" is...
Definition: kis_curve_option.cpp:344
KisDynamicSensorRotation
Definition: kis_dynamic_sensors.h:29
KisDynamicSensorTiltDirection
Definition: kis_dynamic_sensors.h:89
KisCurveOption::ValueComponents::rotationLikeValue
qreal rotationLikeValue(qreal normalizedBaseAngle, bool absoluteAxesFlipped, qreal scalingPartCoeff, bool disableScalingPart) const
Definition: kis_curve_option.cpp:21
XTiltId
const KoID XTiltId("xtilt", ki18nc("Context: dynamic sensors", "X-Tilt"))
number depending on X-tilt
KisCurveOption::setChecked
void setChecked(bool checked)
Definition: kis_curve_option.cpp:324
YTILT
Definition: kis_dynamic_sensor.h:69
FadeId
const KoID FadeId("fade", ki18nc("Context: dynamic sensors", "Fade"))
generate a number that increase every time you call it (e.g. per dab)
KisCurveOption::intMaxValue
virtual int intMaxValue() const
Definition: kis_curve_option.cpp:158
KisDynamicSensor::scalingToAdditive
static qreal scalingToAdditive(qreal x)
Definition: kis_dynamic_sensor.h:189
kis_dynamic_sensors.h
KisCurveOption::replaceSensor
void replaceSensor(KisDynamicSensorSP sensor)
Definition: kis_curve_option.cpp:261
KisCurveOption::valueSuffix
virtual QString valueSuffix() const
Definition: kis_curve_option.cpp:163
This file is part of the KDE documentation.
Documentation copyright © 1996-2021 The KDE developers.
Generated on Sat Apr 10 2021 23:38:28 by doxygen 1.8.16 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

plugins/paintops/libpaintop

Skip menu "plugins/paintops/libpaintop"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members

krita API Reference

Skip menu "krita API Reference"
  • libs
  •   KritaBasicFlakes
  •   brush
  •   KritaUndo2
  •   KritaFlake
  •   image
  •   KritaPlugin
  •   Krita
  •   KritaPigment
  •   KritaResources
  •   KritaStore
  •   ui
  •   KritaWidgets
  •   KritaWidgetUtils
  • plugins
  •   Assitants
  •   Extensions
  •   Filters
  •   Generators
  •   Formats
  •           src
  •   PaintOps
  •     libpaintop

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal