#include <QtGui>

#include "VRichScene.h"
#include "VRichRingItem.h"
#include "VFileManager.h"

#include "CbmRichHit.h"
#include "CbmRichRing.h"
#include "FairTrackParam.h"
#include "CbmRichPoint.h"

#include <string>

VRichScene::VRichScene()
{
    fRingsVisible = true;
    fEllipsesVisible = true;
    fHitsVisible = true;
    fProjVisible = true;
    fPointsVisible = true;

    fRingsColor = Qt::red;
    fEllipsesColor = Qt::gray;
    fHitsColor = Qt::blue;
    fProjColor = Qt::darkGreen;
    fPointsColor = Qt::darkYellow;

    fElRingsVisible = true;
    fPiRingsVisible = true;
    fFakeRingsVisible = true;
    fCloneRingsVisible = true;

    fElRingsColor=Qt::darkYellow;
    fPiRingsColor=Qt::darkYellow;
    fFakeRingsColor=Qt::darkYellow;
    fCloneRingsColor=Qt::darkYellow;

    fLineWidth = 0.5;
    fHitSize = 1.;

    //LoadData();
	setSceneRect( -250, -250, 500, 500);
   // ProcessEvent(0);
}

VRichScene::~VRichScene()
{

}

void VRichScene::LoadData()
{
    VFileManager *fm = VFileManager::instance();

    //TODO uncomment here
    fRichHitsArray = fm->getArray("RichHit");
    fRichRingsArray = fm->getArray("RichRing");
    fRichProjArray = fm->getArray("RichProjection");
    fRichPointsArray = fm->getArray("RichPoint");
}

void VRichScene::ProcessEvent(int ievent)
{
    VFileManager *fm = VFileManager::instance();
    fm->setEventNum(ievent);
    ClearScene();
    DrawEvent();
    DrawGeometry();
}

void VRichScene::ProcessCurEvent()
{
    ClearScene();
    DrawEvent();
    DrawGeometry();
}

void VRichScene::DrawRings()
{
    fRingsGroup = new QGraphicsItemGroup();
    if (!fRichRingsArray){
        qDebug() << "-E- NO fRichRingsArray";
        return;
    }
    CbmRichRing* ring;


    int nofRings = fRichRingsArray->GetEntriesFast();

    for (int iRing = 0; iRing < nofRings; iRing++){
        ring = (CbmRichRing*) fRichRingsArray->At(iRing);
        if (!ring) continue;
        if (ring->GetRadius() > 10) continue;

        int recFlag = ring->GetRecFlag();
        QColor ringsColor = fRingsColor;
        QString recDataSt;
        if (recFlag == 3) {
            ringsColor = fElRingsColor;
            recDataSt = "el";
        }
        if (recFlag == 4) {
            ringsColor = fPiRingsColor;
            recDataSt = "pi";
        }
        if (recFlag == 1) {
            ringsColor = fFakeRingsColor;
            recDataSt = "fake";
        }
        if (recFlag == 2) {
            ringsColor = fCloneRingsColor;
            recDataSt = "clone";
        }

        QGraphicsEllipseItem * ellipse1 =
            new QGraphicsEllipseItem(ring->GetCenterX() - ring->GetRadius(),
                                     ring->GetCenterY()- ring->GetRadius(),
                                    2*ring->GetRadius(), 2*ring->GetRadius() );

        ellipse1->setPen(QPen(ringsColor, fLineWidth));
        QString tip = QString("Ring: Xc= %1 , Yc= %2, R= %3. %4")
                                .arg(ring->GetCenterX())
                                .arg(ring->GetCenterY())
                                .arg(ring->GetRadius())
                                .arg(recDataSt);
        ellipse1->setToolTip(tip);
        ellipse1->setData(0,"ring");
        ellipse1->setData(1, recDataSt);
        //ellipse1->setVisible(fRingsVisible);
        fRingsGroup->addToGroup((QGraphicsItem*)ellipse1);

        QGraphicsEllipseItem * ellipse2 =
            new QGraphicsEllipseItem(ring->GetCenterX() - fHitSize/2.,
                                     ring->GetCenterY() - fHitSize/2.,
                                     fHitSize, fHitSize);

        ellipse2->setPen(QPen(ringsColor));
        ellipse2->setBrush(QBrush(ringsColor));
        QString tip2 = QString("RingCenter: x= %1 , y= %2")
                                .arg(ring->GetCenterX())
                                .arg(ring->GetCenterY());
        ellipse2->setToolTip(tip2);
        ellipse2->setData(0,"ringcenter");
        //ellipse2->setVisible(fRingsVisible);
        fRingsGroup->addToGroup((QGraphicsItem*)ellipse2);
    }
    fRingsGroup->setZValue(1);
    fRingsGroup->setVisible(fRingsVisible);
    this->addItem(fRingsGroup);

}

void VRichScene::DrawEllipses()
{
    fEllipsesGroup = new QGraphicsItemGroup();
    if (!fRichRingsArray){
        qDebug() << "-E- NO fRichRingsArray";
        return;
    }
    CbmRichRing* ring;
    int nofRings = fRichRingsArray->GetEntriesFast();
    for (int iRing = 0; iRing < nofRings; iRing++){
        ring = (CbmRichRing*) fRichRingsArray->At(iRing);
        if (!ring) continue;
        if (ring->GetRadius() > 10) continue;

        QGraphicsEllipseItem * ellipse1 =
            new QGraphicsEllipseItem(ring->GetCenterX() - ring->GetAaxis(),
                                     ring->GetCenterY()- ring->GetBaxis(),
                                    2 * ring->GetAaxis(), 2 * ring->GetBaxis());

        ellipse1->setPen(QPen(fEllipsesColor, fLineWidth));
        QString tip = QString("Ellipse: Xc= %1 , Yc= %2, A= %3, B= %4.")
                                .arg(ring->GetCenterX())
                                .arg(ring->GetCenterY())
                                .arg(ring->GetAaxis())
                                .arg(ring->GetBaxis());
        ellipse1->setToolTip(tip);
        ellipse1->setData(0,"ellipse");
        ellipse1->setData(1, "ellipse");
        //ellipse1->setVisible(fRingsVisible);
        fEllipsesGroup->addToGroup((QGraphicsItem*)ellipse1);

        QGraphicsEllipseItem * ellipse2 =
            new QGraphicsEllipseItem(ring->GetCenterX() - fHitSize/2.,
                                     ring->GetCenterY() - fHitSize/2.,
                                     fHitSize, fHitSize);

        ellipse2->setPen(QPen(fEllipsesColor));
        ellipse2->setBrush(QBrush(fEllipsesColor));
        QString tip2 = QString("Ellipse center: x= %1 , y= %2")
                                .arg(ring->GetCenterX())
                                .arg(ring->GetCenterY());
        ellipse2->setToolTip(tip2);
        ellipse2->setData(0,"ellipsecenter");
        //ellipse2->setVisible(fRingsVisible);
        fEllipsesGroup->addToGroup((QGraphicsItem*)ellipse2);
    }
    fEllipsesGroup->setZValue(1);
    fEllipsesGroup->setVisible(fEllipsesVisible);
    this->addItem(fEllipsesGroup);
}

void VRichScene::DrawRichRingItem()
{
    CbmRichRing* ring;
    CbmRichHit* hit;
    FairTrackParam* proj = NULL;
    double projX, projY;
    fRingItemsGroup = new QGraphicsItemGroup();

    if (!fRichRingsArray){
        qDebug() << "-E- NO fRichRingsArray";
        return;
    }
    if (!fRichProjArray){
        qDebug() << "-E- NO fRichProjArray";
        return;
    }

    int nofRings = fRichRingsArray->GetEntriesFast();
    for (int iRing = 0; iRing < nofRings; iRing++){
        //qDebug() << "iring Beg = " << iRing;
        ring = (CbmRichRing*) fRichRingsArray->At(iRing);
        qDebug() << "track ID = " << ring->GetTrackID();
        if (ring->GetRadius() > 10) continue;

        if (!ring){
            qDebug() << "No Ring " << iRing;
            continue;
        }
        proj = (FairTrackParam*) fRichProjArray->At(ring->GetTrackID());
        if (proj){
            projX = proj->GetX();
            projY = proj->GetY();
        }else{
            qDebug() << "No projection "<< ring->GetTrackID();
            projX = 0.;
            projY = 0.;
        }
        VRichRingItem * ellipse1 =
            new VRichRingItem(ring->GetCenterX(),
                             ring->GetCenterY(),
                             ring->GetRadius(),
                             projX, projY,
                             fLineWidth, fHitSize);
        ellipse1->setData(0,"ringitem");
        ellipse1->setVisible(true);
        int nofHits = ring->GetNofHits();
        for (int iHit = 0; iHit < nofHits; iHit++){
            int hitIndex = ring->GetHit(iHit);
            hit = (CbmRichHit*)fRichHitsArray->At(hitIndex);
            if (!hit){
                qDebug() << "No hit " << hitIndex;
                continue;
            }
            ellipse1->AddHit(hit->GetX(), hit->GetY());
        }
        fRingItemsGroup->addToGroup((QGraphicsItem*)ellipse1);
    }
    fRingItemsGroup->setZValue(4);
    this->addItem(fRingItemsGroup);
}

void VRichScene::DrawHits()
{
    fHitsGroup = new QGraphicsItemGroup();
    if (!fRichHitsArray){
        qDebug() << "-E- NO fRichHitsArray";
        return;
    }

    CbmRichHit* hit;
    int nofHits = fRichHitsArray->GetEntriesFast();
    for (int iHit = 0; iHit < nofHits; iHit++){

        hit = (CbmRichHit*) fRichHitsArray->At(iHit);
        if (!hit) continue;
        QGraphicsEllipseItem * ellipse =
            new QGraphicsEllipseItem(hit->GetX()-fHitSize/2.,
                                     hit->GetY()-fHitSize/2.,
                                     fHitSize,
                                     fHitSize );

        ellipse->setPen(QPen(fHitsColor));
        ellipse->setBrush(QBrush(fHitsColor));
        QString tip = QString("Hit: x= %1 , y= %2")
                                .arg(hit->GetX())
                                .arg(hit->GetY());
        ellipse->setToolTip(tip);
        ellipse->setData(0,"hit");
       // ellipse->setVisible(fHitsVisible);
        fHitsGroup->addToGroup((QGraphicsItem*)ellipse);
    }
    fHitsGroup->setZValue(2);
    fHitsGroup->setVisible(fHitsVisible);
    this->addItem(fHitsGroup);
}

void VRichScene::DrawProjections()
{
    fProjGroup = new QGraphicsItemGroup();
    if (!fRichProjArray){
        qDebug() << "-E- NO fRichProjArray";
        return;
    }
    FairTrackParam* proj;

    int nofProj = fRichProjArray->GetEntriesFast();

    for (int iProj = 0; iProj < nofProj; iProj++){
        proj = (FairTrackParam*) fRichProjArray->At(iProj);
        if (!proj) continue;
        QGraphicsEllipseItem * ellipse =
            new QGraphicsEllipseItem(proj->GetX() - fHitSize/2.,
                                     proj->GetY() - fHitSize/2.,
                                     fHitSize,
                                     fHitSize );

        ellipse->setPen(QPen(fProjColor));
        ellipse->setBrush(QBrush(fProjColor));
        QString tip = QString("Projection: x= %1 , y= %2")
                                .arg(proj->GetX())
                                .arg(proj->GetY());
        ellipse->setToolTip(tip);
        ellipse->setData(0, "proj");
        //ellipse->setVisible(fProjVisible);
        fProjGroup->addToGroup((QGraphicsItem*)ellipse);
    }
    fProjGroup->setZValue(3);
    fProjGroup->setVisible(fProjVisible);
    this->addItem(fProjGroup);
}

void VRichScene::DrawPoints()
{
    fPointsGroup = new QGraphicsItemGroup();
    if (!fRichPointsArray){
        qDebug() << "-E- NO fRichPointsArray";
        return;
    }
 //   CbmRichPoint* point;

    /*int nofPoints = fRichPointsArray->GetEntriesFast();

    for (int iPoint = 0; iPoint < nofPoints; iPoint++){
        point = (CbmRichPoint*) fRichPointsArray->At(iPoint);
        if (!point) continue;
        QGraphicsEllipseItem * ellipse =
            new QGraphicsEllipseItem(point->GetX() - fHitSize/2.,
                                     point->GetY() - fHitSize/2.,
                                     fHitSize,
                                     fHitSize );

        ellipse->setPen(QPen(fPointsColor));
        ellipse->setBrush(QBrush(fPointsColor));
        QString tip = QString("MC point: x= %1 , y= %2")
                                .arg(point->GetX())
                                .arg(point->GetY());
        ellipse->setToolTip(tip);
        ellipse->setData(0, "point");
       // ellipse->setVisible(fPointsVisible);
        fPointsGroup->addToGroup((QGraphicsItem*)ellipse);
    }*/
    fPointsGroup->setZValue(0);
    fPointsGroup->setVisible(fPointsVisible);
    this->addItem(fPointsGroup);
}

void VRichScene::DrawGeometry()
{
    QGraphicsLineItem* lines[8];
    lines[0] = new QGraphicsLineItem(-150,250, 150, 250);
    lines[1] = new QGraphicsLineItem(150,250,150,80);
    lines[2] = new QGraphicsLineItem(150,80,-150,80);
    lines[3] = new QGraphicsLineItem(-150,80,-150,250);
    lines[4] = new QGraphicsLineItem(-150, -80, 150, -80);
    lines[5] = new QGraphicsLineItem(150, -80, 150, -250);
    lines[6] = new QGraphicsLineItem(150, -250, -150, -250);
    lines[7] = new QGraphicsLineItem(-150, -250, -150, -80);
    for (int i = 0; i < 8; i++){
        if (i < 4) lines[i]->setPen(QPen(Qt::red));
        this->addItem(lines[i]);
    }

}

void VRichScene::DrawEvent()
{
    DrawProjections();
    DrawHits();
    DrawRings();
    DrawEllipses();
    DrawRichRingItem();
    DrawPoints();
}

void VRichScene::ChangeItemsVisibility()
{
  //  QList<QGraphicsItem*> items = this->items();
   // for (int i = 0; i < items.count(); i++){
       // if (items[i]->data(0) == "ring" || items[i]->data(0) == "ringcenter"){
       //     items[i]->setVisible(fRingsVisible);
       //     continue;
       // }
        //fRingsGroup->setVisible(fRingsVisible);
        //if (items[i]->data(0) == "hit"){
        //    items[i]->setVisible(fHitsVisible);
        //
        //    continue;
       // }
      //  fHitsGroup->setVisible(fHitsVisible);
       // if (items[i]->data(0) == "proj"){
       //     items[i]->setVisible(fProjVisible);
       //     continue;
       // }
      //  fProjGroup->setVisible(fProjVisible);
   // }
    fRingsGroup->setVisible(fRingsVisible);
    fEllipsesGroup->setVisible(fEllipsesVisible);
    fHitsGroup->setVisible(fHitsVisible);
    fProjGroup->setVisible(fProjVisible);
    fPointsGroup->setVisible(fPointsVisible);
}

void VRichScene::ChangeItemsColor(RichItemsTypeEnum type)
{
	fEllipsesGroup->setVisible(false);
    fRingsGroup->setVisible(false);
    fHitsGroup->setVisible(false);
    fProjGroup->setVisible(false);
    fPointsGroup->setVisible(false);

    QList<QGraphicsItem*> items = this->items();
    for (int i = 0; i < items.count(); i++){

       if (items[i]->data(0) == "ring" && type == kRichRing){
            QAbstractGraphicsShapeItem* item =
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(QPen(fRingsColor, fLineWidth));
            continue;
        }

        if(items[i]->data(0) == "ringcenter" && type == kRichRing){
            QAbstractGraphicsShapeItem* item=
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(QPen(fRingsColor));
            item->setBrush(QBrush(fRingsColor));
            continue;
        }

        if (items[i]->data(0) == "ellipse" && type == kRichEllipse){
             QAbstractGraphicsShapeItem* item =
                 static_cast<QAbstractGraphicsShapeItem*>(items[i]);
             item->setPen(QPen(fEllipsesColor, fLineWidth));
             continue;
         }

         if(items[i]->data(0) == "ellipsecenter" && type == kRichEllipse){
             QAbstractGraphicsShapeItem* item=
                 static_cast<QAbstractGraphicsShapeItem*>(items[i]);
             item->setPen(QPen(fEllipsesColor));
             item->setBrush(QBrush(fEllipsesColor));
             continue;
         }

        if (items[i]->data(0) == "hit" && type == kRichHit){
            QAbstractGraphicsShapeItem* item=
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(QPen(fHitsColor));
            item->setBrush(QBrush(fHitsColor));
            continue;
        }

        if (items[i]->data(0) == "proj" && type == kRichProj){
            QAbstractGraphicsShapeItem* item=
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(QPen(fProjColor));
            item->setBrush(QBrush(fProjColor));
            continue;
        }
        if (items[i]->data(0) == "point" && type == kRichPoint){
            QAbstractGraphicsShapeItem* item =
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(QPen(fPointsColor));
            item->setBrush(QBrush(fPointsColor));
            continue;
        }
    }

    fRingsGroup->setVisible(fRingsVisible);
    fEllipsesGroup->setVisible(fEllipsesVisible);
    fHitsGroup->setVisible(fHitsVisible);
    fProjGroup->setVisible(fProjVisible);
    fPointsGroup->setVisible(fPointsVisible);
}

void VRichScene::ChangeRingsVisibility()
{
    QList<QGraphicsItem*> items = this->items();
    for (int i = 0; i < items.count(); i++){
        if (items[i]->data(0) != "ring") continue;

        if (items[i]->data(1) == "el"){
            items[i]->setVisible(fElRingsVisible);
            continue;
        }
        if (items[i]->data(1) == "pi"){
            items[i]->setVisible(fPiRingsVisible);
            continue;
        }
        if (items[i]->data(1) == "fake"){
            items[i]->setVisible(fFakeRingsVisible);
            continue;
        }
        if (items[i]->data(1) == "clone"){
            items[i]->setVisible(fCloneRingsVisible);
            continue;
        }
    }
}

void VRichScene::ChangeRingsColor(RichRingTypeEnum type)
{
    fRingsGroup->setVisible(false);
    fHitsGroup->setVisible(false);
    fProjGroup->setVisible(false);
    fPointsGroup->setVisible(false);

    QList<QGraphicsItem*> items = this->items();
    for (int i = 0; i < items.count(); i++){
        if (items[i]->data(0) != "ring") continue;

        if (items[i]->data(1) == "el" && type == kRichElRing){
            QAbstractGraphicsShapeItem* item =
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(QPen(fElRingsColor, fLineWidth));
            continue;
        }

        if(items[i]->data(1) == "pi" && type == kRichPiRing){
            QAbstractGraphicsShapeItem* item=
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(QPen(fPiRingsColor, fLineWidth));
            continue;
        }

        if (items[i]->data(1) == "fake" && type == kRichFakeRing){
            QAbstractGraphicsShapeItem* item=
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(QPen(fFakeRingsColor, fLineWidth));
            continue;
        }

        if (items[i]->data(1) == "clone" && type == kRichCloneRing){
            QAbstractGraphicsShapeItem* item=
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(QPen(fCloneRingsColor, fLineWidth));
            continue;
        }
    }
    fRingsGroup->setVisible(fRingsVisible);
    fHitsGroup->setVisible(fHitsVisible);
    fProjGroup->setVisible(fProjVisible);
    fPointsGroup->setVisible(fPointsVisible);
}


void VRichScene::ChangeLineWidth(double width)
{
    fLineWidth = width;
    QList<QGraphicsItem*> items = this->items();
    for (int i = 0; i < items.count(); i++){
       if (items[i]->data(0) == "ring"){
            QAbstractGraphicsShapeItem* item =
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(QPen(fRingsColor, width));
            continue;
        }
        if (items[i]->data(0) == "ringitem"){
            VRichRingItem* item = (VRichRingItem*)items[i];
            item->SetLineWidth(width);
            continue;
        }
    }
}

void VRichScene::ChangeHitSize(double size)
{
    fRingsGroup->setVisible(false);
    fEllipsesGroup->setVisible(false);
    fHitsGroup->setVisible(false);
    fProjGroup->setVisible(false);
    fPointsGroup->setVisible(false);

    QList<QGraphicsItem*> items = this->items();
    QPen penRingCenter(fRingsColor, size);
    QPen penEllipseCenter(fEllipsesColor, size);
    QPen penHit(fHitsColor, size);
    QPen penProj(fProjColor, size);
    QPen penPoint(fPointsColor, size);
    for (int i = 0; i < items.count(); i++){

        if(items[i]->data(0) == "ringcenter"){
            QAbstractGraphicsShapeItem* item=
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(penRingCenter);
            continue;
        }

        if(items[i]->data(0) == "ellipsecenter"){
            QAbstractGraphicsShapeItem* item=
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(penEllipseCenter);
            continue;
        }

        if (items[i]->data(0) == "hit"){
            QAbstractGraphicsShapeItem* item  =
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(penHit);
            continue;
        }

        if (items[i]->data(0) == "proj"){
            QAbstractGraphicsShapeItem* item  =
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(penProj);
            continue;
        }

        if (items[i]->data(0) == "ringitem"){
            VRichRingItem* item = (VRichRingItem*)items[i];
            item->SetHitSize(size);
            continue;
        }

        if (items[i]->data(0) == "point"){
            QAbstractGraphicsShapeItem* item  =
                static_cast<QAbstractGraphicsShapeItem*>(items[i]);
            item->setPen(penPoint);
            continue;
        }
    }
    fRingsGroup->setVisible(fRingsVisible);
    fEllipsesGroup->setVisible(fRingsVisible);
    fHitsGroup->setVisible(fHitsVisible);
    fProjGroup->setVisible(fProjVisible);
    fPointsGroup->setVisible(fPointsVisible);
}

void VRichScene::ClearScene()
{
   // qDebug() << "count before =  " << this->items().count();
    QList<QGraphicsItem*> items1 = this->items();
	if (items1.count() != 0){
        this->removeItem(fHitsGroup);
        delete fHitsGroup;
        this->removeItem(fEllipsesGroup);
        delete fEllipsesGroup;
        this->removeItem(fRingsGroup);
        delete fRingsGroup;
        this->removeItem(fProjGroup);
        delete fProjGroup;
        this->removeItem(fRingItemsGroup);
        delete fRingItemsGroup;
        this->removeItem(fPointsGroup);
        delete fPointsGroup;
	}
    //qDebug() << "count before 2 =  " << this->items().count();
    QList<QGraphicsItem*> items2 = this->items();
    for (int i = 0; i < items2.count(); i++) {
        this->removeItem(items2[i]);
        delete items2[i];
    }
    //qDebug() << "count after = " << this->items().count();
}

void VRichScene::SetItemsVisible(RichItemsTypeEnum type, bool b)
{
    if (type == kRichRing) fRingsVisible = b;
    if (type == kRichEllipse) fEllipsesVisible = b;
    if (type == kRichHit) fHitsVisible = b;
    if (type == kRichProj) fProjVisible = b;
    if (type == kRichPoint) fPointsVisible = b;
}

void VRichScene::SetItemsColor(RichItemsTypeEnum type, QColor c)
{
    if (type == kRichRing) fRingsColor = c;
    if (type == kRichEllipse) fEllipsesColor = c;
    if (type == kRichHit) fHitsColor = c;
    if (type == kRichProj) fProjColor = c;
    if (type == kRichPoint) fPointsColor = c;
}

bool VRichScene::GetItemsVisible(RichItemsTypeEnum type)
{
    if (type == kRichRing) return fRingsVisible;
    if (type == kRichEllipse) return fEllipsesVisible;
    if (type == kRichHit) return fHitsVisible;
    if (type == kRichProj) return fProjVisible;
    if (type == kRichPoint) return fPointsVisible;
    return false;
}

QColor VRichScene::GetItemsColor(RichItemsTypeEnum type)
{
    if (type == kRichRing) return fRingsColor;
    if (type == kRichEllipse) return fEllipsesColor;
    if (type == kRichHit) return fHitsColor;
    if (type == kRichProj) return fProjColor;
    if (type == kRichPoint) return fPointsColor;
    return Qt::black;
}

void VRichScene::SetRingsVisible(RichRingTypeEnum type, bool b)
{
    if (type == kRichElRing) fElRingsVisible = b;
    if (type == kRichPiRing) fPiRingsVisible = b;
    if (type == kRichFakeRing) fFakeRingsVisible = b;
    if (type == kRichCloneRing) fCloneRingsVisible = b;
}

void VRichScene::SetRingsColor(RichRingTypeEnum type, QColor c)
{
    if (type == kRichElRing) fElRingsColor = c;
    if (type == kRichPiRing) fPiRingsColor = c;
    if (type == kRichFakeRing) fFakeRingsColor = c;
    if (type == kRichCloneRing) fCloneRingsColor = c;
}

bool VRichScene::GetRingsVisible(RichRingTypeEnum type)
{
    if (type == kRichElRing) return fElRingsVisible;
    if (type == kRichPiRing) return fPiRingsVisible;
    if (type == kRichFakeRing) return fFakeRingsVisible;
    if (type == kRichCloneRing) return fCloneRingsVisible;
    return false;
}

QColor VRichScene::GetRingsColor(RichRingTypeEnum type)
{
    if (type == kRichElRing) return fElRingsColor;
    if (type == kRichPiRing) return fPiRingsColor;
    if (type == kRichFakeRing) return fFakeRingsColor;
    if (type == kRichCloneRing) return fCloneRingsColor;
    return Qt::white;
}