GraphicView.cpp

   1 // Implementation of graphic display
   2 // Copyright © 2009 The University of Chicago
   3 #include "GraphicView.h"
   4
   5 #include <cmath>
   6 #include <QMessageBox>
   7 #include <Q3PopupMenu>
   8 #include <QContextMenuEvent>
   9 #include <QMouseEvent>
  10 #include <QAction>
  11 #include "linepropertiesdialog.h"
  12 #include "propertiesdialog.h"
  13 #include "Stem.h"
  14 #include "StateEmitHMM.h"
  15 #include "log2.h"
  16
  17 namespace {
  18         const double PI = M_PI;
  19 }
  20 //----------------------------------------------------------------------------------//
  21 //                                                              Video class
  22 //----------------------------------------------------------------------------------//
  23
  24 Video::Video(int dimensionality )
  25 {
  26         m_Dimensionality                = dimensionality;
  27 //      m_NumberOfDataPoints    = NumberOfDataPoints;
  28         m_NumberOfFrames                = 0;
  29 }
  30
  31 Video::~Video()
  32 {
  33         //setAutoDelete(TRUE);  **** == Fix this -- we don't have auto-delete for the (new) QList. Memory leak will result now.
  34 }
  35
  36 void    Video::operator<<       ( VideoFrame * pVideoframe)
  37 {
  38         m_NumberOfFrames++;
  39         append (pVideoframe);
  40
  41 }
  42
  43 //----------------------------------------------------------------------------------//
  44 //                                                              Labeled Data Point class
  45 //----------------------------------------------------------------------------------//
  46
  47         LabeledDataPoint::LabeledDataPoint( QString label, int dimensionality)
  48         {
  49                 m_Label                                 = label;
  50                 m_CurrentLocation               = 0;
  51                 m_Dimensionality                = dimensionality;
  52                 m_Values                                = new double [m_Dimensionality];
  53         }
  54 //----------------------------------------------------------------------------------//
  55
  56         LabeledDataPoint::LabeledDataPoint( )
  57         {
  58                 m_CurrentLocation               = 0;
  59                 m_Dimensionality                = 0;
  60                 m_Values                                = NULL;
  61
  62         }
  63 //----------------------------------------------------------------------------------//
  64         LabeledDataPoint::~LabeledDataPoint( )
  65         {
  66                 delete m_Values;
  67
  68         }
  69 //----------------------------------------------------------------------------------//
  70
  71         bool                    LabeledDataPoint::operator<< (double value)
  72         {
  73                 if ( m_CurrentLocation < m_Dimensionality )
  74                 {
  75                         m_Values[m_CurrentLocation++] = value;
  76                 }
  77                 return TRUE;
  78         }
  79
  80
  81 //----------------------------------------------------------------------------------//
  82 //                                                              Video Frame class
  83 //----------------------------------------------------------------------------------//
  84         VideoFrame::VideoFrame  (int dimensionality)
  85         {
  86                 m_Dimensionality = dimensionality;
  87
  88         };
  89 //----------------------------------------------------------------------------------//
  90
  91
  92         VideoFrame::VideoFrame (  )
  93         {
  94                 m_Dimensionality = 0;
  95         }
  96 //----------------------------------------------------------------------------------//
  97
  98
  99 void VideoFrame::Incorporate(VideoFrame* OtherOne)
 100 {
 101                 //This int-to-int maps will "translate" from each label index
 102                 // to the CParse which is the union of the two.
 103                 IntToInt                                Translator1, Translator2;
 104                 CParse                                  BothLabels (m_DimensionLabels);
 105                 LabeledDataPoint*               pDataPoint;
 106                 int                                             i, n;
 107                 double*                                 tempVector = NULL;
 108
 109                 BothLabels.Append(OtherOne->m_DimensionLabels);
 110
 111                 for ( i = 1; i <= m_Dimensionality; i++)
 112                 {
 113                         n = BothLabels.Find( m_DimensionLabels[i] );
 114                         Translator1.insert (i,  n);
 115                 }
 116
 117                 for ( i = 1; i <= OtherOne->m_Dimensionality; i++)
 118                 {
 119                         n = BothLabels.Find( OtherOne->m_DimensionLabels[i] );
 120                         {
 121                                 Translator2.insert (i, n);
 122                         }
 123                 }
 124
 125                 int newDimensionality = BothLabels.Size();
 126
 127                 //for ( pDataPoint = first(); pDataPoint; pDataPoint = next() )
 128                 for ( int z = 0; z < size(); z++)
 129                 {       pDataPoint = at(z);
 130                         tempVector      = new double[newDimensionality];
 131                         for (i = 1; i <= newDimensionality; i++)
 132                         {
 133                                 tempVector[i] = 0;
 134                         }
 135                         for (i = 1; i <= m_Dimensionality; i++)
 136                         {
 137                                 tempVector[Translator1[i]] = pDataPoint->m_Values [ i] ;
 138                         }// this puts the right value in the new column for the converted data-point-values
 139
 140                         delete pDataPoint->m_Values;
 141                         pDataPoint->m_Values                    = tempVector;
 142                         pDataPoint->m_Dimensionality    = newDimensionality;
 143                 }
 144
 145                 //Second we convert the data points in the OtherOne:
 146                 //for ( pDataPoint = OtherOne->first(); pDataPoint; pDataPoint= OtherOne->next())
 147                 for (int z = 0; z < OtherOne->size(); z++)
 148                 {   pDataPoint = OtherOne->at(z);
 149                         tempVector      = new double[newDimensionality];
 150
 151                         for (i = 1; i <= OtherOne->m_Dimensionality; i++)
 152                         {
 153                                 tempVector[Translator2[i]] = pDataPoint->m_Values [ i] ;
 154
 155                         }// this puts the right value in the new column for the converted data-point-values
 156
 157                         delete pDataPoint->m_Values;
 158                         pDataPoint->m_Values                    = tempVector;
 159                         pDataPoint->m_Dimensionality    = newDimensionality;
 160
 161                 }
 162                 m_DimensionLabels       = BothLabels;
 163
 164         }
 165
 166 //----------------------------------------------------------------------------------//
 167
 168         void VideoFrame::operator<< (LabeledDataPoint* datapoint)
 169         {
 170                 if (m_Dimensionality != datapoint->m_Dimensionality) return;
 171                 append ( datapoint);
 172
 173         }
 174 //----------------------------------------------------------------------------------//
 175         void VideoFrame::AddLabels( CSS string)
 176         {
 177                 m_DimensionLabels.Append (string);
 178
 179         }
 180
 181 //----------------------------------------------------------------------------------//
 182 //                                              Graphic View class
 183 //----------------------------------------------------------------------------------//
 184
 185 //////////////////////////////////////////////////////////////////////
 186 // Construction/Destruction
 187 //////////////////////////////////////////////////////////////////////7
 188
 189 GraphicView::GraphicView()
 190 {
 191         m_filter = NULL;
 192 }
 193 GraphicView::GraphicView(Q3Canvas *canvas, QMap<QString, QString>* filter, QWidget *parent)
 194     : Q3CanvasView(canvas, parent)
 195 {
 196     pendingItem = 0;
 197     activeItem = 0;
 198         m_MyState = 0;
 199         m_MyStem = 0;
 200         m_IsStateView = false;
 201         m_MyRoots = 0;
 202         m_filter = filter;
 203     createActions();
 204
 205 }
 206
 207
 208 GraphicView::~GraphicView()
 209 {
 210
 211 }
 212
 213
 214 ////////////////////////////////
 215 //// Create Action function
 216
 217 void GraphicView::createActions()
 218 {
 219
 220     PropertiesAct = new QAction(tr("&Properties..."), this);
 221     connect(PropertiesAct, SIGNAL(activated()),this, SLOT(Properties()));
 222
 223         PlotStatesAct = new QAction(tr("&Graphic Display State"), this);
 224     connect(PlotStatesAct, SIGNAL(activated()), this, SLOT(PlotStates()));
 225
 226         RefreshAct = new QAction(tr("&Refresh"), this);
 227     connect(RefreshAct, SIGNAL(activated()), this, SLOT(Refresh()));
 228
 229
 230         DisplayMeAct = new QAction(tr("&DisplayMe"), this);
 231     connect(DisplayMeAct, SIGNAL(activated()), this, SLOT(DisplayMe()));
 232
 233
 234
 235 }
 236
 237
 238 //////////////////////////////////
 239 ///  Three Slot functions
 240 // this is used for compounds, among other things.
 241 void GraphicView::PlotStates()
 242 {
 243         this->activeItem = 0;
 244
 245         if (m_MyState != 0) {
 246                 // Removed with Yu Hu’s FSA code.
 247                 struct not_implemented { };
 248
 249                 throw not_implemented();
 250         }
 251         if (m_MyRoots != 0) {
 252                 // Clear qcanvas
 253                 foreach (Q3CanvasItem* i, canvas()->allItems())
 254                         delete i;
 255
 256                 // Get current parameters of qcanvasview
 257                 // and resize the qcanvas to fit this view
 258                 int CanvasView_Height = height();
 259                 int CanvasView_Width = width();
 260                 canvas()->resize(CanvasView_Width - 5, CanvasView_Height - 5);
 261
 262                 // Display the forest
 263                 int x = 10;
 264                 foreach (CEdge* edge, *m_MyRoots) {
 265                         QRect rectangle = edge->m_Daughters.first()
 266                                 ->drawTree(canvas(), x, 0, m_filter);
 267                         x = rectangle.right() + 20;
 268                 }
 269         }
 270 }
 271
 272 void GraphicView::Refresh()
 273 {
 274         if ( m_IsStateView)
 275         {
 276                 if ( m_MyState)
 277                 {
 278                         PlotStates();
 279                 }
 280         }
 281         else
 282         {
 283                 if ( m_MyStem)
 284                 {
 285                         PlotStems();
 286                 }
 287         }
 288 }
 289
 290 void GraphicView::DisplayMe()
 291 {
 292         if (DiagramBox* Box = dynamic_cast<DiagramBox*>(activeItem)) {
 293                 CState* pState = Box->m_MyState;
 294                 SetMyState(pState);
 295                 PlotStates();
 296         }
 297 }
 298
 299 void GraphicView::Properties()
 300 {
 301         if ( !m_IsStateView) return;
 302
 303     if ((activeItem) && (activeItem->rtti() == DiagramBox::RTTI ))
 304         {
 305         PropertiesDialog dialog;
 306         dialog.exec(activeItem);
 307                 return;
 308         }
 309
 310         if ((activeItem) && (activeItem->rtti() == DiagramLine::RTTI ))
 311         {
 312         LinePropertiesDialog dialog;
 313         dialog.exec(activeItem);
 314                 return;
 315         }
 316
 317
 318 }
 319
 320 void GraphicView::PlotStems()
 321 {
 322
 323         if ( !m_MyStem) return;
 324
 325         //int                                           DebugInt;
 326         int                                                     CanvasView_Height,Canvas_Height;
 327         int                                                     CanvasView_Width,Canvas_Width;
 328         int                                                     CanvasLeftUpperX;
 329         int                                                     CanvasLeftUpperY;
 330         QRect                                           RectOfCanvas;
 331         Q3CanvasItem                                    *AddedText;
 332         int                                                     XLocOfOneBar, YLocOfOneBar;
 333         int                                                     WidthOfOneBar = 60;
 334         int                                                     leftReserve =60;
 335         int                                                     rightReserve =60;
 336         int                                                     topReserve = 20;
 337         int                                                     bottemReserve = 20;
 338         int                                                     nameBarHeight = 40;
 339         int                                                     YOfTheNameBars;
 340         QString                                         DisplayText;
 341         int                                                     numberOfUnigrams;
 342         int                                                     numberOfMIs;
 343         int                                                     totalBars;
 344         double                                          maximumPostive;
 345         double                                          maximumNegative;
 346         double                                          totalValueRange;
 347         int                                                     attemptedHeight;
 348         int                                                     attemptedWidthOfCanvas;
 349         int                                                     i;
 350         double                                          oneLogValue;
 351         QString                                         oneNameValue;
 352
 353
 354         activeItem = 0;
 355
 356         // Get some parmaters from the CStem
 357         numberOfUnigrams = m_MyStem ->m_countofunigrams;
 358         numberOfMIs = m_MyStem ->m_countofmis;
 359         totalBars = numberOfUnigrams + numberOfMIs;
 360         maximumPostive = m_MyStem ->m_maxpositive;
 361         maximumNegative = -(m_MyStem ->m_maxnegative);
 362         totalValueRange = maximumPostive + maximumNegative;
 363
 364
 365         attemptedWidthOfCanvas =leftReserve + WidthOfOneBar* (totalBars +1)+ rightReserve ; // this 1 is for the first "#"
 366
 367
 368         // Clear qcanvas
 369         Q3CanvasItemList list = canvas()->allItems();
 370     Q3CanvasItemList::Iterator it = list.begin();
 371     for (; it != list.end(); ++it)
 372         {
 373         if ( *it ) delete *it;
 374     }
 375
 376         pendingItem = NULL;
 377         activeItem = NULL;
 378
 379
 380         // Get current parameters of qcanvasview and resize the qcanvas to fit this view
 381         CanvasView_Height = height();
 382         CanvasView_Width  = width();
 383
 384         if ( CanvasView_Width >= attemptedWidthOfCanvas)
 385         {
 386                 canvas()->resize(CanvasView_Width, CanvasView_Height-20);
 387         }
 388         else
 389         {
 390                 canvas()->resize(attemptedWidthOfCanvas, CanvasView_Height - 20);
 391         }
 392
 393         RectOfCanvas = canvas()->rect();
 394         RectOfCanvas.rect(&CanvasLeftUpperX, &CanvasLeftUpperY, &Canvas_Width, &Canvas_Height);
 395
 396
 397         // compute the YOfTheNameBars
 398         YOfTheNameBars = Canvas_Height - bottemReserve - nameBarHeight;
 399
 400
 401         // compute height for display bars
 402         attemptedHeight = Canvas_Height - topReserve - bottemReserve - nameBarHeight;
 403
 404         // compute the zeroLineHeigt
 405         int zeroLineHeight = static_cast<int>(
 406                 double(attemptedHeight) * (maximumPostive/totalValueRange));
 407
 408         if ( zeroLineHeight > attemptedHeight)
 409         {
 410                 zeroLineHeight = attemptedHeight;
 411         }
 412
 413         // Draw the zero line
 414         Q3CanvasLine* AddedLine = new Q3CanvasLine(canvas());
 415         zeroLineHeight += topReserve;
 416         AddedLine->setPoints(0,zeroLineHeight, Canvas_Width, zeroLineHeight);
 417         showNewItem(AddedLine);
 418
 419         //Add the first probbox refer to the first "#" a WidthOfOneBar x 20 positive bar
 420         XLocOfOneBar = leftReserve;
 421         YLocOfOneBar = zeroLineHeight - 20;
 422         int HeightOfOneBar = 20;
 423
 424         ProbBox* AddedBar = new ProbBox(canvas(),
 425                 WidthOfOneBar, HeightOfOneBar, true, 1);
 426         DisplayText = QString("   Unigram");
 427         AddedBar->setText(DisplayText);
 428         AddedBar->move(XLocOfOneBar, YLocOfOneBar);
 429         showNewItem(AddedBar);
 430
 431         // Add text for this "#" bar
 432         AddedText = new Q3CanvasText(QString("      # "),canvas() );
 433         AddedText ->move(XLocOfOneBar, YOfTheNameBars);
 434     showNewItem(AddedText);
 435
 436
 437         // Add ProbBox one by one. They might be Unigram prob, MI...
 438         for ( i =0; i< numberOfUnigrams; i++)
 439         {
 440                 // One MI bar
 441                 oneLogValue = m_MyStem ->m_mis[i];
 442
 443                 if ( oneLogValue > 0)
 444                 {
 445                         XLocOfOneBar = leftReserve + WidthOfOneBar + i*2*WidthOfOneBar;
 446                         int HeightOfOneBar = static_cast<int>(
 447                                 double(attemptedHeight) *
 448                                 (oneLogValue/totalValueRange));
 449
 450                         YLocOfOneBar = zeroLineHeight - HeightOfOneBar;
 451
 452                         ProbBox* AddedBar = new ProbBox(canvas(), WidthOfOneBar, HeightOfOneBar, true, 2);
 453                         DisplayText = QString("   MI: \n:   %1 ").arg(oneLogValue);
 454                         AddedBar->setText(DisplayText);
 455                         AddedBar->move(XLocOfOneBar, YLocOfOneBar);
 456                         showNewItem(AddedBar);
 457
 458                 }
 459                 else if ( oneLogValue < 0)
 460                 {
 461                         oneLogValue = -oneLogValue;
 462
 463                         XLocOfOneBar = leftReserve + WidthOfOneBar + i*2*WidthOfOneBar;
 464
 465                         int HeightOfOneBar = static_cast<int>(
 466                                 double(attemptedHeight) *
 467                                 (oneLogValue/totalValueRange));
 468
 469                         YLocOfOneBar = zeroLineHeight;
 470
 471                         ProbBox* AddedBar = new ProbBox(canvas(),
 472                                 WidthOfOneBar, HeightOfOneBar, false, 2);
 473                         DisplayText = QString("   MI: \n:   -%1 ").arg(oneLogValue);
 474                         AddedBar->setText(DisplayText);
 475                         AddedBar->move(XLocOfOneBar, YLocOfOneBar);
 476                         showNewItem(AddedBar);
 477                 }
 478
 479                 // One Unigram Bar
 480                 oneLogValue = m_MyStem ->m_unigrams[i]; // oneLogValue can only be > 0
 481
 482                 XLocOfOneBar = leftReserve + WidthOfOneBar + i*2*WidthOfOneBar + WidthOfOneBar;
 483
 484                 int HeightOfOneBar = static_cast<int>(
 485                         double(attemptedHeight) *
 486                         (oneLogValue/totalValueRange));
 487
 488                 YLocOfOneBar = zeroLineHeight - HeightOfOneBar;
 489
 490                 ProbBox* AddedBar = new ProbBox(canvas(),
 491                         WidthOfOneBar, HeightOfOneBar, true, 1);
 492                 DisplayText = QString("   Unigram: \n:   %1 ").arg(oneLogValue);
 493                 AddedBar->setText(DisplayText);
 494                 AddedBar->move(XLocOfOneBar, YLocOfOneBar);
 495                 showNewItem(AddedBar);
 496
 497                 // Put on the Name Bar
 498                 oneNameValue = m_MyStem ->m_phonologies[i];
 499                 AddedText = new Q3CanvasText(QString("      %1").arg(oneNameValue),canvas() );
 500                 AddedText ->move(XLocOfOneBar, YOfTheNameBars);
 501                 showNewItem(AddedText);
 502         }
 503
 504
 505
 506 }
 507 /////////////////////////////////////////////////////////////////////////
 508 // will not be used:
 509 /////////////////////////////////////////////////////////////////////////
 510
 511 void GraphicView::PlotNVectors(int numberOfDimensions, int numberOfDataPoints, double** ptrData, IntToString listOfSymbols)
 512 {
 513 //      int                                                     leftReserve                     = 60;           unused variables: leftReserve, rightReserve, topReserve, bottemReserve,
 514 //      int                                                     rightReserve            = 60;
 515 //      int                                                     topReserve                      = 20;
 516 //      int                                                     bottemReserve           = 20;
 517         int                                                     CanvasView_Height,Canvas_Height;
 518         int                                                     CanvasView_Width,Canvas_Width;
 519         int                                                     CanvasLeftUpperX;
 520         int                                                     CanvasLeftUpperY;
 521         int                                                     CanvasCenterX;
 522         int                                                     CanvasCenterY;
 523         int                                                     XLocOfOneAnchor;
 524         int                                                     YLocOfOneAnchor;
 525         int                                                     radiusOfTheCircle;
 526         int                                                     radiusOfOneAnchor       = 20;
 527         QRect                                           RectOfCanvas;
 528         Anchor*                                         oneAnchor;
 529         QString                                         displayText;
 530         int                                                     stateNumber;
 531         double                                          anchorDegree;
 532         double**                                        anchorCoordinates;
 533         int                                                     i;
 534         double                                          XLocOfOneDataPoint,
 535                                                                 YLocOfOneDataPoint;
 536         Q3CanvasText*                           oneDataPointText;
 537
 538
 539
 540         if (numberOfDimensions < 2)
 541         {
 542                 QMessageBox::information ( NULL, "Warning", "We don't support a dimension less than 2!", "OK" );
 543                 return;
 544         }
 545
 546         if (numberOfDataPoints < 1)
 547         {
 548                 QMessageBox::information ( NULL, "Warning", "Number Of data points is less than 1!", "OK" );
 549                 return;
 550         }
 551
 552         if (ptrData == NULL)
 553         {
 554                 QMessageBox::information ( NULL, "Warning", "Pointer to Data is NULL!", "OK" );
 555                 return;
 556         }
 557
 558
 559         // Get data parameters
 560         m_numberOfDimension                     = numberOfDimensions;
 561 //      m_numberOfDataPoints            = numberOfDataPoints;
 562         m_multiDimensionDataPoints      = ptrData;
 563
 564         // Clear qcanvas
 565         Q3CanvasItemList list           = canvas()->allItems();
 566         Q3CanvasItemList::Iterator it = list.begin();
 567         for (; it != list.end(); ++it)
 568         {
 569                 if ( *it ) delete *it;
 570         }
 571
 572         pendingItem                                     = NULL;
 573         activeItem                                      = NULL;
 574
 575         // Get current parameters of qcanvasview and resize the qcanvas to fit this view
 576         CanvasView_Height                       = height();
 577         CanvasView_Width                        = width();
 578
 579         canvas()                                        ->resize(CanvasView_Width -15, CanvasView_Height -15);
 580         RectOfCanvas                            = canvas()->rect();
 581         RectOfCanvas                            .rect(&CanvasLeftUpperX, &CanvasLeftUpperY, &Canvas_Width, &Canvas_Height);
 582
 583         if ( Canvas_Width > Canvas_Height )
 584         {
 585                 radiusOfTheCircle = Canvas_Height/2 - 5;
 586         }
 587         else
 588         {
 589                 radiusOfTheCircle = Canvas_Width/2 - 5;
 590         }
 591
 592         //JG:
 593         //radiusOfTheCircle                     = 100;
 594
 595
 596         CanvasCenterX                           = int ( CanvasLeftUpperX + 0.5 * Canvas_Width );
 597         CanvasCenterY                           = int ( CanvasLeftUpperY + 0.5 * Canvas_Height );
 598
 599         //allocate memory for anchors
 600         anchorCoordinates                       = new double*[numberOfDimensions];
 601         for ( i=0; i<numberOfDimensions; i++)
 602         {
 603                 anchorCoordinates[i] = new double[2];
 604         }
 605
 606
 607         // Next, locate the anchors one by one.
 608         // first anchor is as easy as ( CanvasCenterX +radiusOfTheCircle ,CanvasCenterY)
 609         oneAnchor                                       = new Anchor(canvas(), radiusOfOneAnchor, radiusOfOneAnchor);
 610         stateNumber                                     = 0;
 611         displayText                                     = QString("%1").arg(stateNumber);
 612         oneAnchor                                       ->setText(displayText);
 613         XLocOfOneAnchor                         = CanvasCenterX +radiusOfTheCircle;
 614         YLocOfOneAnchor                         = CanvasCenterY;
 615         oneAnchor                                       ->move(XLocOfOneAnchor, YLocOfOneAnchor);
 616     showNewItem(oneAnchor);
 617         anchorCoordinates[stateNumber][0] = XLocOfOneAnchor;
 618         anchorCoordinates[stateNumber][1] = YLocOfOneAnchor;
 619         stateNumber++;
 620
 621
 622         // Now the rest of the anchors:
 623         while(stateNumber < numberOfDimensions)
 624         {
 625                 oneAnchor                               = new Anchor(canvas(), radiusOfOneAnchor, radiusOfOneAnchor);
 626                 anchorDegree                    = stateNumber * (360.0 / numberOfDimensions);
 627                 XLocOfOneAnchor                 = int (CanvasCenterX + radiusOfTheCircle*cos(PI * anchorDegree /180.0 ));
 628                 YLocOfOneAnchor                 = int (CanvasCenterY - radiusOfTheCircle*sin(PI * anchorDegree /180.0 ));
 629                 oneAnchor                               ->move(XLocOfOneAnchor, YLocOfOneAnchor);
 630                 displayText                             = QString("%1").arg(stateNumber);
 631                 oneAnchor                               ->setText(displayText);
 632                 showNewItem(oneAnchor);
 633                 anchorCoordinates[stateNumber][0] = XLocOfOneAnchor;
 634                 anchorCoordinates[stateNumber][1] = YLocOfOneAnchor;
 635                 stateNumber++;
 636         }
 637
 638
 639         // Display the data points
 640         for( i=0; i<numberOfDataPoints; i++)
 641         {
 642                 // deal with i datapoint
 643                 computeProjectedLocForOneDataPoint(
 644                                 numberOfDimensions,
 645                                 anchorCoordinates,
 646                                 ptrData[i],
 647                                 XLocOfOneDataPoint,
 648                                 YLocOfOneDataPoint);
 649
 650                 oneDataPointText        = new Q3CanvasText(canvas());
 651
 652                 //to do: get symbol list
 653                 displayText                     = listOfSymbols[i];
 654                 oneDataPointText        ->setText(displayText);
 655                 oneDataPointText        ->move(XLocOfOneDataPoint, YLocOfOneDataPoint);
 656                 showNewItem(oneDataPointText);
 657         }
 658
 659
 660         //release memory
 661         for(i=0; i<numberOfDimensions; i++)
 662         {
 663                 delete [] anchorCoordinates[i];
 664         }
 665
 666         delete []anchorCoordinates;
 667
 668         return;
 669
 670
 671 }
 672 // ------------------------------------------------------------------------//
 673
 674 void GraphicView::PlotVideo (Video* pVideo)
 675 {
 676 //      int                                                     leftReserve                     = 60;
 677 //      int                                                     rightReserve            = 60; unused variables: leftReserve, rightReserve, topReserve, bottemReserve,
 678 //      int                                                     topReserve                      = 20;
 679 //      int                                                     bottemReserve           = 20;
 680         int                                                     CanvasView_Height,Canvas_Height;
 681         int                                                     CanvasView_Width,Canvas_Width;
 682         int                                                     CanvasLeftUpperX;
 683         int                                                     CanvasLeftUpperY;
 684         int                                                     CanvasCenterX;
 685         int                                                     CanvasCenterY;
 686         int                                                     XLocOfOneAnchor;
 687         int                                                     YLocOfOneAnchor;
 688         int                                                     radiusOfTheCircle;
 689         int                                                     radiusOfOneAnchor       = 20;
 690         QRect                                           RectOfCanvas;
 691         Anchor*                                         oneAnchor;
 692         QString                                         displayText;
 693         int                                                     stateNumber;
 694         double                                          anchorDegree;
 695         double**                                        anchorCoordinates;
 696         int                                                     i;
 697         double                                          XLocOfOneDataPoint,
 698                                                                 YLocOfOneDataPoint;
 699         Q3CanvasText*                           oneDataPointText;
 700
 701         if (pVideo ->GetDimensionality() < 2)
 702         {
 703                 QMessageBox::information ( NULL, "Warning", "We don't support a dimension less than 2!", "OK" );
 704                 return;
 705         }
 706
 707
 708
 709
 710         // Get data parameters
 711         m_numberOfDimension                     = pVideo->GetDimensionality();
 712 //      m_numberOfDataPoints            = pVideo->GetNumberOfDataPoints();
 713
 714         // Get current parameters of qcanvasview and resize the qcanvas to fit this view
 715         CanvasView_Height                       = height();
 716         CanvasView_Width                        = width();
 717
 718         canvas()                                        ->resize(CanvasView_Width -15, CanvasView_Height -15);
 719         RectOfCanvas                            = canvas()->rect();
 720         RectOfCanvas                            .rect(&CanvasLeftUpperX, &CanvasLeftUpperY, &Canvas_Width, &Canvas_Height);
 721
 722         if ( Canvas_Width > Canvas_Height )
 723         {
 724                 radiusOfTheCircle = Canvas_Height/2 - 5;
 725         }
 726         else
 727         {
 728                 radiusOfTheCircle = Canvas_Width/2 - 5;
 729         }
 730
 731         //JG:
 732         //radiusOfTheCircle                     = 100;
 733
 734
 735         CanvasCenterX                           = int ( CanvasLeftUpperX + 0.5 * Canvas_Width );
 736         CanvasCenterY                           = int ( CanvasLeftUpperY + 0.5 * Canvas_Height );
 737
 738         //allocate memory for anchors
 739         anchorCoordinates                       = new double*[m_numberOfDimension];
 740         for ( i=0; i<m_numberOfDimension; i++)
 741         {
 742                 anchorCoordinates[i] = new double[2];
 743         }
 744
 745
 746         // Next, locate the anchors one by one.
 747         // first anchor is as easy as ( CanvasCenterX +radiusOfTheCircle ,CanvasCenterY)
 748
 749
 750         oneAnchor                                       = new Anchor(canvas(), radiusOfOneAnchor, radiusOfOneAnchor);
 751         stateNumber                                     = 0;
 752         displayText                                     = QString("%1").arg(stateNumber);
 753         oneAnchor                                       ->setText(displayText);
 754         XLocOfOneAnchor                         = CanvasCenterX +radiusOfTheCircle;
 755         YLocOfOneAnchor                         = CanvasCenterY;
 756         oneAnchor                                       ->move(XLocOfOneAnchor, YLocOfOneAnchor);
 757     showNewItem(oneAnchor);
 758         anchorCoordinates[stateNumber][0] = XLocOfOneAnchor;
 759         anchorCoordinates[stateNumber][1] = YLocOfOneAnchor;
 760         stateNumber++;
 761
 762
 763         // Now the rest of the anchors:
 764         while(stateNumber < m_numberOfDimension)
 765         {
 766                 oneAnchor                               = new Anchor(canvas(), radiusOfOneAnchor, radiusOfOneAnchor);
 767                 anchorDegree                    = stateNumber * (360.0 / m_numberOfDimension);
 768                 XLocOfOneAnchor                 = int (CanvasCenterX + radiusOfTheCircle*cos(PI * anchorDegree /180.0 ));
 769                 YLocOfOneAnchor                 = int (CanvasCenterY - radiusOfTheCircle*sin(PI * anchorDegree /180.0 ));
 770                 oneAnchor                               ->move(XLocOfOneAnchor, YLocOfOneAnchor);
 771                 displayText                             = QString("%1").arg(stateNumber);
 772                 oneAnchor                               ->setText(displayText);
 773                 showNewItem(oneAnchor);
 774                 anchorCoordinates[stateNumber][0] = XLocOfOneAnchor;
 775                 anchorCoordinates[stateNumber][1] = YLocOfOneAnchor;
 776                 stateNumber++;
 777         }
 778
 779
 780
 781 //      int                                                             time = 0;
 782         VideoFrame*                                             pVideoFrame;
 783         LabeledDataPoint*                               pDataPoint;
 784         // Display the data pointsp
 785         //for ( pVideoFrame = pVideo->first(); pVideoFrame; pVideoFrame= pVideo->next() )
 786         for (int z = 0; z < pVideo->size(); z++)
 787         {       pVideoFrame = pVideo->at(z);
 788
 789                         // ----------   Clear qcanvas -------------------------------//
 790                         Q3CanvasItemList list           = canvas()->allItems();
 791                         Q3CanvasItemList::Iterator it = list.begin();
 792                         for (; it != list.end(); ++it)
 793                         {
 794                                 if ( *it ) delete *it;
 795                         }
 796
 797                         pendingItem                                     = NULL;
 798                         activeItem                                      = NULL;
 799                         // ----------   End of Clear qcanvas -------------------------------//
 800
 801
 802
 803                 //for (pDataPoint = pVideoFrame->first(); pDataPoint; pDataPoint = pVideoFrame->next() )
 804                 for (int y = 0; y < pVideoFrame->size(); y++)
 805                 {       pDataPoint = pVideoFrame->at(y);
 806                         computeProjectedLocForOneDataPoint(
 807 //                                      &iter.data(),
 808                                         pDataPoint,
 809                                         anchorCoordinates,
 810                                         XLocOfOneDataPoint,
 811                                         YLocOfOneDataPoint);
 812                         oneDataPointText        = new Q3CanvasText(canvas());
 813                         displayText                     =  pDataPoint->m_Label;
 814                         oneDataPointText        ->setText(displayText);
 815                         oneDataPointText        ->move(XLocOfOneDataPoint,
 816                                                                            YLocOfOneDataPoint);
 817                         showNewItem(oneDataPointText);
 818                 }
 819                 // Sleep for a short time : Is there any Qt sleep function ?
 820                 int                     dummy, j;
 821                 for(j=0; j<500000; j++)
 822                 {
 823                         dummy = int (base2log (100));
 824                         dummy = int (base2log (100));
 825                 }
 826
 827
 828
 829         }
 830
 831
 832 //      for (time = 0; time < pVideo->size(); time++)
 833 //      {
 834 //              pData = &(*pVideo)[time];
 835 //              VideoFrame::Iterator iter = pData->begin();
 836 //              for (; iter != pData->end(); ++iter)
 837 //              {
 838 //                      /////////////// this is where the main work is done: /////////////////
 839 //                      computeProjectedLocForOneDataPoint(
 840 //                                      &iter.data(),
 841 //                                      pData,
 842 //                                      anchorCoordinates,
 843 //                                      XLocOfOneDataPoint,
 844 //                                      YLocOfOneDataPoint);
 845 //                      oneDataPointText        = new QCanvasText(canvas());
 846 //                      displayText                     =  iter.data().m_Label;
 847 //                      oneDataPointText        ->setText(displayText);
 848 //                      oneDataPointText        ->move(XLocOfOneDataPoint,
 849 //                                                                         YLocOfOneDataPoint);
 850 //                      showNewItem(oneDataPointText);
 851 //                      ///////////////////////////////////////////////////////////////////////
 852 //
 853 //              }
 854 //      }
 855
 856         //release memory
 857         for(i=0; i<m_numberOfDimension; i++)
 858         {
 859                 delete [] anchorCoordinates[i];
 860         }
 861
 862         delete []anchorCoordinates;
 863
 864         return;
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878 }
 879
 880 // ------------------------------------------------------------------------//
 881 // John rewrote: 7 2006
 882 void GraphicView::PlotNVectors2(VideoFrame* Data )
 883 {
 884 //      int                                                     leftReserve                     = 60;           unused variables: leftReserve, rightReserve, topReserve, bottemReserve,
 885 //      int                                                     rightReserve            = 60;
 886 //      int                                                     topReserve                      = 20;
 887 //      int                                                     bottemReserve           = 20;
 888         int                                                     CanvasView_Height,Canvas_Height;
 889         int                                                     CanvasView_Width,Canvas_Width;
 890         int                                                     CanvasLeftUpperX;
 891         int                                                     CanvasLeftUpperY;
 892         int                                                     CanvasCenterX;
 893         int                                                     CanvasCenterY;
 894         int                                                     XLocOfOneAnchor;
 895         int                                                     YLocOfOneAnchor;
 896         int                                                     radiusOfTheCircle;
 897         int                                                     radiusOfOneAnchor       = 20;
 898         QRect                                           RectOfCanvas;
 899         Anchor*                                         oneAnchor;
 900         QString                                         displayText;
 901         int                                                     stateNumber;
 902         double                                          anchorDegree;
 903         double**                                        anchorCoordinates;
 904         int                                                     i;
 905         double                                          XLocOfOneDataPoint,
 906                                                                 YLocOfOneDataPoint;
 907         Q3CanvasText*                           oneDataPointText;
 908
 909         if (Data->m_Dimensionality < 2)
 910         {
 911                 QMessageBox::information ( NULL, "Warning", "We don't support a dimension less than 2!", "OK" );
 912                 return;
 913         }
 914
 915         // TODO: put this back in (reformulated, though)
 916 //      if (Data->size() < 1)
 917 //      {
 918 //              QMessageBox::information ( NULL, "Warning", "Number Of data points is less than 1!", "OK" );
 919 //              return;
 920 //      }
 921
 922
 923
 924         // Get data parameters
 925         m_numberOfDimension                     = Data->m_Dimensionality;
 926 //      m_numberOfDataPoints            = Data->size();
 927
 928         // Clear qcanvas
 929         Q3CanvasItemList list           = canvas()->allItems();
 930         Q3CanvasItemList::Iterator it = list.begin();
 931         for (; it != list.end(); ++it)
 932         {
 933                 if ( *it ) delete *it;
 934         }
 935
 936         pendingItem                                     = NULL;
 937         activeItem                                      = NULL;
 938
 939         // Get current parameters of qcanvasview and resize the qcanvas to fit this view
 940         CanvasView_Height                       = height();
 941         CanvasView_Width                        = width();
 942
 943         canvas()                                        ->resize(CanvasView_Width -15, CanvasView_Height -15);
 944         RectOfCanvas                            = canvas()->rect();
 945         RectOfCanvas                            .rect(&CanvasLeftUpperX, &CanvasLeftUpperY, &Canvas_Width, &Canvas_Height);
 946
 947         if ( Canvas_Width > Canvas_Height )
 948         {
 949                 radiusOfTheCircle = Canvas_Height/2 - 5;
 950         }
 951         else
 952         {
 953                 radiusOfTheCircle = Canvas_Width/2 - 5;
 954         }
 955
 956         //JG:
 957         //radiusOfTheCircle                     = 100;
 958
 959
 960         CanvasCenterX                           = int (CanvasLeftUpperX + 0.5 * Canvas_Width);
 961         CanvasCenterY                           = int (CanvasLeftUpperY + 0.5 * Canvas_Height);
 962
 963         //allocate memory for anchors
 964         anchorCoordinates                       = new double*[m_numberOfDimension];
 965         for ( i=0; i<m_numberOfDimension; i++)
 966         {
 967                 anchorCoordinates[i] = new double[2];
 968         }
 969
 970
 971         // Next, locate the anchors one by one.
 972         // first anchor is as easy as ( CanvasCenterX +radiusOfTheCircle ,CanvasCenterY)
 973
 974
 975         oneAnchor                                       = new Anchor(canvas(), radiusOfOneAnchor, radiusOfOneAnchor);
 976         stateNumber                                     = 0;
 977         displayText                                     = QString("%1").arg(stateNumber);
 978         oneAnchor                                       ->setText(displayText);
 979         XLocOfOneAnchor                         = CanvasCenterX +radiusOfTheCircle;
 980         YLocOfOneAnchor                         = CanvasCenterY;
 981         oneAnchor                                       ->move(XLocOfOneAnchor, YLocOfOneAnchor);
 982     showNewItem(oneAnchor);
 983         anchorCoordinates[stateNumber][0] = XLocOfOneAnchor;
 984         anchorCoordinates[stateNumber][1] = YLocOfOneAnchor;
 985         stateNumber++;
 986
 987
 988         // Now the rest of the anchors:
 989         while(stateNumber < m_numberOfDimension)
 990         {
 991                 oneAnchor                               = new Anchor(canvas(), radiusOfOneAnchor, radiusOfOneAnchor);
 992                 anchorDegree                    = stateNumber * (360.0 / m_numberOfDimension);
 993                 XLocOfOneAnchor                 = int(CanvasCenterX + radiusOfTheCircle*cos(PI * anchorDegree /180.0 ));
 994                 YLocOfOneAnchor                 = int(CanvasCenterY - radiusOfTheCircle*sin(PI * anchorDegree /180.0 ));
 995                 oneAnchor                               ->move(XLocOfOneAnchor, YLocOfOneAnchor);
 996                 displayText                             = QString("%1").arg(stateNumber);
 997                 oneAnchor                               ->setText(displayText);
 998                 showNewItem(oneAnchor);
 999                 anchorCoordinates[stateNumber][0] = XLocOfOneAnchor;
1000                 anchorCoordinates[stateNumber][1] = YLocOfOneAnchor;
1001                 stateNumber++;
1002         }
1003
1004
1005
1006         LabeledDataPoint*                               pDataPoint;
1007         // Display the data pointsp
1008         //for (pDataPoint = Data->first(); pDataPoint; pDataPoint = Data->next() )
1009         for (int z = 0; z < Data->size(); z++)
1010         {       pDataPoint = Data->at(z);
1011                 computeProjectedLocForOneDataPoint(
1012                                 pDataPoint,
1013                                 anchorCoordinates,
1014                                 XLocOfOneDataPoint,
1015                                 YLocOfOneDataPoint);
1016                 oneDataPointText        = new Q3CanvasText(canvas());
1017                 displayText                     =  pDataPoint->m_Label;
1018                 oneDataPointText        ->setText(displayText);
1019                 oneDataPointText        ->move(XLocOfOneDataPoint,
1020                                                                            YLocOfOneDataPoint);
1021                 showNewItem(oneDataPointText);
1022         }
1023
1024
1025
1026         //release memory
1027         for(i=0; i<m_numberOfDimension; i++)
1028         {
1029                 delete [] anchorCoordinates[i];
1030         }
1031
1032         delete []anchorCoordinates;
1033
1034         return;
1035
1036
1037 }
1038 //rewritten JG July 2006
1039 void GraphicView::computeProjectedLocForOneDataPoint( LabeledDataPoint* Data,
1040                                                                                                         double** anchorCoordinates,
1041                                                                                                         double& xCoordinate,
1042                                                                                                         double& yCoordinate)
1043 {
1044         int                             i;
1045         double*                 weights;
1046         double                  sumHighDimensionData = 0.0;
1047
1048         for ( i=0; i< Data->m_Dimensionality; i++)
1049         {
1050                 sumHighDimensionData += Data->m_Values[i];
1051         }
1052
1053         weights = new double[Data->m_Dimensionality];
1054
1055         for ( i=0; i< Data->m_Dimensionality; i++)
1056         {
1057                 weights[i] = Data->m_Values[i] / sumHighDimensionData;
1058         }
1059
1060         xCoordinate = 0.0;
1061         yCoordinate = 0.0;
1062
1063         // Compute xCoordinate and  yCoordinate
1064         for ( i=0; i< Data->m_Dimensionality; i++)
1065         {
1066                 xCoordinate += weights[i] * anchorCoordinates[i][0]; // anchorCoordinates[i][0] keeps the xCoordinate of anchor i
1067                 yCoordinate += weights[i] * anchorCoordinates[i][1]; // anchorCoordinates[i][1] keeps the yCoordinate of anchor i
1068         }
1069
1070         delete []weights;
1071 }
1072
1073 //: will not be used:
1074 void GraphicView::computeProjectedLocForOneDataPoint(int numberOfStates,
1075                                                                                                         double** anchorCoordinates,
1076                                                                                                         double* highDimensionData,
1077                                                                                                         double& xCoordinate,
1078                                                                                                         double& yCoordinate)
1079 {
1080         int                             i;
1081         double*                 weights;
1082         double                  sumHighDimensionData = 0.0;
1083
1084         for ( i=0; i< numberOfStates; i++)
1085         {
1086                 sumHighDimensionData += highDimensionData[i];
1087         }
1088
1089         weights = new double[numberOfStates];
1090
1091         for ( i=0; i< numberOfStates; i++)
1092         {
1093                 weights[i] = highDimensionData[i] / sumHighDimensionData;
1094         }
1095
1096         xCoordinate = 0.0;
1097         yCoordinate = 0.0;
1098
1099         // Compute xCoordinate and  yCoordinate
1100         for ( i=0; i< numberOfStates; i++)
1101         {
1102                 xCoordinate += weights[i] * anchorCoordinates[i][0]; // anchorCoordinates[i][0] keeps the xCoordinate of anchor i
1103                 yCoordinate += weights[i] * anchorCoordinates[i][1]; // anchorCoordinates[i][1] keeps the yCoordinate of anchor i
1104         }
1105
1106         delete []weights;
1107 }
1108
1109 /////////////////////////////
1110 //// Mouse event functions
1111
1112
1113 void GraphicView::contentsContextMenuEvent(QContextMenuEvent *event)
1114 {
1115         if ( !m_IsStateView) return;
1116
1117     Q3PopupMenu contextMenu(this);
1118     if (activeItem )
1119         {
1120
1121                 if ( activeItem ->rtti() == DiagramBox::RTTI)
1122                 {
1123                         contextMenu.insertSeparator();
1124                         PropertiesAct->addTo(&contextMenu);
1125                         contextMenu.insertSeparator();
1126                         DisplayMeAct->addTo(&contextMenu);
1127                 }
1128                 else
1129                 {
1130                         contextMenu.insertSeparator();
1131                         PropertiesAct->addTo(&contextMenu);
1132                 }
1133
1134     }
1135         else
1136         {
1137                 RefreshAct->addTo(&contextMenu);
1138         contextMenu.insertSeparator();
1139                 PlotStatesAct->addTo(&contextMenu);
1140     }
1141     contextMenu.exec(event->globalPos());
1142 }
1143
1144
1145
1146 void GraphicView::contentsMousePressEvent(QMouseEvent *event)
1147 {
1148     if ( !m_IsStateView) return;
1149
1150          if ( event->button() == Qt::LeftButton )
1151          {
1152                 Q3CanvasItemList items = canvas()->collisions(event->pos());
1153
1154                 if (items.empty())
1155                 {
1156                         setActiveItem(0);
1157                 }
1158                 else
1159                 {
1160                         setActiveItem(*items.begin());
1161                 }
1162          }
1163 }
1164
1165
1166
1167 void GraphicView::contentsMouseDoubleClickEvent(QMouseEvent *event)
1168 {
1169         if ( !m_IsStateView) return;
1170
1171     if (event->button() == Qt::LeftButton && activeItem)
1172         {
1173                 Properties();
1174     }
1175
1176 }
1177
1178
1179 ///////////////////////////////////////
1180 //// Some other necessary functions
1181
1182 void GraphicView::showNewItem(Q3CanvasItem *item)
1183 {
1184     setActiveItem(item);
1185     item->show();
1186     canvas()->update();
1187 }
1188
1189 void GraphicView::setActiveItem(Q3CanvasItem *item)
1190 {
1191     if (item != activeItem)
1192         {
1193         if (activeItem) activeItem->setActive(false);
1194
1195                 activeItem = item;
1196
1197                 if (activeItem) activeItem->setActive(true);
1198
1199         canvas()->update();
1200     }
1201 }
1202
1203
1204
1205 //////////////////////////////////////////////
1206 /////////////////////////////////////////////
1207 ///  Next are implementation of DiagramBox
1208
1209
1210 DiagramBox::DiagramBox(Q3Canvas *canvas)
1211     : Q3CanvasRectangle(canvas)
1212 {
1213         setSize(100, 60);
1214         setPen(QPen(Qt::blue));
1215         setBrush(Qt::white);
1216         str = "Text";
1217 }
1218
1219 DiagramBox::DiagramBox(Q3Canvas *canvas, int Width, int Height, CState* MyState)
1220         : Q3CanvasRectangle(canvas)
1221 {
1222         setSize(Width, Height);
1223         setPen(QPen(Qt::blue));
1224         setBrush(Qt::white);
1225         str = "Text";
1226         m_MyState = MyState;
1227 }
1228
1229
1230 DiagramBox::~DiagramBox()
1231 {
1232     hide();
1233 }
1234
1235 void DiagramBox::setText(const QString &newText)
1236 {
1237     str = newText;
1238     update();
1239 }
1240
1241
1242 void DiagramBox::drawShape(QPainter &painter)
1243 {
1244         Q3CanvasRectangle::drawShape(painter);
1245     painter.drawText(rect(), Qt::AlignLeft, text());
1246
1247 }
1248
1249
1250 //////////////////////////////////////////////
1251 /////////////////////////////////////////////
1252 ///  Next are implementation of ProbBox
1253
1254
1255 ProbBox::ProbBox(Q3Canvas *canvas)
1256     : Q3CanvasRectangle(canvas)
1257 {
1258     setSize(100, 60);
1259     setPen(QPen(Qt::blue));
1260     setBrush(Qt::white);
1261     str = "Text";
1262 }
1263
1264 ProbBox::ProbBox(Q3Canvas *canvas, int Width, int Height, bool positive, int type)
1265         : Q3CanvasRectangle(canvas)
1266 {
1267         // type =1 --> Unigram;  type = 2 --> MI
1268
1269         setSize(Width, Height);
1270         if ( positive)
1271         {
1272                 if ( type == 1)
1273                 {
1274                         setPen(QPen(Qt::blue));
1275                         setBrush(Qt::green);
1276                 }
1277                 else if ( type == 2)
1278                 {
1279                         setPen(QPen(Qt::red));
1280                         setBrush(Qt::blue);
1281                 }
1282                 else
1283                 {
1284                         setPen(QPen(Qt::white));
1285                         setBrush(Qt::white);
1286                 }
1287         }
1288         else
1289         {
1290                 setPen(QPen(Qt::black));
1291                 setBrush(Qt::red);
1292         }
1293     str = "Text";
1294
1295 }
1296
1297
1298 ProbBox::~ProbBox()
1299 {
1300     hide();
1301 }
1302
1303 void ProbBox::setText(const QString &newText)
1304 {
1305     str = newText;
1306     update();
1307 }
1308
1309
1310 void ProbBox::drawShape(QPainter &painter)
1311 {
1312         Q3CanvasRectangle::drawShape(painter);
1313     painter.drawText(rect(), Qt::AlignLeft, text());
1314
1315 }
1316
1317
1318
1319
1320 /////////////////////////////////////////////
1321 ///// Implementation of DiagramLine
1322
1323 DiagramLine::DiagramLine(Q3Canvas *canvas)
1324     : Q3CanvasLine(canvas)
1325 {
1326     setPoints(0, 0, 0, 99);
1327 }
1328 /*
1329 DiagramLine::DiagramLine(QCanvas *canvas, int SX, int SY, int EX, int EY, int FromState, int ToState, QMap<QString, int>* Morphemes, Morphology* MyMorphology)
1330         : QCanvasLine(canvas)
1331 {
1332         setPen(QPen(Qt::red));
1333         setPoints(SX, SY, EX, EY);
1334         m_FromWhichState = FromState;
1335         m_ToWhichState = ToState;
1336         m_Morphemes = *Morphemes;
1337         m_MyMorphology = MyMorphology;
1338 }
1339 */
1340 DiagramLine::~DiagramLine()
1341 {
1342     hide();
1343 }
1344
1345 void DiagramLine::drawShape(QPainter &painter)
1346 {
1347     Q3CanvasLine::drawShape(painter);
1348 }
1349
1350 //////////////////////////////////////////////
1351 /////////////////////////////////////////////
1352 ///  Next are implementation of DiagramBox
1353
1354
1355 Anchor::Anchor(Q3Canvas *canvas)
1356     : Q3CanvasEllipse(canvas)
1357 {
1358     setSize(60, 60);
1359     setPen(QPen(Qt::blue));
1360     setBrush(Qt::white);
1361     m_str = "Text";
1362 }
1363
1364 Anchor::Anchor(Q3Canvas *canvas, int Width, int Height)
1365         : Q3CanvasEllipse(canvas)
1366 {
1367         setSize(Width, Height);
1368     setPen(QPen(Qt::white));
1369     setBrush(Qt::blue);
1370     m_str = "Text";
1371
1372 }
1373
1374
1375 Anchor::~Anchor()
1376 {
1377     hide();
1378 }
1379
1380 void Anchor::setText(const QString &newText)
1381 {
1382     m_str = newText;
1383     update();
1384 }
1385
1386
1387 void Anchor::drawShape(QPainter &painter)
1388 {
1389         QPen            pen(Qt::white, 2);
1390
1391         Q3CanvasEllipse::drawShape(painter);
1392
1393         painter.setPen(pen);
1394         painter.drawText(boundingRect(), Qt::AlignCenter, text());
1395 }