void CMnemosynthDb::GenerateDelta (TArray<SMnemosynthUpdate> *retUpdates, CDatum *retdLocalUpdates) // GenerateDelta // // Generates a list of changes since the last time we called this { CSmartLock Lock(m_cs); int i, j; // Edge conditions if (m_Endpoints.GetCount() == 0) { *retdLocalUpdates = CDatum(); return; } // If we are not the central module, then we only need to // generate a list of updates made by our own endpoint // (and send it to our central module). if (!m_pProcess->IsCentralModule()) { if (GetLocalEndpoint().dwSeqRecv > GetLocalEndpoint().dwSeqSent) { SMnemosynthUpdate *pUpdate = retUpdates->Insert(); pUpdate->sDestEndpoint = strPattern("%s/CentralModule", m_pProcess->GetMachineName()); // Generate a payload for our updates CComplexArray *pEntries = new CComplexArray; for (i = 0; i < m_Collections.GetCount(); i++) { const CString &sCollection = m_Collections.GetKey(i); SCollection *pCollection = &m_Collections[i]; for (j = 0; j < pCollection->Entries.GetCount(); j++) { SEntry *pEntry = &pCollection->Entries[j]; if (pEntry->dwOwnerID == 0 && pEntry->dwSequence > GetLocalEndpoint().dwSeqSent) { CDatum dEntry = GenerateEntry(i, pCollection->Entries.GetKey(j), pEntry); pEntries->Insert(dEntry); // If this entry is Nil then we can deleted. (We don't // need it as a deletion stub since we just composed // the update. If this message gets lost we need to // resend everything). if (pCollection->Entries.GetValue(j).dValue.IsNil()) { pCollection->Entries.Delete(j); j--; } } } } // Create the payload CComplexStruct *pPayload = new CComplexStruct; pPayload->SetElement(STR_COLLECTIONS, GenerateCollectionsArray()); pPayload->SetElement(STR_ENDPOINT, GetLocalEndpoint().sName); pPayload->SetElement(STR_ENTRIES, CDatum(pEntries)); pPayload->SetElement(FIELD_PROCESS_ID, CDatum(GetLocalEndpoint().dwProcessID)); // Add it CDatum dLocalUpdates = CDatum(pPayload); pUpdate->Payloads.Insert(dLocalUpdates); // Return it *retdLocalUpdates = dLocalUpdates; } else *retdLocalUpdates = CDatum(); } // Otherwise, loop over all endpoints and generate a different // update entry for each one that we need to handle else { bool bFullUpdateNeeded = false; for (i = 1; i < m_Endpoints.GetCount(); i++) if (m_Endpoints[i].bFullUpdate) { bFullUpdateNeeded = true; break; } // Collections CDatum dCollections = GenerateCollectionsArray(); // We end up creating one or two arrays of deltas. The first // array has all the changes since we last generated a delta // (this is used for endpoints that we updated last time). // // The second array has a full set of data (this is for new // endpoints). TArray<CComplexArray *> UpdateEntries; TArray<CComplexArray *> FullEntries; TArray<CDatum> UpdatePayloads; TArray<CDatum> FullPayloads; UpdateEntries.InsertEmpty(m_Endpoints.GetCount()); UpdatePayloads.InsertEmpty(m_Endpoints.GetCount()); if (bFullUpdateNeeded) { FullEntries.InsertEmpty(m_Endpoints.GetCount()); FullPayloads.InsertEmpty(m_Endpoints.GetCount()); } for (i = 0; i < m_Endpoints.GetCount(); i++) { UpdateEntries[i] = new CComplexArray; CComplexStruct *pStruct = new CComplexStruct; pStruct->SetElement(STR_COLLECTIONS, dCollections); pStruct->SetElement(STR_ENDPOINT, m_Endpoints[i].sName); pStruct->SetElement(STR_ENTRIES, CDatum(UpdateEntries[i])); pStruct->SetElement(FIELD_PROCESS_ID, CDatum(m_Endpoints[i].dwProcessID)); UpdatePayloads[i] = CDatum(pStruct); if (bFullUpdateNeeded) { FullEntries[i] = new CComplexArray; pStruct = new CComplexStruct; pStruct->SetElement(STR_COLLECTIONS, dCollections); pStruct->SetElement(STR_ENDPOINT, m_Endpoints[i].sName); pStruct->SetElement(STR_ENTRIES, CDatum(FullEntries[i])); pStruct->SetElement(FIELD_PROCESS_ID, CDatum(m_Endpoints[i].dwProcessID)); FullPayloads[i] = CDatum(pStruct); } } // Loop over all entries in the database and add them to the // appropriate payload arrays for (i = 0; i < m_Collections.GetCount(); i++) { const CString &sCollection = m_Collections.GetKey(i); SCollection *pCollection = &m_Collections[i]; for (j = 0; j < pCollection->Entries.GetCount(); j++) { SEntry *pEntry = &pCollection->Entries[j]; // Get the endpoint for the owner of this collection int iOwner = FindEndpointIndex(pEntry->dwOwnerID); if (iOwner == -1) continue; // Add to the update array if (pEntry->dwSequence > m_Endpoints[iOwner].dwSeqSent) { CDatum dEntry = GenerateEntry(i, pCollection->Entries.GetKey(j), pEntry); UpdateEntries[iOwner]->Insert(dEntry); #ifdef DEBUG_MNEMOSYNTH printf("[CMnemosynthDb::GenerateDelta]: Endpoint %s %x\n", (LPSTR)m_Endpoints[iOwner].sName, m_Endpoints[iOwner].dwSeqSent); #endif } // Add to full array, if necessary if (bFullUpdateNeeded) { // Don't bother inserting Nil entries (since this is a full // update). if (!pEntry->dValue.IsNil()) { CDatum dEntry = GenerateEntry(i, pCollection->Entries.GetKey(j), pEntry); FullEntries[iOwner]->Insert(dEntry); } } // If this entry is Nil then we can deleted. (We don't // need it as a deletion stub since we just composed // the update. If this message gets lost we need to // resend everything). if (pEntry->dValue.IsNil()) { pCollection->Entries.Delete(j); j--; } } } // Now iterate over all destination endpoints for (i = 1; i < m_Endpoints.GetCount(); i++) { SEndpoint *pDestEndpoint = &m_Endpoints[i]; #ifdef DEBUG_MNEMOSYNTH printf("[CMnemosynthDb::GenerateDelta]: Composing for endpoint %s %s%s.\n", (LPSTR)pDestEndpoint->sName, (pDestEndpoint->bCentralModule ? "CentralModule " : ""), (pDestEndpoint->bLocalMachine ? "local" : "")); #endif // If this is a local module, then send it any updates // for everything except itself if (pDestEndpoint->bLocalMachine && !pDestEndpoint->bCentralModule) { SMnemosynthUpdate *pUpdate = NULL; for (j = 0; j < m_Endpoints.GetCount(); j++) if (i != j) { // If we have no update entries, then skip. if (!pDestEndpoint->bFullUpdate && UpdatePayloads[j].GetElement(STR_ENTRIES).GetCount() == 0) continue; // Add an update entry if (pUpdate == NULL) { pUpdate = retUpdates->Insert(); pUpdate->sDestEndpoint = pDestEndpoint->sName; } if (pDestEndpoint->bFullUpdate) pUpdate->Payloads.Insert(FullPayloads[j]); else pUpdate->Payloads.Insert(UpdatePayloads[j]); } } // Otherwise, if this is a foreign central module, then // send it any updates for all local endpoints else if (pDestEndpoint->bCentralModule && !pDestEndpoint->bLocalMachine) { SMnemosynthUpdate *pUpdate = NULL; #ifdef DEBUG_MNEMOSYNTH if (pDestEndpoint->bFullUpdate) printf("[CMnemosynthDb::GenerateDelta]: Composing FULL update for %s\n", (LPSTR)pDestEndpoint->sName); else printf("[CMnemosynthDb::GenerateDelta]: Composing DIFF update for %s\n", (LPSTR)pDestEndpoint->sName); #endif for (j = 0; j < m_Endpoints.GetCount(); j++) if (m_Endpoints[j].bLocalMachine) { // If we have no update entries, then skip. if (!pDestEndpoint->bFullUpdate && UpdatePayloads[j].GetElement(STR_ENTRIES).GetCount() == 0) continue; #ifdef DEBUG_MNEMOSYNTH printf("[CMnemosynthDb::GenerateDelta]: Updates from %s\n", (LPSTR)m_Endpoints[j].sName); #endif // Add an update entry if (pUpdate == NULL) { pUpdate = retUpdates->Insert(); pUpdate->sDestEndpoint = pDestEndpoint->sName; } if (pDestEndpoint->bFullUpdate) pUpdate->Payloads.Insert(FullPayloads[j]); else pUpdate->Payloads.Insert(UpdatePayloads[j]); } } } // Local updates *retdLocalUpdates = UpdatePayloads[0]; } // Reset for (i = 0; i < m_Endpoints.GetCount(); i++) { m_Endpoints[i].dwSeqSent = m_Endpoints[i].dwSeqRecv; m_Endpoints[i].bFullUpdate = false; } m_ModifiedEvent.Reset(); }
vector<Interaction> GetInteractions (Proposal *proposal1, Proposal *proposal2) // list all possible pixel interations (occluder / occluded) between pixels of proposals 1 and 2 { // allocate AllocBuffer(proposal1); // all occluder/occluded - interaction that can occor for all combinations of proposals 1 and 2 vector<Interaction> interactions; // fill the buffer representing the right view for (int y = 0; y < _imgH; y++) for (int x = 0; x < _imgW; x++) { SurfaceModel *sm1 = proposal1->surfacemodels[y * _imgW + x]; SurfaceModel *sm2 = proposal2->surfacemodels[y * _imgW + x]; Entry entry0 = GenerateEntry (sm1, cvPoint (x,y)); entry0.x_i = 0; AddEntry (entry0); Entry entry1 = GenerateEntry (sm2, cvPoint (x,y)); entry1.x_i = 1; AddEntry (entry1); } // read the interactions // if a cell of the buffer contains more than 1 entry then the one of higher disparity // occludes all others of lower disparities for (int y = 0; y < _imgH; y++) for (int x = 0; x < _imgW; x++) { vector<Entry> *cell = Buffer[y * _imgW + x]; if (cell->size() < 2) continue; for (int i = 0; i < cell->size() - 1; i++) { Entry occluder = cell->at(i); for (int j = i + 1; j < cell->size(); j++) { Entry occlusion = cell->at(j); // no interaction for identical surfaces // see paper (improved asymmetric occlusion model) if (occluder.proposalid == occlusion.proposalid && occluder.segid == occlusion.segid) continue; // build occluder / occlusion pair with corresponding states Interaction interaction; interaction.first.left_p = occluder.left_p; interaction.first.x_i = occluder.x_i; interaction.second.left_p = occlusion.left_p; interaction.second.x_i = occlusion.x_i; interactions.push_back (interaction); } } } return interactions; }
ForceInline void main2(int argc, TCHAR **argv) { if (argc < 2) { _tprintf(_T("%s input_dir\n"), findname(argv[0])); return; } TCHAR szOutFile[MAX_PATH]; HANDLE hOut, hHeap; DWORD dwLength, dwEntryCount; PAZTYPE PazType; TMyPAZEntry *pEntry; hHeap = GetProcessHeap(); ghHeap = hHeap; for (int i = 1; i != argc; ++i) { Char (*pPazHeader)[sizeof(headers[0])]; DWORD dwAttributes; dwAttributes = GetFileAttributes(argv[i]); if (dwAttributes == -1) { _tprintf(_T("\"%s\" doesn't exist.\n"), argv[i]); continue; } else if ((dwAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) { _tprintf(_T("%s isn't a directory.\n"), argv[i]); continue; } LPCSTR lpPath; lstrcpy(szOutFile, argv[i]); dwLength = lstrlen(szOutFile); if (szOutFile[dwLength - 1] == '\\') szOutFile[dwLength - 1] = 0; lstrcat(szOutFile, ".paz"); lpPath = argv[i]; PazType = NONE; if (i + 2 < argc) { int j = i + 1; if (argv[j][0] == '-' && ((argv[j][1] & 0xDF) == 'T')) { ++j; for (int k = 0; k != countof(szType); ++k) { if (!lstrcmpi(szType[k], argv[j])) { i = j; PazType = (PAZTYPE)k; break; } } } } else { PazType = GetPazTypeFromFileName(szOutFile); } if (PazType == NONE) { _tprintf(_T("Please specify one PAZ type by -t type or use a special file name.\n") _T("Following type is valid: \n\t") ); for (int i = 0; i != countof(szType); ++i) { printf("%s ", szType[i]); if (i == countof(szType) / 2) printf("\n\t"); } break; } dwKeyIndex = GetKeyIndex(szType[PazType], &GameInfo[dwInfoIndex]); if (dwKeyIndex == -1) { printf("%s: don't know encryption key.\n", szOutFile); continue; } hOut = CreateFile(szOutFile, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hOut == INVALID_HANDLE_VALUE) { _tprintf(_T("Can't create \"%s\"\n"), szOutFile); continue; } g_bIsMovie = IsMovie(szOutFile); bIsVoice = IsAudio(szOutFile); SetCurrentDirectory(lpPath); dwEntryCount = GenerateEntry(&pEntry); if (dwEntryCount == 0 || pEntry == NULL) { _tprintf(_T("There is no file in \"%s\"\n"), argv[i]); continue; } bNeedXor = strnicmp(szType[PazType], "pm", 2) != 0; _tprintf(_T("Packing %s ...\n"), szOutFile); if (bNeedXor) { pPazHeader = (Char (*)[32])headers[dwInfoIndex]; } else pPazHeader = (Char (*)[32])headers[countof(headers) - 1]; WriteFile(hOut, pPazHeader, sizeof(*pPazHeader), &dwLength, NULL); WriteEntry(hOut, pEntry, dwEntryCount, False); WriteFileToPaz(hOut, pEntry, dwEntryCount, PazType); WriteEntry(hOut, pEntry, dwEntryCount, True); // HeapFree(hHeap, 0, pEntry); FreeFileList(pEntry); CloseHandle(hOut); } }