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);
}
