static int gstreamer_open_file(struct input_handle* ih, const char* filename) {
GTimeVal beg, end;
ih->filename = filename;
ih->quit_pipeline = TRUE;
ih->main_loop_quit = FALSE;
ih->ready = FALSE;
ih->bin = NULL;
ih->message_source = NULL;
ih->gstreamer_loop = g_thread_create((GThreadFunc) gstreamer_loop, ih, TRUE, NULL);
g_get_current_time(&beg);
while (!ih->ready) {
g_thread_yield();
g_get_current_time(&end);
if (end.tv_usec + end.tv_sec * G_USEC_PER_SEC
- beg.tv_usec - beg.tv_sec * G_USEC_PER_SEC > 1 * G_USEC_PER_SEC) {
break;
}
}
if (!ih->quit_pipeline) {
if (!query_data(ih)) {
ih->quit_pipeline = TRUE;
}
}
if (ih->quit_pipeline) {
if (ih->bin) {
GstBus *bus = gst_element_get_bus(ih->bin);
gst_bus_post(bus, gst_message_new_eos(NULL));
g_object_unref(bus);
}
g_thread_join(ih->gstreamer_loop);
if (ih->message_source) g_source_destroy(ih->message_source);
if (ih->bin) {
/* cleanup */
gst_element_set_state(ih->bin, GST_STATE_NULL);
g_object_unref(ih->bin);
ih->bin = NULL;
g_main_loop_unref(ih->loop);
}
return 1;
} else {
return 0;
}
}
/** Query subset of the elements.
* @param storage should point to opened storage instance
* @param invert should be set to true to query data in backward direction
* @param expect_empty should be set to true if expected empty result
* @param begin beginning of the time-range (smallest timestamp)
* @param end end of the time-range (largest timestamp)
* @param ids should contain list of ids that we interested in
*/
void query_subset(Storage* storage, std::string begin, std::string end, bool invert, bool expect_empty, std::vector<std::string> ids) {
std::cout << "===============" << std::endl;
std::cout << " Query subset" << std::endl;
std::cout << " begin = " << begin << std::endl;
std::cout << " end = " << end << std::endl;
std::cout << " invert = " << invert << std::endl;
std::cout << " expect_empty = " << expect_empty << std::endl;
std::cout << " ids = ";
auto begin_ts = to_timestamp(begin);
auto end_ts = to_timestamp(end);
bool firstid = true;
for(auto x: ids) {
if (!firstid) {
std::cout << ", ";
}
firstid = false;
std::cout << x;
}
std::cout << std::endl;
std::cout << "===============" << std::endl;
assert(to_timestamp(begin) < to_timestamp(end));
std::set<std::string> idsmap(ids.begin(), ids.end());
std::vector<DataPoint> expected;
for (int i = 0; i < (int)TEST_DATA.size(); i++) {
auto point = TEST_DATA[i];
auto id_match = idsmap.count(point.id);
auto point_ts = to_timestamp(point.timestamp);
if (id_match &&
point_ts >= begin_ts &&
point_ts <= end_ts)
{
expected.push_back(point);
}
}
if (invert) {
auto tmp = begin;
begin = end; end = tmp;
std::reverse(expected.begin(), expected.end());
}
if (expect_empty) {
expected.clear();
}
Query query = { begin, end, ids };
query_data(storage, query, expected);
}
/// Constructor
CQueryFactoryInfo::CQueryFactoryInfo(CRef<IQueryFactory> query_factory,
EBlastProgramType program)
: m_IsProt(Blast_SubjectIsProtein(program) ? true : false), m_MaxLength(0),
m_MinLength(1), m_AvgLength(0), m_QuerySource(0), m_NumSeqs(0)
{
CRef<IRemoteQueryData> query_data(query_factory->MakeRemoteQueryData());
CRef<CBioseq_set> bss(query_data->GetBioseqSet());
_ASSERT(bss.NotEmpty());
m_QuerySource.Reset(new CBlastQuerySourceBioseqSet(*bss, m_IsProt));
if ( !m_QuerySource ) {
NCBI_THROW(CBlastException, eSeqSrcInit,
"Failed to initialize sequences for IQueryFactory");
}
// TODO support for m_MinLength
SetupSubjects_OMF(*m_QuerySource, program, &m_SeqBlkVector, &m_MaxLength);
m_NumSeqs = static_cast<Uint4>(m_QuerySource->Size());
_ASSERT(!m_SeqBlkVector.empty());
}
void
CBlastPrelimSearch::SetNumberOfThreads(size_t nthreads)
{
const bool was_multithreaded = IsMultiThreaded();
CThreadable::SetNumberOfThreads(nthreads);
if (was_multithreaded != IsMultiThreaded()) {
BlastDiagnostics* diags = IsMultiThreaded()
? CSetupFactory::CreateDiagnosticsStructureMT()
: CSetupFactory::CreateDiagnosticsStructure();
m_InternalData->m_Diagnostics.Reset
(new TBlastDiagnostics(diags, Blast_DiagnosticsFree));
CRef<ILocalQueryData> query_data
(m_QueryFactory->MakeLocalQueryData(&*m_Options));
auto_ptr<const CBlastOptionsMemento> opts_memento
(m_Options->CreateSnapshot());
if (IsMultiThreaded())
BlastHSPStreamRegisterMTLock(m_InternalData->m_HspStream->GetPointer(),
Blast_CMT_LOCKInit());
}
}
void mexFunction(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[]){
// check number of arguments
if( nrhs!=2 )
mexErrMsgTxt("This function requires 2 arguments\n");
if( !mxIsNumeric(prhs[0]) )
mexErrMsgTxt("varargin{0} must be a valid kdtree pointer\n");
if( !mxIsNumeric(prhs[1]) )
mexErrMsgTxt("varargin{1} must be a query set of points\n");
// retrieve the tree pointer
KDTree* tree;
retrieve_tree( prhs[0], tree );
// retrieve the query data
vector<double> query_data(tree->ndims(), 0);
retrieve_point( prhs[1], query_data );
// printf("query size: %dx%d\n", npoints, ndims);
// npoints x 1 indexes in output
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
double* kk = mxGetPr(plhs[0]);
// Compute kernel density estimate:
kk[0] = tree->kde(query_data);
}