336 lines
15 KiB
C#
336 lines
15 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using FarmmapsApi;
|
|
using FarmmapsApi.Models;
|
|
using FarmmapsApi.Services;
|
|
using FarmmapsNbs.Models;
|
|
using Microsoft.Extensions.Logging;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using static FarmmapsApiSamples.Constants;
|
|
|
|
namespace FarmmapsNbs
|
|
{
|
|
public class NbsApplication : IApplication
|
|
{
|
|
private const string DownloadFolder = "Downloads";
|
|
private const string SettingsFile = "settings.json";
|
|
|
|
private readonly ILogger<NbsApplication> _logger;
|
|
private readonly FarmmapsApiService _farmmapsApiService;
|
|
private readonly NitrogenService _nitrogenService;
|
|
private readonly GeneralService _generalService;
|
|
|
|
private Settings _settings;
|
|
|
|
public NbsApplication(ILogger<NbsApplication> logger, FarmmapsApiService farmmapsApiService,
|
|
GeneralService generalService, NitrogenService nitrogenService)
|
|
{
|
|
_logger = logger;
|
|
_farmmapsApiService = farmmapsApiService;
|
|
_generalService = generalService;
|
|
_nitrogenService = nitrogenService;
|
|
}
|
|
|
|
public async Task RunAsync()
|
|
{
|
|
var nitrogenInputJson = File.ReadAllText("InputData-NBS.json"); //NitrogenInput.json
|
|
List<NitrogenInput> nitrogenInputs = JsonConvert.DeserializeObject<List<NitrogenInput>>(nitrogenInputJson);
|
|
|
|
if (!Directory.Exists(DownloadFolder))
|
|
Directory.CreateDirectory(DownloadFolder);
|
|
|
|
// !! this call is needed the first time an api is called with a fresh clientid and secret !!
|
|
await _farmmapsApiService.GetCurrentUserCodeAsync();
|
|
var roots = await _farmmapsApiService.GetCurrentUserRootsAsync();
|
|
|
|
foreach (var input in nitrogenInputs)
|
|
{
|
|
try
|
|
{
|
|
await Process(roots, input);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex.Message);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task Process(List<UserRoot> roots, NitrogenInput input)
|
|
{
|
|
|
|
// !!specify if you are using an already created cropfield:
|
|
bool useCreatedCropfield = input. UseCreatedCropfield;
|
|
var plantingDate = input.PlantingDate;
|
|
var FieldName = input.fieldName;
|
|
bool StoreStatistics = input.storeSatelliteStatistics;
|
|
var measurementDate = input.MeasurementDate;
|
|
string settingsfile = $"Settings_{FieldName}.json";
|
|
|
|
LoadSettings(settingsfile);
|
|
|
|
var uploadedRoot = roots.SingleOrDefault(r => r.Name == "Uploaded");
|
|
if (uploadedRoot == null)
|
|
{
|
|
_logger.LogError("Could not find a needed root item");
|
|
return;
|
|
}
|
|
|
|
var myDriveRoot = roots.SingleOrDefault(r => r.Name == "My drive");
|
|
if (myDriveRoot == null)
|
|
{
|
|
_logger.LogError("Could not find a needed root item");
|
|
return;
|
|
}
|
|
|
|
// Use already created cropfield or create new one
|
|
Item cropfieldItem;
|
|
if (useCreatedCropfield == false || string.IsNullOrEmpty(_settings.CropfieldItemCode))
|
|
{
|
|
_logger.LogInformation("Creating cropfield");
|
|
cropfieldItem = await _generalService.CreateCropfieldItemAsync(myDriveRoot.Code,
|
|
$"VRA NBS cropfield {input.OutputFileName}", plantingDate.Year, input.GeometryJson.ToString(Formatting.None));
|
|
_settings.CropfieldItemCode = cropfieldItem.Code;
|
|
SaveSettings(settingsfile);
|
|
}
|
|
else
|
|
{
|
|
_logger.LogInformation("Cropfield already exists, trying to get it");
|
|
cropfieldItem = await _farmmapsApiService.GetItemAsync(_settings.CropfieldItemCode);
|
|
}
|
|
|
|
var geotiffItem = (Item)null;
|
|
|
|
// No file input, use most recent satellite image
|
|
if (string.IsNullOrEmpty(input.File)) {
|
|
_logger.LogInformation("No specific data given, retrieving most recent satellite image");
|
|
|
|
// check if satellite task not yet done, do here and save taskcode
|
|
if (useCreatedCropfield == false || string.IsNullOrEmpty(_settings.SatelliteTaskCode)) {
|
|
var satelliteTaskCode = await _generalService.RunSatelliteTask(cropfieldItem);
|
|
_settings.SatelliteTaskCode = satelliteTaskCode;
|
|
SaveSettings(settingsfile);
|
|
}
|
|
|
|
|
|
// Select a particular satellite item from satelliteTask
|
|
Item satalliteItem = await _generalService.FindSatelliteItem(cropfieldItem, _settings.SatelliteTaskCode, FieldName, StoreStatistics);
|
|
|
|
var satelliteBand = satalliteItem.Data["layers"][0]["name"];
|
|
var satelliteStatistics = satalliteItem.Data["layers"][0]["renderer"]["band"]["statistics"];
|
|
Console.WriteLine($"Satellite image date: {satalliteItem.DataDate}");
|
|
//Console.WriteLine($"Satellite image statistics for band {satelliteBand}: {satelliteStatistics}");
|
|
|
|
//Store data to csv
|
|
if (StoreStatistics==true) {
|
|
var SatelliteFile = $"C:\\Akkerweb\\DataSatellite_{FieldName}.csv";
|
|
var NewLineField = $"\"Field\":{FieldName}" + Environment.NewLine;
|
|
var NewLineDate = $"\"date\":{satalliteItem.DataDate}" + Environment.NewLine;
|
|
var i = 0;
|
|
foreach (var item in satelliteStatistics) {
|
|
//var NewLines2;
|
|
if (i == 0) {
|
|
File.AppendAllText(SatelliteFile, NewLineDate);
|
|
i++;
|
|
}
|
|
File.AppendAllText(SatelliteFile, $"{item}" + Environment.NewLine);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
// must be wdvi[1]
|
|
var inputType = (satalliteItem.Data["layers"] as JArray)?[1]["name"].ToString();
|
|
if (string.IsNullOrEmpty(inputType)) {
|
|
_logger.LogError("Could not get the input type name from the satellite item");
|
|
return;
|
|
}
|
|
|
|
// download the geotiff
|
|
var SatelliteImageDate = (DateTime)satalliteItem.DataDate;
|
|
var SatelliteDate = SatelliteImageDate.ToString("yyyyMMdd");
|
|
_logger.LogInformation("Downloading geotiff file");
|
|
await _farmmapsApiService.DownloadItemAsync(satalliteItem.Code,
|
|
Path.Combine(DownloadFolder, $"nbs_inputSatelliteGeotiff_{input.OutputFileName}_{inputType}_{SatelliteDate}.zip"));
|
|
|
|
// overwrite measurement date by date of satellite item
|
|
measurementDate = satalliteItem.DataDate.Value;
|
|
|
|
geotiffItem = satalliteItem;
|
|
|
|
|
|
}
|
|
|
|
|
|
// (geo)tiff input:
|
|
else if (input.File.Contains(".tif") || input.File.Contains(".geotiff")) {
|
|
_logger.LogInformation("input = tiff data");
|
|
var dataPath = Path.Combine("Data", input.File);
|
|
geotiffItem = await _generalService.UploadDataAsync(uploadedRoot, GEOTIFF_PROCESSED_ITEMTYPE, dataPath,
|
|
Path.GetFileNameWithoutExtension(input.File));
|
|
|
|
if (geotiffItem == null) {
|
|
_logger.LogError("Could not find item for uploaded data");
|
|
return;
|
|
}
|
|
}
|
|
|
|
// json/shape input
|
|
else {
|
|
var isGeoJson = input.File.Contains("json");
|
|
var dataPath = Path.Combine("Data", input.File);
|
|
var shapeItem = isGeoJson ?
|
|
await _generalService.UploadDataAsync(uploadedRoot, SHAPE_PROCESSED_ITEMTYPE, dataPath, Path.GetFileNameWithoutExtension(input.File)) :
|
|
await _generalService.UploadZipWithShapeAsync(uploadedRoot, dataPath, Path.GetFileNameWithoutExtension(input.File));
|
|
|
|
if (shapeItem == null) {
|
|
_logger.LogError("Could not find item for uploaded data");
|
|
return;
|
|
}
|
|
|
|
_logger.LogInformation($"Converting shape to geotiff");
|
|
geotiffItem = await _generalService.ShapeToGeotiff(shapeItem);
|
|
if (geotiffItem == null) {
|
|
_logger.LogError("Something went wrong with shape to geotiff transformation");
|
|
return;
|
|
}
|
|
|
|
_logger.LogInformation("Downloading geotiff file");
|
|
await _farmmapsApiService.DownloadItemAsync(geotiffItem.Code,
|
|
Path.Combine(DownloadFolder, $"{input.OutputFileName}.input_geotiff.zip"));
|
|
}
|
|
|
|
|
|
//// check if vandersat task not yet done, do here and save taskcode
|
|
//if (useCreatedCropfield == false || string.IsNullOrEmpty(_settings.VanDerSatTaskCode)) {
|
|
// var VanDerSatTaskCode = await _generalService.RunVanDerSatTask(cropfieldItem);
|
|
// _settings.VanDerSatTaskCode = VanDerSatTaskCode;
|
|
// SaveSettings(settingsfile);
|
|
//}
|
|
|
|
//// Select a particular image item from VanDerSat
|
|
//Item VanDerSatItem = await _generalService.FindVanDerSatItem(cropfieldItem, _settings.VanDerSatTaskCode, FieldName, StoreStatistics);
|
|
|
|
|
|
//// download the geotiff
|
|
//_logger.LogInformation("Downloading geotiff file");
|
|
//await _farmmapsApiService.DownloadItemAsync(VanDerSatItem.Code,
|
|
// Path.Combine(DownloadFolder, $"nbs_VanDerSatGeotiff_{input.OutputFileName}.zip"));
|
|
|
|
_logger.LogInformation($"Calculating targetN with targetYield: {input.TargetYield}");
|
|
var targetNItem = await _nitrogenService.CreateTargetNItem(cropfieldItem);
|
|
var targetNData = await _nitrogenService.CalculateTargetN(cropfieldItem, targetNItem, plantingDate,
|
|
measurementDate, input.PotatoPurposeType, input.TargetYield);
|
|
|
|
if (targetNData == null) {
|
|
_logger.LogError("Something went wrong with TargetN calculation");
|
|
return;
|
|
}
|
|
|
|
_logger.LogInformation($"TargetN: {targetNData.TargetN}");
|
|
////Option to manually adjust the Target N, for test purposes only!
|
|
//targetNData.TargetN = 225;
|
|
//_logger.LogInformation($"TargetN adjusted: {targetNData.TargetN}");
|
|
|
|
var targetNDataPath = Path.Combine(DownloadFolder, $"{input.OutputFileName}.targetn.json");
|
|
await File.WriteAllTextAsync(targetNDataPath, JsonConvert.SerializeObject(targetNData, Formatting.Indented));
|
|
|
|
_logger.LogInformation("Calculating uptake map");
|
|
var uptakeMapItem =
|
|
await _nitrogenService.CalculateUptakeMap(cropfieldItem, geotiffItem, plantingDate,
|
|
measurementDate, input.InputVariable, input.InputLayerName);
|
|
if (uptakeMapItem == null) {
|
|
_logger.LogError("Something went wrong with creating the uptakeMap");
|
|
return;
|
|
}
|
|
|
|
_logger.LogInformation("Downloading uptake map");
|
|
await _farmmapsApiService.DownloadItemAsync(uptakeMapItem.Code,
|
|
Path.Combine(DownloadFolder, $"{input.OutputFileName}.uptake.zip"));
|
|
_logger.LogInformation("UptakeMap downloaded to {0}", Path.Combine(DownloadFolder, $"{input.OutputFileName}.uptake.zip"));
|
|
|
|
_logger.LogInformation("Calculating application map");
|
|
var applicationMapItem =
|
|
await _nitrogenService.CalculateApplicationMap(cropfieldItem, geotiffItem, plantingDate,
|
|
measurementDate, input.InputVariable, targetNData.TargetN, input.InputLayerName);
|
|
|
|
if (applicationMapItem == null) {
|
|
_logger.LogError("Something went wrong with creating the applicationMap");
|
|
return;
|
|
}
|
|
_logger.LogInformation("Downloading application map");
|
|
await _farmmapsApiService.DownloadItemAsync(applicationMapItem.Code,
|
|
Path.Combine(DownloadFolder, $"{input.OutputFileName}.application.zip"));
|
|
_logger.LogInformation("Application map can be found in {0}", Path.Combine(DownloadFolder, $"{input.OutputFileName}.application.zip"));
|
|
|
|
//transforming tiff to shape
|
|
var tiffItem = applicationMapItem;
|
|
|
|
if (tiffItem == null) {
|
|
_logger.LogError("Could not find item for uploaded data");
|
|
return;
|
|
}
|
|
|
|
//_logger.LogInformation($"Converting geotiff to shape");
|
|
//var taskmap = await _generalService.GeotiffToShape(tiffItem);
|
|
//if (taskmap == null) {
|
|
// _logger.LogError("Something went wrong with geotiff to shape transformation");
|
|
// return;
|
|
//}
|
|
|
|
//ApplicationMap (GEOTIFF) To Taskmap
|
|
_logger.LogInformation($"Converting geotiff to taskmap");
|
|
var taskmap = await _generalService.CreateTaskmap(cropfieldItem, tiffItem, input.CellWidth, input.CellHeight, input.StartPoint.ToString(Formatting.None),
|
|
input.EndPoint.ToString(Formatting.None), input.Angle);
|
|
if (taskmap == null)
|
|
{
|
|
_logger.LogError("Something went wrong with geotiff to shape transformation");
|
|
return;
|
|
}
|
|
|
|
|
|
_logger.LogInformation("Downloading taskmap");
|
|
await _farmmapsApiService.DownloadItemAsync(taskmap.Code,
|
|
Path.Combine(DownloadFolder, $"{input.OutputFileName}.taskmap.zip"));
|
|
|
|
|
|
}
|
|
|
|
|
|
// Functions to save previously created cropfields
|
|
private void LoadSettings(string file)
|
|
{
|
|
if (File.Exists(file))
|
|
{
|
|
var jsonText = File.ReadAllText(file);
|
|
_settings = JsonConvert.DeserializeObject<Settings>(jsonText);
|
|
}
|
|
else
|
|
{
|
|
_settings = new Settings();
|
|
}
|
|
}
|
|
|
|
private void SaveSettings(string file)
|
|
{
|
|
if (_settings == null)
|
|
return;
|
|
|
|
var json = JsonConvert.SerializeObject(_settings);
|
|
File.WriteAllText(file, json);
|
|
}
|
|
private void SaveInfo(string file) {
|
|
if (_settings == null)
|
|
return;
|
|
|
|
var json = JsonConvert.SerializeObject(_settings);
|
|
File.WriteAllText(file, json);
|
|
|
|
}
|
|
|
|
}
|
|
} |