intro

report.qmd

@@ -18,8 +18,54 @@ execute:
   cache: true
 ---
 
+## Introduction
+
+Orbital debris is a form of pollution that is growing at an exponential pace and puts current and
+future space infrastructure at risk. Satellites are critical to military, commercial, and civil
+operations. Unfortunately, the space that debris occupies is increasingly becoming more crowded and
+dangerous, potentially leading to a cascade event that could turn orbit around the Earth into an
+unusable wasteland for decades unless proper mitigation is not introduced. Existing models employed
+by NASA rely on a dataset created from 2D images and are missing many crucial features required for
+correctly modeling the space debris environment. This approach aims to use high-resolution 3D
+scanning to fully capture the geometry of a piece of debris and allow a more advanced analysis of
+each piece. Coupled with machine learning methods, the scans will allow advances to the current
+cutting edge. Physical and photograph-based measurements are time-consuming, hard to replicate, and
+lack precision. 3D scanning allows much more advanced and accurate analysis of each debris sample,
+focusing on properties such as moment of inertia, cross-section, and drag. Once the characteristics
+of space debris are more thoroughly understood, we can begin mitigating the creation and danger of
+future space debris by implementing improved satellite construction methods and more advanced debris
+avoidance measures.
+
+### Current Progress
+
+This project aims to fix very difficult issues, and although great progress has been made there is
+still plenty of work to be done. Currently, algorithms have been made that are capable of getting
+many key features from solid ^[A mesh with a surface that is fully closed and has no holes in its
+geometry.] models that are in the `stl` format. The algorithm for processing the 3D meshes is
+implemented in the Julia programming language. Syntactically the language is very similar to Python
+and Matlab. Julia was chosen because it is nearly as performant as compiled languages like C, while
+still having tooling geared towards engineers and scientists. The code produces a struct with all
+the calculated properties as follows:
+
+```julia
+struct Properties
+    # Volume of the mesh
+    volume::Float64
+    # Center of gravity, meshes are not always center at [0,0,0]
+    center_of_gravity::Vector{Float64}
+    # Moment of inertia tensor
+    inertia::Matrix{Float64}
+    # Surface area of mesh
+    surface_area::Float64
+    # Average orthogonal dimension of the mesh
+    characteristic_length::Float64
+    # Projected length of farthest two points in [x,y,z] directions
+    solidbody_values::Vector{Float64}
+end
+```
+
 ```{julia}
-#| code-fold: true
+#| echo: false
 #| output: false
 
 using FileIO
@@ -29,8 +75,11 @@ using stlProcess
 
 using CSV
 using DataFrames
+using Plots
+theme(:ggplot2)
 
 using LinearAlgebra
+using Statistics
 ```
 
 ```{julia}
@@ -40,7 +89,8 @@ using LinearAlgebra
 # local path to https://gitlab.com/orbital-debris-research/fake-satellite-dataset
 dataset_path = raw"C:\Coding\fake-satellite-dataset"
 
-folders = ["1_5U", "assembly1", "cubesat"]
+# folders = ["1_5U", "assembly1", "cubesat"]
+folders = ["cubesat"]
 
 df = DataFrame(;
     surface_area=Float64[],
@@ -55,8 +105,9 @@ df = DataFrame(;
 ```
 
 ```{julia}
+#| output: false
+
 for path in dataset_path * "\\" .* folders
-    println("Processing Path: ", path)
     Threads.@threads for file in readdir(path)
         stl = load(path * "\\" * file)
         scale = find_scale(stl)
@@ -64,21 +115,44 @@ for path in dataset_path * "\\" .* folders
 
         eigs = eigvals(props.inertia)
         sort_index = sortperm(eigs)
-        Ix, Iy, Iz = eigs[sort_index]
+        I1, I2, I3 = eigs[sort_index]
         sbx, sby, sbz = props.sb_values[sort_index]
 
         push!(
             df,
-            [props.surface_area, props.characteristic_length, sbx, sby, sbz, Ix, Iy, Iz],
+            [props.surface_area, props.characteristic_length, sbx, sby, sbz, I3, I2, I1],
         )
     end
 end
 ```
 
+:::{.column-body-outset}
+
 ```{julia}
+#| echo: false
+
 describe(df)
 ```
 
+:::
+
+```{julia}
+S = cov(Matrix(df))
+
+eig_vals = eigvals(S);
+
+# sorting eigenvalues from largest to smallest
+sort_index = sortperm(eig_vals; rev=true)
+
+lambda = eig_vals[sort_index]
+names_sorted = names(df)[sort_index]
+
+lambda_ratio = cumsum(lambda) ./ sum(lambda)
+
+plot(lambda_ratio, marker=:x)
+xticks!(sort_index,names(df), xrotation = 15)
+```
+
 ## Gathering Data
 
 To get started on the project before any scans of the actual debris are made available, I opted to
@@ -165,7 +239,7 @@ eig_vals = eig(S);
 lambda_ratio = cumsum(lambda) ./ sum(lambda)
 ```
 
-Then plotting `lambda_ratio`, which is the `cumsum`/`sum` produces the following plot:
+Then plotting `lambda_ratio`, which is the `cumsum ./ sum` produces the following plot:
 
 ![PCA Plot](Figures/pca.png)