void CSimpleSource::initPhysicalSource()
{
CAudioMixerUser *mixer = CAudioMixerUser::instance();
CTrack *track = mixer->getFreeTrack(this);
if (track != NULL)
{
nlassert(track->hasPhysicalSource());
_Track = track;
}
}
void CStreamSource::initPhysicalSource()
{
CAudioMixerUser *mixer = CAudioMixerUser::instance();
CTrack *track = mixer->getFreeTrack(this);
if (track != NULL)
{
nlassert(track->hasPhysicalSource());
m_Track = track;
getPhysicalSource()->setStreaming(true);
}
}
// ------------------------------------
// Destroy
void CReynoldsManager::destroy(const NLMISC::CEntityId &entity)
{
CTrack *track = getTrack(entity);
if (track != NULL)
track->forceRelease();
if (track != NULL && track->hasControlOwned())
track->leave();
_ControlledTrackMap.erase(entity);
}
// ------------------------------------
// Set Position
void CReynoldsManager::setPosition(const NLMISC::CEntityId &id, const NLMISC::CVectorD &position, float heading)
{
CTrack *track = getTrack(id);
if (track == NULL)
{
nlwarning("ReynoldsLib:CReynoldsManager:setPosition(): Track %s not found", id.toString().c_str());
return;
}
track->setPosition(position, heading);
}
// ------------------------------------
// Set Vision
void CReynoldsManager::setVision(const NLMISC::CEntityId &id, const std::vector<NLMISC::CEntityId> &vision)
{
CTrack *track = getTrack(id);
if (track == NULL)
{
nlwarning("ReynoldsLib:CReynoldsManager:setVision(): Track %s not found", id.toString().c_str());
return;
}
track->updateVision(vision);
}
LRESULT CCWArrangePage::OnEnddragListTracks(WPARAM wParam, LPARAM lParam)
{
GetTracksInfo ();
CTrack t = m_pTracks->GetTrack (LOWORD (wParam));
m_pTracks->GetTrack (HIWORD (wParam)).SetText (t.GetTitle (), t.GetRemarks ());
SetTracks ();
m_List.SetEditPos (m_List.GetEditPos ().x - 1, HIWORD (wParam) - 1);
return S_OK;
}
// ------------------------------------
// Update
void CReynoldsManager::update(double dt)
{
TControlledTrackMap::iterator it;
for (it=_ControlledTrackMap.begin(); it!=_ControlledTrackMap.end(); ++it)
{
CTrack *track = (CTrack*)((*it).second);
track->update(dt);
}
++_Cycle;
}
bool mi::Work(float *pout, int ns, int const mode) {
bool GotSomething = false;
for (int c = 0; c < iDynTracks; c++) {
CTrack *t = aTracks + c;
if(t->cAdsr.IsPlaying()) {
if(!GotSomething) {
memset(pout,0,ns*sizeof(float));
GotSomething = true; }
t->Work(dspcAuxBuffer,ns);
t->cSaturator.WorkSamplesAddDest(dspcAuxBuffer,pout,ns); } }
return GotSomething; }
bool
CAssemblyWindow::SubjectReleased(
CObservable *subject)
{
D_OBSERVE(("CAssemblyWindow<%p>::SubjectReleased()\n", this));
CTrack *realMaster = Document()->FindTrack((int32)0);
if (subject == realMaster)
{
realMaster->RemoveObserver(this);
return true;
}
return CTrackWindow::SubjectReleased(subject);
}
void CMouseMoveMap::mousePressEvent(QMouseEvent * e)
{
if(e->button() == Qt::LeftButton)
{
oldPoint = e->pos();
CTrack * track = CTrackDB::self().highlightedTrack();
if(!selWpts.isEmpty())
{
if(selWpts.size() == 1)
{
CWpt * selWpt = selWpts.first().wpt;
CWptDB::self().selWptByKey(selWpt->getKey(), false);
}
mousePressEventWpt(e);
}
else if(track && selTrkPt)
{
track->setPointOfFocus(selTrkPt->idx, CTrack::e3Way, false);
}
else if(!selSearch.isNull())
{
CSearchDB::self().selSearchByKey(selSearch->getKey());
mousePressEventSearch(e);
}
else
{
leftButtonPressed = true;
if (!moveMap)
{
CUndoStackView::getInstance()->beginMacro(tr("Move map"));
cursor = QCursor(QPixmap(":/cursors/cursorMove.png"));
QApplication::setOverrideCursor(cursor);
moveMap = true;
CMapDB::self().getMap().fastDrawOn();
}
}
}
else if(e->button() == Qt::RightButton)
{
mousePos = e->pos();
oldPoint = e->pos();
canvas->raiseContextMenu(e->pos());
}
}
// ------------------------------------
// Follow
void CReynoldsManager::follow(const NLMISC::CEntityId &entity, const NLMISC::CEntityId &target)
{
// look for the track, and create a new one if not found -- in both maps
CTrack *etrack = createTrack(entity);
TControlledTrackMap::iterator ite = _ControlledTrackMap.find(entity);
if (ite == _ControlledTrackMap.end())
_ControlledTrackMap.insert(TControlledTrackMap::value_type(entity, etrack));
// look for the target, and create a new track if not found
CTrack *ttrack = createTrack(target);
nldebug("ReynoldsLib:CReynoldsManager:follow(): %s now follows %s", entity.toString().c_str(), target.toString().c_str());
// let entity follow the target
etrack->follow(ttrack);
}
// ------------------------------------
// Set Sheet
void CReynoldsManager::setSheet(const NLMISC::CEntityId &id, const NLMISC::CSheetId &sheet)
{
CTrack *track = getTrack(id);
if (track == NULL)
{
nlwarning("ReynoldsLib:CReynoldsManager:setSheet(): Track %s not found", id.toString().c_str());
return;
}
if (track->hasId())
{
nlwarning("ReynoldsLib:CReynoldsManager:setSheet(): Track %s already has an Id", id.toString().c_str());
return;
}
track->setId(id, sheet);
}
void CCWArrangePage::SetTracks()
{
CString s;
// SetDlgItemText (IDC_RICHEDIT_TITLE, m_pTracks->GetTitle ());
// SetDlgItemText (IDC_EDIT_TITLE2, m_pTracks->GetSubtitle ());
m_EditTitle.SetRTF (m_pTracks->GetRTFTitle (Inlay));
m_List.DeleteAllItems ();
CPoint pt = m_List.GetEditPos ();
int n;
for (int i = 0; i < m_pTracks->GetNumTracks (); i++)
{
CTrack t (m_pTracks->GetTrack (i));
if (t.IsTrackGrouping ())
n = m_List.InsertItem (i, STR_SEPARATOR, 0);
else
{
s.Format (IDS_FORMAT_TRACK, t.GetTrackNum ());
n = m_List.InsertItem (i, s, 1);
}
m_List.SetItemData (n, t.GetTrackNum ());
m_List.SetItemText (n, 1, t.GetLength ());
m_List.SetItemText (n, 2, t.GetTitle ());
m_List.SetItemText (n, 3, t.GetRemarks ());
}
m_List.SetEditText (m_List.GetItemText (pt.y, pt.x));
}
void CReturnTrain::install (int trackPosition) {
/*
installs train, first coach is at track position, last
coach towards start point of track
*/
CTrack* track = getTrack ();
const vector<int>& vx = track->get_x ();
const vector<int>& vy = track->get_y ();
int n = track->get_n ();
if (trackPosition >= n) {
end (CTrain::RETURN_TO_BASE);
return;
} else if (trackPosition < 0) {
end (CTrain::ARRIVED);
return;
}
int j = 0; setCoachPosition (j++, trackPosition);
int x1 = vx [trackPosition], y1 = vy [trackPosition];
for (int i = trackPosition - 1; i > -1; i--) {
int x2 = vx [i], y2 = vy [i];
int dx = x2 - x1;
int dy = y2 - y1;
int distance_2 = dx * dx + dy * dy;
if (distance_2 >= COACH_SEPARATION_2) {
setCoachPosition (j++, i);
if (j == NUM_COACHES) { // coaches installed; calc bounding box that will enclose train.
calcBBox ();
return;
}
x1 = x2;
y1 = y2;
}
}
end (CTrain::ARRIVED);
}
void CPathItem::Select(bool selected)
{
if(NULL == m_pInput)
return;
IFloopyObj::Select( selected );
CPathCtrl *ctrl = (CPathCtrl*)GetParent();
if(NULL != ctrl)
{
CLabel *label = (CLabel*)ctrl->GetParent();
if(NULL != label)
{
CTrack *track = (CTrack*)label->GetParent();
if(NULL != track)
{
track->ShowObjectParameters(m_pInput, selected);
track->Refresh();
}
}
}
}
void CTrack::Tick(int ThisTrack) {
CTrack &trk = pMachine->aTracks[ThisTrack];
TrackParameters &trkp = pMachine->aTrackParams[ThisTrack];
if(trkp.Attack != mpAttack.NoValue) {
trk.rtAttack = pow(10.0,(double)trkp.Attack*(1.0/20)); }
if(trkp.Decay != mpDecay.NoValue) {
trk.rtDecay = pow(10.0,(double)trkp.Decay*(1.0/20)); }
if(trkp.Release != mpRelease.NoValue) {
trk.rtRelease = pow(10.0,(double)trkp.Release*(1.0/20)); }
if(trkp.Sustain != mpSustain.NoValue) {
trk.rtSustain = (1.0 / 128.0) * (double)trkp.Sustain; }
if(trkp.Note == NOTE_OFF) {
pPlayingTrack->NoteOff(); }
else if(trkp.Note != NOTE_NO) {
pPlayingTrack->NoteOff();
pPlayingTrack = pMachine->RequestTrack(ThisTrack);
pPlayingTrack->NoteOn(trkp.Note,trkp.Volume != mpVolume.NoValue ? trkp.Volume : pMachine->cAttributes.DefVol,trk); }
if(trkp.Volume != mpVolume.NoValue)
pPlayingTrack->rtAmplitude = (double)(trkp.Volume * (1.0 / 128));
if(trkp.PWidth != mpPWidth.NoValue) {
pPlayingTrack->cPulse.fPWidth = trk.cPulse.fPWidth = (double)trkp.PWidth * (1.0 / 128);
pPlayingTrack->cPulse.Update(); }
if(trkp.FEnv != mpFEnv.NoValue)
pPlayingTrack->fEnvMod = trk.fEnvMod = (double)trkp.FEnv * (1.0 / 128);
if(trkp.FRes != mpFRes.NoValue)
pPlayingTrack->cFilter.fResonance = trk.cFilter.fResonance = 1.0 - (double)trkp.FRes * (1.0 / 129);
}
void TcxReader::readCourse()
{
Q_ASSERT(isStartElement() && name() == "Course");
CTrack *track = new CTrack(parent);
//track->setTraineeData();
while (!atEnd())
{
readNext();
if (isEndElement())
break;
if (isStartElement())
{
if (name() == "Name")
{
track->setName(readElementText());
}
else if (name() == "Track")
{
readTrack(track,1);
}
else
readUnknownElement();
}
}
if (track->getTrackPoints().count() > 0)
{
track->rebuild(true);
track->sortByTimestamp();
CTrackDB::self().addTrack(track, false);
}
else
{
delete track;
}
}
void CCWArrangePage::OnCopyToClipboard ()
{
m_List.SaveEdit ();
GetTracksInfo ();
if (m_pTracks == NULL)
return;
OpenClipboard ();
EmptyClipboard ();
// prepare data
CString strText = "";
CString strRTF = "";
strRTF = "{\\rtf1\\ansi\\ansicpg1252\\deff0\\deflang1031{\\fonttbl{\\f0\\fswiss\\fcharset0 Arial;}}\\viewkind4\\uc1\\pard\\ql\\f0\\cf1";
if (!m_pTracks->GetArtist ().IsEmpty ())
{
strRTF += "\\fs20" + m_pTracks->GetArtist () + "\\par";
strText += m_pTracks->GetArtist () + ": ";
}
strRTF += "\\fs32 " + m_pTracks->GetTitle () + "\\par\\fs20 ";
strText += m_pTracks->GetTitle () + "\r\n\r\n";
for (int i = 0; i < m_pTracks->GetNumTracks (); i++)
{
CTrack t = m_pTracks->GetTrack (i);
strRTF.AppendFormat ("% 2d.\\tab ", i + 1);
strText.AppendFormat ("%s%d.\t", i >= 9 ? "" : " ", i + 1);
strRTF += t.GetNiceLength () + "\\tab\\b " + t.GetTitle () + "\\b0\\tab\\i " + t.GetRemarks () + "\\i0\\par ";
strText += t.GetNiceLength () + "\t" + t.GetTitle () + "\t" + t.GetRemarks () + "\r\n";
}
strRTF += "}";
// set data to clipboard
HGLOBAL hglText = GlobalAlloc (GMEM_MOVEABLE, strText.GetLength () + 1);
strcpy ((char*) GlobalLock (hglText), strText.GetBuffer (-1));
GlobalUnlock (hglText);
HGLOBAL hglRTF = GlobalAlloc (GMEM_MOVEABLE, strRTF.GetLength () + 1);
strcpy ((char*) GlobalLock (hglRTF), strRTF.GetBuffer (-1));
GlobalUnlock (hglText);
SetClipboardData (CF_TEXT, hglText);
SetClipboardData (RegisterClipboardFormat (CF_RTF), hglRTF);
CloseClipboard ();
}
void
CTrackListView::BuildTrackList()
{
// remember selection
int32 selectedTrackID = -1;
CTrackListItem *selectedItem = dynamic_cast<CTrackListItem *>
(ItemAt(CurrentSelection()));
if (selectedItem)
selectedTrackID = selectedItem->GetTrackID();
// clear list
DeselectAll();
while (CountItems() > 0)
{
CTrackListItem *item = dynamic_cast<CTrackListItem *>(RemoveItem((int32)0));
if (item)
delete item;
}
if (!m_doc)
return;
// re-fill
for (int i = 0; i < m_doc->CountTracks(); i++)
{
CTrack *track = m_doc->TrackAt(i);
if (!track->Deleted())
{
AddItem(new CTrackListItem(track));
if (track->GetID() == selectedTrackID)
Select(i);
}
}
Invalidate();
}
void CTrackToolWidget::slotDBChanged()
{
if(originator) return;
// qDebug() << "void CTrackToolWidget::slotDBChanged()";
if(toolSortAlpha->isChecked())
{
sortmode = eSortByName;
}
else if(toolSortTime->isChecked())
{
sortmode = eSortByTime;
}
QFontMetrics fm(listTracks->font());
QPixmap icon(15,N_LINES*fm.height());
listTracks->clear();
listTracks->setIconSize(icon.size());
QListWidgetItem * highlighted = 0;
CTrackDB::keys_t key;
QList<CTrackDB::keys_t> keys = CTrackDB::self().keys();
foreach(key, keys)
{
CTrack * track = CTrackDB::self().getTrackByKey(key.key);
QListWidgetItem * item = new QListWidgetItem(listTracks);
icon.fill(track->getColor());
QPainter p;
p.begin(&icon);
if(track->isHidden())
{
p.drawPixmap(0,0,QPixmap(":icons/iconClear16x16"));
}
else
{
p.drawPixmap(0,0,QPixmap(":icons/iconOk16x16"));
}
p.end();
item->setText(track->getInfo());
item->setData(Qt::UserRole, track->getKey());
item->setIcon(icon);
if(track->isHighlighted())
{
highlighted = item;
}
}
// ------------------------------------
// Go to
void CReynoldsManager::goTo(const NLMISC::CEntityId &entity, const NLMISC::CVectorD &position)
{
// look for the track, and create a new one if not found -- in both maps
CTrack *etrack = createTrack(entity);
TControlledTrackMap::iterator ite = _ControlledTrackMap.find(entity);
if (ite == _ControlledTrackMap.end())
_ControlledTrackMap.insert(TControlledTrackMap::value_type(entity, etrack));
// create a fake track for point position
static uint i = 0;
CEntityId id(0, i++, 0, 0);
CTrack *pointTo = createTrack(id);
pointTo->setStatic();
pointTo->setId(id, CSheetId::Unknown);
pointTo->setPosition(position, 0.0f);
nldebug("ReynoldsLib:CReynoldsManager:goTo(): %s now goes to (%.1f,%.1f)", entity.toString().c_str(), position.x, position.y);
// let entity follow the target
etrack->follow(pointTo);
}
void CCWArrangePage::OnExportHTML ()
{
m_List.SaveEdit ();
GetTracksInfo ();
if (m_pTracks == NULL)
return;
CFileDialog dlg (FALSE, "html");
if (dlg.DoModal () == IDOK)
{
CStdioFile file (dlg.GetPathName (), CFile::modeCreate | CFile::modeWrite);
file.WriteString ("<html>\r\n\t<head>\r\n\t\t<title>Exported Track Listing: " +
m_pTracks->GetTitle () + "</title>\r\n\t</head>\r\n\r\n\t<body>\r\n");
if (m_pTracks->GetArtist ().IsEmpty ())
file.WriteString ("\t\t<h1>" + m_pTracks->GetTitle () + "</h1>\r\n");
else
file.WriteString ("\t\t<h1>" + m_pTracks->GetArtist () + "</h1>\r\n\t\t<h2>" +
m_pTracks->GetTitle () + "</h2>\r\n");
file.WriteString ("\t\t<table border=\"1\">\r\n\t\t\t<tr>\r\n");
file.WriteString ("\t\t\t\t<th>Track</th>\r\n");
file.WriteString ("\t\t\t\t<th>Track title</th>\r\n");
file.WriteString ("\t\t\t\t<th>Track remarks</th>\r\n");
file.WriteString ("\t\t\t\t<th>Track length</th>\r\n");
file.WriteString ("\t\t\t</tr>\r\n\r\n");
for (int i = 0; i < m_pTracks->GetNumTracks (); i++)
{
CTrack t = m_pTracks->GetTrack (i);
file.WriteString ("\t\t\t<tr>\r\n");
CString s;
s.Format ("%d.", i + 1);
// s
file.WriteString ("\t\t\t\t<td>");
if (s.IsEmpty ())
file.WriteString (" ");
else
file.WriteString (s);
file.WriteString ("</td>\r\n");
// title
file.WriteString ("\t\t\t\t<td>");
s = t.GetTitle ();
if (s.IsEmpty ())
file.WriteString (" ");
else
file.WriteString (s);
file.WriteString ("</td>\r\n");
// remarks
file.WriteString ("\t\t\t\t<td>");
s = t.GetRemarks ();
if (s.IsEmpty ())
file.WriteString (" ");
else
file.WriteString (s);
file.WriteString ("</td>\r\n");
// length
file.WriteString ("\t\t\t\t<td>");
s = t.GetNiceLength ();
if (s.IsEmpty ())
file.WriteString (" ");
else
file.WriteString (s);
file.WriteString ("</td>\r\n");
file.WriteString ("\t\t\t</tr>\r\n");
}
file.WriteString ("\t\t</table>\r\n\t</body>\r\n</html>");
file.Close ();
}
}
void
CTrackListView::MessageReceived(
BMessage *message)
{
D_MESSAGE(("CTrackListView::MessageReceived()\n"));
switch(message->what)
{
case CObservable::UPDATED:
{
int32 trackHint, docHint;
int32 trackID;
if (message->FindInt32("TrackID", &trackID) != B_OK)
trackID = -1;
if (message->FindInt32("TrackAttrs", &trackHint) != B_OK)
trackHint = 0;
if (message->FindInt32("DocAttrs", &docHint ) != B_OK)
docHint = 0;
if (trackHint != 0 || docHint != 0)
{
if (trackID >= 0)
{
for (int i = 0; i < CountItems(); i++)
{
CTrackListItem *item = dynamic_cast<CTrackListItem *>
(ItemAt(i));
if (item && (item->GetTrackID() == trackID))
{
if (trackHint & (CTrack::Update_Name | CTrack::Update_Flags))
{
item->Update(this, be_plain_font);
InvalidateItem(i);
}
}
}
}
if ((docHint & CMeVDoc::Update_AddTrack)
|| (docHint & CMeVDoc::Update_DelTrack)
|| (docHint & CMeVDoc::Update_TrackOrder))
{
BuildTrackList();
}
}
break;
}
case CTrackListItem::EDIT_TRACK:
{
D_MESSAGE((" -> CTrackListItem::EDIT_TRACK\n"));
int32 selection = CurrentSelection();
if (selection >= 0)
{
CTrackListItem *item = (CTrackListItem *)ItemAt(selection);
if (item)
m_doc->ShowWindowFor(item->GetTrack());
}
break;
}
case CTrackListItem::MUTE_TRACK:
{
D_MESSAGE((" -> CTrackListItem::MUTE_TRACK\n"));
int32 selection = CurrentSelection();
if (selection >= 0)
{
CTrackListItem *item = (CTrackListItem *)ItemAt(selection);
CTrack *track = item->GetTrack();
track->SetMuted(!track->Muted());
track->NotifyUpdate(CTrack::Update_Name, NULL);
m_doc->SetModified();
}
break;
}
case CTrackListItem::SOLO_TRACK:
{
D_MESSAGE((" -> CTrackListItem::SOLO_TRACK\n"));
int32 selection = CurrentSelection();
if (selection >= 0)
{
// nyi
}
break;
}
case CTrackListItem::DELETE_TRACK:
{
D_MESSAGE((" -> CTrackListItem::DELETE_TRACK\n"));
int32 selection = CurrentSelection();
if (selection >= 0)
{
CTrackListItem *item = (CTrackListItem *)ItemAt(selection);
CTrack *track = item->GetTrack();
CTrackDeleteUndoAction *undoAction;
undoAction = new CTrackDeleteUndoAction(track);
m_doc->AddUndoAction(undoAction);
}
break;
}
case CTrackListItem::RENAME_TRACK:
{
D_MESSAGE((" -> CTrackListItem::RENAME_TRACK\n"));
int32 index = CurrentSelection();
if (index < 0)
return;
CTrackListItem *item = dynamic_cast<CTrackListItem *>(ItemAt(index));
if (item)
item->StartEdit(this, index, ItemFrame(index));
break;
}
case CTrackListItem::TRACK_NAME_EDITED:
{
D_MESSAGE((" -> CTrackListItem::TRACK_NAME_EDITED\n"));
int32 index;
BString name;
if (message->FindInt32("index", &index) != B_OK)
return;
CTrackListItem *item = dynamic_cast<CTrackListItem *>(ItemAt(index));
if (!item)
return;
item->StopEdit();
if (message->FindString("text", &name) == B_OK)
{
// name changed
CTrack *track = item->GetTrack();
CTrackRenameUndoAction *undoAction;
undoAction = new CTrackRenameUndoAction(track, name);
m_doc->AddUndoAction(undoAction);
}
MakeFocus(true);
break;
}
case MeVDragMsg_ID:
{
D_MESSAGE((" -> MeVDragMsg_ID\n"));
int32 type;
if ((message->FindInt32("Type", &type) != B_OK)
|| (type != DragTrack_ID))
return;
// change of track order requested
int32 index;
message->FindInt32("Index", &index);
// find the target index
BPoint point = ConvertFromScreen(message->DropPoint());
point.y -= ItemFrame(0).Height();
int32 dragIndex;
if (point.y < 0.0)
dragIndex = -1;
else
{
dragIndex = IndexOf(point);
if (dragIndex < 0)
dragIndex = CountItems() - 1;
}
// reorder tracks
if (dragIndex < index)
{
m_doc->ChangeTrackOrder(index, dragIndex + 1);
m_doc->SetModified();
}
else if (dragIndex > index)
{
m_doc->ChangeTrackOrder(index, dragIndex);
m_doc->SetModified();
}
break;
}
default:
{
BListView::MessageReceived(message);
break;
}
}
}
// Uses track sections make in Tracker to create track section models
void E3D_Scene::LoadTrack(char *filename) {
int i, j;
char sModelName[100];
char sLoModelName[100];
E3D_Model *pModel;
E3D_Model *pLoModel;
E3D_Object *pObject;
Pgon *pPoly;
Vertex_f v;
#define TRACK_SCALE 5.0
float seclen;
float x, y, z;
float tx, ty, tz;
float startpitch, startyaw, startroll;
float endpitch, endyaw, endroll;
//float dpitch, dyaw, droll;
float pitch, dirn, roll;
float dforward;
// load the track
CTrack *pTrack = new CTrack();
pTrack->Load(filename);
CTrackSection *ts;
pitch = dirn = roll = 0.0f;
x = y = z = 0;
for(i=0; i<pTrack->GetSectionCount(); i++) {
pModel = AddModel();
pModel->Reset();
sprintf(sModelName, "TS%03d", i);
strcpy(pModel->name, sModelName);
ts = pTrack->GetSection(i);
float dturn = DEG2RAD(ts->turn / ts->numSegments);
float dpitch = DEG2RAD(ts->pitch / ts->numSegments);
float droll = DEG2RAD(ts->roll / ts->numSegments);
tx = 0;
ty = y;
tz = 0;
// generate vertices and polys of our new model
pModel->numverts = (ts->numSegments + 1) * 4;
for(j=0; j<=ts->numSegments; j++) {
// write LHS top vertex
pModel->vert[j*4].x = tx - cos(dirn) * TRACK_SCALE;
pModel->vert[j*4].y = ty + sin(pitch) * TRACK_SCALE;
pModel->vert[j*4].z = tz + sin(dirn) * TRACK_SCALE;
// write RHS top vertex
pModel->vert[j*4+1].x = tx + cos(dirn) * TRACK_SCALE;
pModel->vert[j*4+1].y = ty + sin(pitch) * TRACK_SCALE;
pModel->vert[j*4+1].z = tz - sin(dirn) * TRACK_SCALE;
// write LHS bottom vertex
pModel->vert[j*4+2].x = tx - cos(dirn) * TRACK_SCALE;
pModel->vert[j*4+2].y = 0.0f;
pModel->vert[j*4+2].z = tz + sin(dirn) * TRACK_SCALE;
// write RHS bottom vertex
pModel->vert[j*4+3].x = tx + cos(dirn) * TRACK_SCALE;
pModel->vert[j*4+3].y = 0.0f;
pModel->vert[j*4+3].z = tz - sin(dirn) * TRACK_SCALE;
// update (but not on the last vertex pair)
if(j<ts->numSegments) {
tx = tx - sin(dirn) * TRACK_SCALE;
tz = tz - cos(dirn) * TRACK_SCALE;
ty = ty + sin(pitch) * TRACK_SCALE;
dirn += dturn;
pitch += dpitch;
roll += droll;
}
}
for(j=0; j<ts->numSegments; j++) {
// top
pPoly = pModel->AddPoly4(j*4, j*4+4, j*4+5, j*4+1);
pPoly->filling = 0;
if(j & 1) {
pPoly->colour.r = 1.0f;
pPoly->colour.g = 0.5f;
pPoly->colour.b = 0.2f;
}
else {
pPoly->colour.r = 0.2f;
pPoly->colour.g = 0.5f;
pPoly->colour.b = 1.0f;
}
// left wall
pPoly = pModel->AddPoly4(j*4, j*4+2, j*4+6, j*4+4);
pPoly->filling = 0;
pPoly->colour.r = 0.9f;
pPoly->colour.g = 0.9f;
pPoly->colour.b = 0.9f;
// right wall
pPoly = pModel->AddPoly4(j*4+5, j*4+7, j*4+3, j*4+1);
pPoly->filling = 0;
pPoly->colour.r = 0.9f;
pPoly->colour.g = 0.9f;
pPoly->colour.b = 0.9f;
}
pModel->CalculateNormals(); // generate normals for this model
// add an instance of this model
pObject = AddObject(sModelName);
pObject->MoveTo(x, 0.0, z);
pObject->Rotate(0.0, 0.0, 0.0);
pObject->Scale(1.0, 1.0, 1.0);
pObject->flags |= FLAGS_SURFPOLY; // this object has surface polys
/*
// create LOW-DETAIL VERSION of this track section
pLoModel = AddModel();
pLoModel->Reset();
sprintf(sLoModelName, "TS%03d_LO", i);
strcpy(pLoModel->name, sLoModelName);
v = pModel->vert[0];
pLoModel->AddVertex(v);
v = pModel->vert[1];
pLoModel->AddVertex(v);
v = pModel->vert[2];
pLoModel->AddVertex(v);
v = pModel->vert[3];
pLoModel->AddVertex(v);
v = pModel->vert[ts.numDivs*4];
pLoModel->AddVertex(v);
v = pModel->vert[ts.numDivs*4+1];
pLoModel->AddVertex(v);
v = pModel->vert[ts.numDivs*4+2];
pLoModel->AddVertex(v);
v = pModel->vert[ts.numDivs*4+3];
pLoModel->AddVertex(v);
// top
pPoly = pLoModel->AddPoly4(1, 5, 6, 2);
pPoly->filling = 0;
pPoly->colour.r = 1.0f;
pPoly->colour.g = 0.5f;
pPoly->colour.b = 0.2f;
// left wall
pPoly = pLoModel->AddPoly4(0, 4, 5, 1);
pPoly->filling = 0;
pPoly->colour.r = 0.9f;
pPoly->colour.g = 0.9f;
pPoly->colour.b = 0.9f;
// right wall
pPoly = pLoModel->AddPoly4(2, 6, 7, 3);
pPoly->filling = 0;
pPoly->colour.r = 0.9f;
pPoly->colour.g = 0.9f;
pPoly->colour.b = 0.9f;
pLoModel->CalculateNormals(); // generate normals for this model
pObject = AddObject(sLoModelName);
pObject->MoveTo(ts.vStart.x, 0.0, ts.vStart.z + 200.0);
pObject->Rotate(0, 0, 0);
pObject->Scale(1, 1, 1);
*/
//update track section position
x += tx;
y = ty;
z += tz;
}
}
void CLabel::DrawBG(wxDC& dc, wxRect& rc)
{
CTrack *track = getTrack();
m_rcLabel = rc;
wxBrush oldBrush = dc.GetBrush();
wxPen oldpen = dc.GetPen();
wxPen pen( *wxMEDIUM_GREY_PEN );
pen.SetWidth(1);
dc.SetPen( pen );
//wxBrush brush(m_color, (IsSelected() ? wxCROSSDIAG_HATCH : wxSOLID));
wxBrush brush(track->GetBGColor(), wxSOLID);
dc.SetBrush(brush);
int left, top, width, height;
if(m_bDrawAquaBG)
{
// Draw aqua background
left = 0;
top = rc.GetTop();
width = rc.GetWidth()-left;
height = rc.GetHeight();
//dc.DrawRectangle(left, top, width, height);
wxRect rc(left+1, top+1, width-2, height-2);
DrawAquaRect(dc, rc, 4);
}
else
{
// Draw background
left = 1;//m_nLevel*4+2;
top = rc.GetTop()+1;
width = rc.GetWidth()-1;//left-3;
height = rc.GetHeight()-2;
//dc.DrawRoundedRectangle(left, top, width, height, 4);
//DrawRect3D(dc, wxRect(left, top, width, height));
DrawRect3D(dc, rc);
}
dc.SetTextForeground( track->GetForeColor() );
wxFont oldFont = dc.GetFont();
wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
//wxFont font = oldFont;
//font.SetWeight(IsSelected() ? wxBOLD : wxNORMAL);
//font.SetPointSize(GetHeight() / 4);
font.SetPointSize( 9 );
dc.SetFont(font);
//wxFont font(12, wxDEFAULT, wxITALIC, (IsSelected() ? wxBOLD : wxNORMAL));
//dc.SetFont(font);
////dc.SetFont((IsSelected() ? *wxITALIC_FONT : *wxNORMAL_FONT));
// Get text dimensions
wxCoord w=0, h=0;
wxString csName;
track->GetName(csName);
dc.GetTextExtent(csName, &w, &h);
/*int ptSize = GetHeight() / 2;
// Get text dimensions
wxCoord w=0, h=0;
do {
font.SetPointSize(ptSize);
dc.GetTextExtent(m_name, &w, &h);
ptSize--;
} while (w>width && ptSize > 5);*/
// Draw text
int x = left + 5;//width/2 - w/2;
int y = (rc.GetTop() + (rc.GetHeight()/4) - h/2);
dc.DrawText( csName, x, y );
m_rcLabel.SetHeight(rc.GetHeight());
/*
int n = rc.GetHeight()/2-2;
if(n > 20)
n = 20;
drawLoopSign(dc, wxRect(5, top+height-n-2, n, n));
drawCacheSign(dc, wxRect(n+5+1, top+height-n-2, n, n));
*/
wxRect rcTmp = getPathRect(rc);
m_pPathCtrl->DrawBG(dc, rcTmp);
dc.SetFont(oldFont);
dc.SetPen(oldpen);
dc.SetBrush( oldBrush );
}
CDlgTrackFilter::CDlgTrackFilter(CTrack &track, QWidget * parent)
: QDialog(parent)
, track(track)
{
setupUi(this);
SETTINGS;
checkReduceDataset->setChecked(false);
checkModifyTimestamps->setChecked(false);
QList<CTrack::pt_t>& trkpts = track.getTrackPoints();
QList<CTrack::pt_t>::iterator trkpt = trkpts.begin();
if(IUnit::self().baseunit == "ft")
{
comboMeterFeet->setCurrentIndex((int)FEET_INDEX);
spinDistance->setSuffix("ft");
}
else
{
comboMeterFeet->setCurrentIndex((int)METER_INDEX);
spinDistance->setSuffix("m");
}
spinDistance->setValue(cfg.value("trackfilter/distance",10).toInt());
spinAzimuthDelta->setValue(cfg.value("trackfilter/azimuthdelta",10).toInt());
checkAzimuthDelta->setChecked(cfg.value("trackfilter/useazimuthdelta", false).toBool());
if(trkpt->timestamp == 0x000000000 || trkpt->timestamp == 0xFFFFFFFF)
{
// no track time available
tabTimestamp->setEnabled(false);
radioTimedelta->setEnabled(false);
spinTimedelta->setEnabled(false);
// qDebug() << "Track has no timestamps that could be modified.";
}
else
{
tabTimestamp->setEnabled(true);
radioTimedelta->setEnabled(true);
spinTimedelta->setEnabled(true);
QDateTime t = QDateTime::fromTime_t(trkpt->timestamp).toLocalTime();
datetimeStartTime->setDateTime(t);
radioLocalTime->setChecked(true);
radioUTC->setChecked(false);
}
spinTimedelta->setValue(cfg.value("trackfilter/timedelta",5).toInt());
quint32 cnt = track.getMedianFilterCount();
checkMedian->setText(tr("Smooth profile (Median filter, %1 tabs)").arg(5 + (cnt<<1)));
// user-tunable elements on "Modify Timestamps" tab
connect(buttonReset1stOfMonth, SIGNAL(clicked()), this, SLOT(slotReset1stOfMonth()));
connect(buttonResetEpoch, SIGNAL(clicked()), this, SLOT(slotResetEpoch()));
connect(datetimeStartTime, SIGNAL(dateTimeChanged(const QDateTime &)), this, SLOT(slotDateTimeChanged(const QDateTime &)));
// user-tunable elements on "Reduce Dataset" tab
connect(radioDistance, SIGNAL(clicked()), this, SLOT(slotRadioDistance()));
connect(checkAzimuthDelta, SIGNAL(clicked()), this, SLOT(slotCheckAzimuthDelta()));
connect(radioTimedelta, SIGNAL(clicked()), this, SLOT(slotRadioTimedelta()));
connect(spinDistance, SIGNAL(valueChanged(int)), this, SLOT(slotSpinDistance(int)));
connect(spinAzimuthDelta, SIGNAL(valueChanged(int)), this, SLOT(slotSpinAzimuthDelta(int)));
connect(spinTimedelta, SIGNAL(valueChanged(int)), this, SLOT(slotSpinTimedelta(int)));
connect(comboMeterFeet, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(slotComboMeterFeet(const QString &)));
connect(checkMedian, SIGNAL(clicked()), this, SLOT(slotCheckMedian()));
connect(radioSplitChunks, SIGNAL(clicked()), this, SLOT(slotRadioSplitChunks()));
connect(radioSplitPoints, SIGNAL(clicked()), this, SLOT(slotRadioSplitPoints()));
connect(spinSplitChunks, SIGNAL(valueChanged(int)), this, SLOT(slotSplitChunks(int)));
connect(spinSplitPoints, SIGNAL(valueChanged(int)), this, SLOT(slotSplitPoints(int)));
}
bool CvTrack::UpdateTrack(const double thDistance, const unsigned int thInactive, const unsigned int thActive/*=0*/ )
{
CV_FUNCNAME("CvTrack::UpdateTrack");
__CV_BEGIN__;
unsigned int nBlobs = m_CurBlobs.GetContainterSize();
unsigned int nTracks = m_CurTracks.GetContainterSize();
Blob_vector& tmpBlobs=m_CurBlobs.m_blobs;
Track_vector& tmpTracks=m_CurTracks.m_Tracks;
// Proximity matrix:
// Last row/column is for ID/label.
// Last-1 row/column is for accumulation.
unsigned int *close = new unsigned int[(nBlobs+2)*(nTracks+2)]; // XXX Must be same type than CvLabel.
try
{
// Inicialization:
unsigned int i=0;
for (Blob_vector_constit it = tmpBlobs.begin(); it!=tmpBlobs.end(); ++it, i++){
Last_1_Blobs(i) = 0;
Last_Blobs(i) = (*it)->GetID();
}
unsigned int maxTrackID = 0;
unsigned int j=0;
for (Track_vector_constit jt = tmpTracks.begin(); jt!=tmpTracks.end(); ++jt, j++){
Last_1_Tracks(j) = 0;
Last_Tracks(j) = (*jt)->GetID();
if ((*jt)->GetID() > maxTrackID)
maxTrackID = (*jt)->GetID();
}
// Proximity matrix calculation and "used blob" list inicialization:
for (i=0; i<nBlobs; i++){
for (j=0; j<nTracks; j++){
if (C(i, j) = (distantBlobTrack(GetBlobByID(i), GetTrackByID(j)) < thDistance)){
Last_1_Blobs(i)++;
Last_1_Tracks(j)++;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Detect inactive tracks
for (j=0; j<nTracks; j++){
unsigned int c = Last_1_Tracks(j);
if (c==0){//此track与所有blobs都无关系，说明些track丢失
CTrack *track = GetTrackByID(j);
track->m_inactive++;
track->SetID(0);
}
}
// Detect new tracks
for (i=0; i<nBlobs; i++){
unsigned int c = Last_1_Blobs(i);
if (c==0){//此blobs与所有tracks都无关系，说明是新的目标
maxTrackID++;
CBlob *blob = GetBlobByID(i);
CTrack *track = new CTrack(*blob,maxTrackID,TRACKSTATE_ACTIVE);
tmpTracks.push_back(track);
}
}
// Clustering
for (j=0; j<nTracks; j++){
unsigned int c = Last_1_Tracks(j);
if (c){
list<CTrack*> tt;
tt.push_back(GetTrackByID(j));
list<CBlob*> bb;
getClusterForTrack(j, close, nBlobs, nTracks, tmpBlobs, bb, tt);
// Select track
CTrack *track;
unsigned int area = 0;
for (list<CTrack*>::const_iterator it=tt.begin(); it!=tt.end(); ++it){
CTrack *t = *it;
unsigned int a = (t->m_rcBoundingBox.width)*(t->m_rcBoundingBox.height);
if (a>area){
area = a;
track = t;
}
}
// Select blob
CBlob *blob;
area = 0;
//cout << "Matching blobs: ";
for (list<CBlob*>::const_iterator it=bb.begin(); it!=bb.end(); ++it){
CBlob *b = *it;
//cout << b->label << " ";
if (CBlobGetArea()(*b)>area){
area = CBlobGetArea()(*b);
blob = b;
}
}
// Update track
*track=*blob;
if (track->m_inactive)
track->m_active = 0;
track->m_inactive = 0;
// Others to inactive
for (list<CTrack*>::const_iterator it=tt.begin(); it!=tt.end(); ++it)
{
CTrack *t = *it;
if (t!=track)
{
//cout << "Inactive: track=" << t->id << endl;
//t->inactive++;
//t->label = 0;
t->m_inactive++;
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
for (Track_vector_it jt=tmpTracks.begin(); jt!=tmpTracks.end();){
if ( (*jt)->m_inactive>=thInactive ||
((*jt)->m_inactive && thActive && (*jt)->m_active<thActive) )
{
delete (*jt);
jt=tmpTracks.erase(jt);
}
else
{
(*jt)->m_lifetime++;
if (!(*jt)->m_inactive)
(*jt)->m_active++;
++jt;
}
}
}
catch (...)
{
delete[] close;
throw;
}
delete[] close;
__CV_END__;
return true;
}
void CDeviceGarmin::downloadTracks(QList<CTrack*>& trks)
{
qDebug() << "CDeviceGarmin::downloadTracks()";
Garmin::IDevice * dev = getDevice();
if(dev == 0) return;
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
std::list<Garmin::Track_t> gartrks;
try
{
dev->downloadTracks(gartrks);
if (CResources::self().playSound())
{
QSound::play(":/sounds/xfer-done.wav");
}
QApplication::restoreOverrideCursor();
}
catch(int)
{
QMessageBox::warning(0,tr("Device Link Error"),dev->getLastError().c_str(),QMessageBox::Ok,QMessageBox::NoButton);
QApplication::restoreOverrideCursor();
return;
}
QTextCodec *codec = QTextCodec::codecForName(CResources::self().charset().toLatin1());
std::list<Garmin::Track_t>::const_iterator gartrk = gartrks.begin();
while(gartrk != gartrks.end())
{
CTrack * trk = new CTrack(&CTrackDB::self());
trk->setName(codec->toUnicode(gartrk->ident.c_str()));
trk->setColor(gartrk->color);
std::vector<Garmin::TrkPt_t>::const_iterator gartrkpt = gartrk->track.begin();
while(gartrkpt != gartrk->track.end())
{
QDateTime t = QDateTime::fromTime_t(gartrkpt->time);
t = t.addYears(20).addDays(-1);
CTrack::pt_t trkpt;
trkpt.lon = gartrkpt->lon;
trkpt.lat = gartrkpt->lat;
trkpt.timestamp = t.toTime_t();
trkpt.ele = gartrkpt->alt;
*trk << trkpt;
++gartrkpt;
}
if(trk->getTrackPoints().count() > 0)
{
trks << trk;
}
else
{
delete trk;
}
++gartrk;
}
theMainWindow->getCanvas()->setFadingMessage(tr("Download tracks finished!"));
}
