#include <QtGui>
#include <QtOpenGL>

#include "VTrackingScene.h"
#include "VFileManager.h"
#include "VTrackingData.h"

#include "CbmGlobalTrack.h"
#include "CbmBaseHit.h"
#include "CbmPixelHit.h"
#include "CbmTrack.h"
#include "CbmHit.h"
#include "CbmStsTrack.h"
#include "CbmTrdTrack.h"
#include "CbmMuchTrack.h"
#include "FairMCPoint.h"

VTrackingScene::VTrackingScene()
{
    fNofItemTypes = 3;

    fGroup.resize(fNofItemTypes);

    fSize.resize(fNofItemTypes);
    fColor.resize(fNofItemTypes);
    fIsDraw.resize(fNofItemTypes);

    fSize[kVHIT] = 3.;
    fColor[kVHIT] = Qt::blue;
    fIsDraw[kVHIT] = true;

    fSize[kVPOINT] = 4.;
    fColor[kVPOINT] = Qt::green;
    fIsDraw[kVPOINT] = true;

    fSize[kVTRACK] = 1.0;
    fColor[kVTRACK] = Qt::red;
    fIsDraw[kVTRACK] = true;

    fOriginXZ = QPointF(0, 0);
    fOriginYZ = QPointF(0, 900);
    fOriginXY = QPointF(0, 1800);
    fGeoSize = QSizeF(1100, 900);

	fIsDrawXYProjection = false;
	fIsDrawXZProjection = true;
	fIsDrawYZProjection = false;

   fTrackTitle="STS_PF_pt";
   fTrackCaption="STS_PF_pt, STS_PL_pt,";
}

VTrackingScene::~VTrackingScene()
{
}

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

    fGlobalTracks = fm->getArray("GlobalTrack");
    fMvdHits = fm->getArray("MvdHit");
    fMvdPoints = fm->getArray("MvdPoint");
    fStsHits = fm->getArray("StsHit");
    fStsTracks = fm->getArray("StsTrack");
    fStsPoints = fm->getArray("StsPoint");
    fMuchPixelHits = fm->getArray("MuchPixelHit");
//    fMuchTracks = fm->getArray("MuchTrack");
    fMuchPoints = fm->getArray("MuchPoint");
    fTrdHits = fm->getArray("TrdHit");
//    fTrdTracks = fm->getArray("TrdTrack");
    fTrdPoints = fm->getArray("TrdPoint");
    fTofHits = fm->getArray("TofHit");
    fTofPoints = fm->getArray("TofPoint");

  VMyTrack::GetArrays();
}

void VTrackingScene::ProcessEvent(int ievent)
{
    VFileManager *fm = VFileManager::instance();
    fm->setEventNum(ievent);
    ProcessCurEvent();
}

void VTrackingScene::ProcessCurEvent()
{
	ClearArrays();
    ClearScene();
    CreateArrays();
}

void VTrackingScene::Update()
{
	ProcessCurEvent();
}

void VTrackingScene::DrawGeometryProjection(
		const QPointF& origin,
		const QSizeF& size,
		const QString& text)
{
   	QGraphicsRectItem* rect = new QGraphicsRectItem(origin.x(), origin.y(), size.width(), size.height());

   	QGraphicsLineItem* line = new QGraphicsLineItem(origin.x(), origin.y() + size.height()/2.,
   	   		origin.x() + size.width(),  origin.y() + size.height()/2.);
   	line->setPen(QPen(Qt::DashLine));

	QGraphicsTextItem* label = new QGraphicsTextItem(text);
	label->setPos(origin.x(), origin.y());

   	this->addItem(rect);
   	this->addItem(line);
   	this->addItem(label);
}

void VTrackingScene::DrawGeometry()
{
    if (fIsDrawXZProjection) { DrawGeometryProjection(fOriginXZ, fGeoSize, "XZ"); }
    if (fIsDrawYZProjection) { DrawGeometryProjection(fOriginYZ, fGeoSize, "YZ"); }
    if (fIsDrawXYProjection) { DrawGeometryProjection(fOriginXY, fGeoSize, "XY"); }
}

void VTrackingScene::CreateArrays()
{
    if (fIsDraw[kVHIT]) { CreateHitArray(); }
    if (fIsDraw[kVTRACK]) { CreateTrackArray(); }
    if (fIsDraw[kVPOINT]) { CreatePointArray(); }
}

void VTrackingScene::DrawQt()
{
    if (fIsDraw[kVHIT]) { DrawHits(); }
    if (fIsDraw[kVTRACK]) { DrawTracks(); }
    if (fIsDraw[kVPOINT]) { DrawPoints(); }
	DrawGeometry();
}

void VTrackingScene::ClearScene()
{
    QList<QGraphicsItem*> items1 = this->items();
	if (items1.count() != 0){
		for (int iGroup = 0; iGroup < fNofItemTypes; iGroup++) {
			if (fGroup[iGroup] != NULL) {
				this->removeItem(fGroup[iGroup]);
				delete fGroup[iGroup];
				fGroup[iGroup] = NULL;
			}
		}
	}
    QList<QGraphicsItem*> items2 = this->items();
    for (int i = 0; i < items2.count(); i++){
        this->removeItem(items2[i]);
        delete items2[i];
    }
}

void VTrackingScene::ClearArrays()
{
	fHits.clear();
	fPoints.clear();
	fTracks.clear();
}



void VTrackingScene::DrawHit(
		const VMyHit* hit,
		double size,
		QColor color,
		QGraphicsItemGroup* group)
{
    QString tip = QString(hit->GetDetector()) + " " + QString(hit->GetDataLevel())
    		+ ": " + QString("x=%1 , y=%2, z=%3")
    						.arg(hit->GetX())
                            .arg(hit->GetY())
                            .arg(hit->GetZ());
    //XZ
    if (fIsDrawXZProjection) {
		QPointF xz = MapToXZ(QPointF(hit->GetZ(), hit->GetX()));
		QGraphicsEllipseItem * ellipsexz =
			new QGraphicsEllipseItem(xz.x() - size/2., xz.y() - size/2., size, size);

		ellipsexz->setPen(QPen(color));
		ellipsexz->setBrush(QBrush(color));
		ellipsexz->setToolTip(tip);
		ellipsexz->setData(0, hit->GetDataLevel());
		group->addToGroup((QGraphicsItem*)ellipsexz);
    }

    //YZ
    if (fIsDrawYZProjection) {
		QPointF yz = MapToYZ(QPointF(hit->GetZ(), hit->GetY()));
		QGraphicsEllipseItem * ellipseyz =
			new QGraphicsEllipseItem(yz.x() - size/2., yz.y() - size/2., size, size);

		ellipseyz->setPen(QPen(color));
		ellipseyz->setBrush(QBrush(color));
		ellipseyz->setToolTip(tip);
		ellipseyz->setData(0, hit->GetDataLevel());
		group->addToGroup((QGraphicsItem*)ellipseyz);
    }

    //XY
    if (fIsDrawXYProjection) {
		QPointF xy = MapToXY(QPointF(hit->GetX(), hit->GetY()));
		QGraphicsEllipseItem * ellipsexy =
			new QGraphicsEllipseItem(xy.x() - size/2., xy.y() - size/2., size, size);

		ellipsexy->setPen(QPen(color));
		ellipsexy->setBrush(QBrush(color));
		ellipsexy->setToolTip(tip);
		ellipsexy->setData(0, hit->GetDataLevel());
		group->addToGroup((QGraphicsItem*)ellipsexy);
    }
}

void VTrackingScene::DrawHits()
{
    if (fHits.empty()) {
    	fGroup[kVHIT] = NULL;
    	return;
    }

    fGroup[kVHIT] = new QGraphicsItemGroup();

    for (unsigned int i = 0; i < fHits.size(); i++) {
    	const VMyHit& myhit = fHits[i];
    	DrawHit(&myhit, fSize[kVHIT], fColor[kVHIT], fGroup[kVHIT]);
    }

    fGroup[kVHIT]->setZValue(2);
    fGroup[kVHIT]->setVisible(true);
    this->addItem(fGroup[kVHIT]);
}

void VTrackingScene::CreateHitArray()
{
    if (!fStsHits && !fTrdHits && !fMuchPixelHits & !fTofHits) {
    	qDebug() << "-E- NO HIT ARRAYS";
    	return;
    }

    if (!fMvdHits) {
    	qDebug() << "-E- NO fMvdHits array";
    } else {
    	CreateHits(fMvdHits, "MVD");
    }

    if (!fStsHits) {
    	qDebug() << "-E- NO fStsHits array";
    } else {
    	CreateHits(fStsHits, "STS");
    }

    if (!fTrdHits) {
    	qDebug() << "-E- NO fTrdHits array";
    } else {
    	CreateHits(fTrdHits, "TRD");
    }

    if (!fMuchPixelHits) {
    	qDebug() << "-E- NO fMuchPixelHits array";
    } else {
    	CreateHits(fMuchPixelHits, "MUCH");
    }

    if (!fTofHits) {
    	qDebug() << "-E- NO fTofHits array";
    } else {
    	CreateHits(fTofHits, "TOF");
    }
}

void VTrackingScene::CreateHits(
		const TClonesArray* hits,
		const QString& detector)
{
	if ( !(detector == "STS" || detector == "MVD") ) {
		for (int iHit = 0; iHit < hits->GetEntriesFast(); iHit++){
			CbmPixelHit* hit = static_cast<CbmPixelHit*>(hits->At(iHit));
			VMyHit myhit(hit->GetX(), hit->GetY(), hit->GetZ(), detector, "hit");
			fHits.push_back(myhit);
		}
	} else {
		for (int iHit = 0; iHit < hits->GetEntriesFast(); iHit++){
			CbmHit* hit = static_cast<CbmHit*>(hits->At(iHit));
			VMyHit myhit(hit->GetX(), hit->GetY(), hit->GetZ(), detector, "hit");
			fHits.push_back(myhit);
		}
	}
}

void VTrackingScene::DrawPoints()
{
    if (fPoints.empty()) {
    	fGroup[kVPOINT] = NULL;
    	return;
    }

    fGroup[kVPOINT] = new QGraphicsItemGroup();

    for (unsigned int i = 0; i < fPoints.size(); i++) {
    	const VMyHit& myhit = fPoints[i];
    	DrawHit(&myhit, fSize[kVPOINT], fColor[kVPOINT], fGroup[kVPOINT]);
    }

    fGroup[kVPOINT]->setZValue(1);
    fGroup[kVPOINT]->setVisible(true);
    this->addItem(fGroup[kVPOINT]);
}

void VTrackingScene::CreatePointArray()
{
    if (!fStsPoints && !fTrdPoints && !fMuchPoints & !fTofPoints) {
    	qDebug() << "-E- NO POINTS ARRAYS";
    	return;
    }

    if (!fMvdPoints) {
    	qDebug() << "-E- NO fMvdPoints array";
    } else {
    	CreatePoints(fMvdPoints, "MVD");
    }

    if (!fStsPoints) {
    	qDebug() << "-E- NO fStsPoints array";
    } else {
    	CreatePoints(fStsPoints, "STS");
    }

    if (!fTrdPoints) {
    	qDebug() << "-E- NO fTrdPointsarray";
    } else {
    	CreatePoints(fTrdPoints, "TRD");
    }

    if (!fMuchPoints) {
    	qDebug() << "-E- NO fMuchPoints array";
    } else {
    	CreatePoints(fMuchPoints, "MUCH");
    }

    if (!fTofPoints) {
    	qDebug() << "-E- NO fTofPoints array";
    } else {
    	CreatePoints(fTofPoints, "TOF");
    }
}

void VTrackingScene::CreatePoints(
		const TClonesArray* points,
		const QString& detector)
{
	for (int i = 0; i < points->GetEntriesFast(); i++){
		FairMCPoint* point = (FairMCPoint*) points->At(i);
		VMyHit myhit(point->GetX(), point->GetY(), point->GetZ(), detector, "point");
		fPoints.push_back(myhit);
	}
}

void VTrackingScene::DrawTracks()
{
    if (fTracks.empty()) {
        fGroup[kVTRACK] = NULL;
        return;
    }

    fGroup[kVTRACK] = new QGraphicsItemGroup();

    for (unsigned int i = 0; i < fTracks.size(); i++) {
    	const VMyTrack& mytrack = fTracks[i];
    	DrawTrack(mytrack);
    }

    fGroup[kVTRACK]->setZValue(2);
    fGroup[kVTRACK]->setVisible(true);
    this->addItem(fGroup[kVTRACK]);
}

void VTrackingScene::CreateTrackArray()
{
  int i;

  VMyTrack::GetArrays();

  if (fGlobalTracks==NULL)
  {
    if (fStsTracks==NULL)
    {
      qDebug() << "-E- NO fStsTracks array. No tracks to draw";
      return;
    }
    for(i=0;i<fStsTracks->GetEntriesFast();i++)
          fTracks.push_back(VMyTrack(i, i));
  }
  else
  {
    for(i=0;i<fGlobalTracks->GetEntriesFast();i++)
      fTracks.push_back(VMyTrack(i));
  }
  for(i=0;i<fTracks.size();++i)
    fTracks[i].AssosiateHits(fHits);
}

/*
VMyHit* VTrackingScene::AssociateHit(int trackNum, float x, float y, float z)
{
  unsigned int i;
  for(i=0;i<fHits.size();i++)
    if (fHits[i].GetX()==x&&fHits[i].GetY()==y&&fHits[i].GetZ()==z) break;
  if (i!=fHits.size())
  {
    fHits[i].SetTrack(trackNum);
    return &(fHits[i]);
  }
  return NULL;
}

void VTrackingScene::ConstructStsTrack(CbmStsTrack* stsTrack, int trackNum)
{
  QString info("");

  if (fMvdHits)
  {
    for(int iHit=0;iHit<stsTrack->GetNMvdHits();iHit++)
    {
      int hitId=stsTrack->GetMvdHitIndex(iHit);
      CbmHit* hit=(CbmHit*)fMvdHits->At(hitId);
      if (!hit) continue;
      fTracks[trackNum].AddHit(VMyHit(hit->GetX(), hit->GetY(), hit->GetZ(), "MVD", "hit"));
      AssociateHit(trackNum, hit->GetX(), hit->GetY(), hit->GetZ());
    }
  }
  for(int iHit=0;iHit<stsTrack->GetNStsHits();iHit++)
  {
    int hitId=stsTrack->GetStsHitIndex(iHit);
    CbmHit* hit=(CbmHit*) fStsHits->At(hitId);
    if (!hit) continue;
    fTracks[trackNum].AddHit(VMyHit(hit->GetX(), hit->GetY(), hit->GetZ(), "STS", "hit"));
    AssociateHit(trackNum, hit->GetX(), hit->GetY(), hit->GetZ());
  }
  info+="STS "+QString(": nhmvd=%1, nhsts=%2, chisq=%3, ndf=%4 \n").arg(stsTrack->GetNMvdHits()).arg(stsTrack->GetNStsHits()).arg(stsTrack->GetChi2()).arg(stsTrack->GetNDF());
  const FairTrackParam* par1=stsTrack->GetParamFirst();
  info+="STS"+QString(": param first: x=%1 , y=%2, z=%3, tx=%4, ty=%5, p=%6 \n").arg(par1->GetX()).arg(par1->GetY()).arg(par1->GetZ()).arg(par1->GetTx()).arg(par1->GetTy()).arg(1./par1->GetQp());

  const FairTrackParam* par2 = stsTrack->GetParamLast();
  info+="STS"+QString(": param last: x=%1 , y=%2, z=%3, tx=%4, ty=%5, p=%6 \n").arg(par2->GetX()).arg(par2->GetY()).arg(par2->GetZ()).arg(par2->GetTx()).arg(par2->GetTy()).arg(1./par2->GetQp());

  fTracks[trackNum].SetInfo(info);

  info="";
  double tx=par1->GetTx();
  double ty=par1->GetTy();
  double p=-1111;
  if (fabs(par1->GetQp())>1e-4) p=1.0/par1->GetQp();
  double pz=sqrt(p*p/(tx*tx+ty*ty+1.0));
  if (p>0) info+=QString("Pt=+%1").arg(sqrt(p*p-pz*pz)); else info+=QString("Pt=-%1").arg(sqrt(p*p-pz*pz));
  fTracks[trackNum].SetInfoShort(info);
}

void VTrackingScene::ConstructTrack(const CbmGlobalTrack* track, int trackNum)
{
	Int_t stsId = track->GetStsTrackIndex();
	Int_t trdId = track->GetTrdTrackIndex();
	Int_t muchId = track->GetMuchTrackIndex();
	Int_t tofId = track->GetTofHitIndex();

	QString info("");
	QString infoshort("");

	info += QString("GlobalTrack: sts=%1, much=%3, trd=%2, tof=%4. ")
			.arg(stsId).arg(trdId).arg(muchId).arg(tofId);

	if (stsId != -1 && fStsTracks && fStsHits) {
		CbmStsTrack* stsTrack = (CbmStsTrack*) fStsTracks->At(stsId);
		if (fMvdHits) {
			for (int iHit = 0; iHit < stsTrack->GetNMvdHits(); iHit++) {
				int hitId = stsTrack->GetMvdHitIndex(iHit);
				CbmHit* hit = (CbmHit*) fMvdHits->At(hitId);
				if (!hit) continue;
				fTracks[trackNum].AddHit(VMyHit(hit->GetX(), hit->GetY(), hit->GetZ(), "MVD", "hit"));
                                AssociateHit(trackNum, hit->GetX(), hit->GetY(), hit->GetZ());
			}
		}
		for (int iHit = 0; iHit < stsTrack->GetNStsHits(); iHit++) {
			int hitId = stsTrack->GetStsHitIndex(iHit);
			CbmHit* hit = (CbmHit*) fStsHits->At(hitId);
			if (!hit) continue;
			fTracks[trackNum].AddHit(VMyHit(hit->GetX(), hit->GetY(), hit->GetZ(), "STS", "hit"));
                        AssociateHit(trackNum, hit->GetX(), hit->GetY(), hit->GetZ());
		}
		info += "STS " + QString(": Nmvd=%1, Nsts=%2, chi2=%3, ndf=%4. ")
				.arg(stsTrack->GetNMvdHits()).arg(stsTrack->GetNStsHits())
				.arg(stsTrack->GetChi2()).arg(stsTrack->GetNDF());
		const FairTrackParam* par1 = stsTrack->GetParamFirst();
		info += "STS" + QString(": P1: x=%1 , y=%2, z=%3, tx=%4, ty=%5, p=%6. ")
				.arg(par1->GetX()).arg(par1->GetY()).arg(par1->GetZ())
				.arg(par1->GetTx()).arg(par1->GetTy()).arg(1./par1->GetQp());

		const FairTrackParam* par2 = stsTrack->GetParamLast();
		info += "STS" + QString(": PL: x=%1 , y=%2, z=%3, tx=%4, ty=%5, p=%6. ")
				.arg(par2->GetX()).arg(par2->GetY()).arg(par2->GetZ())
				.arg(par2->GetTx()).arg(par2->GetTy()).arg(1./par2->GetQp());

		double tx=par1->GetTx();
		double ty=par1->GetTy();
		double p=-1111;
		if (fabs(par1->GetQp())>1e-4) p=1.0/par1->GetQp();
		double pz=sqrt(p*p/(tx*tx+ty*ty+1.0));
		if (p>0)
		  infoshort+=QString("Pt=+%1").arg(sqrt(p*p-pz*pz));
		else
		  infoshort+=QString("Pt=-%1").arg(sqrt(p*p-pz*pz));
		fTracks[trackNum].SetInfoShort(infoshort);		
	}
	if (muchId != -1 && fMuchTracks && fMuchPixelHits) {
		CbmTrack* muchTrack = static_cast<CbmTrack*>(fMuchTracks->At(muchId));
		AddHitsToMyTrack(muchTrack, fMuchPixelHits, "MUCH", trackNum, info);
	}
	if (trdId != -1 && fTrdTracks && fTrdHits) {
		CbmTrack* trdTrack = static_cast<CbmTrack*>(fTrdTracks->At(trdId));
		AddHitsToMyTrack(trdTrack, fTrdHits, "TRD", trackNum, info);
	}
	if (tofId != -1 && fTofHits) {
		CbmPixelHit* tofHit = static_cast<CbmPixelHit*>(fTofHits->At(tofId));
		fTracks[trackNum].AddHit(VMyHit(tofHit->GetX(), tofHit->GetY(), tofHit->GetZ(), "TOF", "hit"));
                AssociateHit(trackNum, tofHit->GetX(), tofHit->GetY(), tofHit->GetZ());
	}

	fTracks[trackNum].SetInfo(info);
}

void VTrackingScene::AddHitsToMyTrack(const CbmTrack* track, TClonesArray* hits, const QString& detector, int trackNum,	QString& info)
{
	for (int iHit = 0; iHit < track->GetNofHits(); iHit++) {
		int hitId = track->GetHitIndex(iHit);
		CbmPixelHit* hit = (CbmPixelHit*) hits->At(hitId);
		if (!hit) continue;
		fTracks[trackNum].AddHit(VMyHit(hit->GetX(), hit->GetY(), hit->GetZ(), detector, "hit"));
                AssociateHit(trackNum, hit->GetX(), hit->GetY(), hit->GetZ());
	}

	info += detector + QString(": Nh=%1, chi2=%2, ndf=%3, prev=%4. ")
			.arg(track->GetNofHits()).arg(track->GetChiSq())
			.arg(track->GetNDF()).arg(track->GetPreviousTrackId());

	const FairTrackParam* par1 = track->GetParamFirst();
	info += detector + QString(": P1: x=%1, y=%2, z=%3, tx=%4, ty=%5, p=%6. ")
			.arg(par1->GetX()).arg(par1->GetY()).arg(par1->GetZ())
			.arg(par1->GetTx()).arg(par1->GetTy()).arg(1./par1->GetQp());

	const FairTrackParam* par2 = track->GetParamLast();
	info += detector + QString(": PL: x=%1, y=%2, z=%3, tx=%4, ty=%5, p=%6. ")
			.arg(par2->GetX()).arg(par2->GetY()).arg(par2->GetZ())
			.arg(par2->GetTx()).arg(par2->GetTy()).arg(1./par2->GetQp());
}
*/
void VTrackingScene::DrawTrack(
		const VMyTrack& myTrack)
{
	int nofHits = myTrack.GetNofHits();
	for (int iHit = 0; iHit < nofHits-1; iHit++) {
		const VMyHit* hit1 = &myTrack.GetHit(iHit);
		const VMyHit* hit2 = &myTrack.GetHit(iHit+1);

		QString tip = myTrack.GetInfo();

		//XZ
		if (fIsDrawXZProjection) {
			QPointF xz1 = MapToXZ(QPointF(hit1->GetZ(), hit1->GetX()));
			QPointF xz2 = MapToXZ(QPointF(hit2->GetZ(), hit2->GetX()));
			QGraphicsLineItem * linexz =
				new QGraphicsLineItem(xz1.x(), xz1.y(), xz2.x(), xz2.y());
			linexz->setPen(QPen(fColor[kVTRACK], fSize[kVTRACK]));
			linexz->setToolTip(tip);
			linexz->setData(0,"track");
			fGroup[kVTRACK]->addToGroup((QGraphicsItem*)linexz);
		}

		//YZ
		if (fIsDrawYZProjection) {
			QPointF yz1 = MapToYZ(QPointF(hit1->GetZ(), hit1->GetY()));
			QPointF yz2 = MapToYZ(QPointF(hit2->GetZ(), hit2->GetY()));
			QGraphicsLineItem * lineyz =
				new QGraphicsLineItem(yz1.x(), yz1.y(), yz2.x(), yz2.y());
			lineyz->setPen(QPen(fColor[kVTRACK], fSize[kVTRACK]));
			lineyz->setToolTip(tip);
			lineyz->setData(0,"track");
			fGroup[kVTRACK]->addToGroup((QGraphicsItem*)lineyz);
		}

		//XY
		if (fIsDrawXYProjection) {
			QPointF xy1 = MapToXY(QPointF(hit1->GetX(), hit1->GetY()));
			QPointF xy2 = MapToXY(QPointF(hit2->GetX(), hit2->GetY()));
			QGraphicsLineItem * linexy =
				new QGraphicsLineItem(xy1.x(), xy1.y(), xy2.x(), xy2.y());
			linexy->setPen(QPen(fColor[kVTRACK], fSize[kVTRACK]));
			linexy->setToolTip(tip);
			linexy->setData(0,"track");
			fGroup[kVTRACK]->addToGroup((QGraphicsItem*)linexy);
		}
	}
}

QPointF VTrackingScene::MapToXZ(const QPointF& point)
{
	return QPointF(fOriginXZ.x() + point.x(),
			fOriginXZ.y() + fGeoSize.height()/2. + point.y());
}

QPointF VTrackingScene::MapToYZ(const QPointF& point)
{
	return QPointF(fOriginYZ.x() + point.x(),
			fOriginYZ.y() + fGeoSize.height()/2. + point.y());
}

QPointF VTrackingScene::MapToXY(const QPointF& point)
{
	return QPointF(fOriginXY.x() + fGeoSize.width()/2. + point.x(),
			fOriginXY.y() + fGeoSize.height()/2. + point.y());
}


void VTrackingScene::DrawOpenGL()
{
  ;
}