Stretch Tracker: Advanced Technical Architecture and Implementation

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net9.0-windows</TargetFramework>
    <UseWPF>true</UseWPF>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Hardcodet.NotifyIcon.Wpf" Version="2.0.1" />
    <PackageReference Include="OpenCvSharp4" Version="4.10.0.20241108" />
    <PackageReference Include="TensorFlow.NET" Version="0.150.0" />
    <PackageReference Include="Microsoft.Data.Sqlite" Version="9.0.0" />
  </ItemGroup>
</Project>

private async Task<bool> ProcessFrameForMotionAsync(Mat frame)
{
    // Preprocessing pipeline
    using (Mat grayFrame = new Mat())
    {
        // Convert to grayscale for consistent processing
        Cv2.CvtColor(frame, grayFrame, ColorConversionCodes.BGR2GRAY);

        // Noise reduction using Gaussian blur
        Cv2.GaussianBlur(grayFrame, grayFrame, new Size(21, 21), 0);

        // Frame difference computation
        using (Mat diff = new Mat())
        {
            Cv2.Absdiff(grayFrame, _previousFrame, diff);

            // Binary thresholding to isolate significant movements
            Cv2.Threshold(diff, diff, 30, 255, ThresholdTypes.Binary);

            // Morphological operations for noise filtering
            var kernel = Cv2.GetStructuringElement(MorphShapes.Rect, new Size(5, 5));
            Cv2.Erode(diff, diff, kernel, iterations: 1);
            Cv2.Dilate(diff, diff, kernel, iterations: 2);

            // Motion quantification
            double motionAmount = Cv2.Sum(diff)[0];

            // Adaptive thresholding
            bool isSignificantMotion = motionAmount > _dynamicMotionThreshold;

            return isSignificantMotion;
        }
    }
}

public class PoseDetectionModel
{
    private TF.Session _poseDetectionSession;
    private const int KeypointCount = 17;

    public async Task<PoseDetectionResult> DetectPose(Mat frame)
    {
        // Convert OpenCV Mat to TensorFlow tensor
        var inputTensor = ConvertMatToTensor(frame);

        // Run inference through neural network
        var outputs = _poseDetectionSession.Run(
            new[] { _graph.GetTensorByName("input_tensor") },
            new[] { inputTensor },
            new[] {
                _graph.GetTensorByName("keypoints_output"),
                _graph.GetTensorByName("confidence_output")
            }
        );

        // Process detected keypoints
        var keypointsRaw = outputs[0];
        var confidenceScores = outputs[1];

        return ProcessPoseKeypoints(keypointsRaw, confidenceScores);
    }

    private PoseDetectionResult ProcessPoseKeypoints(Tensor keypointsTensor, Tensor confidenceTensor)
    {
        var keypoints = new List<Keypoint>();

        for (int i = 0; i \< KeypointCount; i++)
        {
            var x = keypointsTensor[0, i, 0];
            var y = keypointsTensor[0, i, 1];
            var confidence = confidenceTensor[0, i];

            keypoints.Add(new Keypoint(
                x, y,
                (KeypointType)i,
                confidence
            ));
        }

        return new PoseDetectionResult(keypoints);
    }
}

// Supporting data structures
public enum KeypointType
{
    Nose, Neck, RightShoulder, RightElbow, // ... and so on
}

public record Keypoint(
    float X,
    float Y,
    KeypointType Type,
    float Confidence
);

public record PoseDetectionResult(List<Keypoint> Keypoints)
{
    public bool IsValidStretch()
    {
        // Complex validation logic
        // Analyze keypoint relationships
        // Determine if current pose represents a stretch
    }
}

public class DatabaseManager
{
    private readonly string _connectionString;

    public void InitializeDatabase()
    {
        using var connection = new SqliteConnection(_connectionString);
        connection.Open();

        // Create stretching sessions table
        using var command = connection.CreateCommand();
        command.CommandText = @"
            CREATE TABLE IF NOT EXISTS StretchSessions (
                Id INTEGER PRIMARY KEY AUTOINCREMENT,
                Date TEXT NOT NULL,
                Completed INTEGER NOT NULL,
                Duration INTEGER NOT NULL
            )";
        command.ExecuteNonQuery();
    }

    public void RecordStretchSession(bool completed, int durationSeconds)
    {
        using var connection = new SqliteConnection(_connectionString);
        connection.Open();

        using var command = connection.CreateCommand();
        command.CommandText = @"
            INSERT INTO StretchSessions (Date, Completed, Duration)
            VALUES (@date, @completed, @duration)";

        command.Parameters.AddWithValue("@date", DateTime.Now.ToString("yyyy-MM-dd"));
        command.Parameters.AddWithValue("@completed", completed ? 1 : 0);
        command.Parameters.AddWithValue("@duration", durationSeconds);

        command.ExecuteNonQuery();
    }

    public int GetCurrentStreak()
    {
        int streak = 0;
        DateTime currentDate = DateTime.Now.Date;

        using var connection = new SqliteConnection(_connectionString);
        connection.Open();

        // Complex streak calculation logic
        // Checks consecutive days of completed stretches
        // ...

        return streak;
    }
}

public class AppSettings
{
    // Configurable parameters
    public int NotificationIntervalMinutes { get; set; } = 120;
    public int RequiredStretchCount { get; set; } = 5;
    public float PoseDetectionThreshold { get; set; } = 0.7f;

    public void Save()
    {
        // JSON serialization of settings
        var json = JsonSerializer.Serialize(this,
            new JsonSerializerOptions { WriteIndented = true });
        File.WriteAllText(_settingsPath, json);
    }

    public static AppSettings Load()
    {
        // Robust settings loading with fallback
        try
        {
            var json = File.ReadAllText(_settingsPath);
            return JsonSerializer.Deserialize<AppSettings>(json)
                   ?? new AppSettings();
        }
        catch
        {
            return new AppSettings(); // Default configuration
        }
    }
}