#include <KisMagneticWorker.h>

Public Member Functions
QVector< QPointF >	computeEdge (int bounds, QPoint start, QPoint end, qreal radius)

qreal	intensity (QPoint pt)

	KisMagneticWorker (const KisPaintDeviceSP &dev)

void	saveTheImage (vQPointF points)

Private Attributes
KisMagneticGraph *	m_graph {nullptr}

KisMagneticLazyTiles	m_lazyTileFilter

Detailed Description

Definition at line 30 of file KisMagneticWorker.h.

Constructor & Destructor Documentation

◆ KisMagneticWorker()

KisMagneticWorker::KisMagneticWorker ( const KisPaintDeviceSP & dev )

Definition at line 181 of file KisMagneticWorker.cc.

                                                                :
    m_lazyTileFilter(dev)
{ }

Member Function Documentation

◆ computeEdge()

QVector< QPointF > KisMagneticWorker::computeEdge	(	int	bounds,
		QPoint	start,
		QPoint	end,
		qreal	radius )

Definition at line 185 of file KisMagneticWorker.cc.

{
    QRect rect;
    KisAlgebra2D::accumulateBounds(QVector<QPoint> { begin, end }, &rect);
    rect = kisGrowRect(rect, bounds);
    m_lazyTileFilter.filter(radius, rect);
 
    VertexDescriptor goal(end);
    VertexDescriptor start(begin);
 
    m_graph = new KisMagneticGraph(m_lazyTileFilter.device(), rect);
 
    // How many maps does it require?
    // Take a look here, if it doesn't make sense, https://www.boost.org/doc/libs/1_70_0/libs/graph/doc/astar_search.html
    PredecessorMap pmap;
    DistanceMap dmap(std::numeric_limits<double>::max());
    dmap[start] = 0;
    std::map<VertexDescriptor, double> rmap;
    std::map<VertexDescriptor, boost::default_color_type> cmap;
    std::map<VertexDescriptor, double> imap;
    WeightMap wmap(*m_graph);
    AStarHeuristic heuristic(goal);
    QVector<QPointF> result;
 
    try {
        boost::astar_search_no_init(
            *m_graph, start, heuristic,
            boost::visitor(AStarGoalVisitor(goal))
            .distance_map(boost::associative_property_map<DistanceMap>(dmap))
            .predecessor_map(boost::ref(pmap))
            .weight_map(boost::associative_property_map<WeightMap>(wmap))
            .vertex_index_map(boost::associative_property_map<std::map<VertexDescriptor, double> >(imap))
            .rank_map(boost::associative_property_map<std::map<VertexDescriptor, double> >(rmap))
            .color_map(boost::associative_property_map<std::map<VertexDescriptor, boost::default_color_type> >
                           (cmap))
            .distance_combine(std::plus<double>())
            .distance_compare(std::less<double>())
            );
    } catch (GoalFound const &) {
        for (VertexDescriptor u = goal; u != start; u = pmap[u]) {
            result.push_front(QPointF(u.x, u.y));
        }
    }
 
    result.push_front(QPoint(start.x, start.y));
 
    return result;
} // KisMagneticWorker::computeEdge

References KisAlgebra2D::accumulateBounds(), bounds, KisMagneticLazyTiles::device(), KisMagneticLazyTiles::filter(), kisGrowRect(), m_graph, m_lazyTileFilter, u, VertexDescriptor::x, and VertexDescriptor::y.

◆ intensity()

qreal KisMagneticWorker::intensity ( QPoint pt )

Definition at line 234 of file KisMagneticWorker.cc.

{
    return m_graph->getIntensity(VertexDescriptor(pt));
}

References KisMagneticGraph::getIntensity(), and m_graph.

◆ saveTheImage()

void KisMagneticWorker::saveTheImage ( vQPointF points )

Definition at line 239 of file KisMagneticWorker.cc.

{
    QImage img = m_lazyTileFilter.device()->convertToQImage(nullptr, m_lazyTileFilter.device()->exactBounds());
 
    const QPointF offset = m_lazyTileFilter.device()->exactBounds().topLeft();
    for (QPointF &pt : points) {
        pt -= offset;
    }
 
    img.convertTo(QImage::Format_ARGB32);
    QPainter gc(&img);
 
    QPainterPath path;
 
    for (int i = 0; i < points.size(); i++) {
        if (i == 0) {
            path.moveTo(points[i]);
        } else {
            path.lineTo(points[i]);
        }
    }
 
    gc.setPen(Qt::blue);
    gc.drawPath(path);
 
    gc.setPen(Qt::green);
    gc.drawEllipse(points[0], 3, 3);
    gc.setPen(Qt::red);
    gc.drawEllipse(points[points.count() - 1], 2, 2);
 
    for (QRect &r : m_lazyTileFilter.tiles() ) {
        gc.drawRect(r);
    }
 
    img.save("result.png");
} // KisMagneticWorker::saveTheImage

References KisPaintDevice::convertToQImage(), KisMagneticLazyTiles::device(), KisPaintDevice::exactBounds(), m_lazyTileFilter, and KisMagneticLazyTiles::tiles().

Member Data Documentation

◆ m_graph

KisMagneticGraph* KisMagneticWorker::m_graph {nullptr}

private

Definition at line 40 of file KisMagneticWorker.h.

40{nullptr};

◆ m_lazyTileFilter

KisMagneticLazyTiles KisMagneticWorker::m_lazyTileFilter