QString toListViewFormatterText::getFormattedString(toExportSettings &settings,
        //const toResultModel *model);
        const QAbstractItemModel * model)
{
    int     columns   = model->columnCount();
    int     rows      = model->rowCount();

    QString output;
    QVector<int> sizes(columns);

    QVector<int> rlist = selectedRows(settings.selected);
    QVector<int> clist = selectedColumns(settings.selected);

    // must get widest length for each column
    // zero array or (if writing headers, set their size)
    for (int i = 0; i < columns - 1; i++)
    {
        if (settings.columnsHeader)
        {
            if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(i))
                continue;
            sizes[i] = model->headerData(
                           i,
                           Qt::Horizontal,
                           Qt::DisplayRole).toString().length();
        }
        else
            sizes[i] = 0;
    }
    sizes[columns - 1] = 1;

    // loop through model and get column widths
    QModelIndex mi;
    for (int row = 0; row < rows; row++)
    {
        for (int column = 0; column < columns - 1; column++)
        {
            if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(column))
                continue;
            if (!settings.rowsHeader && column == 0)
                continue;

            mi = model->index(row, column);
            QVariant data = model->data(mi, Qt::EditRole);
            QString v;
            if (data.isNull())
                v = "{null}";
            else
                v = data.toString();

            int len = v.length();
            if (len > sizes[column])
                sizes[column] = len;
        }
    }

    // write header data to fixed widths
    if (settings.columnsHeader)
    {
        for (int column = 0; column < columns; column++)
        {
            if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(column))
                continue;
            if (!settings.rowsHeader && column == 0)
                continue;
            QString value = model->headerData(
                                column,
                                Qt::Horizontal,
                                Qt::DisplayRole).toString();

            output += value;
            for (int left = value.length(); left <= sizes[column]; left++)
                output += ' ';
        }

        endLine(output);

        // write ==== border
        for (int column = 0; column < columns; column++)
        {
            if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(column))
                continue;
            if (!settings.rowsHeader && column == 0)
                continue;
            for (int left = 0; left < sizes[column]; left++)
                output += '=';
            output += ' ';
        }

        endLine(output);
    }

    // write data
    for (int row = 0; row < rows; row++)
    {
        if (settings.rowsExport == toExportSettings::RowsSelected && !rlist.contains(row))
            continue;

        for (int column = 0; column < columns; column++)
        {
            if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(column))
                continue;
            if (!settings.rowsHeader && column == 0)
                continue;
            mi = model->index(row, column);
            QVariant data = model->data(mi, Qt::EditRole);
            QString value;
            if (data.isNull())
                value = "{null}";
            else
                value = data.toString();

            output += value;
            for (int left = value.length(); left <= sizes[column]; left++)
                output += ' ';
        }

        endLine(output);
    }

    return output;
}
Ejemplo n.º 2
0
static inline QVector<QString> names(QVector<Node> nodes) {
  QVector<QString> names;
  for (const Node &node : nodes)
    names.append(node._name);
  return names;
}
Ejemplo n.º 3
0
/// TODO:名称和路径需要联系起来
// 不能使用QHash ,会出现string相同的情况,那用什么方法呢
// QMultiMap??
void QJDMainWindow::setHomeDir(QString homePath)
{
    areaWidget->clear();

    /// 第一层 -- 工区
    QDir dir1;

    // 这个需要能设置,程序需要有settings.ini
    dir1.setPath(homePath);
    QStringList dirLev1;
    dirLev1<<dir1.entryList(QDir::NoDotAndDotDot|QDir::Dirs);
    //    qDebug()<<dir1.count(); // 包含./..

    /// 第二层 -- 线, 目前要向里面加入data文件夹,data文件夹与flow并列并且继续有往下的选择,可以不用descname
    QStringList areaStringList;
    QStringList areaPathList;
    QStringList lineStringList;
    QStringList linePathList;

    QVector<QStringList> flowStringList;
    QVector<QStringList> flowPathList;

    QVector<QVector<QStringList> > dataStringList;
    QVector<QVector<QStringList> >  dataPathList;
    for(int i=0; i<dirLev1.count(); i++)
    {
        // 遍历
        QDir dir2;
        QString dir2path=dir1.path()+"/"+dirLev1.at(i);
        dir2.setPath(dir2path);
        QStringList dirLev2;
        dirLev2=dir2.entryList(QDir::NoDotAndDotDot|QDir::Dirs);

        // 解析 DescName -- 工区名称
        QFile file2;
        file2.setFileName(dir2path+"/DescName");
        if(!file2.exists())
        {
            continue;
        }
        areaPathList<<dir2path;

        file2.open(QFile::ReadOnly);
        QTextStream stream2(&file2);
        QString areatmp=stream2.readAll();
        areatmp.chop(1);
        areaStringList<<areatmp;   // 路径就是dir2path
        //        qDebug()<<dir2path;
        file2.close();

        /// 第三层 -- 流程/Data, 同一层的data文件夹需要特殊处理
        for(int j=0; j<dirLev2.count(); j++)
        {
            QDir dir3;
            QString dir3path=dir2.path()+"/"+dirLev2.at(j);
            dir3.setPath(dir3path);
            QStringList dirLev3;
            dirLev3=dir3.entryList(QDir::NoDotAndDotDot|QDir::Dirs);  // 线名

            // 解析 DescName -- 线名称
            QFile file3;
            file3.setFileName(dir3path+"/DescName");
            if(!file3.exists())
            {
                continue;
            }
            linePathList<<dir3path;
            file3.open(QFile::ReadOnly);
            QTextStream stream3(&file3);
            QString linetmp=stream3.readAll();
            linetmp.chop(1);
            lineStringList<<linetmp;
            file3.close();
            //            qDebug()<<"line::"<<lineStringList;

            /// 第四层 -- 具体流程
            flowStringList.resize(dirLev2.count());
            flowPathList.resize(dirLev2.count());
            dataStringList.resize(dirLev2.count());
            dataPathList.resize(dirLev2.count());
            for(int k=0; k<dirLev3.count(); k++)
            {
                // 应当没有文件夹了,只剩下文件了
                QDir dir4;
                QString dir4path=dir3.path()+"/"+dirLev3.at(k);
                dir4.setPath(dir4path);
                QStringList dirLev4;
                dirLev4=dir4.entryList(QDir::NoDotAndDotDot|QDir::Files);  // 文件名列表了
                flowPathList[j]<<dir4path;
                /// 底下应当有个记录流程xml文件

                // 解析 DescName -- 线名称
                QFile file4;
                file4.setFileName(dir4path+"/DescName");
                if(!file4.exists())
                {
                    continue;
                }
                file4.open(QFile::ReadOnly);
                QTextStream stream4(&file4);
                QString flowtmp=stream4.readAll();
                flowtmp.chop(1);
                flowStringList[j]<<flowtmp;  // 只有在流程里才会有,其他的文件夹内不会有这个
                file4.close();
                //                qDebug()<<"flow::"<<flowStringList;

                /// 第五层 -- 数据存放,不应当再像前面一样完全扫描了.需要列出文件类型目录即可
                //! !! 如何准确放到某条线下面去,每条线都有,目前还是没有解决这个问题
                // 也就是说需要二维数组来确定
                if(flowtmp=="Data")
                {
                    dataStringList[j].resize(dirLev3.count());
                    dataPathList[j].resize(dirLev3.count());
                    for(int l=0; l<dirLev4.count(); l++)
                    {
                        // 应当没有文件夹了,只剩下文件了
                        QDir dir5;
                        dir5.setPath(dir4.path());
                        QStringList dirLev5;
                        dirLev5=dir5.entryList(QDir::NoDotAndDotDot|QDir::AllDirs);  // 文件名列表了
                        //                        qDebug()<<dir4.path()<<"dirLev5::"<<dirLev5;  // 怎么是空的??
                        dataStringList[j][k].append(dirLev5);
                        /// 底下应当有个记录流程xml文件

                        for(int m=0; m<dirLev5.size(); m++)
                        {
                            QString dataPath=dir4.path()+"/"+dirLev5.at(m);
                            dataPathList[j][k].append(dataPath);
                        }
                    }
                    // dataString为空 path为data descName的path
                    //                    qDebug()<<"!!!!!!!!!!!!!!!!!!!!!!!!!!"<<dirLev4.count()<<dataStringList;
                }
            }
        }
        //        qDebug()<<"\nstart set:::"<<areaStringList.at(i)<<lineStringList<<flowStringList;
        //        qDebug()<<"Data:::"<<dataStringList;

        setAreaWidget(areaStringList.at(i),areaPathList.at(i),lineStringList,
                      linePathList,flowStringList,flowPathList,dataStringList,dataPathList);

        /// 清理
        flowStringList.clear();
        flowPathList.clear();
        lineStringList.clear();
        linePathList.clear();
        dataStringList.clear();
        dataPathList.clear();
    }

    if(!areaStringList.isEmpty())
    {
        //        qDebug()<<areaWidget->topLevelItem(0)->text(0);
        areaWidget->setCurrentItem(areaWidget->topLevelItem(0));
        areaWidget->returnPath(areaWidget->currentItem(),areaWidget->currentColumn());
    }
}
Ejemplo n.º 4
0
void SerialConnection::open() {
    QString status_msg = "connected.";
    QString theport = portname;
    if (context != NULL) {
        close();
    }

    if (theport.length() == 0) {
        QVector<QString> ports = enumerate();
        if (ports.size() > 0) {
            theport = ports[0];
        } else {
            emit status("no serial port found");
            return;
        }
    }

#ifdef _WIN32
    HANDLE handle = CreateFile(theport.toStdWString().c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    DCB dcbSerialParams = {0};

    if (handle == INVALID_HANDLE_VALUE) {
        status_msg = QString("unable to open %1. check if device is already in use.").arg(theport);
    } else if (!GetCommState(handle, &dcbSerialParams)) {
        status_msg = QString("unable to get device attributes");
    } else {
        //Define serial connection parameters for the arduino board
        dcbSerialParams.BaudRate=CBR_38400;
        dcbSerialParams.ByteSize=8;
        dcbSerialParams.StopBits=ONESTOPBIT;
        dcbSerialParams.Parity=NOPARITY;

        //Set the parameters and check for their proper application
        if(!SetCommState(handle, &dcbSerialParams))
            status_msg = QString("unable to set device attributes");
        else {
            context = new HANDLE(handle);
        }
    }
#else
    int fd = ::open(theport.toStdString().c_str(), O_RDWR | O_NOCTTY | O_NONBLOCK);
    struct termios toptions;

    if (fd == -1) {
        status_msg = QString("unable to open %1. check if device is already in use.").arg(theport);
    } else if (ioctl(fd, TIOCEXCL) == -1) {
        status_msg = QString("unable to get exclusive access");
    } else if (fcntl(fd, F_SETFL, 0) == -1) {
        status_msg = QString("unable to restore blocking access");
    } else if (tcgetattr(fd, &toptions) < 0) { 
        status_msg = QString("unable to get device attributes");
    } else {
        cfsetispeed(&toptions, B38400);
        cfsetospeed(&toptions, B38400);

        // 8N1
        toptions.c_cflag &= ~PARENB;
        toptions.c_cflag &= ~CSTOPB;
        toptions.c_cflag &= ~CSIZE;
        toptions.c_cflag |= CS8;
        // no flow control
        toptions.c_cflag &= ~CRTSCTS;

        //toptions.c_cflag &= ~HUPCL; // disable hang-up-on-close to avoid reset

        toptions.c_cflag |= CREAD | CLOCAL;  // turn on READ & ignore ctrl lines
        toptions.c_iflag &= ~(IXON | IXOFF | IXANY); // turn off s/w flow ctrl

        toptions.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // make raw
        toptions.c_oflag &= ~OPOST; // make raw

        // see: http://unixwiz.net/techtips/termios-vmin-vtime.html
        toptions.c_cc[VMIN]  = 0;
        toptions.c_cc[VTIME] = 0;
    
        tcsetattr(fd, TCSANOW, &toptions);
        if (tcsetattr(fd, TCSAFLUSH, &toptions) < 0) {
            status_msg = QString("unable to set device attributes");
        } else {
            tcflush(fd, TCIOFLUSH);
            context = new int(fd);
        }
    }
#endif
    emit status(status_msg);
}
Ejemplo n.º 5
0
void TraceLoader::parseTrace()
{
    QList<ApiTraceFrame*> frames;
    ApiTraceFrame *currentFrame = 0;
    int frameCount = 0;
    QStack<ApiTraceCall*> groups;
    QVector<ApiTraceCall*> topLevelItems;
    QVector<ApiTraceCall*> allCalls;
    quint64 binaryDataSize = 0;

    int lastPercentReport = 0;

    trace::Call *call = m_parser.parse_call();
    while (call) {
        //std::cout << *call;
        if (!currentFrame) {
            currentFrame = new ApiTraceFrame();
            currentFrame->number = frameCount;
            ++frameCount;
        }
        ApiTraceCall *apiCall =
            apiCallFromTraceCall(call, m_helpHash, currentFrame, groups.isEmpty() ? 0 : groups.top(), this);
        allCalls.append(apiCall);
        if (groups.count() == 0) {
            topLevelItems.append(apiCall);
        }
        if (call->flags & trace::CALL_FLAG_MARKER_PUSH) {
            groups.push(apiCall);
        } else if (call->flags & trace::CALL_FLAG_MARKER_POP) {
            groups.top()->finishedAddingChildren();
            groups.pop();
        }
        if (!groups.isEmpty()) {
            groups.top()->addChild(apiCall);
        }
        if (apiCall->hasBinaryData()) {
            QByteArray data =
                apiCall->arguments()[apiCall->binaryDataIndex()].toByteArray();
            binaryDataSize += data.size();
        }
        if (call->flags & trace::CALL_FLAG_END_FRAME) {
            allCalls.squeeze();
            topLevelItems.squeeze();
            if (topLevelItems.count() == allCalls.count()) {
                currentFrame->setCalls(allCalls, allCalls, binaryDataSize);
            } else {
                currentFrame->setCalls(topLevelItems, allCalls, binaryDataSize);
            }
            allCalls.clear();
            groups.clear();
            topLevelItems.clear();
            frames.append(currentFrame);
            currentFrame = 0;
            binaryDataSize = 0;
            if (frames.count() >= FRAMES_TO_CACHE) {
                emit framesLoaded(frames);
                frames.clear();
            }
            if (m_parser.percentRead() - lastPercentReport >= 5) {
                emit parsed(m_parser.percentRead());
                lastPercentReport = m_parser.percentRead();
            }
        }
        delete call;
        call = m_parser.parse_call();
    }

    //last frames won't have markers
    //  it's just a bunch of Delete calls for every object
    //  after the last SwapBuffers
    if (currentFrame) {
        allCalls.squeeze();
        if (topLevelItems.count() == allCalls.count()) {
            currentFrame->setCalls(allCalls, allCalls, binaryDataSize);
        } else {
            currentFrame->setCalls(topLevelItems, allCalls, binaryDataSize);
        }
        frames.append(currentFrame);
        currentFrame = 0;
    }
    if (frames.count()) {
        emit framesLoaded(frames);
    }
}
Ejemplo n.º 6
0
bool QDirIteratorPrivate::matchesFilters(const QString &fileName, const QFileInfo &fi) const
{
    Q_ASSERT(!fileName.isEmpty());

    // filter . and ..?
    const int fileNameSize = fileName.size();
    const bool dotOrDotDot = fileName[0] == QLatin1Char('.')
                             && ((fileNameSize == 1)
                                 ||(fileNameSize == 2 && fileName[1] == QLatin1Char('.')));
    if ((filters & QDir::NoDot) && dotOrDotDot && fileNameSize == 1)
        return false;
    if ((filters & QDir::NoDotDot) && dotOrDotDot && fileNameSize == 2)
        return false;
    if ((filters & QDir::NoDotAndDotDot) && dotOrDotDot) // ### Qt5 remove (NoDotAndDotDot == NoDot|NoDotDot)
        return false;

    // name filter
#ifndef QT_NO_REGEXP
    // Pass all entries through name filters, except dirs if the AllDirs
    if (!nameFilters.isEmpty() && !((filters & QDir::AllDirs) && fi.isDir())) {
        bool matched = false;
        for (QVector<QRegExp>::const_iterator iter = nameRegExps.constBegin(),
                end = nameRegExps.constEnd();
                iter != end; ++iter) {

            if (iter->exactMatch(fileName)) {
                matched = true;
                break;
            }
        }
        if (!matched)
            return false;
    }
#endif
    // skip symlinks
    const bool skipSymlinks = (filters & QDir::NoSymLinks);
    const bool includeSystem = (filters & QDir::System);
    if(skipSymlinks && fi.isSymLink()) {
        // The only reason to save this file is if it is a broken link and we are requesting system files.
        if(!includeSystem || fi.exists())
            return false;
    }

    // filter hidden
    const bool includeHidden = (filters & QDir::Hidden);
    if (!includeHidden && !dotOrDotDot && fi.isHidden())
        return false;

    // filter system files
    if (!includeSystem && (!(fi.isFile() || fi.isDir() || fi.isSymLink())
                           || (!fi.exists() && fi.isSymLink())))
        return false;

    // skip directories
    const bool skipDirs = !(filters & (QDir::Dirs | QDir::AllDirs));
    if (skipDirs && fi.isDir())
        return false;

    // skip files
    const bool skipFiles    = !(filters & QDir::Files);
    if (skipFiles && fi.isFile())
        // Basically we need a reason not to exclude this file otherwise we just eliminate it.
        return false;

    // filter permissions
    const bool filterPermissions = ((filters & QDir::PermissionMask)
                                    && (filters & QDir::PermissionMask) != QDir::PermissionMask);
    const bool doWritable = !filterPermissions || (filters & QDir::Writable);
    const bool doExecutable = !filterPermissions || (filters & QDir::Executable);
    const bool doReadable = !filterPermissions || (filters & QDir::Readable);
    if (filterPermissions
            && ((doReadable && !fi.isReadable())
                || (doWritable && !fi.isWritable())
                || (doExecutable && !fi.isExecutable()))) {
        return false;
    }

    return true;
}
Ejemplo n.º 7
0
void OptimizationPasses::Coordinator::init()
{
    static bool isInitialized = false; // STATIC DATA

    if(isInitialized)
        return;

    isInitialized = true;

    /* Note, below is many of the building blocks re-used in several passes
     * in order to reduce memory use. Thus, when changing one building block
     * it potentially affects many passes. */

    /* ****************************************************** */
    /* Rewrite "count(<expr>) ge 1" into "exists(<expr>)" */
    OptimizationPass::ExpressionMarker firstFirstChild;
    firstFirstChild.append(0);
    firstFirstChild.append(0);

    ExpressionIdentifier::List geOpIDs;
    const ExpressionIdentifier::Ptr countFN(new ByIDIdentifier(Expression::IDCountFN));
    geOpIDs.append(countFN);
    geOpIDs.append(ExpressionIdentifier::Ptr(new IntegerIdentifier(1)));

    QVector<Expression::ID> geMatcher;
    geMatcher.append(Expression::IDValueComparison);
    geMatcher.append(Expression::IDGeneralComparison);

    const ExpressionIdentifier::Ptr ge(new ComparisonIdentifier(geMatcher,
                                       AtomicComparator::OperatorGreaterOrEqual));

    const ExpressionCreator::Ptr existsFN(new ByIDCreator(Expression::IDExistsFN));
    const OptimizationPass::Ptr geToExists(new OptimizationPass(ge, geOpIDs, firstFirstChild, existsFN));
    comparisonPasses.append(geToExists);
    /* ****************************************************** */

    /* ****************************************************** */
    /* Rewrite "count(<expr>) gt 0" into "exists(<expr>)" */
    ExpressionIdentifier::List countAndIntZero;
    countAndIntZero.append(countFN);
    const ExpressionIdentifier::Ptr zeroInteger(new IntegerIdentifier(0));
    countAndIntZero.append(zeroInteger);

    const ExpressionIdentifier::Ptr gt(new ComparisonIdentifier(geMatcher,
                                       AtomicComparator::OperatorGreaterThan));

    const OptimizationPass::Ptr gtToExists(new OptimizationPass(gt, countAndIntZero,
                                           firstFirstChild, existsFN));
    comparisonPasses.append(gtToExists);
    /* ****************************************************** */

    /* ****************************************************** */
    /* Rewrite "count(<expr>) ne 0" into "exists(<expr>)" */

    const ExpressionIdentifier::Ptr ne(new ComparisonIdentifier(geMatcher,
                                       AtomicComparator::OperatorNotEqual));
    const OptimizationPass::Ptr neToExists(new OptimizationPass(ne, countAndIntZero, firstFirstChild,
                                           existsFN,
                                           OptimizationPass::AnyOrder));
    comparisonPasses.append(neToExists);
    /* ****************************************************** */

    /* ****************************************************** */
    /* Rewrite "count(<expr>) eq 0" into "empty(<expr>)" */
    ExpressionIdentifier::List eqOpIDs;
    eqOpIDs.append(countFN);
    eqOpIDs.append(zeroInteger);
    const ExpressionCreator::Ptr emptyFN(new ByIDCreator(Expression::IDEmptyFN));
    const ExpressionIdentifier::Ptr eq(new ComparisonIdentifier(geMatcher,
                                       AtomicComparator::OperatorEqual));
    const OptimizationPass::Ptr eqToEmpty(new OptimizationPass(eq, eqOpIDs, firstFirstChild,
                                          emptyFN,
                                          OptimizationPass::AnyOrder));
    comparisonPasses.append(eqToEmpty);

    /* ****************************************************** */

    /* ****************************************************** */
    /* Rewrite "for $var in <expr> return $var" into "<expr>" */
    ExpressionIdentifier::List forOps;
    OptimizationPass::ExpressionMarker firstChild;
    firstChild.append(0);

    forOps.append(ExpressionIdentifier::Ptr());
    forOps.append(ExpressionIdentifier::Ptr(new ByIDIdentifier(Expression::IDRangeVariableReference)));
    const OptimizationPass::Ptr simplifyFor(new OptimizationPass(ExpressionIdentifier::Ptr(), forOps,
                                            firstChild, ExpressionCreator::Ptr()));
    forPasses.append(simplifyFor);
    /* ****************************************************** */

    /* ****************************************************** */
    /* Rewrite "if(<expr>) then true() else false()" to "<expr>" */
    OptimizationPass::ExpressionMarker marker;
    marker.append(0);

    ExpressionIdentifier::List opIDs;
    opIDs.append(ExpressionIdentifier::Ptr(new BySequenceTypeIdentifier(
            CommonSequenceTypes::ExactlyOneBoolean)));
    opIDs.append(ExpressionIdentifier::Ptr(new BooleanIdentifier(true)));
    opIDs.append(ExpressionIdentifier::Ptr(new BooleanIdentifier(false)));

    const OptimizationPass::Ptr pass(new OptimizationPass(ExpressionIdentifier::Ptr(), opIDs, marker));
    ifThenPasses.append(pass);
    /* ****************************************************** */

    /* ****************************************************** */
    /* Rewrite "not(exists(X))" into "empty(X)" */
    ExpressionIdentifier::List idExistsFN;
    idExistsFN.append(ExpressionIdentifier::Ptr(new ByIDIdentifier(Expression::IDExistsFN)));

    notFN.append(OptimizationPass::Ptr(new OptimizationPass(ExpressionIdentifier::Ptr(),
                                       idExistsFN,
                                       firstFirstChild,
                                       emptyFN)));

    /* Rewrite "not(empty(X))" into "exists(X)" */
    ExpressionIdentifier::List idEmptyFN;
    idEmptyFN.append(ExpressionIdentifier::Ptr(new ByIDIdentifier(Expression::IDEmptyFN)));

    notFN.append(OptimizationPass::Ptr(new OptimizationPass(ExpressionIdentifier::Ptr(),
                                       idEmptyFN,
                                       firstFirstChild,
                                       existsFN)));
    /* ****************************************************** */
}
Ejemplo n.º 8
0
QVector<ushort> CryptXOR::crypt(const QVector<ushort> input) {
    QVector<ushort> output = input;
    for (int i = 0; i < input.size(); i++)
        output[i] ^= m_key[i % (sizeof(m_key) / sizeof(char)) ];
    return output;
}
Ejemplo n.º 9
0
QString CryptXOR::toString(QVector<ushort> vector){
    QString result = "";
    for (QVector<ushort>::iterator i = vector.begin();i != vector.end() ;++i)
        result += uchar(*i);
    return result;
}
Ejemplo n.º 10
0
void FuzzySearchImpl::query(const QString &req, QVector<Service::Item *> *res) const
{
	QVector<QString> words;
	for (QString &word : req.split(QRegExp("\\W+"), QString::SkipEmptyParts))
		words.append(word.toLower());
	QVector<QMap<Service::Item *, unsigned int>> resultsPerWord;

	// Quit if there are no words in query
	if (words.empty())
		return;

	// Split the query into words
	for (QString &word : words)
	{
		unsigned int delta = word.size()/3;

		// Get qGrams with counts of this word
		QMap<QString, unsigned int> qGrams;
		QString spaced(_q-1,' ');
		spaced.append(word.toLower());
		for (unsigned int i = 0 ; i < static_cast<unsigned int>(word.size()); ++i)
			++qGrams[spaced.mid(i,_q)];

		// Get the words referenced by each qGram an increment their
		// reference counter
		QMap<QString, unsigned int> wordMatches;
		// Iterate over the set of qgrams in the word
		for (QMap<QString, unsigned int>::const_iterator it = qGrams.cbegin(); it != qGrams.end(); ++it)
		{
			// Iterate over the set of words referenced by this qGram
			for (QMap<QString, unsigned int>::const_iterator wit = _qGramIndex[it.key()].begin(); wit != _qGramIndex[it.key()].cend(); ++wit)
			{
				// CRUCIAL: The match can contain only the commom amount of qGrams
				wordMatches[wit.key()] += (it.value() < wit.value()) ? it.value() : wit.value();
			}
		}

		// Allocate a new set
		resultsPerWord.push_back(QMap<Service::Item *, unsigned int>());
		QMap<Service::Item *, unsigned int>& resultsRef = resultsPerWord.back();

		// Unite the items referenced by the words accumulating their #matches
		for (QMap<QString, unsigned int>::const_iterator wm = wordMatches.begin(); wm != wordMatches.cend(); ++wm)
		{
//			// Do some kind of (cheap) preselection by mathematical bound
//			if (wm.value() < qGrams.size()-delta*_q)
//				continue;

			// Now check the (expensive) prefix edit distance
			if (!checkPrefixEditDistance(word, wm.key(), delta))
				continue;


			for(Service::Item * item: _invertedIndex[wm.key()])
			{
				resultsRef[item] += wm.value();
			}
		}
	}

	// Intersect the set of items references by the (referenced) words
	// This assusmes that there is at least one word (the query would not have
	// been started elsewise)
	QVector<QPair<Service::Item *, unsigned int>> finalResult;
	if (resultsPerWord.size() > 1)
	{
		// Get the smallest list for intersection (performance)
		unsigned int smallest=0;
		for (unsigned int i = 1; i < static_cast<unsigned int>(resultsPerWord.size()); ++i)
			if (resultsPerWord[i].size() < resultsPerWord[smallest].size())
				smallest = i;

		bool allResultsContainEntry;
		for (QMap<Service::Item *, unsigned int>::const_iterator r = resultsPerWord[smallest].begin(); r != resultsPerWord[smallest].cend(); ++r)
		{
			// Check if all results contain this entry
			allResultsContainEntry=true;
			unsigned int accMatches = resultsPerWord[smallest][r.key()];
			for (unsigned int i = 0; i < static_cast<unsigned int>(resultsPerWord.size()); ++i)
			{
				// Ignore itself
				if (i==smallest)
					continue;

				// If it is in: check next relutlist
				if (resultsPerWord[i].contains(r.key()))
				{
					// Accumulate matches
					accMatches += resultsPerWord[i][r.key()];
					continue;
				}

				allResultsContainEntry = false;
				break;
			}

			// If this is not common, check the next entry
			if (!allResultsContainEntry)
				continue;

			// Finally this match is common an can be put into the results
			finalResult.append(QPair<Service::Item *, unsigned int>(r.key(), accMatches));
		}
	}
	else // Else do it without intersction
	{
		for (QMap<Service::Item *, unsigned int>::const_iterator r = resultsPerWord[0].begin(); r != resultsPerWord[0].cend(); ++r)
			finalResult.append(QPair<Service::Item *, unsigned int>(r.key(), r.value()));
	}

	// Sort em by relevance
	std::sort(finalResult.begin(), finalResult.end(),
			  [&](QPair<Service::Item *, unsigned int> x, QPair<Service::Item *, unsigned int> y)
				{return x.second > y.second;});

	for (QPair<Service::Item *, unsigned int> pair : finalResult){
		res->append(pair.first);
	}
}
// plots heart-rate data
void MainWindow::setupDemo(QCustomPlot *customPlot)
{
    // opens heart-rate data and checks if something selected
    dataname = QFileDialog::getOpenFileName(this,"Open a Heart-Rate Data Text File","","*.txt");
    if(dataname.isEmpty()){
        QMessageBox::information(this, "File Status", "No heart-rate data was loaded.");
        return;
    }

    // parses heart-rate data text file and plots it into ui->customPlot (for heart rate)
    QVector<QString> v;
    QFile textFile(dataname);
    QFile d(dataname);
    QFileInfo dInfo(d.fileName());
    QString dataname_display(dInfo.fileName());
    if(textFile.open(QIODevice::ReadOnly))
    {
        QString all;
        QTextStream textStream(&textFile);
        while (!textStream.atEnd()) {
            textStream >> all;
            if(textStream.status() == QTextStream::Ok){
                v.append(all);
            }
            else
                break;
        }

        if (heart_rate_plots_count == 0){
            a.resize(v.size()-1), b.resize(v.size()-1);
        }
        if (heart_rate_plots_count == 1){
            a2.resize(v.size()-1), b2.resize(v.size()-1);
        }
        if (heart_rate_plots_count == 2){
            a3.resize(v.size()-1), b3.resize(v.size()-1);
        }
        if (heart_rate_plots_count == 3){
            a4.resize(v.size()-1), b4.resize(v.size()-1);
        }
        if (heart_rate_plots_count == 4){
            a5.resize(v.size()-1), b5.resize(v.size()-1);
        }
        if (heart_rate_plots_count == 5){
            a6.resize(v.size()-1), b6.resize(v.size()-1);
        }
        if (heart_rate_plots_count == 6){
            a7.resize(v.size()-1), b7.resize(v.size()-1);
        }
        if (heart_rate_plots_count == 7){
            a8.resize(v.size()-1), b8.resize(v.size()-1);
        }
        if (heart_rate_plots_count == 8){
            a9.resize(v.size()-1), b9.resize(v.size()-1);
        }
        if (heart_rate_plots_count == 9){
            a10.resize(v.size()-1), b10.resize(v.size()-1);
        }

        for(int i=1; i<v.size(); ++i)
        {
            string v_i_as_string = v[i].toUtf8().constData();
            int comma_pos = v_i_as_string.find(",");
            double x_double = stod(v_i_as_string.substr(0,comma_pos));
            double y_double = stod(v_i_as_string.substr(comma_pos+1,v_i_as_string.length()));
            if (heart_rate_plots_count == 0){
                a[i-1] = x_double;
                b[i-1] = y_double;
            }
            if (heart_rate_plots_count == 1){
                a2[i-1] = x_double;
                b2[i-1] = y_double;
            }
            if (heart_rate_plots_count == 2){
                a3[i-1] = x_double;
                b3[i-1] = y_double;
            }
            if (heart_rate_plots_count == 3){
                a4[i-1] = x_double;
                b4[i-1] = y_double;
            }
            if (heart_rate_plots_count == 4){
                a5[i-1] = x_double;
                b5[i-1] = y_double;
            }
            if (heart_rate_plots_count == 5){
                a6[i-1] = x_double;
                b6[i-1] = y_double;
            }
            if (heart_rate_plots_count == 6){
                a7[i-1] = x_double;
                b7[i-1] = y_double;
            }
            if (heart_rate_plots_count == 7){
                a8[i-1] = x_double;
                b8[i-1] = y_double;
            }
            if (heart_rate_plots_count == 8){
                a9[i-1] = x_double;
                b9[i-1] = y_double;
            }
            if (heart_rate_plots_count == 9){
                a10[i-1] = x_double;
                b10[i-1] = y_double;
            }
        }

        //sets ending point to the duration of video
        ending_point = (mMediaPlayer->duration())/1000;

        // add and color the graphs
        customPlot->addGraph();
        QPen graphPen;
        if (heart_rate_plots_count == 0){
            customPlot->graph()->setData(a, b);
            graphPen.setColor(Qt::red);
            hr_legend_qstring += "Legend\nRed: " + dataname_display;
        }
        if (heart_rate_plots_count == 1){
            customPlot->graph()->setData(a2, b2);
            graphPen.setColor(Qt::darkGreen);
            hr_legend_qstring += "\nDark Green: " + dataname_display;
        }
        if (heart_rate_plots_count == 2){
            customPlot->graph()->setData(a3, b3);
            graphPen.setColor(Qt::blue);
            hr_legend_qstring += "\nBlue: " + dataname_display;
        }
        if (heart_rate_plots_count == 3){
            customPlot->graph()->setData(a4, b4);
            graphPen.setColor(Qt::black);
            hr_legend_qstring += "\nBlack: " + dataname_display;
        }
        if (heart_rate_plots_count == 4){
            customPlot->graph()->setData(a5, b5);
            graphPen.setColor(Qt::darkCyan);
            hr_legend_qstring += "\nDark Cyan: " + dataname_display;
        }
        if (heart_rate_plots_count == 5){
            customPlot->graph()->setData(a6, b6);
            graphPen.setColor(Qt::darkMagenta);
            hr_legend_qstring += "\nDark Magenta: " + dataname_display;
        }
        if (heart_rate_plots_count == 6){
            customPlot->graph()->setData(a7, b7);
            graphPen.setColor(Qt::darkYellow);
            hr_legend_qstring += "\nDark Yellow: " + dataname_display;
        }
        if (heart_rate_plots_count == 7){
            customPlot->graph()->setData(a8, b8);
            graphPen.setColor(Qt::darkRed);
            hr_legend_qstring += "\nDark Red: " + dataname_display;
        }
        if (heart_rate_plots_count == 8){
            customPlot->graph()->setData(a9, b9);
            graphPen.setColor(Qt::darkGray);
            hr_legend_qstring += "\nDark Gray: " + dataname_display;
        }
        if (heart_rate_plots_count == 9){
            customPlot->graph()->setData(a10, b10);
            graphPen.setColor(Qt::darkBlue);
            hr_legend_qstring += "\nDark Blue: " + dataname_display;
        }
        ui->hr_legend->setText(hr_legend_qstring);
        heart_rate_plots_count++;
        graphPen.setWidthF(1);
        customPlot->graph()->setPen(graphPen);

        // rescales time axis to match video length
        customPlot->graph()->rescaleAxes();
        customPlot->xAxis->setRangeLower(0);
        customPlot->xAxis->setRangeUpper((mMediaPlayer->duration())/1000);

        // makes ui->customPlot (heart rate) zoomable and draggable
        customPlot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
        customPlot->replot();

        //Message showing user heart-rate data has been loaded.
        QMessageBox::information(this, "File Status", dataname_display + " has been loaded.");
    }
Ejemplo n.º 12
0
void BikerHttpRequestProcessor::processRequest()
{
    std::cerr << "processing request..." << std::endl;
    
    QRegExp numberRegExp("(\\d+(?:.\\d+)?)");
    
    //Es wird nur GET unterstützt, der Rest nicht. Bei was anderem: Grantig sein und 405 antworten.
    if (_requestType != "GET")
    {
        this->send405();
        return;
    }
    if (_requestPath.contains(".."))
    {
        //".." im Pfad ist ein falscher Request. Damit könnte man ins Dateisystem gelangen.
        std::cerr << "\"..\" in request: not allowed." << std::endl;
        this->send400();
    }
    
    std::cerr << "request file: " << _requestPath << std::endl;
    
    if (_requestPath.startsWith("/files/"))
    {
        if (! ProgramOptions::getInstance()->webserver_no_serve_files)
        {
            //"/files/" entfernen!
            QString _myRequestPath = _requestPath.remove(0, 7);
            QDir mainDir((ProgramOptions::getInstance()->webserver_public_html_folder).c_str());
            if ((ProgramOptions::getInstance()->webserver_public_html_folder == "") || !mainDir.exists())
            {
                this->send404();
                return;
            }
            QFile file(QString(ProgramOptions::getInstance()->webserver_public_html_folder.c_str()) + "/" + _myRequestPath);
            QDir dir(QString(ProgramOptions::getInstance()->webserver_public_html_folder.c_str()) + "/" + _myRequestPath);
            
            //Wenn die Datei existiert, und alle sie lesen dürfen (nicht nur
            //    Benutzer oder Gruppe): Datei senden. Sonst: 404 Not found.
            if ((!dir.exists()) && file.exists() && (file.permissions() & QFile::ReadOther))
            {
                std::cerr << "serving file: \"" << file.fileName() << "\"" << std::endl;
                this->sendFile(file);
            }
            else
            {
                if (dir.exists())
                    std::cerr << "file is a directory: \"" << file.fileName() << "\". Not serving." << std::endl;
                else if (!file.exists())
                    std::cerr << "file not found: \"" << file.fileName() << "\". Not serving." << std::endl;
                else if (file.permissions() & QFile::ReadOther)
                    std::cerr << "file does not have read permissions for everybody: \"" << file.fileName() << "\". Not serving." << std::endl;
                
                //In jedem Fall: 404 senden.
                this->send404();
            }
            return;
        }
        else
        {   //Dateien ausliefern durch Einstellungen verboten: Nicht ausliefern.
            std::cerr << "webserver configured not to serve files." << std::endl;
            this->send404();
            return;
        }
    }
    else
    {
        /**
         * @todo RegExp nur einmal erzeugen und dann wiederverwenden!
         */
        QRegExp cloudmadeApiKeyRegExp("^/([\\da-fA-F]{1,64})/(?:api|API)/0.(\\d)");
        //QRegExp cloudmadeApiPointListRegExp("^/(?:(\\d{1,3}.\\d{1,16}),(\\d{1,3}.\\d{1,16})),(?:\\[(?:(\\d{1,3}.\\d{1,16}),(\\d{1,3}.\\d{1,16}))(?:,(?:(\\d{1,3}.\\d{1,16}),(\\d{1,3}.\\d{1,16}))){0,20}\\],)?(?:(\\d{1,3}.\\d{1,16}),(\\d{1,3}.\\d{1,16}))");
        QRegExp cloudmadeApiPointListRegExp("^/(?:(\\d{1,3}.\\d{1,16}),(\\d{1,3}.\\d{1,16})),(?:\\[(?:(\\d{1,3}.\\d{1,16}),(\\d{1,3}.\\d{1,16}))(?:,(\\d{1,3}.\\d{1,16}),(\\d{1,3}.\\d{1,16})){0,200}\\],)?(?:(\\d{1,3}.\\d{1,16}),(\\d{1,3}.\\d{1,16}))");
        QRegExp cloudmadeApiPointListExtractor("(?:(\\d{1,3}.\\d{1,16}),(\\d{1,3}.\\d{1,16}))");
        QRegExp cloudmadeApiRouteTypeRegExp("^/([a-zA-Z0-9]{1,64})(?:/([a-zA-Z0-9]{1,64}))?.(gpx|GPX|js|JS)$");
        
        QString apiKey="";
        int apiVersion=0;
        QVector<GPSPosition> routePointList;
        QString routeType="";
        QString routeModifier="";
        QString routeDataType="";
        
        int position=0;
        if ((position=cloudmadeApiKeyRegExp.indexIn(_requestPath)) != -1)
        {
            apiKey = cloudmadeApiKeyRegExp.cap(1).toLower();
            apiVersion = cloudmadeApiKeyRegExp.cap(2).toInt();
            //API-Key gefunden. Falls uns der interessiert, hier was damit machen!
            
            if (ProgramOptions::getInstance()->webserver_apikey != "")
            {
                if (ProgramOptions::getInstance()->webserver_apikey != apiKey.toStdString())
                {
                    std::cerr << "api key \"" << apiKey << "\" is not valid." << std::endl;
                    this->send403();
                    return;
                }
            }
            
            if (apiVersion != 3)
            {
                std::cerr << "requested api version 0." << apiVersion << ", which is not supported." << std::endl;
                this->send405();
                return;
            }
            
            position += cloudmadeApiKeyRegExp.cap(0).length();
        }
        else
        {
            this->send400();
            return;
        }
        position+=cloudmadeApiPointListRegExp.indexIn(_requestPath.mid(position));
        if (cloudmadeApiPointListRegExp.cap(0).length() != 0)
        {
            //Punktliste gefunden. Auswerten!
            //Neue RegExp zum Punkte herausholen...
            cloudmadeApiPointListExtractor.indexIn(cloudmadeApiPointListRegExp.cap(0));
            QString strLat, strLon;
            routePointList.clear();
            for (int pos=0; pos>=0; pos=cloudmadeApiPointListExtractor.indexIn(cloudmadeApiPointListRegExp.cap(0), cloudmadeApiPointListExtractor.cap(0).length()+pos))
            {
                strLat = cloudmadeApiPointListExtractor.cap(1);
                strLon = cloudmadeApiPointListExtractor.cap(2);
                GPSPosition point(strLat.toDouble(), strLon.toDouble());
                routePointList << point;
            }
            
            position += cloudmadeApiPointListRegExp.cap(0).length();
        }
        else
        {
            this->send400();
            return;
        }
        position+=cloudmadeApiRouteTypeRegExp.indexIn(_requestPath.mid(position));
        if (cloudmadeApiRouteTypeRegExp.cap(0).length() != 0)
        {
            routeType = cloudmadeApiRouteTypeRegExp.cap(1).toLower();
            routeModifier = cloudmadeApiRouteTypeRegExp.cap(2).toLower();
            routeDataType = cloudmadeApiRouteTypeRegExp.cap(3).toLower();
            //Routentyp gefunden. Auswerten!
        }
        else
        {
            this->send400();
            return;
        }
        
        //this->send102();
        
        boost::shared_ptr<RoutingMetric> metric;
        boost::shared_ptr<Router> router;
        boost::shared_ptr<DatabaseConnection> dbA;
        boost::shared_ptr<DatabaseConnection> dbB;
        boost::shared_ptr<AltitudeProvider> altitudeProvider;
        
        #ifdef ZZIP_FOUND
            altitudeProvider.reset(new SRTMProvider());
        #else
            altitudeProvider.reset(new ZeroAltitudeProvider());
        #endif
        
        if ((routeType == "bicycle") || (routeType == "bike"))
        {
            //altitudeProvider.reset(new ZeroAltitudeProvider());
            
            //Routingmetrik festlegen anhand der Benutzerwahl
            if ((routeModifier == "euclidean"))
            {
                metric.reset(new EuclideanRoutingMetric(altitudeProvider));
            }
            else if ((routeModifier == "simpleheight") || (routeModifier == "shortest"))
            {
                float detourPerHeightMeter = 100.0f;
                if (numberRegExp.indexIn(_parameterMap["detourperheightmeter"]) != -1)
                {
                    detourPerHeightMeter = numberRegExp.cap(1).toFloat();
                }
                metric.reset(new SimpleHeightRoutingMetric(altitudeProvider, detourPerHeightMeter));
            }
            else if (routeModifier == "advancedheight")
            {
                float punishment = 1.0f;
                float detourPerHeightMeter = 200.0f;
                if (numberRegExp.indexIn(_parameterMap["punishment"]) != -1)
                {
                    punishment = numberRegExp.cap(1).toFloat();
                }
                if (numberRegExp.indexIn(_parameterMap["detourperheightmeter"]) != -1)
                {
                    detourPerHeightMeter = numberRegExp.cap(1).toFloat();
                }
                metric.reset(new AdvancedHeightRoutingMetric(altitudeProvider, detourPerHeightMeter, punishment));
            }
            else if (routeModifier == "simplepower")
            {
                double weight = 90.0;
                double efficiency = 3 * weight;
                
                if (numberRegExp.indexIn(_parameterMap["weight"]) != -1)
                    weight = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["efficiency"]) != -1)
                    efficiency = numberRegExp.cap(1).toDouble();
                metric.reset(new SimplePowerRoutingMetric(altitudeProvider, weight, efficiency));
            }
            else if ((routeModifier == "power") || (routeModifier == "") || (routeModifier == "fastest"))
            {
                double weight = 90.0;
                //double maxPower = 140.0;
                double maxPower = 150.0;
                double minSpeed = 2.5;
                double pushBikeSpeed = 0.5;
                double haltungskorrekturfaktor = 0.4;
                double maxSpeed = -1.0;
                double noCyclewayPunishmentFactor = 5;
                
                if (numberRegExp.indexIn(_parameterMap["weight"]) != -1)
                    weight = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["maxpower"]) != -1)
                    maxPower = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["minspeed"]) != -1)
                    minSpeed = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["maxspeed"]) != -1)
                    maxSpeed = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["pushbikespeed"]) != -1)
                    pushBikeSpeed = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["nocyclewaypunishmentfactor"]) != -1)
                    noCyclewayPunishmentFactor = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["haltungskorrekturfaktor"]) != -1)
                    haltungskorrekturfaktor = numberRegExp.cap(1).toDouble();
                metric.reset(new PowerRoutingMetric(altitudeProvider, weight, maxPower, minSpeed, pushBikeSpeed, haltungskorrekturfaktor, noCyclewayPunishmentFactor ,maxSpeed));
            }
            else if ((routeModifier == "biketourpower") || (routeModifier == "biketour"))
            {
                double weight = 90.0;
                //double maxPower = 140.0;
                double maxPower = 100.0;
                double minSpeed = 2.5;
                double pushBikeSpeed = 0.5;
                double haltungskorrekturfaktor = 0.4;
                double maxSpeed = -1.0;
                double noCyclewayPunishmentFactor = 7;
                
                if (numberRegExp.indexIn(_parameterMap["weight"]) != -1)
                    weight = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["maxpower"]) != -1)
                    maxPower = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["minspeed"]) != -1)
                    minSpeed = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["maxspeed"]) != -1)
                    maxSpeed = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["pushbikespeed"]) != -1)
                    pushBikeSpeed = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["nocyclewaypunishmentfactor"]) != -1)
                    noCyclewayPunishmentFactor = numberRegExp.cap(1).toDouble();
                if (numberRegExp.indexIn(_parameterMap["haltungskorrekturfaktor"]) != -1)
                    haltungskorrekturfaktor = numberRegExp.cap(1).toDouble();
                metric.reset(new BikeTourPowerRoutingMetric(altitudeProvider, weight, maxPower, minSpeed, pushBikeSpeed, haltungskorrekturfaktor, noCyclewayPunishmentFactor ,maxSpeed));
            }
            else
            {
                std::cerr << "routeModifier \"" << routeModifier << "\" not supported." << std::endl;
                this->send405();
                return;
            }
        }
        else if (routeType == "car")
        {
            //TODO
            this->send405();
            return;
        }
        else if (routeType == "foot")
        {
            if ((routeModifier == "euclidean") || (routeModifier == "") || (routeModifier == "shortest") || (routeModifier == "fastest"))
            {
                metric.reset(new EuclideanRoutingMetric(altitudeProvider));
            }
        }
        else
        {
            std::cerr << "requested routeType=" << routeType << ", which is not supported." << std::endl;
            this->send405();
            return;
        }
        
        #ifdef SPATIALITE_FOUND
            if (ProgramOptions::getInstance()->dbBackend == "spatialite")
            {
                dbA.reset(new SpatialiteDatabaseConnection());
                dbB.reset(new SpatialiteDatabaseConnection());
            }
            else 
        #endif
        if (ProgramOptions::getInstance()->dbBackend == "sqlite")
        {
            dbA.reset(new SQLiteDatabaseConnection());
            dbB.reset(new SQLiteDatabaseConnection());
        }
        //Datenbank ist die globale DB...
        dbA->open(ProgramOptions::getInstance()->dbFilename.c_str());
        dbB->open(ProgramOptions::getInstance()->dbFilename.c_str());
        
        //TODO: Testen, ob das mit dem Cache überhaupt was bringt...
        dbA = boost::shared_ptr<DatabaseConnection>(new DatabaseRAMCache(dbA, ProgramOptions::getInstance()->dbCacheSize));
        dbB = boost::shared_ptr<DatabaseConnection>(new DatabaseRAMCache(dbB, ProgramOptions::getInstance()->dbCacheSize));
        
        //Routingalgorithmus heraussuchen, je nach Angabe. Standard: Mehrthread-A* oder Mehrthread-Dijkstra - je nach Metrik.
        if (_parameterMap["algorithm"] == "multithreadeddijkstra")
            router.reset(new MultithreadedDijkstraRouter(dbA, dbB, metric));
        else if (_parameterMap["algorithm"] == "dijkstra")
            router.reset(new DijkstraRouter(dbA, metric));
        else if (_parameterMap["algorithm"] == "astar")
            router.reset(new AStarRouter(dbA, metric));
        else if (_parameterMap["algorithm"] == "multithreadedastar")
            router.reset(new MultithreadedAStarRouter(dbA, dbB, metric));
        else
        {
            if (metric->getMeasurementUnit() == DISTANCE)
                router.reset(new MultithreadedAStarRouter(dbA, dbB, metric));
            else
                router.reset(new MultithreadedDijkstraRouter(dbA, dbB, metric));
        }
        
        //Route berechnen
        GPSRoute route = router->calculateShortestRoute(routePointList);
        //Keine Route gefunden? 404 senden.
        if (route.isEmpty())
        {
            std::cerr << "no route found." << std::endl;
            this->send404();
            return;
        }
        else
        {
            std::cerr << "found route." << std::endl
                << "  length: " << route.calcLength()/1000.0 << "km" << std::endl
                << "  duration: " << route.getDuration()/60.0 << "min" << std::endl
                << "  has " << route.getSize() << " points." << std::endl;
        }
        
        //Antwort entsprechend des Routentypen senden.
        if (routeDataType == "gpx")
            this->sendFile(route.exportGPXString(altitudeProvider));
        else if (routeDataType == "js")
            this->sendFile(route.exportJSONString());
        else
            std::cerr << "route datatype \"" << routeDataType  << 
                "\" not supported." << std::endl;
        return;
    }
}
Ejemplo n.º 13
0
void DiagramScene::setValues(QMap<QString, QVector<QPointF> > values)
{
    if(!values.keys().size())
    {
        mouseline=0;
        clear();
        return;
    }

    if(!values[values.keys().at(0)].size())
    {
        mouseline=0;
        clear();
        return;
    }

    bool dirty = true;
    int searchiteration=0;
    while(dirty && searchiteration<1000)
    {
        searchiteration++;
        mouseline=0;
        clear();

        for(int index=0; index < value.size(); index++)
            delete value[value.keys().at(index)];

        value.clear();
        minvaluex=0.0;
        maxvaluex=0.0;
        minvaluey=0.0;
        maxvaluey=0.0;

        if(!yscale)
            yscale=1;

        data=values;

        if(!values.size())
            return;

        for(int index=0; index < values.size(); index++)
        {
            QPen pen(QColor(((index+1)*948)%200+50,((index+1)*123)%200+50,((index+1)*11)%200+50));
            QPainterPath tmppath;
            QVector<QPointF> result = values[values.keys().at(index)];
            value[data.keys().at(index)] = new QMap<qreal,qreal>();

            for(int pointindex=0; pointindex < result.size(); pointindex++)
            {
                qreal x = (qreal)(result[pointindex].x());
                qreal y = (qreal)(result[pointindex].y());


                (*value[data.keys().at(index)])[x]=y;

                if(!pointindex && !index)
                {
                    minvaluex=x;
                    maxvaluex=x;
                    minvaluey=(double)y/(double)yscale;
                    maxvaluey=(double)y/(double)yscale;
                }

                if(!pointindex)
                    tmppath.moveTo(x*prec,(-y/yscale)*prec);
                else
                    tmppath.lineTo(x*prec,(-y/yscale)*prec);

                if(x > maxvaluex)
                    maxvaluex=(double)x;
                if(x < minvaluex)
                    minvaluex=(double)x;
                if((double)y/yscale > maxvaluey)
                    maxvaluey=(double)y/yscale;
                if((double)y/yscale < minvaluey)
                    minvaluey=(double)y/yscale;
            }

            addPath(tmppath,pen);
        }

        dirty = false;
        qreal maxyvalue = maxvaluey-minvaluey;

        if(maxvaluey==minvaluey)
            maxyvalue = qAbs(maxvaluey);

        qreal LOWY = 20.0;
        qreal UPPERY = 80.0;

        if(maxyvalue < LOWY || maxyvalue > UPPERY)
        {
            yscale *=maxyvalue/((double)(UPPERY-LOWY)/2.0 + LOWY);
            dirty = true;
        }
    }
    showGrid();

    qreal w , h;

    h = maxvaluey-minvaluey;
    w = maxvaluex-minvaluex;
    if(w < h * 3)
        w = h * 3;

    setSceneRect(minvaluex*prec,-maxvaluey*prec,w*prec, h*prec);

    QList<QGraphicsView*> viewers = views();
    for(int index=0; index < viewers.size(); index++)
    {
        viewers.at(index)->fitInView(sceneRect(),Qt::KeepAspectRatioByExpanding);
        viewers.at(index)->centerOn(maxvaluex*prec,qRound(sceneRect().topRight().y()));
    }
}
Ejemplo n.º 14
0
QString MyString::dataToDotString(Data *data, int type)
{
    QString s;

    //select edges/titles based on type
    QVector<Arrow> *edgesPtr;
    QHash<int, QString> *titlesPtr;
    QString filter;

    switch (type)
    {
    case DOT_TYPE_AFFORDANCE:
        titlesPtr = &(data->affordanceStateTitles);
        edgesPtr = &(data->affordanceEdges);
        filter = data->affordanceFilter;
        break;
    case DOT_TYPE_ACTION:
        titlesPtr = &(data->actionStateTitles);
        edgesPtr = &(data->actionEdges);
        filter = data->actionFilter;
        break;
    case DOT_TYPE_ABSTRACT:
        titlesPtr = &(data->abstractStateTitles);
        edgesPtr = &(data->abstractEdges);
        break;
    default:
        return s;
        break;
    }

    //parse filter string
    QStringList stateNos = filter.split(",");
    QSet<int> filteredSet;
    int filteredSetSize = stateNos.count();
    //build set of filtered states
    for (int index = 0; index < filteredSetSize; index++)
    {
        int value = stateNos.at(index).toInt();
        if (!value)
            continue;
        filteredSet.insert(value);
    }

    s += ("digraph d {\n");
    s += ("graph [ bgcolor=\"white\", resolution=\"128\", fontname=\"Helvetica\", fontcolor=\"black\", fontsize=\"10\" ];");
    s += ("node [ fontname=\"Helvetica\", penwidth=\"0.25\", fontcolor=\"gray32\", fontsize=\"8\"];");
    s += ("edge [ color=\"gray32\", arrowsize=\"0.75\", penwidth=\"0.25\", fontname=\"Helvetica\", fontcolor=\"dodgerblue4\", fontsize=\"8\", arrowhead=\"vee\" ];");

    //states
    std::map<int, QString> states; //tbd: check if necessary
    int size = edgesPtr->count();
    for (int i = 1; i < size; i++) //omit initial state 0
    {
        int sourceId, targetId;
        sourceId = edgesPtr->at(i).source;
        targetId = edgesPtr->at(i).target;
        QString source, target;
        source = MyString::makeState(sourceId, (*titlesPtr)[sourceId]);
        target = MyString::makeState(targetId, (*titlesPtr)[targetId]);
        states.insert(std::make_pair(sourceId, source));
        states.insert(std::make_pair(targetId, target));
    }

    std::map<int, QString>::iterator it;
    for (it = states.begin(); it != states.end(); it++)
    {
        bool active = true;
        if (!filter.isEmpty() && !filteredSet.contains(it->first))
        {
            active = false;
        }

        QString state;

        if (!active)
        {
            state += "//";
        }
        state += QString::number(it->first);
        state += " [label=\"";
        state += it->second;
        state += "\"]\n";

        s += state;
    }

    //arrows
    size = edgesPtr->count();
    int source, target;

    for (int i = 1; i < size; i++) //omit initial state 0
    {
        Arrow a = edgesPtr->at(i);

        source = a.source;
        target = a.target;

        bool active = true;
        if (!filter.isEmpty() &&
                ((!filteredSet.contains(source) || !filteredSet.contains(target))))
        {
            active = false;
        }

        QString arrow;

        if (!active)
        {
            arrow += "//";
        }

        arrow += a.toString();

        s += arrow;
    }

    //end dot structure
    s += "}\n";

    return s;
}
Ejemplo n.º 15
0
/*!
    \fn void QTextTable::removeColumns(int index, int columns)

    Removes a number of \a columns starting with the column at the specified
    \a index.

    \sa insertRows() insertColumns() removeRows() resize() appendRows() appendColumns()
*/
void QTextTable::removeColumns(int pos, int num)
{
    Q_D(QTextTable);
//     qDebug() << "-------- removeCols" << pos << num;

    if (num <= 0 || pos < 0)
	return;
    if (d->dirty)
        d->update();
    if (pos >= d->nCols)
        return;
    if (pos + num > d->nCols)
        pos = d->nCols - num;

    QTextDocumentPrivate *p = d->pieceTable;
    QTextFormatCollection *collection = p->formatCollection();
    p->beginEditBlock();

    // delete whole table?
    if (pos == 0 && num == d->nCols) {
        const int pos = p->fragmentMap().position(d->fragment_start);
        p->remove(pos, p->fragmentMap().position(d->fragment_end) - pos + 1);
        p->endEditBlock();
        return;
    }

    p->aboutToRemoveCell(cellAt(0, pos).firstPosition(), cellAt(d->nRows - 1, pos + num - 1).lastPosition());

    QList<int> touchedCells;
    for (int r = 0; r < d->nRows; ++r) {
        for (int c = pos; c < pos + num; ++c) {
            int cell = d->grid[r*d->nCols + c];
            QTextDocumentPrivate::FragmentIterator it(&p->fragmentMap(), cell);
            QTextCharFormat fmt = collection->charFormat(it->format);
            int span = fmt.tableCellColumnSpan();
            if (touchedCells.contains(cell) && span <= 1)
                continue;
            touchedCells << cell;

            if (span > 1) {
                fmt.setTableCellColumnSpan(span - 1);
                p->setCharFormat(it.position(), 1, fmt);
            } else {
                // remove cell
                int index = d->cells.indexOf(cell) + 1;
                int f_end = index < d->cells.size() ? d->cells.at(index) : d->fragment_end;
                p->remove(it.position(), p->fragmentMap().position(f_end) - it.position());
            }
        }
    }

    QTextTableFormat tfmt = format();
    tfmt.setColumns(tfmt.columns()-num);
    QVector<QTextLength> columnWidths = tfmt.columnWidthConstraints();
    if (columnWidths.count() > pos) {
        columnWidths.remove(pos, num);
        tfmt.setColumnWidthConstraints (columnWidths);
    }
    QTextObject::setFormat(tfmt);

    p->endEditBlock();
//     qDebug() << "-------- end removeCols" << pos << num;
}
Ejemplo n.º 16
0
void SurfaceItem::render(const Map &map, const Camera &camera)
{
    int zone = map.zone(vertices().at(0));

    GLuint tex = textureId();

    if (zone < 0)
        return;

    m_program->bind();
    m_program->setUniformValue(m_matrixUniform, camera.viewProjectionMatrix());

    QSize size = surface()->size();
    m_program->setUniformValue(m_pixelSizeUniform, 5. / size.width(), 5. / size.height());
    m_program->setUniformValue(m_eyeUniform, camera.viewPos());
    m_program->setUniformValue(m_focusColorUniform, GLfloat(m_opacity));
    m_program->setUniformValueArray(m_lightsUniform, map.lights(zone).constData(), map.lights(zone).size());
    m_program->setUniformValue(m_numLightsUniform, map.lights(zone).size());

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, tex);

    QVector<QVector3D> v = vertices();

    QVector3D va = v[0];
    QVector3D vb = v[1];
    QVector3D vc = v[2];
    QVector3D vd = v[3];

    QVector<QVector3D> vertexBuffer;
    vertexBuffer << va << vb << vd << vd << vb << vc;

    qreal y1 = 0;
    qreal y2 = 1;

    if (surface()->origin() == QWaylandSurface::OriginTopLeft)
        qSwap(y1, y2);

    QVector<QVector2D> texCoordBuffer;
    texCoordBuffer << QVector2D(0, y2) << QVector2D(1, y2)
                   << QVector2D(0, y1) << QVector2D(0, y1)
                   << QVector2D(1, y2) << QVector2D(1, y1);

    m_program->setUniformValue(m_normalUniform, -QVector3D::crossProduct(vb - va, vc - va).normalized());

    m_program->enableAttributeArray(m_vertexAttr);
    m_program->setAttributeArray(m_vertexAttr, vertexBuffer.constData());
    m_program->enableAttributeArray(m_texCoordAttr);
    m_program->setAttributeArray(m_texCoordAttr, texCoordBuffer.constData());

    glEnable(GL_BLEND);
    glDisable(GL_CULL_FACE);
    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

    glDrawArrays(GL_TRIANGLES, 0, 6);

    glDisable(GL_BLEND);

    m_program->disableAttributeArray(m_texCoordAttr);
    m_program->disableAttributeArray(m_vertexAttr);

#if 0
    QOpenGLPaintDevice device(camera.viewSize());
    QPainter p(&device);

    va = camera.viewProjectionMatrix().map(va);
    vb = camera.viewProjectionMatrix().map(vb);
    vc = camera.viewProjectionMatrix().map(vc);
    vd = camera.viewProjectionMatrix().map(vd);

    QVector3D c(camera.viewSize().width() * 0.5, camera.viewSize().height() * 0.5, 0);
    va = c + c * va * QVector3D(1, -1, 0);
    vb = c + c * vb * QVector3D(1, -1, 0);
    vc = c + c * vc * QVector3D(1, -1, 0);
    vd = c + c * vd * QVector3D(1, -1, 0);

    QPointF pa(va.x(), va.y());
    QPointF pb(vb.x(), vb.y());
    QPointF pc(vc.x(), vc.y());
    QPointF pd(vd.x(), vd.y());

    p.drawLine(pa, pb);
    p.drawLine(pb, pc);
    p.drawLine(pc, pd);
    p.drawLine(pd, pa);

    extern QVector3D debug;

    QVector3D d = camera.viewProjectionMatrix().map(debug);
    d = c + c * d * QVector3D(1, -1, 0);

    static QVector3D old;
    if (debug != old)
        old = debug;

    p.setPen(Qt::NoPen);
    p.setBrush(Qt::red);
    p.drawEllipse(QRectF(d.x() - 2, d.y() - 2, 4, 4));

    p.end();
#endif
}
Ejemplo n.º 17
0
void QgsSimpleLineSymbolLayerV2::applyDataDefinedSymbology( QgsSymbolV2RenderContext& context, QPen& pen, QPen& selPen, double& offset )
{
  if ( mDataDefinedProperties.isEmpty() )
    return; // shortcut

  //data defined properties
  QgsExpression* strokeWidthExpression = expression( "width" );
  if ( strokeWidthExpression )
  {
    double scaledWidth = strokeWidthExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble()
                         * QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mWidthUnit, mWidthMapUnitScale );
    pen.setWidthF( scaledWidth );
    selPen.setWidthF( scaledWidth );
  }

  //color
  QgsExpression* strokeColorExpression = expression( "color" );
  if ( strokeColorExpression )
  {
    pen.setColor( QgsSymbolLayerV2Utils::decodeColor( strokeColorExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString() ) );
  }

  //offset
  QgsExpression* lineOffsetExpression = expression( "offset" );
  if ( lineOffsetExpression )
  {
    offset = lineOffsetExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
  }

  //dash dot vector
  QgsExpression* dashPatternExpression = expression( "customdash" );
  if ( dashPatternExpression )
  {
    double scaledWidth = mWidth * QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mWidthUnit, mWidthMapUnitScale );
    double dashWidthDiv = mPen.widthF();

    if ( strokeWidthExpression )
    {
      dashWidthDiv = pen.widthF();
      scaledWidth = pen.widthF();
    }

    //fix dash pattern width in Qt 4.8
    QStringList versionSplit = QString( qVersion() ).split( "." );
    if ( versionSplit.size() > 1
         && versionSplit.at( 1 ).toInt() >= 8
         && ( scaledWidth * context.renderContext().rasterScaleFactor() ) < 1.0 )
    {
      dashWidthDiv = 1.0;
    }

    QVector<qreal> dashVector;
    QStringList dashList = dashPatternExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString().split( ";" );
    QStringList::const_iterator dashIt = dashList.constBegin();
    for ( ; dashIt != dashList.constEnd(); ++dashIt )
    {
      dashVector.push_back( dashIt->toDouble() * QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mCustomDashPatternUnit, mCustomDashPatternMapUnitScale ) / dashWidthDiv );
    }
    pen.setDashPattern( dashVector );
  }

  //line style
  QgsExpression* lineStyleExpression = expression( "line_style" );
  if ( lineStyleExpression )
  {
    QString lineStyleString = lineStyleExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString();
    pen.setStyle( QgsSymbolLayerV2Utils::decodePenStyle( lineStyleString ) );
  }

  //join style
  QgsExpression* joinStyleExpression = expression( "joinstyle" );
  if ( joinStyleExpression )
  {
    QString joinStyleString = joinStyleExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString();
    pen.setJoinStyle( QgsSymbolLayerV2Utils::decodePenJoinStyle( joinStyleString ) );
  }

  //cap style
  QgsExpression* capStyleExpression = expression( "capstyle" );
  if ( capStyleExpression )
  {
    QString capStyleString = capStyleExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString();
    pen.setCapStyle( QgsSymbolLayerV2Utils::decodePenCapStyle( capStyleString ) );
  }
}
Ejemplo n.º 18
0
void GraphUtils::minCut(QList<ConnectorItem *> & connectorItems, QList<SketchWidget *> & foreignSketchWidgets, ConnectorItem * source, ConnectorItem * sink, QList<ConnectorEdge *> & minCut) 
{
	// this helped:  http://boost.2283326.n4.nabble.com/graph-edmund-karp-max-flow-vs-kolmogorov-max-flow-color-map-td2565611.html
	
	using namespace boost;

	typedef adjacency_list_traits < vecS, vecS, directedS > Traits;
    typedef property < vertex_color_t, boost::default_color_type > COLOR;
	typedef property < vertex_index_t, long, COLOR > VERTEX;
    typedef property < edge_reverse_t, Traits::edge_descriptor > REVERSE;
    typedef property < edge_residual_capacity_t, long, REVERSE > RESIDUAL;
	typedef property < edge_capacity_t, long, RESIDUAL > EDGE;
	typedef adjacency_list < listS, vecS, directedS, VERTEX, EDGE > Graph;

	Graph g;

	property_map < Graph, edge_capacity_t >::type capacity = get(edge_capacity, g);
	property_map < Graph, edge_residual_capacity_t >::type residual_capacity = get(edge_residual_capacity, g);
	property_map < Graph, edge_reverse_t >::type reverse = get(edge_reverse, g);

	property_map < Graph, vertex_color_t >::type color = get(vertex_color, g);
	property_map < Graph, vertex_index_t >::type index = get(vertex_index, g);

	Traits::vertex_descriptor s, t;

	QList<Wire *> visitedWires;
	QList<int> indexes;
	QHash<ConnectorItem *, int> vertices;
	QList<ConnectorEdge *> edges;
	QVector<Traits::vertex_descriptor> verts;

	vertices.insert(source, 0);
	vertices.insert(sink, 1);
	verts.append(s = add_vertex(g));
	verts.append(t = add_vertex(g));

	foreach (ConnectorItem * connectorItem, connectorItems) {
		//connectorItem->debugInfo("input");
		if (connectorItem->attachedToItemType() == ModelPart::Wire) {
			Wire * wire = qobject_cast<Wire *>(connectorItem->attachedTo());
			if (visitedWires.contains(wire)) continue;

			QList<Wire *> wires;
			QList<ConnectorItem *> ends;
			wire->collectChained(wires, ends);
			visitedWires.append(wires);
			if (ends.count() < 2) continue;

			foreach (ConnectorItem * end, ends) {
				appendVertIf(end, vertices, verts);
			}

			for (int i = 0; i < ends.count(); i++) {
				ConnectorItem * end = ends[i];
				for (int j = i + 1; j < ends.count(); j++) {
					ConnectorEdge * connectorEdge = makeConnectorEdge(edges, end, ends[j], 1000, wire);
					connectorEdge->setHeadTail(vertices.value(connectorEdge->c0), vertices.value(connectorEdge->c1));
				}
			}
			continue;
		}
Ejemplo n.º 19
0
const OperateurDiff& OperateurDiff::evaluate(Pile& pile) const
{
    if (pile.taille() >= getArite()) {
        try
        {
            dynamic_cast<Number&>(pile.top());
        }
        catch(exception&)
        {
            throw ComputerException("Erreur : mauvais arguments");
        }
        Number& N2 = dynamic_cast<Number&>(pile.top());
        pile.pop();
        try
        {
            dynamic_cast<Number&>(pile.top());
        }
        catch(exception&)
        {
            pile.push(N2);
            throw ComputerException("Erreur : mauvais arguments");
        }
        Number& N1 = dynamic_cast<Number&>(pile.top());
        pile.pop();
        double Re1, Re2, Im1, Im2;
        bool bRe, bIm;
        //calcul de la partie réelle
        Re1 = N1.getRe().getNumerateur().getValue()/N1.getRe().getDenominateur().getValue();
        Re2 = N2.getRe().getNumerateur().getValue()/N2.getRe().getDenominateur().getValue();
        //calcul de la partie réelle
        Im1 = N1.getIm().getNumerateur().getValue()/N1.getIm().getDenominateur().getValue();
        Im2 = N2.getIm().getNumerateur().getValue()/N2.getIm().getDenominateur().getValue();

        bRe = Re1 != Re2;
        bIm = Im1 != Im2;

        QString res;
        if(bRe || bIm)
        {
            res = "1";
        }
        else
        {
            res = "0";
        }
        Expression& e = ExpressionManager::getInstance().addExpression(res);

        //ajout sur la pile
        pile.push(e);
        QString message;
        message = N1.toString() + " " + this->getSymbole() + " " + N2.toString() + " : " + res;
        pile.setMessage(message);
        

        //sauvegarde des arguments
        QVector<QString> args;
        args.push_back(N1.toString());
        args.push_back(N2.toString());
        pile.setLastArgs(args);
    }
    else
    {
        throw ComputerException("Erreur : pas assez d'arguments");
    }
    return *this;
}
Ejemplo n.º 20
0
bool FastConvexFitting::getFitting(Geometry & geometry)
{
    if(initflag)
    {
        assert(getConfigurations());
        initflag=0;
    }
    if(configurations.size()==0)
    {
        return 0;
    }

    centerposition=-(orientation.inverse()*position);

    int i,n=configurations.size();
    for(i=0;i<n;i++)
    {
        int j,m=configurations[i].edges.size();
        for(j=0;j<m;j++)
        {
            configurations[i].globaledges[j].startcorner=position+orientation*configurations[i].edges[j].startcorner;
            configurations[i].globaledges[j].endcorner=position+orientation*configurations[i].edges[j].endcorner;
        }
    }

    G.score=0;
    for(i=0;i<n;i++)
    {
        if(getEvaluation(configurations[i])&&G.score<configurations[i].score)
        {
            G=configurations[i];
        }
    }
    if(G.score>0)
    {
        int j,m=G.geometry.size();
        G.sigma.fill(0,m);
        QVector<double> sum;
        sum.fill(0,m);

        for(i=0;i<n;i++)
        {
            int diffcount=0;
            int diffid;
            for(j=0;j<m;j++)
            {
                if(configurations[i].geometry[j]!=G.geometry[j])
                {
                    diffcount++;
                    diffid=j;
                }
                if(diffcount>=2)
                {
                    break;
                }
            }
            if(diffcount==1)
            {
                G.sigma[diffid]+=configurations[i].score*pow(configurations[i].geometry[diffid]-G.geometry[diffid],2);
                sum[diffid]+=configurations[i].score;
            }
            else if(diffcount==0)
            {
                for(j=0;j<m;j++)
                {
                    sum[j]+=configurations[i].score;
                }
            }
        }
        for(j=0;j<m;j++)
        {
            if(sum[j]>0)
            {
                G.sigma[j]/=sum[j];
            }
            if(G.sigma[j]<=0)
            {
                G.sigma[j]=100;
            }
        }
        geometry=G;
        return 1;
    }
    else
    {
        return 0;
    }
}
Ejemplo n.º 21
0
QString transform(const QString &pat, const QString &tss,
                  const QVector<const char *> &params)
{
    QString parsed;

    INFO(i18n("Parsing stylesheet"));
#if defined (SIMPLE_XSLT) && defined(Q_OS_WIN)
    // prepare use of local available dtd versions instead of fetching every time from the internet
    // this approach is url based
    if (!defaultEntityLoader) {
        defaultEntityLoader = xmlGetExternalEntityLoader();
        xmlSetExternalEntityLoader(xsltprocExternalEntityLoader);

        replaceURLList[QLatin1String("http://www.oasis-open.org/docbook/xml/4.5")] = QString("file:///%1").arg(DOCBOOK_XML_CURRDTD);
    }
#endif

    xsltStylesheetPtr style_sheet =
        xsltParseStylesheetFile((const xmlChar *)QFile::encodeName(tss).constData());

    if (!style_sheet) {
        return parsed;
    }
    if (style_sheet->indent == 1) {
        xmlIndentTreeOutput = 1;
    } else {
        xmlIndentTreeOutput = 0;
    }

    INFO(i18n("Parsing document"));

    xmlParserCtxtPtr pctxt;

    pctxt = xmlNewParserCtxt();
    if ( pctxt == NULL ) {
        return parsed;
    }

    xmlDocPtr doc = xmlCtxtReadFile(pctxt, QFile::encodeName(pat).constData(), NULL,
                                    XML_PARSE_NOENT|XML_PARSE_DTDLOAD|XML_PARSE_NONET);
    /* Clean the context pointer, now useless */
    const bool context_valid = (pctxt->valid == 0);
    xmlFreeParserCtxt(pctxt);

    /* Check both the returned doc (for parsing errors) and the context
       (for validation errors) */
    if (doc == NULL) {
        return parsed;
    } else {
        if (context_valid) {
            xmlFreeDoc(doc);
            return parsed;
        }
    }

    INFO(i18n("Applying stylesheet"));
    QVector<const char *> p = params;
    p.append(NULL);
    xmlDocPtr res = xsltApplyStylesheet(style_sheet, doc, const_cast<const char **>(&p[0]));
    xmlFreeDoc(doc);
    if (res != NULL) {
        xmlOutputBufferPtr outp = xmlOutputBufferCreateIO(writeToQString, 0, &parsed, 0);
        outp->written = 0;
        INFO(i18n("Writing document"));
        xsltSaveResultTo(outp, res, style_sheet);
        xmlOutputBufferClose(outp);
        xmlFreeDoc(res);
    }
    xsltFreeStylesheet(style_sheet);

    if (parsed.isEmpty()) {
        parsed = QLatin1Char(' ');    // avoid error message
    }
    return parsed;
}
Ejemplo n.º 22
0
bool FastRectangleFitting::getBeamRange(Geometry &configuration, QVector<int> &edgeID, QVector<int> &startID, QVector<int> &endID)
{
    if(centerposition(0)>configuration.geometry[0]/2.0)
    {
        if(centerposition(1)>configuration.geometry[1]/2.0)
        {
            edgeID.resize(2);
            edgeID[0]=0;
            edgeID[1]=3;
        }
        else if(centerposition(1)<-configuration.geometry[1]/2.0)
        {
            edgeID.resize(2);
            edgeID[0]=0;
            edgeID[1]=1;
        }
        else
        {
            edgeID.resize(1);
            edgeID[0]=0;
        }
    }
    else if(centerposition(0)<-configuration.geometry[0]/2.0)
    {
        if(centerposition(1)>configuration.geometry[1]/2.0)
        {
            edgeID.resize(2);
            edgeID[0]=2;
            edgeID[1]=3;
        }
        else if(centerposition(1)<-configuration.geometry[1]/2.0)
        {
            edgeID.resize(2);
            edgeID[0]=1;
            edgeID[1]=2;
        }
        else
        {
            edgeID.resize(1);
            edgeID[0]=2;
        }
    }
    else
    {
        if(centerposition(1)>configuration.geometry[1]/2.0)
        {
            edgeID.resize(1);
            edgeID[0]=3;
        }
        else if(centerposition(1)<-configuration.geometry[1]/2.0)
        {
            edgeID.resize(1);
            edgeID[0]=1;
        }
        else
        {
            return 0;
        }
    }

    double PI=3.141592654;
    double density=2*PI/beamsnum;

    int i,n=edgeID.size();
    startID.resize(n);
    endID.resize(n);
    for(i=0;i<n;i++)
    {
        startID[i]=(atan2(configuration.globaledges[edgeID[i]].startcorner(1),configuration.globaledges[edgeID[i]].startcorner(0))+PI)/density;
        startID[i]=startID[i]>=0?startID[i]:0;
        startID[i]=startID[i]<beamsnum?startID[i]:beamsnum-1;

        endID[i]=(atan2(configuration.globaledges[edgeID[i]].endcorner(1),configuration.globaledges[edgeID[i]].endcorner(0))+PI)/density;
        endID[i]=endID[i]>=0?endID[i]:0;
        endID[i]=endID[i]<beamsnum?endID[i]:beamsnum-1;
    }
    return 1;
}
QT_BEGIN_NAMESPACE

/*!
    \class QVersionNumber
    \inmodule QtCore
    \since 5.6
    \brief The QVersionNumber class contains a version number with an arbitrary
           number of segments.

    \snippet qversionnumber/main.cpp 0
*/

/*!
    \fn QVersionNumber::QVersionNumber()

    Produces a null version.

    \sa isNull()
*/

/*!
    \fn QVersionNumber::QVersionNumber(int maj)

    Constructs a QVersionNumber consisting of just the major version number \a maj.
*/

/*!
    \fn QVersionNumber::QVersionNumber(int maj, int min)

    Constructs a QVersionNumber consisting of the major and minor
    version numbers \a maj and \a min, respectively.
*/

/*!
    \fn QVersionNumber::QVersionNumber(int maj, int min, int mic)

    Constructs a QVersionNumber consisting of the major, minor, and
    micro version numbers \a maj, \a min and \a mic, respectively.
*/

/*!
    \fn QVersionNumber::QVersionNumber(const QVector<int> &seg)

    Constructs a version number from the list of numbers contained in \a seg.
*/

/*!
    \fn QVersionNumber::QVersionNumber(QVector<int> &&seg)

    Move-constructs a version number from the list of numbers contained in \a seg.

    This constructor is only enabled if the compiler supports C++11 move semantics.
*/

/*!
    \fn QVersionNumber::QVersionNumber(std::initializer_list<int> args)

    Construct a version number from the std::initializer_list specified by
    \a args.

    This constructor is only enabled if the compiler supports C++11 initializer
    lists.
*/

/*!
    \fn bool QVersionNumber::isNull() const

    Returns \c true if there are zero numerical segments, otherwise returns
    \c false.

    \sa segments()
*/

/*!
  \fn bool QVersionNumber::isNormalized() const

  Returns \c true if the version number does not contain any trailing zeros,
  otherwise returns \c false.

  \sa normalized()
*/

/*!
    \fn int QVersionNumber::majorVersion() const

    Returns the major version number, that is, the first segment.
    This function is equivalent to segmentAt(0). If this QVersionNumber object
    is null, this function returns 0.

    \sa isNull(), segmentAt()
*/

/*!
    \fn int QVersionNumber::minorVersion() const

    Returns the minor version number, that is, the second segment.
    This function is equivalent to segmentAt(1). If this QVersionNumber object
    does not contain a minor number, this function returns 0.

    \sa isNull(), segmentAt()
*/

/*!
    \fn int QVersionNumber::microVersion() const

    Returns the micro version number, that is, the third segment.
    This function is equivalent to segmentAt(2). If this QVersionNumber object
    does not contain a micro number, this function returns 0.

    \sa isNull(), segmentAt()
*/

/*!
    \fn const QVector<int>& QVersionNumber::segments() const

    Returns all of the numerical segments.

    \sa majorVersion(), minorVersion(), microVersion()
*/
QVector<int> QVersionNumber::segments() const
{
    if (m_segments.isUsingPointer())
        return *m_segments.pointer_segments;

    QVector<int> result;
    result.resize(segmentCount());
    for (int i = 0; i < segmentCount(); ++i)
        result[i] = segmentAt(i);
    return result;
}
Ejemplo n.º 24
0
void MainWindow::orEClicked()
{

    QList<QGraphicsItem *> selected_list = scene->selectedItems();
    Node* selected = (Node*)(selected_list.at(0));
    selected->setRule("orE");
    selected->update();
    int rect_x;
    int rect_y;

    bool ok;
    while(1){
             QString tekst = QInputDialog::getText(this, tr("QInputDialog::getText()"),
                                             tr("Unesite formulu:"), QLineEdit::Normal,
                                             QDir::home().dirName(), &ok);
             if (ok && !tekst.isEmpty()){
                qDebug() << "radi";
             }


            std::string formula = tekst.toUtf8().constData();
            formula += " ;";
            std::ostringstream stream;
            qDebug() << QString::fromStdString(formula);
            YY_BUFFER_STATE buffer = yy_scan_string(formula.c_str());

            if(yyparse() == 1){
                qDebug() << "Pa to ti ne radi";
             }

            if(parsed_formula->getType() == BaseFormula::T_OR){
                break;
            }
    }

    std::ostringstream stream;
    parsed_formula->printFormula(stream);
    qreal rect_width =  stream.str().length()*PARAMETER;
    qreal rect_height = 20;

    rect_x = selected->getx() - 20 - depth/2;
    rect_y = selected->gety() - 20 - depth/2;

    QVector<Formula> assumptions = selected->getAssumptions();
    assumptions.push_back(parsed_formula);

    Node* item3 = new Node( parsed_formula, rect_width, rect_height, rect_x, rect_y, selected_list.at(0), assumptions);
    scene->addNode(item3);

    Formula op1 = ((Or*)parsed_formula.get())->getOperand1();
    Formula op2 = ((Or*)parsed_formula.get())->getOperand2();

    rect_x = selected->getx() + 25 + depth/2;
    rect_y = selected->gety() - 20 - depth/2;


    assumptions.push_back(op1);
    assumptions.push_back(op2);
    op1->printFormula(stream);
    rect_width = stream.str().length()*PARAMETER;
    Node* item1 = new Node( selected->getFormula(), rect_width, rect_height, rect_x, rect_y, selected_list.at(0), assumptions);
    scene->addNode(item1);

    rect_x = selected->getx() + 50 + depth/2;
    rect_y = selected->gety() - 20 - depth/2;

    op2->printFormula(stream);
    rect_width = stream.str().length()*PARAMETER;
    Node* item2 = new Node(selected->getFormula(), rect_width, rect_height, rect_x, rect_y, selected_list.at(0), assumptions);
    scene->addNode(item2);



}
Ejemplo n.º 25
0
QVector<ApiTraceCall*>
TraceLoader::fetchFrameContents(ApiTraceFrame *currentFrame)
{
    Q_ASSERT(currentFrame);

    if (currentFrame->isLoaded()) {
        return currentFrame->calls();
    }

    if (m_parser.supportsOffsets()) {
        unsigned frameIdx = currentFrame->number;
        int numOfCalls = numberOfCallsInFrame(frameIdx);

        if (numOfCalls) {
            quint64 binaryDataSize = 0;
            QStack<ApiTraceCall*> groups;
            QVector<ApiTraceCall*> topLevelItems;
            QVector<ApiTraceCall*> allCalls(numOfCalls);
            const FrameBookmark &frameBookmark = m_frameBookmarks[frameIdx];

            m_parser.setBookmark(frameBookmark.start);

            trace::Call *call;
            int parsedCalls = 0;
            while ((call = m_parser.parse_call())) {
                ApiTraceCall *apiCall =
                    apiCallFromTraceCall(call, m_helpHash,
                                         currentFrame, groups.isEmpty() ? 0 : groups.top(), this);
                Q_ASSERT(apiCall);
                Q_ASSERT(parsedCalls < allCalls.size());
                allCalls[parsedCalls++] = apiCall;
                if (groups.count() == 0) {
                    topLevelItems.append(apiCall);
                } else {
                    groups.top()->addChild(apiCall);
                }
                if (call->flags & trace::CALL_FLAG_MARKER_PUSH) {
                    groups.push(apiCall);
                } else if (call->flags & trace::CALL_FLAG_MARKER_POP) {
                    if (groups.count()) {
                        groups.top()->finishedAddingChildren();
                        groups.pop();
                    }
                }
                if (apiCall->hasBinaryData()) {
                    QByteArray data =
                        apiCall->arguments()[
                            apiCall->binaryDataIndex()].toByteArray();
                    binaryDataSize += data.size();
                }

                delete call;

                if (apiCall->flags() & trace::CALL_FLAG_END_FRAME) {
                    break;
                }

            }
            // There can be fewer parsed calls when call in different
            // threads cross the frame boundary
            Q_ASSERT(parsedCalls <= numOfCalls);
            Q_ASSERT(parsedCalls <= allCalls.size());
            allCalls.resize(parsedCalls);
            allCalls.squeeze();

            Q_ASSERT(parsedCalls <= currentFrame->numChildrenToLoad());
            if (topLevelItems.count() == allCalls.count()) {
                emit frameContentsLoaded(currentFrame, allCalls,
                                         allCalls, binaryDataSize);
            } else {
                emit frameContentsLoaded(currentFrame, topLevelItems,
                                         allCalls, binaryDataSize);
            }
            return allCalls;
        }
    }
    return QVector<ApiTraceCall*>();
}
Ejemplo n.º 26
0
bool FilterIO::readFilter(QString path, FilterData &filter)
{
    //Open .txt file
    if(!path.contains(".txt"))
        return false;

    QFile file(path);
    if(!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        qDebug()<<"Error opening filter txt file for reading";
        return false;
    }

    //Start reading from file
    QTextStream in(&file);
    QVector<double> coefficientsTemp;

    while(!in.atEnd())
    {
        QString line = in.readLine();

        QStringList fields = line.split(QRegExp("\\s+"));

        //Delete last element if it is a blank character
        if(fields.at(fields.size()-1) == "")
            fields.removeLast();

        if(line.contains("#")) //Filter meta information commented areas in file
        {
            //Read filter sFreq
            if(line.contains("sFreq") && fields.size()==2)
                filter.m_sFreq = fields.at(1).toDouble();

            //Read filter name
            if(line.contains("name")) {
                filter.m_sName.clear();
                for(int i=1; i<fields.size(); i++)
                    filter.m_sName.append(fields.at(i));
            }

            //Read the filter order
            if(line.contains("order") && fields.size()==2)
                filter.m_iFilterOrder = fields.at(1).toInt();

            //Read the filter type
            if(line.contains("type") && fields.size()==2)
                filter.m_Type = FilterData::getFilterTypeForString(fields.at(1));

            //Read the filter LPFreq
            if(line.contains("LPFreq") && fields.size()==2)
                filter.m_dLowpassFreq = fields.at(1).toDouble();

            //Read the filter HPFreq
            if(line.contains("HPFreq") && fields.size()==2)
                filter.m_dHighpassFreq = fields.at(1).toDouble();

            //Read the filter CenterFreq
            if(line.contains("CenterFreq") && fields.size()==2)
                filter.m_dCenterFreq = fields.at(1).toDouble();

            //Read the filter DesignMethod
            if(line.contains("DesignMethod") && fields.size()==2)
                filter.m_designMethod = FilterData::getDesignMethodForString(fields.at(1));

        } else // Read filter coefficients
            coefficientsTemp.push_back(fields.join("").toDouble());
    }
    // Check if reading was successful and correct
    if(filter.m_iFilterOrder != coefficientsTemp.size())
        filter.m_iFilterOrder = coefficientsTemp.size();

//    if(filter.m_sFreq)

//    if(filter.m_sName)

//    if(filter.m_Type)

//    if(filter.m_dLowpassFreq)

//    if(filter.m_dHighFreq)

//    if(filter.m_designMethod)

    filter.m_dCoeffA = RowVectorXd::Zero(coefficientsTemp.size());
    for(int i=0; i<filter.m_dCoeffA.cols(); i++)
        filter.m_dCoeffA(i) = coefficientsTemp.at(i);

    //Compute fft of filtercoeeficients
    filter.fftTransformCoeffs();

    file.close();

    return true;
}
Ejemplo n.º 27
0
// LATER make read and write timeout parameters
bool PfParser::parse(QIODevice *source, PfOptions options) {
  bool lazyBinaryFragments = options.shouldLazyLoadBinaryFragments();
  if (!_handler) {
    qWarning() << "PfParser::parse called before setting a handler";
    return false;
  }
  _handler->setErrorString(tr("unknown handler error"));
  int line = 1, column = 0, arrayColumn = 0;
  quint8 c, quote = 0, escapeshift = 0;
  quint16 escaped = 0;
  qint8 digit;
  State state = TopLevel; // current state
  State quotedState = TopLevel; // saved state for quotes and comments
  State escapedState = TopLevel; // saved state for escapes
  QByteArray content, comment, surface;
  QVector<Node> nodes;
  bool firstNode = true;
  PfArray array;
  if (!source->isOpen() && !source->open(QIODevice::ReadOnly)) {
    _handler->setErrorString(tr("cannot open document : %1")
                             .arg(source->errorString()));
    goto error;
  }
  if (!_handler->startDocument(options)) {
    _handler->setErrorString(tr("cannot handle start of document"));
    goto error;
  }
  while (source->bytesAvailable()
         || source->waitForReadyRead(options.readTimeout()),
         source->getChar((char*)&c)) {
    ++column;
    switch(state) {
    case TopLevel:
      if (c == '(') {
        state = Name;
      } else if (c == '\n') {
        ++line;
        column = 0;
      } else if (pfisspace(c)) {
      } else if (c == '#') {
        state = Comment;
        quotedState = TopLevel;
      } else {
        _handler->setErrorString(tr("unexpected character '%1' "
                                    "(in TopLevel state)")
                                 .arg(pfquotechar(c)));
        goto error;
      }
      break;
    case Name:
      if (pfisendofname(c) && content.isEmpty()) {
        _handler->setErrorString(tr("anonymous node"));
        goto error;
      } else if (c == '(') {
        nodes.append(QString::fromUtf8(content));
        content.clear();
        if (!_handler->startNode(names(nodes))) {
          _handler->setErrorString(tr("cannot handle start of node"));
          goto error;
        }
      } else if (c == ')') {
        nodes.append(QString::fromUtf8(content));
        content.clear();
        QVector<QString> names = ::names(nodes);
        if (!_handler->startNode(names) || !_handler->endNode(names)) {
          _handler->setErrorString(tr("cannot handle end of node"));
          goto error;
        }
        nodes.removeLast();
        state = nodes.size() ? Content : TopLevel;
        if (nodes.isEmpty()) {
          switch (options.rootNodesParsingPolicy()) {
          case StopAfterFirstRootNode:
            if (firstNode)
              goto stop_parsing;
            break;
          case FailAtSecondRootNode:
            if (!firstNode) {
              _handler->setErrorString(tr("only one root node is allowed "
                                          "(by option)"));
              goto error;
            }
            break;
          case ParseEveryRootNode:
            ;
          }
        }
      } else if (pfisspace(c)) {
        if (c == '\n') {
          ++line;
          column = 0;
        }
        nodes.append(QString::fromUtf8(content));
        content.clear();
        if (!_handler->startNode(names(nodes))) {
          _handler->setErrorString(tr("cannot handle start of node"));
          goto error;
        }
        state = Content;
      } else if (c == '#') {
        nodes.append(QString::fromUtf8(content));
        content.clear();
        if (!_handler->startNode(names(nodes))) {
          _handler->setErrorString(tr("cannot handle start of node"));
          goto error;
        }
        state = Comment;
        quotedState = Content;
      } else if (c == '|') {
        nodes.append(QString::fromUtf8(content));
        content.clear();
        if (!_handler->startNode(names(nodes))) {
          _handler->setErrorString(tr("cannot handle start of node"));
          goto error;
        }
        state = BinarySurfaceOrLength;
      } else if (c == ';') {
        nodes.append(QString::fromUtf8(content));
        array.clear();
        content.clear();
        if (!_handler->startNode(names(nodes))) {
          _handler->setErrorString(tr("cannot handle start of node"));
          goto error;
        }
        array.appendHeader("0");
        arrayColumn = 1;
        state = ArrayHeader;
      } else if (pfisquote(c)) {
        quote = c;
        state = Quote;
        quotedState = Name;
      } else if (c == '\\') {
        state = Escape;
        escapedState = Name;
      } else if (pfisspecial(c)) {
        _handler->setErrorString(tr("unexpected character '%1' (in Name state)")
                                 .arg(pfquotechar(c)));
        goto error;
      } else {
        content.append(c);
      }
      break;
    case SpaceInContent:
      if (pfisspace(c)) {
        if (c == '\n') {
          ++line;
          column = 0;
        } else {
          ++column;
        }
        break;
      }
      // otherwise process as Content by falling into Content: label
    case Content:
      if (c == ';') {
        // LATER warn if an array node has text or binary content
        array.clear();
        if (!content.isEmpty()) {
          array.appendHeader(content);
          content.clear();
        } else
          array.appendHeader("0");
        arrayColumn = 1;
        state = ArrayHeader;
      } else if (c == '(') {
        if (content.size()) {
          if (!_handler->text(QString::fromUtf8(content))) {
            _handler->setErrorString(tr("cannot handle text fragment"));
            goto error;
          }
          content.clear();
          nodes.last()._hasContent = true;
        }
        state = Name;
      } else if (c == ')') {
        if (content.size()) {
          if (!_handler->text(QString::fromUtf8(content))) {
            _handler->setErrorString(tr("cannot handle text fragment"));
            goto error;
          }
          content.clear();
          nodes.last()._hasContent = true;
        }
        if (!_handler->endNode(names(nodes))) {
          _handler->setErrorString(tr("cannot handle end of node"));
          goto error;
        }
        nodes.removeLast();
        state = nodes.size() ? Content : TopLevel;
        if (nodes.isEmpty()) {
          switch (options.rootNodesParsingPolicy()) {
          case StopAfterFirstRootNode:
            if (firstNode)
              goto stop_parsing;
            break;
          case FailAtSecondRootNode:
            if (!firstNode) {
              _handler->setErrorString(tr("only one root node is allowed "
                                          "(by option)"));
              goto error;
            }
            break;
          case ParseEveryRootNode:
            ;
          }
        }
      } else if (pfisspace(c)) {
        if (c == '\n') {
          ++line;
          column = 0;
        } else {
          ++column;
        }
        state = SpaceInContent;
      } else if (c == '#') {
        if (content.size()) {
          if (!_handler->text(QString::fromUtf8(content))) {
            _handler->setErrorString(tr("cannot handle text fragment"));
            goto error;
          }
          content.clear();
          nodes.last()._hasContent = true;
        }
        state = Comment;
        quotedState = Content;
      } else if (c == '|') {
        if (content.size()) {
          if (!_handler->text(QString::fromUtf8(content))) {
            _handler->setErrorString(tr("cannot handle text fragment"));
            goto error;
          }
          content.clear();
          nodes.last()._hasContent = true;
        }
        state = BinarySurfaceOrLength;
      } else if (pfisquote(c)) {
        if (state == SpaceInContent)
          content.append(' ');
        quote = c;
        state = Quote;
        quotedState = Content;
      } else if (c == '\\') {
        if (state == SpaceInContent)
          content.append(' ');
        state = Escape;
        escapedState = Content;
      } else if (pfisspecial(c)) {
        _handler->setErrorString(tr("unexpected character '%1' "
                                    "(in Content state)")
                                 .arg(pfquotechar(c)));
        goto error;
      } else {
        if (state == SpaceInContent) {
          if (!content.isEmpty() || nodes.last()._hasContent)
            content.append(' ');
          state = Content;
        }
        content.append(c);
      }
      break;
    case Comment:
      if (c == '\n') {
        if (!options.shouldIgnoreComment()) {
          if (!_handler->comment(comment)) {
            _handler->setErrorString(tr("cannot handle comment"));
            goto error;
          }
        }
        comment.clear();
        ++line;
        column = 0;
        state = quotedState;
      } else {
        if (!options.shouldIgnoreComment())
          comment.append(c);
        ++column;
      }
      break;
    case Quote:
      if (c == quote) {
        state = quotedState;
        ++column;
      } else if (c == '\\' && quote == '"') {
        state = Escape;
        escapedState = Quote;
        ++column;
      } else {
        if (c == '\n') {
          ++line;
          column = 0;
        } else
          ++column;
        content.append(c);
      }
      break;
    case BinarySurfaceOrLength:
      if (c == '\n') {
        if (content.size() == 0) {
          _handler->setErrorString(tr("binary fragment without length"));
          goto error;
        }
        bool ok;
        qint64 l = content.toLongLong(&ok);
        if (!ok) {
          _handler->setErrorString(tr("binary fragment with incorrect length"));
          goto error;
        }
        if (!readAndFinishBinaryFragment(source, &lazyBinaryFragments, "", l,
                                         options))
          goto error;
        content.clear();
        nodes.last()._hasContent = true;
        line = 10000000; // LATER hide line numbers after first binary fragment
        column = 0;
        state = Content;
      } else {
        if (std::isspace(c)) {
          // ignore whitespace, incl. \r
        } else if (c == '|') {
          surface = content;
          content.clear();
          state = BinaryLength;
        } else if (std::isdigit(c) || std::islower(c) || std::isupper(c)
                   || c == ':') {
          content.append(c);
        } else {
          _handler->setErrorString(tr("unexpected character '%1' "
                                      "(in BinarySurfaceOrLength state)")
                                   .arg(pfquotechar(c)));
          goto error;
        }
        ++column;
      }
      break;
    case BinaryLength:
      if (c == '\n') {
        if (content.size() == 0) {
          _handler->setErrorString(tr("binary fragment without length"));
          goto error;
        }
        bool ok;
        qint64 l = content.toLongLong(&ok);
        if (!ok) {
          _handler->setErrorString(tr("binary fragment with incorrect length"));
          goto error;
        }
        if (!readAndFinishBinaryFragment(source, &lazyBinaryFragments, surface,
                                         l, options))
          goto error;
        content.clear();
        nodes.last()._hasContent = true;
        line = 10000000; // LATER hide line numbers after first binary fragment
        column = 0;
        state = Content;
      } else {
        if (std::isspace(c)) {
          // ignore whitespace, incl. \r
        } else if (std::isdigit(c)) {
          content.append(c);
        } else {
          _handler->setErrorString(tr("unexpected character '%1' "
                                      "(in BinaryLength state)")
                                   .arg(pfquotechar(c)));
          goto error;
        }
        ++column;
      }
      break;
    case ArrayHeader:
      if (c == '\n') {
        if (!content.isEmpty()) {
          array.appendHeader(QString::fromUtf8(content));
          content.clear();
        } else
          array.appendHeader(QString::number(arrayColumn));
        ++line;
        column = 0;
        state = ArrayBody;
      } else {
        if (c == ';') {
          if (!content.isEmpty()) {
            array.appendHeader(QString::fromUtf8(content));
            content.clear();
          } else
            array.appendHeader(QString::number(arrayColumn));
          ++arrayColumn;
        } else if (c == ')') {
          content.clear();
          if (!finishArray(_handler, &array, &nodes))
            goto error;
          state = nodes.size() ? Content : TopLevel;
          if (nodes.isEmpty()) {
            switch (options.rootNodesParsingPolicy()) {
            case StopAfterFirstRootNode:
              if (firstNode)
                goto stop_parsing;
              break;
            case FailAtSecondRootNode:
              if (!firstNode) {
                _handler->setErrorString(tr("only one root node is allowed "
                                            "(by option)"));
                goto error;
              }
              break;
            case ParseEveryRootNode:
              ;
            }
          }
        } else if (c == '#') {
          if (!content.isEmpty()) {
            array.appendHeader(QString::fromUtf8(content));
            content.clear();
          } else
            array.appendHeader(QString::number(arrayColumn));
          ++column;
          state = Comment;
          quotedState = ArrayBody;
        } else if (pfisspace(c)) {
          // ignore
        } else if (pfisquote(c)) {
          quote = c;
          state = Quote;
          quotedState = ArrayHeader;
        } else if (c == '\\') {
          state = Escape;
          escapedState = ArrayHeader;
        } else if (pfisspecial(c)) {
          _handler->setErrorString(tr("unexpected character '%1'"
                                      " (in ArrayHeader state)")
                                   .arg(pfquotechar(c)));
          goto error;
        } else {
          content.append(c);
        }
        ++column;
      }
      break;
    case ArrayBody:
      if (c == '\n') {
        array.appendCell(QString::fromUtf8(content));
        content.clear();
        array.appendRow();
        ++line;
        column = 0;
      } else {
        if (c == ';') {
          array.appendCell(QString::fromUtf8(content));
          content.clear();
        } else if (c == ')') {
          if (content.size())
            array.appendCell((QString::fromUtf8(content)));
          array.removeLastRowIfEmpty();
          content.clear();
          if (!finishArray(_handler, &array, &nodes))
            goto error;
          state = nodes.size() ? Content : TopLevel;
          if (nodes.isEmpty()) {
            switch (options.rootNodesParsingPolicy()) {
            case StopAfterFirstRootNode:
              if (firstNode)
                goto stop_parsing;
              break;
            case FailAtSecondRootNode:
              if (!firstNode) {
                _handler->setErrorString(tr("only one root node is allowed "
                                            "(by option)"));
                goto error;
              }
              break;
            case ParseEveryRootNode:
              ;
            }
          }
        } else if (c == '#') {
          if (content.size())
            array.appendCell((QString::fromUtf8(content)));
          content.clear();
          ++column;
          state = Comment;
          quotedState = ArrayBody;
        } else if (pfisspace(c)) {
          // ignore
        } else if (pfisquote(c)) {
          quote = c;
          state = Quote;
          quotedState = ArrayBody;
        } else if (c == '\\') {
          state = Escape;
          escapedState = ArrayBody;
        } else if (pfisspecial(c)) {
          _handler->setErrorString(tr("unexpected character '%1'"
                                      " (in ArrayBody state)")
                                   .arg(pfquotechar(c)));
          goto error;
        } else {
          content.append(c);
        }
        ++column;
      }
      break;
    case Escape:
      if (c == '\n') {
        column = 0;
        ++line;
      } else {
        if (c == 'n')
          c = '\n';
        else if (c == 'r')
          c = '\r';
        else if (c == 't')
          c = '\t';
        else if (c == '0')
          c = 0;
        else if (c == 'x') {
          state = EscapeHex;
          escapeshift = 4;
          escaped = 0;
          break;
        } else if (c == 'u') {
          state = EscapeHex;
          escapeshift = 12;
          escaped = 0;
          break;
        }
        ++column;
      }
      content.append(c);
      state = escapedState;
      break;
    case EscapeHex:
      digit = hexdigits[c];
      if (digit < 0) {
        _handler->setErrorString("bad hexadecimal digit in escape sequence");
        goto error;
      }
      if (escapeshift) {
        escaped |= digit << escapeshift;
        escapeshift -= 4;
      } else {
        if (escaped > 0x7f)
          content.append(QString(QChar(escaped|digit)).toUtf8());
        else
          content.append(QChar(escaped|digit));
        state = escapedState;
      }
      ++column;
      break;
    }
  }
stop_parsing:
  if (state != TopLevel) {
    _handler->setErrorString(tr("unexpected end of document"));
    goto error;
  }
  if (!_handler->endDocument()) {
    _handler->setErrorString(tr("cannot handle end of document"));
    goto error;
  }
  return true;
error:
  _handler->error(line, column);
  return false;
}
Ejemplo n.º 28
0
/*!
    \fn void QTextTable::insertColumns(int index, int columns)

    Inserts a number of \a columns before the column with the specified \a index.

    \sa insertRows() resize() removeRows() removeColumns() appendRows() appendColumns()
*/
void QTextTable::insertColumns(int pos, int num)
{
    Q_D(QTextTable);
    if (num <= 0)
	return;

    if (d->dirty)
        d->update();

    if (pos > d->nCols || pos < 0)
        pos = d->nCols;

//     qDebug() << "-------- insertCols" << pos << num;
    QTextDocumentPrivate *p = d->pieceTable;
    QTextFormatCollection *c = p->formatCollection();
    p->beginEditBlock();

    QList<int> extendedSpans;
    for (int i = 0; i < d->nRows; ++i) {
        int cell;
        if (i == d->nRows - 1 && pos == d->nCols) {
            cell = d->fragment_end;
        } else {
            int logicalGridIndexBeforePosition = pos > 0
                                                 ? d->findCellIndex(d->grid[i*d->nCols + pos - 1])
                                                 : -1;

            // Search for the logical insertion point by skipping past cells which are not the first
            // cell in a rowspan. This means any cell for which the logical grid index is
            // less than the logical cell index of the cell before the insertion.
            int logicalGridIndex;
            int gridArrayOffset = i*d->nCols + pos;
            do {
                cell = d->grid[gridArrayOffset];
                logicalGridIndex = d->findCellIndex(cell);
                gridArrayOffset++;
            } while (logicalGridIndex < logicalGridIndexBeforePosition
                     && gridArrayOffset < d->nRows*d->nCols);

            if (logicalGridIndex < logicalGridIndexBeforePosition
                && gridArrayOffset == d->nRows*d->nCols)
                cell = d->fragment_end;
        }

        if (pos > 0 && pos < d->nCols && cell == d->grid[i*d->nCols + pos - 1]) {
            // cell spans the insertion place, extend it
            if (!extendedSpans.contains(cell)) {
                QTextDocumentPrivate::FragmentIterator it(&p->fragmentMap(), cell);
                QTextCharFormat fmt = c->charFormat(it->format);
                fmt.setTableCellColumnSpan(fmt.tableCellColumnSpan() + num);
                p->setCharFormat(it.position(), 1, fmt);
                d->dirty = true;
                extendedSpans << cell;
            }
        } else {
            /* If the next cell is spanned from the row above, we need to find the right position
            to insert to */
            if (i > 0 && pos < d->nCols && cell == d->grid[(i-1) * d->nCols + pos]) {
                int gridIndex = i*d->nCols + pos;
                const int gridEnd = d->nRows * d->nCols - 1;
                while (gridIndex < gridEnd && cell == d->grid[gridIndex]) {
                    ++gridIndex;
                }
                if (gridIndex == gridEnd)
                    cell = d->fragment_end;
                else
                    cell = d->grid[gridIndex];
            }
            QTextDocumentPrivate::FragmentIterator it(&p->fragmentMap(), cell);
            QTextCharFormat fmt = c->charFormat(it->format);
            fmt.setTableCellRowSpan(1);
            fmt.setTableCellColumnSpan(1);
            Q_ASSERT(fmt.objectIndex() == objectIndex());
            int position = it.position();
            int cfmt = p->formatCollection()->indexForFormat(fmt);
            int bfmt = p->formatCollection()->indexForFormat(QTextBlockFormat());
            for (int i = 0; i < num; ++i)
                p->insertBlock(QTextBeginningOfFrame, position, bfmt, cfmt, QTextUndoCommand::MoveCursor);
        }
    }

    QTextTableFormat tfmt = format();
    tfmt.setColumns(tfmt.columns()+num);
    QVector<QTextLength> columnWidths = tfmt.columnWidthConstraints();
    if (! columnWidths.isEmpty()) {
        for (int i = num; i > 0; --i)
            columnWidths.insert(pos, columnWidths[qMax(0, pos-1)]);
    }
    tfmt.setColumnWidthConstraints (columnWidths);
    QTextObject::setFormat(tfmt);

//     qDebug() << "-------- end insertCols" << pos << num;
    p->endEditBlock();
}
Ejemplo n.º 29
0
bool SQLiteResultPrivate::fetchNext(SqlCachedResult::ValueCache &values, int idx, bool initialFetch)
{
    int res;
    int i;

    if (skipRow) {
        // already fetched
        Q_ASSERT(!initialFetch);
        skipRow = false;
        for(int i=0;i<firstRow.count();i++)
            values[i]=firstRow[i];
        return skippedStatus;
    }
    skipRow = initialFetch;

    if(initialFetch) {
        firstRow.clear();
        firstRow.resize(sqlite3_column_count(stmt));
    }

    if (!stmt) {
        q->setLastError(QSqlError(QCoreApplication::translate("SQLiteResult", "Unable to fetch row"),
                                  QCoreApplication::translate("SQLiteResult", "No query"), QSqlError::ConnectionError));
        q->setAt(QSql::AfterLastRow);
        return false;
    }
    res = sqlite3_step(stmt);

    switch(res) {
    case SQLITE_ROW:
        // check to see if should fill out columns
        if (rInf.isEmpty())
            // must be first call.
            initColumns(false);
        if (idx < 0 && !initialFetch)
            return true;
        for (i = 0; i < rInf.count(); ++i) {
            switch (sqlite3_column_type(stmt, i)) {
            case SQLITE_BLOB:
                values[i + idx] = QByteArray(static_cast<const char *>(
                            sqlite3_column_blob(stmt, i)),
                            sqlite3_column_bytes(stmt, i));
                break;
            case SQLITE_INTEGER:
                values[i + idx] = sqlite3_column_int64(stmt, i);
                break;
            case SQLITE_FLOAT:
                switch(q->numericalPrecisionPolicy()) {
                    case QSql::LowPrecisionInt32:
                        values[i + idx] = sqlite3_column_int(stmt, i);
                        break;
                    case QSql::LowPrecisionInt64:
                        values[i + idx] = sqlite3_column_int64(stmt, i);
                        break;
                    case QSql::LowPrecisionDouble:
                    case QSql::HighPrecision:
                    default:
                        values[i + idx] = sqlite3_column_double(stmt, i);
                        break;
                };
                break;
            case SQLITE_NULL:
                values[i + idx] = QVariant(QVariant::String);
                break;
            default:
                values[i + idx] = QString(reinterpret_cast<const QChar *>(
                            sqlite3_column_text16(stmt, i)),
                            sqlite3_column_bytes16(stmt, i) / sizeof(QChar));
                break;
            }
        }
        return true;
    case SQLITE_DONE:
        if (rInf.isEmpty())
            // must be first call.
            initColumns(true);
        q->setAt(QSql::AfterLastRow);
        sqlite3_reset(stmt);
        return false;
    case SQLITE_CONSTRAINT:
    case SQLITE_ERROR:
        // SQLITE_ERROR is a generic error code and we must call sqlite3_reset()
        // to get the specific error message.
        res = sqlite3_reset(stmt);
        q->setLastError(qMakeError(access, QCoreApplication::translate("SQLiteResult",
                        "Unable to fetch row"), QSqlError::ConnectionError, res));
        q->setAt(QSql::AfterLastRow);
        return false;
    case SQLITE_MISUSE:
    case SQLITE_BUSY:
    default:
        // something wrong, don't get col info, but still return false
        q->setLastError(qMakeError(access, QCoreApplication::translate("SQLiteResult",
                        "Unable to fetch row"), QSqlError::ConnectionError, res));
        sqlite3_reset(stmt);
        q->setAt(QSql::AfterLastRow);
        return false;
    }
    return false;
}
Ejemplo n.º 30
0
Archivo: plotter.cpp Proyecto: Qmax/PT6
void Plotter::drawCurves(QPainter *painter)
{
	//~~~~~~~~Adjust X-y Axis ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    QStringList stringList;
    bool ok=true;
    QFile textFile("AdjustXYaxisVI.txt");
    if (textFile.open(QIODevice::ReadOnly))
    {
        QTextStream textStream(&textFile);
        while (!textStream.atEnd())
        {
            stringList.append(textStream.readLine());
        }
        adjustXaxis=stringList.value(0).toDouble(&ok);
        adjustYaxis=stringList.value(1).toDouble(&ok);
    }else{
        adjustXaxis=5.5;
        adjustYaxis=0;
    }
	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    static const QColor colorForIds[8] = {Qt::red,Qt::green,Qt::cyan,Qt::magenta,Qt::yellow,Qt::white,Qt::gray,Qt::black};
    PlotSettings settings = zoomStack[curZoom];
    if( m_moveFlag == true)
    {
        settings.maxX = m_ZoomSettings->maxX;
        settings.maxY = m_ZoomSettings->maxY;
        settings.minX = m_ZoomSettings->minX;
        settings.minY = m_ZoomSettings->minY;
        settings.m_nOffset = m_ZoomSettings->m_nOffset;
        settings.numXTicks = m_ZoomSettings->numXTicks;
        settings.numYTicks = m_ZoomSettings->numYTicks;
    }
    QRect rect(Margin,Margin,width()-(2*Margin),height()-(2*Margin));
    if(m_bshowZoomRect == true)
    {
        painter->setPen(colorForIds[6]);
        painter->drawRect(rubberBandRect);
    }

    if(!rect.isValid())
        return;
    painter->setClipRect(rect.adjusted(+1,+1,-1,-1));
    QMapIterator<int, QVector<QPointF> > i(curveMap);
//    printf("Rect Left: %d\n",rect.left());
//    printf("Rect Height: %d\n",rect.height());
//    printf("Rect width: %d\n",rect.width());
//    printf("Rect Bottom: %d\n",rect.bottomLeft().y());
//    printf("Rect Top: %d\n",rect.top());
    double dx,dy;
    while(i.hasNext()){

        i.next();
        int id = i.key();
      //  qDebug() << "Curve ID" << id;
        QVector<QPointF> data = i.value();
        QPolygonF polyline(data.count());
        double y =0.0,x=0.0;
        int l_nCounter =0;
        //printf("MinY:%f\n",settings.minY);
        //printf("Offset:%f\n",m_nOffset);
        m_nOffset =0.0;
        for(int j=0; j< data.count();++j)
        {
             dx = data[j].x();
             dy = data[j].y();
             if(m_bUniPolar == true)
             {
                 float l_nDiv = (dy/2.0);
//                 printf("UniPolar %f->%f\n",l_nDiv,dy - l_nDiv);
             }
             if(( data[j].x()>=settings.minX && data[j].x()<=settings.maxX))
             {
                 //printf("X:%f Y:%f\n",dx,dy);
             }
            y =0.0,x=0.0;
            if(m_ZoomFlag == false)
            {
                if(m_bVIMode == true)
                    x = ((rect.width()/2)+adjustXaxis  + ((dx)*(((rect.width()-1)))/(settings.spanX())));
                else
                    x = (rect.left()+ ((dx)*(((rect.width()-1)))/(settings.spanX())));

                if( m_bUniPolar == true){
                    y = ((Margin+rect.bottom()) - (((dy/2.0)+settings.m_nOffset)*((rect.height()-1))/(settings.spanY())));
                    //y+=10;
//                    printf(" Coord-Y %f\n",dy/2.0);
                }
                else
                    y = (((Margin+rect.height()/2)+adjustYaxis) - ((dy+m_nOffset)*((rect.height()-1))/(settings.spanY())));//TO CHANGE THE Y AXIS IN THE GRAPH
               // printf(" Coord- X & Y %f %f\n",x,y);
            }
            else if(m_ZoomFlag == true)
            {
                x = (rect.left() + ((dx-settings.minX)*(((rect.width()-1)))/(settings.spanX())));
                y = ((Margin+rect.height()) - (((dy-settings.minY)+settings.m_nOffset)*((rect.height()-1))/(settings.spanY())));
            }
            if(( data[j].x()>=settings.minX && data[j].x()<=settings.maxX)&&(( data[j].y()>=settings.minY && data[j].y()<=settings.maxY)))
            {

            	polyline[j] = QPointF(x,y);
                l_nCounter++;
            }
        }
        QPolygonF zoomPolyline(l_nCounter);
        y =0.0,x=0.0;
        int l_nIndex1 =0;
        for(int l_nIndex=0;l_nIndex< data.count();l_nIndex++)
        {
            QPointF(x,y);
            x = polyline.at(l_nIndex).x();
            y = polyline.at(l_nIndex).y();
            //qDebug()<<x<<y;
            if(x!=0.0 || y!=0.0 )
            {
                zoomPolyline[l_nIndex1] = QPointF(x,y);
                l_nIndex1++;
            }
        }
//        if( m_nClearID == id)
//        	painter->setPen(Qt::black);
        //else
        	QPen pen;
        	painter->setPen(colorForIds[uint(id) %6]);
//        	pen.setColor(colorForIds[uint(id) %6]);
//            pen.setWidth(20);
//            painter->setPen(pen);


        if(m_ZoomFlag == false)
        {
        	painter->setPen(colorForIds[uint(id) %6]);
                painter->drawPolyline(polyline);
//            qDebug()<<"Band:"<<m_objPlotData->m_nEnvelopBand;
            //compareCurvePoints(polyline1);
        }
        else
            painter->drawPolyline(zoomPolyline);
        }
   // qDebug() << "Exit Draw Cruves.";
}