Merge pull request #3 from MHenderson1988/alpha2

Alpha2

README.md

@@ -2,10 +2,11 @@ Project status - Current work in progress at Alpha stage.
 
 # AIXMGeo
 
-AIXMGeo is an AIXM wrapper for [KMLPlus](https://github.com/MHenderson1988/kmlplus) which supports the creation of a curved and 'floating' objects in KML.
+AIXMGeo is an AIXM wrapper for [KMLPlus](https://github.com/MHenderson1988/kmlplus) which supports the creation of a
+curved and 'floating' objects in KML.
 
-AIXMGeo parses a valid, well-formed, AIXM file and outputs geographic information to a .KML
-file. The .KML file can be opened in Google Earth or other mapping software.
+AIXMGeo parses a valid, well-formed, AIXM file and outputs geographic information to a .KML file. The .KML file can be
+opened in Google Earth or other mapping software.
 
 AIXMGeo is currently only tested with AIXM 5.1 however it should also work with AIXM 5.1.1.
 

aixm_geo/aixm_geo.py

@@ -45,13 +45,7 @@ def draw_airspace(self, aixm_feature_dict, kml_obj):
                            lower_layer_uom=aixm_feature_dict['lower_layer_uom'],
                            upper_layer_uom=aixm_feature_dict['upper_layer_uom'],
                            uom=aixm_feature_dict['lower_layer_uom'], fol=aixm_feature_dict['name'],
-                           altitude_mode=self.altitude_mode(aixm_feature_dict))
-
-    def altitude_mode(self, aixm_dict):
-        altitude_mode = 'absolute'
-        if aixm_dict['upper_layer_reference'] == 'SFC':
-            altitude_mode = 'relativetoground'
-        return altitude_mode
+                           altitude_mode=util.altitude_mode(aixm_feature_dict))
 
     def draw_cylinder(self, aixm_feature_dict, kml_obj):
         aixm_feature_dict = util.convert_elevation(aixm_feature_dict)
@@ -68,4 +62,10 @@ def draw_cylinder(self, aixm_feature_dict, kml_obj):
                          upper_layer=float(upper_layer), uom=uom,
                          fol=aixm_feature_dict['name'], lower_layer_uom=aixm_feature_dict['lower_layer_uom'],
                          upper_layer_uom=aixm_feature_dict['upper_layer_uom'],
-                         altitude_mode=self.altitude_mode(aixm_feature_dict))
+                         altitude_mode=util.altitude_mode(aixm_feature_dict))
+
+
+if __name__ == '__main__':
+    file_loc = Path().absolute().joinpath('..', Path('test_data/donlon.xml'))
+    output = Path().absolute()
+    AixmGeo(file_loc, output, 'test_kml.kml').build_kml()

aixm_geo/base.py

@@ -41,28 +41,6 @@ def get_first_value(self, xpath: str, **kwargs: etree.Element) -> str:
             value = "Unknown"
         return value
 
-    # XPath with namespace example = self.root.xpath('//aixm:name', namespaces=self.namespace)
-    # Uses findall as opposed to find
-    def get_all_values(self, xpath: str, **kwargs: etree.Element):
-        """Returns a list of all values within the subtree which match the Xpath provided
-        Args:
-            xpath (str): Valid Xpath string for the tag to try and find.
-            **kwargs:
-                subtree(etree.Element): The subtree to search.  Defaults to self.root if no value provided.
-        Returns:
-            values(list): List of string values found.
-        """
-        subtree = kwargs.pop('subtree', self._root)
-        try:
-            values = subtree.findall(xpath, namespaces=NAMESPACES)
-            if values is None:
-                raise AttributeError
-            else:
-                values = [x.text for x in values]
-        except AttributeError:
-            values = "Unknown"
-        return values
-
     def get_first_value_attribute(self, xpath: str, **kwargs: Union[etree.Element, str]) -> Union[str, dict]:
         """
         Args:
@@ -104,13 +82,14 @@ def get_elevation(self):
 
     def get_crs(self):
         """
+        Parses the CRS from the AirspaceGeometryComponent parent tag and returns the CRS as a string.
         Args:
             self
         Returns:
             crs(str): A string of 'Anticlockwise' or 'Clockwise' depending upon the CRS
             applied and the start and end angles
         """
-        crs = self._timeslice[-1].xpath(".//aixm:AirspaceGeometryComponent//*[@srsName]", namespaces=NAMESPACES)[0]
+        crs = self._timeslice[-1].xpath(".//*[@srsName]", namespaces=NAMESPACES)[0]
 
         split = crs.get("srsName").split(':')[-1]
         if split == '4326':
@@ -138,6 +117,15 @@ def __init__(self, root):
         super().__init__(root)
 
     def get_coordinate_list(self, subroot):
+        """
+        Parses the LXML etree._Element object and returns a list of coordinate strings.
+        Args:
+            subroot: LXML etree._Element object
+
+        Returns:
+            unpacked_gml(list[str]): A list of coordinate strings
+
+        """
         unpacked_gml = None
         for location in subroot:
             try:
@@ -188,9 +176,9 @@ def unpack_geodesic_string(self, location):
     def unpack_pos_list(self, string_to_manipulate):
         split = string_to_manipulate.split(' ')
         if len(split) > 1:
-            for i in range(len(split)-1):
+            for i in range(len(split) - 1):
                 if i < len(split) and i % 2 == 0:
-                    new_string = f'{split[i]} {split[i+1]}'
+                    new_string = f'{split[i]} {split[i + 1]}'
                     yield new_string
         else:
             yield string_to_manipulate
@@ -203,7 +191,7 @@ def unpack_arc(self, location: etree.Element) -> str:
         Returns:
             coordinate_string(str): A coordinate string
         """
-        centre = self.get_centre(location).strip()
+        centre = self.get_arc_centre_point(location).strip()
         start_angle = self.get_first_value('.//gml:startAngle', subtree=location)
         end_angle = self.get_first_value('.//gml:endAngle', subtree=location)
         # Pyproj uses metres, we will have to convert for distance
@@ -227,7 +215,16 @@ def unpack_arc(self, location: etree.Element) -> str:
 
         return coordinate_string
 
-    def get_centre(self, location):
+    def get_arc_centre_point(self, location):
+        centre = self.get_first_value('.//gml:pos', subtree=location)
+
+        # If none, check for gml:posList instead
+        if centre == 'Unknown':
+            centre = self.get_first_value('.//gml:posList', subtree=location)
+
+        return centre
+
+    def get_circle_centre_point(self, location):
         centre = self.get_first_value('.//gml:pos', subtree=location)
 
         # If none, check for gml:posList instead
@@ -282,7 +279,7 @@ def unpack_circle(self, location: etree.Element) -> str:
             Returns:
                 coordinate_string(str): A coordinate string
         """
-        centre = self.get_centre(location)
+        centre = self.get_circle_centre_point(location)
         radius = self.get_first_value('.//gml:radius', subtree=location)
         radius_uom = self.get_first_value_attribute('.//gml:radius', subtree=location, attribute_string='uom')
 

aixm_geo/factory.py

@@ -39,6 +39,11 @@ def errors(self, value):
         self._errors.append(value)
 
     def get_feature_details(self):
+        """
+        Iterates through the root of the AIXM file and returns a generator of AIXMFeature objects
+        Returns:
+
+        """
         aixm_features = self._root.iterfind('.//message:hasMember', NAMESPACES)
         for feature in aixm_features:
             aixm_feature = self.produce(feature)
@@ -48,6 +53,14 @@ def get_feature_details(self):
                 pass
 
     def produce(self, subroot):
+        """
+        Produces an individual AIXMFeature object from the subroot
+        Args:
+            subroot:
+
+        Returns:
+
+        """
         feature_type = util.get_feature_type(subroot)
         try:
             aixm_feature = self._feature_classes[feature_type](subroot)

aixm_geo/util.py

@@ -62,11 +62,18 @@ def convert_elevation(aixm_feature_dict):
 
     if aixm_feature_dict['upper_layer'] == 'UNL':
         aixm_feature_dict['upper_layer_uom'] = 'M'
-        aixm_feature_dict['upper_layer'] = 18288.00 # 60,000 ft in metres
+        aixm_feature_dict['upper_layer'] = 18288.00  # 60,000 ft in metres
 
     return aixm_feature_dict
 
 
+def altitude_mode(aixm_dict):
+    altitude_mode = 'absolute'
+    if aixm_dict['upper_layer_reference'] == 'SFC':
+        altitude_mode = 'relativetoground'
+    return altitude_mode
+
+
 def switch_radius_uom(radius_uom):
     if radius_uom == '[nmi_i]':
         radius_uom = 'NM'

setup.py

@@ -19,4 +19,4 @@
         "Operating System :: OS Independent",
     ],
     python_requires='>=3.8',
-)
+)

tests/test_base.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 from unittest import TestCase
+
 from aixm_geo.base import MultiPointAixm, SinglePointAixm
 from aixm_geo.factory import AixmFeatureFactory
 from aixm_geo.settings import NAMESPACES
@@ -8,12 +9,13 @@
 class TestSinglePointAixm(TestCase):
     def setUp(self) -> None:
         file_loc = Path().absolute().joinpath('..', Path('test_data/donlon.xml'))
-        features = AixmFeatureFactory(file_loc).root.findall('.//message:hasMember', NAMESPACES)
-        self.ah = SinglePointAixm(features[0])
+        ah_feature = AixmFeatureFactory(file_loc).root.xpath("/message:AIXMBasicMessage/message:hasMember/aixm"
+                                                             ":AirportHeliport", namespaces=NAMESPACES)
+        self.ah = SinglePointAixm(ah_feature[0])
 
     def test_get_first_value(self):
         name = self.ah.get_first_value('.//aixm:name')
-        self.assertEqual('REPUBLIC OF DONLON', name)
+        self.assertEqual('DONLON/DOWNTOWN HELIPORT', name)
         self.assertNotEqual('RANDOM AIRPORT NAME', name)
         self.assertTrue(isinstance(name, str))
 
@@ -26,9 +28,16 @@ def test_get_first_value_attribute(self):
         self.assertTrue(isinstance(attribute, dict))
         self.assertEqual('unknown', attribute['indeterminatePosition'])
 
+    def test_get_elevation(self):
+        elevation = self.ah.get_elevation()
+        self.assertEqual(elevation, (0.0, 'FT'))
+        self.assertNotEqual(elevation, (0.0, 'M'))
+        self.assertTrue(isinstance(elevation, tuple))
+
 
 class TestMultiPointAixm(TestCase):
     def setUp(self) -> None:
         file_loc = Path().absolute().joinpath('..', Path('test_data/donlon.xml'))
-        features = AixmFeatureFactory(file_loc).root.findall('.//message:hasMember', NAMESPACES)
-        self.airspace = MultiPointAixm(features[0])
+        airspace_feature = AixmFeatureFactory(file_loc).root.xpath("/message:AIXMBasicMessage/message:hasMember/"
+                                                                   "aixm:Airspace", namespaces=NAMESPACES)
+        self.airspace = MultiPointAixm(airspace_feature[0])