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 ImageOverlayRegionFinder::fillMaskForRegion(QBitArray &mask, const QRect ®ion)
{
for (int y = region.top(); y <= region.bottom(); y++)
{
int offset = y * m_overlay.getColumns();
mask.fill(true, offset + region.left(), offset + region.right() + 1);
}
}
void QtBinaryCalc::slot_test()
{
QBitArray *a = new QBitArray();
QBitArray *b = new QBitArray();
QBitArray *result = new QBitArray();
QString *resultString = new QString();
a->fill(0, 16);
b->fill(0, 16);
result->fill(0, 16);
for(int i = 0 ; i < this->numberA->getBytesAsBin().count() ; i++)
{
a->setBit(i, this->numberA->getBytesAsBin().at(i).digitValue() );
}
for(int i = 0 ; i < this->numberB->getBytesAsBin().count() ; i++)
{
b->setBit(i, this->numberB->getBytesAsBin().at(i).digitValue() );
}
*result = ~(*a);
SHOWVALUE(result, *result);
for ( int i = result->count()-1 ; i >= 0 ; i-- )
{
resultString->append( QString::number( (int)result->at(i) ) );
}
SHOWVALUE(resultString, *resultString);
SHOWVALUE(resultString->toInt(0, 2), resultString->toInt(0,2));//tu trzeba zrobic invert bitow 0->16, 1->15 itd
this->numberResult->slot_setValue(resultString->toInt());
SHOWVALUE(a, *a);
SHOWVALUE(b, *b);
}
void EventWinRecurrence::getCheckedDays(QBitArray &rDays) {
rDays.fill(FALSE);
if (mondayBox->isChecked())
rDays.setBit(0, 1);
if (tuesdayBox->isChecked())
rDays.setBit(1, 1);
if (wednesdayBox->isChecked())
rDays.setBit(2, 1);
if (thursdayBox->isChecked())
rDays.setBit(3, 1);
if (fridayBox->isChecked())
rDays.setBit(4, 1);
if (saturdayBox->isChecked())
rDays.setBit(5, 1);
if (sundayBox->isChecked())
rDays.setBit(6, 1);
}
//FUNKCJA ODPOWIADA ZA AKTUALIZOWANIE WYNIKU PO ZMIANIE OPERATORA PO LEWEJ STRONIE i za zmiane pol w numberA lub B.
//Dokladniejszy opis w kilkulinijkowym komentarzu pod koniec konstruktora QtBinaryCalc
void QtBinaryCalc::slot_operatorChanged(int op)
{
//int op - identyfikator operatora bitowego (1-NOT, 2-AND itd)
/////////////////////////////////////////////////////////
QBitArray a;
QBitArray b;
QBitArray result;
QString resultString;
a.fill(0, 16);
b.fill(0, 16);
result.fill(0, 16);
for(int i = 0 ; i < this->numberA->getBytesAsBin().count() ; i++)
{
a.setBit(i, this->numberA->getBytesAsBin().at(i).digitValue() );
}
for(int i = 0 ; i < this->numberB->getBytesAsBin().count() ; i++)
{
b.setBit(i, this->numberB->getBytesAsBin().at(i).digitValue() );
}
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
if(op == -1)
{
op = chooser->getOperator();
}
if (op == 1)
{
result = ~(a);
}
else
if (op == 2)
{
result = a&b;
}
else
if (op == 3)
{
result = a|b;
}
else
if (op == 4)
{
result = a^b;
}
QString resultQString;
// SHOWLINE();
for(int i = 0 ; i <= 15 ; i++)
{
SHOWONLYVALUE((int)result.at(i));
resultQString.append( QString::number(result.at(i)) );
}
this->numberResult->slot_setValue( resultQString.toInt(0, 2) );
}
/// not threadsafe
i64 DataFile::readScans(std::vector<int16> & scans_out, u64 pos, u64 num2read, const QBitArray & channelSubset, unsigned downSampleFactor)
{
if (pos > scanCt) return -1;
if (num2read + pos > scanCt) num2read = scanCt - pos;
QBitArray chset = channelSubset;
if (chset.size() != (i64)nChans) chset.fill(true, nChans);
if (downSampleFactor <= 0) downSampleFactor = 1;
unsigned nChansOn = chset.count(true);
int sizeofscans;
if ( (num2read / downSampleFactor) * downSampleFactor < num2read )
sizeofscans = ((num2read / downSampleFactor)+1) * nChansOn;
else
sizeofscans = ((num2read / downSampleFactor)) * nChansOn;
scans_out.resize(sizeofscans);
u64 cur = pos;
i64 nout = 0;
std::vector<int> onChans;
onChans.reserve(chset.size());
for (int i = 0, n = chset.size(); i < n; ++i)
if (chset.testBit(i)) onChans.push_back(i);
qint64 maxBufSize = nChans*sRate*1; // read about max 1sec worth of data at a time as an optimization
qint64 desiredBufSize = num2read*nChans; // but first try and do the entire requested read at once in our buffer if it fits within our limits..
if (desiredBufSize > maxBufSize) desiredBufSize = maxBufSize;
std::vector<int16> buf(desiredBufSize);
if (int(buf.size()) < nChans) buf.resize(nChans); // minimum read is 1 scan
while (cur < pos + num2read) {
if (!dataFile.seek(cur * sizeof(int16) * nChans)) {
Error() << "Error seeking in dataFile::readScans()!";
scans_out.clear();
return -1;
}
qint64 nr = dataFile.read(reinterpret_cast<char *>(&buf[0]), sizeof(int16) * buf.size());
if (nr < int(sizeof(int16) * nChans)) {
Error() << "Short read in dataFile::readScans()!";
scans_out.clear();
return -1;
}
int nscans = int(nr/sizeof(int16))/nChans;
if (nscans <= 0) {
Error() << "Short read in dataFile::readScans()... nscans <= 0!";
scans_out.clear();
return -1;
}
const int16 *bufptr = &buf[0];
const int onChansSize = int(onChans.size());
const int skip = nChans*downSampleFactor;
for (int sc = 0; sc < nscans && cur < pos + num2read; /* .. */) {
if (int(nChansOn) == nChans) {
i64 i_out = nout * nChans;
for (int i = 0; i < nChans; ++i)
scans_out[i_out + i] = int16(bufptr[i]);
} else {
// not all chans on, put subset 1 by 1 in the output vector
i64 i_out = nout*i64(nChansOn);
for (int i = 0; i < onChansSize; ++i)
scans_out[i_out++] = int16(bufptr[onChans[i]]);
}
++nout;
bufptr += skip;
sc += downSampleFactor;
cur += downSampleFactor;
}
}
return nout;
}
