compare_surface_elevations

Code Template

var surfaceAHandle = "REFERENCE_SURFACE_HANDLE";
var surfaceBHandle = "COMPARISON_SURFACE_HANDLE";
var samplePoints = new (double x, double y)[] { };
var tolerance = double.NaN;
var detailLimit = 50;
var isHandle = new Func<string, bool>(value =>
    !string.IsNullOrWhiteSpace(value)
    && System.Text.RegularExpressions.Regex.IsMatch(value, "^[0-9A-Fa-f]{1,16}$")
    && long.TryParse(value, System.Globalization.NumberStyles.HexNumber,
        System.Globalization.CultureInfo.InvariantCulture, out var parsed) && parsed > 0);
if (!isHandle(surfaceAHandle) || !isHandle(surfaceBHandle)
    || surfaceAHandle.Equals(surfaceBHandle, StringComparison.OrdinalIgnoreCase))
    return new { success = false, error = "Configure two distinct positive hexadecimal TIN surface handles." };
if (samplePoints == null || samplePoints.Length < 1 || samplePoints.Length > 2000
    || samplePoints.Any(p => !Double.IsFinite(p.x) || !Double.IsFinite(p.y))
    || samplePoints.Distinct().Count() != samplePoints.Length)
    return new { success = false, error = "Supply 1..2000 distinct finite XY sample points." };
if (!Double.IsFinite(tolerance) || tolerance < 0 || detailLimit < 1 || detailLimit > 200)
    return new { success = false, error = "Tolerance must be finite/nonnegative and detailLimit must be 1..200." };

// Pure statistics also support host-free arithmetic verification.
var summarize = new Func<double[], object>(values => {
    if (values.Length == 0) return null;
    if (values.Any(v => !Double.IsFinite(v))) throw new InvalidOperationException("Nonfinite differences cannot enter statistics.");
    var absolute = values.Select(Math.Abs).OrderBy(v => v).ToArray();
    var signed = values.OrderBy(v => v).ToArray();
    var scale = absolute[absolute.Length - 1];
    var normalized = values.Select(v => scale == 0 ? 0 : v / scale).ToArray();
    var normalizedMean = normalized.Average();
    var mean = normalizedMean * scale;
    var rmse = Math.Sqrt(normalized.Average(v => v * v)) * scale;
    var standardDeviation = Math.Sqrt(normalized.Average(v => (v - normalizedMean) * (v - normalizedMean))) * scale;
    var mae = (scale == 0 ? 0 : absolute.Average(v => v / scale)) * scale;
    var percentile = new Func<double[], double, double>((sorted, fraction) => {
        var position = (sorted.Length - 1) * fraction;
        var lo = (int)Math.Floor(position);
        var hi = (int)Math.Ceiling(position);
        var f = position - lo;
        return sorted[lo] * (1 - f) + sorted[hi] * f;
    });
    if (!Double.IsFinite(mean) || !Double.IsFinite(rmse) || !Double.IsFinite(standardDeviation) || !Double.IsFinite(mae))
        throw new InvalidOperationException("Statistics overflowed; no misleading finite result is returned.");
    var within = absolute.Count(v => v <= tolerance);
    return new {
        count = values.Length, mean, rmse, mae, standardDeviation,
        min = signed[0], max = signed[signed.Length - 1], median = percentile(signed, 0.5),
        p95Absolute = percentile(absolute, 0.95), withinTolerance = within,
        outsideTolerance = values.Length - within, withinTolerancePercent = 100.0 * within / values.Length
    };
});

// Host access starts here.
ObjectId aId;
ObjectId bId;
try
{
    aId = Database.GetObjectId(false, new Handle(Convert.ToInt64(surfaceAHandle, 16)), 0);
    bId = Database.GetObjectId(false, new Handle(Convert.ToInt64(surfaceBHandle, 16)), 0);
}
catch { return new { success = false, error = "A requested surface handle does not resolve in this drawing." }; }
if (aId == bId) return new { success = false, error = "The two handles resolve to the same surface." };
var surfaceA = Transaction.GetObject(aId, OpenMode.ForRead) as TinSurface;
var surfaceB = Transaction.GetObject(bId, OpenMode.ForRead) as TinSurface;
if (surfaceA == null || surfaceB == null || surfaceA.IsErased || surfaceB.IsErased
    || surfaceA is TinVolumeSurface || surfaceB is TinVolumeSurface)
    return new { success = false, error = "Two existing non-volume TIN surfaces are required." };
foreach (var surface in new[] { surfaceA, surfaceB })
    if (surface.IsReferenceObject && (!surface.IsReferenceValid || surface.IsReferenceStale || !surface.IsReferencedSourceExisting))
        return new { success = false, error = "A reference surface is invalid, stale or missing its source." };

var differences = new List<double>();
var rows = new List<object>();
var missingA = 0;
var missingB = 0;
var lookupErrors = 0;
var nonfiniteDifferences = 0;
var lookup = new Func<TinSurface, double, double, (bool available, double z, string status)>((surface, x, y) => {
    try
    {
        var z = surface.FindElevationAtXY(x, y);
        return Double.IsFinite(z) ? (true, z, "available") : (false, 0, "nonfinite_elevation");
    }
    catch (Autodesk.Civil.PointNotOnEntityException) { return (false, 0, "outside_surface"); }
    catch { lookupErrors++; return (false, 0, "lookup_error"); }
});
foreach (var p in samplePoints)
{
    var a = lookup(surfaceA, p.x, p.y);
    var b = lookup(surfaceB, p.x, p.y);
    if (!a.available) missingA++;
    if (!b.available) missingB++;
    double? difference = null;
    if (a.available && b.available)
    {
        var delta = b.z - a.z;
        if (Double.IsFinite(delta)) { difference = delta; differences.Add(delta); }
        else nonfiniteDifferences++;
    }
    if (rows.Count < detailLimit)
        rows.Add(new {
            x = p.x, y = p.y,
            elevationA = a.available ? (double?)a.z : null,
            elevationB = b.available ? (double?)b.z : null,
            statusA = a.status, statusB = b.status, difference
        });
}
return new {
    success = true, surfaceA = new { handle = surfaceA.Handle.ToString(), name = surfaceA.Name },
    surfaceB = new { handle = surfaceB.Handle.ToString(), name = surfaceB.Name },
    differenceDefinition = "B minus A", units = CivilDoc.Settings.DrawingSettings.UnitZoneSettings.DrawingUnits.ToString(),
    tolerance, total = samplePoints.Length, valid = differences.Count,
    missingA, missingB, lookupErrors, nonfiniteDifferences,
    coveragePercent = 100.0 * differences.Count / samplePoints.Length,
    returned = rows.Count, truncated = samplePoints.Length > rows.Count, limit = detailLimit,
    statistics = summarize(differences.ToArray()), samples = rows
};