示例#1
0
Image PatchPCA::apply(Window im, float sigma, int newChannels) {
    
    int patchSize = ((int)(sigma*6+1)) | 1;

    printf("Using %dx%d patches\n", patchSize, patchSize);

    vector<float> mask(patchSize);
    float sum = 0;
    printf("Gaussian mask: ");
    for (int i = 0; i < patchSize; i++) {
        mask[i] = expf(-(i-patchSize/2)*(i - patchSize/2)/(2*sigma*sigma));
        sum += mask[i];
        printf("%f ", mask[i]);
    }
    for (int i = 0; i < patchSize; i++) mask[i] /= sum;
    printf("\n");

    vector<float> vec(patchSize*patchSize*im.channels);

    Eigenvectors e(patchSize*patchSize*im.channels, newChannels);
    for (int iter = 0; iter < min(20000, im.width*im.height*im.frames); iter++) {
        int t = randomInt(0, im.frames-1);
        int x = randomInt(patchSize/2, im.width-1-patchSize/2);
        int y = randomInt(patchSize/2, im.height-1-patchSize/2);
        float *imPtr = im(x, y, t);
        int j = 0;
        for (int dy = -patchSize/2; dy <= patchSize/2; dy++) {
            for (int dx = -patchSize/2; dx <= patchSize/2; dx++) {
                for (int c = 0; c < im.channels; c++) {
                    vec[j] = (mask[dx+patchSize/2]*
                              mask[dy+patchSize/2]*
                              imPtr[dy*im.ystride + dx*im.xstride + c]);
                    j++;
                }
            }
        }
        e.add(&vec[0]);
    }

    e.compute();

    Image filters(patchSize, patchSize, 1, im.channels * newChannels);
    
    for (int i = 0; i < newChannels; i++) {
        e.getEigenvector(i, &vec[0]);
        int j = 0;
        for (int y = 0; y < patchSize; y++) {
            for (int x = 0; x < patchSize; x++) {
                for (int c = 0; c < im.channels; c++) {
                    filters(x, y)[i*im.channels+c] = vec[j];
                    j++;
                }
            }
        }
    }

    return filters;
}
示例#2
0
void AssExportFilterChain::Register(std::unique_ptr<AssExportFilter>&& filter) {
    int filter_copy = 1;
    std::string name = filter->name;
    // Find a unique name
    while (GetFilter(name))
        name = str(boost::format("%s (%d)") % filter->name % filter_copy++);

    filter->name = name;

    // Look for place to insert
    auto begin(filters().begin()), end(filters().end());
    while (begin != end && begin->priority >= filter->priority) ++begin;
    filters().insert(begin, *filter.release());
}
void QMFStorePrivate::processFilters(const QMailMessageIdList &ids, void (QMFStorePrivate::*signal)(const QMessageId &, const QMessageManager::NotificationFilterIdSet &))
{
    QMap<QMailMessageId, QMessageManager::NotificationFilterIdSet> matches;

    // Copy the filter map to protect against modification during traversal
    QMap<QMessageManager::NotificationFilterId, QMailMessageKey> filters(_filters);
    QMap<QMessageManager::NotificationFilterId, QMailMessageKey>::const_iterator it = filters.begin(), end = filters.end();
    for ( ; it != end; ++it) {
	const QMailMessageKey &key(it.value());

	QSet<QMailMessageId> filteredIds;
	if (!key.isEmpty()) {
	    // Empty key matches all messages; otherwise get the filtered set
	    filteredIds = QMailStore::instance()->queryMessages(key).toSet();
	}

	foreach (const QMailMessageId &id, ids) {
	    if (key.isEmpty() || filteredIds.contains(id)) {
		matches[id].insert(it.key());
	    }
	}
    }

    QMap<QMailMessageId, QMessageManager::NotificationFilterIdSet>::const_iterator mit = matches.begin(), mend = matches.end();
    for ( ; mit != mend; ++mit) {
	emit (this->*signal)(QmfHelpers::convert(mit.key()), mit.value());
    }
}
示例#4
0
AssExportFilter *AssExportFilterChain::GetFilter(std::string const& name) {
    for (auto& filter : filters()) {
        if (filter.name == name)
            return &filter;
    }
    return nullptr;
}
 inline void imageResizeVertical(float * output, float const * input,
                                 size_t outputHeight,
                                 size_t height, size_t width, size_t depth,
                                 size_t cropHeight,
                                 size_t cropOffset,
                                 bool flip = false,
                                 vl::impl::ImageResizeFilter::FilterType filterType = vl::impl::ImageResizeFilter::kBilinear)
 {
   ImageResizeFilter filters(outputHeight, height, cropHeight, cropOffset, filterType) ;
   int filterSize = filters.filterSize ;
   for (int d = 0 ; d < (int)depth ; ++d) {
     for (int x = 0 ; x < (int)width ; ++x) {
       for (int y = 0 ; y < (int)outputHeight ; ++y) {
         float z = 0 ;
         int begin = filters.starts[y] ;
         float const * weights = filters.weights + filterSize * y ;
         for (int k = begin ; k < begin + filterSize ; ++k) {
           float w = *weights++ ;
           if (w == 0.f) break ;
           //if ((0 <= k) & (k < (signed)height)) {
             z += input[k] * w ;
           //}
         }
         if (!flip) {
           output[x + y * width] = z ; // transpose
         } else {
           output[x + ((int)outputHeight - 1 - y) * width] = z ; // flip and transpose
         }
       }
       input += height ;
     }
     output += outputHeight * width ;
   }
 }
示例#6
0
int
LogStream::resetFilters ()
{
  list<string> filters (fc->getFilters ());
  fc->clearAllFilters ();
  return ff->chain (fc, filters, out, &nbw);
}
示例#7
0
void Viewer::cb_Save()
{
	std::string filters("all (*.*);; map (*.map);; off (*.off);; ply (*.ply)") ;
	std::string filename = selectFileSave("Save Mesh", "", filters) ;

	exportMesh(filename) ;
}
示例#8
0
void CTextInput::keyPressed( const SDL_KeyboardEvent & key )
{
	if(!focus || key.state != SDL_PRESSED)
		return;

	if(key.keysym.sym == SDLK_TAB)
	{
		moveFocus();
		GH.breakEventHandling();
		return;
	}

	std::string oldText = text;
	switch(key.keysym.sym)
	{
	case SDLK_BACKSPACE:
		if(!text.empty())
			text.resize(text.size()-1);
		break;
	default:
		if (key.keysym.unicode < ' ')
			return;
		else
			text += key.keysym.unicode; //TODO 16-/>8
		break;
	}

	filters(text, oldText);
	if (text != oldText)
	{
		redraw();
		cb(text);
	}
}
示例#9
0
void Reportes::guardarAngulosEnArchivo(QVector<Angulo*> listaAngulos)
{
    QString selectedFilter;
    QString filters(tr("CSV (*.csv);;Archivo de Texto (*.txt)"));
    QString fileName = QFileDialog::getSaveFileName(0, tr("Guardar el Archivo"),"",filters,&selectedFilter);

    if (fileName != ""){
        QFile file(fileName);
        file.remove();
        if (file.open(QIODevice::Append)){
            QTextStream stream(&file);
            foreach (Angulo *var, listaAngulos){
                if(selectedFilter.contains("txt")){
                    /*stream <<"Tiempo: " << QString::number(var->getTiempo()) << " X: " << QString::number(var->getAnguloX())
                           << " Y: " << QString::number(var->getAnguloY()) << endl;*/
                    stream <<QString::number(var->getTiempo(),'f',presicion) << " " << QString::number(var->getAngulo1())
                           <<" " << QString::number(var->getAngulo2()) << endl;
                }
                if(selectedFilter.contains("csv")){
                    stream <<QString::number(var->getTiempo(),'f',presicion) << "," << QString::number(var->getAngulo1())
                           <<"," << QString::number(var->getAngulo2()) << endl;
                }
            }
            file.flush();
            file.close();
        }
示例#10
0
void DigestFile(const char *filename)
{
	SHA1 sha;
	RIPEMD160 ripemd;
	SHA256 sha256;
	Tiger tiger;
	SHA512 sha512;
	Whirlpool whirlpool;
	vector_member_ptrs<HashFilter> filters(6);
	filters[0].reset(new HashFilter(sha));
	filters[1].reset(new HashFilter(ripemd));
	filters[2].reset(new HashFilter(tiger));
	filters[3].reset(new HashFilter(sha256));
	filters[4].reset(new HashFilter(sha512));
	filters[5].reset(new HashFilter(whirlpool));

	auto_ptr<ChannelSwitch> channelSwitch(new ChannelSwitch);
	size_t i;
	for (i=0; i<filters.size(); i++)
		channelSwitch->AddDefaultRoute(*filters[i]);
	FileSource(filename, true, channelSwitch.release());

	HexEncoder encoder(new FileSink(cout), false);
	for (i=0; i<filters.size(); i++)
	{
		cout << filters[i]->AlgorithmName() << ": ";
		filters[i]->TransferTo(encoder);
		cout << "\n";
	}
}
// TestFunction
//------------------------------------------------------------------------------
void TestProjectGeneration::TestFunction() const
{
	AStackString<> project( "../../../../ftmp/Test/ProjectGeneration/testproj.vcxproj" );
	AStackString<> solution( "../../../../ftmp/Test/ProjectGeneration/testsln.sln" );
	AStackString<> filters( "../../../../ftmp/Test/ProjectGeneration/testproj.vcxproj.filters" );
	EnsureFileDoesNotExist( project );
	EnsureFileDoesNotExist( solution );
	EnsureFileDoesNotExist( filters );

	FBuildOptions options;
	options.m_ConfigFile = "Data/TestProjectGeneration/fbuild.bff";
	options.m_ForceCleanBuild = true;
	options.m_ShowSummary = true; // required to generate stats for node count checks
	FBuild fBuild( options );
	TEST_ASSERT( fBuild.Initialize() );

	TEST_ASSERT( fBuild.Build( AStackString<>( "TestSln" ) ) );
	TEST_ASSERT( fBuild.SaveDependencyGraph( "../../../../ftmp/Test/ProjectGeneration/fbuild.fdb" ) );

	EnsureFileExists( project );
	EnsureFileExists( solution );
	EnsureFileExists( filters );

	// Check stats
	//				 Seen,	Built,	Type
	CheckStatsNode ( 1,		1,		Node::DIRECTORY_LIST_NODE );
	CheckStatsNode ( 1,		1,		Node::VCXPROJECT_NODE );
	CheckStatsNode ( 1,		1,		Node::SLN_NODE );
	CheckStatsNode ( 1,		1,		Node::ALIAS_NODE );
	CheckStatsTotal( 4,		4 );
}
示例#12
0
void WebGraphicsLayer::syncFilters()
{
    if (!m_shouldSyncFilters)
        return;
    m_shouldSyncFilters = false;
    m_webGraphicsLayerClient->syncLayerFilters(m_id, filters());
}
示例#13
0
bool WebGraphicsLayer::setFilters(const FilterOperations& newFilters)
{
    if (filters() == newFilters)
        return true;
    didChangeFilters();
    return GraphicsLayer::setFilters(newFilters);
}
示例#14
0
QString FileNaming::fileName(const QString& path, const QString& suffix, const Type& type) {
  FileIndex::Type indexType = (FileIndex::Type) type;

  if (!m_settings) {
    qmlInfo(this) << "settings has not been set";
    return QString();
  }

  if (suffix.isEmpty()) {
    qmlInfo(this) << "called with empty suffix";
    return QString();
  }

  if (path.isEmpty()) {
    qmlInfo(this) << "called with empty path";
    return QString();
  }

  QString date = m_fileNamingInUtc ?
    QDateTime::currentDateTime().toUTC().date().toString("yyyyMMdd") :
    QDateTime::currentDateTime().date().toString("yyyyMMdd");
  QDir dir(path);

  // index is the last used index
  int index = 0;

  if (m_index->stamp(indexType) != date) {
    m_index->setStamp(indexType, date);
  }
  else {
    index = m_index->counter(indexType);
  }

  if (index == 0) {
    QStringList filters(QString("*%1_*").arg(date));
    QStringList entries = dir.entryList(filters, QDir::Files, QDir::Name);
    if (!entries.isEmpty()) {
      QString name = QFile(entries.last()).fileName();
      index = name.section('_', 1, 1).section('.', 0, 0).toInt();
    }
  }

  while (index < INT_MAX) {
    ++index;

    QString name = QString("%1%2_%3.%4")
      .arg(path).arg(date).arg(QString().sprintf("%03i", index)).arg(suffix);

    if (!QFile(name).exists()) {
      m_index->setCounter(indexType, index);
      return name;
    }

  }

  qmlInfo(this) << "Failed to guess a file name";

  return QString();
}
示例#15
0
/** Overloaded function that only computes intermediate results in \c currentIV not final ones. */
ALWAYSINLINE static void filters(IntermediateValues& currentIV, const IntermediateValues& previousIV,
                                 __m128i imgL, __m128i img, __m128i imgR)
{
  // Call \c filters with dummy variables. Compiler will optimize unnecessary computations out.
  __m128i sobelX, sobelY, gaussI;
  __m128 gaussI2A, gaussI2B;
  filters(currentIV, previousIV, sobelX, sobelY, gaussI, gaussI2A, gaussI2B, imgL, img, imgR);
}
示例#16
0
文件: main.cpp 项目: marek-g/Sigil
static void file_open()
{
    const QMap<QString, QString> load_filters = MainWindow::GetLoadFiltersMap();
    QStringList filters(load_filters.values());
    filters.removeDuplicates();
    QString filter_string = "";
    foreach(QString filter, filters) {
        filter_string += filter + ";;";
    }
void CMainWindow::on_OpenFile()
{
	//QString filters("ive files (*.ive);;osg files (*.osg);;osgb files (*.osgb);;obj files (*.obj);;3ds files (*.3ds);;dae files (*.dae);;fbx files (*.fbx);;all files (*.*)");
	QString filters("osgb files (*.osgb);;ive files (*.ive);;osg files (*.osg);;all files (*.*)");
	QString filename = QFileDialog::getOpenFileName(0,QString::fromLocal8Bit("Export"),"./",filters);
	if(filename == "") return;
	g_pRoot->removeChild(0,g_pRoot->getNumChildren());
	osg::ref_ptr<osg::Node> node = osgDB::readNodeFile(filename.toLocal8Bit().data());
	g_pRoot->addChild(node.get());
}
示例#18
0
void Viewer::cb_Open()
{
	std::string filters("all (*.*);; trian (*.trian);; ctm (*.ctm);; off (*.off);; ply (*.ply)") ;
	std::string filename = selectFile("Open Mesh", "", filters) ;
	if (filename.empty())
		return ;

	importMesh(filename) ;
	updateGL() ;
}
示例#19
0
//-----------------------------------------------------------------------------
ctkPathLineEdit::ctkPathLineEdit(QWidget *parentWidget)
  : QWidget(parentWidget)
  , d_ptr(new ctkPathLineEditPrivate(*this))
{
  Q_D(ctkPathLineEdit);
  d->init();

  this->setNameFilters(nameFilters());
  this->setFilters(filters());
}
示例#20
0
/*!
    Read current path and filters from settings and apply it for UI dock
*/
void FileBrowser::restoreSettings()
{
    if ( mDock )
    {
        mDock->setCurrentPath( path() );
        mDock->setCurrentFilePath( filePath() );
        mDock->setFilters( filters() );
        mDock->setBookmarks( bookmarks() );
    }
}
示例#21
0
bool QFSFileEngineIterator::hasNext() const
{
    if (!done && !nativeIterator) {
        nativeIterator.reset(new QFileSystemIterator(QFileSystemEntry(path()),
                    filters(), nameFilters()));
        advance();
    }

    return !done;
}
示例#22
0
void ParseFile::parseDirectory(QString const& filePath, QString const& filter)
{
   QDir dir(filePath);

   QStringList list;
   if (filter.isEmpty()) {
      m_name = dir.dirName();
      list << dir.dirName() + ".*";
   }else {
      m_name = filter;
      list << filter + ".*";
   }
   dir.setNameFilters(list);

   QDir::Filters filters(QDir::Files | QDir::Readable);
   m_filePaths << dir.entryList(filters);

   if (m_filePaths.isEmpty()) {
      // look for the first output file
      list.clear();
      list << "*.out";
      dir.setNameFilters(list);
      m_filePaths << dir.entryList(filters);
      if (m_filePaths.isEmpty()) return;

      QFileInfo info(m_filePaths.first());
      m_name = info.completeBaseName();
      m_filePaths.clear();
      list.clear();
      
      list << m_name + ".*";
      dir.setNameFilters(list);
      m_filePaths << dir.entryList(filters);
      if (m_filePaths.isEmpty()) return;
   }

   qDebug() << "FilePath: " << m_filePath;
   qDebug() << "FilePaths:" << m_filePaths;

//  ---
   // This is a hack to ensure the .out file gets read before the other files
   //qDebug() << "Reversing directory file order";

   QStringList filePaths;
   for (int i = 0; i < m_filePaths.size(); ++i) {
       filePaths.prepend(m_filePaths[i]);
   }
   m_filePaths = filePaths;
//  ---

   QStringList::iterator iter;
   for (iter = m_filePaths.begin(); iter != m_filePaths.end(); ++iter) {
       (*iter).prepend(m_filePath + "/");
   }
}
示例#23
0
 std::vector<T> getFilters() const {
   std::vector<T> result;
   std::vector<FilterClause> candidates = filters();
   for (std::vector<FilterClause>::const_iterator it = candidates.begin(), 
        itEnd = candidates.end(); it != itEnd; ++it) 
   {
     boost::optional<T> oFilter = it->optionalCast<T>();
     if (oFilter) { result.push_back(*oFilter); }
   }
   return result;
 }
示例#24
0
QString Controls::populateModelMenu()
{
    QString first;
    QMenu *menu = m_ui->menuModels;
    QStringList searchDirs;
    searchDirs << ":/" << "./";
    QStringList::const_iterator it = searchDirs.begin();
    for ( ; it != searchDirs.end(); ++it)
    {
        if (it != searchDirs.begin())
            menu->addSeparator();
        QDir modelDir(*it);
        QStringList filters("*.3ds");
        modelDir.setNameFilters(filters);
        QStringList models = modelDir.entryList();
        QStringList::const_iterator mit = models.begin();
        for ( ; mit != models.end(); ++mit)
        {
            QString name = *mit;
            name.prepend(*it);
            first = name;
            QAction *act = new QAction(name, this);
            menu->addAction(act);
            QObject::connect(act, SIGNAL(triggered()),
                             this, SLOT(load()));
        }
    }
    QString cmdlineModel;
    QSettings settings;
    settings.beginGroup("General");
    cmdlineModel = settings.value("LastModel").toString();
    QStringList args = qApp->arguments();
    int ix = args.indexOf(QLatin1String("--model"));
    if (ix == -1)
        ix = args.indexOf(QLatin1String("-model"));
    if (ix == -1)
        ix = args.indexOf(QLatin1String("-m"));
    if (ix != -1)
    {
        int mdlIx = ix + 1;
        if (args.count() == mdlIx)
            qWarning("%s requires a string with the model file path", qPrintable(args[ix]));
        else
            cmdlineModel = args[mdlIx];
    }
    if (!cmdlineModel.isEmpty())
    {
        if (QFile::exists(cmdlineModel))
            return cmdlineModel;
        else
            qWarning("%s model file could not be found", qPrintable(cmdlineModel));
    }
    return first;
}
bool CoordinatedGraphicsLayer::setFilters(const FilterOperations& newFilters)
{
    if (filters() == newFilters)
        return true;

    if (!GraphicsLayer::setFilters(newFilters))
        return false;

    didChangeFilters();
    return true;
}
示例#26
0
文件: FiltersMenu.cpp 项目: KDE/apper
FiltersMenu::~FiltersMenu()
{
    KConfig config("apper");
    KConfigGroup filterMenuGroup(&config, "FilterMenu");

    // For usability we will only save ViewInGroups settings and Newest filter,
    // - The user might get angry when he does not find any packages because he didn't
    //   see that a filter is set by config

    // This entry does not depend on the backend it's ok to call this pointer
//     filterMenuGroup.writeEntry("ViewInGroups", m_filtersMenu->actionGrouped());

    // This entry does not depend on the backend it's ok to call this pointer
    filterMenuGroup.writeEntry("FilterNewest",
                               static_cast<bool>(filters() & Transaction::FilterNewest));
    // This entry does not depend on the backend it's ok to call this pointer
    filterMenuGroup.writeEntry("FilterNative",
                               static_cast<bool>(filters() & Transaction::FilterArch));
#ifdef HAVE_APPSTREAM
    filterMenuGroup.writeEntry("HidePackages", m_applications->isChecked());
#endif // HAVE_APPSTREAM
}
示例#27
0
void Reportes::guardarImagenGrafico(QCustomPlot *grafico, int ancho, int alto)
{
    QString filters("Imagen PNG (*.png);;Imagen JPG (*.jpg);;Archivo PDF (*.pdf)");
    QString selectedFilter;
    QString fileName = QFileDialog::getSaveFileName(0, "Guardar Imagen","",filters,&selectedFilter);

    if(selectedFilter.contains("PNG"))
        grafico->savePng(fileName,ancho,alto);
    if(selectedFilter.contains("JPG"))
       grafico->saveJpg(fileName,ancho,alto);
    if(selectedFilter.contains("PDF"))
      grafico->savePdf(fileName,false,ancho,alto);
}
示例#28
0
文件: pipeline.cpp 项目: foolab/aura
QString Pipeline::nextFileName()
{
    QString date = QDate::currentDate().toString("yyMMdd");

    QDir dir(APP_FOLDER);
    QStringList filters(QString("*%1*").arg(date));
    dir.setNameFilters(filters);
    int index = dir.count() + 1;

    QString filename(APP_FOLDER);
    filename += QDir::separator() + QString("%1_%2.%3").arg(date).arg(index).arg(FILE_SUFFIX);
    return filename;
}
示例#29
0
QList<QTreeWidgetItem*> FragmentTable::loadFragments(QDir const& dir, QTreeWidgetItem* parent)
{
   QList<QTreeWidgetItem*> items;
   QTreeWidgetItem* item;
   QDir::Filters filters(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot | QDir::Readable);
   QStringList contents(dir.entryList(filters, QDir::DirsLast));

   QStringList::iterator iter;
   for (iter = contents.begin(); iter != contents.end(); ++iter) {
       QFileInfo info(dir, *iter);
       QString name(*iter);
       name = name.replace(".efp", " ", Qt::CaseInsensitive);
       name = name.replace(".xyz", " ", Qt::CaseInsensitive);
       name = name.replace("_L", " (L)");
       name = name.replace("_", " ");
 
       if (info.isDir()) {
          if (parent == 0) {
             item = new QTreeWidgetItem(QStringList(name));
             loadFragments(QDir(info.filePath()), item);
             items.append(item);
          }else {
             item = new QTreeWidgetItem(parent, QStringList(name));
          }
          item->setData(0, s_fileRole, s_invalidFile);
          item->setData(0, s_imageRole, s_invalidFile);

       }else if (info.suffix().contains("efp", Qt::CaseInsensitive) ||
                 info.suffix().contains("xyz", Qt::CaseInsensitive) ) {

          if (parent == 0) {
             item = new QTreeWidgetItem(QStringList(name));
             items.append(item);
          }else {
             item = new QTreeWidgetItem(parent, QStringList(name));
          }

          item->setData(0, s_fileRole, info.filePath());
          item->setData(0, s_imageRole, s_invalidFile);
          info.setFile(dir, info.completeBaseName() + ".png");

          if (info.exists()) {
              item->setData(0, s_imageRole, info.filePath());
          }else {
              QLOG_DEBUG() << "Image file not found:" << info.filePath();
          }
       }
   }
   return items;
}
示例#30
0
/** \returns the equivalent of the string passed in
 *  although any brace expressions are expanded.
 *  (E.g. "*.{png,jpg}" -> "*.png *.jpg")
 */
QStringList fileFilters(QString const & desc)
{
	// we have: "*.{gif,png,jpg,bmp,pbm,ppm,tga,tif,xpm,xbm}"
	// but need:  "*.cpp;*.cc;*.C;*.cxx;*.c++"
	FileFilterList filters(qstring_to_ucs4(desc));
	//LYXERR0("DESC: " << desc);
	QStringList list;
	for (size_t i = 0; i != filters.filters_.size(); ++i) {
		QString f = filters.filters_[i].toString();
		//LYXERR0("FILTER: " << f);
		list.append(f);
	}
	return list;
}