WimaGOperationArea.cc

#include "WimaGOperationArea.h"


const char* WimaGOperationArea::settingsGroup =                   "OperationArea";
const char* WimaGOperationArea::bottomLayerAltitudeName =         "BottomLayerAltitude";
const char* WimaGOperationArea::numberOfLayersName =              "NumberOfLayers";
const char* WimaGOperationArea::layerDistanceName =               "LayerDistance";
const char* WimaGOperationArea::borderPolygonOffsetName =         "BorderPolygonOffset";
const char* WimaGOperationArea::wimaGOperationAreaName =          "Operation Area";

WimaGOperationArea::WimaGOperationArea()
    : WimaGOperationArea(nullptr)
{

}

WimaGOperationArea::WimaGOperationArea(QObject *parent)
  : WimaArea (parent)
  , _metaDataMap            (FactMetaData::createMapFromJsonFile(QStringLiteral(":/json/WimaGOperationArea.SettingsGroup.json"), this /* QObject parent */))
  , _bottomLayerAltitude    (settingsGroup, _metaDataMap[bottomLayerAltitudeName])
  , _numberOfLayers         (settingsGroup, _metaDataMap[numberOfLayersName])
  , _layerDistance          (settingsGroup, _metaDataMap[layerDistanceName])
  , _borderPolygonOffset    (settingsGroup, _metaDataMap[borderPolygonOffsetName])
  , _borderPolygon          (new QGCMapPolygon(this))
{
    this->setObjectName(wimaGOperationAreaName);
    connect(this, &WimaGOperationArea::pathChanged, this, &WimaGOperationArea::recalcBorderPolygon);
    connect(&_borderPolygonOffset, &SettingsFact::rawValueChanged, this, &WimaGOperationArea::recalcBorderPolygon);
}

WimaGOperationArea::WimaGOperationArea(const WimaArea &other, QObject *parent)
  : WimaArea(other, parent)
  , _metaDataMap            (FactMetaData::createMapFromJsonFile(QStringLiteral(":/json/WimaGOperationArea.SettingsGroup.json"), this /* QObject parent */))
  , _bottomLayerAltitude    (settingsGroup, _metaDataMap[bottomLayerAltitudeName])
  , _numberOfLayers         (settingsGroup, _metaDataMap[numberOfLayersName])
  , _layerDistance          (settingsGroup, _metaDataMap[layerDistanceName])
  , _borderPolygonOffset    (settingsGroup, _metaDataMap[borderPolygonOffsetName])
  , _borderPolygon          (new QGCMapPolygon(this))
{
    this->setObjectName(wimaGOperationAreaName);
    connect(this, &WimaGOperationArea::pathChanged, this, &WimaGOperationArea::recalcBorderPolygon);
    connect(&_borderPolygonOffset, &SettingsFact::rawValueChanged, this, &WimaGOperationArea::recalcBorderPolygon);
 }

void WimaGOperationArea::addVehicle(WimaVehicle *vehicle)
{
    if(vehicle != nullptr){
        _wimaVehicle = vehicle;
        emit vehicleChanged();
    }
}

void WimaGOperationArea::removeVehicle(int vehicleIndex)
{
    if(vehicleIndex >= 0){
        _wimaVehicle = nullptr;
        emit vehicleChanged();
    }
}

void WimaGOperationArea::setVehicleCorridor(WimaVCorridor *corridor)
{
    if(corridor != nullptr){
        if (corridor != _vehicleCorridor){
            _vehicleCorridor = corridor;
            emit vehicleCorridorChanged(_vehicleCorridor);
        }
        else {
            qWarning("WimaGOperationArea::setVehicleCorridor(): new corridor equals old _vehicleCorridor!");
        }
    }else{
        qWarning("WimaGOperationArea::setVehicleCorridor(): corridor == nullptr!");
    }
}

void WimaGOperationArea::saveToJson(QJsonObject &json)
{
    this->WimaArea::saveToJson(json);
    json[bottomLayerAltitudeName]   = _bottomLayerAltitude.rawValue().toDouble();
    json[numberOfLayersName]        = _numberOfLayers.rawValue().toInt();
    json[layerDistanceName]         = _layerDistance.rawValue().toDouble();
    json[borderPolygonOffsetName]   = _borderPolygonOffset.rawValue().toDouble();
    json[areaTypeName]              = wimaGOperationAreaName;
}

bool WimaGOperationArea::loadFromJson(const QJsonObject &json, QString& errorString)
{
    if (this->WimaArea::loadFromJson(json, errorString)) {
        bool retVal = true;

        if ( json.contains(bottomLayerAltitudeName) && json[bottomLayerAltitudeName].isDouble() ) {
            _bottomLayerAltitude.setRawValue(json[bottomLayerAltitudeName].toDouble());
        } else {
            errorString.append(tr("Could not load Bottom Layer Altitude!\n"));
            retVal = false;
        }

        if ( json.contains(numberOfLayersName) && json[numberOfLayersName].isDouble() ) {
            _numberOfLayers.setRawValue(json[numberOfLayersName].toInt());
        } else {
            errorString.append(tr("Could not load Number of Layers!\n"));
            retVal = false;
        }

        if ( json.contains(layerDistanceName) && json[layerDistanceName].isDouble() ) {
            _layerDistance.setRawValue(json[layerDistanceName].toDouble());
        } else {
            errorString.append(tr("Could not load Layer Distance!\n"));
            retVal = false;
        }

        if ( json.contains(borderPolygonOffsetName) && json[borderPolygonOffsetName].isDouble() ) {
            _borderPolygonOffset.setRawValue(json[borderPolygonOffsetName].toDouble());
        } else {
            errorString.append(tr("Could not load Border Polygon Offset!\n"));
            retVal = false;
        }

        return retVal;
    } else {
        return false;
    }
}

void WimaGOperationArea::recalcBorderPolygon()
{
    //qWarning("WimaGOperationArea::recalcBorderPolygon() %f", _borderPolygonOffset.rawValue().toDouble());
    QGCMapPolygon polyCopy = this->toQGCPolygon(*this);
    polyCopy.offset(_borderPolygonOffset.rawValue().toDouble());
    _borderPolygon.setPath(polyCopy.path());
    polyCopy.deleteLater();

    emit borderPolygonChanged();
}

/*void WimaGOperationArea::recalculatesubPolygons()
{
    int vehicleCount = _vehicleList->count();
    QScopedPointer<QList<QGCMapPolygon*>> listQGCPoly(this->splitPolygonArea(vehicleCount));

    int polyCount = listQGCPoly->size();
    _vehiclePolygons->clear();
    for(int i = 0; i < polyCount; i++){
        WimaVehicleMeasurementPolygon* subPoly = new WimaVehicleMeasurementPolygon(listQGCPoly->takeAt(i), this);
        _vehiclePolygons->append(subPoly);
    }
}

void WimaGOperationArea::removeAllVehicles()
{
    int count = _vehicleList->count();

    if(count > 0){
        do{
            _vehicleList->removeAt(0);
            count--;
        }while(count > 0);

        emit vehicleListChanged();
    }

}


void WimaGOperationArea::addVehiclePolygon()
{
    _vehiclePolygons->append(new WimaVehicleMeasurementPolygon(this));

    emit vehiclePolygonsChanged();
}

void WimaGOperationArea::removeVehiclePolygon(int polygonIndex)
{
    if(polygonIndex >= 0 && polygonIndex < _vehiclePolygons->count()){
        _vehiclePolygons->removeAt(polygonIndex);

        emit vehiclePolygonsChanged();
    }else {
        qWarning("Index out of bounds!");
    }
}

void WimaGOperationArea::removeVehiclePolygon(WimaVehicleMeasurementPolygon *wimaPolygon)
{
    if(wimaPolygon != nullptr){
        QObject* removedPolygon = _vehiclePolygons->removeOne(wimaPolygon);
        if(removedPolygon){
            emit vehiclePolygonsChanged();
        }else {
            qWarning("Polygon not inside polygon list.");
        }
    }else {
        qWarning("Not a valid Polygon.");
    }
}*/