ErrorList topolTest::checkyLineEndsCoveredByPoints( double tolerance, QgsVectorLayer *layer1, QgsVectorLayer *layer2, bool isExtent )
{
Q_UNUSED( tolerance );
int i = 0;
ErrorList errorList;
if ( layer1->geometryType() != QgsWkbTypes::LineGeometry )
{
return errorList;
}
if ( layer2->geometryType() != QgsWkbTypes::PointGeometry )
{
return errorList;
}
QgsSpatialIndex *index = mLayerIndexes[layer2->id()];
QgsGeometry canvasExtentPoly = QgsGeometry::fromWkt( qgsInterface->mapCanvas()->extent().asWktPolygon() );
QList<FeatureLayer>::Iterator it;
for ( it = mFeatureList1.begin(); it != mFeatureList1.end(); ++it )
{
if ( !( ++i % 100 ) )
emit progress( i );
if ( testCanceled() )
break;
QgsGeometry g1 = it->feature.geometry();
QgsPolylineXY g1Polyline = g1.asPolyline();
QgsGeometry startPoint = QgsGeometry::fromPointXY( g1Polyline.at( 0 ) );
QgsGeometry endPoint = QgsGeometry::fromPointXY( g1Polyline.last() );
QgsRectangle bb = g1.boundingBox();
QList<QgsFeatureId> crossingIds;
crossingIds = index->intersects( bb );
QList<QgsFeatureId>::ConstIterator cit = crossingIds.begin();
QList<QgsFeatureId>::ConstIterator crossingIdsEnd = crossingIds.end();
bool touched = false;
bool touchStartPoint = false;
bool touchEndPoint = false;
for ( ; cit != crossingIdsEnd; ++cit )
{
QgsFeature &f = mFeatureMap2[*cit].feature;
QgsGeometry g2 = f.geometry();
if ( g2.isNull() || !_canExportToGeos( g2 ) )
{
QgsMessageLog::logMessage( tr( "Second geometry missing or GEOS import failed." ), tr( "Topology plugin" ) );
continue;
}
if ( g2.intersects( startPoint ) )
{
touchStartPoint = true;
}
if ( g2.intersects( endPoint ) )
{
touchEndPoint = true;
}
if ( touchStartPoint && touchEndPoint )
{
touched = true;
break;
}
}
if ( !touched )
{
QgsGeometry conflictGeom = g1;
if ( isExtent )
{
if ( canvasExtentPoly.disjoint( conflictGeom ) )
{
continue;
}
if ( canvasExtentPoly.crosses( conflictGeom ) )
{
conflictGeom = conflictGeom.intersection( canvasExtentPoly );
}
}
QList<FeatureLayer> fls;
fls << *it << *it;
//bb.scale(10);
TopolErrorLineEndsNotCoveredByPoints *err = new TopolErrorLineEndsNotCoveredByPoints( bb, conflictGeom, fls );
errorList << err;
}
}
return errorList;
}
//Note: no guarantee of selection order???
void MDIViewPage::setTreeToSceneSelect(void)
{
bool saveBlock = blockConnection(true); // block selectionChanged signal from Tree/Observer
blockSelection(true);
Gui::Selection().clearSelection();
// QList<QGraphicsItem*> sceneSel = m_view->scene()->selectedItems(); //"no particular order"!!!
QList<QGraphicsItem*> sceneSel = m_sceneSelected;
for (QList<QGraphicsItem*>::iterator it = sceneSel.begin(); it != sceneSel.end(); ++it) {
QGIView *itemView = dynamic_cast<QGIView *>(*it);
if(itemView == 0) {
QGIEdge *edge = dynamic_cast<QGIEdge *>(*it);
if(edge) {
QGraphicsItem*parent = edge->parentItem();
if(!parent)
continue;
QGIView *viewItem = dynamic_cast<QGIView *>(parent);
if(!viewItem)
continue;
TechDraw::DrawView *viewObj = viewItem->getViewObject();
std::stringstream ss;
ss << "Edge" << edge->getProjIndex();
//bool accepted =
static_cast<void> (Gui::Selection().addSelection(viewObj->getDocument()->getName(),
viewObj->getNameInDocument(),
ss.str().c_str()));
showStatusMsg(viewObj->getDocument()->getName(),
viewObj->getNameInDocument(),
ss.str().c_str());
continue;
}
QGIVertex *vert = dynamic_cast<QGIVertex *>(*it);
if(vert) {
QGraphicsItem*parent = vert->parentItem();
if(!parent)
continue;
QGIView *viewItem = dynamic_cast<QGIView *>(parent);
if(!viewItem)
continue;
TechDraw::DrawView *viewObj = viewItem->getViewObject();
std::stringstream ss;
ss << "Vertex" << vert->getProjIndex();
//bool accepted =
static_cast<void> (Gui::Selection().addSelection(viewObj->getDocument()->getName(),
viewObj->getNameInDocument(),
ss.str().c_str()));
showStatusMsg(viewObj->getDocument()->getName(),
viewObj->getNameInDocument(),
ss.str().c_str());
continue;
}
QGIFace *face = dynamic_cast<QGIFace *>(*it);
if(face) {
QGraphicsItem*parent = face->parentItem();
if(!parent)
continue;
QGIView *viewItem = dynamic_cast<QGIView *>(parent);
if(!viewItem)
continue;
TechDraw::DrawView *viewObj = viewItem->getViewObject();
std::stringstream ss;
ss << "Face" << face->getProjIndex();
//bool accepted =
static_cast<void> (Gui::Selection().addSelection(viewObj->getDocument()->getName(),
viewObj->getNameInDocument(),
ss.str().c_str()));
showStatusMsg(viewObj->getDocument()->getName(),
viewObj->getNameInDocument(),
ss.str().c_str());
continue;
}
QGIDatumLabel *dimLabel = dynamic_cast<QGIDatumLabel*>(*it);
if(dimLabel) {
QGraphicsItem*dimParent = dimLabel->QGraphicsItem::parentItem();
if(!dimParent)
continue;
QGIView *dimItem = dynamic_cast<QGIView *>(dimParent);
if(!dimItem)
continue;
TechDraw::DrawView *dimObj = dimItem->getViewObject();
if (!dimObj) {
continue;
}
const char* name = dimObj->getNameInDocument();
if (!name) { //can happen during undo/redo if Dim is selected???
//Base::Console().Log("INFO - MDIVP::sceneSelectionChanged - dimObj name is null!\n");
continue;
}
//bool accepted =
static_cast<void> (Gui::Selection().addSelection(dimObj->getDocument()->getName(),dimObj->getNameInDocument()));
}
} else {
TechDraw::DrawView *viewObj = itemView->getViewObject();
if (viewObj && !viewObj->isRemoving()) {
std::string doc_name = viewObj->getDocument()->getName();
std::string obj_name = viewObj->getNameInDocument();
Gui::Selection().addSelection(doc_name.c_str(), obj_name.c_str());
showStatusMsg(doc_name.c_str(),
obj_name.c_str(),
"");
}
}
}
blockSelection(false);
blockConnection(saveBlock);
}
void Highlighter::iterateThroughRules(const QString &text,
const int length,
ProgressData *progress,
const bool childRule,
const QList<QSharedPointer<Rule> > &rules)
{
typedef QList<QSharedPointer<Rule> >::const_iterator RuleIterator;
bool contextChanged = false;
bool atLeastOneMatch = false;
RuleIterator it = rules.begin();
RuleIterator endIt = rules.end();
while (it != endIt && progress->offset() < length) {
int startOffset = progress->offset();
const QSharedPointer<Rule> &rule = *it;
if (rule->matchSucceed(text, length, progress)) {
atLeastOneMatch = true;
if (!m_indentationBasedFolding) {
if (!rule->beginRegion().isEmpty()) {
blockData(currentBlockUserData())->m_foldingRegions.push(rule->beginRegion());
++m_regionDepth;
if (progress->isOpeningBraceMatchAtFirstNonSpace())
++blockData(currentBlockUserData())->m_foldingIndentDelta;
}
if (!rule->endRegion().isEmpty()) {
QStack<QString> *currentRegions =
&blockData(currentBlockUserData())->m_foldingRegions;
if (!currentRegions->isEmpty() && rule->endRegion() == currentRegions->top()) {
currentRegions->pop();
--m_regionDepth;
if (progress->isClosingBraceMatchAtNonEnd())
--blockData(currentBlockUserData())->m_foldingIndentDelta;
}
}
progress->clearBracesMatches();
}
if (progress->isWillContinueLine()) {
createWillContinueBlock();
progress->setWillContinueLine(false);
} else {
if (rule->hasChildren())
iterateThroughRules(text, length, progress, true, rule->children());
if (!rule->context().isEmpty() && contextChangeRequired(rule->context())) {
m_currentCaptures = progress->captures();
changeContext(rule->context(), rule->definition());
contextChanged = true;
}
}
// Format is not applied to child rules directly (but relative to the offset of their
// parent) nor to look ahead rules.
if (!childRule && !rule->isLookAhead()) {
if (rule->itemData().isEmpty())
applyFormat(startOffset, progress->offset() - startOffset,
m_currentContext->itemData(), m_currentContext->definition());
else
applyFormat(startOffset, progress->offset() - startOffset, rule->itemData(),
rule->definition());
}
// When there is a match of one child rule the others should be skipped. Otherwise
// the highlighting would be incorret in a case like 9ULLLULLLUULLULLUL, for example.
if (contextChanged || childRule) {
break;
} else {
it = rules.begin();
continue;
}
}
++it;
}
if (!childRule && !atLeastOneMatch) {
if (m_currentContext->isFallthrough()) {
handleContextChange(m_currentContext->fallthroughContext(),
m_currentContext->definition());
iterateThroughRules(text, length, progress, false, m_currentContext->rules());
} else {
applyFormat(progress->offset(), 1, m_currentContext->itemData(),
m_currentContext->definition());
if (progress->isOnlySpacesSoFar() && !text.at(progress->offset()).isSpace())
progress->setOnlySpacesSoFar(false);
progress->incrementOffset();
}
}
}
void ShaderProgram::setupParameterUI(QWidget* parentWidget)
{
QFormLayout* layout = new QFormLayout(parentWidget);
QList<QPair<ShaderParam,QVariant> > paramsOrdered;
for (auto p = m_params.begin(); p != m_params.end(); ++p)
{
paramsOrdered.push_back(qMakePair(p.key(), p.value()));
}
qSort(paramsOrdered.begin(), paramsOrdered.end(), paramOrderingLess);
for (int i = 0; i < paramsOrdered.size(); ++i)
{
QWidget* edit = 0;
const ShaderParam& parDesc = paramsOrdered[i].first;
const QVariant& parValue = paramsOrdered[i].second;
switch (parDesc.type)
{
case ShaderParam::Float:
{
bool expScaling = parDesc.kvPairs.value("scaling", "exponential").
startsWith("exp");
double speed = parDesc.kvPairs.value("speed", "1").toDouble();
if (speed == 0)
speed = 1;
DragSpinBox* spin = new DragSpinBox(expScaling, speed, parentWidget);
double min = parDesc.getDouble("min", 0);
double max = parDesc.getDouble("max", 100);
if (expScaling)
{
// Prevent min or max == 0 for exp scaling which would be invalid
if (max == 0) max = 100;
if (min == 0) min = max > 0 ? 1e-8 : -1e-8;
spin->setDecimals((int)floor(std::max(0.0, -log(min)/log(10.0)) + 0.5) + 2);
}
else
{
double m = std::max(fabs(min), fabs(max));
spin->setDecimals((int)floor(std::max(0.0, -log(m)/log(10.0)) + 0.5) + 2);
}
spin->setMinimum(min);
spin->setMaximum(max);
spin->setValue(parValue.toDouble());
connect(spin, SIGNAL(valueChanged(double)),
this, SLOT(setUniformValue(double)));
edit = spin;
}
break;
case ShaderParam::Int:
if (parDesc.kvPairs.contains("enum"))
{
// Parameter is an enumeration variable
QComboBox* box = new QComboBox(parentWidget);
QStringList names = parDesc.kvPairs.value("enum").split('|');
box->insertItems(0, names);
box->setCurrentIndex(parValue.toInt());
connect(box, SIGNAL(currentIndexChanged(int)),
this, SLOT(setUniformValue(int)));
edit = box;
}
else
{
// Parameter is a freely ranging integer
QSpinBox* spin = new QSpinBox(parentWidget);
spin->setMinimum(parDesc.getInt("min", 0));
spin->setMaximum(parDesc.getInt("max", 100));
spin->setValue(parValue.toInt());
connect(spin, SIGNAL(valueChanged(int)),
this, SLOT(setUniformValue(int)));
edit = spin;
}
break;
default:
// FIXME
continue;
}
QString PopplerExtractor::parseFirstPage(Poppler::Document* pdfDoc, const QString& fileUrl)
{
QScopedPointer<Poppler::Page> p(pdfDoc->page(0));
if (!p) {
qWarning() << "Could not read page content from" << fileUrl;
return QString();
}
QList<Poppler::TextBox*> tbList = p->textList();
QMap<int, QString> possibleTitleMap;
int currentLargestChar = 0;
int skipTextboxes = 0;
// Iterate over all textboxes. Each textbox can be a single character/word or textblock
// Here we combine the etxtboxes back together based on the textsize
// Important are the words with the biggest font size
foreach(Poppler::TextBox * tb, tbList) {
// if we added followup words, skip the textboxes here now
if (skipTextboxes > 0) {
skipTextboxes--;
continue;
}
int height = tb->charBoundingBox(0).height();
// if the following text is smaller than the biggest we found up to now, ignore it
if (height >= currentLargestChar) {
QString possibleTitle;
possibleTitle.append(tb->text());
currentLargestChar = height;
// if the text has follow up words add them to to create the full title
Poppler::TextBox* next = tb->nextWord();
while (next) {
possibleTitle.append(QLatin1Char(' '));
possibleTitle.append(next->text());
next = next->nextWord();
skipTextboxes++;
}
// now combine text for each font size together, very likeley it must be connected
QString existingTitlePart = possibleTitleMap.value(currentLargestChar, QString());
existingTitlePart.append(QLatin1Char(' '));
existingTitlePart.append(possibleTitle);
possibleTitleMap.insert(currentLargestChar, existingTitlePart);
}
}
qDeleteAll(tbList);
QList<int> titleSizes = possibleTitleMap.keys();
qSort(titleSizes.begin(), titleSizes.end(), qGreater<int>());
QString newPossibleTitle;
// find the text with the largest font that is not just 1 character
foreach(int i, titleSizes) {
QString title = possibleTitleMap.value(i);
// sometime the biggest part is a single letter
// as a starting paragraph letter
if (title.size() < 5) {
continue;
} else {
newPossibleTitle = title.trimmed();
break;
}
}
void AnnotationWorkstationExtensionPlugin::onLoadButtonPressed(const std::string& filePath) {
QString fileName;
if (filePath.empty()) {
fileName = QFileDialog::getOpenFileName(NULL, tr("Load annotations"), _settings->value("lastOpenendPath", QStandardPaths::standardLocations(QStandardPaths::DocumentsLocation)).toString(), tr("Annotation files(*.xml;*.ndpa)"));
}
else {
fileName = QString::fromStdString(filePath);
}
if (!fileName.isEmpty()) {
onClearButtonPressed();
if (!_annotationService->loadRepositoryFromFile(fileName.toStdString())) {
int ret = QMessageBox::warning(NULL, tr("ASAP"),
tr("The annotations could not be loaded."),
QMessageBox::Ok);
}
// Check if it is an ImageScopeRepository, if so, offer the user the chance to reload with new closing distance
std::shared_ptr<ImageScopeRepository> imscRepo = std::dynamic_pointer_cast<ImageScopeRepository>(_annotationService->getRepository());
if (imscRepo) {
bool ok = false;
float newClosingDistance = QInputDialog::getDouble(_viewer, tr("Enter the annotation closing distance."), tr("Please provide the maximal distance for which annotations are automatically closed by ASAP if they remain open."), 30., 0, 1000, 1, &ok);
float closingDistance = imscRepo->getClosingDistance();
if (ok && newClosingDistance != closingDistance) {
_annotationService->getList()->removeAllAnnotations();
_annotationService->getList()->removeAllGroups();
imscRepo->setClosingDistance(newClosingDistance);
imscRepo->load();
}
}
// Add loaded groups to treewidget
QList<QtAnnotationGroup* > childGroups;
std::map<std::shared_ptr<AnnotationGroup>, QTreeWidgetItem*> annotToWidget;
std::vector<std::shared_ptr<AnnotationGroup> > grps = _annotationService->getList()->getGroups();
for (std::vector<std::shared_ptr<AnnotationGroup> >::const_iterator it = grps.begin(); it != grps.end(); ++it) {
QtAnnotationGroup *grp = new QtAnnotationGroup(*it, this);
if ((*it)->getGroup() == NULL) {
_qtAnnotationGroups.append(grp);
QTreeWidgetItem* newAnnotationGroup = new QTreeWidgetItem(_treeWidget);
newAnnotationGroup->setText(1, QString::fromStdString((*it)->getName()));
newAnnotationGroup->setText(2, "Group");
newAnnotationGroup->setData(1, Qt::UserRole, QVariant::fromValue<QtAnnotationGroup*>(grp));
newAnnotationGroup->setFlags(newAnnotationGroup->flags() | Qt::ItemIsEditable);
int cHeight = _treeWidget->visualItemRect(newAnnotationGroup).height();
QPixmap iconPM(cHeight, cHeight);
iconPM.fill(QColor((*it)->getColor().c_str()));
QIcon color(iconPM);
newAnnotationGroup->setIcon(0, color);
newAnnotationGroup->setData(0, Qt::UserRole, QColor((*it)->getColor().c_str()));
annotToWidget[grp->getAnnotationGroup()] = newAnnotationGroup;
}
else {
childGroups.append(grp);
}
}
while (!childGroups.empty()) {
for (QList<QtAnnotationGroup*>::iterator it = childGroups.begin(); it != childGroups.end();) {
if (annotToWidget.find((*it)->getAnnotationGroup()->getGroup()) != annotToWidget.end()) {
_qtAnnotationGroups.append((*it));
QTreeWidgetItem* newAnnotationGroup = new QTreeWidgetItem(annotToWidget[(*it)->getAnnotationGroup()->getGroup()]);
newAnnotationGroup->setText(1, QString::fromStdString((*it)->getAnnotationGroup()->getName()));
newAnnotationGroup->setText(2, "Group");
newAnnotationGroup->setData(1, Qt::UserRole, QVariant::fromValue<QtAnnotationGroup*>((*it)));
newAnnotationGroup->setFlags(newAnnotationGroup->flags() | Qt::ItemIsEditable);
int cHeight = _treeWidget->visualItemRect(newAnnotationGroup).height();
QPixmap iconPM(cHeight, cHeight);
iconPM.fill(QColor((*it)->getAnnotationGroup()->getColor().c_str()));
QIcon color(iconPM);
newAnnotationGroup->setIcon(0, color);
newAnnotationGroup->setData(0, Qt::UserRole, QColor((*it)->getAnnotationGroup()->getColor().c_str()));
annotToWidget[(*it)->getAnnotationGroup()] = newAnnotationGroup;
it = childGroups.erase(it);
}
else{
++it;
}
}
}
std::vector<std::shared_ptr<Annotation> > annots = _annotationService->getList()->getAnnotations();
for (std::vector<std::shared_ptr<Annotation> >::const_iterator it = annots.begin(); it != annots.end(); ++it) {
QTreeWidgetItem* prnt = _treeWidget->invisibleRootItem();
if ((*it)->getGroup()) {
prnt = annotToWidget[(*it)->getGroup()];
}
std::string key = "Annotation " + QString::number(_annotationIndex).toStdString() + "_annotation";
// Add QtAnnotation
QtAnnotation* annot = NULL;
if ((*it)->getType() == Annotation::Type::DOT) {
annot = new DotQtAnnotation((*it), this, _viewer->getSceneScale());
}
else if ((*it)->getType() == Annotation::Type::POLYGON) {
annot = new PolyQtAnnotation((*it), this, _viewer->getSceneScale());
dynamic_cast<PolyQtAnnotation*>(annot)->setInterpolationType("linear");
}
else if ((*it)->getType() == Annotation::Type::SPLINE) {
annot = new PolyQtAnnotation((*it), this, _viewer->getSceneScale());
dynamic_cast<PolyQtAnnotation*>(annot)->setInterpolationType("spline");
}
else if ((*it)->getType() == Annotation::Type::POINTSET) {
annot = new PointSetQtAnnotation((*it), this, _viewer->getSceneScale());
}
if (annot) {
annot->finish();
_qtAnnotations.append(annot);
_viewer->scene()->addItem(annot);
annot->setZValue(20.);
_annotationIndex += 1;
QTreeWidgetItem* newAnnotation = new QTreeWidgetItem(prnt);
newAnnotation->setText(1, QString::fromStdString((*it)->getName()));
newAnnotation->setText(2, QString::fromStdString((*it)->getTypeAsString()));
newAnnotation->setFlags(newAnnotation->flags() & ~Qt::ItemIsDropEnabled);
newAnnotation->setFlags(newAnnotation->flags() | Qt::ItemIsEditable);
newAnnotation->setData(1, Qt::UserRole, QVariant::fromValue<QtAnnotation*>(annot));
int cHeight = _treeWidget->visualItemRect(newAnnotation).height();
if (_treeWidget->topLevelItemCount() > 0) {
cHeight = _treeWidget->visualItemRect(_treeWidget->topLevelItem(0)).height();
}
QPixmap iconPM(cHeight, cHeight);
iconPM.fill(QColor((*it)->getColor().c_str()));
QIcon color(iconPM);
newAnnotation->setIcon(0, color);
newAnnotation->setData(0, Qt::UserRole, QColor((*it)->getColor().c_str()));
_annotToItem[annot] = newAnnotation;
updateAnnotationToolTip(annot);
connect(annot, SIGNAL(coordinatesChanged(QtAnnotation*)), this, SLOT(updateAnnotationToolTip(QtAnnotation*)));
}
}
_treeWidget->resizeColumnToContents(0);
_treeWidget->resizeColumnToContents(1);
}
int main ( int argc, char **argv )
{
QCoreApplication app ( argc, argv );
QHash<int, QImage> imagesToUse;
QList<QImage> images;
const QSize size16 ( 16,16 );
const QSize size32 ( 32,32 );
const QSize size48 ( 48,48 );
if ( argc < 3 )
usage ( "To few arguments" );
QString rcFileName;
QString icoFileName;
int hotspotx = 0;
int hotspoty = 0;
int framerate = 3;
for ( int i = 1; i < argc; i++ ) {
const QString arg = app.arguments() [i];
if ( arg == QLatin1String ( "--rcfile" ) ) {
if ( i + 1 < argc ) {
rcFileName = app.arguments() [i+1];
i++;
continue;
} else {
usage ( "option '--rcfile' without filename" );
}
} else if (arg == "--hotspotx") {
if ( i + 1 < argc ) {
hotspotx = app.arguments()[i+1].toInt();
i++;
continue;
} else {
usage ( "option '--hotspotx' without value" );
}
} else if (arg == "--hotspoty") {
if ( i + 1 < argc ) {
hotspoty = app.arguments()[i+1].toInt();
i++;
continue;
} else {
usage ( "option '--hotspoty' without value" );
}
} else if (arg == "--framerate") {
if ( i + 1 < argc ) {
framerate = app.arguments()[i+1].toInt();
i++;
continue;
} else {
usage ( "option '--framerate' without value" );
}
}
if ( icoFileName.isEmpty() ) {
icoFileName = arg;
continue;
}
QImage img;
img.load ( arg );
if ( img.isNull() ) {
warning ( QString ( "Can not load image %1" ).arg ( arg ) );
continue;
}
if (icoFileName.endsWith(".ico", Qt::CaseInsensitive)) {
images += img;
if ( img.size() == size16 ) {
if ( imagesToUse.contains ( 16 ) ) {
warning ( QString ( "Already have an Image with 16x16 - overwriting with %1" ).arg ( arg ) );
}
imagesToUse.insert ( 16, img );
continue;
}
if ( img.size() == size32 ) {
if ( imagesToUse.contains ( 32 ) ) {
warning ( QString ( "Already have an Image with 32x32 - overwriting with %1" ).arg ( arg ) );
}
imagesToUse.insert ( 32, img );
continue;
}
if ( img.size() == size48 ) {
if ( imagesToUse.contains ( 48 ) ) {
warning ( QString ( "Already have an Image with 48x48- overwriting with %1" ).arg ( arg ) );
}
imagesToUse.insert ( 48, img );
continue;
}
} else {
if (img.size() != QSize(32, 32)) {
img = scaleImage(img);
}
images += img;
}
}
if ( images.count() == 0 )
usage ( "No valid images found!" );
if (icoFileName.endsWith(".ico", Qt::CaseInsensitive)) {
qSort ( images.begin(), images.end(), sortQImageForSize );
// 48x48 available -> if not create one
if ( !imagesToUse.contains ( 48 ) ) {
QImage img;
Q_FOREACH ( const QImage &i, images ) {
if ( img.width() >= 32 && img.height() >= 32 ) {
img = i;
}
}
if ( img.isNull() ) {
// none found -> use the last (==biggest) available
img = images.last();
}
imagesToUse.insert ( 48, img.scaled ( 48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation ) );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RotateSampleRefFrame::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getCellAttributeMatrixPath().getDataContainerName());
float rotAngle = m_RotationAngle * SIMPLib::Constants::k_Pi / 180.0;
int64_t xp = 0, yp = 0, zp = 0;
float xRes = 0.0f, yRes = 0.0f, zRes = 0.0f;
int64_t xpNew = 0, ypNew = 0, zpNew = 0;
float xResNew = 0.0f, yResNew = 0.0f, zResNew = 0.0f;
RotateSampleRefFrameImplArg_t params;
xp = static_cast<int64_t>(m->getGeometryAs<ImageGeom>()->getXPoints());
xRes = m->getGeometryAs<ImageGeom>()->getXRes();
yp = static_cast<int64_t>(m->getGeometryAs<ImageGeom>()->getYPoints());
yRes = m->getGeometryAs<ImageGeom>()->getYRes();
zp = static_cast<int64_t>(m->getGeometryAs<ImageGeom>()->getZPoints());
zRes = m->getGeometryAs<ImageGeom>()->getZRes();
params.xp = xp;
params.xRes = xRes;
params.yp = yp;
params.yRes = yRes;
params.zp = zp;
params.zRes = zRes;
size_t col = 0, row = 0, plane = 0;
float rotMat[3][3] = { { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f } };
float coords[3] = { 0.0f, 0.0f, 0.0f };
float newcoords[3] = { 0.0f, 0.0f, 0.0f };
float xMin = std::numeric_limits<float>::max();
float xMax = std::numeric_limits<float>::min();
float yMin = std::numeric_limits<float>::max();
float yMax = std::numeric_limits<float>::min();
float zMin = std::numeric_limits<float>::max();
float zMax = std::numeric_limits<float>::min();
FOrientArrayType om(9);
FOrientTransformsType::ax2om(FOrientArrayType(m_RotationAxis.x, m_RotationAxis.y, m_RotationAxis.z, rotAngle), om);
om.toGMatrix(rotMat);
for (int32_t i = 0; i < 8; i++)
{
if (i == 0) { col = 0, row = 0, plane = 0; }
if (i == 1) { col = xp - 1, row = 0, plane = 0; }
if (i == 2) { col = 0, row = yp - 1, plane = 0; }
if (i == 3) { col = xp - 1, row = yp - 1, plane = 0; }
if (i == 4) { col = 0, row = 0, plane = zp - 1; }
if (i == 5) { col = xp - 1, row = 0, plane = zp - 1; }
if (i == 6) { col = 0, row = yp - 1, plane = zp - 1; }
if (i == 7) { col = xp - 1, row = yp - 1, plane = zp - 1; }
coords[0] = static_cast<float>(col * xRes);
coords[1] = static_cast<float>(row * yRes);
coords[2] = static_cast<float>(plane * zRes);
MatrixMath::Multiply3x3with3x1(rotMat, coords, newcoords);
if (newcoords[0] < xMin) { xMin = newcoords[0]; }
if (newcoords[0] > xMax) { xMax = newcoords[0]; }
if (newcoords[1] < yMin) { yMin = newcoords[1]; }
if (newcoords[1] > yMax) { yMax = newcoords[1]; }
if (newcoords[2] < zMin) { zMin = newcoords[2]; }
if (newcoords[2] > zMax) { zMax = newcoords[2]; }
}
float xAxis[3] = {1, 0, 0};
float yAxis[3] = {0, 1, 0};
float zAxis[3] = {0, 0, 1};
float xAxisNew[3] = { 0.0f, 0.0f, 0.0f };
float yAxisNew[3] = { 0.0f, 0.0f, 0.0f };
float zAxisNew[3] = { 0.0f, 0.0f, 0.0f };
MatrixMath::Multiply3x3with3x1(rotMat, xAxis, xAxisNew);
MatrixMath::Multiply3x3with3x1(rotMat, yAxis, yAxisNew);
MatrixMath::Multiply3x3with3x1(rotMat, zAxis, zAxisNew);
float closestAxis = 0.0f;
xResNew = xRes;
closestAxis = fabs(GeometryMath::CosThetaBetweenVectors(xAxis, xAxisNew));
if (fabs(GeometryMath::CosThetaBetweenVectors(yAxis, xAxisNew)) > closestAxis) { xResNew = yRes, closestAxis = fabs(GeometryMath::CosThetaBetweenVectors(yAxis, xAxisNew)); }
if (fabs(GeometryMath::CosThetaBetweenVectors(zAxis, xAxisNew)) > closestAxis) { xResNew = zRes, closestAxis = fabs(GeometryMath::CosThetaBetweenVectors(zAxis, xAxisNew)); }
yResNew = yRes;
closestAxis = fabs(GeometryMath::CosThetaBetweenVectors(yAxis, yAxisNew));
if (fabs(GeometryMath::CosThetaBetweenVectors(xAxis, yAxisNew)) > closestAxis) { yResNew = xRes, closestAxis = fabs(GeometryMath::CosThetaBetweenVectors(xAxis, yAxisNew)); }
if (fabs(GeometryMath::CosThetaBetweenVectors(zAxis, yAxisNew)) > closestAxis) { yResNew = zRes, closestAxis = fabs(GeometryMath::CosThetaBetweenVectors(zAxis, yAxisNew)); }
zResNew = zRes;
closestAxis = fabs(GeometryMath::CosThetaBetweenVectors(zAxis, zAxisNew));
if (fabs(GeometryMath::CosThetaBetweenVectors(xAxis, zAxisNew)) > closestAxis) { zResNew = xRes, closestAxis = fabs(GeometryMath::CosThetaBetweenVectors(xAxis, zAxisNew)); }
if (fabs(GeometryMath::CosThetaBetweenVectors(yAxis, zAxisNew)) > closestAxis) { zResNew = yRes, closestAxis = fabs(GeometryMath::CosThetaBetweenVectors(yAxis, zAxisNew)); }
xpNew = static_cast<int64_t>(nearbyint((xMax - xMin) / xResNew) + 1);
ypNew = static_cast<int64_t>(nearbyint((yMax - yMin) / yResNew) + 1);
zpNew = static_cast<int64_t>(nearbyint((zMax - zMin) / zResNew) + 1);
params.xpNew = xpNew;
params.xResNew = xResNew;
params.xMinNew = xMin;
params.ypNew = ypNew;
params.yResNew = yResNew;
params.yMinNew = yMin;
params.zpNew = zpNew;
params.zResNew = zResNew;
params.zMinNew = zMin;
int64_t newNumCellTuples = params.xpNew * params.ypNew * params.zpNew;
DataArray<int64_t>::Pointer newIndiciesPtr = DataArray<int64_t>::CreateArray(newNumCellTuples, "_INTERNAL_USE_ONLY_RotateSampleRef_NewIndicies");
newIndiciesPtr->initializeWithValue(-1);
int64_t* newindicies = newIndiciesPtr->getPointer(0);
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range3d<int64_t, int64_t, int64_t>(0, params.zpNew, 0, params.ypNew, 0, params.xpNew),
RotateSampleRefFrameImpl(newIndiciesPtr, ¶ms, rotMat, m_SliceBySlice), tbb::auto_partitioner());
}
else
#endif
{
RotateSampleRefFrameImpl serial(newIndiciesPtr, ¶ms, rotMat, m_SliceBySlice);
serial.convert(0, params.zpNew, 0, params.ypNew, 0, params.xpNew);
}
// This could technically be parallelized also where each thread takes an array to adjust. Except
// that the DataContainer is NOT thread safe or re-entrant so that would actually be a BAD idea.
QString attrMatName = getCellAttributeMatrixPath().getAttributeMatrixName();
QList<QString> voxelArrayNames = m->getAttributeMatrix(attrMatName)->getAttributeArrayNames();
// resize attribute matrix
QVector<size_t> tDims(3);
tDims[0] = params.xpNew;
tDims[1] = params.ypNew;
tDims[2] = params.zpNew;
m->getAttributeMatrix(attrMatName)->resizeAttributeArrays(tDims);
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attrMatName)->getAttributeArray(*iter);
// Make a copy of the 'p' array that has the same name. When placed into
// the data container this will over write the current array with
// the same name.
IDataArray::Pointer data = p->createNewArray(newNumCellTuples, p->getComponentDimensions(), p->getName());
void* source = NULL;
void* destination = NULL;
int64_t newIndicies_I = 0;
int32_t nComp = data->getNumberOfComponents();
for (size_t i = 0; i < static_cast<size_t>(newNumCellTuples); i++)
{
newIndicies_I = newindicies[i];
if(newIndicies_I >= 0)
{
source = p->getVoidPointer((nComp * newIndicies_I));
if (NULL == source)
{
QString ss = QObject::tr("The index is outside the bounds of the source array");
setErrorCondition(-11004);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
destination = data->getVoidPointer((data->getNumberOfComponents() * i));
::memcpy(destination, source, p->getTypeSize() * data->getNumberOfComponents());
}
else
{
data->initializeTuple(i, 0);
}
}
m->getAttributeMatrix(attrMatName)->addAttributeArray(*iter, data);
}
m->getGeometryAs<ImageGeom>()->setResolution(params.xResNew, params.yResNew, params.zResNew);
m->getGeometryAs<ImageGeom>()->setDimensions(params.xpNew, params.ypNew, params.zpNew);
m->getGeometryAs<ImageGeom>()->setOrigin(xMin, yMin, zMin);
notifyStatusMessage(getHumanLabel(), "Complete");
}
RipCDDialog::RipCDDialog(QWidget* parent)
: QDialog(parent),
ui_(new Ui_RipCDDialog),
ripper_(new Ripper(this)),
working_(false) {
// Init
ui_->setupUi(this);
// Set column widths in the QTableWidget.
ui_->tableWidget->horizontalHeader()->setResizeMode(
kCheckboxColumn, QHeaderView::ResizeToContents);
ui_->tableWidget->horizontalHeader()->setResizeMode(
kTrackNumberColumn, QHeaderView::ResizeToContents);
ui_->tableWidget->horizontalHeader()->setResizeMode(kTrackTitleColumn,
QHeaderView::Stretch);
// Add a rip button
rip_button_ = ui_->button_box->addButton(tr("Start ripping"),
QDialogButtonBox::ActionRole);
cancel_button_ = ui_->button_box->button(QDialogButtonBox::Cancel);
close_button_ = ui_->button_box->button(QDialogButtonBox::Close);
// Hide elements
cancel_button_->hide();
ui_->progress_group->hide();
connect(ui_->select_all_button, SIGNAL(clicked()), SLOT(SelectAll()));
connect(ui_->select_none_button, SIGNAL(clicked()), SLOT(SelectNone()));
connect(ui_->invert_selection_button, SIGNAL(clicked()),
SLOT(InvertSelection()));
connect(rip_button_, SIGNAL(clicked()), SLOT(ClickedRipButton()));
connect(cancel_button_, SIGNAL(clicked()), ripper_, SLOT(Cancel()));
connect(close_button_, SIGNAL(clicked()), SLOT(hide()));
connect(ui_->options, SIGNAL(clicked()), SLOT(Options()));
connect(ui_->select, SIGNAL(clicked()), SLOT(AddDestination()));
connect(ripper_, SIGNAL(Finished()), SLOT(Finished()));
connect(ripper_, SIGNAL(Cancelled()), SLOT(Cancelled()));
connect(ripper_, SIGNAL(ProgressInterval(int, int)),
SLOT(SetupProgressBarLimits(int, int)));
connect(ripper_, SIGNAL(Progress(int)), SLOT(UpdateProgressBar(int)));
setWindowTitle(tr("Rip CD"));
AddDestinationDirectory(QDir::homePath());
// Get presets
QList<TranscoderPreset> presets = Transcoder::GetAllPresets();
qSort(presets.begin(), presets.end(), ComparePresetsByName);
for (const TranscoderPreset& preset : presets) {
ui_->format->addItem(
QString("%1 (.%2)").arg(preset.name_).arg(preset.extension_),
QVariant::fromValue(preset));
}
// Load settings
QSettings s;
s.beginGroup(kSettingsGroup);
last_add_dir_ = s.value("last_add_dir", QDir::homePath()).toString();
QString last_output_format = s.value("last_output_format", "ogg").toString();
for (int i = 0; i < ui_->format->count(); ++i) {
if (last_output_format ==
ui_->format->itemData(i).value<TranscoderPreset>().extension_) {
ui_->format->setCurrentIndex(i);
break;
}
}
}
void TriggerSkillSorter::sort(QList<const TriggerSkill *> &skills){
qStableSort(skills.begin(), skills.end(), *this);
}
bool Tessellation::accept()
{
if (ui->treeWidget->selectedItems().isEmpty()) {
QMessageBox::critical(this, windowTitle(),
tr("Select a shape for meshing, first."));
return false;
}
App::Document* activeDoc = App::GetApplication().getDocument((const char*)this->document.toLatin1());
if (!activeDoc) {
QMessageBox::critical(this, windowTitle(),
tr("No such document '%1'.").arg(this->document));
return false;
}
try {
QString shape, label;
Gui::WaitCursor wc;
int method = buttonGroup->checkedId();
activeDoc->openTransaction("Meshing");
QList<QTreeWidgetItem *> items = ui->treeWidget->selectedItems();
std::vector<Part::Feature*> shapes = Gui::Selection().getObjectsOfType<Part::Feature>();
for (QList<QTreeWidgetItem *>::iterator it = items.begin(); it != items.end(); ++it) {
shape = (*it)->data(0, Qt::UserRole).toString();
label = (*it)->text(0);
QString cmd;
if (method == 0) { // Standard
double devFace = ui->spinSurfaceDeviation->value().getValue();
cmd = QString::fromLatin1(
"__doc__=FreeCAD.getDocument(\"%1\")\n"
"__mesh__=__doc__.addObject(\"Mesh::Feature\",\"Mesh\")\n"
"__mesh__.Mesh=Mesh.Mesh(__doc__.getObject(\"%2\").Shape.tessellate(%3))\n"
"__mesh__.Label=\"%4 (Meshed)\"\n"
"__mesh__.ViewObject.CreaseAngle=25.0\n"
"del __doc__, __mesh__\n")
.arg(this->document)
.arg(shape)
.arg(devFace)
.arg(label);
}
else if (method == 1) { // Mefisto
double maxEdge = ui->spinMaximumEdgeLength->value().getValue();
if (!ui->spinMaximumEdgeLength->isEnabled())
maxEdge = 0;
cmd = QString::fromLatin1(
"__doc__=FreeCAD.getDocument(\"%1\")\n"
"__mesh__=__doc__.addObject(\"Mesh::Feature\",\"Mesh\")\n"
"__mesh__.Mesh=MeshPart.meshFromShape(Shape=__doc__.getObject(\"%2\").Shape,MaxLength=%3)\n"
"__mesh__.Label=\"%4 (Meshed)\"\n"
"__mesh__.ViewObject.CreaseAngle=25.0\n"
"del __doc__, __mesh__\n")
.arg(this->document)
.arg(shape)
.arg(maxEdge)
.arg(label);
}
else if (method == 2) { // Netgen
int fineness = ui->comboFineness->currentIndex();
double growthRate = ui->doubleGrading->value();
double nbSegPerEdge = ui->spinEdgeElements->value();
double nbSegPerRadius = ui->spinCurvatureElements->value();
bool secondOrder = ui->checkSecondOrder->isChecked();
bool optimize = ui->checkOptimizeSurface->isChecked();
bool allowquad = ui->checkQuadDominated->isChecked();
if (fineness < 5) {
cmd = QString::fromLatin1(
"__doc__=FreeCAD.getDocument(\"%1\")\n"
"__mesh__=__doc__.addObject(\"Mesh::Feature\",\"Mesh\")\n"
"__mesh__.Mesh=MeshPart.meshFromShape(Shape=__doc__.getObject(\"%2\").Shape,"
"Fineness=%3,SecondOrder=%4,Optimize=%5,AllowQuad=%6)\n"
"__mesh__.Label=\"%7 (Meshed)\"\n"
"__mesh__.ViewObject.CreaseAngle=25.0\n"
"del __doc__, __mesh__\n")
.arg(this->document)
.arg(shape)
.arg(fineness)
.arg(secondOrder ? 1 : 0)
.arg(optimize ? 1 : 0)
.arg(allowquad ? 1 : 0)
.arg(label);
}
else {
cmd = QString::fromLatin1(
"__doc__=FreeCAD.getDocument(\"%1\")\n"
"__mesh__=__doc__.addObject(\"Mesh::Feature\",\"Mesh\")\n"
"__mesh__.Mesh=MeshPart.meshFromShape(Shape=__doc__.getObject(\"%2\").Shape,"
"GrowthRate=%3,SegPerEdge=%4,SegPerRadius=%5,SecondOrder=%6,Optimize=%7,AllowQuad=%8)\n"
"__mesh__.Label=\"%9 (Meshed)\"\n"
"__mesh__.ViewObject.CreaseAngle=25.0\n"
"del __doc__, __mesh__\n")
.arg(this->document)
.arg(shape)
.arg(growthRate)
.arg(nbSegPerEdge)
.arg(nbSegPerRadius)
.arg(secondOrder ? 1 : 0)
.arg(optimize ? 1 : 0)
.arg(allowquad ? 1 : 0)
.arg(label);
}
}
Gui::Command::doCommand(Gui::Command::Doc, (const char*)cmd.toUtf8());
}
activeDoc->commitTransaction();
}
catch (const Base::Exception& e) {
Base::Console().Error(e.what());
}
return true;
}
ErrorList topolTest::checkPointCoveredBySegment( double tolerance, QgsVectorLayer *layer1, QgsVectorLayer *layer2, bool isExtent )
{
Q_UNUSED( tolerance );
int i = 0;
ErrorList errorList;
if ( layer1->geometryType() != QgsWkbTypes::PointGeometry )
{
return errorList;
}
if ( layer2->geometryType() == QgsWkbTypes::PointGeometry )
{
return errorList;
}
QgsSpatialIndex *index = mLayerIndexes[layer2->id()];
QgsGeometry canvasExtentPoly = QgsGeometry::fromWkt( qgsInterface->mapCanvas()->extent().asWktPolygon() );
QList<FeatureLayer>::Iterator it;
for ( it = mFeatureList1.begin(); it != mFeatureList1.end(); ++it )
{
if ( !( ++i % 100 ) )
emit progress( i );
if ( testCanceled() )
break;
QgsGeometry g1 = it->feature.geometry();
QgsRectangle bb = g1.boundingBox();
QList<QgsFeatureId> crossingIds;
crossingIds = index->intersects( bb );
QList<QgsFeatureId>::ConstIterator cit = crossingIds.begin();
QList<QgsFeatureId>::ConstIterator crossingIdsEnd = crossingIds.end();
bool touched = false;
for ( ; cit != crossingIdsEnd; ++cit )
{
QgsFeature &f = mFeatureMap2[*cit].feature;
QgsGeometry g2 = f.geometry();
if ( g2.isNull() )
{
QgsMessageLog::logMessage( tr( "Invalid geometry in covering test." ), tr( "Topology plugin" ) );
continue;
}
// test if point touches other geometry
if ( g1.touches( g2 ) )
{
touched = true;
break;
}
}
if ( !touched )
{
QgsGeometry conflictGeom = QgsGeometry( g1 );
if ( isExtent )
{
if ( canvasExtentPoly.disjoint( conflictGeom ) )
{
continue;
}
}
QList<FeatureLayer> fls;
fls << *it << *it;
//bb.scale(10);
TopolErrorCovered *err = new TopolErrorCovered( bb, conflictGeom, fls );
errorList << err;
}
}
return errorList;
}
ErrorList topolTest::checkOverlaps( double tolerance, QgsVectorLayer *layer1, QgsVectorLayer *layer2, bool isExtent )
{
Q_UNUSED( tolerance );
Q_UNUSED( layer2 );
int i = 0;
ErrorList errorList;
// could be enabled for lines and points too
// so duplicate rule may be removed?
if ( layer1->geometryType() != QgsWkbTypes::PolygonGeometry )
{
return errorList;
}
QList<QgsFeatureId> *duplicateIds = new QList<QgsFeatureId>();
QgsSpatialIndex *index = mLayerIndexes[layer1->id()];
if ( !index )
{
qDebug() << "no index present";
delete duplicateIds;
return errorList;
}
QMap<QgsFeatureId, FeatureLayer>::const_iterator it;
for ( it = mFeatureMap2.constBegin(); it != mFeatureMap2.constEnd(); ++it )
{
if ( !( ++i % 100 ) )
emit progress( i );
QgsFeatureId currentId = it->feature.id();
if ( duplicateIds->contains( currentId ) )
{
//is already a duplicate geometry..skip..
continue;
}
if ( testCanceled() )
break;
QgsGeometry g1 = it->feature.geometry();
if ( !g1.isGeosValid() )
{
qDebug() << "invalid geometry(g1) found..skipping.." << it->feature.id();
continue;
}
QgsRectangle bb = g1.boundingBox();
QList<QgsFeatureId> crossingIds;
crossingIds = index->intersects( bb );
QList<QgsFeatureId>::ConstIterator cit = crossingIds.begin();
QList<QgsFeatureId>::ConstIterator crossingIdsEnd = crossingIds.end();
bool duplicate = false;
QgsGeometry canvasExtentPoly = QgsGeometry::fromWkt( qgsInterface->mapCanvas()->extent().asWktPolygon() );
for ( ; cit != crossingIdsEnd; ++cit )
{
duplicate = false;
// skip itself
if ( mFeatureMap2[*cit].feature.id() == it->feature.id() )
continue;
QgsGeometry g2 = mFeatureMap2[*cit].feature.geometry();
if ( g2.isNull() )
{
QgsMessageLog::logMessage( tr( "Invalid second geometry in overlaps test." ), tr( "Topology plugin" ) );
continue;
}
if ( !_canExportToGeos( g2 ) )
{
QgsMessageLog::logMessage( tr( "Failed to import second geometry into GEOS in overlaps test." ), tr( "Topology plugin" ) );
continue;
}
if ( !g2.isGeosValid() )
{
QgsMessageLog::logMessage( tr( "Skipping invalid second geometry of feature %1 in overlaps test." ).arg( it->feature.id() ), tr( "Topology plugin" ) );
continue;
}
qDebug() << "checking overlap for" << it->feature.id();
if ( g1.overlaps( g2 ) )
{
duplicate = true;
duplicateIds->append( mFeatureMap2[*cit].feature.id() );
}
if ( duplicate )
{
QList<FeatureLayer> fls;
fls << *it << *it;
QgsGeometry conflictGeom = g1.intersection( g2 );
if ( isExtent )
{
if ( canvasExtentPoly.disjoint( conflictGeom ) )
{
continue;
}
if ( canvasExtentPoly.crosses( conflictGeom ) )
{
conflictGeom = conflictGeom.intersection( canvasExtentPoly );
}
}
TopolErrorOverlaps *err = new TopolErrorOverlaps( bb, conflictGeom, fls );
errorList << err;
}
}
}
delete duplicateIds;
return errorList;
}
ErrorList topolTest::checkCloseFeature( double tolerance, QgsVectorLayer *layer1, QgsVectorLayer *layer2, bool isExtent )
{
Q_UNUSED( isExtent );
ErrorList errorList;
QgsSpatialIndex *index = 0;
bool badG1 = false, badG2 = false;
bool skipItself = layer1 == layer2;
int i = 0;
QList<FeatureLayer>::Iterator it;
QList<FeatureLayer>::ConstIterator FeatureListEnd = mFeatureList1.end();
for ( it = mFeatureList1.begin(); it != FeatureListEnd; ++it )
{
if ( !( ++i % 100 ) )
emit progress( i );
if ( testCanceled() )
break;
QgsGeometry *g1 = it->feature.geometry();
if ( !g1 || !g1->asGeos() )
{
badG1 = true;
continue;
}
QgsRectangle bb = g1->boundingBox();
// increase bounding box by tolerance
QgsRectangle frame( bb.xMinimum() - tolerance, bb.yMinimum() - tolerance, bb.xMaximum() + tolerance, bb.yMaximum() + tolerance );
QList<QgsFeatureId> crossingIds;
crossingIds = index->intersects( frame );
QList<QgsFeatureId>::Iterator cit = crossingIds.begin();
QList<QgsFeatureId>::ConstIterator crossingIdsEnd = crossingIds.end();
for ( ; cit != crossingIdsEnd; ++cit )
{
QgsFeature &f = mFeatureMap2[*cit].feature;
QgsGeometry *g2 = f.geometry();
// skip itself, when invoked with the same layer
if ( skipItself && f.id() == it->feature.id() )
continue;
if ( !g2 || !g2->asGeos() )
{
badG2 = true;
continue;
}
if ( g1->distance( *g2 ) < tolerance )
{
QgsRectangle r = g2->boundingBox();
r.combineExtentWith( &bb );
QList<FeatureLayer> fls;
FeatureLayer fl;
fl.feature = f;
fl.layer = layer2;
fls << *it << fl;
QgsGeometry *conflict = new QgsGeometry( *g2 );
TopolErrorClose *err = new TopolErrorClose( r, conflict, fls );
//TopolErrorClose* err = new TopolErrorClose(r, g2, fls);
errorList << err;
}
}
}
if ( badG2 )
QgsMessageLog::logMessage( tr( "Invalid second geometry." ), tr( "Topology plugin" ) );
if ( badG1 )
QgsMessageLog::logMessage( tr( "Invalid first geometry." ), tr( "Topology plugin" ) );
return errorList;
}
void QgsMapToolNodeTool::canvasPressEvent( QMouseEvent * e )
{
QgsDebugCall;
mClicked = true;
mPressCoordinates = e->pos();
QList<QgsSnappingResult> snapResults;
if ( !mSelectedFeature )
{
QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() );
if ( !vlayer )
return;
mSelectAnother = false;
mSnapper.snapToCurrentLayer( e->pos(), snapResults, QgsSnapper::SnapToVertexAndSegment, -1 );
if ( snapResults.size() < 1 )
{
displaySnapToleranceWarning();
return;
}
mSelectedFeature = new QgsSelectedFeature( snapResults[0].snappedAtGeometry, vlayer, mCanvas );
connect( mSelectedFeature, SIGNAL( destroyed() ), this, SLOT( selectedFeatureDestroyed() ) );
mIsPoint = vlayer->geometryType() == QGis::Point;
}
else
{
QgsVectorLayer *vlayer = mSelectedFeature->vlayer();
Q_ASSERT( vlayer );
// some feature already selected
QgsPoint layerCoordPoint = toLayerCoordinates( vlayer, e->pos() );
double tol = QgsTolerance::vertexSearchRadius( vlayer, mCanvas->mapRenderer() );
// get geometry and find if snapping is near it
int atVertex, beforeVertex, afterVertex;
double dist;
QgsPoint closestLayerVertex = mSelectedFeature->geometry()->closestVertex( layerCoordPoint, atVertex, beforeVertex, afterVertex, dist );
dist = sqrt( dist );
mSnapper.snapToCurrentLayer( e->pos(), snapResults, QgsSnapper::SnapToVertex, tol );
if ( dist <= tol )
{
// some vertex selected
mMoving = true;
mClosestMapVertex = toMapCoordinates( vlayer, closestLayerVertex );
if ( mMoving )
{
if ( mSelectedFeature->isSelected( atVertex ) )
{
mDeselectOnRelease = atVertex;
}
else if ( mCtrl )
{
mSelectedFeature->invertVertexSelection( atVertex );
}
else
{
mSelectedFeature->deselectAllVertexes();
mSelectedFeature->selectVertex( atVertex );
}
}
else
{
// select another feature
mAnother = snapResults.first().snappedAtGeometry;
mSelectAnother = true;
}
}
else
{
// no near vertex to snap
// unless point layer, try segment
if ( !mIsPoint )
mSnapper.snapToCurrentLayer( e->pos(), snapResults, QgsSnapper::SnapToSegment, tol );
if ( snapResults.size() > 0 )
{
// need to check all if there is a point in the feature
mAnother = snapResults.first().snappedAtGeometry;
mSelectAnother = true;
QList<QgsSnappingResult>::iterator it = snapResults.begin();
QgsSnappingResult snapResult;
for ( ; it != snapResults.end(); ++it )
{
if ( it->snappedAtGeometry == mSelectedFeature->featureId() )
{
snapResult = *it;
mAnother = 0;
mSelectAnother = false;
break;
}
}
if ( !mSelectAnother )
{
mMoving = true;
mClosestMapVertex = toMapCoordinates( vlayer, closestLayerVertex );
if ( mIsPoint )
{
if ( !mCtrl )
{
mSelectedFeature->deselectAllVertexes();
mSelectedFeature->selectVertex( snapResult.snappedVertexNr );
}
else
{
mSelectedFeature->invertVertexSelection( snapResult.snappedVertexNr );
}
}
else
{
if ( !mCtrl )
{
mSelectedFeature->deselectAllVertexes();
mSelectedFeature->selectVertex( snapResult.afterVertexNr );
mSelectedFeature->selectVertex( snapResult.beforeVertexNr );
}
else
{
mSelectedFeature->invertVertexSelection( snapResult.afterVertexNr );
mSelectedFeature->invertVertexSelection( snapResult.beforeVertexNr );
}
}
}
}
else if ( !mCtrl )
{
mSelectedFeature->deselectAllVertexes();
}
}
}
}
SCgBaseCommand* SCgScene::deleteSelObjectsCommand(SCgBaseCommand* parentCmd, bool addToStack)
{
QList<QGraphicsItem*> selObjects = selectedItems();
QList<QGraphicsItem*>::iterator it = selObjects.begin();
SCgBaseCommand *cmd = 0;
for (; it != selObjects.end(); ++it)
{
// skip none sc.g-objects
if ( !SCgObject::isSCgObjectType((*it)->type()) )
continue;
SCgObject *obj = static_cast<SCgObject*>(*it);
if (!cmd)
cmd = new SCgCommandObjectDelete(this, obj, parentCmd);
else
new SCgCommandObjectDelete(this, obj, cmd);
}
// Delete points only if object is not deleted by previous operations
if(!cmd)
{
SCgPointObject* parent = 0;
SCgPointObject::PointFVector newPoints;
QList<int> delIndexes; //< list with indexes of points which will be deleted
for (it = selObjects.begin(); it != selObjects.end(); ++it)
{
// skip none Point items
if ( (*it)->type() != SCgPointGraphicsItem::Type)
continue;
SCgPointGraphicsItem *item = static_cast<SCgPointGraphicsItem*>(*it);
if(!parent)
{
parent = item->parentSCgPointObject();
newPoints = parent->points();
if(newPoints.size() < 2 || (parent->type() == SCgContour::Type && newPoints.size() < 3))
break; //If there are not enough points, we should do nothing.
}
//We expect, that at the same time only one SCgPointObject is editable.
Q_ASSERT(parent == item->parentSCgPointObject());
delIndexes.push_back(item->pointIndex());
}
if(parent)
{
// Sort list in back order. Because after erasing item from vector, indexes
// can be wrong. So we should delete in back order.
qSort(delIndexes.begin(), delIndexes.end(), qGreater<int>());
foreach(const int& index, delIndexes)
{
int s = newPoints.size();
if(s > 2 && (parent->type() != SCgContour::Type || s > 3))//< another checking of points count
newPoints.erase(newPoints.begin()+index);
}
if(newPoints != parent->points())
cmd = new SCgCommandPointsChange(this, parent, newPoints, parentCmd);
}
bool QgsComposerModel::dropMimeData( const QMimeData *data,
Qt::DropAction action, int row, int column, const QModelIndex &parent )
{
if ( column != ItemId )
{
return false;
}
if ( action == Qt::IgnoreAction )
{
return true;
}
if ( !data->hasFormat( "application/x-vnd.qgis.qgis.composeritemid" ) )
{
return false;
}
if ( parent.isValid() )
{
return false;
}
int beginRow = row != -1 ? row : rowCount( QModelIndex() );
QByteArray encodedData = data->data( "application/x-vnd.qgis.qgis.composeritemid" );
QDataStream stream( &encodedData, QIODevice::ReadOnly );
QList<QgsComposerItem*> droppedItems;
int rows = 0;
while ( !stream.atEnd() )
{
QString text;
stream >> text;
const QgsComposerItem* item = mComposition->getComposerItemByUuid( text );
if ( item )
{
droppedItems << const_cast<QgsComposerItem*>( item );
++rows;
}
}
if ( droppedItems.length() == 0 )
{
//no dropped items
return false;
}
//move dropped items
//first sort them by z-order
qSort( droppedItems.begin(), droppedItems.end(), zOrderDescending );
//calculate position in z order list to drop items at
int destPos = 0;
if ( beginRow < rowCount() )
{
QgsComposerItem* itemBefore = mItemsInScene.at( beginRow );
destPos = mItemZList.indexOf( itemBefore );
}
else
{
//place items at end
destPos = mItemZList.size();
}
//calculate position to insert moved rows to
int insertPos = destPos;
QList<QgsComposerItem*>::iterator itemIt = droppedItems.begin();
for ( ; itemIt != droppedItems.end(); ++itemIt )
{
int listPos = mItemZList.indexOf( *itemIt );
if ( listPos == -1 )
{
//should be impossible
continue;
}
if ( listPos < destPos )
{
insertPos--;
}
}
//remove rows from list
itemIt = droppedItems.begin();
for ( ; itemIt != droppedItems.end(); ++itemIt )
{
mItemZList.removeOne( *itemIt );
}
//insert items
itemIt = droppedItems.begin();
for ( ; itemIt != droppedItems.end(); ++itemIt )
{
mItemZList.insert( insertPos, *itemIt );
insertPos++;
}
rebuildSceneItemList();
mComposition->updateZValues( false );
return true;
}
void OptBase::interpretKeyword_base(QString &line, Structure* structure)
{
QString rep = "";
// User data
if (line == "user1") rep += optimizer()->getUser1();
else if (line == "user2") rep += optimizer()->getUser2();
else if (line == "user3") rep += optimizer()->getUser3();
else if (line == "user4") rep += optimizer()->getUser4();
else if (line == "description") rep += description;
else if (line == "percent") rep += "%";
// Structure specific data
if (line == "coords") {
QList<Avogadro::Atom*> atoms = structure->atoms();
QList<Avogadro::Atom*>::const_iterator it;
int optIndex = -1;
QHash<int, int> *lut = structure->getOptimizerLookupTable();
lut->clear();
const Eigen::Vector3d *vec;
for (it = atoms.begin();
it != atoms.end();
it++) {
rep += QString(OpenBabel::etab.GetSymbol((*it)->atomicNumber()))+ " ";
vec = (*it)->pos();
rep += QString::number(vec->x()) + " ";
rep += QString::number(vec->y()) + " ";
rep += QString::number(vec->z()) + "\n";
lut->insert(++optIndex, (*it)->index());
}
}
else if (line == "coordsInternalFlags") {
QList<Avogadro::Atom*> atoms = structure->atoms();
QList<Avogadro::Atom*>::const_iterator it;
const Eigen::Vector3d *vec;
int optIndex = -1;
QHash<int, int> *lut = structure->getOptimizerLookupTable();
lut->clear();
for (it = atoms.begin();
it != atoms.end();
it++) {
rep += QString(OpenBabel::etab.GetSymbol((*it)->atomicNumber()))+ " ";
vec = (*it)->pos();
rep += QString::number(vec->x()) + " 1 ";
rep += QString::number(vec->y()) + " 1 ";
rep += QString::number(vec->z()) + " 1\n";
lut->insert(++optIndex, (*it)->index());
}
}
else if (line == "coordsSuffixFlags") {
QList<Avogadro::Atom*> atoms = structure->atoms();
QList<Avogadro::Atom*>::const_iterator it;
const Eigen::Vector3d *vec;
int optIndex = -1;
QHash<int, int> *lut = structure->getOptimizerLookupTable();
lut->clear();
for (it = atoms.begin();
it != atoms.end();
it++) {
rep += QString(OpenBabel::etab.GetSymbol((*it)->atomicNumber()))+ " ";
vec = (*it)->pos();
rep += QString::number(vec->x()) + " ";
rep += QString::number(vec->y()) + " ";
rep += QString::number(vec->z()) + " 1 1 1\n";
lut->insert(++optIndex, (*it)->index());
}
}
else if (line == "coordsId") {
QList<Avogadro::Atom*> atoms = structure->atoms();
QList<Avogadro::Atom*>::const_iterator it;
const Eigen::Vector3d *vec;
int optIndex = -1;
QHash<int, int> *lut = structure->getOptimizerLookupTable();
lut->clear();
for (it = atoms.begin();
it != atoms.end();
it++) {
rep += QString(OpenBabel::etab.GetSymbol((*it)->atomicNumber()))+ " ";
rep += QString::number((*it)->atomicNumber()) + " ";
vec = (*it)->pos();
rep += QString::number(vec->x()) + " ";
rep += QString::number(vec->y()) + " ";
rep += QString::number(vec->z()) + "\n";
lut->insert(++optIndex, (*it)->index());
}
}
else if (line == "numAtoms") rep += QString::number(structure->numAtoms());
else if (line == "numSpecies") rep += QString::number(structure->getSymbols().size());
else if (line == "filename") rep += structure->fileName();
else if (line == "rempath") rep += structure->getRempath();
else if (line == "gen") rep += QString::number(structure->getGeneration());
else if (line == "id") rep += QString::number(structure->getIDNumber());
else if (line == "incar") rep += QString::number(structure->getCurrentOptStep());
else if (line == "optStep") rep += QString::number(structure->getCurrentOptStep());
if (!rep.isEmpty()) {
// Remove any trailing newlines
rep = rep.replace(QRegExp("\n$"), "");
line = rep;
}
}
void HistoryManager::load()
{
loadSettings();
QFile historyFile(QDesktopServices::storageLocation(QDesktopServices::DataLocation)
+ QLatin1String("/history"));
if (!historyFile.exists())
return;
if (!historyFile.open(QFile::ReadOnly)) {
qWarning() << "Unable to open history file" << historyFile.fileName();
return;
}
QList<HistoryEntry> list;
QDataStream in(&historyFile);
// Double check that the history file is sorted as it is read in
bool needToSort = false;
HistoryEntry lastInsertedItem;
QByteArray data;
QDataStream stream;
QBuffer buffer;
QString string;
stream.setDevice(&buffer);
while (!historyFile.atEnd()) {
in >> data;
buffer.close();
buffer.setBuffer(&data);
buffer.open(QIODevice::ReadOnly);
quint32 ver;
stream >> ver;
if (ver != HISTORY_VERSION)
continue;
HistoryEntry item;
stream >> string;
item.url = atomicString(string);
stream >> item.dateTime;
stream >> string;
item.title = atomicString(string);
if (!item.dateTime.isValid())
continue;
if (item == lastInsertedItem) {
if (lastInsertedItem.title.isEmpty() && !list.isEmpty())
list[0].title = item.title;
continue;
}
if (!needToSort && !list.isEmpty() && lastInsertedItem < item)
needToSort = true;
list.prepend(item);
lastInsertedItem = item;
}
if (needToSort)
qSort(list.begin(), list.end());
setHistory(list, true);
// If we had to sort re-write the whole history sorted
if (needToSort) {
m_lastSavedUrl.clear();
m_saveTimer->changeOccurred();
}
}
qf::core::utils::TreeTable RelaysPlugin::nlegsResultsTable(int class_id, int leg_count, int places, bool exclude_not_finish)
{
int max_leg = 0;
qfs::Query q;
{
qfs::QueryBuilder qb;
qb.select("relayLegCount")
.from("classdefs")
.where("classId=" QF_IARG(class_id));
q.execThrow(qb.toString());
if(q.next())
max_leg = q.value(0).toInt();
}
if(max_leg == 0) {
qfError() << "Leg count not defined for class id:" << class_id;
return qf::core::utils::TreeTable();
}
if(leg_count > max_leg)
leg_count = max_leg;
QList<Relay> relays;
//QStringList relay_ids;
{
qfs::QueryBuilder qb;
qb.select2("relays", "id, club, name, number")
.select2("clubs", "name")
.from("relays")
.join("relays.club", "clubs.abbr")
.where("relays.classId=" QF_IARG(class_id));
q.execThrow(qb.toString());
while(q.next()) {
Relay r;
r.relayId = q.value("relays.id").toInt();
r.name = (q.value("relays.number").toString()
+ ' ' + q.value("relays.club").toString()
+ ' ' + q.value("relays.name").toString()
+ ' ' + q.value("clubs.name").toString()).trimmed();
for (int i = 0; i < leg_count; ++i)
r.legs << Leg();
relays << r;
//relay_ids << QString::number(r.relayId);
}
}
{
qfs::QueryBuilder qb;
qb.select2("competitors", "id, registration")
.select2("runs", "id, relayId, leg")
.select("COALESCE(competitors.lastName, '') || ' ' || COALESCE(competitors.firstName, '') AS competitorName")
.from("runs")
.join("runs.competitorId", "competitors.id")
.joinRestricted("runs.relayId", "relays.id", "relays.classId=" QF_IARG(class_id), qfs::QueryBuilder::INNER_JOIN)
//.where("runs.relayId IN (" + relay_ids.join(',') + ")")
.where("runs.leg>0 AND runs.leg<=" + QString::number(leg_count))
.orderBy("runs.relayId, runs.leg");
q.execThrow(qb.toString());
while(q.next()) {
int relay_id = q.value("runs.relayId").toInt();
for (int i = 0; i < relays.count(); ++i) {
if(relays[i].relayId == relay_id) {
Relay &relay = relays[i];
int legno = q.value("runs.leg").toInt();
Leg &leg = relay.legs[legno - 1];
leg.name = q.value("competitorName").toString();
leg.runId = q.value("runs.id").toInt();
leg.reg = q.value("competitors.registration").toString();
break;
}
}
}
}
for (int legno = 1; legno <= leg_count; ++legno) {
qfs::QueryBuilder qb;
qb.select2("runs", "id, relayId, timeMs, disqualified")
.from("runs")
.joinRestricted("runs.relayId", "relays.id",
"relays.classId=" QF_IARG(class_id)
" AND runs.leg=" QF_IARG(legno)
" AND runs.isRunning"
" AND NOT runs.notCompeting"
" AND runs.finishTimeMs>0"
, qfs::QueryBuilder::INNER_JOIN)
.orderBy("runs.disqualified, runs.timeMs");
q.execThrow(qb.toString());
int run_pos = 1;
while(q.next()) {
int relay_id = q.value("runs.relayId").toInt();
for (int i = 0; i < relays.count(); ++i) {
if(relays[i].relayId == relay_id) {
int run_id = q.value("runs.id").toInt();
Relay &relay = relays[i];
Leg &leg = relay.legs[legno - 1];
if(leg.runId != run_id) {
qfError() << "internal error, leg:" << legno << "runId check:" << leg.runId << "should equal" << run_id;
}
else {
leg.notfinish = false;
leg.disq = q.value("runs.disqualified").toBool();
leg.time = q.value("timeMs").toInt();
leg.pos = leg.disq? 0: run_pos;
run_pos++;
}
break;
}
}
}
}
/// compute overal legs positions
for (int legno = 1; legno <= leg_count; ++legno) {
QList<QPair<int, int>> relay_stime;
for (int i = 0; i < relays.count(); ++i) {
Relay &relay = relays[i];
Leg &leg = relay.legs[legno - 1];
if(!leg.notfinish && !leg.disq) {
if(legno == 1)
leg.stime = leg.time;
else if(relay.legs[legno-2].stime > 0)
leg.stime = leg.time + relay.legs[legno-2].stime;
}
if(leg.stime > 0)
relay_stime << QPair<int, int>(relay.relayId, leg.stime);
}
std::sort(relay_stime.begin(), relay_stime.end(), [](const QPair<int, int> &a, const QPair<int, int> &b) {return a.second < b.second;});
int pos = 0;
for(const QPair<int, int> &p : relay_stime) {
int relay_id = p.first;
for (int i = 0; i < relays.count(); ++i) {
if(relays[i].relayId == relay_id) {
Relay &relay = relays[i];
Leg &leg = relay.legs[legno - 1];
leg.spos = ++pos;
break;
}
}
}
}
if(exclude_not_finish) {
/*
relays.erase(std::remove_if(relays.begin(),
relays.end(),
[](const Relay &r){return r.time(leg_count) == TIME_NOT_FINISH;}),
relays.end());
*/
QMutableListIterator<Relay> i(relays);
while (i.hasNext()) {
const Relay &r = i.next();
if(r.time(leg_count) == qog::TimeMs::NOT_FINISH_TIME_MSEC)
i.remove();
}
}
/// sort relays
std::sort(relays.begin(), relays.end(), [leg_count](const Relay &a, const Relay &b) {
return a.time(leg_count) < b.time(leg_count);
});
int time0 = 0;
qf::core::utils::TreeTable tt;
tt.appendColumn("pos", QVariant::Int);
tt.appendColumn("name", QVariant::String);
tt.appendColumn("time", QVariant::Int);
tt.appendColumn("loss", QVariant::Int);
for (int i = 0; i < qMin(relays.count(), places); ++i) {
qf::core::utils::TreeTableRow rr = tt.appendRow();
Relay &relay = relays[i];
int time = relay.time(leg_count);
if(i == 0)
time0 = time;
int prev_time = (i > 0)? relays[i-1].time(leg_count): 0;
rr.setValue("pos", (time <= qog::TimeMs::MAX_REAL_TIME_MSEC && time > prev_time)? i+1: 0);
rr.setValue("name", relay.name);
rr.setValue("time", time);
rr.setValue("loss", (time <= qog::TimeMs::MAX_REAL_TIME_MSEC)?time - time0: 0);
qf::core::utils::TreeTable tt2;
tt.appendColumn("name", QVariant::String);
tt.appendColumn("reg", QVariant::String);
tt.appendColumn("time", QVariant::Int);
tt.appendColumn("pos", QVariant::Int);
tt.appendColumn("stime", QVariant::Int);
tt.appendColumn("spos", QVariant::Int);
//tt.appendColumn("disq", QVariant::Bool);
for (int j = 0; j < relay.legs.count(); ++j) {
Leg &leg = relay.legs[j];
qf::core::utils::TreeTableRow rr2 = tt2.appendRow();
rr2.setValue("competitorName", leg.name);
rr2.setValue("registration", leg.reg);
rr2.setValue("time",
leg.disq? qog::TimeMs::DISQ_TIME_MSEC
: (leg.time == 0)? qog::TimeMs::NOT_FINISH_TIME_MSEC
: leg.time);
rr2.setValue("pos", leg.pos);
rr2.setValue("stime", leg.stime);
rr2.setValue("spos", leg.spos);
//rr2.setValue("disq", leg.disq);
}
rr.appendTable(tt2);
}
//qfInfo() << tt.toString();
return tt;
}
void QgsSingleBandPseudoColorRendererWidget::on_mClassifyButton_clicked()
{
int bandComboIndex = mBandComboBox->currentIndex();
if ( bandComboIndex == -1 || !mRasterLayer )
{
return;
}
//int bandNr = mBandComboBox->itemData( bandComboIndex ).toInt();
//QgsRasterBandStats myRasterBandStats = mRasterLayer->dataProvider()->bandStatistics( bandNr );
int numberOfEntries;
QgsColorRampShader::ColorRamp_TYPE interpolation = static_cast< QgsColorRampShader::ColorRamp_TYPE >( mColorInterpolationComboBox->itemData( mColorInterpolationComboBox->currentIndex() ).toInt() );
bool discrete = interpolation == QgsColorRampShader::DISCRETE;
QList<double> entryValues;
QVector<QColor> entryColors;
double min = lineEditValue( mMinLineEdit );
double max = lineEditValue( mMaxLineEdit );
QScopedPointer< QgsVectorColorRampV2 > colorRamp( mColorRampComboBox->currentColorRamp() );
if ( mClassificationModeComboBox->itemData( mClassificationModeComboBox->currentIndex() ).toInt() == Continuous )
{
if ( colorRamp.data() )
{
numberOfEntries = colorRamp->count();
entryValues.reserve( numberOfEntries );
if ( discrete )
{
double intervalDiff = max - min;
// remove last class when ColorRamp is gradient and discrete, as they are implemented with an extra stop
QgsVectorGradientColorRampV2* colorGradientRamp = dynamic_cast<QgsVectorGradientColorRampV2*>( colorRamp.data() );
if ( colorGradientRamp != NULL && colorGradientRamp->isDiscrete() )
{
numberOfEntries--;
}
else
{
// if color ramp is continuous scale values to get equally distributed classes.
// Doesn't work perfectly when stops are non equally distributed.
intervalDiff *= ( numberOfEntries - 1 ) / ( double )numberOfEntries;
}
// skip first value (always 0.0)
for ( int i = 1; i < numberOfEntries; ++i )
{
double value = colorRamp->value( i );
entryValues.push_back( min + value * intervalDiff );
}
entryValues.push_back( std::numeric_limits<double>::infinity() );
}
else
{
for ( int i = 0; i < numberOfEntries; ++i )
{
double value = colorRamp->value( i );
entryValues.push_back( min + value * ( max - min ) );
}
}
// for continuous mode take original color map colors
for ( int i = 0; i < numberOfEntries; ++i )
{
entryColors.push_back( colorRamp->color( colorRamp->value( i ) ) );
}
}
}
else // for other classification modes interpolate colors linearly
{
numberOfEntries = mNumberOfEntriesSpinBox->value();
if ( numberOfEntries < 2 )
return; // < 2 classes is not useful, shouldn't happen, but if it happens save it from crashing
if ( mClassificationModeComboBox->itemData( mClassificationModeComboBox->currentIndex() ).toInt() == Quantile )
{ // Quantile
int bandNr = mBandComboBox->itemData( bandComboIndex ).toInt();
//QgsRasterHistogram rasterHistogram = mRasterLayer->dataProvider()->histogram( bandNr );
double cut1 = std::numeric_limits<double>::quiet_NaN();
double cut2 = std::numeric_limits<double>::quiet_NaN();
QgsRectangle extent = mMinMaxWidget->extent();
int sampleSize = mMinMaxWidget->sampleSize();
// set min and max from histogram, used later to calculate number of decimals to display
mRasterLayer->dataProvider()->cumulativeCut( bandNr, 0.0, 1.0, min, max, extent, sampleSize );
entryValues.reserve( numberOfEntries );
if ( discrete )
{
double intervalDiff = 1.0 / ( numberOfEntries );
for ( int i = 1; i < numberOfEntries; ++i )
{
mRasterLayer->dataProvider()->cumulativeCut( bandNr, 0.0, i * intervalDiff, cut1, cut2, extent, sampleSize );
entryValues.push_back( cut2 );
}
entryValues.push_back( std::numeric_limits<double>::infinity() );
}
else
{
double intervalDiff = 1.0 / ( numberOfEntries - 1 );
for ( int i = 0; i < numberOfEntries; ++i )
{
mRasterLayer->dataProvider()->cumulativeCut( bandNr, 0.0, i * intervalDiff, cut1, cut2, extent, sampleSize );
entryValues.push_back( cut2 );
}
}
}
else // EqualInterval
{
entryValues.reserve( numberOfEntries );
if ( discrete )
{
// in discrete mode the lowest value is not an entry and the highest
// value is inf, there are ( numberOfEntries ) of which the first
// and last are not used.
double intervalDiff = ( max - min ) / ( numberOfEntries );
for ( int i = 1; i < numberOfEntries; ++i )
{
entryValues.push_back( min + i * intervalDiff );
}
entryValues.push_back( std::numeric_limits<double>::infinity() );
}
else
{
//because the highest value is also an entry, there are (numberOfEntries - 1) intervals
double intervalDiff = ( max - min ) / ( numberOfEntries - 1 );
for ( int i = 0; i < numberOfEntries; ++i )
{
entryValues.push_back( min + i * intervalDiff );
}
}
}
if ( !colorRamp.data() )
{
//hard code color range from blue -> red (previous default)
int colorDiff = 0;
if ( numberOfEntries != 0 )
{
colorDiff = ( int )( 255 / numberOfEntries );
}
entryColors.reserve( numberOfEntries );
for ( int i = 0; i < numberOfEntries; ++i )
{
QColor currentColor;
int idx = mInvertCheckBox->isChecked() ? numberOfEntries - i - 1 : i;
currentColor.setRgb( colorDiff*idx, 0, 255 - colorDiff * idx );
entryColors.push_back( currentColor );
}
}
else
{
entryColors.reserve( numberOfEntries );
for ( int i = 0; i < numberOfEntries; ++i )
{
int idx = mInvertCheckBox->isChecked() ? numberOfEntries - i - 1 : i;
entryColors.push_back( colorRamp->color((( double ) idx ) / ( numberOfEntries - 1 ) ) );
}
}
}
mColormapTreeWidget->clear();
QList<double>::const_iterator value_it = entryValues.begin();
QVector<QColor>::const_iterator color_it = entryColors.begin();
// calculate a reasonable number of decimals to display
double maxabs = log10( qMax( qAbs( max ), qAbs( min ) ) );
int nDecimals = qRound( qMax( 3.0 + maxabs - log10( max - min ), maxabs <= 15.0 ? maxabs + 0.49 : 0.0 ) );
for ( ; value_it != entryValues.end(); ++value_it, ++color_it )
{
QgsTreeWidgetItem* newItem = new QgsTreeWidgetItem( mColormapTreeWidget );
newItem->setText( ValueColumn, QString::number( *value_it, 'g', nDecimals ) );
newItem->setBackground( ColorColumn, QBrush( *color_it ) );
newItem->setText( LabelColumn, QString() );
newItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable );
connect( newItem, SIGNAL( itemEdited( QTreeWidgetItem*, int ) ),
this, SLOT( mColormapTreeWidget_itemEdited( QTreeWidgetItem*, int ) ) );
}
autoLabel();
emit widgetChanged();
}
void LogScene::createBackground() {
QBrush brush(QColor("white"));
QPen pen(QColor("white"));
// Background color
QList<QGraphicsView*> views = this->views();
int maxWidth = 0;
double minuteSize = (double)BLOCKSIZE / (double)60;
int maxHeight = minuteSize * 25 * 60;
for (QList<QGraphicsView*>::iterator iter = views.begin(); iter != views.end(); iter++) {
QGraphicsView* view = *iter;
// int viewHeight = view->height();
int viewWidth = view->width();
// if (viewHeight > maxHeight) {
// maxHeight = viewHeight;
// }
if (viewWidth > maxWidth) {
maxWidth = viewWidth;
}
}
// if (_viewSizeHeight > maxHeight) {
// maxHeight = _viewSizeHeight;
// }
if (_viewSizeWidth > maxWidth) {
maxWidth = _viewSizeWidth;
}
_viewSizeHeight = BLOCKSIZE*25;
_viewSizeWidth = maxWidth;
this->addRect(0, 0, maxWidth, maxHeight, pen, brush);
// int columnSize = geometry().width() / NU_COLS;
int textSize = 30;
int margin = 15;
int cols = _totalDays;
if ((cols * dayWidth()) < maxWidth) {
cols = (maxWidth / dayWidth()) + 10;
_totalDays = cols;
}
DateTime startDate = this->_startDate;
DateTime today;
today.setHour(0);
today.setMin(0);
today.setSecs(0);
for (int x = 0; x < (cols + 1); x++) {
QColor barcolor;
if ((x % 2) > 0) {
barcolor = QColor("white");
} else {
barcolor = QColor(240, 240, 240);
}
QBrush brushBar(barcolor);
QPen penBar(barcolor);
int left = (x* dayWidth()) + 0;
int top = 0;
int heigth = maxHeight;
addRect(left, top, dayWidth(), heigth, penBar, brushBar);
QPen pen(QColor(200, 200, 200));
pen.setStyle(Qt::DashLine);
addLine(x*dayWidth(), 0 , x*dayWidth(), heigth, pen);
if (startDate == today) {
barcolor = QColor(230, 230, 250);
addRect(left, top, dayWidth(), heigth, penBar, QBrush(barcolor));
}
startDate = startDate.addDays(1);
}
}
/**
* This method is called several times, one by received entries. The entries are inserted into the model.
* The given entries are sorted by their level, we will keep the sort when inserting the entry but with some modifications :
* - The directories are put first.
* - All entries with the same level are sorted first by their path (prefixed with the shared directory name) and then by their name.
* - All file entries with the same chunks (identical data) are grouped. They can be owned by different peer.
*/
void SearchModel::result(const Protos::Common::FindResult& findResult)
{
if (findResult.entry_size() == 0)
return;
QList<const Protos::Common::FindResult_EntryLevel*> sortedEntries;
for (int i = 0; i < findResult.entry_size(); i++)
sortedEntries << &findResult.entry(i);
qSort(sortedEntries.begin(), sortedEntries.end(), &findEntryLessThan);
int currentIndex = 0;
bool maxLevelChange = false;
for (QListIterator<const Protos::Common::FindResult_EntryLevel*> i(sortedEntries); i.hasNext();)
{
const Protos::Common::FindResult_EntryLevel* entry = i.next();
if (this->setMaxLevel(entry->level()))
maxLevelChange = true;
// Search if a similar entry already exists. If so then insert the new tree as child.
if (entry->entry().type() == Protos::Common::Entry_Type_FILE && entry->entry().chunk_size() > 0)
{
Common::Hash firstChunk = entry->entry().chunk(0).hash();
SearchTree* similarTree = 0;
if ((similarTree = this->indexedFile.value(firstChunk)) && similarTree->isSameAs(entry->entry()))
{
if (similarTree->getNbChildren() == 0)
{
this->beginInsertRows(this->createIndex(0, 0, similarTree), 0, 0);
similarTree->insertChild(similarTree);
this->endInsertRows();
}
// Search the better name (tree with the lowest level) to display it on the top.
for (int i = 0; i <= similarTree->getNbChildren(); i++)
{
if (i == similarTree->getNbChildren() || static_cast<SearchTree*>(similarTree->getChild(i))->getLevel() > static_cast<int>(entry->level()))
{
this->beginInsertRows(this->createIndex(0, 0, similarTree), i, i);
Common::Hash peerID = findResult.peer_id().hash();
SearchTree* newTree = similarTree->insertChild(i, *entry, peerID, this->peerListModel.getNick(peerID, tr("<unknown>")));
this->endInsertRows();
if (static_cast<int>(entry->level()) < similarTree->getLevel())
{
const int row = similarTree->getOwnPosition();
similarTree->copyFrom(newTree);
emit dataChanged(this->createIndex(row, 0, similarTree), this->createIndex(row, 3, similarTree));
}
break;
}
}
continue;
}
}
currentIndex = this->insertTree(*entry, findResult.peer_id().hash(), currentIndex);
}
if (maxLevelChange && this->rowCount() > 0)
emit dataChanged(this->createIndex(0, 2), this->createIndex(this->rowCount() - 1, 2));
}
void QgsGraduatedSymbolRendererV2::updateClasses( QgsVectorLayer *vlayer, Mode mode, int nclasses )
{
if ( mAttrName.isEmpty() )
return;
setMode( mode );
// Custom classes are not recalculated
if ( mode == Custom )
return;
if ( nclasses < 1 )
nclasses = 1;
QList<double> values;
bool valuesLoaded = false;
double minimum;
double maximum;
int attrNum = vlayer->fieldNameIndex( mAttrName );
if ( attrNum == -1 )
{
values = getDataValues( vlayer );
if ( values.isEmpty() )
return;
qSort( values );
minimum = values.first();
maximum = values.last();
valuesLoaded = true;
}
else
{
minimum = vlayer->minimumValue( attrNum ).toDouble();
maximum = vlayer->maximumValue( attrNum ).toDouble();
}
QgsDebugMsg( QString( "min %1 // max %2" ).arg( minimum ).arg( maximum ) );
QList<double> breaks;
QList<double> labels;
if ( mode == EqualInterval )
{
breaks = _calcEqualIntervalBreaks( minimum, maximum, nclasses );
}
else if ( mode == Pretty )
{
breaks = _calcPrettyBreaks( minimum, maximum, nclasses );
}
else if ( mode == Quantile || mode == Jenks || mode == StdDev )
{
// get values from layer
if ( !valuesLoaded )
{
values = getDataValues( vlayer );
}
// calculate the breaks
if ( mode == Quantile )
{
breaks = _calcQuantileBreaks( values, nclasses );
}
else if ( mode == Jenks )
{
breaks = _calcJenksBreaks( values, nclasses, minimum, maximum );
}
else if ( mode == StdDev )
{
breaks = _calcStdDevBreaks( values, nclasses, labels );
}
}
else
{
Q_ASSERT( false );
}
double lower, upper = minimum;
QString label;
deleteAllClasses();
// "breaks" list contains all values at class breaks plus maximum as last break
int i = 0;
for ( QList<double>::iterator it = breaks.begin(); it != breaks.end(); ++it, ++i )
{
lower = upper; // upper border from last interval
upper = *it;
// Label - either StdDev label or default label for a range
if ( mode == StdDev )
{
if ( i == 0 )
{
label = "< " + QString::number( labels[i], 'f', 2 ) + " Std Dev";
}
else if ( i == labels.count() - 1 )
{
label = ">= " + QString::number( labels[i-1], 'f', 2 ) + " Std Dev";
}
else
{
label = QString::number( labels[i-1], 'f', 2 ) + " Std Dev" + " - " + QString::number( labels[i], 'f', 2 ) + " Std Dev";
}
}
else
{
label = mLabelFormat.labelForRange( lower, upper );
}
QgsSymbolV2* newSymbol = mSourceSymbol ? mSourceSymbol->clone() : QgsSymbolV2::defaultSymbol( vlayer->geometryType() );
addClass( QgsRendererRangeV2( lower, upper, newSymbol, label ) );
}
updateColorRamp( 0, mInvertedColorRamp );
}
/* Update our model of the wallet incrementally, to synchronize our model of the wallet
with that of the core.
Call with transaction that was added, removed or changed.
*/
void updateWallet(const uint256 &hash, int status)
{
OutputDebugStringF("updateWallet %s %i\n", hash.ToString().c_str(), status);
{
LOCK(wallet->cs_wallet);
// Find transaction in wallet
std::map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(hash);
bool inWallet = mi != wallet->mapWallet.end();
// Find bounds of this transaction in model
QList<TransactionRecord>::iterator lower = qLowerBound(
cachedWallet.begin(), cachedWallet.end(), hash, TxLessThan());
QList<TransactionRecord>::iterator upper = qUpperBound(
cachedWallet.begin(), cachedWallet.end(), hash, TxLessThan());
int lowerIndex = (lower - cachedWallet.begin());
int upperIndex = (upper - cachedWallet.begin());
bool inModel = (lower != upper);
// Determine whether to show transaction or not
bool showTransaction = (inWallet && TransactionRecord::showTransaction(mi->second));
if(status == CT_UPDATED)
{
if(showTransaction && !inModel)
status = CT_NEW; /* Not in model, but want to show, treat as new */
if(!showTransaction && inModel)
status = CT_DELETED; /* In model, but want to hide, treat as deleted */
}
OutputDebugStringF(" inWallet=%i inModel=%i Index=%i-%i showTransaction=%i derivedStatus=%i\n",
inWallet, inModel, lowerIndex, upperIndex, showTransaction, status);
switch(status)
{
case CT_NEW:
if(inModel)
{
OutputDebugStringF("Warning: updateWallet: Got CT_NEW, but transaction is already in model\n");
break;
}
if(!inWallet)
{
OutputDebugStringF("Warning: updateWallet: Got CT_NEW, but transaction is not in wallet\n");
break;
}
if(showTransaction)
{
// Added -- insert at the right position
QList<TransactionRecord> toInsert =
TransactionRecord::decomposeTransaction(wallet, mi->second);
if(!toInsert.isEmpty()) /* only if something to insert */
{
parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex+toInsert.size()-1);
int insert_idx = lowerIndex;
foreach(const TransactionRecord &rec, toInsert)
{
cachedWallet.insert(insert_idx, rec);
insert_idx += 1;
}
parent->endInsertRows();
}
}
break;
case CT_DELETED:
if(!inModel)
{
OutputDebugStringF("Warning: updateWallet: Got CT_DELETED, but transaction is not in model\n");
break;
}
// Removed -- remove entire transaction from table
parent->beginRemoveRows(QModelIndex(), lowerIndex, upperIndex-1);
cachedWallet.erase(lower, upper);
parent->endRemoveRows();
break;
case CT_UPDATED:
// Miscellaneous updates -- nothing to do, status update will take care of this, and is only computed for
// visible transactions.
break;
}
void DlgRevolution::accept()
{
if (!this->validate())
return;
Gui::WaitCursor wc;
App::Document* activeDoc = App::GetApplication().getActiveDocument();
activeDoc->openTransaction("Revolve");
try{
QString shape, type, name, solid;
QList<QTreeWidgetItem *> items = ui->treeWidget->selectedItems();
if (ui->checkSolid->isChecked()) {
solid = QString::fromLatin1("True");}
else {
solid = QString::fromLatin1("False");}
App::PropertyLinkSub axisLink;
this->getAxisLink(axisLink);
QString strAxisLink;
if (axisLink.getValue()){
strAxisLink = QString::fromLatin1("(App.ActiveDocument.%1, %2)")
.arg(QString::fromLatin1(axisLink.getValue()->getNameInDocument()))
.arg(axisLink.getSubValues().size() == 1 ?
QString::fromLatin1("\"%1\"").arg(QString::fromLatin1(axisLink.getSubValues()[0].c_str()))
: QString() );
} else {
strAxisLink = QString::fromLatin1("None");
}
QString symmetric;
if (ui->checkSymmetric->isChecked()) {
symmetric = QString::fromLatin1("True");}
else {
symmetric = QString::fromLatin1("False");}
for (QList<QTreeWidgetItem *>::iterator it = items.begin(); it != items.end(); ++it) {
shape = (*it)->data(0, Qt::UserRole).toString();
type = QString::fromLatin1("Part::Revolution");
name = QString::fromLatin1(activeDoc->getUniqueObjectName("Revolve").c_str());
Base::Vector3d axis = this->getDirection();
Base::Vector3d pos = this->getPosition();
QString code = QString::fromLatin1(
"FreeCAD.ActiveDocument.addObject(\"%1\",\"%2\")\n"
"FreeCAD.ActiveDocument.%2.Source = FreeCAD.ActiveDocument.%3\n"
"FreeCAD.ActiveDocument.%2.Axis = (%4,%5,%6)\n"
"FreeCAD.ActiveDocument.%2.Base = (%7,%8,%9)\n"
"FreeCAD.ActiveDocument.%2.Angle = %10\n"
"FreeCAD.ActiveDocument.%2.Solid = %11\n"
"FreeCAD.ActiveDocument.%2.AxisLink = %12\n"
"FreeCAD.ActiveDocument.%2.Symmetric = %13\n"
"FreeCADGui.ActiveDocument.%3.Visibility = False\n")
.arg(type).arg(name).arg(shape) //%1, 2, 3
.arg(axis.x,0,'f',15) //%4
.arg(axis.y,0,'f',15) //%5
.arg(axis.z,0,'f',15) //%6
.arg(pos.x, 0,'f',15) //%7
.arg(pos.y, 0,'f',15) //%8
.arg(pos.z, 0,'f',15) //%9
.arg(getAngle(),0,'f',15) //%10
.arg(solid) //%11
.arg(strAxisLink) //%12
.arg(symmetric) //13
;
Gui::Command::runCommand(Gui::Command::App, code.toLatin1());
QByteArray to = name.toLatin1();
QByteArray from = shape.toLatin1();
Gui::Command::copyVisual(to, "ShapeColor", from);
Gui::Command::copyVisual(to, "LineColor", from);
Gui::Command::copyVisual(to, "PointColor", from);
}
activeDoc->commitTransaction();
activeDoc->recompute();
} catch (Base::Exception &err) {
QMessageBox::critical(this, windowTitle(),
tr("Creating Revolve failed.\n\n%1").arg(QString::fromUtf8(err.what())));
return;
} catch (...){
QMessageBox::critical(this, windowTitle(),
tr("Creating Revolve failed.\n\n%1").arg(QString::fromUtf8("Unknown error")));
return;
}
QDialog::accept();
}
void old_tesselate_polygon(QVector<XTrapezoid> *traps, const QPointF *pg, int pgSize,
bool winding)
{
QVector<QEdge> edges;
edges.reserve(128);
qreal ymin(INT_MAX/256);
qreal ymax(INT_MIN/256);
//painter.begin(pg, pgSize);
Q_ASSERT(pg[0] == pg[pgSize-1]);
// generate edge table
// qDebug() << "POINTS:";
for (int x = 0; x < pgSize-1; ++x) {
QEdge edge;
QPointF p1(Q27Dot5ToDouble(FloatToQ27Dot5(pg[x].x())),
Q27Dot5ToDouble(FloatToQ27Dot5(pg[x].y())));
QPointF p2(Q27Dot5ToDouble(FloatToQ27Dot5(pg[x+1].x())),
Q27Dot5ToDouble(FloatToQ27Dot5(pg[x+1].y())));
// qDebug() << " "
// << p1;
edge.winding = p1.y() > p2.y() ? 1 : -1;
if (edge.winding > 0)
qSwap(p1, p2);
edge.p1.x = XDoubleToFixed(p1.x());
edge.p1.y = XDoubleToFixed(p1.y());
edge.p2.x = XDoubleToFixed(p2.x());
edge.p2.y = XDoubleToFixed(p2.y());
edge.m = (p1.y() - p2.y()) / (p1.x() - p2.x()); // line derivative
edge.b = p1.y() - edge.m * p1.x(); // intersection with y axis
edge.m = edge.m != 0.0 ? 1.0 / edge.m : 0.0; // inverted derivative
edges.append(edge);
ymin = qMin(ymin, qreal(XFixedToDouble(edge.p1.y)));
ymax = qMax(ymax, qreal(XFixedToDouble(edge.p2.y)));
}
QList<const QEdge *> et; // edge list
for (int i = 0; i < edges.size(); ++i)
et.append(&edges.at(i));
// sort edge table by min y value
qSort(et.begin(), et.end(), compareEdges);
// eliminate shared edges
for (int i = 0; i < et.size(); ++i) {
for (int k = i+1; k < et.size(); ++k) {
const QEdge *edgeI = et.at(i);
const QEdge *edgeK = et.at(k);
if (edgeK->p1.y > edgeI->p1.y)
break;
if (edgeI->winding != edgeK->winding &&
isEqual(edgeI->p1, edgeK->p1) && isEqual(edgeI->p2, edgeK->p2)
) {
et.removeAt(k);
et.removeAt(i);
--i;
break;
}
}
}
if (ymax <= ymin)
return;
QList<const QEdge *> aet; // edges that intersects the current scanline
// if (ymin < 0)
// ymin = 0;
// if (paintEventClipRegion) // don't scan more lines than we have to
// ymax = paintEventClipRegion->boundingRect().height();
#ifdef QT_DEBUG_TESSELATOR
qDebug("==> ymin = %f, ymax = %f", ymin, ymax);
#endif // QT_DEBUG_TESSELATOR
currentY = ymin; // used by the less than op
for (qreal y = ymin; y < ymax;) {
// fill active edge table with edges that intersect the current line
for (int i = 0; i < et.size(); ++i) {
const QEdge *edge = et.at(i);
if (edge->p1.y > XDoubleToFixed(y))
break;
aet.append(edge);
et.removeAt(i);
--i;
}
// remove processed edges from active edge table
for (int i = 0; i < aet.size(); ++i) {
if (aet.at(i)->p2.y <= XDoubleToFixed(y)) {
aet.removeAt(i);
--i;
}
}
if (aet.size()%2 != 0) {
#ifndef QT_NO_DEBUG
qWarning("QX11PaintEngine: aet out of sync - this should not happen.");
#endif
return;
}
// done?
if (!aet.size()) {
if (!et.size()) {
break;
} else {
y = currentY = XFixedToDouble(et.at(0)->p1.y);
continue;
}
}
// calculate the next y where we have to start a new set of trapezoids
qreal next_y(INT_MAX/256);
for (int i = 0; i < aet.size(); ++i) {
const QEdge *edge = aet.at(i);
if (XFixedToDouble(edge->p2.y) < next_y)
next_y = XFixedToDouble(edge->p2.y);
}
if (et.size() && next_y > XFixedToDouble(et.at(0)->p1.y))
next_y = XFixedToDouble(et.at(0)->p1.y);
int aetSize = aet.size();
for (int i = 0; i < aetSize; ++i) {
for (int k = i+1; k < aetSize; ++k) {
const QEdge *edgeI = aet.at(i);
const QEdge *edgeK = aet.at(k);
qreal m1 = edgeI->m;
qreal b1 = edgeI->b;
qreal m2 = edgeK->m;
qreal b2 = edgeK->b;
if (qAbs(m1 - m2) < 0.001)
continue;
// ### intersect is not calculated correctly when optimized with -O2 (gcc)
volatile qreal intersect = 0;
if (!qIsFinite(b1))
intersect = (1.f / m2) * XFixedToDouble(edgeI->p1.x) + b2;
else if (!qIsFinite(b2))
intersect = (1.f / m1) * XFixedToDouble(edgeK->p1.x) + b1;
else
intersect = (b1*m1 - b2*m2) / (m1 - m2);
if (intersect > y && intersect < next_y)
next_y = intersect;
}
}
XFixed yf, next_yf;
yf = qrealToXFixed(y);
next_yf = qrealToXFixed(next_y);
if (yf == next_yf) {
y = currentY = next_y;
continue;
}
#ifdef QT_DEBUG_TESSELATOR
qDebug("###> y = %f, next_y = %f, %d active edges", y, next_y, aet.size());
qDebug("===> edges");
dump_edges(et);
qDebug("===> active edges");
dump_edges(aet);
#endif
// calc intersection points
QVarLengthArray<QIntersectionPoint> isects(aet.size()+1);
for (int i = 0; i < isects.size()-1; ++i) {
const QEdge *edge = aet.at(i);
isects[i].x = (edge->p1.x != edge->p2.x) ?
((y - edge->b)*edge->m) : XFixedToDouble(edge->p1.x);
isects[i].edge = edge;
}
Q_ASSERT(isects.size()%2 == 1);
// sort intersection points
qSort(&isects[0], &isects[isects.size()-1], compareIntersections);
// qDebug() << "INTERSECTION_POINTS:";
// for (int i = 0; i < isects.size(); ++i)
// qDebug() << isects[i].edge << isects[i].x;
if (winding) {
// winding fill rule
for (int i = 0; i < isects.size()-1;) {
int winding = 0;
const QEdge *left = isects[i].edge;
const QEdge *right = 0;
winding += isects[i].edge->winding;
for (++i; i < isects.size()-1 && winding != 0; ++i) {
winding += isects[i].edge->winding;
right = isects[i].edge;
}
if (!left || !right)
break;
//painter.addTrapezoid(&toXTrapezoid(yf, next_yf, *left, *right));
traps->append(toXTrapezoid(yf, next_yf, *left, *right));
}
} else {
// odd-even fill rule
for (int i = 0; i < isects.size()-2; i += 2) {
//painter.addTrapezoid(&toXTrapezoid(yf, next_yf, *isects[i].edge, *isects[i+1].edge));
traps->append(toXTrapezoid(yf, next_yf, *isects[i].edge, *isects[i+1].edge));
}
}
y = currentY = next_y;
}
#ifdef QT_DEBUG_TESSELATOR
qDebug("==> number of trapezoids: %d - edge table size: %d\n", traps->size(), et.size());
for (int i = 0; i < traps->size(); ++i)
dump_trap(traps->at(i));
#endif
// optimize by unifying trapezoids that share left/right lines
// and have a common top/bottom edge
// for (int i = 0; i < tps.size(); ++i) {
// for (int k = i+1; k < tps.size(); ++k) {
// if (i != k && tps.at(i).right == tps.at(k).right
// && tps.at(i).left == tps.at(k).left
// && (tps.at(i).top == tps.at(k).bottom
// || tps.at(i).bottom == tps.at(k).top))
// {
// tps[i].bottom = tps.at(k).bottom;
// tps.removeAt(k);
// i = 0;
// break;
// }
// }
// }
//static int i = 0;
//QImage img = painter.end();
//img.save(QString("res%1.png").arg(i++), "PNG");
}
/* Update our model of the wallet incrementally, to synchronize our model of the wallet
with that of the core.
Call with transaction that was added, removed or changed.
*/
void updateWallet(const std::string &hash, int status)
{
LOG_PRINT_L2("TransactionTablePriv::updateWallet : " << hash << " " << status);
{
LOG_PRINT_L4("LOCK2(cs_main, wallet->cs_wallet) updateWallet");
LOCK2(cs_main, wallet->cs_wallet);
LOG_PRINT_L4("LOCK2(cs_main, wallet->cs_wallet) updateWallet acquired");
// Find transaction in wallet
auto mi = wallet->mapWallet.find(GetCryptoHash(hash));
bool inWallet = mi != wallet->mapWallet.end();
// Find bounds of this transaction in model
QList<TransactionRecord>::iterator lower = qLowerBound(
cachedWallet.begin(), cachedWallet.end(), hash, TxLessThan());
QList<TransactionRecord>::iterator upper = qUpperBound(
cachedWallet.begin(), cachedWallet.end(), hash, TxLessThan());
int lowerIndex = (lower - cachedWallet.begin());
int upperIndex = (upper - cachedWallet.begin());
bool inModel = (lower != upper);
// Determine whether to show transaction or not
bool showTransaction = (inWallet && TransactionRecord::showTransaction(mi->second));
if(status == CT_UPDATED)
{
if(showTransaction && !inModel)
status = CT_NEW; /* Not in model, but want to show, treat as new */
if(!showTransaction && inModel)
status = CT_DELETED; /* In model, but want to hide, treat as deleted */
}
//qDebug() << " inWallet=" + QString::number(inWallet) + " inModel=" + QString::number(inModel) +
// " Index=" + QString::number(lowerIndex) + "-" + QString::number(upperIndex) +
// " showTransaction=" + QString::number(showTransaction) + " derivedStatus=" + QString::number(status);
switch(status)
{
case CT_NEW:
if(inModel)
{
LOG_PRINT_L1("TransactionTablePriv::updateWallet : Warning: Got CT_NEW, but transaction is already in model");
break;
}
if(!inWallet)
{
LOG_PRINT_L1("TransactionTablePriv::updateWallet : Warning: Got CT_NEW, but transaction is not in wallet");
break;
}
if(showTransaction)
{
// Added -- insert at the right position
QList<TransactionRecord> toInsert =
TransactionRecord::decomposeTransaction(wallet, mi->second);
if(!toInsert.isEmpty()) // only if something to insert
{
parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex+toInsert.size()-1);
int insert_idx = lowerIndex;
foreach(const TransactionRecord &rec, toInsert)
{
cachedWallet.insert(insert_idx, rec);
insert_idx += 1;
}
parent->endInsertRows();
}
}
break;
case CT_DELETED:
if(!inModel)
{
LOG_PRINT_L1("TransactionTablePriv::updateWallet : Warning: Got CT_DELETED, but transaction is not in model");
break;
}
// Removed -- remove entire transaction from table
parent->beginRemoveRows(QModelIndex(), lowerIndex, upperIndex-1);
cachedWallet.erase(lower, upper);
parent->endRemoveRows();
break;
case CT_UPDATED:
// Miscellaneous updates -- nothing to do, status update will take care of this, and is only computed for
// visible transactions.
break;
}
void CleverApplicationIconPresenterSortingDelegate::_sortTheseByFiltersImplementation(QList<IdBasedWidgetBase *> allItems, QString filterText, bool isOnlyAutostartOnes, bool isOnlyHiddenOnes, bool isAllowHiddenOnes, bool isAllowNotInstalledOnes, bool isCaseSensitive, bool isCompareWithoutSpaces)
{
WidgetListSnapshot resultItems;
QList<QWidget *> resultIconPresenterList;
QString normalizedFilterText = filterText;
if(!isCaseSensitive) {
normalizedFilterText = normalizedFilterText.toLower();
}
if(isCompareWithoutSpaces) {
normalizedFilterText = normalizedFilterText.replace(" ", "");
}
//
// first, filter the items
{
QList<IdBasedWidgetBase *>::const_iterator it = allItems.begin();
QList<IdBasedWidgetBase *>::const_iterator eit = allItems.end();
for( ; it != eit; ++it )
{
bool isAddCurrItemToResultList = false;
AppIconAndButtonPresenterWidget *castedIconPresenterWidget = dynamic_cast<AppIconAndButtonPresenterWidget *>( (*it) );
if(castedIconPresenterWidget == NULL) {
WLog("Cannot cast the widget to icon-presenter-widget. Cannot sort it.");
}
else {
QString currItem = castedIconPresenterWidget->getRelatedAppName();
if(isCompareWithoutSpaces) {
currItem = currItem.replace(" ", "");
}
if(!isCaseSensitive) {
currItem = currItem.toLower();
}
if(isMachesFilter(currItem, normalizedFilterText))
{
// maches the filter-text, filter by other filters
bool isHidden = castedIconPresenterWidget->getRelatedAppDescriptionModel().getDynamicDescription_ReadOnly()->getIsHidden();
if(!isHidden) {
isAddCurrItemToResultList = true;
} else if(isAllowHiddenOnes) {
isAddCurrItemToResultList = true;
}
if(isAddCurrItemToResultList) {
if(isOnlyHiddenOnes && !isHidden) {
isAddCurrItemToResultList = false;
}
}
if(isAddCurrItemToResultList) {
if(isOnlyAutostartOnes) {
bool isStartThisAppWhenClientStarts = castedIconPresenterWidget->getRelatedAppDescriptionModel().getDynamicDescription_ReadOnly()->getIsStartWhenClientStarts();
if(!isStartThisAppWhenClientStarts) {
isAddCurrItemToResultList = false;
}
}
}
if(isAddCurrItemToResultList) {
if(!isAllowNotInstalledOnes) {
AppWhirr::ApplicationGrabStates::ApplicationGrabStatesEnum currState = castedIconPresenterWidget->getRelatedAppDescriptionModel().getDynamicDescription_ReadOnly()->getAppState();
if((int)currState < (int)AppWhirr::ApplicationGrabStates::Installed) {
isAddCurrItemToResultList = false;
}
}
}
}
}
if(isAddCurrItemToResultList) {
resultIconPresenterList << *it;
}
}
}
//
// sort them
{
// QString filterMatchItem;
// SortingDatabaseManager *sortingDbManager = new SortingDatabaseManager;
// bool isSuccess = sortingDbManager->getValueForKey(filterText, filterMatchItem);
// delete sortingDbManager;
QString filterMatchItem = this->_filterKeyValueMap.value(filterText, QString());
// filter match test
if(!filterMatchItem.isEmpty())
{
// filter match found!!
qDebug("!! filter match found !!");
int idx = -1;
IdBasedWidgetBase *foundFilterMatchItem = NULL;
// search
{
int foundItemCnt = resultIconPresenterList.size();
for(int i = 0; i < foundItemCnt && idx == -1; i++) {
AppIconAndButtonPresenterWidget *castedItem = dynamic_cast<AppIconAndButtonPresenterWidget *>(resultIconPresenterList[i]);
if(castedItem != NULL &&
castedItem->getRelatedAppName() == filterMatchItem) {
idx = i;
foundFilterMatchItem = castedItem;
}
}
}
if(idx != -1)
{
// move to the front
resultIconPresenterList.removeAt(idx);
resultIconPresenterList.insert(0, foundFilterMatchItem);
}
}
}
// and Q_EMIT and update
resultItems._setItems(resultIconPresenterList);
Q_EMIT sortingHappened(resultItems);
//return resultItems;
}
ErrorList topolTest::checkOverlapWithLayer( double tolerance, QgsVectorLayer *layer1, QgsVectorLayer *layer2, bool isExtent )
{
Q_UNUSED( tolerance );
int i = 0;
ErrorList errorList;
bool skipItself = layer1 == layer2;
QgsSpatialIndex *index = mLayerIndexes[layer2->id()];
QgsGeometry canvasExtentPoly = QgsGeometry::fromWkt( qgsInterface->mapCanvas()->extent().asWktPolygon() );
QList<FeatureLayer>::iterator it;
for ( it = mFeatureList1.begin(); it != mFeatureList1.end(); ++it )
{
if ( !( ++i % 100 ) )
emit progress( i );
if ( testCanceled() )
break;
QgsGeometry g1 = it->feature.geometry();
QgsRectangle bb = g1.boundingBox();
QList<QgsFeatureId> crossingIds;
crossingIds = index->intersects( bb );
QList<QgsFeatureId>::ConstIterator cit = crossingIds.begin();
QList<QgsFeatureId>::ConstIterator crossingIdsEnd = crossingIds.end();
for ( ; cit != crossingIdsEnd; ++cit )
{
QgsFeature &f = mFeatureMap2[*cit].feature;
QgsGeometry g2 = f.geometry();
// skip itself, when invoked with the same layer
if ( skipItself && f.id() == it->feature.id() )
continue;
if ( g2.isNull() )
{
QgsMessageLog::logMessage( tr( "Second geometry missing." ), tr( "Topology plugin" ) );
continue;
}
if ( g1.overlaps( g2 ) )
{
QgsRectangle r = bb;
QgsRectangle r2 = g2.boundingBox();
r.combineExtentWith( r2 );
QgsGeometry conflictGeom = g1.intersection( g2 );
// could this for some reason return NULL?
if ( conflictGeom.isNull() )
{
continue;
}
if ( isExtent )
{
if ( canvasExtentPoly.disjoint( conflictGeom ) )
{
continue;
}
if ( canvasExtentPoly.crosses( conflictGeom ) )
{
conflictGeom = conflictGeom.intersection( canvasExtentPoly );
}
}
//c = new QgsGeometry;
QList<FeatureLayer> fls;
FeatureLayer fl;
fl.feature = f;
fl.layer = layer2;
fls << *it << fl;
TopolErrorIntersection *err = new TopolErrorIntersection( r, conflictGeom, fls );
errorList << err;
}
}
}
return errorList;
}
