void ArtworkUploader::doUploadArtworks(const QVector<ArtworkMetadata *> &artworkList) {
int artworksCount = artworkList.length();
if (artworksCount == 0) {
return;
}
UploadInfoRepository *uploadInfoRepository = m_CommandManager->getUploadInfoRepository();
const QVector<Models::UploadInfo *> &infos = uploadInfoRepository->getUploadInfos();
const Encryption::SecretsManager *secretsManager = m_CommandManager->getSecretsManager();
const Models::SettingsModel *settingsModel = m_CommandManager->getSettingsModel();
uploadInfoRepository->resetPercents();
uploadInfoRepository->updatePercentages();
m_UploadCoordinator->uploadArtworks(artworkList, infos, m_IncludeVector, secretsManager, settingsModel);
m_CommandManager->reportUserAction(Conectivity::UserActionUpload);
}
void FrameNumberVisualizator::rescale(){
EulerDataSeries * buffer= static_cast<EulerDataSeries *>( curve->data() );
if(buffer==NULL||buffer==0)
return;
QVector<double> values = buffer->getData();
if(values.isEmpty())
return;
double max = 0;
for(int i=0;i<values.length();i++){
if(values[i]>max)
max=values[i];
}
plot->setAxisScale(QwtPlot::yLeft,max - 500 ,max + 500);
}
void WarningsService::submitItems(const QVector<Models::ArtworkMetadata *> &items) {
if (m_WarningsWorker == NULL) {
return;
}
int length = items.length();
std::vector<std::shared_ptr<WarningsItem> > itemsToSubmit;
itemsToSubmit.reserve(length);
for (int i = 0; i < length; ++i) {
Models::ArtworkMetadata *item = items.at(i);
itemsToSubmit.emplace_back(new WarningsItem(item));
}
LOG_INFO << "Submitting" << length << "item(s)";
m_WarningsWorker->submitItems(itemsToSubmit);
}
void Neuron::TurningWeight(float time, QVector<float> data)
{
if(this->weight.length() != data.length())
return;
float var1 = -1 * time / Param_1;
float result1 = LearningRate * expf(var1);
float var2 = -1 * time / Param_2;
float result2 = NeighborDis * expf(var2);
GaussianValue = expf((-1.0) * (DisWithWinner * DisWithWinner) / 2.0 * (result2 * result2));
for(int i=0; i<this->weight.length(); i++)
{
float var3 = data[i] - weight[i];
weight[i] += result1 * GaussianValue * var3;
}
}
void MainWindow::addButtons(QVector<QPushButton *> buttonList, QScrollArea *symbolScrollArea, QString labelText)
{
iter = 0;
row++, column = 0;
symbolLabel = new QLabel(this);
QString HTMLtext = "<b>" + labelText + "</b>";
symbolLabel->setText(HTMLtext);
symbolLayout->addWidget(symbolLabel, row, column);
row++, column = -1;
foreach(symbolButton, buttonList)
{
if(column == 5)
{
column = 0;
row++;
}
else
column++;
symbolButton->setStyleSheet("background-color : rgba(50,50,50,100%);"
"color: white;"
"border-style: solid;"
"border-width: 2px;"
"border-color: rgba(255,255,255,90%);");
symbolButton->setMinimumHeight(symbolScrollArea->height() / 5);
symbolLayout->addWidget(symbolButton, row, column);
connect(symbolButton, SIGNAL(clicked()), this, SLOT(onNotationClicked()));
iter++;
if(iter == buttonList.length())
{
row++;
column = -1;
}
}
}
void MetadataIOCoordinator::writeMetadata(const QVector<Models::ArtworkMetadata *> &artworksToWrite, bool useBackups) {
m_WritingWorker = new MetadataWritingWorker(artworksToWrite,
m_CommandManager->getSettingsModel(),
useBackups);
QThread *thread = new QThread();
m_WritingWorker->moveToThread(thread);
QObject::connect(thread, SIGNAL(started()), m_WritingWorker, SLOT(process()));
QObject::connect(m_WritingWorker, SIGNAL(stopped()), thread, SLOT(quit()));
QObject::connect(m_WritingWorker, SIGNAL(stopped()), m_WritingWorker, SLOT(deleteLater()));
QObject::connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
QObject::connect(m_WritingWorker, SIGNAL(finished(bool)), this, SLOT(writingWorkerFinished(bool)));
QObject::connect(this, SIGNAL(metadataWritingFinished()), m_WritingWorker, SIGNAL(stopped()));
setProcessingItemsCount(artworksToWrite.length());
qDebug() << "Starting metadata writing thread";
thread->start();
}
void MetaModelPayload::setBlendedVertices(int blendNumber, const QVector<BlendshapeOffset>& blendshapeOffsets, const QVector<int>& blendedMeshSizes, const render::ItemIDs& subRenderItems) {
PROFILE_RANGE(render, __FUNCTION__);
if (blendNumber < _appliedBlendNumber) {
return;
}
_appliedBlendNumber = blendNumber;
// We have fewer meshes than before. Invalidate everything
if (blendedMeshSizes.length() < (int)_blendshapeBuffers.size()) {
_blendshapeBuffers.clear();
}
int index = 0;
for (int i = 0; i < blendedMeshSizes.size(); i++) {
int numVertices = blendedMeshSizes.at(i);
// This mesh isn't blendshaped
if (numVertices == 0) {
_blendshapeBuffers.erase(i);
continue;
}
const auto& buffer = _blendshapeBuffers.find(i);
const auto blendShapeBufferSize = numVertices * sizeof(BlendshapeOffset);
if (buffer == _blendshapeBuffers.end()) {
_blendshapeBuffers[i] = std::make_shared<gpu::Buffer>(blendShapeBufferSize, (gpu::Byte*) blendshapeOffsets.constData() + index * sizeof(BlendshapeOffset), blendShapeBufferSize);
} else {
buffer->second->setData(blendShapeBufferSize, (gpu::Byte*) blendshapeOffsets.constData() + index * sizeof(BlendshapeOffset));
}
index += numVertices;
}
render::Transaction transaction;
for (auto& id : subRenderItems) {
transaction.updateItem<ModelMeshPartPayload>(id, [this, blendedMeshSizes](ModelMeshPartPayload& data) {
data.setBlendshapeBuffer(_blendshapeBuffers, blendedMeshSizes);
});
}
AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
}
void ArtworksRepository::cleanupEmptyDirectories() {
LOG_DEBUG << "#";
int count = m_DirectoriesList.length();
QVector<int> indicesToRemove;
indicesToRemove.reserve(count);
for (int i = 0; i < count; ++i) {
const QString &directory = m_DirectoriesList[i];
if (m_DirectoriesHash[directory] == 0) {
indicesToRemove.append(i);
}
}
if (!indicesToRemove.isEmpty()) {
LOG_INFO << indicesToRemove.length() << "empty directory(ies)...";
QVector<QPair<int, int> > rangesToRemove;
Helpers::indicesToRanges(indicesToRemove, rangesToRemove);
removeItemsAtIndices(rangesToRemove);
}
}
void SpellCheckerService::submitItems(const QVector<ISpellCheckable *> &itemsToCheck) {
if (!m_WorkerIsAlive) { return; }
if (m_SpellCheckWorker != NULL && !m_SpellCheckWorker->isCancelled()) {
QVector<SpellCheckItemBase *> items;
int length = itemsToCheck.length();
items.reserve(length);
for (int i = 0; i < length; ++i) {
SpellCheck::ISpellCheckable *itemToCheck = itemsToCheck.at(i);
SpellCheckItem *item = new SpellCheckItem(itemToCheck, Common::SpellCheckAll);
itemToCheck->connectSignals(item);
items.append(item);
}
qInfo() << "SpellCheck service: about to submit" << length << "items";
m_SpellCheckWorker->submitItems(items);
m_SpellCheckWorker->submitItem(new SpellCheckSeparatorItem());
}
}
// horizontalPoints is an auxiliar method for the button position computation.
// starts from a known center and keeps adding elements horizontally
// and returns the computed positions.
QVector<QPoint> ButtonHandler::horizontalPoints(
const QPoint ¢er, const int elements, const bool leftToRight) const
{
QVector<QPoint> res;
// Distance from the center to start adding buttons
int shift = 0;
if (elements % 2 == 0) {
shift = m_buttonExtendedSize * (elements / 2) - (m_separator / 2);
} else {
shift = m_buttonExtendedSize * ((elements-1) / 2) + m_buttonBaseSize / 2;
}
if (!leftToRight) { shift -= m_buttonBaseSize; }
int x = leftToRight ? center.x() - shift :
center.x() + shift;
QPoint i(x, center.y());
while (elements > res.length()) {
res.append(i);
leftToRight ? i.setX(i.x() + m_buttonExtendedSize) :
i.setX(i.x() - m_buttonExtendedSize);
}
return res;
}
// verticalPoints is an auxiliar method for the button position computation.
// starts from a known center and keeps adding elements vertically
// and returns the computed positions.
QVector<QPoint> ButtonHandler::verticalPoints(
const QPoint ¢er, const int elements, const bool upToDown) const
{
QVector<QPoint> res;
// Distance from the center to start adding buttons
int shift = 0;
if (elements % 2 == 0) {
shift = m_buttonExtendedSize * (elements / 2) - (m_separator / 2);
} else {
shift = m_buttonExtendedSize * ((elements-1) / 2) + m_buttonBaseSize / 2;
}
if (!upToDown) { shift -= m_buttonBaseSize; }
int y = upToDown ? center.y() - shift :
center.y() + shift;
QPoint i(center.x(), y);
while (elements > res.length()) {
res.append(i);
upToDown ? i.setY(i.y() + m_buttonExtendedSize) :
i.setY(i.y() - m_buttonExtendedSize);
}
return res;
}
void CSV::exportActorColors(QString path, QVector<int> actorIds, QVector<QString> colorCode)
{
QFile f(path);
if (f.open(QFile::WriteOnly | QFile::Truncate))
{
QTextStream data( &f );
QStringList strList;
//appending data
for (int row=0; row < actorIds.length(); row++)
{
strList.clear();
strList << QString::number(actorIds.at(row));
strList << colorCode.at(row);
data << strList.join(",") + "\n";
// qDebug() << strList;
}
f.close();
}
}
void MainWindow::on_btnRemove_clicked()
{
QModelIndexList selected = ui->listView->selectionModel()->selectedIndexes();
if (!selected.isEmpty())
{
QString str = list.at(selected.first().row());
QVector<QString> vRemove = readFile(str);
for(int i = 0; i < vGlobal.length(); i++)
for(int k = 0; k < vRemove.length(); k++)
{
if(vGlobal.at(i) == vRemove.at(k))
{
vGlobal.removeAt(i);
showDataInTableView(tvModel, vGlobal);
ui->tableView->setModel(tvModel);
}
}
QStandardItemModel *tModel = new QStandardItemModel(0,0,this);
tModel->setHorizontalHeaderItem(0, new QStandardItem(QString("Site A")));
tModel->setHorizontalHeaderItem(1, new QStandardItem(QString("Site B")));
showDataInTableView(tModel, vGlobal);
ui->tableView->setModel(tModel);
list.removeAt(selected.first().row());
((QStringListModel*) ui->listView->model())->setStringList(list);
vRemove.clear();
if(list.isEmpty())
ui->btnRemove->setEnabled(false);
ui->btnStart->setEnabled(false);
}
}
void WireCreator::createLine()
{
QVector<int> usedPoints;
int currPoint=deadEnds[0];
//currPath.push_back(vertices[currPoint]);
usedPoints.push_back(currPoint);
//while(currPoint!=deadEnds.last()){
while(deadEnds.indexOf(currPoint)==-1||usedPoints.length()==1){
for(auto p: edges){
if(p.first==currPoint){
currPoint=p.second;
break;
}
}
//currPath.push_back(vertices[currPoint]);
usedPoints.push_back(currPoint);
}
//usedPoints.pop_back();
qDebug()<<containsAllE(usedPoints);
//modifiedPath=currPath;
//qDebug()<<currPath;
rawPath=usedPoints;
}
void MainWindow::on_btnSelectDB_clicked()
{
model = new QStringListModel(this);
QString fileName = getFileName();
QVector<QString> vRead = readFile(fileName);
for(int i = 0; i < vRead.length(); i++)
vGlobal.append(vRead.at(i));
vRead.clear();
showDataInTableView(tvModel, vGlobal);
setListViewElements(fileName);
ui->tableView->setModel(tvModel);
model->setStringList(list);
ui->listView->setModel(model);
}
bool CGDReader::makeCGData(QVector<QVector<double> > p3r, QVector<QVector<int> > ftr, CGData* cgd) {
cgd->pointAmount = p3r.length() - 1;
cgd->surfaceAmount = ftr.length() - 1;
cgd->verticesData = new CGPoint[p3r.length() - 1];
for(int i = 1; i < p3r.length(); i ++) {
cgd->verticesData[i - 1].x = p3r[i][1];
cgd->verticesData[i - 1].y = p3r[i][2];
cgd->verticesData[i - 1].z = p3r[i][3];
cgd->verticesData[i - 1].rear = p3r[i][4];
}
cgd->surfacesData = new CGFace[ftr.length() - 1];
for(int i = 1; i < ftr.length(); i ++) {
cgd->surfacesData[i - 1].vertexAmount = ftr[i][0];
cgd->surfacesData[i - 1].vertices = new int[ftr[i].length()];
for(int j = 1; j <= ftr[i][0]; j ++) {
cgd->surfacesData[i - 1].vertices[j - 1] = ftr[i][j];
}
}
return true;
}
QString Rig::ApplyDrawToCanvas(QPainter *painter, const QMatrix4x4 view, const QMatrix4x4 perspective, const int width, const int hei)
{
if (skeleton != NULL && skin != NULL && bindMesh != NULL){
// skeleton->SetRotation(QVector3D(0,0,90), 20);
// ++ang;
// for (int i = 0; i <= skeleton->joints.length(); i++)
// skeleton->SetRotation(QVector3D(-ang , 0, 0), i);
// //skeleton->SetRotation(QVector3D(ang, ang+=5, ang), 0);
BendSkinToSkeleton();
}
// vertexes
// ...
QVector<QVector2D> Vertexes2D = From3DTo2D(bindMesh->vertexes, view, perspective);
QVector<QVector2D> Vertexes2DBend;
QVector<QPoint> appliedToScreenCoords;
QVector<QPoint> appliedToScreenCoordsBended;
if (bendedMesh != NULL)Vertexes2DBend = From3DTo2D(bendedMesh->vertexes, view, perspective);
for (int curPoint = 0; curPoint < Vertexes2D.length(); curPoint++)
{
int x,y;
painter->setPen(ChangeQPainter(QColor(0,255, 0,120), 4));
if (ApplyScreen(x,y, Vertexes2D[curPoint], width, hei))
painter->drawPoint(x,y);
appliedToScreenCoords << QPoint(x,y);
// ...
// bended mods
if (bendedMesh != NULL)
{
int xb,yb;
painter->setPen(ChangeQPainter(QColor(255,150,0,255), 2));
if (ApplyScreen(xb,yb, Vertexes2DBend[curPoint], width, hei))
painter->drawPoint(xb,yb);
appliedToScreenCoordsBended << QPoint(xb, yb);
//painter->setPen(ChangeQPainter(QColor(255,0,0,10), 1));
//painter->drawLine(xb,yb,x,y);
}
// ...
// draw a attend
if (false && skin != NULL){
QVector<QVector3D> attened3D = {};
QVector<QVector2D> attened2D = {};
for (int att = 0; att < skin->vertAttends[curPoint].localJointCoords.length(); att++)
attened3D << bindMesh->vertexes[curPoint] + skin->vertAttends[curPoint].localJointCoords[att];
attened2D = From3DTo2D(attened3D, view, perspective);
for (int att = 0; att < attened2D.length(); att++){
int xa, ya;
ApplyScreen(xa,ya, attened2D[att], width, hei);
painter->setPen(ChangeQPainter(QColor(255,0,0,5), 2));
painter->drawLine(x,y,xa,ya);
}
}
}
// draw a mf polygons
// ..................................................................................................................................
Mesh* drawMesh = (bendedMesh == NULL)? bindMesh : bendedMesh;
QVector<QPainterPath> polygonDrawArray;
QVector<QColor> polygonColorArray;
QVector<float> distFromPolygonCentersToCamera;
for (int currentPolygon = 0; currentPolygon < drawMesh->polygonStartIndexes.length() - 1; currentPolygon++){
QPolygon poly;
QVector<int> selectedIndexes;
QVector3D VertexInPolygonSumm = QVector3D();
int totalVertexInPolygonCount = 0;
for (int selecInd = drawMesh->polygonStartIndexes[currentPolygon]; selecInd < drawMesh->polygonStartIndexes[currentPolygon + 1]; selecInd++){
totalVertexInPolygonCount ++;
VertexInPolygonSumm += drawMesh->vertexes[drawMesh->polygonIndexes[selecInd]];
selectedIndexes << drawMesh->polygonIndexes[selecInd];
poly << ((drawMesh == bindMesh)? appliedToScreenCoords/*Bended*/[drawMesh->polygonIndexes[selecInd]]
: appliedToScreenCoordsBended[drawMesh->polygonIndexes[selecInd]]);
}
//
//int colorIntenese = (int)(((double)currentPolygon * 254.0)/(bindMesh->polygonStartIndexes.length() - 1));
QPainterPath newPolyg; newPolyg.addPolygon(poly);
polygonDrawArray << newPolyg;
polygonColorArray << QColor(200,200,200,200);//(QColor(colorIntenese,colorIntenese,colorIntenese));
distFromPolygonCentersToCamera << (VertexInPolygonSumm * (1.0 / totalVertexInPolygonCount)).distanceToPoint(*cameraCenter);
}
QBrush brush;
painter->setPen(QPen(Qt::darkGray));
QVector<int> needPolygonInds = GetSortedIndex(distFromPolygonCentersToCamera);
for (int cPath = 0; cPath < polygonDrawArray.length(); cPath ++){
brush = QBrush(polygonColorArray[needPolygonInds[cPath]]);
painter->fillPath(polygonDrawArray[needPolygonInds[cPath]], brush);
painter->drawPath(polygonDrawArray[needPolygonInds[cPath]]);
}
// ..................................................................................................................................
if (skeleton == NULL)
return QString("No skeleton detected");
// joints
// ...
QVector<QVector3D> Joints3D;
for (int curJoint = 0; curJoint < skeleton->joints.length(); curJoint++){
QVector3D parentVect = QVector3D(0,0,0),
childVect = skeleton->getJointCoordByIndex(curJoint, parentVect);
Joints3D << childVect << parentVect;
}
Vertexes2D = From3DTo2D(Joints3D, view,perspective);
painter->setPen(ChangeQPainter(QColor(255,130,0), 1));
for (int curPoint = 0; curPoint < Vertexes2D.length() / 2; curPoint++)
{
int xc,yc,xp,yp;
ApplyScreen(xc,yc,Vertexes2D[curPoint * 2], width, hei);
ApplyScreen(xp,yp,Vertexes2D[curPoint * 2 + 1], width, hei);
painter->drawLine(xc,yc,xp,yp);
painter->drawText(xc, yc,300,150,0, QString::number(curPoint));//+" " +skeleton->joints[curPoint]->name);// +", "+ QString::number(skeleton->joints[curPoint]->currentRotation.y()) +", "+ QString::number(skeleton->joints[curPoint]->currentRotation.z()));
//painter->drawText(xc, yc,300,150,0, QString::number(Joints3D[curPoint*2].x()) +"\n"+ QString::number(Joints3D[curPoint*2].y()) +"\n"+ QString::number(Joints3D[curPoint*2].z()));
}
QString logs = "";
QVector<QVector3D> jointLocalRots = skeleton->getJointsLocalRotations();
for (int curJointInd = 0; curJointInd < skeleton->joints.length(); curJointInd++)
logs += ("#" + QString::number(curJointInd) + " : ")
+ QString::number(jointLocalRots[curJointInd].x()) + ", "
+ QString::number(jointLocalRots[curJointInd].y()) + ", "
+ QString::number(jointLocalRots[curJointInd].z()) + "\n";
painter->drawText(width, 40, 200, hei - 40,0, logs);//+" " +skeleton->joints[curPoint]->name);// +", "+ QString::number(skeleton->joints[curPoint]->currentRotation.y()) +", "+ QString::number(skeleton->joints[curPoint]->currentRotation.z()));
//painter->end();
return QString();
}
bool QgsCurve::snapToGridPrivate( double hSpacing, double vSpacing, double dSpacing, double mSpacing,
const QVector<double> &srcX, const QVector<double> &srcY, const QVector<double> &srcZ, const QVector<double> &srcM,
QVector<double> &outX, QVector<double> &outY, QVector<double> &outZ, QVector<double> &outM ) const
{
int length = numPoints();
if ( length <= 0 )
return false;
bool hasZ = is3D();
bool hasM = isMeasure();
// helper functions
auto roundVertex = [hSpacing, vSpacing, dSpacing, mSpacing, hasZ, hasM, &srcX, &srcY, &srcZ, &srcM]( QgsPoint & out, int i )
{
if ( hSpacing > 0 )
out.setX( std::round( srcX.at( i ) / hSpacing ) * hSpacing );
else
out.setX( srcX.at( i ) );
if ( vSpacing > 0 )
out.setY( std::round( srcY.at( i ) / vSpacing ) * vSpacing );
else
out.setY( srcY.at( i ) );
if ( hasZ )
{
if ( dSpacing > 0 )
out.setZ( std::round( srcZ.at( i ) / dSpacing ) * dSpacing );
else
out.setZ( srcZ.at( i ) );
}
if ( hasM )
{
if ( mSpacing > 0 )
out.setM( std::round( srcM.at( i ) / mSpacing ) * mSpacing );
else
out.setM( srcM.at( i ) );
}
};
auto append = [hasZ, hasM, &outX, &outY, &outM, &outZ]( QgsPoint const & point )
{
outX.append( point.x() );
outY.append( point.y() );
if ( hasZ )
outZ.append( point.z() );
if ( hasM )
outM.append( point.m() );
};
auto isPointEqual = [dSpacing, mSpacing, hasZ, hasM]( const QgsPoint & a, const QgsPoint & b )
{
return ( a.x() == b.x() )
&& ( a.y() == b.y() )
&& ( !hasZ || dSpacing <= 0 || a.z() == b.z() )
&& ( !hasM || mSpacing <= 0 || a.m() == b.m() );
};
// temporary values
QgsWkbTypes::Type pointType = QgsWkbTypes::zmType( QgsWkbTypes::Point, hasZ, hasM );
QgsPoint last( pointType );
QgsPoint current( pointType );
// Actual code (what does all the work)
roundVertex( last, 0 );
append( last );
for ( int i = 1; i < length; ++i )
{
roundVertex( current, i );
if ( !isPointEqual( current, last ) )
{
append( current );
last = current;
}
}
// if it's not closed, with 2 points you get a correct line
// if it is, you need at least 4 (3 + the vertex that closes)
if ( outX.length() < 2 || ( isClosed() && outX.length() < 4 ) )
return false;
return true;
}
QStringList Manager::fetchMonster(const int &id, const int &level) {
QTextStream cout(stdout); // set cout for console debug
QStringList array;
QString idString;
if ( id < 10 )
idString = "00" + QString::number(id);
else if ( id < 100)
idString = "0" + QString::number(id);
else
idString = QString::number(id);
array.append(QString::number(id));
array.append(idString);
array.append(QString::number(level));
cout << QDir::setCurrent("/usr/share/harbour-pocketmonsters/qml/pages/xmls/") << endl;
QFile pokedex( idString + ".xml");
cout << pokedex.open(QIODevice::ReadOnly) << endl;
QXmlStreamReader xml(&pokedex);
while (!xml.atEnd() && !xml.hasError()) {
xml.readNext();
if ( xml.isStartElement() && xml.name().toString() == "index" && xml.attributes().value("id").toString() == idString) {
xml.readNext();
} else if ( ( xml.name().toString() == "moveset" ) ) {
break;
}
if ( xml.isStartElement() ) {
QString string = xml.readElementText();
array.append(string);
}
}
if (xml.hasError())
{
cout << "XML error: " << xml.errorString() << "line:column - " << xml.lineNumber() << ":" << xml.columnNumber() << endl;
}
else if (xml.atEnd())
{
cout << "Reached end, done" << endl;
}
QVector <int> levelsArray;
QVector <int> idsArray;
while (!xml.atEnd() && !xml.hasError()) {
xml.readNext();
QXmlStreamAttributes attributes = xml.attributes();
if ( xml.isStartElement() && xml.name().toString() == "move") {
levelsArray.append(attributes.value("level").toInt());
idsArray.append(attributes.value("id").toInt());
}
}
if (xml.hasError())
{
cout << "XML error: " << xml.errorString() << "line:column - " << xml.lineNumber() << ":" << xml.columnNumber() << endl;
}
else if (xml.atEnd())
{
cout << "Reached end, done" << endl;
}
if ( levelsArray.length() < 5 ) {
if ( level >= levelsArray[0])
array.append(QString::number(idsArray[0]));
if ( level >= levelsArray[1])
array.append(QString::number(idsArray[1]));
if ( level >= levelsArray[2])
array.append(QString::number(idsArray[2]));
if ( level >= levelsArray[3])
array.append(QString::number(idsArray[3]));
}
while ( array.length() < 23 )
array.append(QString::number(0));
for ( int i = 0; i < array.length(); i++) {
cout << array[i] << ";";
}
cout << endl;
fetchMonsterDone();
return array;
}
// Initialize all your OpenGL objects here
void MainWindow::initialize()
{
// Initialize important variables and the MVP matrices
mouseClick = QPoint(0,0);
eye = QVector3D(0,0,-4);
center = QVector3D(0,0,0) ;
up = QVector3D(0,1,0);
FoV = 60;
model.setToIdentity();
view.lookAt(eye, center, up);
calculateProjection();
qDebug() << "MainWindow::initialize()";
QString glVersion;
glVersion = reinterpret_cast<const char*>(glGetString(GL_VERSION));
qDebug() << "Using OpenGL" << qPrintable(glVersion);
// Initialize the shaders
m_shaderProgram = new QOpenGLShaderProgram(this);
// Use the ":" to load from the resources files (i.e. from the resources.qrc)
m_shaderProgram->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shaders/vertex.glsl");
m_shaderProgram->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/shaders/fragment.glsl");
m_shaderProgram->link();
// Shaders are initialized
// You can retrieve the locations of the uniforms from here
// Initialize your objects and buffers
QVector<QVector3D> objectVectors;
QVector<QVector3D> generatedColors;
OBJModel cube = OBJModel(":/models/cube.obj");
objectVectors = cube.vertices;
vectorsNumber = objectVectors.length();
// Calculate the random colours using the color seed
for(int i = 0; i < vectorsNumber/3; i++){
float colorArray[3] = {0,0,0};
for(unsigned int j = 0; j < 3; j++){
srand(COLOR_SEED*(j+1)*(i+1));
colorArray[j] = ((double)rand()/RAND_MAX);
}
printf("color %d, %f %f %f\n", i, colorArray[0],colorArray[1],colorArray[2] );
generatedColors.append(QVector3D(colorArray[0], colorArray[1], colorArray[2]));
generatedColors.append(QVector3D(colorArray[0], colorArray[1], colorArray[2]));
generatedColors.append(QVector3D(colorArray[0], colorArray[1], colorArray[2]));
}
// generate VAO and bind it
m_funcs->glGenVertexArrays(1, &VAO);
m_funcs->glBindVertexArray(VAO);
// generate color and vertice buffers
m_funcs->glGenBuffers(1, &vertices);
m_funcs->glGenBuffers(1, &colors);
// bind vertice buffer and fill it with the vertices
m_funcs->glBindBuffer(GL_ARRAY_BUFFER, vertices);
m_funcs->glBufferData(GL_ARRAY_BUFFER, sizeof(QVector3D) * objectVectors.length(),objectVectors.data(), GL_STATIC_DRAW);
m_funcs->glEnableVertexAttribArray(0);
m_funcs->glVertexAttribPointer(0,3, GL_FLOAT, GL_FALSE, 0,0);
// Bind color buffer, fill it with the generated colors
m_funcs->glBindBuffer(GL_ARRAY_BUFFER, colors);
m_funcs->glBufferData(GL_ARRAY_BUFFER, sizeof(QVector3D) * generatedColors.length(), generatedColors.data(), GL_STATIC_DRAW);
m_funcs->glEnableVertexAttribArray(1);
m_funcs->glVertexAttribPointer(1,3, GL_FLOAT, GL_FALSE, 0,0);
// Create your Vertex Array Object (VAO) and Vertex Buffer Objects (VBO) here.
// Set OpenGL to use Filled triangles (can be used to render points, or lines)
m_funcs->glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
// Enable Z-buffering
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
qDebug() << "Depth Buffer size:" << this->format().depthBufferSize() << "bits";
// Function for culling, removing faces which don't face the camera
//glEnable(GL_CULL_FACE);
//glCullFace(GL_BACK);
// Set the clear color to be black (color used for resetting the screen)
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
}
void mergeFiles(QString XMLFile){
QString outname;
QMap<int,O3DPFile*> o3dpfileMap;
QVector<fileWithLocation> files;
QVector<long> outGridSize(3,0);
QVector<float> voxDims(3,0);
QVector<double> outBBox(6,0);
quint32 nmat = 0;
/// Parse XML into
/// - fileWithLocations
/// - a fixed gridsize
/// - bbox
/// - outfilename
QFile f(XMLFile);
f.open(QIODevice::ReadOnly);
QXmlStreamReader xml(&f);
while(!xml.atEnd() && !xml.hasError()){
QXmlStreamReader::TokenType token = xml.readNext();
if(token == QXmlStreamReader::StartDocument){
//we don’t want any of this data, it isn’t any element
//we need.
continue;
}
if(token == QXmlStreamReader::StartElement) {
if(xml.name() == "files"){
continue;
}
if(xml.name() == "filename"){
outname = xml.readElementText();
qDebug()<<"outname: "<<outname;
}
if(xml.name() == "inputfile"){
int id = xml.attributes().value("id").toInt();
QString filename = xml.readElementText();
O3DPFile* input = new O3DPFile(filename);
o3dpfileMap[id] = input;
}
if (xml.name() == "insertfile"){
int id = xml.attributes().value("id").toInt();
QVector<int> indecies(3,0.0);
indecies[0] = xml.attributes().value("x").toFloat();
indecies[1] = xml.attributes().value("y").toFloat();
indecies[2] = xml.attributes().value("z").toFloat();
fileWithLocation loc;
loc.o3dp = o3dpfileMap[id];
loc.indices = indecies;
nmat = std::max(nmat,loc.o3dp->num_mat);
files.append(loc);
}
if(xml.name() == "gridsize"){
outGridSize[0] = xml.attributes().value("x").toLong();
outGridSize[1] = xml.attributes().value("y").toLong();
outGridSize[2] = xml.attributes().value("z").toLong();
}
if(xml.name() == "voxeldims"){
voxDims[0] = xml.attributes().value("x").toFloat();
voxDims[1] = xml.attributes().value("y").toFloat();
voxDims[2] = xml.attributes().value("z").toFloat();
}
}
}
if (xml.hasError()){qDebug()<<"Error:"<<xml.error();}
for(int i=0;i<3;i++){
outBBox[3+i] = outGridSize[i]*voxDims[i];
}
O3DPFile OutFile(outname,outGridSize,outBBox);
OutFile.num_mat=nmat;
OutFile.writeHeader();
for( int z=0; z<outGridSize[2]; z++){
QByteArray layer( outGridSize[1]*outGridSize[0],0);
for(int f=0; f<files.length();f++){
int file_layer_number = z-files.at(f).indices[2];
// if the file is in this layer then add the values
if( (file_layer_number > -1) &&
(file_layer_number < files.at(f).o3dp->gridSize[2]) ){
// get the layer
QByteArray fileLayer = files.at(f).o3dp->layer(file_layer_number);
// for each row write out
for (int y=0;y<files.at(f).o3dp->gridSize[1];y++){
/// *-------->
/// | |
/// |---x
/// \|/
int indexInLayer = (y+files.at(f).indices[1])*outGridSize[0]+
files.at(f).indices[0];
int len = files.at(f).o3dp->gridSize[0];
QByteArray col = fileLayer.mid(y*len,len);
layer.replace(indexInLayer,len,col);
}
}
}
//OutFile.grid[z] = layer;
qDebug()<<"layer:"<<z<<" : "<<OutFile.writeLayer(layer);
}
//qDebug()<<"generated";
//OutFile.writeAll(outname);
qDebug()<<"done writing";
}
void QGLView::initializeVertexBuffer(ModelType type, const QVector<ModelVertex> &vertices)
{
initializeVertexBuffer(type, vertices.data(), vertices.length() * sizeof(ModelVertex));
}
void Algorithm::FFT(QVector< std::complex<double> > &a, bool invert)
{
//qDebug()<<a;
int n=a.length();
if(n==1)
{
return;
}
int i;
QVector< std::complex<double> >a0(n/2),a1(n/2);
for(i=0;i<n;i+=2)
{
a0[i/2]=a[i];
a1[i/2]=a[i+1];
}
FFT(a0,invert);
FFT(a1,invert);
static double pi_2;//=M_PI *2;
double ang=(pi_2/n)*(invert?-1:1);
std::complex<double> w(1),wn(cos(ang),sin(ang));
for(i=0;i<n/2;i++)
{
a[i]=a0[i]+w*a1[i];
a[i+ n/2 ]=a0[i]-w*a1[i];
if(invert)
{
a[i]/=2;
a[i+ n/2 ]/=2;
}
w*=wn;
}
/*/
int i,j=0;
int n=a.length();
//double pi_2=M_PI *2;
double ang;
std::complex<double> w,wn;
QVector< std::complex<double> > _a(n);
for(i=0;i<n;i++)
{
a_[j]=a[i];
j=j+n/2;
}
n/=2;
for(;n>1;n/=2)
{
ang=(M_PI/n)*(invert?-1:1);
qDebug()<<"length"<<n;
w=1,wn={cos(ang),sin(ang)};
i=0;
j=0;
while(1)
{
_a[i]=a[i]+w*a[i+n/2];
_a[i+n]=a[i]-w*a[i+n/2];
i++,j++;
if(j==n/2)
{
w*=wn;
j=0;
i+=n/2;
}
qDebug()<<i<<j;
if(i>=a.length())
{
break;
}
a=_a;
}
}
/*/
}
/**
* @brief DelaunayTriangulation::checkDelaunayConditionLocaly
* @param triangles
* @return {bool} is triangulation restructured
*/
bool DelaunayTriangulation::
checkDelaunayConditionLocaly(QVector<TriangularUnit>& trianglesToCheck) {
bool isRestructured = false;
for (int i = 0; i < trianglesToCheck.length(); i++) {
int triangleIndex = i;
TriangularUnit triangle = trianglesToCheck.at(triangleIndex);
QVector< int > neighborsIndexes = getTriangularUnitNeighbors(triangle);
QVectorIterator< int > itNeighbors( neighborsIndexes );
QVector<Point> triangleVertexes = triangle.getVertexes();
if (neighborsIndexes.length() > 3) {
ExMath::consoleLog(neighborsIndexes.length());
}
while (itNeighbors.hasNext()) {
int neighborIndex = itNeighbors.next();
TriangularUnit neighbor = triangles.at(neighborIndex);
Point p0 = triangle.getNotAdjacentPoint(neighbor);
Edge mutualEdge = neighbor.getMutualEdge(triangle);
double x0 = p0.x(), y0 = p0.y();
int indexMutualVertex1 = triangleVertexes.indexOf(mutualEdge.getStartPoint());
int indexMutualVertex2 = triangleVertexes.indexOf(mutualEdge.getEndPoint());
int i1 = (abs(indexMutualVertex1 - indexMutualVertex2) == 1)?
std::min(indexMutualVertex1, indexMutualVertex2):
std::max(indexMutualVertex1, indexMutualVertex2);
int i3 = (i1 == indexMutualVertex1)? indexMutualVertex2: indexMutualVertex1;
int i2 = 3 - i1 - i3;
double x1 = triangleVertexes.at(i1).x(), y1 = triangleVertexes.at(i1).y();
double x2 = triangleVertexes.at(i2).x(), y2 = triangleVertexes.at(i2).y();
double x3 = triangleVertexes.at(i3).x(), y3 = triangleVertexes.at(i3).y();
double targetValue = fabs((x0 - x1)*(y0 - y3) - (x0 - x3)*(y0 - y1))*
((x2 - x1)*(x2 - x3) + (y2 - y1)*(y2 - y3)) +
((x0 - x1)*(x0 - x3) + (y0 - y1)*(y0 - y3))*
fabs((x2 - x1)*(y2 - y3) - (x2 - x3)*(y2 - y1));
//targetValue = (x1*x1 + y1*y1)*(y2*x3 - x2*y3) + (x2*x2 + y2*y2)*(x1*y3 - y1*x3) + (x3*x3 + y3*y3)*(y1*x2 - x1*y2) <= 0;
if (targetValue < 0) {
Point p4 = neighbor.getNotAdjacentPoint(triangle);
Edge newMutualEdge(p0, p4);
TriangularUnit newTriangle1(newMutualEdge, mutualEdge.getEndPoint());
TriangularUnit newTriangle2(newMutualEdge, mutualEdge.getStartPoint());
edges.remove(mutualEdge);
edges.insert(newMutualEdge);
triangles[neighborIndex] = newTriangle1;
triangles[triangles.indexOf(triangle)] = newTriangle2;
trianglesToCheck.append(newTriangle1);
trianglesToCheck.append(newTriangle2);
break;
ExMath::consoleLog("swapped");
isRestructured = true;
}
}
}
return isRestructured;
}
QVariantMap QgsCollectorAlgorithm::processCollection( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback,
const std::function<QgsGeometry( const QVector< QgsGeometry >& )> &collector, int maxQueueLength )
{
std::unique_ptr< QgsFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !source )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, source->fields(), QgsWkbTypes::multiType( source->wkbType() ), source->sourceCrs() ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
QStringList fields = parameterAsFields( parameters, QStringLiteral( "FIELD" ), context );
long count = source->featureCount();
QgsFeature f;
QgsFeatureIterator it = source->getFeatures();
double step = count > 0 ? 100.0 / count : 1;
int current = 0;
if ( fields.isEmpty() )
{
// dissolve all - not using fields
bool firstFeature = true;
// we dissolve geometries in blocks using unaryUnion
QVector< QgsGeometry > geomQueue;
QgsFeature outputFeature;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( firstFeature )
{
outputFeature = f;
firstFeature = false;
}
if ( f.hasGeometry() && !f.geometry().isNull() )
{
geomQueue.append( f.geometry() );
if ( maxQueueLength > 0 && geomQueue.length() > maxQueueLength )
{
// queue too long, combine it
QgsGeometry tempOutputGeometry = collector( geomQueue );
geomQueue.clear();
geomQueue << tempOutputGeometry;
}
}
feedback->setProgress( current * step );
current++;
}
outputFeature.setGeometry( collector( geomQueue ) );
sink->addFeature( outputFeature, QgsFeatureSink::FastInsert );
}
else
{
QList< int > fieldIndexes;
Q_FOREACH ( const QString &field, fields )
{
int index = source->fields().lookupField( field );
if ( index >= 0 )
fieldIndexes << index;
}
QHash< QVariant, QgsAttributes > attributeHash;
QHash< QVariant, QVector< QgsGeometry > > geometryHash;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
QVariantList indexAttributes;
Q_FOREACH ( int index, fieldIndexes )
{
indexAttributes << f.attribute( index );
}
if ( !attributeHash.contains( indexAttributes ) )
{
// keep attributes of first feature
attributeHash.insert( indexAttributes, f.attributes() );
}
if ( f.hasGeometry() && !f.geometry().isNull() )
{
geometryHash[ indexAttributes ].append( f.geometry() );
}
}
// Initialize all your OpenGL objects here
void MainWindow::initialize()
{
rotate = false;
qDebug() << "MainWindow::initialize()";
QString glVersion;
glVersion = reinterpret_cast<const char*>(glGetString(GL_VERSION));
qDebug() << "Using OpenGL" << qPrintable(glVersion);
// Initialize the shaders
m_shaderProgram = new QOpenGLShaderProgram(this);
// Use the ":" to load from the resources files (i.e. from the resources.qrc)
m_shaderProgram->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shaders/vertex.glsl");
m_shaderProgram->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/shaders/fragment.glsl");
m_shaderProgram->link();
// Shaders are initialized
// Initialize objects and buffers
OBJModel sphere = OBJModel(":/models/sphere.obj");
QVector<QVector3D> vertices = sphere.vertices;
nVertices = vertices.length();
QVector<QVector3D> normals = sphere.normals;
QVector<QVector3D> colors;
for (int i = 0; i < sphere.indices.length(); i += 3){
QVector3D c = QVector3D((double) rand() / RAND_MAX, (double) rand() / RAND_MAX, (double) rand() / RAND_MAX);
colors.append(c);
colors.append(c);
colors.append(c);
}
// Create your Vertex Array Object (VAO) and Vertex Buffer Objects (VBO) here.
object.create();
object.bind();
coordinates = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
coordinates->create();
coordinates->bind();
coordinates->allocate(vertices.data(), vertices.length() * sizeof(QVector3D));
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,0);
normal_buffer = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
normal_buffer->create();
normal_buffer->bind();
normal_buffer->allocate(normals.data(), normals.length() * sizeof(QVector3D));
glVertexAttribPointer(2,3,GL_FLOAT,GL_FALSE,0,0);
m_shaderProgram->setUniformValue("normal", normal);
// for (int index = 0; index < sphere.indices.length(); index++)
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(2);
object.release();
// Set OpenGL to use Filled triangles (can be used to render points, or lines)
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
// Enable Z-buffering
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
qDebug() << "Depth Buffer size:" << this->format().depthBufferSize() << "bits";
// Set the clear color to be black (color used for resetting the screen)
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
}
void Rig::BendSkinToSkeleton()
{
Q_ASSERT(bindMesh->vertexes.length() == skin->vertAttends.length());
if (!skeleton->CalculateGlobalCoordForEachJointMatrix())
return;
Mesh* newMesh = new Mesh();
newMesh->polygonIndexes = bindMesh->polygonIndexes;
newMesh->polygonStartIndexes = bindMesh->polygonStartIndexes;
int vertexesTransformed = 0;
QVector<int> failedIndexes;
for (int currentVertexInd = 0; currentVertexInd < skin->vertAttends.length(); currentVertexInd ++){
QVector<QVector3D> bendedVariants;
QVector<float> weightes;
// we have 0.3 && QVec3D && from joint a place and rotation
for (int jointInd = 0; jointInd < skin->vertAttends[currentVertexInd].jointIndexs.length(); jointInd++){
int jointBendInd = skin->vertAttends[currentVertexInd].jointIndexs[jointInd];
QVector3D originalOffset = skin->vertAttends[currentVertexInd].localJointCoords[jointInd];
QVector3D jointBendTranslation, jointBendRotation;
skeleton->getJointTranslationAndRotation(jointBendInd, jointBendTranslation, jointBendRotation);
//qDebug() << currentVertexInd<< jointBendInd<< originalOffset << jointBendTranslation << jointBendRotation;
///bendedVariants <<
///CommonFuncs::AddDirect(jointBendTranslation, -originalOffset, jointBendRotation);
QMatrix4x4 localAttendTransformMatrix = QMatrix4x4(),
localRotateMatrix = CommonFuncs::GetNormalRotateMatrix(skeleton->joints[jointBendInd]->currentRotation);
localAttendTransformMatrix.translate(- skin->vertAttends[currentVertexInd].localJointCoords[jointInd]);
bendedVariants <<
CommonFuncs::AddDirectMatrx(QVector3D(1,1,1),
//skin->vertAttends[currentVertexInd].localJointCoords
skeleton->joints[jointBendInd]->globalTransformMatrix
* localRotateMatrix
* localAttendTransformMatrix
);
weightes << skin->vertAttends[currentVertexInd].weights[jointInd];
}
QVector3D result = QVector3D();
float bendedSumm = 0;
for (int curPoint = 0; curPoint < weightes.length(); curPoint++)
bendedSumm += weightes[curPoint];
if (bendedSumm == 0)
failedIndexes << currentVertexInd;
else
for (int curPoint = 0; curPoint < bendedVariants.length(); curPoint++)
result = result + weightes[curPoint]/ bendedSumm * bendedVariants[curPoint] ;
if (bendedVariants.length() > 0)
vertexesTransformed ++;
newMesh->vertexes << result;
}
qDebug() << QString::number(vertexesTransformed) + " / " + QString::number(skin->vertAttends.length()) + " / " + QString::number(bindMesh->vertexes.length()) +" vertexes transformed ( "+QString::number(failedIndexes.length())+" failed)";
//
bendedMesh = newMesh;
}
void CharSelect::slot_insertSpecialChars(const QVector<uint> & chars)
{
chToIns = QString::fromUcs4(chars.data(), chars.length());
slot_insertSpecialChar();
}
QVariantMap QgsClipAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
std::unique_ptr< QgsFeatureSource > featureSource( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !featureSource )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
std::unique_ptr< QgsFeatureSource > maskSource( parameterAsSource( parameters, QStringLiteral( "OVERLAY" ), context ) );
if ( !maskSource )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "OVERLAY" ) ) );
QString dest;
QgsWkbTypes::GeometryType sinkType = QgsWkbTypes::geometryType( featureSource->wkbType() );
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, featureSource->fields(), QgsWkbTypes::multiType( featureSource->wkbType() ), featureSource->sourceCrs() ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
// first build up a list of clip geometries
QVector< QgsGeometry > clipGeoms;
QgsFeatureIterator it = maskSource->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( QList< int >() ).setDestinationCrs( featureSource->sourceCrs(), context.transformContext() ) );
QgsFeature f;
while ( it.nextFeature( f ) )
{
if ( f.hasGeometry() )
clipGeoms << f.geometry();
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
if ( clipGeoms.isEmpty() )
return outputs;
// are we clipping against a single feature? if so, we can show finer progress reports
bool singleClipFeature = false;
QgsGeometry combinedClipGeom;
if ( clipGeoms.length() > 1 )
{
combinedClipGeom = QgsGeometry::unaryUnion( clipGeoms );
if ( combinedClipGeom.isEmpty() )
{
throw QgsProcessingException( QObject::tr( "Could not create the combined clip geometry: %1" ).arg( combinedClipGeom.lastError() ) );
}
singleClipFeature = false;
}
else
{
combinedClipGeom = clipGeoms.at( 0 );
singleClipFeature = true;
}
// use prepared geometries for faster intersection tests
std::unique_ptr< QgsGeometryEngine > engine( QgsGeometry::createGeometryEngine( combinedClipGeom.constGet() ) );
engine->prepareGeometry();
QgsFeatureIds testedFeatureIds;
int i = -1;
Q_FOREACH ( const QgsGeometry &clipGeom, clipGeoms )
{
i++;
if ( feedback->isCanceled() )
{
break;
}
QgsFeatureIterator inputIt = featureSource->getFeatures( QgsFeatureRequest().setFilterRect( clipGeom.boundingBox() ) );
QgsFeatureList inputFeatures;
QgsFeature f;
while ( inputIt.nextFeature( f ) )
inputFeatures << f;
if ( inputFeatures.isEmpty() )
continue;
double step = 0;
if ( singleClipFeature )
step = 100.0 / inputFeatures.length();
int current = 0;
Q_FOREACH ( const QgsFeature &inputFeature, inputFeatures )
{
if ( feedback->isCanceled() )
{
break;
}
if ( !inputFeature.hasGeometry() )
continue;
if ( testedFeatureIds.contains( inputFeature.id() ) )
{
// don't retest a feature we have already checked
continue;
}
testedFeatureIds.insert( inputFeature.id() );
if ( !engine->intersects( inputFeature.geometry().constGet() ) )
continue;
QgsGeometry newGeometry;
if ( !engine->contains( inputFeature.geometry().constGet() ) )
{
QgsGeometry currentGeometry = inputFeature.geometry();
newGeometry = combinedClipGeom.intersection( currentGeometry );
if ( newGeometry.wkbType() == QgsWkbTypes::Unknown || QgsWkbTypes::flatType( newGeometry.wkbType() ) == QgsWkbTypes::GeometryCollection )
{
QgsGeometry intCom = inputFeature.geometry().combine( newGeometry );
QgsGeometry intSym = inputFeature.geometry().symDifference( newGeometry );
newGeometry = intCom.difference( intSym );
}
}
else
{
// clip geometry totally contains feature geometry, so no need to perform intersection
newGeometry = inputFeature.geometry();
}
if ( !QgsOverlayUtils::sanitizeIntersectionResult( newGeometry, sinkType ) )
continue;
QgsFeature outputFeature;
outputFeature.setGeometry( newGeometry );
outputFeature.setAttributes( inputFeature.attributes() );
sink->addFeature( outputFeature, QgsFeatureSink::FastInsert );
if ( singleClipFeature )
feedback->setProgress( current * step );
}
if ( !singleClipFeature )
{
// coarse progress report for multiple clip geometries
feedback->setProgress( 100.0 * static_cast< double >( i ) / clipGeoms.length() );
}
}
/*
* Load the file with chosen filename and emit the signal sendFileData() when the file is read.
*/
void ConvertEcgToIbi::run()
{
QFile myFile(fname);
if (myFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
time.start();
QTextStream ecgInfo(&myFile);
QVector<int > ecgVals;
QVector<double> timeData;
int iterations;
if (!ecgInfo.atEnd()) {
QString strVals = ecgInfo.readLine();
ecgInfo.readLine();
ecgInfo.readLine();
double tmp;
int i=0;
while (!ecgInfo.atEnd()) {
strVals = ecgInfo.readLine();
QStringList strPieces = strVals.split(QRegularExpression("\\s+"));
if (strPieces.length()==4) {
tmp=strPieces[2].toDouble();
ecgVals.append((tmp*500)); ///< @todo normalize input to work with more files
}
else if (strPieces.length()==3) {
tmp=strPieces[2].toDouble();
ecgVals.append((tmp*500));
}
else if (strPieces.length()==5){
tmp=strPieces[2].toDouble();
ecgVals.append((tmp*500));
}
else {
std::cerr << "Wrong File" << std::endl;
return;
}
i++;
}
QVector<double> qrsPeaks;
extractRtoR(&ecgVals, &qrsPeaks);
qrsPeaks.takeFirst();// Remove the influense of the QRS-detectors learning period
qrsPeaks.takeFirst();// Remove the influense of the QRS-detectors learning period
qrsPeaks.takeFirst();// Remove the influense of the QRS-detectors learning period
tmp=0;
for (int i; i<qrsPeaks.length(); i++){
tmp=tmp+(qrsPeaks.at(i));
timeData.append(tmp);
}
if (qrsPeaks.length()>10){ ///@todo FIX this check neater
emit sendFileData(qrsPeaks,timeData);
saveAsIbiFile(&qrsPeaks);
}
else
std::cerr << "Not enough R peaks detected" << std::endl;
qDebug("Time elapsed: %d ms", time.elapsed());
}
ecgInfo.flush();
myFile.close();
}
}