int main() { QString path = getenv("HOME"); path += "/maskingdata"; QFile datafile(path); datafile.open(IO_ReadOnly); QDataStream datastream(&datafile); //currently the QStrings at the beginning of the file //are just being read, not written to stdout QString str; for(int i = 0; i < 3; i++) datastream >> str; float val; int counter = 0; while( ! datastream.atEnd() ) { counter++; datastream >> val; printf("%d: %f \n", counter, val); } return 0; }
void ParticleGenerator::getFileInput(char* fileName, ParticleContainer* pc, Simulation *sim) { double m = 1; int num_cuboids = 0; std::ifstream input_file(fileName); string tmp_string; if (input_file.is_open()) { getline(input_file, tmp_string); LOG4CXX_DEBUG(iolog, "Read line: " << tmp_string); while (tmp_string.size() == 0 || tmp_string[0] == '#') { getline(input_file, tmp_string); LOG4CXX_DEBUG(iolog, "Read line: " << tmp_string); } istringstream numstream(tmp_string); numstream >> num_cuboids; LOG4CXX_DEBUG(iolog, "Reading " << num_cuboids << "."); getline(input_file, tmp_string); LOG4CXX_DEBUG(iolog, "Read line: " << tmp_string); for (int i = 0; i < num_cuboids; i++) { istringstream datastream(tmp_string); for (int j = 0; j < 3; j++) { datastream >> X[j]; } for (int j = 0; j < 3; j++) { datastream >> V[j]; } for (int j = 0; j < 3; j++) { datastream >> num[j]; } if (datastream.eof()) { LOG4CXX_ERROR(iolog, "Error reading file: eof reached unexpectedly reading from line " << i); exit(-1); } datastream >> meanV; datastream >> M; datastream >> H; // create particles from cuboid data LOG4CXX_ERROR(particlelog, "Generating Cuboid..."); createParticles(pc); getline(input_file, tmp_string); } } else {
void CommentLoader::loadFile(const QString filename, const int pagecount) { this->pagecount = pagecount; notes = new QStringList[pagecount]; datafile.setFileName(filename); if (datafile.exists()) { datafile.open(QIODevice::ReadOnly | QIODevice::Text); if (datafile.isOpen()) { QTextStream datastream(&datafile); int slide = 0; while (!datastream.atEnd()) { QString line = datastream.readLine(); if (line.startsWith("slide ")) { QStringList params=line.split(" "); if (params.count() > 1) { slide = params[1].toInt() - 1; } } if (line.startsWith("comment {")) { line = datastream.readLine(); while (!datastream.atEnd() && !line.startsWith("}")) { if (slide < pagecount) { notes[slide].append(line.trimmed()); } line = datastream.readLine(); } } if (line.startsWith("keys {")) { line = datastream.readLine(); while (!datastream.atEnd() && !line.startsWith("}")) { keys.append(line.trimmed()); line = datastream.readLine(); } } if (line.startsWith("bookmarks {")) { line = datastream.readLine(); while (!datastream.atEnd() && !line.startsWith("}")) { QStringList bmarks=line.split(" "); for (int i=0; i<bmarks.size(); i++) { bookmarks.append(bmarks[i].toInt() - 1); } line = datastream.readLine(); } } } } } }
static BOOL DLL_CALLCONV Validate(FreeImageIO *io, fi_handle handle) { LibRaw RawProcessor; BOOL bSuccess = TRUE; // wrap the input datastream LibRaw_freeimage_datastream datastream(io, handle); // open the datastream if(RawProcessor.open_datastream(&datastream) != LIBRAW_SUCCESS) { bSuccess = FALSE; // LibRaw : failed to open input stream (unknown format) } // clean-up internal memory allocations RawProcessor.recycle(); return bSuccess; }
Value fetch( const Key& key ) { try { FC_ASSERT( is_open(), "Database is not open!" ); ldb::Slice key_slice( (char*)&key, sizeof(key) ); std::string value; auto status = _db->Get( _read_options, key_slice, &value ); if( status.IsNotFound() ) { FC_THROW_EXCEPTION( fc::key_not_found_exception, "unable to find key ${key}", ("key",key) ); } if( !status.ok() ) { FC_THROW_EXCEPTION( level_pod_map_failure, "database error: ${msg}", ("msg", status.ToString() ) ); } fc::datastream<const char*> datastream(value.c_str(), value.size()); Value tmp; fc::raw::unpack(datastream, tmp); return tmp; } FC_RETHROW_EXCEPTIONS( warn, "error fetching key ${key}", ("key",key) ); }
Value fetch( const Key& key ) { try { ldb::Slice key_slice( (char*)&key, sizeof(key) ); std::string value; auto status = _db->Get( ldb::ReadOptions(), key_slice, &value ); if( status.IsNotFound() ) { FC_THROW_EXCEPTION( key_not_found_exception, "unable to find key ${key}", ("key",key) ); } if( !status.ok() ) { FC_THROW_EXCEPTION( exception, "database error: ${msg}", ("msg", status.ToString() ) ); } fc::datastream<const char*> datastream(value.c_str(), value.size()); Value tmp; fc::raw::unpack(datastream, tmp); return tmp; } FC_RETHROW_EXCEPTIONS( warn, "error fetching key ${key}", ("key",key) ); }
void ARControlConnection::onNavdata(const ARControlFrame &frame) { Q_D(ARControlConnection); // TODO: Should we do this, or should we allow application to decide // when/if an acknowledge occurs? // Construct acknowledge frame, if this incoming frame requires it. if(frame.type == ARControlConnection::AcknowledgeData) { QByteArray payload(1, 0x00); QDataStream datastream(&payload, QIODevice::WriteOnly); datastream.setByteOrder(QDataStream::LittleEndian); datastream << (quint8)frame.seq; sendFrame(ARControlConnection::Acknowledge, ARNET_C2D_NAVDATA_ACK_ID, payload.constData(), payload.size()); } // Decode command header. quint8 project = static_cast<quint8>(frame.payload[0]); quint8 klass = static_cast<quint8>(frame.payload[1]); quint16 id = qFromLittleEndian(static_cast<quint16>(frame.payload[2])); const char *data = frame.payload.data() + 4; // Resolve command meta-type information. ARCommandInfo *command = d->commands->find(project, klass, id); if(command == NULL) { WARNING_T(QString("Unrecognised command: %1 %2 %3") .arg(project) .arg(klass) .arg(id)); return; } // Use command codec to decode command parameters. QVariantMap params = d->codec->decode(command, data); DEBUG_T(QString("Decoded Command %1 %2 %3").arg(command->klass->project).arg(command->klass->name).arg(command->name)); d->controller->onCommandReceived(*command, params); }
void SimpleDataSet::read(int type){ openMysqlSession(); this->dataSet.clear(); ResultSet *resSet; PreparedStatement *prep_stmt; /* create a statement object */ prep_stmt = con -> prepareStatement("SELECT * FROM `SimpleDataSet` WHERE `compression_rate`=? AND `num_clusters`=? AND `type`=?"); prep_stmt->setInt(1, compressionRate); prep_stmt->setInt(2, numClusters); prep_stmt->setInt(3, type); resSet = prep_stmt->executeQuery(); while (resSet->next()) { std::stringstream datastream(resSet->getString("sequence")); //for each loop we save one sequence vector<int> sequence; while (!datastream.eof()) { int state; datastream >> state; sequence.push_back(state); } SimpleData newSD; newSD.sequence=sequence; newSD.idAction=resSet->getInt("id_action"); this->dataSet.push_back(newSD); } delete resSet; delete prep_stmt; closeMysqlSession(); cout<<"SimpleData readad: "<<this->dataSet.size()<<" data, each sequence length:"<<this->dataSet[0].sequence.size()<<endl; }
void Mesh_Binary_File_Writer::write_mesh( const Filename & file, Mesh & mesh ) { std::ofstream datastream((char*)file.string().c_str(), std::ios::binary); if (!datastream) { throw_exception( IO_Error("Mesh_Binary_File_Writer: cannot create " "binary file: " + file.string()), WARNING_LEVEL, __FILE__, __LINE__); } // write header infos for the current mesh Vertex_Index vertex_count = mesh.vertex_count(); Triangle_Index triangle_count = mesh.triangle_count(); Triangle_Index triangle_strip_length = mesh.triangle_strip_length(); datastream.write((char*)&vertex_count, sizeof(Vertex_Index)); datastream.write((char*)&triangle_count, sizeof(Triangle_Index)); datastream.write((char*)&triangle_strip_length, sizeof(Triangle_Index)); // write the vertices data datastream.write((char*)mesh.vertices().pointer(), vertex_count * 3 * sizeof(Micron)); datastream.write((char*)mesh.vertex_sections().pointer(), vertex_count * sizeof(Section_ID)); datastream.write((char*)mesh.vertex_relative_distances().pointer(), vertex_count * sizeof(float)); // write the triangles data datastream.write((char*)mesh.triangles().pointer(), triangle_count * 3 * sizeof(Vertex_Index)); datastream.write((char*)mesh.triangle_strip().pointer(), triangle_strip_length * sizeof(Vertex_Index)); }
static FIBITMAP * DLL_CALLCONV Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) { FIBITMAP *dib = NULL; LibRaw RawProcessor; BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS; try { // wrap the input datastream LibRaw_freeimage_datastream datastream(io, handle); // open the datastream if(RawProcessor.open_datastream(&datastream) != LIBRAW_SUCCESS) { throw "LibRaw : failed to open input stream (unknown format)"; } if(header_only) { // header only mode dib = FreeImage_AllocateHeaderT(header_only, FIT_RGB16, RawProcessor.imgdata.sizes.width, RawProcessor.imgdata.sizes.height); // try to get JPEG embedded Exif metadata if(dib) { FIBITMAP *metadata_dib = libraw_LoadEmbeddedPreview(RawProcessor, FIF_LOAD_NOPIXELS); if(metadata_dib) { FreeImage_CloneMetadata(dib, metadata_dib); FreeImage_Unload(metadata_dib); } } } else if((flags & RAW_PREVIEW) == RAW_PREVIEW) { // try to get the embedded JPEG dib = libraw_LoadEmbeddedPreview(RawProcessor, 0); if(!dib) { // no JPEG preview: try to load as 8-bit/sample (i.e. RGB 24-bit) dib = libraw_LoadRawData(RawProcessor, 8); } } else if((flags & RAW_DISPLAY) == RAW_DISPLAY) { // load raw data as 8-bit/sample (i.e. RGB 24-bit) dib = libraw_LoadRawData(RawProcessor, 8); } else { // default: load raw data as linear 16-bit/sample (i.e. RGB 48-bit) dib = libraw_LoadRawData(RawProcessor, 16); } // save ICC profile if present if(NULL != RawProcessor.imgdata.color.profile) { FreeImage_CreateICCProfile(dib, RawProcessor.imgdata.color.profile, RawProcessor.imgdata.color.profile_length); } // try to get JPEG embedded Exif metadata if(dib && !((flags & RAW_PREVIEW) == RAW_PREVIEW) ) { FIBITMAP *metadata_dib = libraw_LoadEmbeddedPreview(RawProcessor, FIF_LOAD_NOPIXELS); if(metadata_dib) { FreeImage_CloneMetadata(dib, metadata_dib); FreeImage_Unload(metadata_dib); } } // clean-up internal memory allocations RawProcessor.recycle(); return dib; } catch(const char *text) { if(dib) { FreeImage_Unload(dib); } RawProcessor.recycle(); FreeImage_OutputMessageProc(s_format_id, text); } return NULL; }
bool FastSearchFormat::ReadChemObject(OBConversion* pConv) { //Searches index file for structural matches //This function is called only once per search std::string auditMsg = "OpenBabel::Read fastsearch index "; std::string description(Description()); auditMsg += description.substr(0,description.find('\n')); obErrorLog.ThrowError(__FUNCTION__, auditMsg, obAuditMsg); //Derive index name string indexname = pConv->GetInFilename(); string::size_type pos=indexname.find_last_of('.'); if(pos!=string::npos) { indexname.erase(pos); indexname += ".fs"; } //Have to open input stream again because needs to be in binary mode ifstream ifs; stringstream errorMsg; if(!indexname.empty()) ifs.open(indexname.c_str(),ios::binary); if(!ifs) { errorMsg << "Couldn't open " << indexname << endl; obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obError); return false; } string datafilename = fs.ReadIndex(&ifs); if(datafilename.empty()) { errorMsg << "Difficulty reading from index " << indexname << endl; obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obError); return false; } vector<OBMol> patternMols; if(!ObtainTarget(pConv, patternMols, indexname)) return false; bool exactmatch = pConv->IsOption("e",OBConversion::INOPTIONS)!=NULL;// -ae option //Open the datafile and put it in pConv //datafile name derived from index file probably won't have a file path //but indexname may. Derive a full datafile name string path; pos = indexname.find_last_of("/\\"); if(pos==string::npos) path = datafilename; else path = indexname.substr(0,pos+1) + datafilename; ifstream datastream(path.c_str()); if(!datastream) { errorMsg << "Difficulty opening " << path << endl; obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obError); return false; } pConv->SetInStream(&datastream); //Input format is currently fs; set it appropriately if(!pConv->SetInAndOutFormats(pConv->FormatFromExt(datafilename.c_str()),pConv->GetOutFormat())) return false; // If target has dative bonds like -[N+](=O)[O-] convert it to the uncharged form // (-N(=O)=O and add uncharged form to vector of mols which are sent to // the -s (SMARTS)filter. // Also check whether the target has dative bonds in the uncharged form and supply // the charged form to the -s filter. // Together with the automatic conversion to the uncharged form when the fs index is made, // this ensures that both forms are found however they occur in the datafile or the taget. vector<OBBase*> extraSMARTSMols; vector<OBMol>extraUnchargedMols; for(unsigned i=0;i<patternMols.size();++i) { if(patternMols[i].ConvertDativeBonds()) extraSMARTSMols.push_back(&patternMols[i]); else { // If target has uncharged dative bonds, still use it for fastsearching, // but add the charged form for -s filter. extraUnchargedMols.push_back(patternMols[i]); if(extraUnchargedMols.back().MakeDativeBonds()) extraSMARTSMols.push_back(&extraUnchargedMols.back()); } } OBOp* sFilter = OBOp::FindType("s"); if(sFilter) sFilter->ProcessVec(extraSMARTSMols); //Now do searching const char* p = pConv->IsOption("t",OBConversion::INOPTIONS); if(p) { //Do a similarity search multimap<double, unsigned int> SeekposMap; string txt=p; if(txt.find('.')==string::npos) { //Finds n molecules with largest Tanimoto int n = atoi(p); fs.FindSimilar(&patternMols[0], SeekposMap, n); } else { //Finds molecules with Tanimoto > MinTani double MaxTani = 1.1; size_t pos = txt.find(','); if( pos != string::npos ) { MaxTani = atof( txt.substr( pos + 1 ).c_str() ); } double MinTani = atof( txt.substr( 0, pos ).c_str() ); fs.FindSimilar(&patternMols[0], SeekposMap, MinTani, MaxTani); } //Don't want to filter through SMARTS filter pConv->RemoveOption("s", OBConversion::GENOPTIONS); //also because op names are case independent pConv->RemoveOption("S", OBConversion::GENOPTIONS); multimap<double, unsigned int>::reverse_iterator itr; for(itr=SeekposMap.rbegin();itr!=SeekposMap.rend();++itr) { datastream.seekg(itr->second); if(pConv->IsOption("a", OBConversion::INOPTIONS)) { //Adds Tanimoto coeff to title //First remove any previous value pConv->RemoveOption("addtotitle", OBConversion::GENOPTIONS); stringstream ss; ss << " " << itr->first; pConv->AddOption("addtotitle",OBConversion::GENOPTIONS, ss.str().c_str()); } pConv->SetOneObjectOnly(); if(itr != --SeekposMap.rend()) pConv->SetMoreFilesToCome();//so that not seen as last on output pConv->Convert(NULL,NULL); } } else { //Structure search int MaxCandidates = 4000; p = pConv->IsOption("l",OBConversion::INOPTIONS); if(p && atoi(p)) MaxCandidates = atoi(p); vector<unsigned int> SeekPositions; if(exactmatch) { //Find mols where all fingerprint bits are the same as the target fs.FindMatch(&patternMols[0], SeekPositions, MaxCandidates); // ensure that SMARTS filter in transform.cpp looks only for an exact match // by setting an option with the number of heavy atoms in the pattern mol included. stringstream ss; ss << patternMols[0].NumHvyAtoms(); pConv->AddOption("exactmatch", OBConversion::GENOPTIONS, ss.str().c_str()); } else { //Do a substructure search for each target vector<OBMol>::iterator iter; for(iter=patternMols.begin();iter!=patternMols.end();++iter) fs.Find(&*iter, SeekPositions, MaxCandidates); clog << SeekPositions.size() << " candidates from fingerprint search phase" << endl; } vector<unsigned int>::iterator seekitr, begin = SeekPositions.begin(), end = SeekPositions.end(); if(patternMols.size()>1)//only sort and eliminate duplicates if necessary { sort(begin, end); end = unique(begin, end); //removed duplicates are after new end } //Output the candidate molecules, filtering through s filter, unless it was not requested if(pConv->IsOption("n", OBConversion::INOPTIONS) ) pConv->RemoveOption("s",OBConversion::GENOPTIONS); pConv->SetLast(false); for(seekitr=begin; seekitr!=end; ++seekitr) { datastream.seekg(*seekitr); if(!pConv->GetInFormat()->ReadChemObject(pConv)) return false; pConv->SetFirstInput(false); //needed for OpSort } } return false; //To finish }
void ARControlConnection::onVideoData(const ARControlFrame &frame) { TRACE Q_D(ARControlConnection); quint16 frameNumber = qFromLittleEndian(*((quint16*)(frame.payload.constData()))); quint8 frameFlags = static_cast<quint8>(frame.payload[2]); quint8 fragmentNumber = static_cast<quint8>(frame.payload[3]); quint8 fragsPerFrame = static_cast<quint8>(frame.payload[4]); if(frameNumber != d->frameNumber) { if(frameFlags == 0x01) { DEBUG_T(QString("Video Key Frame Header [%1] (%2 %3 %4)") .arg(QString(QByteArray().append(frame.payload.constData(), 5).toHex())) .arg(frameNumber) .arg(fragmentNumber) .arg(fragsPerFrame)); } else { DEBUG_T(QString("Video Frame Header (%2 %3 %4)") .arg(frameNumber) .arg(fragmentNumber) .arg(fragsPerFrame)); } if(fragsPerFrame < 64) { d->hiAck = 0xffffffffffffffff; d->loAck = 0xffffffffffffffff << fragsPerFrame; } else if(fragsPerFrame < 128) { d->hiAck = 0xffffffffffffffff << (fragsPerFrame - 64); d->loAck = 0ll; } else { d->hiAck = 0ll; d->loAck = 0ll; } d->frameNumber = frameNumber; } if(fragmentNumber < 64) { d->loAck |= (1ll << fragmentNumber); } else if(fragmentNumber < 128) { d->hiAck |= (1ll << (fragmentNumber - 64)); } // Construct reply. QByteArray payload(2 + 8 + 8, 0x00); QDataStream datastream(&payload, QIODevice::WriteOnly); if(!d->sequenceIds.contains(ARNET_C2D_VIDEO_ACK_ID)) d->sequenceIds.insert(ARNET_C2D_VIDEO_ACK_ID, 0x00); datastream.setByteOrder(QDataStream::LittleEndian); datastream << (quint16)frameNumber << (quint64)d->hiAck << (quint64)d->loAck; sendFrame(ARControlConnection::LowLatencyData, ARNET_C2D_VIDEO_ACK_ID, payload.constData(), payload.size()); }
static FIBITMAP * DLL_CALLCONV Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) { FIBITMAP *dib = NULL; LibRaw RawProcessor; BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS; try { // wrap the input datastream LibRaw_freeimage_datastream datastream(io, handle); // set decoding parameters // the following parameters affect data reading // -------------------------------------------- // (-w) Use camera white balance, if possible (otherwise, fallback to auto_wb) RawProcessor.imgdata.params.use_camera_wb = 1; // RAW data filtration mode during data unpacking and postprocessing RawProcessor.imgdata.params.filtering_mode = LIBRAW_FILTERING_AUTOMATIC; // (-h) outputs the image in 50% size RawProcessor.imgdata.params.half_size = ((flags & RAW_HALFSIZE) == RAW_HALFSIZE) ? 1 : 0; // open the datastream if(RawProcessor.open_datastream(&datastream) != LIBRAW_SUCCESS) { throw "LibRaw : failed to open input stream (unknown format)"; } if(header_only) { // header only mode dib = FreeImage_AllocateHeaderT(header_only, FIT_RGB16, RawProcessor.imgdata.sizes.width, RawProcessor.imgdata.sizes.height); // try to get JPEG embedded Exif metadata if(dib) { FIBITMAP *metadata_dib = libraw_LoadEmbeddedPreview(RawProcessor, FIF_LOAD_NOPIXELS); if(metadata_dib) { FreeImage_CloneMetadata(dib, metadata_dib); FreeImage_Unload(metadata_dib); } } } else if((flags & RAW_PREVIEW) == RAW_PREVIEW) { // try to get the embedded JPEG dib = libraw_LoadEmbeddedPreview(RawProcessor, 0); if(!dib) { // no JPEG preview: try to load as 8-bit/sample (i.e. RGB 24-bit) dib = libraw_LoadRawData(RawProcessor, 8); } } else if((flags & RAW_DISPLAY) == RAW_DISPLAY) { // load raw data as 8-bit/sample (i.e. RGB 24-bit) dib = libraw_LoadRawData(RawProcessor, 8); } else { // default: load raw data as linear 16-bit/sample (i.e. RGB 48-bit) dib = libraw_LoadRawData(RawProcessor, 16); } // save ICC profile if present if(NULL != RawProcessor.imgdata.color.profile) { FreeImage_CreateICCProfile(dib, RawProcessor.imgdata.color.profile, RawProcessor.imgdata.color.profile_length); } // try to get JPEG embedded Exif metadata if(dib && !((flags & RAW_PREVIEW) == RAW_PREVIEW) ) { FIBITMAP *metadata_dib = libraw_LoadEmbeddedPreview(RawProcessor, FIF_LOAD_NOPIXELS); if(metadata_dib) { FreeImage_CloneMetadata(dib, metadata_dib); FreeImage_Unload(metadata_dib); } } // clean-up internal memory allocations RawProcessor.recycle(); return dib; } catch(const char *text) { if(dib) { FreeImage_Unload(dib); } RawProcessor.recycle(); FreeImage_OutputMessageProc(s_format_id, text); } return NULL; }
bool FastSearchFormat::ReadChemObject(OBConversion* pConv) { //Searches index file for structural matches //This function is called only once per search std::string auditMsg = "OpenBabel::Read fastsearch index "; std::string description(Description()); auditMsg += description.substr(0,description.find('\n')); obErrorLog.ThrowError(__FUNCTION__, auditMsg, obAuditMsg); //Derive index name string indexname = pConv->GetInFilename(); string::size_type pos=indexname.find_last_of('.'); if(pos!=string::npos) { indexname.erase(pos); indexname += ".fs"; } //Have to open input stream again because needs to be in binary mode ifstream ifs; stringstream errorMsg; if(!indexname.empty()) ifs.open(indexname.c_str(),ios::binary); if(!ifs) { errorMsg << "Couldn't open " << indexname << endl; obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obError); return false; } string datafilename = fs.ReadIndex(&ifs); if(datafilename.empty()) { errorMsg << "Difficulty reading from index " << indexname << endl; obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obError); return false; } OBMol patternMol; bool doSubset = pConv->IsOption("s",OBConversion::INOPTIONS)!=NULL;// -as option bool exactmatch = pConv->IsOption("e",OBConversion::INOPTIONS)!=NULL;// -ae option if(!doSubset) { //Similarity or substructure if(!ObtainTarget(pConv, patternMol, indexname)) return false; } //Open the datafile and put it in pConv //datafile name derived from index file probably won't have a file path //but indexname may. Derive a full datafile name string path; pos = indexname.find_last_of("/\\"); if(pos==string::npos) path = datafilename; else path = indexname.substr(0,pos+1) + datafilename; ifstream datastream(path.c_str()); if(!datastream) { errorMsg << "Difficulty opening " << path << endl; obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obError); return false; } pConv->SetInStream(&datastream); //Input format is currently fs; set it appropriately if(!pConv->SetInAndOutFormats(pConv->FormatFromExt(datafilename.c_str()),pConv->GetOutFormat())) return false; pConv->AddOption("b",OBConversion::GENOPTIONS); //Now do searching const char* p = pConv->IsOption("t",OBConversion::INOPTIONS); if(p) { //Do a similarity search multimap<double, unsigned int> SeekposMap; string txt=p; if(txt.find('.')==string::npos) { //Finds n molecules with largest Tanimoto int n = atoi(p); fs.FindSimilar(&patternMol, SeekposMap, n); } else { //Finds molecules with Tanimoto > MinTani double MinTani = atof(txt.c_str()); // if(doSubset) // fs.FindSubset(SeekposMap, MinTani); // else fs.FindSimilar(&patternMol, SeekposMap, MinTani); } //Don't want to filter through SMARTS filter pConv->RemoveOption("s", OBConversion::GENOPTIONS); multimap<double, unsigned int>::reverse_iterator itr; for(itr=SeekposMap.rbegin(); itr!=SeekposMap.rend(); ++itr) { datastream.seekg(itr->second); if(pConv->IsOption("a", OBConversion::INOPTIONS)) { //Adds Tanimoto coeff to title //First remove any previous value pConv->RemoveOption("addtotitle", OBConversion::GENOPTIONS); stringstream ss; ss << " " << itr->first; pConv->AddOption("addtotitle",OBConversion::GENOPTIONS, ss.str().c_str()); } pConv->SetOneObjectOnly(); if(itr != --SeekposMap.rend()) pConv->SetMoreFilesToCome();//so that not seen as last on output pConv->Convert(NULL,NULL); } } else { //Structure search int MaxCandidates = 4000; p = pConv->IsOption("l",OBConversion::INOPTIONS); if(p && atoi(p)) MaxCandidates = atoi(p); vector<unsigned int> SeekPositions; if(exactmatch) { //Find mols where all fingerprint bits are the same as the target fs.FindMatch(&patternMol, SeekPositions, MaxCandidates); // ensure that SMARTS filter in transform.cpp looks only for an exact match // by setting an option with the number of heavy atoms in the pattern mol included. stringstream ss; ss << patternMol.NumHvyAtoms(); pConv->AddOption("exactmatch", OBConversion::GENOPTIONS, ss.str().c_str()); } else { //Do a substructure search fs.Find(&patternMol, SeekPositions, MaxCandidates); clog << SeekPositions.size() << " candidates from fingerprint search phase" << endl; } //Output the candidate molecules //filtering through s filter, unless the fingerprint type does not require it if(fs.GetFingerprint()->Flags() & OBFingerprint::FPT_UNIQUEBITS) pConv->RemoveOption("s",OBConversion::GENOPTIONS); vector<unsigned int>::iterator itr; for(itr=SeekPositions.begin(); itr!=SeekPositions.end(); itr++) { datastream.seekg(*itr); // datastream.seekg(*itr - datastream.tellg(), ios_base::cur); //Avoid retrieving start //debugging kludge to output all candidates directly if(pConv->IsOption("c",OBConversion::GENOPTIONS)) { string ln; getline(datastream,ln); datastream.seekg(*itr); *pConv->GetOutStream() << "** " << ln << endl; } pConv->SetOneObjectOnly(); pConv->SetLast(itr+1 == SeekPositions.end()); pConv->Convert(NULL,NULL); } } return false; //To finish }