C++ QBitArray::clearBit方法代码示例

quint32 CBerBitStringStorage::deserialize(CBerByteArrayInputStream& iStream, QObject* obj, CBerLength& length, quint32 codeLength)
{
	length.decode(iStream);
	qDebug() << "CBerBitStringStorage::deserialize, length extracted: " << length.getVal();

	qint32 lenVal = length.getVal();

	QByteArray data(lenVal, Qt::Initialization::Uninitialized);

	if (data.size() > 0)
	{
		QBitArray val;

		qint32 rdLength = iStream.read(data, 0, lenVal);
		if (rdLength == lenVal)
		{
			val.resize(rdLength);
			for (qint32 i=0; i<rdLength; ++i)
			{
				if (data[i]) val.setBit(i);
				else val.clearBit(i);
			}

			codeLength += rdLength + 1;

			QBitArray* pVal = &val;
			QVariant wrvar(PtrMetaTypes::s_QBitArrayPtrMetaType, &pVal);
			obj->metaObject()->property(3).write(obj, wrvar);
		}
	}

	return codeLength;
}

void KisConvolutionFilter::process(KisConstProcessingInformation srcInfo,
                                   KisProcessingInformation dstInfo,
                                   const QSize& size,
                                   const KisFilterConfiguration* config,
                                   KoUpdater* progressUpdater
                                  ) const
{
    Q_UNUSED(config);

    const KisPaintDeviceSP src = srcInfo.paintDevice();
    KisPaintDeviceSP dst = dstInfo.paintDevice();
    QPoint dstTopLeft = dstInfo.topLeft();
    QPoint srcTopLeft = srcInfo.topLeft();
    Q_ASSERT(src != 0);
    Q_ASSERT(dst != 0);

    KisConvolutionPainter painter(dst, dstInfo.selection());

    QBitArray channelFlags;
    if (config) {
        channelFlags = config->channelFlags();
    }
    if (channelFlags.isEmpty() || !config) {
        channelFlags = QBitArray(src->colorSpace()->channelCount(), true);
    }
 
    // disable alpha channel
    channelFlags.clearBit(1);

    painter.setChannelFlags(channelFlags);
    painter.setProgress(progressUpdater);
    painter.applyMatrix(m_matrix, src, srcTopLeft, dstTopLeft, size, BORDER_REPEAT);

}

void HoleFinderPrivate::mergeHoles()
{
  // Make copy, clear original, add merged holes back into original
  QVector<Hole> holeCopy (this->holes);
  const int numHoles = this->holes.size();
  this->holes.clear();
  this->holes.reserve(numHoles);

  // If the bit is on, it has not been merged. If off, it has been.
  QBitArray mask (holeCopy.size(), true);

  // Check each pair of unmerged holes. If one contains the other, merge them.
  QVector<Hole*> toMerge;
  toMerge.reserve(256); // Way bigger than we need, but certainly sufficient

  // Temp vars
  Eigen::Vector3d diffVec;

  // "i" indexes the "base" hole
  for (int i = 0; i < numHoles; ++i) {
    if (!mask.testBit(i))
      continue;

    mask.clearBit(i);
    Hole &hole_i = holeCopy[i];

    toMerge.clear();
    toMerge.reserve(256);
    toMerge.push_back(&hole_i);

    // "j" indexes the compared holes
    for (int j = i+1; j < numHoles; ++j) {
      if (!mask.testBit(j))
        continue;

      Hole &hole_j = holeCopy[j];

      diffVec = hole_j.center - hole_i.center;

      // Use the greater of the two radii
      const double rad = (hole_i.radius > hole_j.radius)
          ? hole_i.radius : hole_j.radius;
      const double radSq = rad * rad;

      // Check periodic conditions
      // Convert diffVec to fractional units
      this->cartToFrac(&diffVec);
      // Adjust each component to range [-0.5, 0.5] (shortest representation)
      while (diffVec.x() < -0.5) ++diffVec.x();
      while (diffVec.y() < -0.5) ++diffVec.y();
      while (diffVec.z() < -0.5) ++diffVec.z();
      while (diffVec.x() > 0.5) --diffVec.x();
      while (diffVec.y() > 0.5) --diffVec.y();
      while (diffVec.z() > 0.5) --diffVec.z();
      // Back to cartesian
      this->fracToCart(&diffVec);

      // if j is within i's radius, add "j" to the merge list
      // and mark "j" as merged
      if (fabs(diffVec.x()) > rad ||
          fabs(diffVec.y()) > rad ||
          fabs(diffVec.z()) > rad ||
          fabs(diffVec.squaredNorm()) > radSq)
        continue; // no match

      // match:
      // Reset j's position to account for periodic wrap-around
      hole_j.center = hole_i.center + diffVec;
      mask.clearBit(j);
      toMerge.push_back(&hole_j);
    }

    if (toMerge.size() == 1)
      this->holes.push_back(hole_i);
    else
      this->holes.push_back(reduceHoles(toMerge));
  }
}