orbx 1.0.0__py3-none-any.whl

orbx/density/Density.py

@@ -0,0 +1,74 @@
+import contextlib
+import io
+from orbx.clustering.Schema import Schema
+from orbx.synthetic_orbits.orbit_finder.DMT import VectorizedKeplerianOrbit
+import pandas as pd
+
+def _cluster_density(df_cluster: pd.DataFrame, verbose: bool = False) -> float:
+    """Calculate variance-style density for one cluster DataFrame."""
+    cluster_size = len(df_cluster)
+    if cluster_size < 2:
+        return 0.0
+
+    # Import here is because of Orekit dependency
+    # Keeping it at top level requires an orekit installation even if you don't use
+    # it directly.
+    from orbx.synthetic_orbits.orbit_finder.frechet_orbit_finder import frechet_orbit
+
+    if verbose:
+        frechet_orbit_result = frechet_orbit(df_cluster)
+    else:
+        # Suppress verbose optimizer logs unless explicitly requested.
+        with contextlib.redirect_stdout(io.StringIO()):
+            frechet_orbit_result = frechet_orbit(df_cluster)
+    if frechet_orbit_result is None:
+        raise ValueError("Unable to compute Fréchet mean orbit for cluster.")
+
+    if isinstance(frechet_orbit_result, pd.DataFrame):
+        frechet_mean_orbit = frechet_orbit_result.iloc[-1]
+    else:
+        frechet_mean_orbit = frechet_orbit_result
+
+    if "line1" not in df_cluster.columns or "line2" not in df_cluster.columns:
+        raise ValueError("df_cluster must include 'line1' and 'line2' columns.")
+    if "line1" not in frechet_mean_orbit or "line2" not in frechet_mean_orbit:
+        raise ValueError("Fréchet mean orbit must include 'line1' and 'line2'.")
+
+    mean_orbit = VectorizedKeplerianOrbit(
+        pd.Series([frechet_mean_orbit["line1"]]).values,
+        pd.Series([frechet_mean_orbit["line2"]]).values,
+    )
+    cluster_orbits = VectorizedKeplerianOrbit(
+        df_cluster["line1"].values,
+        df_cluster["line2"].values,
+    )
+
+    distances = VectorizedKeplerianOrbit.DistanceMetric(mean_orbit, cluster_orbits).ravel()
+    total_squared_distance = float((distances**2).sum())
+
+    variance = total_squared_distance / (cluster_size - 1)
+    return float(variance)
+
+def density(df: pd.DataFrame, label_column: str = "label", verbose: bool = False) -> pd.DataFrame:
+    """
+    Compute density per label group and return a summary DataFrame.
+
+    Arguments
+    _______________
+    df : pd.DataFrame
+        Each row should contain the satellite TLE and the cluster label it belongs to (at a minimum). Your df should contain
+        a "line1", "line2", and "label" in each row, corresponding to a satellite. If missing label, 
+        use cluster() to assign a label.
+    label_column : str
+        Name of the cluster label column. Defaults to "label".
+    verbose : bool
+        If True, print optimizer diagnostics while computing Fréchet means.
+    """
+    Schema().validate(df)
+
+    results = []
+    for label, group in df.groupby(label_column, dropna=False):
+        cluster_density = _cluster_density(group, verbose=verbose)
+        results.append({"label": label, "density": cluster_density})
+
+    return pd.DataFrame(results)

orbx/density/__init__.py

@@ -0,0 +1,3 @@
+from .Density import density
+
+__all__ = ["density"]

orbx/density/tools/DMT.py

@@ -0,0 +1,49 @@
+from sgp4.api import Satrec
+import numpy as np
+
+class VectorizedKeplerianOrbit:
+    def __init__(self, line1_array, line2_array=None):
+        if line2_array is not None:
+            satellites = np.vectorize(Satrec.twoline2rv)(line1_array, line2_array)
+            radius_earth_km = satellites[0].radiusearthkm
+
+            self.a = np.array([sat.a * radius_earth_km for sat in satellites])
+            self.e = np.array([sat.ecco for sat in satellites])
+            self.i = np.array([sat.inclo for sat in satellites])
+            self.omega = np.array([sat.argpo for sat in satellites])
+            self.raan = np.array([sat.nodeo for sat in satellites])
+            self.q = np.array([sat.altp * radius_earth_km for sat in satellites])
+            self.p = self.a * (1 - self.e ** 2)
+        else:
+            self.a, self.e, self.i, self.omega, self.raan, self.q, self.p = line1_array
+
+    def __getitem__(self, key):
+        return VectorizedKeplerianOrbit(
+            np.array([self.a[key], self.e[key], self.i[key], self.omega[key], self.raan[key], self.q[key], self.p[key]])
+        )
+
+    @staticmethod
+    def DistanceMetric(orbit1, orbit2):
+        w1 = orbit1.omega[:, np.newaxis]
+        w2 = orbit2.omega[np.newaxis, :]
+
+        c1 = np.cos(orbit1.i)[:, np.newaxis]
+        c2 = np.cos(orbit2.i)[np.newaxis, :]
+
+        s1 = np.sin(orbit1.i)[:, np.newaxis]
+        s2 = np.sin(orbit2.i)[np.newaxis, :]
+
+        delta = orbit1.raan[:, np.newaxis] - orbit2.raan[np.newaxis, :]
+        cosI = c1 * c2 + s1 * s2 * np.cos(delta)
+
+        cosP = s1 * s2 * np.sin(w1) * np.sin(w2) + \
+               (np.cos(w1) * np.cos(w2) + c1 * c2 * np.sin(w1) * np.sin(w2)) * np.cos(delta) + \
+               (c2 * np.cos(w1) * np.sin(w2) - c1 * np.sin(w1) * np.cos(w2)) * np.sin(delta)
+
+        q = (1 + orbit1.e[:, np.newaxis]**2) * orbit1.p[:, np.newaxis] + \
+            (1 + orbit2.e[np.newaxis, :]**2) * orbit2.p[np.newaxis, :] - \
+            2 * np.sqrt(orbit1.p[:, np.newaxis] * orbit2.p[np.newaxis, :]) * \
+            (cosI + orbit1.e[:, np.newaxis] * orbit2.e[np.newaxis, :] * cosP)
+
+        return q
+        

orbx/density/tools/distance_matrix.py

@@ -0,0 +1,147 @@
+from orbx.tools.DMT import VectorizedKeplerianOrbit
+import pickle
+from math import pi
+import pandas as pd 
+import numpy as np
+
+"""
+This file is used to process the given elset data into a distance matrix and save
+to disk.
+"""
+
+def get_distance_matrix(df, save=False):
+        
+    line1 = df['line1'].values
+    line2 = df['line2'].values
+    
+    print("Calculating orbits")
+    orbits = VectorizedKeplerianOrbit(line1, line2)
+    
+    print("Calculating distances")
+    distance_matrix = VectorizedKeplerianOrbit.DistanceMetric(orbits, orbits)
+    if save:
+        print("Saving distance matrix to disk...") 
+        with open(f'data/distance_matrix.pkl', 'wb') as f:
+            pickle.dump(distance_matrix, f)
+    
+    key = get_key(df, save=save)
+
+    if _validate_matrix(distance_matrix):
+        return distance_matrix, key
+
+def _validate_matrix(distance_matrix):
+    """
+    Validate and sanitize distance matrix.
+    Modifies the matrix in place to fix common issues.
+    """
+    # check if distance matrix is square
+    if distance_matrix.shape[0] != distance_matrix.shape[1]:
+        raise ValueError("Distance matrix is not square")
+    
+    # Sanitize diagonal first (ensure it's zero)
+    np.fill_diagonal(distance_matrix, 0)
+    
+    # Sanitize any negative values (numerical errors)
+    if np.any(distance_matrix < 0):
+        num_negatives = np.sum(distance_matrix < 0)
+        min_negative = distance_matrix[distance_matrix < 0].min()
+        print(f"  Found {num_negatives} negative values (min: {min_negative:.2e}), setting to zero")
+        distance_matrix[distance_matrix < 0] = 0
+    
+    # check if distance matrix is symmetric
+    if not np.allclose(distance_matrix, distance_matrix.T):
+        print("  WARNING: Matrix not symmetric. Symmetrizing...")
+        distance_matrix[:] = (distance_matrix + distance_matrix.T) / 2
+    
+    print("Distance matrix is valid")
+    return True
+    
+def get_key(df, save=False):
+    """These dictionaries map satellite numbers to their
+        index in the distance matrix and vice versa"""
+        
+    df = df['satNo'].unique()
+    
+    satNo_idx_dict = {}
+    idx_satNo_dict = {}
+    
+    for i, satNo in enumerate(df):
+        idx_satNo_dict[i] = satNo
+        satNo_idx_dict[satNo] = i
+    
+    if save:
+        # save both as pkl
+        with open(f'data/satNo_idx_dict.pkl', 'wb') as f:
+            pickle.dump(satNo_idx_dict, f)
+        
+        with open(f'data/idx_satNo_dict.pkl', 'wb') as f:
+            pickle.dump(idx_satNo_dict, f)
+            
+    # return both dictionaries
+    return {'satNo_idx_dict': satNo_idx_dict, 'idx_satNo_dict': idx_satNo_dict} 
+        
+if __name__ == '__main__':
+    inclination_range = (0, 180)  # degrees
+    apogee_range = (0, 2000)   # kilometers
+    # get all satellites from celestrak data and create distance matrix
+    celestrak_tles_path = 'data/3le'
+    data = []
+    
+    with open(celestrak_tles_path, 'r') as f:
+        lines = f.readlines()
+    
+    earth_radius = 6371000  # meters
+    GM_earth = 3.986004418e14  # m^3/s^2
+    seconds_in_day = 86400  # seconds per day
+   
+    for i in range(0, len(lines), 3):
+        if i + 2 < len(lines):
+            name = lines[i].strip()
+            line1 = lines[i + 1].strip()
+            line2 = lines[i + 2].strip()
+           
+            if not (line1.startswith('1 ') and line2.startswith('2 ')):
+                continue
+               
+            sat_no = line1[2:7].strip()
+           
+            inclination = float(line2[8:16].strip())
+           
+            # Extract mean motion (revolutions per day)
+            mean_motion = float(line2[52:63].strip())
+           
+            # Extract eccentricity (columns 27-33 in standard TLE format)
+            eccentricity = float("0." + line2[26:33].strip())
+           
+            # Calculate angular velocity n in radians per second
+            n = mean_motion * 2 * pi / seconds_in_day
+           
+            # Calculate semi-major axis a in meters
+            a = (GM_earth / (n ** 2)) ** (1/3)
+           
+            # Calculate apogee in kilometers
+            apogee = (a * (1 + eccentricity) - earth_radius) / 1000
+           
+            data.append({
+                'satNo': sat_no,
+                'line1': line1,
+                'line2': line2,
+                'inclination': inclination,
+                'apogee': apogee
+            })
+    
+    elset_df = pd.DataFrame(data)
+    
+    elset_df['satNo'] = (
+        elset_df['satNo']
+        .astype(str)
+        .str.replace(r"\.0$", "", regex=True)
+        .str.zfill(5)
+    )
+    
+    elset_df = elset_df[
+        (elset_df['inclination'] >= inclination_range[0]) & (elset_df['inclination'] <= inclination_range[1]) &
+        (elset_df['apogee'] >= apogee_range[0]) & (elset_df['apogee'] <= apogee_range[1])
+    ].copy()
+
+    distance_matrix, key = get_distance_matrix(elset_df, save=True)

orbx/synthetic_orbits/DMT.py

@@ -0,0 +1,49 @@
+from sgp4.api import Satrec
+import numpy as np
+
+class VectorizedKeplerianOrbit:
+    def __init__(self, line1_array, line2_array=None):
+        if line2_array is not None:
+            satellites = np.vectorize(Satrec.twoline2rv)(line1_array, line2_array)
+            radius_earth_km = satellites[0].radiusearthkm
+
+            self.a = np.array([sat.a * radius_earth_km for sat in satellites])
+            self.e = np.array([sat.ecco for sat in satellites])
+            self.i = np.array([sat.inclo for sat in satellites])
+            self.omega = np.array([sat.argpo for sat in satellites])
+            self.raan = np.array([sat.nodeo for sat in satellites])
+            self.q = np.array([sat.altp * radius_earth_km for sat in satellites])
+            self.p = self.a * (1 - self.e ** 2)
+        else:
+            self.a, self.e, self.i, self.omega, self.raan, self.q, self.p = line1_array
+
+    def __getitem__(self, key):
+        return VectorizedKeplerianOrbit(
+            np.array([self.a[key], self.e[key], self.i[key], self.omega[key], self.raan[key], self.q[key], self.p[key]])
+        )
+
+    @staticmethod
+    def DistanceMetric(orbit1, orbit2):
+        w1 = orbit1.omega[:, np.newaxis]
+        w2 = orbit2.omega[np.newaxis, :]
+
+        c1 = np.cos(orbit1.i)[:, np.newaxis]
+        c2 = np.cos(orbit2.i)[np.newaxis, :]
+
+        s1 = np.sin(orbit1.i)[:, np.newaxis]
+        s2 = np.sin(orbit2.i)[np.newaxis, :]
+
+        delta = orbit1.raan[:, np.newaxis] - orbit2.raan[np.newaxis, :]
+        cosI = c1 * c2 + s1 * s2 * np.cos(delta)
+
+        cosP = s1 * s2 * np.sin(w1) * np.sin(w2) + \
+               (np.cos(w1) * np.cos(w2) + c1 * c2 * np.sin(w1) * np.sin(w2)) * np.cos(delta) + \
+               (c2 * np.cos(w1) * np.sin(w2) - c1 * np.sin(w1) * np.cos(w2)) * np.sin(delta)
+
+        q = (1 + orbit1.e[:, np.newaxis]**2) * orbit1.p[:, np.newaxis] + \
+            (1 + orbit2.e[np.newaxis, :]**2) * orbit2.p[np.newaxis, :] - \
+            2 * np.sqrt(orbit1.p[:, np.newaxis] * orbit2.p[np.newaxis, :]) * \
+            (cosI + orbit1.e[:, np.newaxis] * orbit2.e[np.newaxis, :] * cosP)
+
+        return q
+        

orbx/synthetic_orbits/__init__.py

@@ -0,0 +1,3 @@
+from orbx.synthetic_orbits.synthetic_orbit import synthetic_orbit
+
+__all__ = ["synthetic_orbit"]

orbx/synthetic_orbits/data_handling/build_czml.py

@@ -0,0 +1,176 @@
+from sgp4.api import Satrec, jday
+import json
+import datetime as dt
+import numpy as np
+from random import random
+from skyfield.api import load
+from orbx.synthetic.orbit_finder.get_optimum_orbit import calculate_average_epoch
+
+ts = load.timescale()
+
+def getPos(dSeconds, satrec, julianDate):
+    
+    fraction = dSeconds / 86400
+    
+    days = 0
+    if fraction > 1:
+        days = int(fraction)
+        fraction -= days
+    
+    return satrec.sgp4(julianDate + days, fraction)[1]
+
+def get_posvcs(TLE_LINE1, TLE_LINE2, epochStr, only_one_period=True):
+    # Initialize satellite with skyfield
+    satrec = Satrec.twoline2rv(TLE_LINE1, TLE_LINE2)
+    
+    # Convert epochStr to skyfield Time
+    epoch_dt = dt.datetime.strptime(epochStr, '%Y-%m-%dT%H:%M:%S.%fZ')
+    year = epoch_dt.year
+    month = epoch_dt.month
+    day = epoch_dt.day
+    hour = epoch_dt.hour
+    minute = epoch_dt.minute
+    second = epoch_dt.second + epoch_dt.microsecond / 1e6  # Include microseconds
+    
+    # Convert epochStr to Julian date
+    jd_epochStr, fr_epochStr = jday(year, month, day, hour, minute, second)
+    
+    mean_motion = satrec.no_kozai # radians per minute
+    periodInMinutes = np.pi * 2  / mean_motion
+    periodInSeconds = int(periodInMinutes * 60)
+    
+    if only_one_period:
+        time_limit = periodInSeconds
+    else:
+        time_limit = 86400
+    
+    stepSeconds = 600
+    
+    positions = []
+    coord_list = []
+    
+    getLat = lambda position: np.degrees(np.arctan2(position[2], np.sqrt(position[0]**2 + position[1]**2)))
+    getLon = lambda position: np.degrees(np.arctan2(position[1], position[0]))
+    getAlt = lambda position: ((np.sqrt(position[0]**2 + position[1]**2 + position[2]**2) - 6371) * 1000)
+    
+    for dSeconds in range(0, time_limit + stepSeconds , stepSeconds):
+        delta_days = dSeconds / 86400.0
+        jd_total = jd_epochStr + fr_epochStr + delta_days
+        jd_int = int(jd_total)
+        fr = jd_total - jd_int
+        
+        position = satrec.sgp4(jd_int, fr)[1]
+        
+        positions.append(position)
+        lat = getLat(position)
+        lon = getLon(position)
+        alt = getAlt(position)
+        coord_list.extend([dSeconds, lon, lat, alt])
+        
+        
+    if only_one_period:
+        lat0 = getLat(positions[0])
+        lon0 = getLon(positions[0])
+        alt0 = getAlt(positions[0])
+        coord_list.extend([periodInSeconds, lon0, lat0, alt0])
+    
+    # if only_one_period:
+    #     coord_list.extend([periodInSeconds, getLon(positions[0]), getLat(positions[0]), getAlt(positions[0])])
+    
+    return positions, coord_list
+
+
+import colorsys
+
+def get_cluster_colors(labels):
+    """
+    Generate a distinct, bright RGBA color for each unique cluster label.
+    Uses HSV color space to space hues evenly, keeping high saturation and value.
+    Noise label (-1) gets grey.
+    """
+    unique_labels = sorted(set(str(l).replace('.0', '') for l in labels))
+    # Remove noise
+    non_noise = [l for l in unique_labels if l != '-1']
+    
+    color_map = {}
+    n = len(non_noise)
+    
+    for idx, label in enumerate(non_noise):
+        # Space hues evenly across the spectrum, skip dark blues/near-black region
+        hue = (idx / max(n, 1)) % 1.0
+        # High saturation and value to avoid dark/muted colors
+        r, g, b = colorsys.hsv_to_rgb(hue, 0.85, 0.95)
+        color_map[label] = [int(r * 255), int(g * 255), int(b * 255), 255]
+    
+    # Noise gets grey
+    color_map['-1'] = [128, 128, 128, 255]
+    
+    return color_map
+
+
+def build_czml(df):
+    
+    epochTime = calculate_average_epoch(df)
+    endTime = epochTime + dt.timedelta(days=65)
+    epochStr, endTimeStr = map(lambda x: x.strftime('%Y-%m-%dT%H:%M:%S.%fZ'), [epochTime, endTime])
+    
+    # Pre-compute color map across all cluster labels in the dataframe
+    color_map = get_cluster_colors(df['label'].tolist())
+    
+    czml = [{'id': 'document', 'version': '1.0'}]
+    
+    for i, row in df.iterrows():
+        
+        _, coordinates = get_posvcs(row['line1'], row['line2'], epochStr)
+        coords = [int(coord) if idx % 4 == 0 else float(coord) 
+                  for idx, coord in enumerate(coordinates)]
+        
+        label_str = str(row['label']).replace('.0', '')
+        
+        # Synthetic orbits override color to distinguish from real satellites
+        if row['satNo'] == '99999':
+            if row['name'] in ('MaximallySeparated', 'Maximally Separated'):
+                color = [255, 255, 255, 255]   # white — maximally separated
+            else:
+                color = [255, 165, 0, 255]     # orange — Fréchet mean
+        else:
+            color = color_map.get(label_str, [0, 255, 0, 255])
+        
+        name = row['name']
+        if name == 'MaximallySeparated':
+            name = 'Maximally Separated'
+        if name == 'Optimized':
+            name = 'Fréchet mean'
+                
+        czml.append({
+            'id': f"{row['satNo']}_{i}",
+            'name': str(name),
+            'availability': f"{epochStr}/{endTimeStr}",
+            'position': {
+                'epoch': epochStr, 
+                'cartographicDegrees': coords, 
+                'interpolationDegree': 5,
+                'interpolationAlgorithm': 'LAGRANGE'
+            },
+            'properties': {
+                'satNo': row['satNo'],
+                'apogee': row['apogee'],
+                'inclination': row['inclination'],
+                'prop_correlated': row['correlated'],
+                'label': label_str,
+                'prop_orbitColor': {"rgba": color}
+            },
+            'point': {
+                'color': {
+                    'rgba': color
+                },
+                'pixelSize': 2
+            }
+        })
+        
+    with open('orbX/output.czml', 'w') as file:
+        json.dump(czml, file, indent=2, separators=(',', ': '))
+
+    
+if __name__ == '__main__':
+    build_czml()

orbx/synthetic_orbits/data_handling/ionop_czml.py

@@ -0,0 +1,95 @@
+import boto3
+import requests
+import time
+
+def ionop_czml():
+   
+    ACCESSTOKEN = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiI5OTMwYjJlMS0yYjBhLTQwMmMtYjJkZi1mZWZiY2RiYTNmN2UiLCJpZCI6MjQwODIwLCJpYXQiOjE3MzgzMDM2ODl9.h1pXOgujWRPoS6ZFc5wL-l5_XJnSyUsPZym3ssZj7TQ'
+    
+    BASEURL     = 'https://api.cesium.com/v1/assets'
+    FILEPATH    = 'orbX/output.czml'
+
+    headers = {'Authorization': f'Bearer {ACCESSTOKEN}'}
+
+    try:
+        postBody = {
+            'name': 'output',
+            'description': "l-dit demo czml file",
+            'type': 'CZML',
+            'options': {
+                'sourceType': 'CZML'
+            }
+        }
+
+        response = requests.post(BASEURL, headers = headers, json = postBody)
+        response.raise_for_status()
+
+        assetId = response.json()['assetMetadata']['id']
+        uploadLocation = response.json().get('uploadLocation', {})
+
+        s3Client = boto3.client(
+            's3',
+            aws_access_key_id     = uploadLocation['accessKey'],
+            aws_secret_access_key = uploadLocation['secretAccessKey'],
+            aws_session_token     = uploadLocation['sessionToken'],
+            endpoint_url          = uploadLocation['endpoint']
+        )
+
+        with open(FILEPATH, 'rb') as f:
+            s3Client.upload_fileobj(f, uploadLocation['bucket'], f"{uploadLocation['prefix']}output.czml")
+
+        print('PASSED')
+
+        onComplete       = response.json().get('onComplete', {})
+        onCompleteURL    = onComplete.get('url')
+        onCompleteMethod = onComplete.get('method')
+        onCompleteFields = onComplete.get('fields')
+
+        response = requests.request(
+            method  = onCompleteMethod,
+            url     = onCompleteURL,
+            headers = headers,
+            json    = onCompleteFields
+        )
+        response.raise_for_status()
+
+        print('PASSED')
+
+        while True:
+            statusResponse = requests.get(BASEURL + '/' + str(assetId), headers = headers)
+            statusResponse.raise_for_status()
+            status = statusResponse.json()['status']
+            if status == 'COMPLETE':
+                print('PASSED')
+                break
+            elif status == 'DATA_ERROR':
+                print('FAILED')
+                break
+            else:
+                print(f"Tiling status: {statusResponse.json()['percentComplete']}")
+                time.sleep(20)
+
+        params = {
+            'sortBy': 'DATE_ADDED',
+            'sortOrder': 'DESC'
+        }
+        response = requests.get(BASEURL, headers = headers, params = params)
+        response.raise_for_status()
+
+        assets = [item['id'] for item in response.json()['items'] if item['status'] == 'COMPLETE']
+        if len(assets) >= 2:
+            assetIdToDelete = assets[1]
+            deleteURL       = f'{BASEURL}/{assetIdToDelete}'
+            response        = requests.delete(deleteURL, headers = headers)
+            response.raise_for_status()
+            print('PASSED')
+        else:
+            print('FAILED')
+
+    except requests.exceptions.RequestException as e:
+        print('ERROR:', e)
+    except Exception as e:
+        print('ERROR:', e)
+
+if __name__ == '__main__':
+    ionop_czml()

orbx/synthetic_orbits/orbit_finder/DMT.py

@@ -0,0 +1,57 @@
+from sgp4.api import Satrec
+import numpy as np
+
+class VectorizedKeplerianOrbit:
+    def __init__(self, line1_array, line2_array=None):
+        if line2_array is not None:
+            satellites = np.vectorize(Satrec.twoline2rv)(line1_array, line2_array)
+            radius_earth_km = satellites[0].radiusearthkm
+
+            self.a = np.array([sat.a * radius_earth_km for sat in satellites])
+            self.e = np.array([sat.ecco for sat in satellites])
+            self.i = np.array([sat.inclo for sat in satellites])
+            self.omega = np.array([sat.argpo for sat in satellites])
+            self.raan = np.array([sat.nodeo for sat in satellites])
+            self.q = np.array([sat.altp * radius_earth_km for sat in satellites])
+            self.p = self.a * (1 - self.e ** 2)
+        else:
+            # Here we assume line1_array is a complete orbit [a, e, i, omega, raan, q, p]
+            arr = np.array(line1_array)
+            self.a = np.array([arr[0]])
+            self.e = np.array([arr[1]])
+            self.i = np.array([arr[2]])
+            self.omega = np.array([arr[3]])
+            self.raan = np.array([arr[4]])
+            self.q = np.array([arr[5]])
+            self.p = np.array([arr[6]])
+
+    def __getitem__(self, key):
+        return VectorizedKeplerianOrbit(
+            np.array([self.a[key], self.e[key], self.i[key], self.omega[key], self.raan[key], self.q[key], self.p[key]])
+        )
+
+    @staticmethod
+    def DistanceMetric(orbit1, orbit2):
+        w1 = orbit1.omega[:, np.newaxis]
+        w2 = orbit2.omega[np.newaxis, :]
+
+        c1 = np.cos(orbit1.i)[:, np.newaxis]
+        c2 = np.cos(orbit2.i)[np.newaxis, :]
+
+        s1 = np.sin(orbit1.i)[:, np.newaxis]
+        s2 = np.sin(orbit2.i)[np.newaxis, :]
+
+        delta = orbit1.raan[:, np.newaxis] - orbit2.raan[np.newaxis, :]
+        cosI = c1 * c2 + s1 * s2 * np.cos(delta)
+
+        cosP = s1 * s2 * np.sin(w1) * np.sin(w2) + \
+               (np.cos(w1) * np.cos(w2) + c1 * c2 * np.sin(w1) * np.sin(w2)) * np.cos(delta) + \
+               (c2 * np.cos(w1) * np.sin(w2) - c1 * np.sin(w1) * np.cos(w2)) * np.sin(delta)
+
+        q = (1 + orbit1.e[:, np.newaxis]**2) * orbit1.p[:, np.newaxis] + \
+            (1 + orbit2.e[np.newaxis, :]**2) * orbit2.p[np.newaxis, :] - \
+            2 * np.sqrt(orbit1.p[:, np.newaxis] * orbit2.p[np.newaxis, :]) * \
+            (cosI + orbit1.e[:, np.newaxis] * orbit2.e[np.newaxis, :] * cosP)
+
+        return q
+