TillageAI

The Ag-Analytics® TillageAI tillage identification model exposed via API, uses mutlispectral harmonized Landsat/Sentinel data, as well as other data sources and artificial intelligence algorithms to determine whether a field has been tilled or not, and at what date of the year.

b) Tillage Identification

Service Overview

Similar to the crop identification models, there is also great value in being able to identify where tillage and no-till (a conservation practice) are being used, and to be able to construct histories.

The Ag-Analytics® TillageAI API provides the service in which a user may point to any field in any year, and be able to infer:

  1. Was the field tilled or not
  2. If tilled, what date it was tilled
  3. If tilled, depth and type of tillage

This API uses NDVI imagery, location, weather, and other available data to "predict", or determine, if a field has been tilled.

The Tillage Model is a “backfilling model”, meaning that it can determine whether a field was tilled in the past, rather than provide prediction as to whether a field will be tilled. The model uses a seven-week window of satellite imagery, so as long as the date requested is more than three weeks prior to the current date (i.e., if today is Monday of the 20th week of the year, the latest request that can be made is for the 16th week.).

The Ag-Analytics Tillage Identification GET API allows a user to easily "fetch" and download locally a resulting .tif from the Tillage Identification POST API.


Example of Tillage Identification

 

Model Specifications

The Tillage Model predicts tillage using one of two models that have been trained on approximately 2,000 tillage records from real farming operations. The dataset of tillage operations is used for ground truthing to create a verification label. Without the ground-truth data, there would be no way to tell the model that it predicted tillage correctly, and no way to determine the accuracy of a trained model.

The models are trained on three categories of data. The first is the location of the field geospatially. Tillage practices may vary in different areas of the country, so the addition of geospatial coordinates can illuminate some of these relationships. The second is the week of the year. In combination with the location of the field, the week of the year can help determine whether a field is able to be tilled at a given time of year. For example, tilling in Florida happens at a different time than in Minnesota. Third, remote sensing satellite imagery is used to find patterns in the ground reflectance that happen before, during, and after tillage. The temporal reflectance patterns are the primary driver for the tillage model in determining whether the field has been tilled. Currently, the model uses a seven-week window of satellite imagery.



Call API

Request

Request URL

Request parameters

  • File name of the file from POST TillageAI API.

Request body

Responses

200 OK

null

Code samples

@ECHO OFF

curl -v -X GET "https://ag-analytics.azure-api.net/tillage-model/?filename={filename}"

--data-ascii "{body}" 
using System;
using System.Net.Http.Headers;
using System.Text;
using System.Net.Http;
using System.Web;

namespace CSHttpClientSample
{
    static class Program
    {
        static void Main()
        {
            MakeRequest();
            Console.WriteLine("Hit ENTER to exit...");
            Console.ReadLine();
        }
        
        static async void MakeRequest()
        {
            var client = new HttpClient();
            var queryString = HttpUtility.ParseQueryString(string.Empty);


            var uri = "https://ag-analytics.azure-api.net/tillage-model/?filename={filename}&" + queryString;

            var response = await client.GetAsync(uri);
        }
    }
}	
// // This sample uses the Apache HTTP client from HTTP Components (http://hc.apache.org/httpcomponents-client-ga/)
import java.net.URI;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class JavaSample 
{
    public static void main(String[] args) 
    {
        HttpClient httpclient = HttpClients.createDefault();

        try
        {
            URIBuilder builder = new URIBuilder("https://ag-analytics.azure-api.net/tillage-model/?filename={filename}");


            URI uri = builder.build();
            HttpGet request = new HttpGet(uri);


            // Request body
            StringEntity reqEntity = new StringEntity("{body}");
            request.setEntity(reqEntity);

            HttpResponse response = httpclient.execute(request);
            HttpEntity entity = response.getEntity();

            if (entity != null) 
            {
                System.out.println(EntityUtils.toString(entity));
            }
        }
        catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
    }
}

<!DOCTYPE html>
<html>
<head>
    <title>JSSample</title>
    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.0/jquery.min.js"></script>
</head>
<body>

<script type="text/javascript">
    $(function() {
        var params = {
            // Request parameters
        };
      
        $.ajax({
            url: "https://ag-analytics.azure-api.net/tillage-model/?filename={filename}&" + $.param(params),
            beforeSend: function(xhrObj){
                // Request headers
            },
            type: "GET",
            // Request body
            data: "{body}",
        })
        .done(function(data) {
            alert("success");
        })
        .fail(function() {
            alert("error");
        });
    });
</script>
</body>
</html>
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[])
{
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    
    NSString* path = @"https://ag-analytics.azure-api.net/tillage-model/?filename={filename}";
    NSArray* array = @[
                         // Request parameters
                         @"entities=true",
                      ];
    
    NSString* string = [array componentsJoinedByString:@"&"];
    path = [path stringByAppendingFormat:@"?%@", string];

    NSLog(@"%@", path);

    NSMutableURLRequest* _request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:path]];
    [_request setHTTPMethod:@"GET"];
    // Request headers
    // Request body
    [_request setHTTPBody:[@"{body}" dataUsingEncoding:NSUTF8StringEncoding]];
    
    NSURLResponse *response = nil;
    NSError *error = nil;
    NSData* _connectionData = [NSURLConnection sendSynchronousRequest:_request returningResponse:&response error:&error];

    if (nil != error)
    {
        NSLog(@"Error: %@", error);
    }
    else
    {
        NSError* error = nil;
        NSMutableDictionary* json = nil;
        NSString* dataString = [[NSString alloc] initWithData:_connectionData encoding:NSUTF8StringEncoding];
        NSLog(@"%@", dataString);
        
        if (nil != _connectionData)
        {
            json = [NSJSONSerialization JSONObjectWithData:_connectionData options:NSJSONReadingMutableContainers error:&error];
        }
        
        if (error || !json)
        {
            NSLog(@"Could not parse loaded json with error:%@", error);
        }
        
        NSLog(@"%@", json);
        _connectionData = nil;
    }
    
    [pool drain];

    return 0;
}
<?php
// This sample uses the Apache HTTP client from HTTP Components (http://hc.apache.org/httpcomponents-client-ga/)
require_once 'HTTP/Request2.php';

$request = new Http_Request2('https://ag-analytics.azure-api.net/tillage-model/?filename={filename}');
$url = $request->getUrl();

$headers = array(
    // Request headers
);

$request->setHeader($headers);

$parameters = array(
    // Request parameters
);

$url->setQueryVariables($parameters);

$request->setMethod(HTTP_Request2::METHOD_GET);

// Request body
$request->setBody("{body}");

try
{
    $response = $request->send();
    echo $response->getBody();
}
catch (HttpException $ex)
{
    echo $ex;
}

?>
########### Python 2.7 #############
import httplib, urllib, base64

headers = {
}

params = urllib.urlencode({
})

try:
    conn = httplib.HTTPSConnection('ag-analytics.azure-api.net')
    conn.request("GET", "/tillage-model/?filename={filename}&%s" % params, "{body}", headers)
    response = conn.getresponse()
    data = response.read()
    print(data)
    conn.close()
except Exception as e:
    print("[Errno {0}] {1}".format(e.errno, e.strerror))

####################################

########### Python 3.2 #############
import http.client, urllib.request, urllib.parse, urllib.error, base64

headers = {
}

params = urllib.parse.urlencode({
})

try:
    conn = http.client.HTTPSConnection('ag-analytics.azure-api.net')
    conn.request("GET", "/tillage-model/?filename={filename}&%s" % params, "{body}", headers)
    response = conn.getresponse()
    data = response.read()
    print(data)
    conn.close()
except Exception as e:
    print("[Errno {0}] {1}".format(e.errno, e.strerror))

####################################
require 'net/http'

uri = URI('https://ag-analytics.azure-api.net/tillage-model/?filename={filename}')


request = Net::HTTP::Get.new(uri.request_uri)
# Request body
request.body = "{body}"

response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
    http.request(request)
end

puts response.body