0032437: Coding Rules - eliminate MinGW warning -Wmaybe-uninitialized
[occt.git] / src / AIS / AIS_ColorScale.cxx
1 // Created on: 2015-02-03
2 // Copyright (c) 2015 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #include <AIS_ColorScale.hxx>
16
17 #include <AIS_InteractiveContext.hxx>
18 #include <Aspect_TypeOfColorScaleData.hxx>
19 #include <Aspect_TypeOfColorScalePosition.hxx>
20 #include <Aspect_Window.hxx>
21 #include <Geom_Line.hxx>
22 #include <GeomAdaptor_Curve.hxx>
23 #include <Graphic3d_ArrayOfPolygons.hxx>
24 #include <Graphic3d_ArrayOfPolylines.hxx>
25 #include <Graphic3d_AspectFillArea3d.hxx>
26 #include <Graphic3d_AspectText3d.hxx>
27 #include <Graphic3d_GraphicDriver.hxx>
28 #include <Graphic3d_ArrayOfTriangles.hxx>
29 #include <Graphic3d_Text.hxx>
30 #include <Prs3d_LineAspect.hxx>
31 #include <Prs3d_ShadingAspect.hxx>
32 #include <Prs3d_Text.hxx>
33 #include <Prs3d_TextAspect.hxx>
34 #include <SelectMgr_EntityOwner.hxx>
35 #include <SelectMgr_Selection.hxx>
36 #include <Select3D_SensitiveBox.hxx>
37 #include <Select3D_SensitiveSegment.hxx>
38 #include <StdPrs_Curve.hxx>
39 #include <V3d_Viewer.hxx>
40 #include <V3d_View.hxx>
41
42 IMPLEMENT_STANDARD_RTTIEXT(AIS_ColorScale, AIS_InteractiveObject)
43
44 namespace
45 {
46   //! Method to add colored quad into array of triangles.
47   static void addColoredQuad (const Handle(Graphic3d_ArrayOfTriangles)& theTris,
48                               const Standard_Integer theXLeft, const Standard_Integer theYBottom,
49                               const Standard_Integer theSizeX, const Standard_Integer theSizeY,
50                               const Quantity_Color& theColorBottom,
51                               const Quantity_Color& theColorTop)
52   {
53     const Standard_Integer aVertIndex = theTris->VertexNumber() + 1;
54     theTris->AddVertex (gp_Pnt (theXLeft,            theYBottom,            0.0), theColorBottom);
55     theTris->AddVertex (gp_Pnt (theXLeft + theSizeX, theYBottom,            0.0), theColorBottom);
56     theTris->AddVertex (gp_Pnt (theXLeft,            theYBottom + theSizeY, 0.0), theColorTop);
57     theTris->AddVertex (gp_Pnt (theXLeft + theSizeX, theYBottom + theSizeY, 0.0), theColorTop);
58     theTris->AddEdges (aVertIndex,     aVertIndex + 1, aVertIndex + 2);
59     theTris->AddEdges (aVertIndex + 1, aVertIndex + 2, aVertIndex + 3);
60   }
61
62   //! Compute hue angle from specified value.
63   static Quantity_Color colorFromValueEx (const Standard_Real theValue,
64                                           const Standard_Real theMin,
65                                           const Standard_Real theMax,
66                                           const Graphic3d_Vec3d& theHlsMin,
67                                           const Graphic3d_Vec3d& theHlsMax)
68   {
69     const Standard_Real aValueDelta = theMax - theMin;
70     Standard_Real aValue = 0.0;
71     if (aValueDelta != 0.0)
72     {
73       aValue = (theValue - theMin) / aValueDelta;
74     }
75
76     Standard_Real aHue        = NCollection_Lerp<Standard_Real>::Interpolate (theHlsMin[0], theHlsMax[0], aValue);
77     Standard_Real aLightness  = NCollection_Lerp<Standard_Real>::Interpolate (theHlsMin[1], theHlsMax[1], aValue);
78     Standard_Real aSaturation = NCollection_Lerp<Standard_Real>::Interpolate (theHlsMin[2], theHlsMax[2], aValue);
79     return Quantity_Color (AIS_ColorScale::hueToValidRange (aHue), aLightness, aSaturation, Quantity_TOC_HLS);
80   }
81
82   //! Return the index of discrete interval for specified value.
83   //! Note that when value lies exactly on the border between two intervals,
84   //! determining which interval to return is undefined operation;
85   //! Current implementation returns the following interval in this case.
86   //! @param theValue [in] value to map
87   //! @param theMin   [in] values range, lower value
88   //! @param theMax   [in] values range, upper value
89   //! @param theNbIntervals [in] number of discrete intervals
90   //! @return index of interval within [1, theNbIntervals] range
91   static Standard_Integer colorDiscreteInterval (Standard_Real theValue,
92                                                  Standard_Real theMin,
93                                                  Standard_Real theMax,
94                                                  Standard_Integer theNbIntervals)
95   {
96     if (Abs (theMax - theMin) <= Precision::Approximation())
97     {
98       return 1;
99     }
100
101     Standard_Integer anInterval = 1 + (Standard_Integer )Floor (Standard_Real (theNbIntervals) * (theValue - theMin) / (theMax - theMin));
102     // map the very upper value (theValue==theMax) to the largest color interval
103     anInterval = Min (anInterval, theNbIntervals);
104     return anInterval;
105   }
106 }
107
108 //=======================================================================
109 //function : AIS_ColorScale
110 //purpose  :
111 //=======================================================================
112 AIS_ColorScale::AIS_ColorScale()
113 : myMin (0.0),
114   myMax (1.0),
115   myColorHlsMin (230.0, 1.0, 1.0),
116   myColorHlsMax (0.0,   1.0, 1.0),
117   myFormat ("%.4g"),
118   myNbIntervals (10),
119   myColorType (Aspect_TOCSD_AUTO),
120   myLabelType (Aspect_TOCSD_AUTO),
121   myIsLabelAtBorder (Standard_True),
122   myIsReversed (Standard_False),
123   myIsLogarithmic (Standard_False),
124   myIsSmooth (Standard_False),
125   myLabelPos (Aspect_TOCSP_RIGHT),
126   myTitlePos (Aspect_TOCSP_LEFT),
127   myXPos (0),
128   myYPos (0),
129   myBreadth (0),
130   myHeight  (0),
131   mySpacing (5),
132   myTextHeight (20)
133 {
134   SetDisplayMode (0);
135   myDrawer->SetupOwnShadingAspect();
136   myDrawer->ShadingAspect()->Aspect()->SetShadingModel (Graphic3d_TOSM_UNLIT);
137   myDrawer->ShadingAspect()->Aspect()->SetAlphaMode (Graphic3d_AlphaMode_Opaque);
138   myDrawer->ShadingAspect()->Aspect()->SetInteriorColor (Quantity_NOC_WHITE);
139 }
140
141 //=======================================================================
142 //function : GetLabel
143 //purpose  :
144 //=======================================================================
145 TCollection_ExtendedString AIS_ColorScale::GetLabel (const Standard_Integer theIndex) const
146 {
147   if (myLabelType == Aspect_TOCSD_USER)
148   {
149     if (theIndex >= myLabels.Lower()
150      || theIndex <= myLabels.Upper())
151     {
152       return myLabels.Value(theIndex);
153     }
154     return TCollection_ExtendedString();
155   }
156
157   // value to be shown depends on label position
158   const Standard_Real aVal = myIsLabelAtBorder
159                            ? GetIntervalValue (theIndex - 1)
160                            : (0.5 * (GetIntervalValue (theIndex - 1) + GetIntervalValue (theIndex)));
161
162   char aBuf[1024];
163   sprintf (aBuf, myFormat.ToCString(), aVal);
164   return TCollection_ExtendedString (aBuf);
165 }
166
167 //=======================================================================
168 //function : GetIntervalColor
169 //purpose  :
170 //=======================================================================
171 Quantity_Color AIS_ColorScale::GetIntervalColor (const Standard_Integer theIndex) const
172 {
173   if (myColorType== Aspect_TOCSD_USER)
174   {
175     if (theIndex <= 0 || theIndex > myColors.Length())
176     {
177       return Quantity_Color();
178     }
179     return myColors.Value (theIndex);
180   }
181
182   return colorFromValue (theIndex - 1, 0, myNbIntervals - 1);
183 }
184
185 //=======================================================================
186 //function : GetLabels
187 //purpose  :
188 //=======================================================================
189 void AIS_ColorScale::GetLabels (TColStd_SequenceOfExtendedString& theLabels) const
190 {
191   theLabels.Clear();
192   for (TColStd_SequenceOfExtendedString::Iterator aLabIter (myLabels); aLabIter.More(); aLabIter.Next())
193   {
194     theLabels.Append (aLabIter.Value());
195   }
196 }
197
198 //=======================================================================
199 //function : GetColors
200 //purpose  :
201 //=======================================================================
202 void AIS_ColorScale::GetColors (Aspect_SequenceOfColor& theColors) const
203 {
204   theColors.Clear();
205   for (Aspect_SequenceOfColor::Iterator aColorIter (myColors); aColorIter.More(); aColorIter.Next())
206   {
207     theColors.Append (aColorIter.Value());
208   }
209 }
210
211 //=======================================================================
212 //function : SetRange
213 //purpose  :
214 //=======================================================================
215 void AIS_ColorScale::SetRange (const Standard_Real theMin, const Standard_Real theMax)
216 {
217   myMin = Min (theMin, theMax);
218   myMax = Max (theMin, theMax);
219 }
220
221 //=======================================================================
222 //function : SetNumberOfIntervals
223 //purpose  :
224 //=======================================================================
225 void AIS_ColorScale::SetNumberOfIntervals (const Standard_Integer theNum)
226 {
227   if (theNum < 1)
228   {
229     return;
230   }
231
232   myNbIntervals = theNum;
233 }
234
235 //=======================================================================
236 //function : SetLabel
237 //purpose  :
238 //=======================================================================
239 void AIS_ColorScale::SetLabel (const TCollection_ExtendedString& theLabel,
240                                const Standard_Integer theIndex)
241 {
242   const Standard_Integer aLabIndex = (theIndex <= 0 ? myLabels.Length() + 1 : theIndex);
243   while (myLabels.Length() < aLabIndex)
244   {
245     myLabels.Append (TCollection_ExtendedString());
246   }
247   myLabels.SetValue (aLabIndex, theLabel);
248 }
249
250 //=======================================================================
251 //function : SetIntervalColor
252 //purpose  :
253 //=======================================================================
254 void AIS_ColorScale::SetIntervalColor (const Quantity_Color&  theColor,
255                                        const Standard_Integer theIndex)
256 {
257   const Standard_Integer aColorIndex = (theIndex <= 0 ? myColors.Length() + 1 : theIndex);
258   while (myColors.Length() < aColorIndex)
259   {
260     myColors.Append (Quantity_Color());
261   }
262   myColors.SetValue (aColorIndex, theColor);
263 }
264
265 //=======================================================================
266 //function : SetLabels
267 //purpose  :
268 //=======================================================================
269 void AIS_ColorScale::SetLabels (const TColStd_SequenceOfExtendedString& theSeq)
270 {
271   myLabels.Clear();
272   for (TColStd_SequenceOfExtendedString::Iterator aLabIter (theSeq); aLabIter.More(); aLabIter.Next())
273   {
274     myLabels.Append (aLabIter.Value());
275   }
276 }
277
278 //=======================================================================
279 //function : SetColors
280 //purpose  :
281 //=======================================================================
282 void AIS_ColorScale::SetColors (const Aspect_SequenceOfColor& theSeq)
283 {
284   myColors.Clear();
285   for (Aspect_SequenceOfColor::Iterator aColorIter (theSeq); aColorIter.More(); aColorIter.Next())
286   {
287     myColors.Append (aColorIter.Value());
288   }
289 }
290
291 //=======================================================================
292 //function : MakeUniformColors
293 //purpose  :
294 //=======================================================================
295 Aspect_SequenceOfColor AIS_ColorScale::MakeUniformColors (Standard_Integer theNbColors, 
296                                                           Standard_Real theLightness,
297                                                           Standard_Real theHueFrom,
298                                                           Standard_Real theHueTo)
299 {
300   Aspect_SequenceOfColor aResult;
301
302   // adjust range to be within (0, 360], with sign according to theHueFrom and theHueTo 
303   Standard_Real aHueRange = std::fmod (theHueTo - theHueFrom, 360.);
304   const Standard_Real aHueEps = Precision::Angular() * 180. / M_PI;
305   if (Abs (aHueRange) <= aHueEps)
306   {
307     aHueRange = (aHueRange < 0 ? -360. : 360.);
308   }
309
310   // treat limit cases
311   if (theNbColors < 1)
312   {
313     return aResult;
314   }
315   if (theNbColors == 1)
316   {
317     Standard_Real aHue = std::fmod (theHueFrom, 360.);
318     if (aHue < 0.)
319     {
320       aHue += 360.;
321     }
322     Quantity_Color aColor (theLightness, 130., aHue, Quantity_TOC_CIELch);
323     aResult.Append (aColor);
324     return aResult;
325   }
326
327   // discretize the range with 1 degree step
328   const int NBCOLORS = 2 + (int)Abs (aHueRange / 1.);
329   Standard_Real aHueStep = aHueRange / (NBCOLORS - 1);
330   NCollection_Array1<Quantity_Color> aGrid (0, NBCOLORS - 1);
331   for (Standard_Integer i = 0; i < NBCOLORS; i++)
332   {
333     Standard_Real aHue = std::fmod (theHueFrom + i * aHueStep, 360.);
334     if (aHue < 0.)
335     {
336       aHue += 360.;
337     }
338     aGrid(i).SetValues (theLightness, 130., aHue, Quantity_TOC_CIELch);
339   }
340
341   // and compute distances between each two colors in a grid
342   TColStd_Array1OfReal aMetric (0, NBCOLORS - 1);
343   Standard_Real aLength = 0.;
344   for (Standard_Integer i = 0, j = NBCOLORS - 1; i < NBCOLORS; j = i++)
345   {
346     aLength += (aMetric(i) = aGrid(i).DeltaE2000 (aGrid(j)));
347   }
348
349   // determine desired step by distance;
350   // normally we aim to distribute colors from start to end
351   // of the range, but if distance between first and last points of the range
352   // is less than that step (e.g. range is full 360 deg),
353   // then distribute by the whole 360 deg scope to ensure that first
354   // and last colors are sufficiently distanced
355   Standard_Real aDStep = (aLength - aMetric.First()) / (theNbColors - 1);
356   if (aMetric.First() < aDStep)
357   {
358     aDStep = aLength / theNbColors;
359   }
360
361   // generate sequence
362   aResult.Append(aGrid(0));
363   Standard_Real aParam = 0., aPrev = 0., aTarget = aDStep;
364   for (int i = 1; i < NBCOLORS; i++)
365   {
366     aParam = aPrev + aMetric(i);
367     while (aTarget <= aParam)
368     {
369       float aCoefPrev = float((aParam - aTarget) / (aParam - aPrev));
370       float aCoefCurr = float((aTarget - aPrev) / (aParam - aPrev));
371       Quantity_Color aColor (aGrid(i).Rgb() * aCoefCurr + aGrid(i-1).Rgb() * aCoefPrev);
372       aResult.Append (aColor);
373       aTarget += aDStep;
374     }
375     aPrev = aParam;
376   }
377   if (aResult.Length() < theNbColors)
378   {
379     aResult.Append (aGrid.Last());
380   }
381   Standard_ASSERT_VOID (aResult.Length() == theNbColors, "Failed to generate requested nb of colors");
382   return aResult;
383 }
384
385 //=======================================================================
386 //function : SizeHint
387 //purpose  :
388 //=======================================================================
389 void AIS_ColorScale::SizeHint (Standard_Integer& theWidth, Standard_Integer& theHeight) const
390 {
391   const Standard_Integer aTextHeight = TextHeight ("");
392   const Standard_Integer aColorWidth = 20;
393   Standard_Integer aTextWidth = 0;
394   if (myLabelPos != Aspect_TOCSP_NONE)
395   {
396     for (Standard_Integer aLabIter = (myIsLabelAtBorder ? 0 : 1); aLabIter <= myNbIntervals; ++aLabIter)
397     {
398       aTextWidth = Max (aTextWidth, TextWidth (GetLabel (aLabIter)));
399     }
400   }
401
402   const Standard_Integer aScaleWidth  = aColorWidth + aTextWidth + (aTextWidth ? 3 : 2) * mySpacing;
403   const Standard_Integer aScaleHeight = (Standard_Integer)(1.5 * (myNbIntervals + (myIsLabelAtBorder ? 2 : 1)) * aTextHeight);
404
405   Standard_Integer aTitleWidth  = 0;
406   Standard_Integer aTitleHeight = 0;
407   if (!myTitle.IsEmpty())
408   {
409     aTitleHeight = TextHeight (myTitle) + mySpacing;
410     aTitleWidth =  TextWidth  (myTitle) + mySpacing * 2;
411   }
412
413   theWidth  = Max (aTitleWidth, aScaleWidth);
414   theHeight = aScaleHeight + aTitleHeight;
415 }
416
417 //=======================================================================
418 //function : GetIntervalValue
419 //purpose  :
420 //=======================================================================
421 Standard_Real AIS_ColorScale::GetIntervalValue (const Standard_Integer theIndex) const
422 {
423   if (myNbIntervals <= 0)
424   {
425     return 0.0;
426   }
427
428   if (IsLogarithmic())
429   {
430     Standard_Real aMin     = myMin > 0 ? myMin : 1.0;
431     Standard_Real aDivisor = std::pow (myMax / aMin, 1.0 / myNbIntervals);
432     return aMin * std::pow (aDivisor,theIndex);
433   }
434
435   Standard_Real aNum = 0;
436   if (myNbIntervals > 0)
437   {
438     aNum = GetMin() + theIndex * (Abs (GetMax() - GetMin()) / myNbIntervals);
439   }
440   return aNum;
441 }
442
443 //=======================================================================
444 //function : colorFromValue
445 //purpose  :
446 //=======================================================================
447 Quantity_Color AIS_ColorScale::colorFromValue (const Standard_Real theValue,
448                                                const Standard_Real theMin,
449                                                const Standard_Real theMax) const
450 {
451   return colorFromValueEx (theValue, theMin, theMax, myColorHlsMin, myColorHlsMax);
452 }
453
454 //=======================================================================
455 //function : FindColor
456 //purpose  :
457 //=======================================================================
458 Standard_Boolean AIS_ColorScale::FindColor (const Standard_Real theValue,
459                                             Quantity_Color& theColor) const
460 {
461   if (theValue < myMin || theValue > myMax || myMax < myMin)
462   {
463     theColor = Quantity_Color();
464     return Standard_False;
465   }
466
467   if (myColorType == Aspect_TOCSD_USER)
468   {
469     const Standard_Integer anInterval = colorDiscreteInterval (theValue, myMin, myMax, myNbIntervals);
470     if (anInterval < myColors.Lower() || anInterval > myColors.Upper())
471     {
472       theColor = Quantity_Color();
473       return Standard_False;
474     }
475
476     theColor = myColors.Value (anInterval);
477     return Standard_True;
478   }
479
480   return FindColor (theValue, myMin, myMax, myNbIntervals, theColor);
481 }
482
483 //=======================================================================
484 //function : FindColor
485 //purpose  :
486 //=======================================================================
487 Standard_Boolean AIS_ColorScale::FindColor (const Standard_Real theValue,
488                                             const Standard_Real theMin,
489                                             const Standard_Real theMax,
490                                             const Standard_Integer theColorsCount,
491                                             const Graphic3d_Vec3d& theColorHlsMin,
492                                             const Graphic3d_Vec3d& theColorHlsMax,
493                                             Quantity_Color& theColor)
494 {
495   if (theValue < theMin || theValue > theMax || theMax < theMin)
496   {
497     return Standard_False;
498   }
499
500   const Standard_Integer anInterval = colorDiscreteInterval (theValue, theMin, theMax, theColorsCount);
501   theColor = colorFromValueEx (anInterval - 1, 0, theColorsCount - 1, theColorHlsMin, theColorHlsMax);
502   return Standard_True;
503 }
504
505 //=======================================================================
506 //function : computeMaxLabelWidth
507 //purpose  :
508 //=======================================================================
509 Standard_Integer AIS_ColorScale::computeMaxLabelWidth (const TColStd_SequenceOfExtendedString& theLabels) const
510 {
511   Standard_Integer aWidthMax = 0;
512   for (TColStd_SequenceOfExtendedString::Iterator aLabIter (theLabels); aLabIter.More(); aLabIter.Next())
513   {
514     if (!aLabIter.Value().IsEmpty())
515     {
516       aWidthMax = Max (aWidthMax, TextWidth (aLabIter.Value()));
517     }
518   }
519   return aWidthMax;
520 }
521
522 //=======================================================================
523 //function : updateTextAspect
524 //purpose  :
525 //=======================================================================
526 void AIS_ColorScale::updateTextAspect()
527 {
528   // update text aspect
529   const Quantity_Color aFgColor (hasOwnColor ? myDrawer->Color() : Quantity_NOC_WHITE);
530   if (!myDrawer->HasOwnTextAspect())
531   {
532     myDrawer->SetTextAspect (new Prs3d_TextAspect());
533     *myDrawer->TextAspect()->Aspect() = *myDrawer->Link()->TextAspect()->Aspect();
534   }
535
536   const Handle(Prs3d_TextAspect)& anAspect = myDrawer->TextAspect();
537   anAspect->SetColor  (aFgColor);
538   anAspect->SetHeight (myTextHeight);
539   anAspect->SetHorizontalJustification (Graphic3d_HTA_LEFT);
540   anAspect->SetVerticalJustification (Graphic3d_VTA_BOTTOM);
541   anAspect->Aspect()->SetTextZoomable (Standard_True);
542 }
543
544 //=======================================================================
545 //function : Compute
546 //purpose  :
547 //=======================================================================
548 void AIS_ColorScale::Compute (const Handle(PrsMgr_PresentationManager)& ,
549                               const Handle(Prs3d_Presentation)& thePrs,
550                               const Standard_Integer theMode)
551 {
552   if (theMode != 0)
553   {
554     return;
555   }
556
557   // update text aspect
558   updateTextAspect();
559
560   const Standard_Integer aTitleOffset = !myTitle.IsEmpty() ? (myTextHeight + mySpacing) : 0;
561
562   const Standard_Integer aBarYOffset = myTextHeight / 2 + 2 * mySpacing; // a half-label offset
563   const Standard_Integer aBarBottom  = myYPos + aBarYOffset;
564   const Standard_Integer aBarTop     = myYPos + myHeight - aTitleOffset - aBarYOffset;
565   const Standard_Integer aBarHeight  = aBarTop - aBarBottom;
566
567   TColStd_SequenceOfExtendedString aLabels;
568   if (myLabelType == Aspect_TOCSD_USER)
569   {
570     aLabels = myLabels;
571   }
572   else
573   {
574     const Standard_Integer aNbLabels = myIsLabelAtBorder ? myNbIntervals + 1 : myNbIntervals;
575     for (Standard_Integer aLabIter = 1; aLabIter <= aNbLabels; ++aLabIter)
576     {
577       if (myIsReversed)
578       {
579         aLabels.Prepend (GetLabel (aLabIter));
580       }
581       else
582       {
583         aLabels.Append (GetLabel (aLabIter));
584       }
585     }
586   }
587
588   const Standard_Integer aTextWidth = myLabelPos != Aspect_TOCSP_NONE ? computeMaxLabelWidth (aLabels) : 0;
589   Standard_Integer aColorBreadth = Max (5, Min (20, myBreadth - aTextWidth - 3 * mySpacing));
590   if (myLabelPos == Aspect_TOCSP_CENTER
591    || myLabelPos == Aspect_TOCSP_NONE)
592   {
593     aColorBreadth += aTextWidth;
594   }
595
596   // draw title
597   Handle(Graphic3d_Group) aLabelsGroup;
598   if (!myTitle.IsEmpty()
599    || !aLabels.IsEmpty())
600   {
601     aLabelsGroup = thePrs->NewGroup();
602     aLabelsGroup->SetGroupPrimitivesAspect (myDrawer->TextAspect()->Aspect());
603   }
604   if (!myTitle.IsEmpty())
605   {
606     drawText (aLabelsGroup, myTitle,
607               myXPos + mySpacing,
608               aBarTop + aBarYOffset,
609               Graphic3d_VTA_BOTTOM);
610   }
611
612   // draw colors
613   drawColorBar (thePrs, aBarBottom, aBarHeight, aTextWidth, aColorBreadth);
614
615   // draw Labels
616   drawLabels (aLabelsGroup, aLabels, aBarBottom, aBarHeight, aTextWidth, aColorBreadth);
617 }
618
619 //=======================================================================
620 //function : drawColorBar
621 //purpose  :
622 //=======================================================================
623 void AIS_ColorScale::drawColorBar (const Handle(Prs3d_Presentation)& thePrs,
624                                    const Standard_Integer theBarBottom,
625                                    const Standard_Integer theBarHeight,
626                                    const Standard_Integer theMaxLabelWidth,
627                                    const Standard_Integer theColorBreadth)
628 {
629   const Standard_Real aStepY = Standard_Real(theBarHeight) / Standard_Real(myNbIntervals);
630   if (aStepY <= 0.0)
631   {
632     return;
633   }
634
635   // Draw colors
636   const Standard_Integer anXLeft = myLabelPos == Aspect_TOCSP_LEFT
637                                  ? myXPos + mySpacing + theMaxLabelWidth + (theMaxLabelWidth != 0 ? 1 : 0) * mySpacing
638                                  : myXPos + mySpacing;
639
640   Aspect_SequenceOfColor aColors;
641   for (Standard_Integer anIntervalIter = 1; anIntervalIter <= myNbIntervals; ++anIntervalIter)
642   {
643     if (myIsReversed)
644     {
645       aColors.Prepend (GetIntervalColor (anIntervalIter));
646     }
647     else
648     {
649       aColors.Append (GetIntervalColor (anIntervalIter));
650     }
651   }
652
653   Handle(Graphic3d_ArrayOfTriangles) aTriangles;
654   if (myIsSmooth
655    && myColorType == Aspect_TOCSD_USER)
656   {
657     // Smooth custom intervals, so that the color in the center of interval is equal to specified one
658     // (thus the halves of first and last intervals have solid color)
659     aTriangles = new Graphic3d_ArrayOfTriangles ((aColors.Length() + 1) * 4,     // quads
660                                                  (aColors.Length() + 1) * 2 * 3, // quads as triangles
661                                                  false, true);                   // per-vertex colors
662     Quantity_Color aColor1 (aColors.Value (1)), aColor2;
663     Standard_Integer       aSizeY        = Standard_Integer(aStepY / 2);
664     const Standard_Integer anYBottom     = theBarBottom + aSizeY;
665     Standard_Integer       anYBottomIter = anYBottom;
666     addColoredQuad (aTriangles,
667                     anXLeft, theBarBottom,
668                     theColorBreadth, aSizeY,
669                     aColor1, aColor1);
670     for (Standard_Integer aColorIter = 0; aColorIter < myNbIntervals - 1; ++aColorIter)
671     {
672       aColor1 = aColors.Value (aColorIter + 1);
673       aColor2 = aColors.Value (aColorIter + 2);
674       aSizeY  = anYBottom + Standard_Integer((aColorIter + 1) * aStepY) - anYBottomIter;
675       addColoredQuad (aTriangles,
676                       anXLeft, anYBottomIter,
677                       theColorBreadth, aSizeY,
678                       aColor1, aColor2);
679       anYBottomIter += aSizeY;
680     }
681     aColor2 = aColors.Value (myNbIntervals);
682     aSizeY  = theBarBottom + theBarHeight - anYBottomIter;
683     addColoredQuad (aTriangles,
684                     anXLeft, anYBottomIter,
685                     theColorBreadth, aSizeY,
686                     aColor2, aColor2);
687   }
688   else if (myIsSmooth)
689   {
690     // smooth transition between standard colors - without solid color regions at the beginning and end of full color range
691     const Quantity_Color aColorsFixed[5] =
692     {
693       colorFromValue (0, 0, 4),
694       colorFromValue (1, 0, 4),
695       colorFromValue (2, 0, 4),
696       colorFromValue (3, 0, 4),
697       colorFromValue (4, 0, 4)
698     };
699     aTriangles = new Graphic3d_ArrayOfTriangles (4 * 4,        // quads
700                                                  4 * 2 * 3,    // quads as triangles
701                                                  false, true); // per-vertex colors
702     Standard_Integer anYBottomIter = theBarBottom;
703     addColoredQuad (aTriangles,
704                     anXLeft, theBarBottom,
705                     theColorBreadth, theBarHeight / 4,
706                     aColorsFixed[0], aColorsFixed[1]);
707     anYBottomIter += theBarHeight / 4;
708     addColoredQuad (aTriangles,
709                     anXLeft, anYBottomIter,
710                     theColorBreadth, theBarHeight / 4,
711                     aColorsFixed[1], aColorsFixed[2]);
712     anYBottomIter += theBarHeight / 4;
713     addColoredQuad (aTriangles,
714                     anXLeft, anYBottomIter,
715                     theColorBreadth, theBarHeight / 4,
716                     aColorsFixed[2], aColorsFixed[3]);
717     anYBottomIter += theBarHeight / 4;
718     const Standard_Integer aLastSizeY  = theBarBottom + theBarHeight - anYBottomIter;
719     addColoredQuad (aTriangles,
720                     anXLeft, anYBottomIter,
721                     theColorBreadth, aLastSizeY,
722                     aColorsFixed[3], aColorsFixed[4]);
723   }
724   else
725   {
726     // no color smoothing
727     aTriangles = new Graphic3d_ArrayOfTriangles (aColors.Length() * 4,     // quads
728                                                  aColors.Length() * 2 * 3, // quads as triangles
729                                                  false, true);             // per-vertex colors
730     Standard_Integer anYBottomIter = theBarBottom;
731     for (Standard_Integer aColorIter = 0; aColorIter < myNbIntervals; ++aColorIter)
732     {
733       const Quantity_Color&  aColor = aColors.Value (aColorIter + 1);
734       const Standard_Integer aSizeY = theBarBottom + Standard_Integer((aColorIter + 1) * aStepY) - anYBottomIter;
735       addColoredQuad (aTriangles,
736                       anXLeft, anYBottomIter,
737                       theColorBreadth, aSizeY,
738                       aColor, aColor);
739       anYBottomIter += aSizeY;
740     }
741   }
742
743   Handle(Graphic3d_Group) aGroup = thePrs->NewGroup();
744   aGroup->SetGroupPrimitivesAspect (myDrawer->ShadingAspect()->Aspect());
745   aGroup->AddPrimitiveArray (aTriangles);
746
747   const Quantity_Color aFgColor (hasOwnColor ? myDrawer->Color() : Quantity_NOC_WHITE);
748   drawFrame (thePrs,
749              anXLeft - 1, theBarBottom - 1,
750              theColorBreadth + 2,
751              theBarHeight + 2,
752              aFgColor);
753 }
754
755 //=======================================================================
756 //function : drawLabels
757 //purpose  :
758 //=======================================================================
759 void AIS_ColorScale::drawLabels (const Handle(Graphic3d_Group)& theGroup,
760                                  const TColStd_SequenceOfExtendedString& theLabels,
761                                  const Standard_Integer theBarBottom,
762                                  const Standard_Integer theBarHeight,
763                                  const Standard_Integer theMaxLabelWidth,
764                                  const Standard_Integer theColorBreadth)
765 {
766   if (myLabelPos == Aspect_TOCSP_NONE
767    || theLabels.IsEmpty())
768   {
769     return;
770   }
771
772   const Standard_Integer aNbLabels    = theLabels.Size();
773   const Standard_Integer aNbIntervals = myIsLabelAtBorder ? aNbLabels - 1 : aNbLabels;
774   const Standard_Real    aStepY       = Standard_Real(theBarHeight) / Standard_Real(aNbIntervals);
775   if (aStepY <= 0.0)
776   {
777     return;
778   }
779
780   Standard_Integer aFilter = 0;
781   {
782     const Standard_Integer aTitleHeight = !myTitle.IsEmpty() ? (myTextHeight + 2 * mySpacing) : mySpacing;
783     const Standard_Integer aSpc         = myHeight - aTitleHeight - ((Min (aNbLabels, 2) + Abs (aNbLabels - aNbIntervals - 1)) * myTextHeight);
784     if (aSpc <= 0)
785     {
786       return;
787     }
788
789     const Standard_Real aVal = Standard_Real(aNbLabels) * myTextHeight / aSpc;
790     Standard_Real anIPart = 0.0;
791     Standard_Real anFPart = std::modf (aVal, &anIPart);
792     aFilter = (Standard_Integer )anIPart + (anFPart != 0 ? 1 : 0);
793   }
794   if (aFilter <= 0)
795   {
796     return;
797   }
798
799   Standard_Integer anXLeft = myXPos + mySpacing;
800   const Standard_Integer anAscent = 0;
801   switch (myLabelPos)
802   {
803     case Aspect_TOCSP_NONE:
804     case Aspect_TOCSP_LEFT:
805     {
806       break;
807     }
808     case Aspect_TOCSP_CENTER:
809     {
810       anXLeft += (theColorBreadth - theMaxLabelWidth) / 2;
811       break;
812     }
813     case Aspect_TOCSP_RIGHT:
814     {
815       anXLeft += theColorBreadth + mySpacing;
816       break;
817     }
818   }
819
820   Standard_Integer i1 = 0;
821   Standard_Integer i2 = aNbLabels - 1;
822   Standard_Integer aLast1 = i1;
823   Standard_Integer aLast2 = i2;
824   const Standard_Integer anYBottom = myIsLabelAtBorder
825                                    ? theBarBottom
826                                    : theBarBottom + Standard_Integer(aStepY / 2);
827   while (i2 - i1 >= aFilter || ( i2 == 0 && i1 == 0 ))
828   {
829     Standard_Integer aPos1 = i1;
830     Standard_Integer aPos2 = aNbLabels - 1 - i2;
831     if (aFilter && !(aPos1 % aFilter))
832     {
833       drawText (theGroup, theLabels.Value (i1 + 1),
834                 anXLeft, anYBottom + Standard_Integer(i1 * aStepY + anAscent),
835                 Graphic3d_VTA_CENTER);
836       aLast1 = i1;
837     }
838     if (aFilter && !(aPos2 % aFilter))
839     {
840       drawText (theGroup, theLabels.Value (i2 + 1),
841                 anXLeft, anYBottom + Standard_Integer(i2 * aStepY + anAscent),
842                 Graphic3d_VTA_CENTER);
843       aLast2 = i2;
844     }
845     i1++;
846     i2--;
847   }
848   Standard_Integer aPos = i1;
849   Standard_Integer i0   = -1;
850   while (aPos <= i2 && i0 == -1)
851   {
852     if (aFilter && !(aPos % aFilter)
853       && Abs (aPos - aLast1) >= aFilter
854       && Abs (aPos - aLast2) >= aFilter)
855     {
856       i0 = aPos;
857     }
858     aPos++;
859   }
860
861   if (i0 != -1)
862   {
863     drawText (theGroup, theLabels.Value (i0 + 1),
864               anXLeft, anYBottom + Standard_Integer(i0 * aStepY + anAscent),
865               Graphic3d_VTA_CENTER);
866   }
867 }
868
869 //=======================================================================
870 //function : drawFrame
871 //purpose  :
872 //=======================================================================
873 void AIS_ColorScale::drawFrame (const Handle(Prs3d_Presentation)& thePrs,
874                                 const Standard_Integer theX, const Standard_Integer theY,
875                                 const Standard_Integer theWidth, const Standard_Integer theHeight,
876                                 const Quantity_Color& theColor)
877 {
878   Handle(Graphic3d_ArrayOfPolylines) aPrim = new Graphic3d_ArrayOfPolylines(5);
879   aPrim->AddVertex (theX,            theY, 0.0);
880   aPrim->AddVertex (theX + theWidth, theY, 0.0);
881   aPrim->AddVertex (theX + theWidth, theY + theHeight, 0.0);
882   aPrim->AddVertex (theX,            theY + theHeight, 0.0);
883   aPrim->AddVertex (theX,            theY, 0.0);
884
885   Handle(Graphic3d_AspectLine3d) anAspect = new Graphic3d_AspectLine3d (theColor, Aspect_TOL_SOLID, 1.0);
886   Handle(Graphic3d_Group) aGroup = thePrs->NewGroup();
887   aGroup->SetGroupPrimitivesAspect (anAspect);
888   aGroup->AddPrimitiveArray (aPrim);
889 }
890
891 //=======================================================================
892 //function : drawText
893 //purpose  :
894 //=======================================================================
895 void AIS_ColorScale::drawText (const Handle(Graphic3d_Group)& theGroup,
896                                const TCollection_ExtendedString& theText,
897                                const Standard_Integer theX, const Standard_Integer theY,
898                                const Graphic3d_VerticalTextAlignment theVertAlignment)
899 {
900   const Handle(Prs3d_TextAspect)& anAspect = myDrawer->TextAspect();
901
902   Handle(Graphic3d_Text) aText = new Graphic3d_Text ((Standard_ShortReal)anAspect->Height());
903   aText->SetText (theText.ToExtString());
904   aText->SetOrientation (gp_Ax2 (gp_Pnt (theX, theY, 0.0), gp::DZ()));
905   aText->SetOwnAnchorPoint (Standard_False);
906   aText->SetVerticalAlignment (theVertAlignment);
907
908   theGroup->AddText (aText);
909 }
910
911 //=======================================================================
912 //function : TextWidth
913 //purpose  :
914 //=======================================================================
915 Standard_Integer AIS_ColorScale::TextWidth (const TCollection_ExtendedString& theText) const
916 {
917   Standard_Integer aWidth = 0, anAscent = 0, aDescent = 0;
918   TextSize (theText, myTextHeight, aWidth, anAscent, aDescent);
919   return aWidth;
920 }
921
922 //=======================================================================
923 //function : TextHeight
924 //purpose  :
925 //=======================================================================
926 Standard_Integer AIS_ColorScale::TextHeight (const TCollection_ExtendedString& theText) const
927 {
928   Standard_Integer aWidth = 0, anAscent = 0, aDescent = 0;
929   TextSize (theText, myTextHeight, aWidth, anAscent, aDescent);
930   return anAscent + aDescent;
931 }
932
933 //=======================================================================
934 //function : TextSize
935 //purpose  :
936 //=======================================================================
937 void AIS_ColorScale::TextSize (const TCollection_ExtendedString& theText,
938                                const Standard_Integer theHeight,
939                                Standard_Integer& theWidth,
940                                Standard_Integer& theAscent,
941                                Standard_Integer& theDescent) const
942 {
943   Standard_ShortReal aWidth = 10.0f, anAscent = 1.0f, aDescent = 1.0f;
944   if (HasInteractiveContext())
945   {
946     const TCollection_AsciiString aText (theText);
947     const Handle(V3d_Viewer)&      aViewer = GetContext()->CurrentViewer();
948     const Handle(Graphic3d_CView)& aView   = aViewer->ActiveViewIterator().Value()->View();
949     aViewer->Driver()->TextSize (aView, aText.ToCString(), (Standard_ShortReal)theHeight, aWidth, anAscent, aDescent);
950   }
951   theWidth   = (Standard_Integer)aWidth;
952   theAscent  = (Standard_Integer)anAscent;
953   theDescent = (Standard_Integer)aDescent;
954 }