Land Registry data for December 2021

I've uploaded the latest house price data for England and Wales to my website. And it's as you were, with lower sales and slowing inflation in prices. 

.NET Coords in .NET Core

.NET Coords is now a .NET Standard 2.0 project, meaning it can be used in .NET Framework 4.8 and .NET Core projects

UPRN data

I've uploaded UPRN (Unique Property Reference Number) data for the UK to my website. They are only currently available as a link from viewing a particular postcode (an example) but do let me know if it would be useful to provide them in some other way.

Unfortunately the freely available data doesn't include the thing that would be make this data exceedingly useful, the address. I doubt that is likely to happen since there are many companies whose business is based on selling that data

One other major problem is the open data includes old UPRNs but no indication that the UPRN is no longer active, hopefully this will be addressed in a future release.

There's more information on this data here which covers other issues with it.

C# code to generate a segment FIT file

Someone asked about getting hold of the code to generate FIT files from Strava segments. It's not possible to provide standalone code since it's has dependencies on the rest of my website and a Strava library, but here's what I use which may give people an idea of how to use the rather confusing Garmin FIT API

using System;
using System.Collections.Generic;
using System.IO;
using System.Web;
using Dynastream.Fit;
using Newtonsoft.Json.Linq;
using Strava.Common;
using Strava.Segments;
using Strava.Streams;

public static class FitGenerator
{ 
  private static void AddLeaderEntry(SegmentPointMesg newRecord, int goal, float currentDistance, 
    float totalDistance, byte goalIndex)  
  {
    if (goal != 0)
    {
      var currentGoalTime = (float)Math.Floor(currentDistance / totalDistance * goal);
      newRecord.SetLeaderTime(goalIndex, currentGoalTime);
    }
  }

  private static SegmentLeaderboardEntryMesg GetLeaderboard(int goal, byte goalIndex, 
    SegmentLeaderboardType type, string name)
  {
    var goalLeaderboard = new SegmentLeaderboardEntryMesg();
    if (goal != 0)
    {
      goalLeaderboard.SetMessageIndex(goalIndex);
      goalLeaderboard.SetSegmentTime(goal);
      goalLeaderboard.SetType(type);
      if (!string.IsNullOrEmpty(name))
        goalLeaderboard.SetName(name);
    }

    return goalLeaderboard;
  }

  private static int LatOrLngToSemicircle(double latOrLng)
  {
    return (int)(latOrLng * (Math.Pow(2, 31) / 180));
  }

  private static bool HasPr(List<SegmentStream> pr, Segment seg)
  {
    if (pr != null)
      return true;
    if (seg.AthleteSegmentStats != null && seg.AthleteSegmentStats.PrElapsedTime != null)
      return true;

    return false;
  }

  public static byte[] Generate(Segment seg, int goal, string goalName, int rival, string rivalName, 
    int challenger, string challengerName)
  {
    List<SegmentStream> altitude = null;
    try
    {
      StravaBaseHandler.TryStravaRequest((client) =>
      {
        altitude = client.Streams.GetSegmentStream(seg.Id.ToString(), 
          SegmentStreamType.Altitude | SegmentStreamType.LatLng);
      });
    }
    catch (Exception ex)
    {
      throw new Exception("Failed to get stream for segment " + seg.Id, ex);
    }

    // get all the streams we are interested in
    SegmentStream locationStream = null;
    SegmentStream altitudeStream = null;
    SegmentStream distanceStream = null;

    locationStream = SegmentStream.GetStream(altitude, StreamType.LatLng);
    altitudeStream = SegmentStream.GetStream(altitude, StreamType.Altitude);
    distanceStream = SegmentStream.GetStream(altitude, StreamType.Distance);

    // grab user's best time
    List<SegmentStream> pr = null;
    var athlete = HttpContext.Current.Request.Cookies["athlete"];
    if (athlete != null)
    {
      try
      {
        pr = StravaBaseHandler.GetSegmentPr(seg.Id.ToString(), athlete.Value);
      }
      catch
      {
        // do nothing
      }
    }

    // Generate some FIT messages
    // Every FIT file MUST contain a 'File ID' message as the first message
    var fileIdMesg = new FileIdMesg(); 
    var records = new List<SegmentPointMesg>();

    fileIdMesg.SetType(Dynastream.Fit.File.Segment);
    fileIdMesg.SetManufacturer(Manufacturer.Strava);  // Types defined in the profile are available
    fileIdMesg.SetProduct(65534);
    fileIdMesg.SetTimeCreated(new Dynastream.Fit.DateTime(System.DateTime.Now));
    fileIdMesg.SetSerialNumber(1);
    fileIdMesg.SetNumber(1);

    var fileCreator = new FileCreatorMesg();
    fileCreator.SetHardwareVersion(0);
    fileCreator.SetSoftwareVersion(0);

    // segment ID
    var segmentId = new SegmentIdMesg();
    segmentId.SetName(seg.Name);
    segmentId.SetEnabled(Bool.True);

    if (seg.ActivityType == "Run")
      segmentId.SetSport(Sport.Running);
    else
      segmentId.SetSport(Sport.Cycling);

    byte prIndex = 0;
    byte goalIndex = 1;
    byte rivalIndex = 2;
    byte challengerIndex = 3;
    byte komIndex = 4;
    byte qomIndex = 5;

    if (!HasPr(pr, seg))
    {
      goalIndex--;
      rivalIndex--;
      challengerIndex--;
      komIndex--;
      qomIndex--;
    }

    if (goal == 0)
    {
      rivalIndex--;
      challengerIndex--;
      komIndex--;
      qomIndex--;
    }

    if (rival == 0)
    {
      challengerIndex--;
      komIndex--;
      qomIndex--;
    }

    if (challenger == 0)
    {
      komIndex--;
      qomIndex--;
    }

    if (seg.KOM() == 0)
    {
      qomIndex--;
    }

    segmentId.SetSelectionType(SegmentSelectionType.Starred);
    segmentId.SetUuid(Guid.NewGuid().ToByteArray());
    if (HasPr(pr, seg))
      segmentId.SetDefaultRaceLeader(prIndex);

    if (seg.Map.Polyline == "")
      throw new Exception("The segment has no map data (which is somewhat unexpected), " + 
        "I can't generate the FIT file");

    var points = PolylineDecoder.Decode(seg.Map.Polyline);

    // figure out SW and NE
    double swLat = 1000;
    double swLong = 1000;
    double neLat = -1000;
    double neLong = -1000;
    foreach (var pt in points)
    {
      swLat = Math.Min(swLat, pt.Latitude);
      swLong = Math.Min(swLong, pt.Longitude);
      neLat = Math.Max(neLat, pt.Latitude);
      neLong = Math.Max(neLong, pt.Longitude);
    }

    // segment info
    var lap = new SegmentLapMesg();
    lap.SetUuid(Guid.NewGuid().ToByteArray());
    lap.SetTotalDistance(seg.Distance);
    lap.SetTotalAscent((ushort)seg.TotalElevationGain);
    lap.SetSwcLat(LatOrLngToSemicircle(swLat));
    lap.SetSwcLong(LatOrLngToSemicircle(swLong));
    lap.SetNecLat(LatOrLngToSemicircle(neLat));
    lap.SetNecLong(LatOrLngToSemicircle(neLong));
    lap.SetMessageIndex(1);
    lap.SetStartPositionLat(LatOrLngToSemicircle(points[0].Latitude));
    lap.SetStartPositionLong(LatOrLngToSemicircle(points[0].Longitude));
    lap.SetEndPositionLat(LatOrLngToSemicircle(points[points.Count - 1].Latitude));
    lap.SetEndPositionLong(LatOrLngToSemicircle(points[points.Count - 1].Longitude));

    // goal entry
    var goalLeaderboard = GetLeaderboard(goal, goalIndex, SegmentLeaderboardType.Goal, goalName);
    var rivalLeaderboard = GetLeaderboard(rival, rivalIndex, SegmentLeaderboardType.Rival, rivalName);
    var challengerLeaderboard = 
      GetLeaderboard(challenger, challengerIndex, SegmentLeaderboardType.Challenger, challengerName);
    var komLeaderboard = GetLeaderboard(seg.KOM(), komIndex, SegmentLeaderboardType.Kom, "");
    var qomLeaderboard = GetLeaderboard(seg.QOM(), qomIndex, SegmentLeaderboardType.Qom, "");

    SegmentStream prDistanceStream = null;
    SegmentStream prTimeStream = null;
    if (pr != null)
    {
      prDistanceStream = SegmentStream.GetStream(pr, StreamType.Distance);
      prTimeStream = SegmentStream.GetStream(pr, StreamType.Time);
    }

    SegmentLeaderboardEntryMesg prLeaderboard = null;
    if (HasPr(pr, seg))
    {
      prLeaderboard = new SegmentLeaderboardEntryMesg();
      prLeaderboard.SetMessageIndex(prIndex);
      var prTime = seg.AthleteSegmentStats.PrElapsedTime;
      prLeaderboard.SetSegmentTime(prTime);
      prLeaderboard.SetType(SegmentLeaderboardType.Pr);
    }

    for (var i = 0; i < locationStream.Data.Count; i++)
    {
      var newRecord = new SegmentPointMesg();
      var latLng = locationStream.Data[i];
      if (latLng != null)
      {
        var intLat = LatOrLngToSemicircle(Convert.ToDouble(((JArray)(latLng)).First));
        newRecord.SetPositionLat(intLat);
        var intLng = LatOrLngToSemicircle(Convert.ToDouble(((JArray)(latLng)).Last));
        newRecord.SetPositionLong(intLng);
      }

      if (altitudeStream != null)
        newRecord.SetAltitude(Convert.ToSingle(altitudeStream.Data[i]));
      var currentDistance = Convert.ToSingle(distanceStream.Data[i]);
      newRecord.SetDistance(currentDistance);
      newRecord.SetMessageIndex((ushort)i);

      if (HasPr(pr, seg))
      {
        if (pr != null)
        {
          // add PR time
          // find index of the PR item that is at or beyond current distance
          var pos = prDistanceStream.Data.Count - 1;
          for (var j = 0; j < prDistanceStream.Data.Count; j++)
          {
            if (Convert.ToSingle(prDistanceStream.Data[j]) - 
              Convert.ToSingle(prDistanceStream.Data[0]) >= currentDistance)
            {
              pos = j;
              break;
            }
          }
          // find time at that distance
          if (pos > 0)
          {
            var prStartDistance = Convert.ToSingle(prDistanceStream.Data[pos - 1]) - 
              Convert.ToSingle(prDistanceStream.Data[0]);
            var prEndDistance = Convert.ToSingle(prDistanceStream.Data[pos]) - 
              Convert.ToSingle(prDistanceStream.Data[0]);
            var fraction = (currentDistance - prStartDistance) / (prEndDistance - prStartDistance);

            var prTime = Convert.ToSingle(prTimeStream.Data[pos - 1]) + fraction * 
              (Convert.ToSingle(prTimeStream.Data[pos]) - Convert.ToSingle(prTimeStream.Data[pos - 1]));

            newRecord.SetLeaderTime(prIndex, 
              (float)Math.Floor(prTime - Convert.ToSingle(prTimeStream.Data[0])));
          }
          else
          {
            newRecord.SetLeaderTime(prIndex, 0);
          }
        }
        else
        {
          AddLeaderEntry(newRecord, seg.AthleteSegmentStats.PrElapsedTime.Value, currentDistance, 
            seg.Distance, prIndex);
        }
      }

      // add goal time
      AddLeaderEntry(newRecord, goal, currentDistance, seg.Distance, goalIndex);
      AddLeaderEntry(newRecord, rival, currentDistance, seg.Distance, rivalIndex);
      AddLeaderEntry(newRecord, challenger, currentDistance, seg.Distance, challengerIndex);
      AddLeaderEntry(newRecord, seg.KOM(), currentDistance, seg.Distance, komIndex);
      AddLeaderEntry(newRecord, seg.QOM(), currentDistance, seg.Distance, qomIndex);

      records.Add(newRecord);
    }

    // Create file encode object
    var encodeDemo = new Encode(ProtocolVersion.V20);

    using (var fitDest = new MemoryStream())
    {

      // Write our header
      encodeDemo.Open(fitDest);

      // Encode each message, a definition message is automatically generated and output if necessary
      encodeDemo.Write(fileIdMesg);
      encodeDemo.Write(fileCreator);
      encodeDemo.Write(segmentId);
      if (prLeaderboard != null)
        encodeDemo.Write(prLeaderboard);
      if (goal != 0)
        encodeDemo.Write(goalLeaderboard);
      if (rival != 0)
        encodeDemo.Write(rivalLeaderboard);
      if (challenger != 0)
        encodeDemo.Write(challengerLeaderboard);
      if (seg.KOM() != 0)
        encodeDemo.Write(komLeaderboard);
      if (seg.QOM() != 0)
        encodeDemo.Write(qomLeaderboard);

      encodeDemo.Write(lap);
      encodeDemo.Write(records);
      encodeDemo.Close();

      fitDest.Flush();
      fitDest.Position = 0;
      return fitDest.ToArray();
    }
  }
}