00001
00002
00003 #ifndef Impala_Visualization_AllFramesTLineVideo_h
00004 #define Impala_Visualization_AllFramesTLineVideo_h
00005
00006 #include "Persistency/SimilarityTableSetRepository.h"
00007 #include "Persistency/AnnotationTableRepository.h"
00008 #include "OglGui/CheckBox.h"
00009 #include "OglGui/UpDownButton.h"
00010 #include "OglGui/FramesPerSecond.h"
00011 #include "Visualization/SimilarityTimeLineVideo.h"
00012 #include "Core/VideoSet/SegmentationDocument.h"
00013 #include "Core/Database/RawDataSet.h"
00014 #include "Core/Stream/RgbDataSrcRaw.h"
00015 #include "Visualization/AppControlDoc.h"
00016
00017
00018 namespace Impala {
00019 namespace Visualization {
00020
00021 class AllFramesTLineVideo : public OglGui::Window,
00022 public AppControlDoc,
00023 public OglGui::WindowListener,
00024 public OglGui::CheckBoxListener,
00025 public OglGui::ButtonListener,
00026 public OglGui::UpDownButtonListener,
00027 public Core::Database::DataDocumentListener
00028 {
00029 public:
00030 static const int SHOW_SHOT_BOUNDARIES = 1;
00031 static const int SHOW_VIEWSTRIP = 2;
00032 static const int NEXT_PREV_SHOT = 3;
00033 static const int NEXT_PREV_KEYFRAME = 4;
00034 static const int VIEWSTRIP_PRE = 5;
00035 static const int VIEWSTRIP_MIN = 6;
00036 static const int VIEWSTRIP_MAX = 7;
00037 static const int CENTER_NEEDLE = 8;
00038 static const int CENTER_NEEDLE_ONPLAY = 9;
00039 static const int EXTRA_TIMELINE = 10;
00040 static const int NEXT_PREV_POSITIVE = 11;
00041
00042 static const int VALIDATE = 31;
00043
00044 typedef OglGui::CheckBox CheckBox;
00045 typedef OglGui::StaticText StaticText;
00046 typedef OglGui::Button Button;
00047 typedef OglGui::UpDownButton UpDownButton;
00048
00049 typedef Core::VideoSet::SegmentationDocument SegmentationDocument;
00050 typedef Core::VideoSet::Segmentation Segmentation;
00051 typedef Core::VideoSet::Keyframes Keyframes;
00052 typedef Core::Table::SimilarityTableSet SimilarityTableSet;
00053 typedef SimilarityTableSet::SimTableType SimTableType;
00054
00055 typedef std::vector<int> IntVector;
00056 typedef std::vector<IntVector*> AnnoPositives;
00057 typedef std::vector<float> FloatVector;
00058 typedef std::vector<FloatVector*> Averages;
00059
00060 typedef Core::Table::AnnotationTable AnnotationTable;
00061
00062 typedef Core::Stream::RgbDataSrcRaw RgbDataSrcRaw;
00063 typedef Core::Stream::RgbDataSrcFactory RgbDataSrcFactory;
00064 typedef Core::Stream::RgbDataSrc RgbDataSrc;
00065 typedef Core::Database::RawDataSet RawDataSet;
00066
00067 typedef Core::VideoSet::VideoSet VideoSet;
00068
00069 AllFramesTLineVideo(OglGui::Window* parent,int wndW, int wndH,
00070 SegmentationDocument* segDoc, int controlId) :
00071 Window(parent,0,0,wndW, wndH, true),
00072 AppControlDoc(controlId, segDoc)
00073 {
00074 Init(wndW, wndH, segDoc);
00075 }
00076
00077 void HandleNewVideo()
00078 {
00079 VideoSet* videoSet = mSegDoc->GetVideoSet();
00080 String videoName = videoSet->GetFile(mCurFile);
00081 bool vidIsMpg = !mTimeLineVideoRaw;
00082 bool stripIsMpg = !mViewStripVideoRaw;
00083
00084 RgbDataSrc* rgbDataSrc;
00085 if (mTimeLineVideoRaw)
00086 rgbDataSrc = videoSet->GetVideoInLowResolution(mCurFile, true);
00087 if (!mTimeLineVideoRaw || (mTimeLineVideoRaw && !rgbDataSrc))
00088 {
00089 rgbDataSrc = videoSet->GetVideo(mCurFile);
00090 vidIsMpg = true;
00091 }
00092 mSimTLV->OpenVideo(rgbDataSrc,videoName);
00093
00094 SimilarityTimeLine* timeLine = mSimTLV->TimeLine();
00095 if (mShowViewStrip)
00096 {
00097 timeLine->ViewStripRgbDataSrc((RgbDataSrc*)0);
00098 timeLine->SetAxisY(mTLVAxisY);
00099 timeLine->ViewStripY(mViewStripY);
00100 timeLine->ViewStripFrameStep(mViewStripStep);
00101 timeLine->ViewStripMinViewWidth(mViewStripMinW);
00102 timeLine->SetNeedleColor(mNeedleColor);
00103 }
00104 if (mShowViewStrip)
00105 {
00106 if (mViewStripVideoRaw)
00107 rgbDataSrc = videoSet->GetVideoInLowResolution(mCurFile, true);
00108 if (!mViewStripVideoRaw || (mViewStripVideoRaw && !rgbDataSrc))
00109 {
00110 rgbDataSrc = videoSet->GetVideo(mCurFile);
00111 stripIsMpg = true;
00112 }
00113 timeLine->ViewStripRgbDataSrc(rgbDataSrc);
00114 }
00115 timeLine->mBothMpg = (stripIsMpg && vidIsMpg);
00116
00117 mSimTLV->Player()->GotoFrame(mSegDoc->CurFrame());
00118 ConstructPositives();
00119 }
00120 #if 0
00121 void HandleNewVideo()
00122 {
00123 VideoSet videoSet = mSegDoc->GetVideoSet();
00124 RawDataSet* dataSet = mSegDoc->GetDataSet();
00125 String videoName = dataSet->GetFile(mCurFile);
00126 bool vidIsMpg = !mTimeLineVideoRaw;
00127 bool stripIsMpg = !mViewStripVideoRaw;
00128
00129 RgbDataSrc* rgbDataSrc = videoSet->GetVideo(mCurFile, mTimeLineVideoRaw);
00130 if (mTimeLineVideoRaw && !rgbDataSrc)
00131 {
00132 rgbDataSrc = videoSet->GetVideo(mCurFile);
00133 vidIsMpg = true;
00134 }
00135 mSimTLV->OpenVideo(rgbDataSrc,videoName);
00136
00137 SimilarityTimeLine* timeLine = mSimTLV->TimeLine();
00138 if (mShowViewStrip)
00139 {
00140 timeLine->ViewStripRgbDataSrc((RgbDataSrc*)0);
00141 timeLine->SetAxisY(mTLVAxisY);
00142 timeLine->ViewStripY(mViewStripY);
00143 timeLine->ViewStripFrameStep(mViewStripStep);
00144 timeLine->ViewStripMinViewWidth(mViewStripMinW);
00145 timeLine->SetNeedleColor(mNeedleColor);
00146 }
00147 if (mShowViewStrip)
00148 {
00149 RgbDataSrc* dataSrc = videoSet->GetVideo(mCurFile, mViewStripVideoRaw);
00150 if (mViewStripVideoRaw && !dataSrc)
00151 {
00152 dataSrc = videoSet->GetVideo(mCurFile);
00153 stripIsMpg = true;
00154 }
00155 timeLine->ViewStripRgbDataSrc(dataSrc);
00156 }
00157 timeLine->mBothMpg = (stripIsMpg && vidIsMpg);
00158
00159 mSimTLV->Player()->GotoFrame(mSegDoc->CurFrame());
00160 ConstructPositives();
00161 }
00162 #endif 0
00163
00164 void HandleNewSimSet()
00165 {
00166 bool doExtra = false;
00167 RawDataSet* dataSet = mSegDoc->GetDataSet();
00168
00169
00170 #ifndef REPOSITORY_USED // Here comes the deprecated stuff
00171 std::string simNames =
00172 dataSet->GetFilePathSimilarityData("Frames", mConceptSet, mConceptModel,
00173 mConceptFeature, mCurFile,
00174 "names.txt", false, false);
00175
00176 if (mSimSet)
00177 delete mSimSet;
00178 mSimSet = 0;
00179 if (!simNames.empty())
00180 mSimSet = SimilarityTableSet::MakeFromFile(simNames,
00181 dataSet->GetDatabase());
00182 #else // REPOSITORY_USED
00183 typedef Persistency::SimilarityTableSetLocator SimLoc;
00184 SimLoc loc(dataSet->GetLocator(), false, "Frames", mConceptSet,
00185 mConceptModel, mConceptFeature,
00186 dataSet->GetContainerFile(mCurFile));
00187 if (mSimSet)
00188 delete mSimSet;
00189 mSimSet = Persistency::SimilarityTableSetRepository().Get(loc);
00190 #endif // REPOSITORY_USED
00191
00192 if (!mSimTLV)
00193 {
00194 int m = 0;
00195 m |= mShowViewStrip ? 4 : 0;
00196 m |= mTimeLineVideo3D ? 16 : 0;
00197 mSimTLV = new SimilarityTimeLineVideo(this,0,30,W(),H()-30,
00198 mSimSet,m);
00199 SimilarityTimeLine* simTL = mSimTLV->TimeLine();
00200 simTL->SetWindowListener(this);
00201 simTL->FrameError(mFrameError);
00202 mSimTLV->ConnectTo(this);
00203 mSimTLV->ScaleChildren(0,0);
00204 doExtra = true;
00205 }
00206 else
00207 mSimTLV->SetSimilarityTableSet(mSimSet);
00208 HandleNewVideo();
00209 if (doExtra)
00210 HandleExtraTimeLines();
00211 }
00212
00213 virtual void
00214 HandleNewFile()
00215 {
00216 if (!mSegDoc->HasCursor())
00217 {
00218 mCurFile = -1;
00219 return;
00220 }
00221 int fileId = mSegDoc->CurFileId();
00222 if (fileId == mCurFile && mSimTLV)
00223 {
00224 mSimTLV->Player()->GotoFrame(mSegDoc->CurFrame()-mFrameError);
00225 return;
00226 }
00227 mCurFile = fileId;
00228 HandleNewSimSet();
00229 }
00230
00231 virtual void CheckBoxEvent(CheckBox *src, bool checked, void* vData)
00232 {
00233 int userData = (long long) vData;
00234 if (userData == SHOW_SHOT_BOUNDARIES)
00235 mShowBoundaries = checked;
00236 if (userData == SHOW_VIEWSTRIP)
00237 mSimTLV->TimeLine()->ViewStripShow(checked);
00238 if (userData == CENTER_NEEDLE_ONPLAY)
00239 mSimTLV->CenterNeedleOnPlay(checked);
00240 if (userData == CENTER_NEEDLE)
00241 mSimTLV->CenterNeedle(checked);
00242 }
00243
00244 int FindFrameShot(int frame)
00245 {
00246 Segmentation* seg = mSegDoc->GetSegmentation();
00247 int firstShot = seg->GetFirstShotVideo(mCurFile);
00248 int lastShot = firstShot+seg->GetNrShotsVideo(mCurFile);
00249 int i;
00250
00251 for (i=firstShot; i<lastShot; i++)
00252 if (seg->GetStart(i) > frame)
00253 break;
00254 return i-1;
00255 }
00256
00257 void GoToAdjacentShot(bool next)
00258 {
00259 Segmentation* seg = mSegDoc->GetSegmentation();
00260 int curFrame = mSimTLV->Player()->FrameNr();
00261 int nextShot = FindFrameShot(curFrame) + (next?1:-1);
00262 mSimTLV->TimeLine()->Current(seg->GetStart(nextShot)*40);
00263 }
00264
00265 int FindAdjacentKeyFrame(int frame, bool next)
00266 {
00267 Keyframes* keys = mSegDoc->GetKeyframes();
00268 int firstKeyFr = keys->GetFirstKeyframeVideo(mCurFile);
00269 int lastKeyFr = firstKeyFr+keys->GetNrKeyframesVideo(mCurFile);
00270 int i, k, prevK;
00271
00272
00273 frame += next ? 1 : 0;
00274 for (i=firstKeyFr; i<lastKeyFr; i++)
00275 {
00276 if ((k=keys->GetFrameNr(i))<frame)
00277 prevK = k;
00278 else
00279 break;
00280 }
00281 return (next ? k : prevK);
00282 }
00283
00284 void GoToAdjacentKeyFrame(bool next)
00285 {
00286 int curFrame = mSimTLV->Player()->FrameNr();
00287 int nFrame = FindAdjacentKeyFrame(curFrame,next);
00288 mSimTLV->TimeLine()->Current(nFrame*40);
00289 }
00290
00291 int FindAdjacentPositive(int id, int frame, bool next)
00292 {
00293 int i, k, prevK;
00294
00295 frame += next ? 1 : 0;
00296 IntVector* positiveVector = mAnnoPositives[id];
00297
00298 for (i=0; i<positiveVector->size(); i++)
00299 {
00300 if ((k=(*positiveVector)[i])<frame)
00301 prevK = k;
00302 else
00303 break;
00304 }
00305 return (next ? k : prevK);
00306 }
00307
00308 void GoToAdjacentPositive(int id, bool next)
00309 {
00310 int curFrame = mSimTLV->Player()->FrameNr();
00311 int nFrame = FindAdjacentPositive(id,curFrame,next);
00312 mSimTLV->TimeLine()->Current(nFrame*40);
00313 }
00314
00315 virtual void
00316 UpDownButtonSelectionEvent(UpDownButton *src, bool isUpBtn, void* vData)
00317 {
00318 int userData = (long long) vData;
00319 if (userData == NEXT_PREV_SHOT)
00320 GoToAdjacentShot(isUpBtn);
00321 if (userData==NEXT_PREV_KEYFRAME)
00322 GoToAdjacentKeyFrame(isUpBtn);
00323 if (userData>=NEXT_PREV_POSITIVE && userData<NEXT_PREV_POSITIVE+20)
00324 GoToAdjacentPositive(userData-NEXT_PREV_POSITIVE,isUpBtn);
00325 mSimTLV->TimeLine()->MakeCurrentVisible();
00326 }
00327
00328 virtual void ButtonSelectionEvent(Button *src, void* vData)
00329 {
00330 int userData = (long long) vData;
00331 if (userData==VIEWSTRIP_PRE)
00332 mSimTLV->TimeLine()->ViewStripZoomToShowViews(0);
00333 if (userData==VIEWSTRIP_MIN)
00334 mSimTLV->TimeLine()->ViewStripZoomToShowViews(1);
00335 if (userData==VIEWSTRIP_MAX)
00336 mSimTLV->TimeLine()->ViewStripZoomToShowViews(2);
00337 if (userData==EXTRA_TIMELINE)
00338 mSimTLV->ExtraTimeLine(mSimTLV, mSimTLV->TitledTimeLine()->X(),
00339 mSimTLV->H()-200,
00340 mSimTLV->TitledTimeLine()->W(),182,
00341 "Extra TimeLine");
00342 if (userData==VALIDATE)
00343 AnnoValidate();
00344 }
00345
00346 void AnnoValidate()
00347 {
00348 RawDataSet* dataSet = mSegDoc->GetDataSet();
00349 std::string dir = dataSet->GetFile(mCurFile);
00350
00351 printf("\n\nValidation %s\n--------------------------------------\n",
00352 dir.c_str());
00353 SimilarityTimeLine* timeLine = mSimTLV->TimeLine();
00354 for (int a=0; a<mAnnoTables.size(); a++)
00355 {
00356 AnnotationTable* anno = mAnnoTables[a];
00357 FloatVector* avgVector = (*mSimTLV->GetAverages())[a];
00358
00359 int nPosCorrect=0, nPosInCorrect = 0;
00360 int nFalseCorrect=0, nFalseInCorrect= 0;
00361 int n = 0;
00362 float maxim = (*mSimTLV->Maxima())[a];
00363 float mean = (*mSimTLV->Means())[a];
00364
00365 int sz = anno->Size();
00366 for (int i=0; i<sz; i++)
00367 {
00368 Quid quid = anno->Get1(i);
00369 float qual = anno->Get2(i);
00370 int vidId = QuidObject(quid);
00371 int frameId = QuidId(quid);
00372 if (vidId==mCurFile)
00373 {
00374 float sim = (*avgVector)[frameId];
00375 bool isConcept = timeLine->PassTest(sim,maxim,mean);
00376 if (qual > 0)
00377 {
00378 if (isConcept)
00379 nPosCorrect++;
00380 else
00381 nPosInCorrect++;
00382 }
00383 if (qual < 0)
00384 {
00385 if (isConcept)
00386 nFalseInCorrect++;
00387 else
00388 nFalseCorrect++;
00389 }
00390 n++;
00391 }
00392 }
00393 printf("%18s: %3d TruePos, %3d FalseNeg, TrueNeg %3d FalsePos %3d\n",
00394 mSimSet->GetNames()[a].c_str(), nPosCorrect, nPosInCorrect, nFalseCorrect, nFalseInCorrect);
00395 }
00396 }
00397
00398 void ReadAnnotations()
00399 {
00400 AnnotationTable *anno;
00401
00402 for (int i=0; i<mSegDoc->NrConcepts(); i++)
00403 {
00404 anno = 0;
00405 Core::VideoSet::VideoSet* vidSet = mSegDoc->GetVideoSet();
00406 #ifndef REPOSITORY_USED // Here comes the deprecated stuff
00407 std::string fName = vidSet->GetFilePathAnnotation
00408 (QUID_CLASS_FRAME, mConceptAnnotations,
00409 mSegDoc->GetConcept(i)+".tab", false, true);
00410 if (fName.empty())
00411 printf("No annotions for %s\n", mSegDoc->GetConcept(i).c_str());
00412 else
00413 anno = Core::Table::AnnotationTable::MakeFromFile
00414 (mSegDoc->GetConcept(i), fName, vidSet->GetDatabase());
00415 #else // REPOSITORY_USED
00416 typedef Persistency::AnnotationTableLocator AnnoLoc;
00417 AnnoLoc loc(vidSet->GetLocator(), QUID_CLASS_FRAME,
00418 mConceptAnnotations, mSegDoc->GetConcept(i));
00419 if (Persistency::AnnotationTableRepository().Exists(loc))
00420 anno = Persistency::AnnotationTableRepository().Get(loc);
00421 #endif // REPOSITORY_USED
00422 if (anno)
00423 mAnnoTables.push_back(anno);
00424 }
00425 }
00426
00427 void ClearPositives()
00428 {
00429 for (int i=0; i<mAnnoPositives.size(); i++)
00430 delete mAnnoPositives[i];
00431 mAnnoPositives.clear();
00432 }
00433
00434 void ConstructPositives()
00435 {
00436 ClearPositives();
00437
00438 int sz = mAnnoTables.size();
00439 for (int a=0; a<sz; a++)
00440 {
00441 AnnotationTable* anno = mAnnoTables[a];
00442 IntVector* positiveVector = new IntVector;
00443
00444 for (int i=0; i<anno->Size(); i++)
00445 {
00446 Quid quid = anno->Get1(i);
00447 float qual = anno->Get2(i);
00448 int vidId = QuidObject(quid);
00449 int frameId = QuidId(quid);
00450
00451 if (vidId == mCurFile && qual > 0)
00452 positiveVector->push_back(frameId);
00453 }
00454 mAnnoPositives.push_back(positiveVector);
00455 }
00456 }
00457
00458 virtual void WindowDisplayEvent(OglGui::Window *src, void* userData)
00459 {
00460 ShowBoundaries((SimilarityTimeLine*) src);
00461 ShowPositives((SimilarityTimeLine*) src);
00462
00463 if (!mChBoxValueBars)
00464 {
00465 mChBoxValueBars = mSimTLV->ChBoxValueBars();
00466 OglGui::CheckBoxValueBar* chBoxVB;
00467 int item = 0;
00468 while( chBoxVB = mChBoxValueBars->GetItem(item) )
00469 {
00470 UpDownButton* upDownBtn
00471 = RightUpDownButton(chBoxVB,20,12,NEXT_PREV_POSITIVE+item);
00472 item++;
00473 }
00474 }
00475 }
00476
00477 void ShowBoundaries(SimilarityTimeLine* simTL)
00478 {
00479 if (!mShowBoundaries)
00480 return;
00481
00482 Segmentation* seg = mSegDoc->GetSegmentation();
00483 int firstShot = seg->GetFirstShotVideo(mCurFile);
00484 int nrShots = seg->GetNrShotsVideo(mCurFile);
00485 int frameErr = simTL->FrameError();
00486
00487 int y = simTL->GetAxisY();
00488
00489 int i, x, frame;
00490
00491 SetSolidLineColor(0xffff8050);
00492 for (i=firstShot; i<firstShot+nrShots; i++)
00493 {
00494 frame = seg->GetStart(i);
00495 x = simTL->Unit2Pixel((frame-frameErr)*40);
00496 DrawLine(x,y-16,x,y+200);
00497 }
00498
00499 Keyframes* keys = mSegDoc->GetKeyframes();
00500 int firstKeyfr = keys->GetFirstKeyframeVideo(mCurFile);
00501 int nrKeys = keys->GetNrKeyframesVideo(mCurFile);
00502
00503 int curFr = mSegDoc->CurFrame();
00504 for (i=firstKeyfr; i<firstKeyfr+nrKeys; i++)
00505 {
00506 frame = keys->GetFrameNr(i);
00507 ULONG col = keys->IsRKF(i) ? oglRED : oglBLUE;
00508 if (curFr == frame)
00509 col = oglGREEN;
00510 SetSolidLineColor(col);
00511 x = simTL->Unit2Pixel((frame-frameErr)*40);
00512
00513 DrawLine(x,y-16,x,y+100);
00514 }
00515 }
00516
00517 void ShowPositives(SimilarityTimeLine* simTL)
00518 {
00519 if (!mShowPositives)
00520 return;
00521
00522
00523
00524 int y = simTL->GetAxisY();
00525
00526 SetLineWidth(3);
00527 int nConcepts = mAnnoPositives.size();
00528 for (int i=0; i<nConcepts; i++)
00529 {
00530 if (!simTL->GetShowSim(i))
00531 continue;
00532
00533 ULONG col = simTL->GetSimColor(i);
00534 SetSolidLineColor(col);
00535 IntVector* positiveVector = mAnnoPositives[i];
00536 int sz = positiveVector->size();
00537 for (int p=0; p<sz; p++)
00538 {
00539 int posFrame = (*positiveVector)[p];
00540 int x = simTL->Unit2Pixel(posFrame*40);
00541 DrawLine(x,y-(i*2)-2,x,y-20);
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553 }
00554 }
00555 SetLineWidth(1);
00556 }
00557
00558 private:
00559 void HandleExtraTimeLines()
00560 {
00561 for (int i=0; i<mNrExtraTimeLines; i++)
00562 {
00563 int x,y,w,h,tlvH=mSimTLV->H();
00564 mSimTLV->TitledTimeLine()->GetDimensions(x,y,w,h);
00565 int nH = (tlvH - (y+h))/mNrExtraTimeLines;
00566 OglGui::TitledWindow* titledWnd =
00567 mSimTLV->ExtraTimeLine(mSimTLV,x,tlvH-(mNrExtraTimeLines-i)*nH,
00568 w,nH-2,"Extra TimeLine");
00569 titledWnd->ScaleTo(this);
00570 mSimTLV->TimeLineExtra(i)->DocX(30);
00571 int oldW = mSimTLV->TimeLineExtra(i)->DocW();
00572 int n = (mNrExtraTimeLines-i);
00573 mSimTLV->TimeLineExtra(i)->DocW((n*n*15)*oldW);
00574 }
00575 if (mNrExtraTimeLines>0)
00576 {
00577 int oldW = mSimTLV->TimeLine()->DocW();
00578 mSimTLV->TimeLine()->DocX(30);
00579 int n = (mNrExtraTimeLines+2);
00580 mSimTLV->TimeLine()->DocW(n*n*15*oldW);
00581 }
00582 }
00583
00584 void HandleOptions()
00585 {
00586 CmdOptions& options = CmdOptions::GetInstance();
00587
00588 mFrameError = options.GetInt("timeLineVideoFrameError");
00589 mTimeLineVideoRaw = options.GetBool("timeLineVideoRaw");
00590 mViewStripVideoRaw = options.GetBool("viewStripVideoRaw");
00591
00592
00593
00594 mConceptSet = options.GetString("conceptSet");
00595 mConceptModel = options.GetString("conceptModel");
00596 mConceptFeature = options.GetString("conceptFeature");
00597 mConceptAnnotations = options.GetString("conceptAnnotations");
00598 mTimeLineVideo3D = options.GetBool("timeLineVideo3D");
00599 mTLVAxisY = options.GetInt("timeLineVideoAxisY");
00600
00601
00602 mShowViewStrip = options.GetBool("viewStrip");
00603 mViewStripUseMem = options.GetBool("viewStripUseMemory");
00604 mViewStripY = options.GetInt("viewStripY");
00605 mViewStripStep = options.GetInt("viewStripStep");
00606 mViewStripMinW = options.GetInt("viewStripMinWidth");
00607
00608 std::string needleColS = options.GetString("timeLineNeedleColor");
00609 mNrExtraTimeLines = options.GetInt("timeLineExtra");
00610
00611 if (mFrameError == -1)
00612 mFrameError = 0;
00613
00614
00615
00616
00617 if (mConceptFeature.empty())
00618 mConceptFeature = "combined";
00619 if (mTLVAxisY == -1)
00620 mTLVAxisY = 20;
00621 if (mViewStripY == -1)
00622 mViewStripY = 24;
00623 if (mViewStripStep == -1)
00624 mViewStripStep = 1;
00625 if (mViewStripMinW < 4)
00626 mViewStripMinW = 4;
00627 if (!needleColS.empty())
00628 mNeedleColor = OglColorStr(needleColS.c_str());
00629 }
00630
00631 CheckBox*
00632 ScaledCheckBox(Window* parent, int x, int y, int w, int h,
00633 strconst str, bool checked, int userData)
00634 {
00635 CheckBox* cb =
00636 new CheckBox(parent,x,y,w,h,str,checked,BEV_ETCHED);
00637
00638 cb->ScaleTo(parent);
00639 cb->SetCheckBoxListener(this,(void*)userData);
00640 cb->SetBorderFillShaded(0);
00641 cb->SetAllowScaling(false);
00642 return cb;
00643 }
00644
00645 UpDownButton*
00646 RightUpDownButton(Window* parent, int w, int h, int userData)
00647 {
00648 int y = (parent->H()-h)/2;
00649 int x = parent->W()-w-2;
00650 UpDownButton* upDownBtn = new UpDownButton(parent,x,y,w,h,true);
00651
00652 upDownBtn->ScaleTo(parent);
00653 upDownBtn->SetUpDownButtonListener(this,(void*)userData);
00654 upDownBtn->SetRepeatMode(true);
00655 upDownBtn->SetAllowScaling(false);
00656 return upDownBtn;
00657 }
00658
00659 Button*
00660 ViewStripButton(Window* parent, int x, int w, strconst str, int lData)
00661 {
00662 Button *btn = new Button(parent,x,2,w,parent->H()-4,str,BEV_ETCHED,true);
00663
00664 btn->ScaleTo(parent);
00665 btn->SetButtonListener(this, (void*)lData);
00666 btn->SetAllowScaling(false);
00667 return btn;
00668 }
00669
00670 void Init(int w, int h, SegmentationDocument* segDoc)
00671 {
00672 mSegDoc = segDoc;
00673 mCurFile = 0;
00674 mSimTLV = 0;
00675 mSimSet = 0;
00676 mNeedleColor = 0xffC0C0C0;
00677 mShowBoundaries = false;
00678 mShowPositives = true;
00679 AddDocListener(this);
00680
00681 HandleOptions();
00682 ReadAnnotations();
00683 SetBorderType(-1);
00684 SetBorderBackground(0x80808080);
00685
00686
00687 new OglGui::FramesPerSecond(this,W()-76,4,70,28);
00688
00689 CheckBox* cb = ScaledCheckBox(this,4,4,130,24,"Boundaries",false,
00690 SHOW_SHOT_BOUNDARIES);
00691 UpDownButton* upDownBtn = RightUpDownButton(cb,30,20,NEXT_PREV_SHOT);
00692
00693 StaticText* txt = new StaticText(this,140,4,96,24,"keyframe");
00694 txt->SetAlign(oglLeftAlign,oglCenterAlign);
00695 txt->SetBorderType(BEV_ETCHED);
00696 upDownBtn = RightUpDownButton(txt,30,20,NEXT_PREV_KEYFRAME);
00697
00698 if (!mShowViewStrip)
00699 return;
00700 cb = ScaledCheckBox(this,250,4,184,24,"ViewStrip",true,SHOW_VIEWSTRIP);
00701
00702 Button* btn;
00703 btn = ViewStripButton(cb, 84,32,"Pre",VIEWSTRIP_PRE);
00704 btn = ViewStripButton(cb,116,32,"Min",VIEWSTRIP_MIN);
00705 btn = ViewStripButton(cb,148,32,"Max",VIEWSTRIP_MAX);
00706
00707 cb = ScaledCheckBox(this,438,4,200,24,"Center Needle",true,
00708 CENTER_NEEDLE);
00709
00710 ScaledCheckBox(cb,116,0,84,24,"On Play",
00711 true, CENTER_NEEDLE_ONPLAY);
00712
00713 btn = new Button(this,cb->X()+cb->W()+4,4,140,24,"Extra TimeLine",
00714 BEV_ETCHED,true);
00715 btn->SetButtonListener(this, EXTRA_TIMELINE);
00716
00717 btn = new Button(this,btn->X()+btn->W()+6,4,80,24,"Validate",
00718 BEV_ETCHED,true);
00719 btn->SetButtonListener(this, VALIDATE);
00720 mChBoxValueBars = 0;
00721 }
00722
00723 SegmentationDocument* mSegDoc;
00724 SimilarityTableSet* mSimSet;
00725 SimilarityTimeLineVideo* mSimTLV;
00726
00727 std::vector<AnnotationTable*> mAnnoTables;
00728 AnnoPositives mAnnoPositives;
00729 OglGui::CheckBoxValueBars* mChBoxValueBars;
00730
00731 RgbDataSrcRaw* mRgbDataSrcRaw;
00732
00733
00734
00735
00736
00737 std::string mConceptSet;
00738 std::string mConceptModel;
00739 std::string mConceptFeature;
00740 std::string mConceptAnnotations;
00741 bool mTimeLineVideo3D;
00742 bool mViewStripUseMem;
00743
00744 bool mViewStripVideoRaw;
00745 bool mTimeLineVideoRaw;
00746
00747 bool mShowBoundaries;
00748 bool mShowPositives;
00749
00750
00751 bool mShowViewStrip;
00752 int mViewStripY;
00753 int mViewStripStep;
00754 int mViewStripMinW;
00755 int mTLVAxisY;
00756 ULONG mNeedleColor;
00757 int mCurFile;
00758 int mFrameError;
00759 int mNrExtraTimeLines;
00760
00761 bool mOldNoKeyListening;
00762
00763 ILOG_VAR_DEC;
00764 };
00765
00766 ILOG_VAR_INIT(AllFramesTLineVideo, Visualization);
00767
00768 }
00769 }
00770
00771 #endif