SnakeWorker.h

#pragma once

#include <QObject>
#include <QVariant>
#include <QThread>
#include <QVector>
#include <QGeoCoordinate>
#include <vector>

#include "GeoPolygonArray.h"
#include "PolygonArray.h"


typedef QList<QVariant> QVariantList;

typedef struct Result{
    QVector<QGeoCoordinate> waypoints;
    GeoPolygonArray         tiles;
    PolygonArray            tilesLocal;
    QVariantList            tileCenterPoints;
    QGeoCoordinate          origin;
    QVector<unsigned long>  arrivalPathIdx;
    QVector<unsigned long>  returnPathIdx;
    bool                    success;
    QString                 errorMessage;

    void clear();
}WorkerResult_t;

class SnakeWorker : public QThread{
    Q_OBJECT

public:
    SnakeWorker(QObject *parent = nullptr);
    ~SnakeWorker() override;


    template<template<class, class...> class Container>
    void setMeasurementArea     (const Container<QGeoCoordinate>  &measurementArea);
    template<template<class, class...> class Container>
    void setServiceArea         (const Container<QGeoCoordinate>  &serviceArea);
    template<template<class, class...> class Container>
    void setCorridor            (const Container<QGeoCoordinate>  &corridor);
    template<template<class, class...> class Container, class IntType>
    void setProgress            (const Container<IntType>  &progress);

    WorkerResult_t &result();

    double lineDistance() const;
    void setLineDistance(double lineDistance);

    double minTransectLength() const;
    void setMinTransectLength(double minTransectLength);

    double minTileArea() const;
    void setMinTileArea(double minTileArea);

    double tileHeight() const;
    void setTileHeight(double tileHeight);

    double tileWidth() const;
    void setTileWidth(double tileWidth);

protected:
    void run() override;

private:
    bool precondition() const;


    std::vector<QGeoCoordinate> _mArea;
    std::vector<QGeoCoordinate> _sArea;
    std::vector<QGeoCoordinate> _corridor;
    std::vector<int>            _progress;
    double                      _lineDistance;
    double                      _minTransectLength;
    double                      _tileWidth;
    double                      _tileHeight;
    double                      _minTileArea;
    WorkerResult_t              _result;
};

template<template<class, class...> class Container>
void SnakeWorker::setCorridor(const Container<QGeoCoordinate> &corridor)
{
    _corridor.clear();
    for (auto vertex : corridor) {
        _corridor.push_back(vertex);
    }
}

template<template<class, class...> class Container>
void SnakeWorker::setMeasurementArea(const Container<QGeoCoordinate> &measurementArea)
{
    _mArea.clear();
    for (auto vertex : measurementArea) {
        _mArea.push_back(vertex);
    }
}

template<template<class, class...> class Container>
void SnakeWorker::setServiceArea(const Container<QGeoCoordinate> &serviceArea)
{
    _sArea.clear();
    for (auto vertex : serviceArea) {
        _sArea.push_back(vertex);
    }
}

template<template<class, class...> class Container, class IntType>
void SnakeWorker::setProgress(const Container<IntType> &progress)
{
    _progress.clear();
    for (auto p : progress) {
        assert(p >= -1 && p <= 100);
        _progress.push_back(p);
    }
}