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

bool PropertyBitmaskConverter::applyMaskWithInValues_helper(QVariant &inVariant, QVariant &outVariant)
{
    bool ok(true);
    QBitArray inBitRepres = variantToBitArray(inVariant, ok);
    qDebug()<<"In value \t"<<inBitRepres;
    if (!ok)
        return ok;
    QBitArray outBitRepres = variantToBitArray(outVariant, ok);
    qDebug()<<"Out value \t"<<outBitRepres;
    if (!ok)
        return ok;
    Q_ASSERT(!_bitmaskFromInternal.isNull());
    QBitArray maskCopy = _bitmaskFromInternal;
    if (outBitRepres.count() != 0)
        maskCopy.truncate(outBitRepres.size());
    else
        outBitRepres.resize(maskCopy.count());
    inBitRepres.truncate(maskCopy.count());
    qDebug()<<"Mask (mod)\t"<<maskCopy;

    //! \todo optimize and beautify it
    if (inVariant.type() == QVariant::Bool)
        inBitRepres = maskCopy;
    else
        inBitRepres &= (maskCopy);//get only masked bits
    outBitRepres &= (~maskCopy);//clear mask bits
    outBitRepres |= inBitRepres;//set relevant bits from mask
    qDebug()<<"Out res\t"<<outBitRepres;

    return variantFromBitArray(outVariant, outBitRepres);
}

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;
}

// Compare images:
QBitArray OKFilter::imageToVect(const QString &inputImage)
{
    // Check src file:
    QFileInfo fi(inputImage);

    // Check files:
    if (!fi.exists())
        return QBitArray();

    QImage img(inputImage);
    if (img.isNull())
        return QBitArray();
    QBitArray result;
    result.resize(img.width()*img.height());
    int c = 0;
    for (int j=0; j<img.height(); j++)
        for (int i=0; i<img.width(); i++)
        {
            QRgb color = img.pixel(i, j);
            int alpha = qAlpha(color);
            result[c++] = (alpha>0);
        }

    return result;
}

QByteArray dehuffman(QByteArray data, MainWindow *mainWindow)
{
	QHash<quint8, QBitArray> codes;
	qint32 size;
	QBitArray bits;
	{
		QDataStream stream(data);
		stream >> codes >> size >> bits;
		Q_ASSERT(stream.status() == QDataStream::Ok);
	}

	QHash<QBitArray, quint8> table;
	for (int i = 0; i < tableSize; ++i)
		if (codes.contains(i))	table[codes[i]] = i;

	QByteArray result;
	result.reserve(data.size());

	int index = 0;
	for (int i = 0; i < size; ++i)
	{
		mainWindow->setProgress(qRound(static_cast<qreal>(100 * i) / size));

		QBitArray b;
		while (!table.contains(b))
		{
			b.resize(b.size() + 1);
			if (bits[index])	b.setBit(b.size() - 1);
			++index;
		}
		result.append(table[b]);
	}

	return result;
}

void tst_QBitArray::countBits2()
{
    QBitArray bitArray;
    for (int i = 0; i < 4017; ++i) {
        bitArray.resize(i);
        bitArray.fill(true);
        QCOMPARE(bitArray.count(true), i);
        QCOMPARE(bitArray.count(false), 0);
        bitArray.fill(false);
        QCOMPARE(bitArray.count(true), 0);
        QCOMPARE(bitArray.count(false), i);
    }
}

void tst_QBitArray::resize()
{
    // -- check that a resize handles the bits correctly
    QBitArray a = QStringToQBitArray(QString("11"));
    a.resize(10);
    QVERIFY(a.size() == 10);
    QCOMPARE( a, QStringToQBitArray(QString("1100000000")) );

    a.setBit(9);
    a.resize(9);
    // now the bit in a should have been gone:
    QCOMPARE( a, QStringToQBitArray(QString("110000000")) );

    // grow the array back and check the new bit
    a.resize(10);
    QCOMPARE( a, QStringToQBitArray(QString("1100000000")) );

    // other test with and
    a.resize(9);
    QBitArray b = QStringToQBitArray(QString("1111111111"));
    b &= a;
    QCOMPARE( b, QStringToQBitArray(QString("1100000000")) );

}

/**
 * Helper function to initialize a bitarray from a string
 */
static QBitArray QStringToQBitArray(const QString &str)
{
    QBitArray ba;
    ba.resize(str.length());
    int i;
    QChar tru('1');
    for (i = 0; i < str.length(); i++)
    {
        if (str.at(i) == tru)
        {
            ba.setBit(i, true);
        }
    }
    return ba;
}

void KoList::setContinueNumbering(int level, bool enable)
{
    Q_ASSERT(level > 0 && level <= 10);
    level = qMax(qMin(level, 10), 1);

    QBitArray bitArray = d->properties[ContinueNumbering].toBitArray();
    if (bitArray.isEmpty())
        bitArray.resize(10);
    bitArray.setBit(level-1, enable);
    d->properties[ContinueNumbering] = bitArray;

    QTextList *textList = d->textLists.value(level-1).data();
    if (!textList)
        return;
    QTextListFormat format = textList->format();
    if (enable) {
        format.setProperty(KListStyle::ContinueNumbering, true);
    } else {
        format.clearProperty(KListStyle::ContinueNumbering);
    }
    textList->setFormat(format);
}

void CFillTool::doFill() {
	// This is not the nicest code, but.. it works?

	auto map = widget()->map();
	int toReplace = map->get(m_whatType, m_hovered);

	if (toReplace == m_whatValue)
		return;

	QBitArray checked;
	checked.resize(map->width() * map->height());

	QQueue<CMapPoint> queue;
	queue.enqueue(m_hovered);

	while (!queue.isEmpty()) {
		CMapPoint point = queue.dequeue();

		int bitID = ((point.x / 2) * map->width()) + point.y;
		checked.setBit(bitID);

		CEditCommand::Change change;
		change.before = toReplace;
		change.after = m_whatValue;
		change.type = m_whatType;
		change.pos = point;
		m_command->changes.append(change);

		// Check every side to see what we've got to add to the list
		CMapPoint nw = point;
		nw.moveNW();
		int nwBit = ((nw.x / 2) * map->width()) + nw.y;
		if (map->positionValid(nw) && !checked.testBit(nwBit) && map->get(m_whatType, nw) == toReplace) {
			checked.setBit(nwBit);
			queue.enqueue(nw);
		}

		CMapPoint ne = point;
		ne.moveNE();
		int neBit = ((ne.x / 2) * map->width()) + ne.y;
		if (map->positionValid(ne) && !checked.testBit(neBit) && map->get(m_whatType, ne) == toReplace) {
			checked.setBit(neBit);
			queue.enqueue(ne);
		}

		CMapPoint sw = point;
		sw.moveSW();
		int swBit = ((sw.x / 2) * map->width()) + sw.y;
		if (map->positionValid(sw) && !checked.testBit(swBit) && map->get(m_whatType, sw) == toReplace) {
			checked.setBit(swBit);
			queue.enqueue(sw);
		}

		CMapPoint se = point;
		se.moveSE();
		int seBit = ((se.x / 2) * map->width()) + se.y;
		if (map->positionValid(se) && !checked.testBit(seBit) && map->get(m_whatType, se) == toReplace) {
			checked.setBit(seBit);
			queue.enqueue(se);
		}
	}

/*	while (!queue.isEmpty()) {
		CMapPoint point = queue.dequeue();

		// First off, check the NW side of this point
		CMapPoint check = point;

		while (true) {
			check.moveNW();
			if (!map->positionValid(check))
				break;
			if (map->get(m_whatType, check) != toReplace)
				break;

			int bitID = ((check.x / 2) * map->width()) + check.y;
			if (checked.testBit(bitID))
				break;
			checked.setBit(bitID);

			CEditCommand::Change change;
			change.before = toReplace;
			change.after = m_whatValue;
			change.type = m_whatType;
			change.pos = check;
			m_command->changes.append(change);

			// Check if we need to add anything SW/NE of this one
			CMapPoint checkSW = check;
			checkSW.moveSW();
			if (map->positionValid(checkSW) && map->get(m_whatType, checkSW) == toReplace)
				queue.enqueue(checkSW);

			CMapPoint checkNE = check;
			checkNE.moveNE();
			if (map->positionValid(checkNE) && map->get(m_whatType, checkNE) == toReplace)
				queue.enqueue(checkNE);
		}

		// Now check the SE side
//.........这里部分代码省略.........

bool Compress::compress() {
    File * f = new File(m_path, m_fileName);
    QByteArray qba = f->read();
    if (qba != NULL) {
        CountOccurrence * co = new CountOccurrence(qba);
        QList<Occurrence> occur = co->orderByOccurrence();
        HuffmanTree * cht = new HuffmanTree(occur);
        Tree * tree = cht->createTree();
        tree->createRep();
        cht->createHash(tree);

        QString data;
        for (int i = 0; i < qba.size(); ++i) {
            QString pathNode = cht->hash()->value(qba.at(i));
            data.append(pathNode);
        }

        int garbageSize = 8 - data.size()%8;
        if (garbageSize == 8) {
            garbageSize = 0;
        }
        for (int i = 0; i < garbageSize; ++i) {
            data.append("0");
        }

        QBitArray toByte;
        toByte.resize(data.size());
        for (int i = 0; i < data.size(); ++i) {
            if (data.at(i) == '0') {
                toByte[i] = true;
            }
            else {
                toByte[i] = false;
            }
        }

        bool ok;
        QByteArray encoded;
        QString c;
        for (int i = 0; i < data.size(); i+=8) {
            QString h = data.mid(i,8);
            encoded.append(QChar(h.toInt(&ok, 2)));
            c.append(h);
        }

        QString binaryGarbageSize = QString::number(garbageSize,2);
        QString binaryTreeSize = QString::number(tree->rep().size(),2);
        int zeros = 16 - (binaryGarbageSize.size() + binaryTreeSize.size());
        for (int i = 0; i < zeros; ++i) {
            binaryTreeSize.prepend(QString::number(0));
        }

        QString toBit = binaryGarbageSize;
        toBit.append(binaryTreeSize);

        int h1 = toBit.mid(0,8).toInt(&ok, 2);
        int h2 = toBit.mid(8,8).toInt(&ok, 2);

        QByteArray toWrite;
        toWrite.clear();
        toWrite.append(QChar(h1));
        toWrite.append(QChar(h2));
        toWrite.append(m_fileName);

        for (int i = m_fileName.size(); i < 128; ++i ) {
            toWrite.append("#");
        }

        toWrite.append(tree->rep());
        toWrite.append(encoded);

        f->write(toWrite, m_path + m_compressedFileName);

        qDebug() << m_fileName << " comprimido";

        return true;
    } else {
        qDebug() << "Arquivo não encontrado";

        return false;
    }
}

QByteArray huffman(QByteArray data, MainWindow *mainWindow)
{
	// count
	int count[tableSize];
	qFill(&count[0], &count[tableSize - 1], 0);
	for (int i = 0; i < data.size(); ++i)
		++count[static_cast<quint8>(data[i])];

	QMultiMap<int, QList<QPair<quint8, QBitArray> > > p; // <count, <symbol, code> >
	for (int i = 0; i < tableSize; ++i)
	{
		if (count[i] == 0)	continue;

		QList<QPair<quint8, QBitArray> > list;
		list.append(qMakePair(static_cast<quint8>(i), QBitArray()));
		p.insert(count[i], list);
	}

	// caculate codes from bottom to top
	while (p.size() > 1)
	{
		const int count0 = p.begin().key();
		QList<QPair<quint8, QBitArray> > list0 = p.begin().value();
		p.erase(p.begin());

		const int count1 = p.begin().key();
		QList<QPair<quint8, QBitArray> > list1 = p.begin().value();
		p.erase(p.begin());

		for (QList<QPair<quint8, QBitArray> >::Iterator iter = list0.begin(); iter != list0.end(); ++iter)
		{
			iter->second.resize(iter->second.size() + 1);
			iter->second.setBit(iter->second.size() - 1, false);
		}

		for (QList<QPair<quint8, QBitArray> >::Iterator iter = list1.begin(); iter != list1.end(); ++iter)
		{
			iter->second.resize(iter->second.size() + 1);
			iter->second.setBit(iter->second.size() - 1, true);
		}
		p.insert(count0 + count1, list0 + list1);
	}

	// extract codes
	QHash<quint8, QBitArray> codes;
	for (QList<QPair<quint8, QBitArray> >::ConstIterator iter = p.begin().value().constBegin(); iter != p.begin().value().constEnd(); ++iter)
	{
		QBitArray code;
		code.resize(iter->second.size());
		for (int j = 0; j < code.size(); ++j)
			if (iter->second[code.size() - j - 1])
				code.setBit(j);
		codes[iter->first] = code;
	}

	// encode
	QBitArray bits;
	for (int i = 0; i < data.size(); ++i)
	{
		mainWindow->setProgress(qRound(static_cast<qreal>(100 * i) / data.size()));

		const QBitArray &code = codes[static_cast<quint8>(data[i])];
		const int oldSize = bits.size();
		bits.resize(oldSize + code.size());

		for (int i = 0; i < code.size(); ++i)
			if (code[i])	bits.setBit(oldSize + i);
	}

	QByteArray result;
	{
		QDataStream stream(&result, QIODevice::WriteOnly);
		stream << codes << static_cast<qint32>(data.size()) << bits;
	}

	return result;
}

void SerialDecoderNode::inputsUpdated( qint64 pTimeStamp )
{
	if( mPinInputBits->isUpdated( pTimeStamp ) )
	{
		QBitArray	InpDat = variant( mPinInputBits ).toBitArray();

		if( !InpDat.isEmpty() )
		{
			QBitArray		SrcDat;
			QByteArray		DstDat;

			// Prepend any buffered data

			if( !mBitBuf.isEmpty() )
			{
				int		InpSze = InpDat.size();
				int		BufSze = mBitBuf.size();

				SrcDat.resize( BufSze + InpSze );

				for( int i = 0 ; i < BufSze ; i++ )
				{
					SrcDat.setBit( i, mBitBuf.testBit( i ) );
				}

				for( int i = 0 ; i < InpSze ; i++ )
				{
					SrcDat.setBit( BufSze + i, InpDat.testBit( i ) );
				}

				mBitBuf.clear();
			}
			else
			{
				SrcDat.swap( InpDat );
			}

			// Look for data

//			qDebug() << "R:" << SrcDat;

			int SrcOff;

			for( SrcOff = 0 ; SrcOff < SrcDat.size() - 9 ; )
			{
				if( SrcDat.testBit( SrcOff ) || !SrcDat.testBit( SrcOff + 9 ) )
				{
					SrcOff++;

					continue;
				}

				QBitArray	T( 8 );

				quint8		C = 0;

				for( int j = 0 ; j < 8 ; j++ )
				{
					C |= ( SrcDat.testBit( SrcOff + 1 + j ) ? 0x01 : 0x00 ) << j;

					T.setBit( j, SrcDat.testBit( SrcOff + 1 + j ) );
				}

//				qDebug() << SrcOff << T;

				DstDat.append( C );

				SrcOff += 10;
			}

			if( SrcOff < SrcDat.size() )
			{
				if( SrcOff > 0 )
				{
					mBitBuf.resize( SrcDat.size() - SrcOff );

					for( int i = 0 ; i < mBitBuf.size() ; i++ )
					{
						mBitBuf.setBit( i, SrcDat.testBit( SrcOff + i ) );
					}
				}
				else
				{
					SrcDat.swap( mBitBuf );
				}

//				qDebug() << "B" << mBitBuf;
			}

			if( !DstDat.isEmpty() )
			{
				mValOutputData->setVariant( DstDat );

				pinUpdated( mPinOutputData );
			}
		}
	}
}