C++ QMap::lowerBound方法代码示例

void TrackView::editToggleInterpolationType()
{
	SyncDocument *doc = getDocument();

	if (editTrack < getTrackCount()) {
		SyncTrack *t = getTrack(editTrack);
		QMap<int, SyncTrack::TrackKey> keyMap = t->getKeyMap();

		QMap<int, SyncTrack::TrackKey>::const_iterator it = keyMap.lowerBound(editRow);
		if (it != keyMap.constBegin() && it.key() != editRow)
			--it;

		if (it.key() > editRow || it == keyMap.constEnd()) {
			QApplication::beep();
			return;
		}

		// copy and modify
		SyncTrack::TrackKey newKey = *it;
		newKey.type = (SyncTrack::TrackKey::KeyType)
		    ((newKey.type + 1) % SyncTrack::TrackKey::KEY_TYPE_COUNT);

		// apply change to data-set
		doc->setKeyFrame(t, newKey);

		// update user interface
		dirtyCurrentValue();
	} else
		QApplication::beep();
}

QRgb ColorElement::get_color(double v, bool smooth) {
    /* exact match */
    //if(colorMap.contains(v)) return colorMap.value(v);

    /* out of bounderies */
    if(v<=minVal) return colorMap.begin().value();
    if(v>=maxVal) return (colorMap.end()-1).value();

    /* std case */
    QMap<double,QRgb>::Iterator it=colorMap.lowerBound(v);

    if(smooth) {
        double fact=(v-(it-1).key())/((it).key()-(it-1).key());
        double fact2=1-fact;
        QRgb minVal=(it-1).value();
        QRgb maxVal=it.value();
        int r,g,b;
        r=(int)(fact2*qRed(minVal)+fact*qRed(maxVal)+0.5);
        g=(int)(fact2*qGreen(minVal)+fact*qGreen(maxVal)+0.5);
        b=(int)(fact2*qBlue(minVal)+fact*qBlue(maxVal)+0.5);

        return qRgba(r,g,b,transparence);

    }
    else {
        if(v-(it-1).key()<it.key()-v)
            return (it).value();
        else
            return (it-1).value();
    }

}

void HoleFinderPrivate::finalizeHoles()
{
  QMap<double, Hole> tmpMap;
  double totalVolume = 0.0;
  for (QVector<Hole>::const_iterator it = this->holes.constBegin(),
       it_end = this->holes.constEnd(); it != it_end; ++it) {
    double volume = it->volume();
    tmpMap.insertMulti(volume, *it);
    totalVolume += volume;
  }

  QMap<double, Hole>::const_iterator largestHole = tmpMap.constEnd() - 1;
  QMap<double, Hole>::const_iterator smallestHole =
      tmpMap.lowerBound(this->minVolume);
  if (smallestHole == tmpMap.constEnd()) {
    smallestHole = tmpMap.lowerBound(0.1 * largestHole.key());
    qWarning() << "HoleFinderPrivate::finalizeHoles No holes satisfying the "
                  "minimum specified volume of " << this->minVolume <<  "."
                  " Using a minimum volume that is 10% of the largest hole,"
               << smallestHole.key();
  }

  this->holeMap.clear();
  double trimmedVolume = 0.0;
  for (QMap<double, Hole>::const_iterator it = smallestHole,
       it_end = tmpMap.constEnd(); it != it_end; ++it) {
    trimmedVolume += it.key();
    this->holeMap.insertMulti(it.key(), it.value());
  }

  this->holes.clear();

  DEBUGOUT("finalizeHoles") "Total hole volume:" << totalVolume;
  DEBUGOUT("finalizeHoles") "Trimmed hole volume:" << trimmedVolume;
  DEBUGOUT("finalizeHoles") "Largest hole volume:" << largestHole.key();
  DEBUGOUT("finalizeHoles") "Smallest hole volume:" << smallestHole.key();
  DEBUGOUT("finalizeHoles") "Total holes:" << tmpMap.size();
  DEBUGOUT("finalizeHoles") "Trimmed holes:" << this->holeMap.size();
}

/*!
    \internal
*/
static QPair<int, int> findMissingKey(const QMap<int, QPlaceContent> &map)
{
    int start = 0;
    while (map.contains(start))
        ++start;

    QMap<int, QPlaceContent>::const_iterator it = map.lowerBound(start);
    if (it == map.end())
        return qMakePair(start, -1);

    int end = start;
    while (!map.contains(end))
        ++end;

    return qMakePair(start, end - 1);
}

float calculateRenderAccuracy(const glm::vec3& position,
        const AABox& bounds,
        float octreeSizeScale,
        int boundaryLevelAdjust) {
    float largestDimension = bounds.getLargestDimension();

    const float maxScale = (float)TREE_SCALE;
    float visibleDistanceAtMaxScale = boundaryDistanceForRenderLevel(boundaryLevelAdjust, octreeSizeScale) / OCTREE_TO_MESH_RATIO;

    static std::once_flag once;
    static QMap<float, float> shouldRenderTable;
    std::call_once(once, [&] {
        float SMALLEST_SCALE_IN_TABLE = 0.001f; // 1mm is plenty small
        float scale = maxScale;
        float factor = 1.0f;

        while (scale > SMALLEST_SCALE_IN_TABLE) {
            scale /= 2.0f;
            factor /= 2.0f;
            shouldRenderTable[scale] = factor;
        }
    });

    float closestScale = maxScale;
    float visibleDistanceAtClosestScale = visibleDistanceAtMaxScale;
    QMap<float, float>::const_iterator lowerBound = shouldRenderTable.lowerBound(largestDimension);
    if (lowerBound != shouldRenderTable.constEnd()) {
        closestScale = lowerBound.key();
        visibleDistanceAtClosestScale = visibleDistanceAtMaxScale * lowerBound.value();
    }

    if (closestScale < largestDimension) {
        visibleDistanceAtClosestScale *= 2.0f;
    }

    // FIXME - for now, it's either visible or not visible. We want to adjust this to eventually return
    // a floating point for objects that have small angular size to indicate that they may be rendered
    // with lower preciscion
    float distanceToCamera = glm::length(bounds.calcCenter() - position);
    return (distanceToCamera <= visibleDistanceAtClosestScale) ? 1.0f : 0.0f;
}

bool LODManager::shouldRender(const RenderArgs* args, const AABox& bounds) {
    const float maxScale = (float)TREE_SCALE;
    const float octreeToMeshRatio = 4.0f; // must be this many times closer to a mesh than a voxel to see it.
    float octreeSizeScale = args->_sizeScale;
    int boundaryLevelAdjust = args->_boundaryLevelAdjust;
    float visibleDistanceAtMaxScale = boundaryDistanceForRenderLevel(boundaryLevelAdjust, octreeSizeScale) / octreeToMeshRatio;
    float distanceToCamera = glm::length(bounds.calcCenter() - args->_viewFrustum->getPosition());
    float largestDimension = bounds.getLargestDimension();
    
    static bool shouldRenderTableNeedsBuilding = true;
    static QMap<float, float> shouldRenderTable;
    if (shouldRenderTableNeedsBuilding) {
        float SMALLEST_SCALE_IN_TABLE = 0.001f; // 1mm is plenty small
        float scale = maxScale;
        float factor = 1.0f;
        
        while (scale > SMALLEST_SCALE_IN_TABLE) {
            scale /= 2.0f;
            factor /= 2.0f;
            shouldRenderTable[scale] = factor;
        }
        
        shouldRenderTableNeedsBuilding = false;
    }
    
    float closestScale = maxScale;
    float visibleDistanceAtClosestScale = visibleDistanceAtMaxScale;
    QMap<float, float>::const_iterator lowerBound = shouldRenderTable.lowerBound(largestDimension);
    if (lowerBound != shouldRenderTable.constEnd()) {
        closestScale = lowerBound.key();
        visibleDistanceAtClosestScale = visibleDistanceAtMaxScale * lowerBound.value();
    }
    
    if (closestScale < largestDimension) {
        visibleDistanceAtClosestScale *= 2.0f;
    }

    return distanceToCamera <= visibleDistanceAtClosestScale;
};

void TextEditorOverlay::mapEquivalentSelections()
{
    m_equivalentSelections.clear();
    m_equivalentSelections.resize(m_selections.size());

    QMap<QString, int> all;
    for (int i = 0; i < m_selections.size(); ++i)
        all.insertMulti(selectionText(i).toLower(), i);

    const QList<QString> &uniqueKeys = all.uniqueKeys();
    foreach (const QString &key, uniqueKeys) {
        QList<int> indexes;
        QMap<QString, int>::const_iterator lbit = all.lowerBound(key);
        QMap<QString, int>::const_iterator ubit = all.upperBound(key);
        while (lbit != ubit) {
            indexes.append(lbit.value());
            ++lbit;
        }

        foreach (int index, indexes)
            m_equivalentSelections[index] = indexes;
    }

Map *TileStamp::randomVariation() const
{
    if (d->variations.isEmpty())
        return 0;

    QMap<qreal, const TileStampVariation *> probabilityThresholds;
    qreal sum = 0.0;
    for (const TileStampVariation &variation : d->variations) {
        sum += variation.probability;
        probabilityThresholds.insert(sum, &variation);
    }

    qreal random = ((qreal)rand() / RAND_MAX) * sum;
    auto it = probabilityThresholds.lowerBound(random);

    const TileStampVariation *variation;
    if (it != probabilityThresholds.end())
        variation = it.value();
    else
        variation = &d->variations.last(); // floating point may have failed us

    return variation->map;
}

int ScriptInfo::lineOffset(int lineNumber)
{
    QMap<int, int>::const_iterator it = m_lineOffsets.constFind(lineNumber);
    if (it != m_lineOffsets.constEnd())
        return it.value();

    int offset;
    it = m_lineOffsets.constFind(lineNumber - 1);
    if (it != m_lineOffsets.constEnd()) {
        offset = it.value();
        offset = m_code.indexOf(QLatin1Char('\n'), offset);
        if (offset != -1)
            ++offset;
        m_lineOffsets.insert(lineNumber, offset);
    } else {
        int index;
        it = m_lineOffsets.lowerBound(lineNumber);
        --it;
        if (it != m_lineOffsets.constBegin()) {
            index = it.key();
            offset = it.value();
        } else {
            index = m_lineNumber;
            offset = 0;
        }
        int j = index;
        for ( ; j < lineNumber; ++j) {
            m_lineOffsets.insert(j, offset);
            offset = m_code.indexOf(QLatin1Char('\n'), offset);
            if (offset == -1)
                break;
            ++offset;
        }
        m_lineOffsets.insert(j, offset);
    }
    return offset;
}

void PluginGauss::loadRefDatas()//const ProjectSettings& settings)
{
    mRefDatas.clear();
    
    QString calibPath = getRefsPath();
    QDir calibDir(calibPath);
    
    QFileInfoList files = calibDir.entryInfoList(QStringList(), QDir::Files);
    for(int i=0; i<files.size(); ++i)
    {
        if(files[i].suffix().toLower() == "csv")
        {
            QFile file(files[i].absoluteFilePath());
            if(file.open(QIODevice::ReadOnly | QIODevice::Text))
            {
                QMap<QString, QMap<double, double> > curves;
                
                QMap<double, double> curveG;
                QMap<double, double> curveG95Sup;
                QMap<double, double> curveG95Inf;
                
                QTextStream stream(&file);
                while(!stream.atEnd())
                {
                    QString line = stream.readLine();
                    if(!isComment(line))
                    {
                        QStringList values = line.split(",");
                        if(values.size() >= 3)
                        {
                            double t = values[0].toDouble();
                            
                            double g = values[1].toDouble();
                            double gSup = g + 1.96 * values[2].toDouble();
                            double gInf = g - 1.96 * values[2].toDouble();
                            
                            curveG[t] = g;
                            curveG95Sup[t] = gSup;
                            curveG95Inf[t] = gInf;
                        }
                    }
                }
                file.close();
                
                // The curves do not have 1-year precision!
                // We have to interpolate in the blanks
                
                double tmin = curveG.firstKey();
                double tmax = curveG.lastKey();
                
                for(double t=tmin; t<tmax; ++t)//t+=settings.mStep)//++t)
                {
                    if(curveG.find(t) == curveG.end())
                    {
                        // This actually return the iterator with the nearest greater key !!!
                        QMap<double, double>::const_iterator iter = curveG.lowerBound(t);
                        if(iter != curveG.end())
                        {
                            double t_upper = iter.key();
                            --iter;
                            if(iter != curveG.begin())
                            {
                                double t_under = iter.key();
                                
                                //qDebug() << t_under << " < " << t << " < " << t_upper;
                                
                                double g_under = curveG[t_under];
                                double g_upper = curveG[t_upper];
                                
                                double gsup_under = curveG95Sup[t_under];
                                double gsup_upper = curveG95Sup[t_upper];
                                
                                double ginf_under = curveG95Inf[t_under];
                                double ginf_upper = curveG95Inf[t_upper];
                                
                                curveG[t] = interpolate(t, t_under, t_upper, g_under, g_upper);
                                curveG95Sup[t] = interpolate(t, t_under, t_upper, gsup_under, gsup_upper);
                                curveG95Inf[t] = interpolate(t, t_under, t_upper, ginf_under, ginf_upper);
                            }
                            else
                            {
                                curveG[t] = 0;
                                curveG95Sup[t] = 0;
                                curveG95Inf[t] = 0;
                            }
                        }
                        else
                        {
                            curveG[t] = 0;
                            curveG95Sup[t] = 0;
                            curveG95Inf[t] = 0;
                        }
                    }
                }
                
                // Store the resulting curves :
                
                curves["G"] = curveG;
                curves["G95Sup"] = curveG95Sup;
                curves["G95Inf"] = curveG95Inf;
//.........这里部分代码省略.........