bool QgsSpatiaLiteFeatureIterator::fetchFeature( QgsFeature& feature ) { if ( mClosed ) return false; feature.setValid( false ); if ( sqliteStatement == NULL ) { QgsDebugMsg( "Invalid current SQLite statement" ); close(); return false; } if ( !getFeature( sqliteStatement, feature ) ) { sqlite3_finalize( sqliteStatement ); sqliteStatement = NULL; close(); return false; } feature.setValid( true ); return true; }
void Game::processOpenOutfitWindow(const Outfit& currentOufit, const std::vector<std::tuple<int, std::string, int> >& outfitList, const std::vector<std::tuple<int, std::string> >& mountList) { // create virtual creature outfit CreaturePtr virtualOutfitCreature = CreaturePtr(new Creature); virtualOutfitCreature->setDirection(Otc::South); Outfit outfit = currentOufit; outfit.setMount(0); virtualOutfitCreature->setOutfit(outfit); // creature virtual mount outfit CreaturePtr virtualMountCreature = nullptr; if(getFeature(Otc::GamePlayerMounts)) { virtualMountCreature = CreaturePtr(new Creature); virtualMountCreature->setDirection(Otc::South); if(currentOufit.getMount() > 0) { Outfit mountOutfit; mountOutfit.setId(currentOufit.getMount()); virtualMountCreature->setOutfit(mountOutfit); } } g_lua.callGlobalField("g_game", "onOpenOutfitWindow", virtualOutfitCreature, outfitList, virtualMountCreature, mountList); }
bool QgsPostgresFeatureIterator::fetchFeature( QgsFeature& feature ) { feature.setValid( false ); if ( mClosed ) return false; if ( mFeatureQueue.empty() ) { QString fetch = QString( "FETCH FORWARD %1 FROM %2" ).arg( mFeatureQueueSize ).arg( mCursorName ); QgsDebugMsgLevel( QString( "fetching %1 features." ).arg( mFeatureQueueSize ), 4 ); if ( mConn->PQsendQuery( fetch ) == 0 ) // fetch features asynchronously { QgsMessageLog::logMessage( QObject::tr( "Fetching from cursor %1 failed\nDatabase error: %2" ).arg( mCursorName, mConn->PQerrorMessage() ), QObject::tr( "PostGIS" ) ); } QgsPostgresResult queryResult; for ( ;; ) { queryResult = mConn->PQgetResult(); if ( !queryResult.result() ) break; if ( queryResult.PQresultStatus() != PGRES_TUPLES_OK ) { QgsMessageLog::logMessage( QObject::tr( "Fetching from cursor %1 failed\nDatabase error: %2" ).arg( mCursorName, mConn->PQerrorMessage() ), QObject::tr( "PostGIS" ) ); break; } int rows = queryResult.PQntuples(); if ( rows == 0 ) continue; for ( int row = 0; row < rows; row++ ) { mFeatureQueue.enqueue( QgsFeature() ); getFeature( queryResult, row, mFeatureQueue.back() ); } // for each row in queue } } if ( mFeatureQueue.empty() ) { QgsDebugMsg( QString( "Finished after %1 features" ).arg( mFetched ) ); close(); mSource->mShared->ensureFeaturesCountedAtLeast( mFetched ); return false; } feature = mFeatureQueue.dequeue(); mFetched++; feature.setValid( true ); feature.setFields( mSource->mFields ); // allow name-based attribute lookups return true; }
void InputMatrix::printFeatureMatrix(std::ostream& stream) { START_COLLECT_TIME(writingOutput, Counters::WritingOutput); stream << "# FeatureMatrix" << std::endl; stream << _rowsCount << " " << _qColsCount << std::endl; for(auto i=0; i<_rowsCount; ++i, stream << std::endl) { for(auto j=0; j<_qColsCount; ++j, stream << " ") { if(getFeature(i, j) == std::numeric_limits<int>::min()) stream << '-'; else stream << getFeature(i, j); } } STOP_COLLECT_TIME(writingOutput); }
void QgsFeaturePool::refreshCache( const QgsFeature &feature ) { QgsReadWriteLocker locker( mCacheLock, QgsReadWriteLocker::Write ); mFeatureCache.remove( feature.id() ); mIndex.deleteFeature( feature ); locker.unlock(); QgsFeature tempFeature; getFeature( feature.id(), tempFeature ); }
void QgsFeaturePool::removeFeature( const QgsFeatureId featureId ) { QgsFeature origFeature; QgsReadWriteLocker locker( mCacheLock, QgsReadWriteLocker::Unlocked ); if ( getFeature( featureId, origFeature ) ) { locker.changeMode( QgsReadWriteLocker::Write ); mIndex.deleteFeature( origFeature ); } locker.changeMode( QgsReadWriteLocker::Write ); mFeatureCache.remove( origFeature.id() ); }
void Game::setPVPMode(Otc::PVPModes pvpMode) { if(!canPerformGameAction()) return; if(!getFeature(Otc::GamePVPMode)) return; if(m_pvpMode == pvpMode) return; m_pvpMode = pvpMode; m_protocolGame->sendChangeFightModes(m_fightMode, m_chaseMode, m_safeFight, m_pvpMode); g_lua.callGlobalField("g_game", "onPVPModeChange", pvpMode); }
TetrisValue TetrisEmulator::getValue(TetrisBoard b) { double feature[FEATURE_COUNT]; getFeature(feature, b); double v = 0; for (int i = 0; i < FEATURE_COUNT; ++i) { // std::cout << feature[i] << '\n'; v += feature[i] * weight[i]; } return v; }
bool BaseTagHDF5::deleteFeature(const string &name_or_id) { boost::optional<Group> g = feature_group(); bool deleted = false; if (g && hasFeature(name_or_id)) { shared_ptr<IFeature> feature = getFeature(name_or_id); g->removeGroup(feature->id()); deleted = true; } return deleted; }
void Game::editVip(int playerId, const std::string& description, int iconId, bool notifyLogin) { if(!canPerformGameAction()) return; auto it = m_vips.find(playerId); if(it == m_vips.end()) return; std::get<2>(m_vips[playerId]) = description; std::get<3>(m_vips[playerId]) = iconId; std::get<4>(m_vips[playerId]) = notifyLogin; if(getFeature(Otc::GameAdditionalVipInfo)) m_protocolGame->sendEditVip(playerId, description, iconId, notifyLogin); }
SessionImpl::~SessionImpl() { try { if (isTransaction() && !getFeature("autoCommit")) { try { rollback(); } catch (...) { } } close(); } catch (...) { poco_unexpected(); } }
std::string Game::formatCreatureName(const std::string& name) { std::string formatedName = name; if(getFeature(Otc::GameFormatCreatureName) && name.length() > 0) { bool upnext = true; for(uint i=0;i<formatedName.length();++i) { char ch = formatedName[i]; if(upnext) { formatedName[i] = stdext::upchar(ch); upnext = false; } if(ch == ' ') upnext = true; } } return formatedName; }
DOMDocument* XQillaBuilderImpl::getDocumentAndAddGrammar() { DOMDocument *doc = 0; #if _XERCES_VERSION >= 30000 if (getParameter(XMLUni::fgXercesUserAdoptsDOMDocument) != 0) #else if (getFeature(XMLUni::fgXercesUserAdoptsDOMDocument)) #endif doc = adoptDocument(); else doc = getDocument(); if(doc == 0) { return 0; } if(getParameter(XMLUni::fgXercesDOMHasPSVIInfo)) { //we copy this gramamr and reset the parser one in the process. XMLGrammarPool *oldGrPool = getGrammarResolver()->getGrammarPool(); XQillaXMLGrammarPoolImpl *gr = new (getMemoryManager()) XQillaXMLGrammarPoolImpl(getMemoryManager()); // manually copy string pool contents to work around XERCESC-1798. const XMLStringPool* src = oldGrPool->getURIStringPool(); XMLStringPool* dst = gr->getURIStringPool(); for (unsigned int i = 1; i < src->getStringCount() + 1; ++i) dst->addOrFind (src->getValueForId(i)); RefHashTableOfEnumerator< Grammar> enumerator = oldGrPool->getGrammarEnumerator(); while(enumerator.hasMoreElements()) { Grammar &g = enumerator.nextElement(); gr->cacheGrammar(getGrammarResolver()->orphanGrammar(g.getGrammarDescription()->getGrammarKey())); } ((XQillaDocumentImpl*)doc)->setGrammarPool(gr, true); } return doc; }
void Game::autoWalk(std::vector<Otc::Direction> dirs) { if(!canPerformGameAction()) return; // protocol limits walk path up to 255 directions if(dirs.size() > 127) { g_logger.error("Auto walk path too great, the maximum number of directions is 127"); return; } if(dirs.size() == 0) return; // must cancel follow before any new walk if(isFollowing()) cancelFollow(); auto it = dirs.begin(); Otc::Direction direction = *it; if(!m_localPlayer->canWalk(direction)) return; TilePtr toTile = g_map.getTile(m_localPlayer->getPosition().translatedToDirection(direction)); if(toTile && toTile->isWalkable() && !m_localPlayer->isServerWalking()) { m_localPlayer->preWalk(direction); if(getFeature(Otc::GameForceFirstAutoWalkStep)) { forceWalk(direction); dirs.erase(it); } } g_lua.callGlobalField("g_game", "onAutoWalk", dirs); m_protocolGame->sendAutoWalk(dirs); }
void FeatureIndex::addFeature( std::unordered_map<std::string, std::vector<Feature>>& result, const IndexedSubfeature& indexedFeature, const GeometryCollection& queryGeometry, const optional<std::vector<std::string>>& filterLayerIDs, const GeometryTile& geometryTile, const CanonicalTileID& tileID, const style::Style& style, const float bearing, const float pixelsToTileUnits) const { auto& layerIDs = bucketLayerIDs.at(indexedFeature.bucketName); if (filterLayerIDs && !vectorsIntersect(layerIDs, *filterLayerIDs)) { return; } auto sourceLayer = geometryTile.getLayer(indexedFeature.sourceLayerName); assert(sourceLayer); auto geometryTileFeature = sourceLayer->getFeature(indexedFeature.index); assert(geometryTileFeature); for (const auto& layerID : layerIDs) { if (filterLayerIDs && !vectorContains(*filterLayerIDs, layerID)) { continue; } auto styleLayer = style.getLayer(layerID); if (!styleLayer || (!styleLayer->is<style::SymbolLayer>() && !styleLayer->baseImpl->queryIntersectsGeometry(queryGeometry, geometryTileFeature->getGeometries(), bearing, pixelsToTileUnits))) { continue; } result[layerID].push_back(convertFeature(*geometryTileFeature, tileID)); } }
void InputMatrix::calcRVector(int* r, int row1, int row2) { auto multiplier1 = 1; auto multiplier2 = 1; for(auto k=0; k<_qColsCount; ++k) { r[k] = 0; if(getFeature(row1, k) == DASH) { multiplier1 *= getFeatureValuesCount(k); } if(getFeature(row2, k) == DASH) { multiplier2 *= getFeatureValuesCount(k); } } auto calcLimits = [this](int row, int col) { return getFeature(row, col) == DASH ? std::tuple<int, int>(_qMinimum[col], _qMaximum[col]) : std::tuple<int, int>(getFeature(row, col), getFeature(row, col)); }; for (auto k=0; k<_qColsCount; ++k) { auto multiplier = multiplier1 * multiplier2; if(getFeature(row1, k) == DASH) { multiplier /= getFeatureValuesCount(k); } if(getFeature(row2, k) == DASH) { multiplier /= getFeatureValuesCount(k); } auto limit1 = calcLimits(row1, k); for (auto i = std::get<0>(limit1); i <= std::get<1>(limit1); ++i) { auto limit2 = calcLimits(row2, k); for (auto j = std::get<0>(limit2); j <= std::get<1>(limit2); ++j) { r[k] += std::abs(i - j) * multiplier; } } } }
unsigned int ofxLibdc::getBrightness() { return getFeature(DC1394_FEATURE_BRIGHTNESS); }
/** * OCR process from gray image input */ int ocrProcess(Image binImg) { int i, h, w; h = binImg.h; w = binImg.w; int count =0, lCount = 0; int start = 0; int endLine = 0; int nLine; Rect rect; int* charIndex[20]; system("rm -rf data"); system("mkdir -p data"); system("rm -rf leven"); system("mkdir -p leven"); createNetworkFromFile(); /// segmentation processing while((nLine = ccLineLabeling(binImg, start))!= 0) { if(nLine < 3) continue; printf("%d\n",nLine); int baseLine = getBaselineHeight(nLine); // int avgSpace = getAverageSpace(nLine); /// get slant deg int slantDeg = getSlantDeg(binImg, baseLine, nLine); // printf("slantDeg = %d\n", slantDeg); int nChar = 0; for(i = 0; i < nLine; i++) { int index = getSegmentIndex(i); // printf("%d ", index); rect = getCharRect(index); endLine = endLine > (rect.y + rect.h) ? endLine :(rect.y + rect.h); Image charImg = getImageFromRect(binImg, rect, index); if(slantDeg) { charImg = slantRemoval(charImg, slantDeg); } // char* name = (char*) malloc(20* sizeof(char)); // sprintf(name, "out_s_%d_%d.txt", lCount, i); // printImage(charImg, name); charImg = contourFinding(charImg); smoothContour(charImg); thinImageOnMatch(charImg); double* input = getFeature(charImg); double prop, maxProp = 0.0; /// recognition nChar++; charIndex[nChar-1] = charRecognition(input, &prop); /// check space //int space = getSpace(i, nLine, binImg); //if(space > baseLine/2) {//printf(" "); // createWordFst(charIndex, nChar); // nChar = 0; // printf(" "); //} deleteImage(charImg); free(input); count++; // } // printf(" "); // start_w = end_w; // deleteImage(wordImg); } printf("\n"); start = endLine; lCount++; } deleteImage(binImg); deleteNetwork(); printf("%d\n", count); return 0; }
QByteArray QUsbHid::getFeature(int maxLen, bool* r) { return getFeature(0,maxLen,r); }
void Objectness::generateTrianData() { const int NUM_TRAIN = _voc.trainNum; const int FILTER_SZ = _W*_W; vector<vector<Mat> > xTrainP(NUM_TRAIN), xTrainN(NUM_TRAIN); vector<vecI> szTrainP(NUM_TRAIN); // Corresponding size index. const int NUM_NEG_BOX = 100; // Number of negative windows sampled from each image #pragma omp parallel for for (int i = 0; i < NUM_TRAIN; i++) { const int NUM_GT_BOX = (int)_voc.gtTrainBoxes[i].size(); vector<Mat> &xP = xTrainP[i], &xN = xTrainN[i]; vecI &szP = szTrainP[i]; xP.reserve(NUM_GT_BOX*4), szP.reserve(NUM_GT_BOX*4), xN.reserve(NUM_NEG_BOX); Mat im3u = imread(format(_S(_voc.imgPathW), _S(_voc.trainSet[i]))); // Get positive training data for (int k = 0; k < NUM_GT_BOX; k++) { const Vec4i& bbgt = _voc.gtTrainBoxes[i][k]; vector<Vec4i> bbs; // bounding boxes; vecI bbR; // Bounding box ratios int nS = gtBndBoxSampling(bbgt, bbs, bbR); for (int j = 0; j < nS; j++) { bbs[j][2] = min(bbs[j][2], im3u.cols); bbs[j][3] = min(bbs[j][3], im3u.rows); Mat mag1f = getFeature(im3u, bbs[j]), magF1f; flip(mag1f, magF1f, CV_FLIP_HORIZONTAL); xP.push_back(mag1f); xP.push_back(magF1f); szP.push_back(bbR[j]); szP.push_back(bbR[j]); } } // Get negative training data for (int k = 0; k < NUM_NEG_BOX; k++) { int x1 = rand() % im3u.cols + 1, x2 = rand() % im3u.cols + 1; int y1 = rand() % im3u.rows + 1, y2 = rand() % im3u.rows + 1; Vec4i bb(min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)); if (maxIntUnion(bb, _voc.gtTrainBoxes[i]) < 0.5) xN.push_back(getFeature(im3u, bb)); } } const int NUM_R = _numT * _numT + 1; vecI szCount(NUM_R); // Object counts of each size (combination of scale and aspect ratio) int numP = 0, numN = 0, iP = 0, iN = 0; for (int i = 0; i < NUM_TRAIN; i++) { numP += xTrainP[i].size(); numN += xTrainN[i].size(); const vecI &rP = szTrainP[i]; for (size_t j = 0; j < rP.size(); j++) szCount[rP[j]]++; } vecI szActive; // Indexes of active size for (int r = 1; r < NUM_R; r++) { if (szCount[r] > 50) // If only 50- positive samples at this size, ignore it. szActive.push_back(r-1); } matWrite(_modelName + ".idx", Mat(szActive)); Mat xP1f(numP, FILTER_SZ, CV_32F), xN1f(numN, FILTER_SZ, CV_32F); for (int i = 0; i < NUM_TRAIN; i++) { vector<Mat> &xP = xTrainP[i], &xN = xTrainN[i]; for (size_t j = 0; j < xP.size(); j++) memcpy(xP1f.ptr(iP++), xP[j].data, FILTER_SZ*sizeof(float)); for (size_t j = 0; j < xN.size(); j++) memcpy(xN1f.ptr(iN++), xN[j].data, FILTER_SZ*sizeof(float)); } CV_Assert(numP == iP && numN == iN); matWrite(_modelName + ".xP", xP1f); matWrite(_modelName + ".xN", xN1f); }
ofPolyline ofxFaceTracker2Landmarks::getImageFeature(Feature feature) const { return getFeature(feature, getImagePoints()); }
bool BaseTagHDF5::hasFeature(const string &name_or_id) const { return getFeature(name_or_id) != nullptr; }
std::vector<Feature> MultiTag::features(const util::Filter<Feature>::type &filter) const { auto f = [this] (size_t i) { return getFeature(i); }; return getEntities<Feature>(f, featureCount(), filter); }
shared_ptr<IFeature> BaseTagHDF5::getFeature(size_t index) const { boost::optional<Group> g = feature_group(); string id = g->objectName(index); return getFeature(id); }
float ofxLibdc::getFeatureNorm(dc1394feature_t feature) { unsigned int value = getFeature(feature); unsigned int min, max; getFeatureRange(feature, &min, &max); return ((float) value - min) / (max - min); }
unsigned int ofxLibdc::getShutter() { return getFeature(DC1394_FEATURE_SHUTTER); }
unsigned int ofxLibdc::getExposure() { return getFeature(DC1394_FEATURE_EXPOSURE); }
unsigned int ofxLibdc::getGain() { return getFeature(DC1394_FEATURE_GAIN); }
bool QgsPostgresFeatureIterator::nextFeature( QgsFeature& feature ) { feature.setValid( false ); if ( mClosed ) return false; #if 0 // featureAtId used to have some special checks - necessary? if ( !mUseQueue ) { QgsPostgresResult queryResult = P->mConnectionRO->PQexec( QString( "FETCH FORWARD 1 FROM %1" ).arg( mCursorName ) ); int rows = queryResult.PQntuples(); if ( rows == 0 ) { QgsMessageLog::logMessage( tr( "feature %1 not found" ).arg( featureId ), tr( "PostGIS" ) ); P->mConnectionRO->closeCursor( cursorName ); return false; } else if ( rows != 1 ) { QgsMessageLog::logMessage( tr( "found %1 features instead of just one." ).arg( rows ), tr( "PostGIS" ) ); } bool gotit = getFeature( queryResult, 0, feature ); feature.setValid( gotit ); feature.setFields( &P->mAttributeFields ); // allow name-based attribute lookups return gotit; } #endif if ( mFeatureQueue.empty() ) { QString fetch = QString( "FETCH FORWARD %1 FROM %2" ).arg( mFeatureQueueSize ).arg( mCursorName ); QgsDebugMsgLevel( QString( "fetching %1 features." ).arg( mFeatureQueueSize ), 4 ); if ( P->mConnectionRO->PQsendQuery( fetch ) == 0 ) // fetch features asynchronously { QgsMessageLog::logMessage( QObject::tr( "Fetching from cursor %1 failed\nDatabase error: %2" ).arg( mCursorName ).arg( P->mConnectionRO->PQerrorMessage() ), QObject::tr( "PostGIS" ) ); } QgsPostgresResult queryResult; for ( ;; ) { queryResult = P->mConnectionRO->PQgetResult(); if ( !queryResult.result() ) break; if ( queryResult.PQresultStatus() != PGRES_TUPLES_OK ) { QgsMessageLog::logMessage( QObject::tr( "Fetching from cursor %1 failed\nDatabase error: %2" ).arg( mCursorName ).arg( P->mConnectionRO->PQerrorMessage() ), QObject::tr( "PostGIS" ) ); break; } int rows = queryResult.PQntuples(); if ( rows == 0 ) continue; for ( int row = 0; row < rows; row++ ) { mFeatureQueue.enqueue( QgsFeature() ); getFeature( queryResult, row, mFeatureQueue.back() ); } // for each row in queue } } if ( mFeatureQueue.empty() ) { QgsDebugMsg( QString( "Finished after %1 features" ).arg( mFetched ) ); close(); if ( P->mFeaturesCounted < mFetched ) { QgsDebugMsg( QString( "feature count adjusted from %1 to %2" ).arg( P->mFeaturesCounted ).arg( mFetched ) ); P->mFeaturesCounted = mFetched; } return false; } // Now return the next feature from the queue if ( mRequest.flags() & QgsFeatureRequest::NoGeometry ) { feature.setGeometryAndOwnership( 0, 0 ); } else { QgsGeometry* featureGeom = mFeatureQueue.front().geometryAndOwnership(); feature.setGeometry( featureGeom ); } feature.setFeatureId( mFeatureQueue.front().id() ); feature.setAttributes( mFeatureQueue.front().attributes() ); mFeatureQueue.dequeue(); mFetched++; feature.setValid( true ); feature.setFields( &P->mAttributeFields ); // allow name-based attribute lookups return true; }
unsigned int ofxLibdc::getGamma() { return getFeature(DC1394_FEATURE_GAMMA); }