//-----------------------------------------------------------------------------
void CIwBeMotionCamFree::Init()
{
IW_CALLSTACK("CIwBeMotionCamFree::Init")
IwAssert(ENGINE, GetEnt());
CIwCamera* pCam = (CIwCamera*)GetEnt();
pCam->ExposeMatLocal();
}
int TSkyGridBs::AddDoc(
const TStr& SwIdStr, const uint64& Tm,
const TStr& TitleStr, const TStr& HeadlineStr,
const TIntStrPrV FqEntNmPrV){
// create entity-id vector
TIntPrV EntIdFqPrV(FqEntNmPrV.Len(), 0);
for (int EntN=0; EntN<FqEntNmPrV.Len(); EntN++){
TStr EntNm=FqEntNmPrV[EntN].Val2;
int EntFq=FqEntNmPrV[EntN].Val1;
if (EntFq>=GetMnEntFqPerDoc()){
int EntId=AddEntNm(EntNm);
EntIdFqPrV.Add(TIntPr(EntId, EntFq));
}
}
// check entity-id vector lenght
if (EntIdFqPrV.Len()<GetMnEntsPerDoc()){
return -1;}
// create document
PSkyGridDoc Doc=
TSkyGridDoc::New(SwIdStr, Tm, TitleStr, HeadlineStr, EntIdFqPrV);
// add document to base
int DocId=GetNewDocId();
IdToDocH.AddDat(DocId, Doc);
// get entity
for (int EntN=0; EntN<EntIdFqPrV.Len(); EntN++){
int EntId=EntIdFqPrV[EntN].Val1;
TSkyGridEnt& Ent=GetEnt(EntId);
Ent.PushDocId(DocId);
}
// create link
int EntLinkWgtSum=0;
for (int EntN1=0; EntN1<EntIdFqPrV.Len(); EntN1++){
int EntId1=EntIdFqPrV[EntN1].Val1;
TSkyGridEnt& Ent1=GetEnt(EntId1);
int EntWgt1=EntIdFqPrV[EntN1].Val2;
for (int EntN2=0; EntN2<EntIdFqPrV.Len(); EntN2++){
if (EntN1==EntN2){continue;}
int EntId2=EntIdFqPrV[EntN2].Val1;
int EntWgt2=EntIdFqPrV[EntN2].Val2;
// entity-link-weight
int EntLinkWgt=EntWgt1*EntWgt2;
EntLinkWgtSum+=EntLinkWgt;
// create entity-link-context
TSkyGridEntLinkCtx LinkCtx(EntLinkWgt, DocId, Tm);
Ent1.AddLink(EntId2, LinkCtx);
}
}
// return doc-id
return DocId;
}
/////////////////////////////////////////////////
// SkyGrid-Base
void TSkyGridBs::GetSorted_DocsEntIdPrV(TIntPrV& DocsEntIdPrV){
TIntIntH EntIdToDocsH;
for (int EntId=0; EntId<GetEnts(); EntId++){
int Docs=GetEnt(EntId).GetDocIds();
EntIdToDocsH.AddDat(EntId, Docs);
}
DocsEntIdPrV.Clr(); EntIdToDocsH.GetDatKeyPrV(DocsEntIdPrV);
DocsEntIdPrV.Sort(false);
}
void TSkyGridBs::SaveTxt(const TStr& FNm, const uint64& CurTm){
// time-limit
TStr CurTmStr=TTm::GetTmFromMSecs(CurTm).GetWebLogDateTimeStr();
uint64 CurDateTm=TTm::GetMSecsFromTm(TTm::GetTmFromWebLogDateTimeStr(TTm::GetTmFromMSecs(CurTm).GetWebLogDateStr()));
TStr CurDateTmStr=TTm::GetTmFromMSecs(CurDateTm).GetWebLogDateTimeStr();
TUInt64V MnTmV;
MnTmV.Add(CurDateTm-0*TTmInfo::GetDayMSecs());
MnTmV.Add(CurDateTm-1*TTmInfo::GetDayMSecs());
MnTmV.Add(CurDateTm-2*TTmInfo::GetDayMSecs());
MnTmV.Add(CurDateTm-4*TTmInfo::GetDayMSecs());
MnTmV.Add(CurDateTm-8*TTmInfo::GetDayMSecs());
MnTmV.Add(CurDateTm-16*TTmInfo::GetDayMSecs());
MnTmV.Add(CurDateTm-32*TTmInfo::GetDayMSecs());
// get bow
//PBowDocBs BowDocBs=GetBowDocBs(3, 5);
PBowDocBs BowDocBs=GetBowDocBs();
PBowDocWgtBs BowDocWgtBs=GetBowDocWgtBs(BowDocBs);
// open file
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
// get docs-entities sorted vector
TIntPrV DocsEntIdPrV; GetSorted_DocsEntIdPrV(DocsEntIdPrV);
// traverse entities
for (int EntN=0; EntN<DocsEntIdPrV.Len(); EntN++){
int EntId=DocsEntIdPrV[EntN].Val2;
TStr EntNm=GetEntNm(EntId);
int EntDocs=DocsEntIdPrV[EntN].Val1;
TSkyGridEnt& Ent=GetEnt(EntId);
int LinkEnts=Ent.GetLinkEnts();
fprintf(fOut, "'%s' [%d docs] [%d ents]\n", EntNm.CStr(), EntDocs, LinkEnts);
// output docs over dates
{TStrIntPrV DateStrDocsPrV; int _EntDocs;
Ent.GetDocsPerDateV(this, DateStrDocsPrV, _EntDocs);
fprintf(fOut, " Docs per Date (%d docs):", _EntDocs);
for (int DateN=0; DateN<DateStrDocsPrV.Len(); DateN++){
TStr DateStr=DateStrDocsPrV[DateN].Val1;
int Docs=DateStrDocsPrV[DateN].Val2;
fprintf(fOut, " [%s:%d]", DateStr.CStr(), Docs);
}
fprintf(fOut, "\n");}
fprintf(fOut, " [Now: %s]\n", CurTmStr.CStr());
TIntPrV PrevLinkWgtDstEntIdPrV;
TStrFltPrV PrevWordStrWgtPrV;
for (int MnTmN=0; MnTmN<MnTmV.Len(); MnTmN++){
uint64 MnTm=MnTmV[MnTmN];
double PastDays=(CurDateTm-MnTm)/double(TTmInfo::GetDayMSecs());
TStr MnTmStr=TTm::GetTmFromMSecs(MnTm).GetWebLogDateTimeStr();
// get linked entities
TIntPrV LinkWgtDstEntIdPrV;
Ent.GetSorted_LinkWgtDstEntIdPrV(MnTm, 0.9, LinkWgtDstEntIdPrV);
// output difference between previous and current centroid
if (MnTmN>0){
TIntPrV NegDiffLinkWgtDstEntIdPrV; TIntPrV PosDiffLinkWgtDstEntIdPrV;
GetLinkWgtDstEntIdPrVDiff(LinkWgtDstEntIdPrV, PrevLinkWgtDstEntIdPrV,
NegDiffLinkWgtDstEntIdPrV, PosDiffLinkWgtDstEntIdPrV);
// output positive change
TChA PosDiffLinkWgtDstEntIdPrVChA;
GetLinkWgtDstEntIdPrVChA(PosDiffLinkWgtDstEntIdPrV, PosDiffLinkWgtDstEntIdPrVChA);
fprintf(fOut, " Pos-Diff: %s\n", PosDiffLinkWgtDstEntIdPrVChA.CStr());
// output negative change
TChA NegDiffLinkWgtDstEntIdPrVChA;
GetLinkWgtDstEntIdPrVChA(NegDiffLinkWgtDstEntIdPrV, NegDiffLinkWgtDstEntIdPrVChA);
fprintf(fOut, " Neg-Diff: %s\n", NegDiffLinkWgtDstEntIdPrVChA.CStr());
}
PrevLinkWgtDstEntIdPrV=LinkWgtDstEntIdPrV;
// output linked entities
int TopLinkEnts=LinkWgtDstEntIdPrV.Len();
TChA LinkWgtDstEntIdPrVChA;
GetLinkWgtDstEntIdPrVChA(LinkWgtDstEntIdPrV, LinkWgtDstEntIdPrVChA);
fprintf(fOut, " Entities (%d ents): %s\n",
TopLinkEnts, LinkWgtDstEntIdPrVChA.CStr());
// get text centroid
int CtrDocs; TStrFltPrV WordStrWgtPrV;
Ent.GetDocCentroid(this, BowDocBs, BowDocWgtBs, MnTm, 150, 0.9, CtrDocs, WordStrWgtPrV);
// output difference between previous and current centroid
if (MnTmN>0){
TStrFltPrV NegDiffWordStrWgtPrV; TStrFltPrV PosDiffWordStrWgtPrV;
GetWordStrWgtPrVDiff(WordStrWgtPrV, PrevWordStrWgtPrV,
NegDiffWordStrWgtPrV, PosDiffWordStrWgtPrV);
// output positive change
TChA PosDiffWordStrWgtPrVChA; GetWordStrWgtPrVChA(PosDiffWordStrWgtPrV, PosDiffWordStrWgtPrVChA);
fprintf(fOut, " Pos-Diff: %s\n", PosDiffWordStrWgtPrVChA.CStr());
// output negative change
TChA NegDiffWordStrWgtPrVChA; GetWordStrWgtPrVChA(NegDiffWordStrWgtPrV, NegDiffWordStrWgtPrVChA);
fprintf(fOut, " Neg-Diff: %s\n", NegDiffWordStrWgtPrVChA.CStr());
}
PrevWordStrWgtPrV=WordStrWgtPrV;
// output centroid
TChA WordStrWgtPrVChA; GetWordStrWgtPrVChA(WordStrWgtPrV, WordStrWgtPrVChA);
fprintf(fOut, " Centroid (%d docs, %d words): %s\n",
CtrDocs, WordStrWgtPrV.Len(), WordStrWgtPrVChA.CStr());
// output time
fprintf(fOut, " [-%.1f days: %s]\n", PastDays, MnTmStr.CStr());
}
// entity clustering
/*TVec<TStrFltPrV> EntNmWgtPrVV;
Ent.GetEntClustV(this, MnTmV.Last(), 100, 1000, 10, EntNmWgtPrVV);
for (int ClustN=0; ClustN<EntNmWgtPrVV.Len(); ClustN++){
TStrFltPrV& EntNmWgtPrV=EntNmWgtPrVV[ClustN];
fprintf(fOut, " Clust-%d:", ClustN);
for (int EntN=0; EntN<EntNmWgtPrV.Len(); EntN++){
TStr EntNm=EntNmWgtPrV[EntN].Val1;
double Wgt=EntNmWgtPrV[EntN].Val2;
fprintf(fOut, " ['%s':%.3f]", EntNm.CStr(), Wgt);
}
fprintf(fOut, "\n");
}*/
fprintf(fOut, "\n");
}
}
//-----------------------------------------------------------------------------
void CIwBeMotionCamFree::Update()
{
IW_CALLSTACK("CIwBeMotionCamFree::Update")
CIwCamera* pCam = (CIwCamera*)GetEnt();
CIwMat* pMat = pCam->ExposeMatLocal();
#if defined I3D_OS_WINDOWS || defined I3D_OS_S3E
const s3eKey kLeft = s3eKeyLeft;
const s3eKey kRight = s3eKeyRight;
const s3eKey kUp = s3eKeyUp;
const s3eKey kDown = s3eKeyDown;
const s3eKey kZRotUp = s3eKeyNumPadPlus;
const s3eKey kZRotDown = s3eKeyNumPadMinus;
const s3eKey kFore = s3eKeyNumPad4;
const s3eKey kBack = s3eKeyNumPad1;
const s3eKey kRise = s3eKeyNumPad2;
const s3eKey kFall = s3eKeyNumPad5;
const s3eKey kStrafeLeft = s3eKeyNumPad7;
const s3eKey kStrafeRight = s3eKeyNumPad8;
const s3eKey kFast = s3eKeyShift;
#else
const s3eKey kLeft = s3eKey4;
const s3eKey kRight = s3eKey6;
const s3eKey kUp = s3eKey2;
const s3eKey kDown = s3eKey8;
const s3eKey kZRotUp = s3eKeyLSK;
const s3eKey kZRotDown = s3eKeyRSK;
const s3eKey kFore = s3eKey1;
const s3eKey kBack = s3eKey7;
const s3eKey kRise = s3eKey3;
const s3eKey kFall = s3eKey9;
const s3eKey kStrafeLeft = s3eKey0;
const s3eKey kStrafeRight = s3eKeyHash;
const s3eKey kFast = s3eKeyStar;
#endif
bool shift = (s3eKeyboardGetState(kFast) & S3E_KEY_STATE_DOWN) != 0;
int32 maxAngVel = shift ? m_MaxAngVel : m_MaxAngVel/2;
int32 maxSpeed = shift ? m_MaxSpeed : m_MaxSpeed/4;
int32 angAcc = maxAngVel >> 3;
int32 acc = maxSpeed >> 1;
#ifdef HALF_SPEED
maxAngVel >>= 1;
maxSpeed >>= 1;
#endif
// Rotate Y
if (s3eKeyboardGetState(kLeft) & S3E_KEY_STATE_DOWN)
m_AngVel.y = MAX(-maxAngVel, m_AngVel.y + angAcc);
else
if (s3eKeyboardGetState(kRight) & S3E_KEY_STATE_DOWN)
m_AngVel.y = MIN(maxAngVel, m_AngVel.y - angAcc);
else
m_AngVel.y = 0;
// Rotate X
if (s3eKeyboardGetState(kUp) & S3E_KEY_STATE_DOWN)
m_AngVel.x = MAX(-maxAngVel, m_AngVel.x - angAcc);
else
if (s3eKeyboardGetState(kDown) & S3E_KEY_STATE_DOWN)
m_AngVel.x = MIN(maxAngVel, m_AngVel.x + angAcc);
else
m_AngVel.x = 0;
m_AngVel.z = 0;
if ((s3eKeyboardGetState(s3eKeyV) & S3E_KEY_STATE_DOWN))
{
// Rotate Z
if (s3eKeyboardGetState(kZRotUp) & S3E_KEY_STATE_DOWN)
m_AngVel.z = MAX(-maxAngVel, m_AngVel.z - angAcc);
else
if (s3eKeyboardGetState(kZRotDown) & S3E_KEY_STATE_DOWN)
m_AngVel.z = MIN(maxAngVel, m_AngVel.z + angAcc);
else
m_AngVel.z = 0;
}
if (m_AngVel.x || m_AngVel.y || m_AngVel.z)
{
// Back up translation of matrix, and zero it so that the
// rotations don't change the current position of the camera
const CIwVec3 origTranslation = pMat->t;
pMat->t = CIwVec3::g_Zero;
// Apply required rotation
CIwMat mat;
if (m_AngVel.x)
{
mat.SetAxisAngle(pMat->VecX(), m_AngVel.x);
*pMat *= mat;
}
if (m_AngVel.y)
{
if (m_UseWorldY)
mat.SetRotY(-m_AngVel.y);
else
mat.SetAxisAngle(pMat->VecY(), m_AngVel.y);
*pMat *= mat;
}
if (m_AngVel.z)
{
mat.SetAxisAngle(pMat->VecZ(), m_AngVel.z);
*pMat *= mat;
}
// Normalise matrix and copy back the original position
pMat->Normalise();
pMat->t = origTranslation;
}
// Move forward/back
if (s3eKeyboardGetState(kFore) & S3E_KEY_STATE_DOWN)
m_Vel.z = MIN(maxSpeed, m_Vel.z + acc);
else
if (s3eKeyboardGetState(kBack) & S3E_KEY_STATE_DOWN)
m_Vel.z = MAX(-maxSpeed, m_Vel.z - acc);
else
m_Vel.z = 0;
pMat->t += pMat->VecZ() * m_Vel.z;
// Move up/down
if (s3eKeyboardGetState(kRise) & S3E_KEY_STATE_DOWN)
m_Vel.y = MIN(maxSpeed, m_Vel.y + acc);
else
if (s3eKeyboardGetState(kFall) & S3E_KEY_STATE_DOWN)
m_Vel.y = MAX(-maxSpeed, m_Vel.y - acc);
else
m_Vel.y = 0;
pMat->t += pMat->VecY() * m_Vel.y;
// Strafe left/right
if (s3eKeyboardGetState(kStrafeRight) & S3E_KEY_STATE_DOWN)
m_Vel.x = MIN(maxSpeed, m_Vel.x + acc);
else
if (s3eKeyboardGetState(kStrafeLeft) & S3E_KEY_STATE_DOWN)
m_Vel.x = MAX(-maxSpeed, m_Vel.x - acc);
else
m_Vel.x = 0;
pMat->t += pMat->VecX() * m_Vel.x;
// Change perspmul
if (s3eKeyboardGetState(s3eKeyV) & S3E_KEY_STATE_DOWN)
{
if (s3eKeyboardGetState(s3eKeyNumPadPlus) & S3E_KEY_STATE_DOWN) pCam->m_PerspMul += 0x8;
if (s3eKeyboardGetState(s3eKeyNumPadMinus) & S3E_KEY_STATE_DOWN) pCam->m_PerspMul = MAX(0x8, pCam->m_PerspMul - 0x8);
}
}
