igs-slm 0.1.5b3__py3-none-any.whl → 0.2.0b1__py3-none-any.whl

slm/signals.py

@@ -46,10 +46,9 @@ published.
 
 site_status_changed = Signal()
 """
-Sent when a site log is published, or when a section of a site log is
-published. Its possible that both the previous and new status states are
-Published. If this happens a site log was edited and published simultaneously.
-The published timestamp will have increased.
+Sent when a site log's status changes. Its possible that both the previous and
+new status states are Published. If this happens a site log was edited and
+published simultaneously. The published timestamp will have increased.
 
 :param sender: The sending object (unreliable).
 :param site: The Site object.

slm/static/slm/js/enums.js

@@ -201,12 +201,12 @@ class SiteFileUploadStatus {
 }
 class SiteLogFormat {
 	
-	static LEGACY = new SiteLogFormat(1, "LEGACY", "Legacy (ASCII)", "text/plain", "bi bi-file-text", "log", ["text", "txt", "legacy"], ["txt", "sitelog"]);
-	static GEODESY_ML = new SiteLogFormat(2, "GEODESY_ML", "GeodesyML", "application/xml", "bi bi-filetype-xml", "xml", ["xml"], ["gml"]);
-	static JSON = new SiteLogFormat(3, "JSON", "JSON", "application/json", "bi bi-filetype-json", "json", ["json", "js"], ["js"]);
-	static ASCII_9CHAR = new SiteLogFormat(4, "ASCII_9CHAR", "ASCII (9-Char)", "text/plain", "bi bi-file-text", "log", ["text", "txt", "9char"], ["txt", "sitelog"]);
+	static LEGACY = new SiteLogFormat(1, "LEGACY", "Legacy (ASCII)", "text/plain", "bi bi-file-text", "log", ["text", "txt", "legacy", "sitelog"], [], "log");
+	static GEODESY_ML = new SiteLogFormat(2, "GEODESY_ML", "GeodesyML", "application/xml", "bi bi-filetype-xml", "xml", ["xml", "gml"], [], "xml");
+	static JSON = new SiteLogFormat(3, "JSON", "JSON", "application/json", "bi bi-filetype-json", "json", ["json", "js"], [], "json");
+	static ASCII_9CHAR = new SiteLogFormat(4, "ASCII_9CHAR", "ASCII (9-Char)", "text/plain", "bi bi-file-text", "log", ["text", "txt", "9char", "sitelog"], "[(1, 'Legacy (ASCII)')]", "log");
 	
-	constructor (value, name, label, mimetype, icon, ext, alts, alt_exts) {
+	constructor (value, name, label, mimetype, icon, ext, alts, supersedes, suffix) {
 		this.value = value;
 		this.name = name;
 		this.label = label;
@@ -214,7 +214,8 @@ class SiteLogFormat {
 		this.icon = icon;
 		this.ext = ext;
 		this.alts = alts;
-		this.alt_exts = alt_exts;
+		this.supersedes = supersedes;
+		this.suffix = suffix;
 	}
 	
 	static ciCompare(a, b) {

slm/static/slm/js/form.js

@@ -167,7 +167,16 @@ class Form extends slm.Persistable {
                     data[field.name] = [value];
                 }
             } else {
-                data[field.name] = value;
+                if (Object.hasOwn(data, field.name)) {
+                    const current = data[field.name];
+                    if (Array.isArray(current)) {
+                        current.push(value);
+                    } else {
+                        data[field.name] = [current, value];
+                    }
+                } else {
+                    data[field.name] = value;
+                }
             }
         }
 
@@ -234,16 +243,20 @@ class Form extends slm.Persistable {
                         checked.prop('checked', true);
                         this.element.find(`[name="${field}"]:checkbox`).not(checked).prop('checked', false);
                         break;
-                    default:
-                        if (ipt.length > 0) {
-                            throw TypeError(`Array given for form data type: ${ipt.prop('type')}`);
+                    case 'number':
+                        if (value.length === ipt.length) {
+                            let idx = 0;
+                            for (const val of value) { $(ipt[idx++]).val(val); }
+                            break;
                         }
+                    default:
+                        throw TypeError(`Type mismatch: ${value} ${ipt.prop('type')}`);
                 }
             } else if (ipt.length > 1) {
                 const types = [];
                 ipt.each(function () { types.push($(this).prop('type')); });
                 const values = this.decompose(types, value);
-                ipt.map((e, i) => { setField(e, values[i]); });
+                ipt.each((i, e) => setField($(e), values[i]));
             } else { setField(ipt, value); }
         }.bind(this));
 
@@ -302,22 +315,20 @@ class Form extends slm.Persistable {
     }
 
     decompose(types, value) {
-        switch (types) {
-            case ['date', 'time']:
+        const typeList = Array.isArray(types) ? types : Array.from(types);
+        if (typeList.length === 2 && typeList[0] === 'date' && typeList[1] === 'time') {
                 if (value) { return value.split('T'); }
                 return ['', ''];
-            default:
-                throw TypeError(`Unexpected decomposition types: ${types}`);
         }
+        throw TypeError(`Unexpected decomposition types: ${types}`);
     }
 
     compose(types, inputs) {
-        switch (types) {
-            case ['date', 'time']:
-                return `${inputs.get(0).value}T${inputs.get(1).value || "00:00"}Z`
-            default:
-                throw TypeError(`Unexpected composition types: ${types}`);
+        const typeList = Array.isArray(types) ? types : Array.from(types);
+        if (typeList.length === 2 && typeList[0] === 'date' && typeList[1] === 'time') {
+            return `${inputs[0]}T${inputs[1] || "00:00"}Z`                
         }
+        throw TypeError(`Unexpected composition types: ${[...typeList].join(', ')}`);
     }
 
     clear() {

slm/static/slm/js/slm.js

@@ -130,10 +130,12 @@ slm.handlePostSuccess = function(form, response, status, jqXHR) {
             'button.accordion-button'
         ).removeClass('slm-section-deleted');
         form.find('.alert.slm-form-deleted').hide();
-        form.find('.form-control:visible').removeAttr('disabled');
-        form.find('input.form-check-input:visible').removeAttr('disabled', '');
         form.find('.slm-flag').show();
         form.find('div[contenteditable]').attr('contenteditable', true);
+        
+        // TODO Form class setters/getters still not completely working for all forms
+        // const filterForm = new slm.Form(form);
+        // filterForm.data = data;
     }
 
     if (data.hasOwnProperty('_diff') && Object.keys(data._diff).length) {

slm/templatetags/slm.py

@@ -111,7 +111,7 @@ def iso_utc_full(datetime_field):
 @register.filter(name="multi_line")
 def multi_line(text):
     if text:
-        limit = 47
+        limit = 48
         lines = [line.rstrip() for line in text.split("\n")]
         limited = []
         for line in lines:

slm/utils.py

@@ -1,7 +1,8 @@
 import json
 import re
+import typing as t
 from datetime import date, datetime, timedelta
-from math import atan2, cos, sin, sqrt
+from math import atan2, copysign, cos, floor, sin, sqrt
 
 from dateutil import parser as date_parser
 from django.conf import settings
@@ -39,43 +40,121 @@ def get_record_model():
         ) from ve
 
 
-def dddmmssss_to_decimal(dddmmssss):
-    if dddmmssss is not None:
-        if isinstance(dddmmssss, str):
-            dddmmssss = float(dddmmssss)
-        dddmmssss /= 10000
-        degrees = int(dddmmssss)
-        minutes = (dddmmssss - degrees) * 100
-        seconds = float((minutes - int(minutes)) * 100)
-        return degrees + int(minutes) / 60 + seconds / 3600
-    return None
-
-
-def decimal_to_dddmmssss(dec):
-    if dec is not None:
-        if isinstance(dec, str):
-            dec = float(dec)
-        degrees = int(dec)
-        minutes = (dec - degrees) * 60
-        seconds = float(minutes - int(minutes)) * 60
-        return degrees * 10000 + int(minutes) * 100 + seconds
-    return None
+def dddmmssss_to_decimal(
+    dddmmssss: t.Optional[t.Union[float, str, int]], sec_digits: int = 6
+) -> t.Optional[float]:
+    """
+    Convert DDDMMSS.ss composite to decimal degrees.
+    Preserves -0.0 and normalizes 60s/60m carries.
 
+    :param dddmmssss: latitude or longitude in DDDMMSS.SS format
+    :return: the coordinate in decimal degrees
+    """
+    if dddmmssss is None:
+        return None
+    if isinstance(dddmmssss, str):
+        dddmmssss = float(dddmmssss)
+
+    sgn = copysign(1.0, dddmmssss)
+    v = abs(dddmmssss)
+
+    # Extract D, M, S from DDDMMSS.ss
+    degrees = int(v // 10000)
+    remainder = v - degrees * 10000
+    minutes = int(remainder // 100)
+    seconds = remainder - minutes * 100
+
+    # Clean up float noise and normalize carries
+    seconds = round(seconds, sec_digits)
+    if seconds >= 60.0:
+        seconds = 0.0
+        minutes += 1
+    if minutes >= 60:
+        minutes = 0
+        degrees += 1
+
+    dec = degrees + minutes / 60.0 + seconds / 3600.0
+    return copysign(dec, sgn)
+
+
+def decimal_to_dddmmssss(
+    dec: t.Optional[t.Union[str, float]], sec_digits: int = 2
+) -> t.Optional[float]:
+    """
+    Convert decimal degrees to DDDMMSS.SS... as a float.
+    Preserves the sign of -0.0 and normalizes carry (sec/min -> min/deg).
 
-def dddmmss_ss_parts(dec):
+    :param: dec: string or float of decimal degrees of either latitude or longitude
+    :return: floating point lat or lon in DDDMMSS.SS format
+    """
+    if dec is None:
+        return None
+    if isinstance(dec, str):
+        dec = float(dec)
+
+    # Work with absolute value; keep original sign with copysign at the end
+    a = abs(dec)
+
+    degrees = int(a)
+    minutes_full = (a - degrees) * 60.0
+    minutes = int(minutes_full)
+    seconds = (minutes_full - minutes) * 60.0
+
+    # Round seconds, then normalize carries (60s -> +1m, 60m -> +1d)
+    seconds = round(seconds, sec_digits)
+    if seconds >= 60.0:
+        seconds = 0.0
+        minutes += 1
+    if minutes >= 60:
+        minutes = 0
+        degrees += 1
+
+    # Compose as DDDMMSS.ss (minutes and seconds are non-negative)
+    composite = degrees * 10000 + minutes * 100 + seconds
+    return copysign(composite, dec)
+
+
+def dddmmss_ss_parts(
+    dec: t.Optional[t.Union[str, float, int]], sec_digits: int = 2
+) -> t.Tuple[t.Optional[float], t.Optional[int], t.Optional[float]]:
     """
     Return (degrees, minutes, seconds) from decimal degrees
     :param dec: Decimal degrees lat or lon
-    :return:
+    :return: a 3-tuple of degrees, minutes seconds components. The degrees component will be a
+      whole number, but is a float so that it may contain the sign.
     """
-    if dec is not None:
-        if isinstance(dec, str):
-            dec = float(dec)
-        degrees = int(dec)
-        minutes = (dec - degrees) * 60
-        seconds = float(minutes - int(minutes)) * 60
-        return degrees, abs(int(minutes)), abs(seconds)
-    return None, None, None
+    if dec is None:
+        return None, None, None
+    if isinstance(dec, str):
+        dec = float(dec)
+
+    sign = int(copysign(1, dec))
+    v = abs(dec)
+
+    degrees = floor(v)
+    minutes_full = (v - degrees) * 60
+    minutes = floor(minutes_full)
+    seconds = (minutes_full - minutes) * 60
+
+    seconds = round(seconds, sec_digits)
+
+    # Handle rounding overflow (e.g. 59.9999 → 60.0)
+    if seconds >= 60.0:
+        seconds = 0.0
+        minutes += 1
+    if minutes >= 60:
+        minutes = 0
+        degrees += 1
+
+    return (sign * float(degrees), minutes, seconds)
+
+
+def lon_180_to_360(lon):
+    return lon % 360.0
+
+
+def lon_360_to_180(lon):
+    return ((lon + 180) % 360) - 180
 
 
 def set_protocol(request):
@@ -249,11 +328,20 @@ def get_exif_tags(file_path):
     return {}
 
 
-def xyz2llh(xyz):
-    a_e = 6378.1366e3  # meters
-    f_e = 1 / 298.25642  # IERS2000 standards
+def xyz2llh(*xyz, geodetic=True) -> t.Tuple[float, float, float]:
+    """
+    Convert ECEF to LLH using ITRF2020 Ellipsoid.
+
+    :param xyz: A 3-tuple or 3 xyz parameters, e.g. xyz2llh(x,y,z) or xyz2llh((x,y,z))
+    :return: A 3-tuple of latitude, longitude, height. Longitude is geodetic (+/-180) by default and height is in meters.
+    """
+    a_e = 6378.137e3  # meters
+    f_e = 1 / 298.257222101  # ITRF2020 flattening
     radians2degree = 45 / atan2(1, 1)
 
+    # allow xyz2llh(x,y,z) or xyz2llh((x,y,z))
+    xyz = xyz[0] if len(xyz) == 1 else xyz
+
     xyz_array = [v / a_e for v in xyz]
     (x, y, z) = (xyz_array[0], xyz_array[1], xyz_array[2])
     e2 = f_e * (2 - f_e)
@@ -271,7 +359,44 @@ def xyz2llh(xyz):
         lon = lon + 360
     h = a_e * (p * cos(phi) + z * sin(phi) - sqrt(1 - e2 * (sin(phi)) ** 2))
 
-    return lat, lon, h
+    return lat, lon_360_to_180(lon) if geodetic else lon, h
+
+
+def llh2xyz(*llh) -> t.Tuple[float, float, float]:
+    """
+    Convert LLH (latitude, longitude, height) to ECEF (X, Y, Z)
+    using ITRF2020 Ellipsoid.
+
+    :param llh: A 3-tuple or 3 separate parameters, e.g. llh2xyz(lat, lon, h) or llh2xyz((lat, lon, h))
+    :returns: (x, y, z) in meters
+    """
+    a_e = 6378.137e3  # semi-major axis in meters
+    f_e = 1 / 298.257222101  # flattening (ITRF2020)
+    radians_per_degree = atan2(1, 1) / 45  # inverse of your radians2degree
+
+    # allow llh2xyz(lat, lon, h) or llh2xyz((lat, lon, h))
+    llh = llh[0] if len(llh) == 1 else llh
+    lat, lon, h = llh
+
+    # convert to radians
+    phi = lat * radians_per_degree
+    lam = lon * radians_per_degree
+
+    e2 = f_e * (2 - f_e)
+    sin_phi = sin(phi)
+    cos_phi = cos(phi)
+    sin_lam = sin(lam)
+    cos_lam = cos(lam)
+
+    # prime vertical radius of curvature
+    N = a_e / sqrt(1 - e2 * sin_phi**2)
+
+    # ECEF coordinates
+    x = (N + h) * cos_phi * cos_lam
+    y = (N + h) * cos_phi * sin_lam
+    z = ((1 - e2) * N + h) * sin_phi
+
+    return x, y, z
 
 
 def convert_9to4(text: str, name: str) -> str:

slm/validators.py

@@ -295,3 +295,54 @@ class TimeRangeValidator(SLMValidator):
                         instance,
                         field,
                     )
+
+
+class PositionsMatchValidator(SLMValidator):
+    """
+    Attach this validator to SiteLocation llh and/or xyz fields to validate that these
+    positions are within the given tolerance of each other.
+    """
+
+    tolerance = 1.0
+    """
+    3D tolerance in meters between the positions before flagging.
+    """
+
+    def __init__(
+        self,
+        *args,
+        severity=FlagSeverity.BLOCK_SAVE,
+        tolerance: float = tolerance,
+        **kwargs,
+    ):
+        self.tolerance = tolerance
+        super().__init__(*args, severity=severity, **kwargs)
+
+    def __call__(self, instance, field, value):
+        from math import sqrt
+
+        from slm.utils import llh2xyz
+
+        fieldname = field.name
+        xyz1 = value if fieldname == "xyz" else llh2xyz(value)
+        other = "xyz" if fieldname == "llh" else "llh"
+        otherfield = instance._meta.get_field(other)
+        if xyz1:
+            xyz2 = (
+                llh2xyz(getattr(instance, other))
+                if other == "llh"
+                else getattr(instance, other)
+            )
+            if xyz2:
+                diff = sqrt(
+                    (xyz1[0] - xyz2[0]) ** 2
+                    + (xyz1[1] - xyz2[1]) ** 2
+                    + (xyz1[2] - xyz2[2]) ** 2
+                )
+                if diff > self.tolerance:
+                    print(instance.site.name, diff)
+                    self.throw_error(
+                        f"{diff:.2f} meters away from {otherfield.verbose_name}",
+                        instance,
+                        field,
+                    )