| 1 | // Created on: 2004-06-22 |
| 2 | // Created by: STV |
| 3 | // Copyright (c) 2004-2012 OPEN CASCADE SAS |
| 4 | // |
| 5 | // The content of this file is subject to the Open CASCADE Technology Public |
| 6 | // License Version 6.5 (the "License"). You may not use the content of this file |
| 7 | // except in compliance with the License. Please obtain a copy of the License |
| 8 | // at http://www.opencascade.org and read it completely before using this file. |
| 9 | // |
| 10 | // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its |
| 11 | // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France. |
| 12 | // |
| 13 | // The Original Code and all software distributed under the License is |
| 14 | // distributed on an "AS IS" basis, without warranty of any kind, and the |
| 15 | // Initial Developer hereby disclaims all such warranties, including without |
| 16 | // limitation, any warranties of merchantability, fitness for a particular |
| 17 | // purpose or non-infringement. Please see the License for the specific terms |
| 18 | // and conditions governing the rights and limitations under the License. |
| 19 | |
| 20 | |
| 21 | #include <Aspect_ColorScale.ixx> |
| 22 | |
| 23 | #include <Aspect_ColorMap.hxx> |
| 24 | #include <Aspect_ColorMapEntry.hxx> |
| 25 | #include <Aspect_SequenceOfColor.hxx> |
| 26 | #include <Aspect_TypeOfColorScaleData.hxx> |
| 27 | #include <Aspect_TypeOfColorScalePosition.hxx> |
| 28 | |
| 29 | #include <TCollection_AsciiString.hxx> |
| 30 | #include <TCollection_ExtendedString.hxx> |
| 31 | #include <TColStd_SequenceOfExtendedString.hxx> |
| 32 | |
| 33 | #include <Precision.hxx> |
| 34 | |
| 35 | #include <stdio.h> |
| 36 | |
| 37 | Aspect_ColorScale::Aspect_ColorScale() |
| 38 | : MMgt_TShared(), |
| 39 | myMin( 0.0 ), |
| 40 | myMax( 1.0 ), |
| 41 | myXPos( 0 ), |
| 42 | myYPos( 0 ), |
| 43 | myWidth( 0.2 ), |
| 44 | myHeight( 1 ), |
| 45 | myTitle( "" ), |
| 46 | myInterval( 10 ), |
| 47 | myFormat( "%.4g" ), |
| 48 | myAtBorder( Standard_True ), |
| 49 | myReversed( Standard_False ), |
| 50 | myColorType( Aspect_TOCSD_AUTO ), |
| 51 | myLabelType( Aspect_TOCSD_AUTO ), |
| 52 | myLabelPos( Aspect_TOCSP_RIGHT ), |
| 53 | myTitlePos( Aspect_TOCSP_CENTER ), |
| 54 | myTextHeight(20) |
| 55 | { |
| 56 | } |
| 57 | |
| 58 | Standard_Real Aspect_ColorScale::GetMin() const |
| 59 | { |
| 60 | return myMin; |
| 61 | } |
| 62 | |
| 63 | Standard_Real Aspect_ColorScale::GetMax() const |
| 64 | { |
| 65 | return myMax; |
| 66 | } |
| 67 | |
| 68 | void Aspect_ColorScale::GetRange( Standard_Real& aMin, Standard_Real& aMax ) const |
| 69 | { |
| 70 | aMin = myMin; |
| 71 | aMax = myMax; |
| 72 | } |
| 73 | |
| 74 | Aspect_TypeOfColorScaleData Aspect_ColorScale::GetLabelType() const |
| 75 | { |
| 76 | return myLabelType; |
| 77 | } |
| 78 | |
| 79 | Aspect_TypeOfColorScaleData Aspect_ColorScale::GetColorType() const |
| 80 | { |
| 81 | return myColorType; |
| 82 | } |
| 83 | |
| 84 | Standard_Integer Aspect_ColorScale::GetNumberOfIntervals() const |
| 85 | { |
| 86 | return myInterval; |
| 87 | } |
| 88 | |
| 89 | TCollection_ExtendedString Aspect_ColorScale::GetTitle() const |
| 90 | { |
| 91 | return myTitle; |
| 92 | } |
| 93 | |
| 94 | TCollection_AsciiString Aspect_ColorScale::GetFormat() const |
| 95 | { |
| 96 | return myFormat; |
| 97 | } |
| 98 | |
| 99 | TCollection_ExtendedString Aspect_ColorScale::GetLabel( const Standard_Integer anIndex ) const |
| 100 | { |
| 101 | TCollection_ExtendedString aLabel; |
| 102 | if ( anIndex >= 0 && anIndex < myLabels.Length() ) |
| 103 | aLabel = myLabels.Value( anIndex + 1 ); |
| 104 | return aLabel; |
| 105 | } |
| 106 | |
| 107 | Quantity_Color Aspect_ColorScale::GetColor( const Standard_Integer anIndex ) const |
| 108 | { |
| 109 | Quantity_Color aColor; |
| 110 | if ( anIndex >= 0 && anIndex < myColors.Length() ) |
| 111 | aColor = myColors.Value( anIndex + 1 ); |
| 112 | return aColor; |
| 113 | } |
| 114 | |
| 115 | void Aspect_ColorScale::GetLabels( TColStd_SequenceOfExtendedString& aLabels ) const |
| 116 | { |
| 117 | aLabels.Clear(); |
| 118 | for ( Standard_Integer i = 1; i <= myLabels.Length(); i++ ) |
| 119 | aLabels.Append( myLabels.Value( i ) ); |
| 120 | } |
| 121 | |
| 122 | void Aspect_ColorScale::GetColors( Aspect_SequenceOfColor& aColors ) const |
| 123 | { |
| 124 | aColors.Clear(); |
| 125 | for ( Standard_Integer i = 1; i <= myColors.Length(); i++ ) |
| 126 | aColors.Append( myColors.Value( i ) ); |
| 127 | } |
| 128 | |
| 129 | Aspect_TypeOfColorScalePosition Aspect_ColorScale::GetLabelPosition() const |
| 130 | { |
| 131 | return myLabelPos; |
| 132 | } |
| 133 | |
| 134 | Aspect_TypeOfColorScalePosition Aspect_ColorScale::GetTitlePosition() const |
| 135 | { |
| 136 | return myTitlePos; |
| 137 | } |
| 138 | |
| 139 | Standard_Boolean Aspect_ColorScale::IsReversed() const |
| 140 | { |
| 141 | return myReversed; |
| 142 | } |
| 143 | |
| 144 | Standard_Boolean Aspect_ColorScale::IsLabelAtBorder() const |
| 145 | { |
| 146 | return myAtBorder; |
| 147 | } |
| 148 | |
| 149 | void Aspect_ColorScale::SetMin( const Standard_Real aMin ) |
| 150 | { |
| 151 | SetRange( aMin, GetMax() ); |
| 152 | } |
| 153 | |
| 154 | void Aspect_ColorScale::SetMax( const Standard_Real aMax ) |
| 155 | { |
| 156 | SetRange( GetMin(), aMax ); |
| 157 | } |
| 158 | |
| 159 | void Aspect_ColorScale::SetRange( const Standard_Real aMin, const Standard_Real aMax ) |
| 160 | { |
| 161 | if ( myMin == aMin && myMax == aMax ) |
| 162 | return; |
| 163 | |
| 164 | myMin = Min( aMin, aMax ); |
| 165 | myMax = Max( aMin, aMax ); |
| 166 | |
| 167 | if ( GetColorType() == Aspect_TOCSD_AUTO ) |
| 168 | UpdateColorScale(); |
| 169 | } |
| 170 | |
| 171 | void Aspect_ColorScale::SetLabelType( const Aspect_TypeOfColorScaleData aType ) |
| 172 | { |
| 173 | if ( myLabelType == aType ) |
| 174 | return; |
| 175 | |
| 176 | myLabelType = aType; |
| 177 | UpdateColorScale(); |
| 178 | } |
| 179 | |
| 180 | void Aspect_ColorScale::SetColorType( const Aspect_TypeOfColorScaleData aType ) |
| 181 | { |
| 182 | if ( myColorType == aType ) |
| 183 | return; |
| 184 | |
| 185 | myColorType = aType; |
| 186 | UpdateColorScale(); |
| 187 | } |
| 188 | |
| 189 | void Aspect_ColorScale::SetNumberOfIntervals( const Standard_Integer aNum ) |
| 190 | { |
| 191 | if ( myInterval == aNum || aNum < 1 ) |
| 192 | return; |
| 193 | |
| 194 | myInterval = aNum; |
| 195 | UpdateColorScale(); |
| 196 | } |
| 197 | |
| 198 | void Aspect_ColorScale::SetTitle( const TCollection_ExtendedString& aTitle ) |
| 199 | { |
| 200 | if ( myTitle == aTitle ) |
| 201 | return; |
| 202 | |
| 203 | myTitle = aTitle; |
| 204 | UpdateColorScale(); |
| 205 | } |
| 206 | |
| 207 | void Aspect_ColorScale::SetFormat( const TCollection_AsciiString& aFormat ) |
| 208 | { |
| 209 | if ( myFormat == aFormat ) |
| 210 | return; |
| 211 | |
| 212 | myFormat = aFormat; |
| 213 | if ( GetLabelType() == Aspect_TOCSD_AUTO ) |
| 214 | UpdateColorScale(); |
| 215 | } |
| 216 | |
| 217 | void Aspect_ColorScale::SetLabel( const TCollection_ExtendedString& aLabel, const Standard_Integer anIndex ) |
| 218 | { |
| 219 | Standard_Boolean changed = Standard_False; |
| 220 | Standard_Integer i = anIndex < 1 ? myLabels.Length() + 1 : anIndex; |
| 221 | if ( i <= myLabels.Length() ) { |
| 222 | changed = myLabels.Value( i ) != aLabel; |
| 223 | myLabels.SetValue( i, aLabel ); |
| 224 | } |
| 225 | else { |
| 226 | changed = Standard_True; |
| 227 | while ( i > myLabels.Length() ) |
| 228 | myLabels.Append( TCollection_ExtendedString() ); |
| 229 | myLabels.SetValue( i, aLabel ); |
| 230 | } |
| 231 | if ( changed ) |
| 232 | UpdateColorScale(); |
| 233 | } |
| 234 | |
| 235 | void Aspect_ColorScale::SetColor(const Quantity_Color& aColor, const Standard_Integer anIndex ) |
| 236 | { |
| 237 | Standard_Boolean changed = Standard_False; |
| 238 | Standard_Integer i = anIndex < 1 ? myLabels.Length() + 1 : anIndex; |
| 239 | if ( i <= myColors.Length() ) { |
| 240 | changed = myColors.Value( i ) != aColor; |
| 241 | myColors.SetValue( i, aColor ); |
| 242 | } |
| 243 | else { |
| 244 | changed = Standard_True; |
| 245 | while ( i > myColors.Length() ) |
| 246 | myColors.Append( Quantity_Color() ); |
| 247 | myColors.SetValue( i, aColor ); |
| 248 | } |
| 249 | if ( changed ) |
| 250 | UpdateColorScale(); |
| 251 | } |
| 252 | |
| 253 | void Aspect_ColorScale::SetLabels( const TColStd_SequenceOfExtendedString& aSeq ) |
| 254 | { |
| 255 | myLabels.Clear(); |
| 256 | for ( Standard_Integer i = 1; i <= aSeq.Length(); i++ ) |
| 257 | myLabels.Append( aSeq.Value( i ) ); |
| 258 | } |
| 259 | |
| 260 | void Aspect_ColorScale::SetColors( const Handle(Aspect_ColorMap)& aMap ) |
| 261 | { |
| 262 | myColors.Clear(); |
| 263 | if ( !aMap.IsNull() ) |
| 264 | for ( Standard_Integer i = 1; i <= aMap->Size(); i++ ) |
| 265 | myColors.Append( aMap->Entry( i ).Color() ); |
| 266 | } |
| 267 | |
| 268 | void Aspect_ColorScale::SetColors( const Aspect_SequenceOfColor& aSeq ) |
| 269 | { |
| 270 | myColors.Clear(); |
| 271 | for ( Standard_Integer i = 1; i <= aSeq.Length(); i++ ) |
| 272 | myColors.Append( aSeq.Value( i ) ); |
| 273 | } |
| 274 | |
| 275 | void Aspect_ColorScale::SetLabelPosition( const Aspect_TypeOfColorScalePosition aPos ) |
| 276 | { |
| 277 | if ( myLabelPos == aPos ) |
| 278 | return; |
| 279 | |
| 280 | myLabelPos = aPos; |
| 281 | UpdateColorScale(); |
| 282 | } |
| 283 | |
| 284 | void Aspect_ColorScale::SetTitlePosition( const Aspect_TypeOfColorScalePosition aPos ) |
| 285 | { |
| 286 | if ( myTitlePos == aPos ) |
| 287 | return; |
| 288 | |
| 289 | myTitlePos = aPos; |
| 290 | UpdateColorScale(); |
| 291 | } |
| 292 | |
| 293 | void Aspect_ColorScale::SetReversed( const Standard_Boolean aReverse ) |
| 294 | { |
| 295 | if ( myReversed == aReverse ) |
| 296 | return; |
| 297 | |
| 298 | myReversed = aReverse; |
| 299 | UpdateColorScale(); |
| 300 | } |
| 301 | |
| 302 | void Aspect_ColorScale::SetLabelAtBorder( const Standard_Boolean anOn ) |
| 303 | { |
| 304 | if ( myAtBorder == anOn ) |
| 305 | return; |
| 306 | |
| 307 | myAtBorder = anOn; |
| 308 | UpdateColorScale(); |
| 309 | } |
| 310 | |
| 311 | void Aspect_ColorScale::GetPosition( Standard_Real& aX, Standard_Real& aY ) const |
| 312 | { |
| 313 | aX = myXPos; |
| 314 | aY = myYPos; |
| 315 | } |
| 316 | |
| 317 | Standard_Real Aspect_ColorScale::GetXPosition() const |
| 318 | { |
| 319 | return myXPos; |
| 320 | } |
| 321 | |
| 322 | Standard_Real Aspect_ColorScale::GetYPosition() const |
| 323 | { |
| 324 | return myYPos; |
| 325 | } |
| 326 | |
| 327 | void Aspect_ColorScale::SetPosition( const Standard_Real aX, const Standard_Real aY ) |
| 328 | { |
| 329 | if ( myXPos == aX && myYPos == aY ) |
| 330 | return; |
| 331 | |
| 332 | myXPos = aX; |
| 333 | myYPos = aY; |
| 334 | |
| 335 | UpdateColorScale(); |
| 336 | } |
| 337 | |
| 338 | void Aspect_ColorScale::SetXPosition( const Standard_Real aX ) |
| 339 | { |
| 340 | SetPosition( aX, GetYPosition() ); |
| 341 | } |
| 342 | |
| 343 | void Aspect_ColorScale::SetYPosition( const Standard_Real aY ) |
| 344 | { |
| 345 | SetPosition( GetXPosition(), aY ); |
| 346 | } |
| 347 | |
| 348 | void Aspect_ColorScale::GetSize( Standard_Real& aWidth, Standard_Real& aHeight ) const |
| 349 | { |
| 350 | aWidth = myWidth; |
| 351 | aHeight = myHeight; |
| 352 | } |
| 353 | |
| 354 | Standard_Real Aspect_ColorScale::GetWidth() const |
| 355 | { |
| 356 | return myWidth; |
| 357 | } |
| 358 | |
| 359 | Standard_Real Aspect_ColorScale::GetHeight() const |
| 360 | { |
| 361 | return myHeight; |
| 362 | } |
| 363 | |
| 364 | void Aspect_ColorScale::SetSize( const Standard_Real aWidth, const Standard_Real aHeight ) |
| 365 | { |
| 366 | if ( myWidth == aWidth && myHeight == aHeight ) |
| 367 | return; |
| 368 | |
| 369 | myWidth = aWidth; |
| 370 | myHeight = aHeight; |
| 371 | |
| 372 | UpdateColorScale(); |
| 373 | } |
| 374 | |
| 375 | void Aspect_ColorScale::SetWidth( const Standard_Real aWidth ) |
| 376 | { |
| 377 | SetSize( aWidth, GetHeight() ); |
| 378 | } |
| 379 | |
| 380 | void Aspect_ColorScale::SetHeight( const Standard_Real aHeight ) |
| 381 | { |
| 382 | SetSize( GetWidth(), aHeight ); |
| 383 | } |
| 384 | |
| 385 | void Aspect_ColorScale::SizeHint( Standard_Integer& aWidth, Standard_Integer& aHeight ) const |
| 386 | { |
| 387 | Standard_Integer num = GetNumberOfIntervals(); |
| 388 | |
| 389 | Standard_Integer spacer = 5; |
| 390 | Standard_Integer textWidth = 0; |
| 391 | Standard_Integer textHeight = TextHeight( "" ); |
| 392 | Standard_Integer colorWidth = 20; |
| 393 | |
| 394 | if ( GetLabelPosition() != Aspect_TOCSP_NONE ) |
| 395 | for ( Standard_Integer idx = 0; idx < num; idx++ ) |
| 396 | textWidth = Max( textWidth, TextWidth( GetCurrentLabel( idx + 1 ) ) ); |
| 397 | |
| 398 | Standard_Integer scaleWidth = 0; |
| 399 | Standard_Integer scaleHeight = 0; |
| 400 | |
| 401 | Standard_Integer titleWidth = 0; |
| 402 | Standard_Integer titleHeight = 0; |
| 403 | |
| 404 | if ( IsLabelAtBorder() ) { |
| 405 | num++; |
| 406 | if ( GetTitle().Length() ) |
| 407 | titleHeight += 10; |
| 408 | } |
| 409 | |
| 410 | scaleWidth = colorWidth + textWidth + ( textWidth ? 3 : 2 ) * spacer; |
| 411 | scaleHeight = (Standard_Integer)( 1.5 * ( num + 1 ) * textHeight ); |
| 412 | |
| 413 | if ( GetTitle().Length() ) { |
| 414 | titleHeight = TextHeight( GetTitle() ) + spacer; |
| 415 | titleWidth = TextWidth( GetTitle() ) + 10; |
| 416 | } |
| 417 | |
| 418 | aWidth = Max( titleWidth, scaleWidth ); |
| 419 | aHeight = scaleHeight + titleHeight; |
| 420 | } |
| 421 | |
| 422 | void Aspect_ColorScale::DrawScale( const Quantity_Color& aBgColor, |
| 423 | const Standard_Integer X, const Standard_Integer Y, |
| 424 | const Standard_Integer W, const Standard_Integer H ) |
| 425 | { |
| 426 | if ( !BeginPaint() ) |
| 427 | return; |
| 428 | |
| 429 | Standard_Integer num = GetNumberOfIntervals(); |
| 430 | Aspect_TypeOfColorScalePosition labPos = GetLabelPosition(); |
| 431 | |
| 432 | Standard_Integer spacer = 5; |
| 433 | Standard_Integer textWidth = 0; |
| 434 | Standard_Integer textHeight = TextHeight( "" ); |
| 435 | |
| 436 | Standard_Boolean drawLabel = GetLabelPosition() != Aspect_TOCSP_NONE; |
| 437 | |
| 438 | TCollection_ExtendedString aTitle = GetTitle(); |
| 439 | |
| 440 | Standard_Integer titleWidth = 0; |
| 441 | Standard_Integer titleHeight = 0; |
| 442 | |
| 443 | Standard_Integer aGray = (Standard_Integer)(255 * ( aBgColor.Red() * 11 + aBgColor.Green() * 16 + aBgColor.Blue() * 5 ) / 32); |
| 444 | Quantity_Color aFgColor( aGray < 128 ? Quantity_NOC_WHITE : Quantity_NOC_BLACK ); |
| 445 | |
| 446 | // Draw title |
| 447 | if ( aTitle.Length() ) { |
| 448 | titleWidth = TextWidth( aTitle ); |
| 449 | titleHeight = TextHeight( aTitle ) + 2 * spacer; |
| 450 | PaintText( aTitle, X + spacer, Y + spacer, aFgColor ); |
| 451 | } |
| 452 | |
| 453 | Standard_Boolean reverse = IsReversed(); |
| 454 | |
| 455 | Aspect_SequenceOfColor colors; |
| 456 | TColStd_SequenceOfExtendedString labels; |
| 457 | for ( int idx = 0; idx < num; idx++ ) { |
| 458 | if ( reverse ) { |
| 459 | colors.Append( GetCurrentColor( idx ) ); |
| 460 | labels.Append( GetCurrentLabel( idx ) ); |
| 461 | } |
| 462 | else { |
| 463 | colors.Prepend( GetCurrentColor( idx ) ); |
| 464 | labels.Prepend( GetCurrentLabel( idx ) ); |
| 465 | } |
| 466 | } |
| 467 | |
| 468 | if ( IsLabelAtBorder() ) { |
| 469 | if ( reverse ) |
| 470 | labels.Append( GetCurrentLabel( num ) ); |
| 471 | else |
| 472 | labels.Prepend( GetCurrentLabel( num ) ); |
| 473 | } |
| 474 | |
| 475 | if ( drawLabel ) |
| 476 | for ( Standard_Integer i = 1; i <= labels.Length(); i++ ) |
| 477 | textWidth = Max( textWidth, TextWidth( labels.Value( i ) ) ); |
| 478 | |
| 479 | Standard_Integer lab = labels.Length(); |
| 480 | |
| 481 | Standard_Real spc = ( H - ( ( Min( lab, 2 ) + Abs( lab - num - 1 ) ) * textHeight ) - titleHeight ); |
| 482 | Standard_Real val = spc != 0 ? 1.0 * ( lab - Min( lab, 2 ) ) * textHeight / spc : 0; |
| 483 | Standard_Real iPart; |
| 484 | Standard_Real fPart = modf( val, &iPart ); |
| 485 | Standard_Integer filter = (Standard_Integer)iPart + ( fPart != 0 ? 1 : 0 ); |
| 486 | |
| 487 | Standard_Real step = 1.0 * ( H - ( lab - num + Abs( lab - num - 1 ) ) * textHeight - titleHeight ) / num; |
| 488 | |
| 489 | Standard_Integer ascent = 0; |
| 490 | Standard_Integer colorWidth = Max( 5, Min( 20, W - textWidth - 3 * spacer ) ); |
| 491 | if ( labPos == Aspect_TOCSP_CENTER || !drawLabel ) |
| 492 | colorWidth = W - 2 * spacer; |
| 493 | |
| 494 | // Draw colors |
| 495 | Standard_Integer x = X + spacer; |
| 496 | if ( labPos == Aspect_TOCSP_LEFT ) |
| 497 | x += textWidth + ( textWidth ? 1 : 0 ) * spacer; |
| 498 | |
| 499 | Standard_Real offset = 1.0 * textHeight / 2 * ( lab - num + Abs( lab - num - 1 ) ) + titleHeight; |
| 500 | for ( Standard_Integer ci = 1; ci <= colors.Length() && step > 0; ci++ ) { |
| 501 | Standard_Integer y = (Standard_Integer)( Y + ( ci - 1 )* step + offset ); |
| 502 | Standard_Integer h = (Standard_Integer)( Y + ( ci ) * step + offset ) - y; |
| 503 | PaintRect( x, y, colorWidth, h, colors.Value( ci ), Standard_True ); |
| 504 | } |
| 505 | |
| 506 | if ( step > 0 ) |
| 507 | PaintRect( x - 1, (Standard_Integer)(Y + offset - 1), colorWidth + 2, (Standard_Integer)(colors.Length() * step + 2), aFgColor ); |
| 508 | |
| 509 | // Draw labels |
| 510 | offset = 1.0 * Abs( lab - num - 1 ) * ( step - textHeight ) / 2 + 1.0 * Abs( lab - num - 1 ) * textHeight / 2; |
| 511 | offset += titleHeight; |
| 512 | if ( drawLabel && labels.Length() && filter > 0 ) { |
| 513 | Standard_Integer i1 = 0; |
| 514 | Standard_Integer i2 = lab - 1; |
| 515 | Standard_Integer last1( i1 ), last2( i2 ); |
| 516 | x = X + spacer; |
| 517 | switch ( labPos ) { |
| 518 | case Aspect_TOCSP_CENTER: |
| 519 | x += ( colorWidth - textWidth ) / 2; |
| 520 | break; |
| 521 | case Aspect_TOCSP_RIGHT: |
| 522 | x += colorWidth + spacer; |
| 523 | break; |
| 524 | } |
| 525 | while ( i2 - i1 >= filter || ( i2 == 0 && i1 == 0 ) ) { |
| 526 | Standard_Integer pos1 = i1; |
| 527 | Standard_Integer pos2 = lab - 1 - i2; |
| 528 | if ( filter && !( pos1 % filter ) ) { |
| 529 | PaintText( labels.Value( i1 + 1 ), x, (Standard_Integer)( Y + i1 * step + ascent + offset ), aFgColor ); |
| 530 | last1 = i1; |
| 531 | } |
| 532 | if ( filter && !( pos2 % filter ) ) { |
| 533 | PaintText( labels.Value( i2 + 1 ), x, (Standard_Integer)( Y + i2 * step + ascent + offset ), aFgColor ); |
| 534 | last2 = i2; |
| 535 | } |
| 536 | i1++; |
| 537 | i2--; |
| 538 | } |
| 539 | Standard_Integer pos = i1; |
| 540 | Standard_Integer i0 = -1; |
| 541 | while ( pos <= i2 && i0 == -1 ) { |
| 542 | if ( filter && !( pos % filter ) && Abs( pos - last1 ) >= filter && Abs( pos - last2 ) >= filter ) |
| 543 | i0 = pos; |
| 544 | pos++; |
| 545 | } |
| 546 | |
| 547 | if ( i0 != -1 ) |
| 548 | PaintText( labels.Value( i0 + 1 ), x, (Standard_Integer)( Y + i0 * step + ascent + offset ), aFgColor ); |
| 549 | } |
| 550 | |
| 551 | EndPaint(); |
| 552 | } |
| 553 | |
| 554 | Standard_Boolean Aspect_ColorScale::BeginPaint() |
| 555 | { |
| 556 | return Standard_True; |
| 557 | } |
| 558 | |
| 559 | Standard_Boolean Aspect_ColorScale::EndPaint() |
| 560 | { |
| 561 | return Standard_True; |
| 562 | } |
| 563 | |
| 564 | void Aspect_ColorScale::UpdateColorScale() |
| 565 | { |
| 566 | } |
| 567 | |
| 568 | TCollection_AsciiString Aspect_ColorScale::Format() const |
| 569 | { |
| 570 | return GetFormat(); |
| 571 | } |
| 572 | |
| 573 | TCollection_ExtendedString Aspect_ColorScale::GetCurrentLabel( const Standard_Integer anIndex ) const |
| 574 | { |
| 575 | TCollection_ExtendedString aLabel; |
| 576 | if ( GetLabelType() == Aspect_TOCSD_USER ) |
| 577 | aLabel = GetLabel( anIndex ); |
| 578 | else { |
| 579 | Standard_Real val = GetNumber( anIndex ); |
| 580 | Standard_Character buf[1024]; |
| 581 | TCollection_AsciiString aFormat = Format(); |
| 582 | sprintf( buf, aFormat.ToCString(), val ); |
| 583 | aLabel = TCollection_ExtendedString( buf ); |
| 584 | } |
| 585 | |
| 586 | return aLabel; |
| 587 | } |
| 588 | |
| 589 | Quantity_Color Aspect_ColorScale::GetCurrentColor( const Standard_Integer anIndex ) const |
| 590 | { |
| 591 | Quantity_Color aColor; |
| 592 | if ( GetColorType() == Aspect_TOCSD_USER ) |
| 593 | aColor = GetColor( anIndex ); |
| 594 | else |
| 595 | aColor = Quantity_Color( HueFromValue( anIndex, 0, GetNumberOfIntervals() - 1 ), 1.0, 1.0, Quantity_TOC_HLS ); |
| 596 | return aColor; |
| 597 | } |
| 598 | |
| 599 | Standard_Real Aspect_ColorScale::GetNumber( const Standard_Integer anIndex ) const |
| 600 | { |
| 601 | Standard_Real aNum = 0; |
| 602 | if ( GetNumberOfIntervals() > 0 ) |
| 603 | aNum = GetMin() + anIndex * ( Abs( GetMax() - GetMin() ) / GetNumberOfIntervals() ); |
| 604 | return aNum; |
| 605 | } |
| 606 | |
| 607 | Standard_Integer Aspect_ColorScale::HueFromValue( const Standard_Integer aValue, |
| 608 | const Standard_Integer aMin, const Standard_Integer aMax ) |
| 609 | { |
| 610 | Standard_Integer minLimit( 0 ), maxLimit( 230 ); |
| 611 | |
| 612 | Standard_Integer aHue = maxLimit; |
| 613 | if ( aMin != aMax ) |
| 614 | aHue = (Standard_Integer)( maxLimit - ( maxLimit - minLimit ) * ( aValue - aMin ) / ( aMax - aMin ) ); |
| 615 | |
| 616 | aHue = Min( Max( minLimit, aHue ), maxLimit ); |
| 617 | |
| 618 | return aHue; |
| 619 | } |
| 620 | |
| 621 | Standard_Integer Aspect_ColorScale::GetTextHeight() const { |
| 622 | return myTextHeight; |
| 623 | } |
| 624 | |
| 625 | void Aspect_ColorScale::SetTextHeight(const Standard_Integer aHeigh) { |
| 626 | myTextHeight = aHeigh; |
| 627 | UpdateColorScale (); |
| 628 | } |
| 629 | |
| 630 | |
| 631 | Standard_Boolean Aspect_ColorScale::FindColor( const Standard_Real aValue, |
| 632 | Quantity_Color& aColor ) const |
| 633 | { |
| 634 | return FindColor( aValue, myMin, myMax, myInterval, aColor ); |
| 635 | } |
| 636 | |
| 637 | |
| 638 | Standard_Boolean Aspect_ColorScale::FindColor( const Standard_Real aValue, |
| 639 | const Standard_Real aMin, |
| 640 | const Standard_Real aMax, |
| 641 | const Standard_Integer ColorsCount, |
| 642 | Quantity_Color& aColor ) |
| 643 | { |
| 644 | if( aValue<aMin || aValue>aMax || aMax<aMin ) |
| 645 | return Standard_False; |
| 646 | |
| 647 | else |
| 648 | { |
| 649 | Standard_Real IntervNumber = 0; |
| 650 | if( aValue<aMin ) |
| 651 | IntervNumber = 0; |
| 652 | else if( aValue>aMax ) |
| 653 | IntervNumber = ColorsCount-1; |
| 654 | else if( Abs( aMax-aMin ) > Precision::Approximation() ) |
| 655 | IntervNumber = Ceiling( Standard_Real( ColorsCount ) * ( aValue - aMin ) / ( aMax - aMin ) ); |
| 656 | |
| 657 | Standard_Integer Interv = Standard_Integer( IntervNumber ); |
| 658 | |
| 659 | aColor = Quantity_Color( HueFromValue( Interv, 0, ColorsCount - 1 ), 1.0, 1.0, Quantity_TOC_HLS ); |
| 660 | |
| 661 | return Standard_True; |
| 662 | } |
| 663 | } |