BaseMatInstance * MaterialManager::createMeshDebugMatInstance(const ColorF &meshColor) { String meshDebugStr = String::ToString( "Torque_MeshDebug_%d", meshColor.getRGBAPack() ); Material *debugMat; if (!Sim::findObject(meshDebugStr,debugMat)) { debugMat = allocateAndRegister( meshDebugStr ); debugMat->mDiffuse[0] = meshColor; debugMat->mEmissive[0] = true; } BaseMatInstance *debugMatInstance = NULL; if( debugMat != NULL ) { debugMatInstance = debugMat->createMatInstance(); GFXStateBlockDesc desc; desc.setCullMode(GFXCullNone); desc.fillMode = GFXFillWireframe; debugMatInstance->addStateBlockDesc(desc); // Disable fog and other stuff. FeatureSet debugFeatures; debugFeatures.addFeature( MFT_DiffuseColor ); debugMatInstance->init( debugFeatures, getGFXVertexFormat<GFXVertexPCN>() ); } return debugMatInstance; }
// Perform simple feature matching. This just uses the SSD // distance between two feature vectors, and matches a feature in the // first image with the closest feature in the second image. It can // match multiple features in the first image to the same feature in // the second image. void ssdMatchFeatures(const FeatureSet &f1, const FeatureSet &f2, vector<FeatureMatch> &matches, double &totalScore) { int m = f1.size(); int n = f2.size(); matches.resize(m); totalScore = 0; double d; double dBest; int idBest; for (int i=0; i<m; i++) { dBest = 1e100; idBest = 0; for (int j=0; j<n; j++) { d = distanceSSD(f1[i].data, f2[j].data); if (d < dBest) { dBest = d; idBest = f2[j].id; } } matches[i].id1 = f1[i].id; matches[i].id2 = idBest; matches[i].score = dBest; totalScore += matches[i].score; } }
void RowLookupTable::buildIndex( const FeatureSet & fset ) { size_t n = fset.size(); if( !n ) return; _maxY = ( int )fset[ n - 1 ].pt.y; _rowIndex.resize( _maxY + 1, Row() ); int cy = ( int )fset[ 0 ].pt.y; _minY = cy; _rowIndex[ cy ].start = 0; FeatureSet::CmpYi cmp; while( cy < _maxY ){ int prevStart = _rowIndex[ cy ].start; // calculate the upper bound for the previous y coord int start = std::upper_bound( &fset[ prevStart ], &fset[ n - 1 ], fset[ prevStart ], cmp ) - &fset[ 0 ]; if( start == prevStart ) { break; } _rowIndex[ cy ].len = start - prevStart; cy = ( int ) fset[ start ].pt.y; _rowIndex[ cy ].start = start; } _rowIndex[ cy ].len = fset.size() - _rowIndex[ cy ].start; }
// Perform ratio feature matching. This just uses the ratio of the SSD distance of the // two best matches and matches a feature in the first image with the closest feature // in the second image. It can match multiple features in the first image to the same // feature in the second image. void ratioMatchFeatures(const FeatureSet &f1, const FeatureSet &f2, vector<FeatureMatch> &matches) { int m = f1.size(); int n = f2.size(); matches.resize(m); double d; double dBest, dBest2; int idBest; for (int i=0; i<m; i++) { dBest = 1e100; dBest2 = 1e100; idBest = 0; for (int j=0; j<n; j++) { d = distanceSSD(f1[i].data, f2[j].data); if (d < dBest) { dBest2 = dBest; dBest = d; idBest = f2[j].id; } else if (d < dBest2) { dBest2 = d; } } matches[i].id1 = f1[i].id; matches[i].id2 = idBest; matches[i].distance = dBest/dBest2; } }
void SkyBox::_initMaterial() { if ( mMatInstance ) SAFE_DELETE( mMatInstance ); if ( mMaterial ) mMatInstance = mMaterial->createMatInstance(); else mMatInstance = MATMGR->createMatInstance( "WarningMaterial" ); // We want to disable culling and z write. GFXStateBlockDesc desc; desc.setCullMode( GFXCullNone ); desc.setBlend( true ); desc.setZReadWrite( true, false ); mMatInstance->addStateBlockDesc( desc ); // Also disable lighting on the skybox material by default. FeatureSet features = MATMGR->getDefaultFeatures(); features.removeFeature( MFT_RTLighting ); features.removeFeature( MFT_Visibility ); features.addFeature(MFT_SkyBox); // Now initialize the material. mMatInstance->init(features, getGFXVertexFormat<GFXVertexPNT>()); }
// Compute Simple descriptors. void ComputeSimpleDescriptors(CFloatImage &image, FeatureSet &features) { //Create grayscale image used for Harris detection CFloatImage grayImage=ConvertToGray(image); vector<Feature>::iterator i = features.begin(); while (i != features.end()) { Feature &f = *i; //these fields should already be set in the computeFeatures function int x = f.x; int y = f.y; // now get the 5x5 window surrounding the feature and store them in the features for(int row=(y-2); row<=(y+2); row++) { for(int col=(x-2); col<=(x+2); col++) { //if the pixel is out of bounds, assume it is black if(row<0 || row>=grayImage.Shape().height || col<0 || col>=grayImage.Shape().width) { f.data.push_back(0.0); } else { f.data.push_back(grayImage.Pixel(col,row,0)); } } } printf("feature num %d\n", i->id); i++; } }
void ImposterCaptureMaterialHook::init( BaseMatInstance *inMat ) { // We cannot capture impostors on custom materials // as we don't know how to get just diffuse and just // normals rendering. if ( dynamic_cast<CustomMaterial*>( inMat->getMaterial() ) ) return; // Tweak the feature data to include just what we need. FeatureSet features; features.addFeature( MFT_VertTransform ); features.addFeature( MFT_DiffuseMap ); features.addFeature( MFT_OverlayMap ); features.addFeature( MFT_DetailMap ); features.addFeature( MFT_DiffuseColor ); features.addFeature( MFT_AlphaTest ); features.addFeature( MFT_IsTranslucent ); const String &matName = inMat->getMaterial()->getName(); mDiffuseMatInst = MATMGR->createMatInstance( matName ); mDiffuseMatInst->getFeaturesDelegate().bind( &ImposterCaptureMaterialHook::_overrideFeatures ); mDiffuseMatInst->init( features, inMat->getVertexFormat() ); features.addFeature( MFT_IsDXTnm ); features.addFeature( MFT_NormalMap ); features.addFeature( MFT_NormalsOut ); mNormalsMatInst = MATMGR->createMatInstance( matName ); mNormalsMatInst->getFeaturesDelegate().bind( &ImposterCaptureMaterialHook::_overrideFeatures ); mNormalsMatInst->init( features, inMat->getVertexFormat() ); }
void ShadowMaterialHook::_overrideFeatures( ProcessedMaterial *mat, U32 stageNum, MaterialFeatureData &fd, const FeatureSet &features ) { if ( stageNum != 0 ) { fd.features.clear(); return; } // Disable the base texture if we don't // have alpha test enabled. if ( !fd.features[ MFT_AlphaTest ] ) { fd.features.removeFeature( MFT_TexAnim ); fd.features.removeFeature( MFT_DiffuseMap ); } // HACK: Need to figure out how to enable these // suckers without this override call! fd.features.setFeature( MFT_ParaboloidVertTransform, features.hasFeature( MFT_ParaboloidVertTransform ) ); fd.features.setFeature( MFT_IsSinglePassParaboloid, features.hasFeature( MFT_IsSinglePassParaboloid ) ); // The paraboloid transform outputs linear depth, so // it needs to use the plain depth out feature. if ( fd.features.hasFeature( MFT_ParaboloidVertTransform ) ) fd.features.addFeature( MFT_DepthOut ); else fd.features.addFeature( MFT_EyeSpaceDepthOut ); }
AbstractClient::AbstractClient(QObject *parent) : QObject(parent), nextCmdId(0), status(StatusDisconnected) { qRegisterMetaType<QVariant>("QVariant"); qRegisterMetaType<CommandContainer>("CommandContainer"); qRegisterMetaType<Response>("Response"); qRegisterMetaType<Response::ResponseCode>("Response::ResponseCode"); qRegisterMetaType<ClientStatus>("ClientStatus"); qRegisterMetaType<RoomEvent>("RoomEvent"); qRegisterMetaType<GameEventContainer>("GameEventContainer"); qRegisterMetaType<Event_ServerIdentification>("Event_ServerIdentification"); qRegisterMetaType<Event_ConnectionClosed>("Event_ConnectionClosed"); qRegisterMetaType<Event_ServerShutdown>("Event_ServerShutdown"); qRegisterMetaType<Event_AddToList>("Event_AddToList"); qRegisterMetaType<Event_RemoveFromList>("Event_RemoveFromList"); qRegisterMetaType<Event_UserJoined>("Event_UserJoined"); qRegisterMetaType<Event_UserLeft>("Event_UserLeft"); qRegisterMetaType<Event_ServerMessage>("Event_ServerMessage"); qRegisterMetaType<Event_ListRooms>("Event_ListRooms"); qRegisterMetaType<Event_GameJoined>("Event_GameJoined"); qRegisterMetaType<Event_UserMessage>("Event_UserMessage"); qRegisterMetaType<Event_NotifyUser>("Event_NotifyUser"); qRegisterMetaType<ServerInfo_User>("ServerInfo_User"); qRegisterMetaType<QList<ServerInfo_User> >("QList<ServerInfo_User>"); qRegisterMetaType<Event_ReplayAdded>("Event_ReplayAdded"); qRegisterMetaType<QList<QString> >("missingFeatures"); FeatureSet features; features.initalizeFeatureList(clientFeatures); connect(this, SIGNAL(sigQueuePendingCommand(PendingCommand *)), this, SLOT(queuePendingCommand(PendingCommand *))); }
int MetalabelFeature::ExtractFeature(const vector<TokenCitation*>& tokenVector, CitationSet& citationSet, UniGramFeature& uniGrams, BiGramFeature& biGrams, JournalSet& journalSet, FeatureSet& allFeatures, int printLog) { int rtn = 0; allFeatures.mFeatures.clear(); allFeatures.mMaxIndex = uniGrams.mDictionary.rbegin()->first + 1; allFeatures.mFeatures.resize(tokenVector.size()); FeatureSet biFeatures; biFeatures.mMaxIndex = biGrams.mDictionary.rbegin()->first + 1; biFeatures.mFeatures.resize(tokenVector.size()); FeatureSet jourFeatures; jourFeatures.mMaxIndex = journalSet.mJournals.rbegin()->first + 1; jourFeatures.mFeatures.resize(tokenVector.size()); int numThreads = omp_get_num_procs(); if (printLog != SILENT) clog << "CPU number: " << numThreads << endl; omp_set_num_threads(numThreads); if (printLog != SILENT) clog << "Start Parallel Extract Features" << endl; #pragma omp parallel for schedule(dynamic) for (int i = 0; i < tokenVector.size(); i++) { uniGrams.Extract(*tokenVector[i], allFeatures.mFeatures[i]); } #pragma omp parallel for schedule(dynamic) for (int i = 0; i < tokenVector.size(); i++) { biGrams.Extract(*tokenVector[i], biFeatures.mFeatures[i]); } #pragma omp parallel for schedule(dynamic) for (int i = 0; i < tokenVector.size(); ++i) { Journal* ptrJournal = NULL; ptrJournal = journalSet.SearchJournalTitle(citationSet[tokenVector[i]->mPmid]->mJournalTitle); if (ptrJournal != NULL) { jourFeatures.mFeatures[i][ptrJournal->mJournalId] = 1.0; } else { cerr << "Error: can't find \"" << citationSet[tokenVector[i]->mPmid]->mJournalTitle << " in pmid " << tokenVector[i]->mPmid << endl; } } rtn = allFeatures.Merge(biFeatures); CHECK_RTN(rtn); rtn = allFeatures.Merge(jourFeatures); CHECK_RTN(rtn); rtn = allFeatures.Normalize(); CHECK_RTN(rtn); return 0; }
bool IWizardFactory::isAvailable(const QString &platformName) const { FeatureSet availableFeatures = pluginFeatures(); foreach (const Core::IFeatureProvider *featureManager, s_providerList) availableFeatures |= featureManager->availableFeatures(platformName); return availableFeatures.contains(requiredFeatures()); }
std::vector<float> SupportVectorMachine::predict(const FeatureSet& fset) const { std::vector<float> preds(fset.size()); for(int i = 0; i < fset.size(); i++) { preds[i] = predict(fset[i]); } return preds; }
bool IWizard::isAvailable(const QString &platformName) const { FeatureSet availableFeatures; const QList<Core::IFeatureProvider*> featureManagers = ExtensionSystem::PluginManager::getObjects<Core::IFeatureProvider>(); foreach (const Core::IFeatureProvider *featureManager, featureManagers) availableFeatures |= featureManager->availableFeatures(platformName); return availableFeatures.contains(requiredFeatures()); }
/** * Reads the recorded gesture data from the files and brings it in the format ready for training. */ vector<FeatureSet> GestureManagement::readData() { // read all takes for each gesture vector<FeatureSet> sets; sets.clear(); for (int i=0; i<=NUMBER_OF_ROGGEN_SENSORS; ++i) { FeatureSet s; s.clear(); sets.push_back(s); } for (int f=0; f<config->getStrings("classification names").size(); ++f) { if (config->getInt("verbosity") > 1) { cout << "Training classification name number " << f << endl; } // cout << "Gesture: " << f << endl; vector<float> varianceSums; // compute sums for every sensor within a gesture varianceSums.clear(); for (int i=0; i<NUMBER_OF_ROGGEN_SENSORS; i++) { varianceSums.push_back(0); // inital value } int sizeSum = 0; // for (int i=1; i<=NUMBER_OF_TAKES; i++) { // for each of the 3 takes for (int i=1; i<=config->getInt("number of takes"); ++i) { // cout << "Take " << i << endl; string fname = XML_SUBDIRECTORY+config->getStrings("classification names").at(f)+Helper::toString(i)+".xml"; // cout << "Filename: " << fname << endl; if (!Helper::fileExists(fname.c_str())) { cerr << fname << " not yet recorded!" << endl; cerr << "No training possible" << endl; sets.clear(); return sets; } else { vector<vector<int> > rd = convert(XmlFileHandling::readIntData(fname)); for (int sensor=0; sensor<NUMBER_OF_ROGGEN_SENSORS; ++sensor) { // for every sensor // cout << "Sensor " << sensor << endl; buffers.at(sensor)->clear(); buffers.at(sensor)->setUnlimited(); buffers.at(sensor)->put(RoggenBuffer::filter(0,config->getInts("IDs").at(sensor),rd)); maxGestureLength = Helper::getMax(maxGestureLength,buffers.at(sensor)->size()); FeatureSample fs; fs.out = f; fs.in.clear(); fs.in = extractFeatures(sensor); sets.at(sensor).push_back(fs); int size = buffers.at(sensor)->size(); sizeSum += size; } // for every sensor } // if fileexists } // for every take sizeSum /= config->getInt("number of takes") * NUMBER_OF_ROGGEN_SENSORS; // compute average size of one gesture sizes.push_back(sizeSum); // store sizes (averages) } // for every gesture return sets; }
void ProcessedFFMaterial::_determineFeatures( U32 stageNum, FixedFuncFeatureData& featData, const FeatureSet &features ) { if ( mStages[stageNum].getTex( MFT_DiffuseMap ) ) featData.features[FixedFuncFeatureData::DiffuseMap] = true; if ( features.hasFeature( MFT_LightMap ) ) featData.features[FixedFuncFeatureData::LightMap] = true; if ( features.hasFeature( MFT_ToneMap )) featData.features[FixedFuncFeatureData::ToneMap] = true; }
int MatchFeaturesByDistRatio(const FeatureSet &f1, const FeatureSet &f2, vector<FeatureMatch> &matches) { //cout<<"ratio between the first and the second best match: "<<Match_threshold_for_ratio<<endl; int count = 0; int m = f1.size(); int n = f2.size(); matches.clear(); double d; double dBest[2]; int idBest; FeatureMatch feamatch; for (int i=0; i<m; i++) { dBest[0] = 1e100; dBest[1] = 1e100 + 1; idBest = 0; for (int j=0; j<n; j++) { d = distanceEuclidean(f1[i].data, f2[j].data); if (d < dBest[0]) { dBest[1] = dBest[0]; dBest[0] = d; idBest = f2[j].id; } else if (d < dBest[1]) { dBest[1] = d; } } if (sqrt(dBest[0] / dBest[1]) < Match_threshold_for_ratio) { feamatch.id = idBest; matches.push_back(feamatch); count++; } else { feamatch.id = -1; matches.push_back(feamatch); } } return count; }
//Add a training sample void LearningInterface::addTrainingSample(FeatureSet &features, double label) { sample_type samp; // samp(0) = (double)features.bandwidth(); // samp(1) = (double)features.contentType(); for(int i = 0; i < FEATURE_SET_NUM_FEATURES; i++) samp(i) = features.getFeatureByIndex((FeatureSetIndexType) i); m_training_set.push_back(samp); if(label == 1.0) m_labels.push_back(+1); else m_labels.push_back(-1); m_num_training_samples++; //Test to see if user falls into only one class if(m_one_class_only) { //This is the first sample if(m_single_class_val == -2) { //Set this as the single class value m_single_class_val = (int) label; } //See if this is the other class else if((int)label != m_single_class_val) { //Lower flags m_one_class_only = false; } } }
/******************* TO DO ********************* * countInliers: * INPUT: * f1, f2: source feature sets * matches: correspondences between f1 and f2 * m: motion model * f: focal length * width: image width * height: image height * M: transformation matrix * RANSACthresh: RANSAC distance threshold * inliers: inlier feature IDs * OUTPUT: * transform the features in f1 by M * * count the number of features in f1 for which the transformed * feature is within Euclidean distance RANSACthresh of its match * in f2 * * store these features IDs in inliers * * this method should be similar to evaluateMatch from project 1, * except you are comparing each distance to a threshold instead * of averaging them */ int countInliers(const FeatureSet &f1, const FeatureSet &f2, const vector<FeatureMatch> &matches, MotionModel m, float f, int width, int height, CTransform3x3 M, double RANSACthresh, vector<int> &inliers) { inliers.clear(); int count = 0; for (unsigned int i=0; i<f1.size(); i++) { // BEGIN TODO // determine if the ith feature in f1, when transformed by M, // is within RANSACthresh of its match in f2 (if one exists) // // if so, increment count and append i to inliers if (matches[i].id < 0) continue; CVector3 p1, p2; p1[0] = f1[i].x - width / 2.0; p1[1] = f1[i].y - height / 2.0; p1[2] = f; p2 = M * p1; double xNew = p2[0] + width / 2.0; double yNew = p2[1] + height / 2.0; int f2pos = matches[i].id - 1; double dist = sqrt(pow(xNew - f2[f2pos].x, 2) + pow(yNew - f2[f2pos].y, 2)); if (dist < RANSACthresh) { inliers.push_back(i); count++; } // END TODO } return count; }
// Compute silly example features. This doesn't do anything // meaningful, but may be useful to use as an example. void dummyComputeFeatures(CFloatImage &image, FeatureSet &features) { CShape sh = image.Shape(); Feature f; for (int y=0; y<sh.height; y++) { for (int x=0; x<sh.width; x++) { double r = image.Pixel(x,y,0); double g = image.Pixel(x,y,1); double b = image.Pixel(x,y,2); if ((int)(255*(r+g+b)+0.5) % 100 == 1) { // If the pixel satisfies this meaningless criterion, // make it a feature. f.type = 1; f.id += 1; f.x = x; f.y = y; f.data.resize(1); f.data[0] = r + g + b; features.push_back(f); } } } }
void ComputeHarrisFeatures(CFloatImage &image, FeatureSet &features) { //Create grayscale image used for Harris detection CFloatImage grayImage=ConvertToGray(image); //Create image to store Harris values CFloatImage harrisImage(image.Shape().width,image.Shape().height,1); //Create image to store local maximum harris values as 1, other pixels 0 CByteImage harrisMaxImage(image.Shape().width,image.Shape().height,1); //compute Harris values puts harris values at each pixel position in harrisImage. //You'll need to implement this function. computeHarrisValues(grayImage, harrisImage); // Threshold the harris image and compute local maxima. You'll need to implement this function. computeLocalMaxima(harrisImage,harrisMaxImage); // Prints out the harris image for debugging purposes CByteImage tmp(harrisImage.Shape()); convertToByteImage(harrisImage, tmp); WriteFile(tmp, "harris.tga"); // TO DO-------------------------------------------------------------------- //Loop through feature points in harrisMaxImage and fill in information needed for //descriptor computation for each point above a threshold. We fill in id, type, //x, y, and angle. CFloatImage A(grayImage.Shape()); CFloatImage B(grayImage.Shape()); CFloatImage C(grayImage.Shape()); CFloatImage partialX(grayImage.Shape()); CFloatImage partialY(grayImage.Shape()); GetHarrisComponents(grayImage, A, B, C, &partialX, &partialY); int featureCount = 0; for (int y=0;y<harrisMaxImage.Shape().height;y++) { for (int x=0;x<harrisMaxImage.Shape().width;x++) { // Skip over non-maxima if (harrisMaxImage.Pixel(x, y, 0) == 0) continue; //TO DO--------------------------------------------------------------------- // Fill in feature with descriptor data here. Feature f; f.type = 2; f.id = featureCount++; f.x = x; f.y = y; f.angleRadians = GetCanonicalOrientation(x, y, A, B, C, partialX, partialY); //atan(partialY.Pixel(x, y, 0)/partialX.Pixel(x, y, 0)); // Add the feature to the list of features features.push_back(f); } } }
int MetalabelFeature::ExtractFeature(const vector<TokenCitation*>& tokenVector, UniGramFeature& uniGrams, BiGramFeature& biGrams, feature_node** &featureSpace, int printLog) { int numThreads = omp_get_num_procs(); if (printLog != SILENT) clog << "CPU number: " << numThreads << endl; omp_set_num_threads(numThreads); if (printLog != SILENT) clog << "Extract unigram & bigram" << endl; if (printLog != SILENT) clog << "Make Feature table" << endl; int featureNum = (int)tokenVector.size(); featureSpace = NULL; featureSpace = Malloc(feature_node*, featureNum); memset(featureSpace, 0, sizeof(feature_node*)* featureNum); int uniMaxIndex = uniGrams.mDictionary.rbegin()->first + 1; int biMaxIndex = biGrams.mDictionary.rbegin()->first + 1; if (printLog != SILENT) clog << "Extract features parallel" << endl; #pragma omp parallel for schedule(dynamic) for (int i = 0; i < (int)tokenVector.size(); i++) { FeatureSet tabAllFeatures; tabAllFeatures.mMaxIndex = uniMaxIndex; tabAllFeatures.mFeatures.resize(1); FeatureSet tabBiFeatures; tabBiFeatures.mMaxIndex = biMaxIndex; tabBiFeatures.mFeatures.resize(1); uniGrams.Extract(*tokenVector[i], tabAllFeatures.mFeatures[0]); biGrams.Extract(*tokenVector[i], tabBiFeatures.mFeatures[0]); tabAllFeatures.Merge(tabBiFeatures); tabAllFeatures.Normalize(); featureSpace[i] = NULL; LinearMachine::TransFeatures(featureSpace[i], tabAllFeatures.mFeatures[0]); } return 0; }
void ImposterCaptureMaterialHook::_overrideFeatures( ProcessedMaterial *mat, U32 stageNum, MaterialFeatureData &fd, const FeatureSet &features ) { if ( features.hasFeature( MFT_NormalsOut) ) fd.features.addFeature( MFT_NormalsOut ); fd.features.addFeature( MFT_ForwardShading ); }
void DatabaseSubsystem::getAvailableFeatures(Session& session, const map<int, int>& clObjMap, FeatureSet& featureSet) { int ddType; string featureName; double featureParam1, featureParam2, featureParam3; featureSet.clear(); ostringstream clObjIDs; for (map<int, int>::const_iterator itr = clObjMap.begin(); itr != clObjMap.end(); ++itr) { if (itr != clObjMap.begin()) { clObjIDs << ","; } clObjIDs << itr->first; } Statement stmt = (session << "SELECT DISTINCT " " data_descriptor.type, data_feature.feature_name, " " data_feature.feature_param1, data_feature.feature_param2, " " data_feature.feature_param3 " "FROM data_feature INNER JOIN data_descriptor " "ON (data_feature.descr_id = data_descriptor.descr_id) " "WHERE data_descriptor.descr_id IN (" " SELECT descr_id FROM classification_object_data WHERE object_id IN (" << clObjIDs.str() << "))", range(0, 1), into(ddType), into(featureName), into(featureParam1), into(featureParam2), into(featureParam3)); while (!stmt.done()) { if (stmt.execute() == 1) { featureSet.add(FeatureDescriptor(featureName, (DataDescriptor::Type) ddType, featureParam1, featureParam2, featureParam3)); } } }
void CFeatureDrawer::DrawFadeFeaturesSet(FeatureSet& fadeFeatures, int modelType) { for (FeatureSet::iterator fi = fadeFeatures.begin(); fi != fadeFeatures.end(); ) { const float cols[] = {1.0f, 1.0f, 1.0f, fi->second}; if (modelType != MODELTYPE_3DO) { glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, cols); } // hack, sorting objects by distance would look better glAlphaFunc(GL_GREATER, fi->second / 2.0f); glColor4fv(cols); if (!DrawFeatureNow(fi->first, fi->second)) { fi = set_erase(fadeFeatures, fi); } else { ++fi; } } }
vector<FeatureMatch> matchFeatures(const FeatureSet &f1, const FeatureSet &f2) { vector<FeatureMatch> matches; float threshold = 500; for (int i = 0; i < f1.size(); ++i) { int nearest = -1; float nearestDis = threshold; for (int j = 0; j < f2.size(); ++j) { float dis = featureDist(f1[i], f2[j]); if (dis < nearestDis) { nearestDis = dis; nearest = j; } } FeatureMatch newMatch; newMatch.id = nearest + 1; newMatch.score = nearestDis; matches.push_back(newMatch); } return matches; }
FeatureSet FeatureSet::clone() const { FeatureSet other; for (FeatureSet::const_iterator i = begin(); i != end(); ++i) { FeatureVector cv = i->clone(); // check that all data is the same: if (cv.size() != i->size()) throw std::runtime_error("ssssssssss"); for (unsigned int idx=0; idx<cv.size(); ++idx) { if (cv[idx] != (*i)[idx]) { cout << "(" << cv[idx] << "!=" << (*i)[idx] << ")" << flush; throw std::runtime_error("??????????"); } } if (cv.getTag<TagTrueClassLabel>().label != i->getTag<TagTrueClassLabel>().label) { cout << "(" << cv.getTag<TagTrueClassLabel>().label << "!=" << i->getTag<TagTrueClassLabel>().label << ")" << flush; throw std::runtime_error("!!!!!!!!!!!"); } other.push_back(cv); } return other; }
void FeatureExtractor::operator()(const ImageDatabase& db, FeatureSet& featureSet) const { int n = db.getSize(); featureSet.resize(n); for(int i = 0; i < n; i++) { CByteImage img; ReadFile(img, db.getFilename(i).c_str()); featureSet[i] = (*this)(img); } }
bool outputAndCheck(const DataSet& dataSet, const FeatureSet& featureSet) { int i = 0; bool ok = true; for (DataSet::const_iterator dItr = dataSet.begin(); dItr != dataSet.end(); ++dItr, ++i) { cout << "DataPoint #" << i << " has " << dItr->components.size() << " features: "; for (DataPoint::ComponentMap::const_iterator cItr = dItr->components.begin(); cItr != dItr->components.end(); ++cItr) { cout << cItr->first.toString() << " "; if (!featureSet.has(cItr->first)) { ok = false; } } cout << endl; if (dItr->components.size() != featureSet.size()) ok = false; } return ok; }
void FeatureSet::filter( const FeatureSet &features ) { PROFILE_SCOPE( FeatureSet_Filter ); for ( U32 i=0; i < mFeatures.size(); ) { if ( !features.hasFeature( *mFeatures[i].type ) ) mFeatures.erase_fast( i ); else i++; } mDescription.clear(); }
//Make a prediction using the given feature set double LearningInterface::predict(FeatureSet &features) { //Get the sample sample_type sample; // sample(0) = (double)features.bandwidth(); // sample(1) = (double)features.contentType(); for(int i = 0; i < FEATURE_SET_NUM_FEATURES; i++) sample(i) = features.getFeatureByIndex((FeatureSetIndexType) i); //If the user only has one label ever applied then the cross validation will fail; //we can safely predict that this will be their label return m_one_class_only ? m_single_class_val : m_decision_function(sample); }