TRange.h
Go to the documentation of this file.
1 #ifndef istd_TRange_included
2 #define istd_TRange_included
3 
4 
5 // Qt includes
6 #include <QtCore/QtGlobal>
7 
8 
9 namespace istd
10 {
11 
12 
16 template <typename ValueType>
17 class TRange
18 {
19 public:
23  TRange();
27  TRange(const TRange& range);
28 
32  TRange(ValueType minValue, ValueType maxValue);
33 
37  bool IsValid() const;
38 
42  bool IsEmpty() const;
43 
47  bool IsValidNonEmpty() const;
48 
52  ValueType GetMinValue() const;
53 
57  ValueType& GetMinValueRef();
58 
62  void SetMinValue(ValueType minValue);
63 
67  ValueType GetMaxValue() const;
68 
72  ValueType& GetMaxValueRef();
73 
77  void SetMaxValue(ValueType maxValue);
78 
82  void Reset();
83 
88  ValueType GetLength() const;
89 
95  TRange GetValidated() const;
96 
102  void GetValidated(TRange& result) const;
103 
109  void Validate();
110 
115  bool Contains(ValueType value) const;
116 
120  bool Contains(const TRange& range) const;
121 
126  bool IsIntersectedBy(const TRange& range) const;
127 
131  bool IsOutsideOf(const TRange& range) const;
132 
137  TRange GetTranslated(ValueType offset) const;
138 
143  void Translate(ValueType offset);
144 
148  TRange GetIntersection(const TRange& range) const;
149 
153  void Intersection(const TRange& range);
154 
158  TRange GetUnion(const TRange& range) const;
159 
163  TRange GetUnion(double value) const;
164 
168  void Unite(const TRange& range);
169 
173  void Unite(double value);
174 
179  TRange GetExpanded(const TRange& range) const;
180 
185  void Expand(const TRange& range);
186 
191  ValueType GetDistance(ValueType value) const;
195  ValueType GetNearestInside(ValueType value) const;
196 
200  ValueType GetClipped(ValueType value) const;
201 
205  TRange GetClipped(const TRange& range) const;
206 
213  ValueType GetValueFromAlpha(double alpha) const;
214 
221  double GetAlphaFromValue(ValueType value) const;
222 
234  ValueType GetMappedTo(ValueType value, const TRange& range) const;
235 
240  TRange GetApply(const TRange& range) const;
241 
242  TRange GetInvertApply(const TRange& range) const;
243 
244  TRange GetInverted() const;
245 
249  void SetInterpolated(const TRange& first, const TRange& second, double alpha);
250 
251  TRange& operator=(const TRange& range);
252  bool operator==(const TRange& range) const;
253  bool operator!=(const TRange& range) const;
254  TRange operator*(double value) const;
255  TRange operator/(double value) const;
256  TRange& operator*=(double value);
257  TRange& operator/=(double value);
258 
259  // static methods
263  static const TRange& GetNull();
267  static const TRange& GetInvalid();
271  static TRange GetValid(ValueType value1, ValueType value2);
272 
273 private:
274  ValueType m_minValue;
275  ValueType m_maxValue;
276 
277  // static attributes
278  static TRange s_null;
279  static TRange s_invalid;
280 };
281 
282 
283 // public methods
284 
285 template <typename ValueType>
287  :m_minValue(0),
288  m_maxValue(0)
289 {
290 }
291 
292 
293 template <typename ValueType>
295  :m_minValue(range.m_minValue),
296  m_maxValue(range.m_maxValue)
297 {
298 }
299 
300 
301 template <typename ValueType>
302 TRange<ValueType>::TRange(ValueType minValue, ValueType maxValue)
303  :m_minValue(minValue),
304  m_maxValue(maxValue)
305 {
306 }
307 
308 
309 template <typename ValueType>
310 inline bool TRange<ValueType>::IsValid() const
311 {
312  return (m_minValue <= m_maxValue);
313 }
314 
315 
316 template <typename ValueType>
317 inline bool TRange<ValueType>::IsEmpty() const
318 {
319  return (m_minValue == m_maxValue);
320 }
321 
322 
323 template <typename ValueType>
325 {
326  return (m_minValue < m_maxValue);
327 }
328 
329 
330 template <typename ValueType>
331 inline ValueType TRange<ValueType>::GetMinValue() const
332 {
333  return m_minValue;
334 }
335 
336 
337 template <typename ValueType>
339 {
340  return m_minValue;
341 }
342 
343 
344 template <typename ValueType>
345 inline void TRange<ValueType>::SetMinValue(ValueType minValue)
346 {
347  m_minValue = minValue;
348 }
349 
350 
351 template <typename ValueType>
352 inline ValueType TRange<ValueType>::GetMaxValue() const
353 {
354  return m_maxValue;
355 }
356 
357 
358 template <typename ValueType>
360 {
361  return m_maxValue;
362 }
363 
364 
365 template <typename ValueType>
366 inline void TRange<ValueType>::SetMaxValue(ValueType maxValue)
367 {
368  m_maxValue = maxValue;
369 }
370 
371 
372 template <typename ValueType>
374 {
375  m_minValue = ValueType(0);
376  m_maxValue = ValueType(0);
377 }
378 
379 
380 template <typename ValueType>
381 inline ValueType TRange<ValueType>::GetLength() const
382 {
383  return IsValid()? m_maxValue - m_minValue: 0;
384 }
385 
386 
387 template <typename ValueType>
389 {
390  return TRange(
391  qMin(m_minValue, m_maxValue),
392  qMax(m_minValue, m_maxValue));
393 }
394 
395 
396 template <typename ValueType>
397 inline void TRange<ValueType>::GetValidated(TRange& result) const
398 {
399  result.SetMinValue(qMin(m_minValue, m_maxValue));
400  result.SetMaxValue(qMax(m_minValue, m_maxValue));
401 }
402 
403 
404 template <typename ValueType>
406 {
407  *this = TRange(qMin(m_minValue, m_maxValue), qMax(m_minValue, m_maxValue));
408 }
409 
410 
411 template <typename ValueType>
412 inline bool TRange<ValueType>::Contains(ValueType value) const
413 {
414  Q_ASSERT(IsValid());
415 
416  return (value >= m_minValue) && (value <= m_maxValue);
417 }
418 
419 
420 template <typename ValueType>
421 inline bool TRange<ValueType>::Contains(const TRange& range) const
422 {
423  Q_ASSERT(IsValid());
424  Q_ASSERT(range.IsValid());
425 
426  return (range.m_minValue >= m_minValue) && (range.m_maxValue <= m_maxValue);
427 }
428 
429 
430 template <typename ValueType>
431 inline bool TRange<ValueType>::IsIntersectedBy(const TRange& range) const
432 {
433  return (range.m_maxValue > m_minValue) && (range.m_minValue < m_maxValue);
434 }
435 
436 
437 template <typename ValueType>
438 inline bool TRange<ValueType>::IsOutsideOf(const TRange& range) const
439 {
440  return (range.m_maxValue <= m_minValue) || (range.m_minValue >= m_maxValue);
441 }
442 
443 
444 template <typename ValueType>
446 {
447  return TRange(m_minValue + offset, m_maxValue + offset);
448 }
449 
450 
451 template <typename ValueType>
452 inline void TRange<ValueType>::Translate(ValueType offset)
453 {
454  m_minValue += offset;
455  m_maxValue += offset;
456 }
457 
458 
459 template <typename ValueType>
461 {
462  if (IsEmpty()){
463  return *this;
464  }
465  else{
466  return TRange(qMax(m_minValue, range.m_minValue), qMin(m_maxValue, range.m_maxValue));
467  }
468 }
469 
470 
471 template <typename ValueType>
473 {
474  if (!IsEmpty()){
475  if (range.m_minValue > m_minValue){
476  m_minValue = range.m_minValue;
477  }
478 
479  if (range.m_maxValue < m_maxValue){
480  m_maxValue = range.m_maxValue;
481  }
482  }
483 }
484 
485 
486 template <typename ValueType>
488 {
489  if (range.IsValid()){
490  if (IsValid()){
491  return TRange(qMin(m_minValue, range.m_minValue), qMax(m_maxValue, range.m_maxValue));
492  }
493  else{
494  return range;
495  }
496  }
497  else{
498  return *this;
499  }
500 }
501 
502 
503 template <typename ValueType>
505 {
506  if (IsValid()){
507  return TRange(qMin(m_minValue, value), qMax(m_maxValue, value));
508  }
509  else{
510  return TRange(value, value);
511  }
512 }
513 
514 
515 template <typename ValueType>
517 {
518  if (range.IsValid()){
519  if (IsValid()){
520  if (range.m_minValue < m_minValue){
521  m_minValue = range.m_minValue;
522  }
523 
524  if (range.m_maxValue > m_maxValue){
525  m_maxValue = range.m_maxValue;
526  }
527  }
528  else{
529  *this = range;
530  }
531  }
532 }
533 
534 
535 template <typename ValueType>
536 void TRange<ValueType>::Unite(double value)
537 {
538  if (IsValid()){
539  if (value < m_minValue){
540  m_minValue = value;
541  }
542 
543  if (value > m_maxValue){
544  m_maxValue = value;
545  }
546  }
547  else{
548  m_minValue = value;
549  m_maxValue = value;
550  }
551 }
552 
553 
554 template <typename ValueType>
556 {
557  return TRange(m_minValue + range.m_minValue, m_maxValue + range.m_maxValue);
558 }
559 
560 
561 template <typename ValueType>
562 inline void TRange<ValueType>::Expand(const TRange& range)
563 {
564  m_minValue += range.m_minValue;
565  m_maxValue += range.m_maxValue;
566 }
567 
568 
569 template <typename ValueType>
570 inline ValueType TRange<ValueType>::GetDistance(ValueType value) const
571 {
572  if (value > m_maxValue){
573  return value - m_maxValue;
574  }
575 
576  if (value < m_minValue){
577  return m_minValue - value;
578  }
579 
580  return 0;
581 }
582 
583 
584 template <typename ValueType>
585 inline ValueType TRange<ValueType>::GetNearestInside(ValueType value) const
586 {
587  if (value > m_maxValue){
588  value = m_maxValue;
589  }
590 
591  if (value < m_minValue){
592  value = m_minValue;
593  }
594 
595  return value;
596 }
597 
598 
599 template <typename ValueType>
600 ValueType TRange<ValueType>::GetClipped(ValueType value) const
601 {
602  if (!Contains(value)){
603  ValueType distanceMin = (ValueType)qAbs(value - m_minValue);
604  ValueType distanceMax = (ValueType)qAbs(value - m_maxValue);
605 
606  return distanceMin < distanceMax ? m_minValue : m_maxValue;
607  }
608 
609  return value;
610 }
611 
612 
613 template <typename ValueType>
615 {
616  istd::TRange<ValueType> clippedRange = range;
617 
618  if (!Contains(range.GetMinValue())){
619  clippedRange.SetMinValue(m_minValue);
620  }
621 
622  if (!Contains(range.GetMaxValue())){
623  clippedRange.SetMaxValue(m_maxValue);
624  }
625 
626  return clippedRange;
627 }
628 
629 
630 template <typename ValueType>
631 inline ValueType TRange<ValueType>::GetValueFromAlpha(double alpha) const
632 {
633  return GetMinValue() + alpha * GetLength();
634 }
635 
636 
637 template <typename ValueType>
638 inline double TRange<ValueType>::GetAlphaFromValue(ValueType value) const
639 {
640  return (value - GetMinValue()) / GetLength();
641 }
642 
643 
644 template <typename ValueType>
645 inline ValueType TRange<ValueType>::GetMappedTo(ValueType value, const TRange& range) const
646 {
647  return ValueType(range.GetMinValue() + (value - GetMinValue()) * (range.GetLength() / GetLength()));
648 }
649 
650 
651 template <typename ValueType>
653 {
654  TRange result;
655  result.m_minValue = GetValueFromAlpha(range.m_minValue);
656  result.m_maxValue = GetValueFromAlpha(range.m_maxValue);
657 
658  return result;
659 }
660 
661 
662 template <typename ValueType>
664 {
665  TRange result;
666 
667  ValueType length = GetLength();
668  result.m_minValue = ValueType((range.m_minValue - m_minValue) / (double)length);
669  result.m_maxValue = ValueType((range.m_maxValue - m_minValue) / (double)length);
670 
671  return result;
672 }
673 
674 
675 template <typename ValueType>
677 {
678  TRange result;
679 
680  ValueType minusWidth = m_minValue - m_maxValue;
681  result.m_minValue = ValueType(m_minValue / (double)minusWidth);
682  result.m_maxValue = ValueType((m_minValue - 1) / (double)minusWidth);
683 
684  return result;
685 }
686 
687 
688 template <typename ValueType>
689 void TRange<ValueType>::SetInterpolated(const TRange& first, const TRange& second, double alpha)
690 {
691  double beta = 1 - alpha;
692 
693  m_minValue = ValueType(first.m_minValue * beta + second.m_minValue * alpha);
694  m_maxValue = ValueType(first.m_maxValue * beta + second.m_maxValue * alpha);
695 }
696 
697 
698 template <typename ValueType>
699 inline bool TRange<ValueType>::operator==(const TRange& range) const
700 {
701  return (m_maxValue == range.m_maxValue) && (m_minValue == range.m_minValue);
702 }
703 
704 
705 template <typename ValueType>
706 inline bool TRange<ValueType>::operator!=(const TRange& range) const
707 {
708  return (m_maxValue != range.m_maxValue) || (m_minValue != range.m_minValue);
709 }
710 
711 
712 
713 template <typename ValueType>
715 {
716  m_maxValue = range.m_maxValue;
717  m_minValue = range.m_minValue;
718 
719  return *this;
720 }
721 
722 
723 template <typename ValueType>
725 {
726  TRange result = *this;
727 
728  result.m_minValue *= value;
729  result.m_maxValue *= value;
730 
731  return result;
732 }
733 
734 
735 template <typename ValueType>
737 {
738  TRange result = *this;
739 
740  result.m_minValue /= value;
741  result.m_maxValue /= value;
742 
743  return result;
744 }
745 
746 
747 template <typename ValueType>
749 {
750  m_minValue *= value;
751  m_maxValue *= value;
752 
753  return this;
754 }
755 
756 
757 template <typename ValueType>
759 {
760  m_minValue /= value;
761  m_maxValue /= value;
762 
763  return this;
764 }
765 
766 
767 // static methods
768 
769 template <typename ValueType>
770 inline TRange<ValueType> TRange<ValueType>::GetValid(ValueType value1, ValueType value2)
771 {
772  return TRange(qMin(value1, value2), qMax(value1, value2));
773 }
774 
775 
776 // static methods
777 
778 template <typename ValueType>
780 {
781  return s_null;
782 }
783 
784 
785 template <typename ValueType>
787 {
788  return s_invalid;
789 }
790 
791 
792 // static attributes
793 
794 template <typename ValueType>
796 
797 template <typename ValueType>
799 
800 
801 // typedefs
802 
805 
806 
807 } // namespace istd
808 
809 
810 #endif // !istd_TRange_included
811 
812 
ValueType GetClipped(ValueType value) const
Get value clipped to the range.
Definition: TRange.h:600
static const TRange & GetInvalid()
Return invalid range.
Definition: TRange.h:786
TRange GetTranslated(ValueType offset) const
Get translated position range.
Definition: TRange.h:445
ValueType GetLength() const
Get length of this range.
Definition: TRange.h:381
bool operator==(const TRange &range) const
Definition: TRange.h:699
void Expand(const TRange &range)
Set this range to be expanded.
Definition: TRange.h:562
TRange operator/(double value) const
Definition: TRange.h:736
istd::TRange< int > CIntRange
Definition: TRange.h:804
TRange GetUnion(const TRange &range) const
Get union with the second range.
Definition: TRange.h:487
TRange GetInverted() const
Definition: TRange.h:676
bool IsEmpty() const
Return true if the bottom value is equal to the top value.
Definition: TRange.h:317
ValueType GetMaxValue() const
Get the top value.
Definition: TRange.h:352
bool IsValidNonEmpty() const
Return true if the range is valid and it is not empty.
Definition: TRange.h:324
TRange GetApply(const TRange &range) const
Get a combined range.
Definition: TRange.h:652
ValueType GetMappedTo(ValueType value, const TRange &range) const
Returns the value, that corresponds the input value inputValue in the other range range...
Definition: TRange.h:645
ValueType GetValueFromAlpha(double alpha) const
Get value based on 'alpha' factor.
Definition: TRange.h:631
bool Contains(ValueType value) const
Returns true, if value is in range between top and bottom.
Definition: TRange.h:412
static const TRange & GetNull()
Return null range.
Definition: TRange.h:779
void Reset()
Set this range to be empty.
Definition: TRange.h:373
TRange GetValidated() const
Get validated range, if it was invalid.
Definition: TRange.h:388
TRange GetExpanded(const TRange &range) const
Get expanded range using the second range.
Definition: TRange.h:555
ValueType GetDistance(ValueType value) const
Get distance from value to range.
Definition: TRange.h:570
TRange & operator=(const TRange &range)
Definition: TRange.h:714
bool operator!=(const TRange &range) const
Definition: TRange.h:706
bool IsValid() const
Return true if the bottom value is smaller or equal then the top value.
Definition: TRange.h:310
void SetMaxValue(ValueType maxValue)
Set the top value.
Definition: TRange.h:366
TRange operator*(double value) const
Definition: TRange.h:724
void Intersection(const TRange &range)
Set this range to be intersection of two ranges.
Definition: TRange.h:472
TRange GetInvertApply(const TRange &range) const
Definition: TRange.h:663
Implementation of a abstract range defined by two values - minimum and maximum.
Definition: TRange.h:17
TRange()
Constructs an empty range object.
Definition: TRange.h:286
TRange & operator*=(double value)
Definition: TRange.h:748
bool IsIntersectedBy(const TRange &range) const
Check if this range is intersected by other range.
Definition: TRange.h:431
void SetInterpolated(const TRange &first, const TRange &second, double alpha)
Set this range to be linear interpolated using two other ranges and adjast alpha value.
Definition: TRange.h:689
TRange GetIntersection(const TRange &range) const
Get intersection with the second range.
Definition: TRange.h:460
void Unite(const TRange &range)
Set this range to be union of two ranges.
Definition: TRange.h:516
void Translate(ValueType offset)
Translated position of this range.
Definition: TRange.h:452
bool IsOutsideOf(const TRange &range) const
Check if this range is outside of the given range.
Definition: TRange.h:438
TRange & operator/=(double value)
Definition: TRange.h:758
void SetMinValue(ValueType minValue)
Set the bottom value.
Definition: TRange.h:345
static TRange GetValid(ValueType value1, ValueType value2)
Return always valid range.
Definition: TRange.h:770
ValueType & GetMaxValueRef()
Get reference to the top value.
Definition: TRange.h:359
double GetAlphaFromValue(ValueType value) const
Get value based on 'alpha' factor.
Definition: TRange.h:638
void Validate()
Force this range to be valid.
Definition: TRange.h:405
ValueType & GetMinValueRef()
Get reference to the bottom value.
Definition: TRange.h:338
ValueType GetNearestInside(ValueType value) const
Get nearest value belonging to range.
Definition: TRange.h:585
ValueType GetMinValue() const
Get the bottom value.
Definition: TRange.h:331
istd::TRange< double > CRange
Definition: TRange.h:803

© 2007-2017 Witold Gantzke and Kirill Lepskiy